我在我的项目中使用JPA。
我遇到一个查询，我需要对五个表进行连接操作。因此，我创建了一个返回五个字段的本机查询。
现在我想将结果对象转换为java POJO类，其中包含相同的五个字符串。
在JPA中有任何方法可以直接将结果转换为POJO对象列表吗??
我想出了如下的解决办法。
@NamedNativeQueries({
@NamedNativeQuery(
name = "nativeSQL",
query = "SELECT * FROM Actors",
resultClass = db.Actor.class),
@NamedNativeQuery(
name = "nativeSQL2",
query = "SELECT COUNT(*) FROM Actors",
resultClass = XXXXX) // <--------------- problem
})
现在在resultClass中，我们需要提供一个实际的JPA实体类吗?
或
我们可以将其转换为包含相同列名的任何JAVA POJO类?
如果您使用Spring-jpa，这是对答案和这个问题的补充。如有任何瑕疵，请改正。根据我的实际需求，我主要使用了三种方法来实现“map result Object[] to a pojo”:
JPA内置方法就足够了。
JPA内置的方法是不够的，但一个自定义的sql与它的实体是足够的。
前2失败，我必须使用一个nativeQuery。
下面是一些例子。
pojo期待着:
公共类
private String;
private Integer successRate;
// getter和setter
public Antistealingdto(String secretKey, Integer successRate) {
这一点。secretKey = secretKey;
这一点。successRate =成功率;
｝
｝
方法1:将pojo更改为接口:
public interface Antistealingdto {
String getSecretKey();
Integer getSuccessRate();
}
和存储库:
interface AntiStealingRepository extends CrudRepository<Antistealing, Long> {
Antistealingdto findById(Long id);
}
方法2:
存储库:
@Query("select new AntistealingDTO(secretKey, successRate) from Antistealing where ....")
Antistealing whatevernamehere(conditions);
注意:POJO构造函数的参数顺序在POJO定义和sql中必须相同。
方法3:
在Edwin Dalorzo的回答中，以实体中的@SqlResultSetMapping和@NamedNativeQuery为例。
前两个方法将调用许多中间处理程序，如自定义转换器。例如，AntiStealing定义了一个secretKey，在它被持久化之前，会插入一个转换器来加密它。这将导致前2个方法返回一个转换后的返回secretKey，这不是我想要的。而方法3将克服转换器，返回的secretKey将与存储时相同(加密的)。
是的，使用JPA 2.1很容易。你有非常有用的注解。他们简化了你的生活。
首先声明本机查询，然后声明结果集映射(它定义了数据库返回的数据到pojo的映射)。编写要引用的POJO类(为了简洁，这里没有包括)。最后但同样重要的是:在DAO中创建一个方法(例如)来调用查询。这在dropwizard(1.0.0)应用中很管用。
首先在实体类中声明一个本机查询:
@NamedNativeQuery (
name = "domain.io.MyClass.myQuery",
query = "Select a.colA, a.colB from Table a",
resultSetMapping = "mappinMyNativeQuery") // must be the same name as in the SqlResultSetMapping declaration
下面你可以添加resultset映射声明:
@SqlResultSetMapping(
name = "mapppinNativeQuery", // same as resultSetMapping above in NativeQuery
classes = {
@ConstructorResult(
targetClass = domain.io.MyMapping.class,
columns = {
@ColumnResult( name = "colA", type = Long.class),
@ColumnResult( name = "colB", type = String.class)
}
)
}
)
稍后在DAO中，您可以将查询引用为
public List<domain.io.MyMapping> findAll() {
return (namedQuery("domain.io.MyClass.myQuery").list());
}
就是这样。
使用DTO设计模式。它在EJB 2.0中使用。实体由容器管理。采用DTO设计模式来解决这一问题。
但是，当应用程序分别开发服务器端和客户端时，现在可能会使用它。DTO用于服务器端不想将带有注释的实体传递/返回给客户端。
DTO示例:
PersonEntity.java
@Entity
public class PersonEntity {
@Id
private String id;
private String address;
public PersonEntity(){
}
public PersonEntity(String id, String address) {
this.id = id;
this.address = address;
}
//getter and setter
}
PersonDTO.java
public class PersonDTO {
private String id;
private String address;
public PersonDTO() {
}
public PersonDTO(String id, String address) {
this.id = id;
this.address = address;
}
//getter and setter
}
DTOBuilder.java
public class DTOBuilder() {
public static PersonDTO buildPersonDTO(PersonEntity person) {
return new PersonDTO(person.getId(). person.getAddress());
}
}
java <——可能需要
public class EntityBuilder() {
public static PersonEntity buildPersonEntity(PersonDTO person) {
return new PersonEntity(person.getId(). person.getAddress());
}
}
参见下面的示例，使用POJO作为伪实体从本机查询检索结果，而不使用复杂的SqlResultSetMapping。只需要两个注释，一个裸露的@Enity和一个假的@Id在你的POJO。@Id可以用于您选择的任何字段，@Id字段可以有重复的键，但不能为空值。
因为@Enity不映射到任何物理表，所以这个POJO被称为伪实体。
环境:eclipselink 2.5.0-RC1, jpa-2.1.0, mysql-connector-java-5.1.14
您可以在这里下载完整的maven项目
本机查询是基于mysql的样本雇员数据库
http://dev.mysql.com/doc/employee/en/employees-installation.html
persistence . xml
<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.1"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
<persistence-unit name="jpa-mysql" transaction-type="RESOURCE_LOCAL">
<class>org.moonwave.jpa.model.pojo.Employee</class>
<properties>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/employees" />
<property name="javax.persistence.jdbc.user" value="user" />
<property name="javax.persistence.jdbc.password" value="***" />
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
</properties>
</persistence-unit>
Employee.java
package org.moonwave.jpa.model.pojo;
@Entity
public class Employee {
@Id
protected Long empNo;
protected String firstName;
protected String lastName;
protected String title;
public Long getEmpNo() {
return empNo;
}
public void setEmpNo(Long empNo) {
this.empNo = empNo;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("empNo: ").append(empNo);
sb.append(", firstName: ").append(firstName);
sb.append(", lastName: ").append(lastName);
sb.append(", title: ").append(title);
return sb.toString();
}
}
EmployeeNativeQuery.java
public class EmployeeNativeQuery {
private EntityManager em;
private EntityManagerFactory emf;
public void setUp() throws Exception {
emf=Persistence.createEntityManagerFactory("jpa-mysql");
em=emf.createEntityManager();
}
public void tearDown()throws Exception {
em.close();
emf.close();
}
@SuppressWarnings("unchecked")
public void query() {
Query query = em.createNativeQuery("select e.emp_no as empNo, e.first_name as firstName, e.last_name as lastName," +
"t.title from employees e join titles t on e.emp_no = t.emp_no", Employee.class);
query.setMaxResults(30);
List<Employee> list = (List<Employee>) query.getResultList();
int i = 0;
for (Object emp : list) {
System.out.println(++i + ": " + emp.toString());
}
}
public static void main( String[] args ) {
EmployeeNativeQuery test = new EmployeeNativeQuery();
try {
test.setUp();
test.query();
test.tearDown();
} catch (Exception e) {
System.out.println(e);
}
}
}
