问题
I have an old table that I'm working with, which looks like this:
+------------------+--------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------------+--------------+------+-----+---------+-------+
| BINARY_DATA_ID | varchar(255) | NO | PRI | | |
| BINARY_DATA | longblob | YES | | NULL | |
| BINARY_DATA_NAME | varchar(255) | YES | | NULL | |
+------------------+--------------+------+-----+---------+-------+
The main problem with this is that the BinaryData Java class loads the BINARY_DATA column, even if I only require the BINARY_DATA_NAME. I know that the best way to architect this is to split the data from the meta-data (like the file name) so they live in separate tables. From there it's trivial to make the data lazy-loaded. This is how it should have been done in the first place.
Unfortunately it may not be possible for me to do the above due to organizational constraints. As a workaround, is it possible to make that column lazy-loaded using some annotations instead of splitting things out into separate tables? I've modified the BinaryData class so that it has an inner static BinaryDataData class which is @Embedded and the attribute is @Basic(fetch=FetchType.LAZY):
@Entity
@Table
@Proxy(lazy=false)
@Inheritance(strategy=InheritanceType.JOINED)
public class BinaryData implements Serializable, Persistable<BinaryData>, Cloneable {
private static final long serialVersionUID = /** blah */;
@Id @Column @GeneratedValue(generator="uuid") @GenericGenerator(name="uuid", strategy="uuid")
private String id;
@Column
private String binaryDataName;
@Embedded
@Basic(fetch = FetchType.LAZY)
private BinaryDataData binaryData;
@Transient
private String cacheId;
/**
* Hibernate constructor
*/
public BinaryData() { /* Creates a new instance of Attachment. */}
public BinaryData(byte[] binaryData, String binaryDataName) {
this.binaryData = new BinaryDataData(ArrayUtils.clone(binaryData));
this.binaryDataName = binaryDataName;
}
/**
* Returns the BinaryData byte stream.
*
* @return binaryData byte stream
*/
@Embedded
@Basic(fetch = FetchType.LAZY)
public byte[] getBinaryData() {
if (this.binaryData == null) {
return new byte[0];
}
return binaryData.getActualData();
}
@Embeddable
public static class BinaryDataData implements Serializable {
@Column(length=32*1024*1024, columnDefinition="longblob", name="BINARY_DATA") @Lob
private byte[] actualData;
public BinaryDataData() { }
public BinaryDataData(byte[] data) {
this.actualData = data;
}
public byte[] getActualData() {
if (this.actualData == null) {
return new byte[0];
}
return this.actualData;
}
public void setBinaryData(byte[] newData) {
this.actualData = newData;
}
@Override public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (!(obj instanceof BinaryDataData)) {
return false;
}
final BinaryDataData other = (BinaryDataData) obj;
if (!Arrays.equals(actualData, other.actualData)) {
return false;
}
return true;
}
}
/** onwards... */
Unfortunately this doesn't work. The SQL that I'm seeing still shows a complete fetch of the object even if the binary data isn't requested:
select ideaattach0_.BINARY_DATA_ID as BINARY1_9_, ideaattach0_1_.BINARY_DATA as BINARY2_9_, ideaattach0_1_.BINARY_DATA_NAME as BINARY3_9_, ideaattach0_.IDEA_BUCKET_ID as IDEA2_136_ from IDEA_ATTACHMENT ideaattach0_ inner join BINARY_DATA ideaattach0_1_ on ideaattach0_.BINARY_DATA_ID=ideaattach0_1_.BINARY_DATA_ID where ideaattach0_.BINARY_DATA_ID=?
Any ideas? Thank you.
回答1:
From Hibernate, Chapter 19. Improving performance:
Lazy attribute fetching: an attribute or single valued association is fetched when the instance variable is accessed. This approach requires buildtime bytecode instrumentation and is rarely necessary.
回答2:
For maven project it's needed to add following plugin dependency into pom.xml:
<plugin>
<groupId>org.hibernate.orm.tooling</groupId>
<artifactId>hibernate-enhance-maven-plugin</artifactId>
<version>${hibernate.version}</version>
<executions>
<execution>
<configuration>
<failOnError>true</failOnError>
<enableLazyInitialization>true</enableLazyInitialization>
</configuration>
<goals>
<goal>enhance</goal>
</goals>
</execution>
</executions>
</plugin>
I have checked it in my project and it works, example of entity:
@Entity(name = "processing_record")
public class ProcessingRecord {
/**
* Why uuid: https://www.clever-cloud.com/blog/engineering/2015/05/20/why-auto-increment-is-a-terrible-idea/
*/
@Id
@Column(name = "record_id")
@org.hibernate.annotations.Type(type = "pg-uuid")
private UUID id;
...
/**
* Processing result.
*/
@Column(name = "result")
@Basic(fetch = FetchType.LAZY)
private String result;
...
For more details take a look on following article: LINK
回答3:
I am aware of the date of this inquiry, however, I would have also attempted to use a projection value class that maps as subset of the columns, and use that projection with a specified named query which instantiates that projection value object, instead of the base object being referenced here.
I am working on a solution which uses this method so I do not currently have a full example. However, the basic idea is that you will create a JPA query which uses the "select NEW Projection_Object_Target" syntax, where the fields are directly referenced within the constructor of "Projection_Object_Target".
I.E. Use a constructor expression as follows:
SELECT NEW fully.qualified.package.name.ProjectionObject(baseObject.column_target_0,baseObject.column_target_1,...,baseObject.column_target_n) FROM BaseObjectMappedInDBTable AS baseObject
Generic example use-case:
String queryStr =
"SELECT NEW fully.qualified.package.name.ProjectionObject(baseObject.column_target_0) " +
"FROM BaseObjectMappedInTable AS baseObject";
TypedQuery<ProjectionObject> query =
em.createQuery(queryStr, ProjectionObject.class);
List<ProjectionObject> results = query.getResultList();
来源：https://stackoverflow.com/questions/11526255/lazy-fetching-single-column-class-attribute-with-hibernate