序列化 LazyLoaded Hibernate 表导致异常
Serializing LazyLoaded Hibernate Tables Causes Exceptions
我有一个相当标准的用例，它给我带来了非标准问题。
我在服务器上有一个 Java 网络应用 运行（使用 Jersey 和 Hibernate）。它有一个 AJAX api 从浏览器中调用 Java 脚本。
此服务公开给 ajax：
import list.nice.bll.UserBLL;
import list.nice.dal.dto.Token;
import list.nice.dal.dto.User;
import org.glassfish.jersey.media.multipart.FormDataBodyPart;
import org.glassfish.jersey.media.multipart.FormDataMultiPart;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.*;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
import java.net.URISyntaxException;
import java.security.GeneralSecurityException;
@Path("/users")
public class UserInfoService {
@POST
@Path("/getUser")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response getUserFromLogin(JAXBElement<User> user){
User rUser = user.getValue();
rUser = UserInfoService.getActiveUser(rUser.getUserID());
return Response.status(Response.Status.OK).header("Access-Control-Allow-Origin", "*").entity(UserInfoService.getActiveUser(rUser.getUserID())).build();
}
}
我有一个用户 class 对应于一个用户 table。每个用户都有朋友，但我不需要我加载的每个用户的朋友（不需要一次获取整个对象图）。
User.java 看起来像这样：
@Entity
@Table(name="users")
public class User {
@Id
@GeneratedValue(generator = "increment")
@GenericGenerator(name="increment", strategy = "increment")
private int userID;
private String name;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
public User(){}
public User(int userID, String name) {
this.userID = userID;
this.name = name;
}
public int getUserID() {
return userID;
}
public void setUserID(int userID) {
this.userID = userID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<User> getFriends() {
return friends;
}
public void setFriends(Set<User> friends) {
this.friends = friends;
}
当我检索活跃用户时，我想立即检索他们的所有朋友，但不是朋友的朋友（以及更多朋友）。所以我的 getActiveUser() 函数看起来像这样：
protected static User getActiveUser(int userID) {
EntityManager entityManager = HibernateUtil.getEntityManagerFactory().createEntityManager();
User user = (User) entityManager.createQuery("from User where userID = :userID").setParameter("userID", userID).getSingleResult();
user.getFriends();
//I have also tried Hibernate.initialize(user.getFriends())
entityManager.close();
return user;
}
对该函数的 Ajax 调用最终得到一个 500 内部服务器错误，但服务器没有给我太多数据（它一直在 运行 就好像什么都没有发生了）。调试控制台中打印的所有内容是：
Feb 12, 2016 1:49:13 PM org.hibernate.engine.jdbc.env.internal.LobCreatorBuilderImpl useContextualLobCreation
INFO: HHH000424: Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException
Feb 12, 2016 1:49:13 PM org.hibernate.type.BasicTypeRegistry register
INFO: HHH000270: Type registration [java.util.UUID] overrides previous : org.hibernate.type.UUIDBinaryType@6505e696
Feb 12, 2016 1:49:13 PM org.hibernate.jpa.internal.util.LogHelper logPersistenceUnitInformation
INFO: HHH000204: Processing PersistenceUnitInfo [
name: myapp.mypackage
...]
Feb 12, 2016 1:49:14 PM org.hibernate.engine.jdbc.env.internal.LobCreatorBuilderImpl useContextualLobCreation
INFO: HHH000424: Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException
Feb 12, 2016 1:49:14 PM org.hibernate.type.BasicTypeRegistry register
INFO: HHH000270: Type registration [java.util.UUID] overrides previous : org.hibernate.type.UUIDBinaryType@6505e696
Feb 12, 2016 1:49:14 PM org.hibernate.hql.internal.QueryTranslatorFactoryInitiator initiateService
INFO: HHH000397: Using ASTQueryTranslatorFactory
但是，我认为这不是有用的信息，因为如果我将加载切换为 EAGER，它会在控制台中提供相同的消息，但工作正常。
除此之外我基本上完全迷失了，但为了完整起见，这是我尝试过但也没有用的一件事：
我决定试一试自定义 XMLAdapter，因为我在调试时注意到 friends 是一个 PersistentSet，我想也许 Jersey 处理得不好。
所以我像这样更改了用户 class：
@XmlJavaTypeAdapter(FriendAdapter.class)
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
FriendAdapter 看起来像这样：
import org.hibernate.collection.internal.PersistentSet;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.util.*;
public class FriendAdapter extends XmlAdapter<List<User>, Set> {
@Override
public Set unmarshal(List<Friend> v) throws Exception {
return new HashSet<Friend>(v);
}
@Override
public List<Friend> marshal(Set v) throws Exception {
PersistentSet p = (PersistentSet) v;
if(p.empty()) {
return null;
}
return new ArrayList<Friend>(Arrays.asList((Friend[])v.toArray(new Friend[0])));
}
}
这给了我一个非常奇怪的结果：在序列化之后，进行 ajax 调用的 Web 浏览器将获得（而不是正常的对象数组）一个字符串，它显示为 "myapp.mypackage.User@3c81a180 myapp.mypackage.User@28d2a9cf myapp.mypackage.User@19c74a79"
我应该怎么做才能克服这个问题？急切加载修复了一切，但我不想加载朋友的朋友的朋友。
因此，这不是世界上最好的解决方案，更具战略性地使用 XMLMappers 也可能有效，但这同样有效。我的最终问题是 Hibernate 相对糟糕的代理系统。
我从这些帮助我朝着正确方向前进的其他答案中拼凑出这个解决方案：
Converting Hibernate proxy to real object
为了克服 Hibernates 代理系统，我调整了我的用户 class，添加了一个别名，这样序列化程序就不会尝试直接访问好友列表（因为它是一个 Hibernate 代理）：
@Entity
@Table(name="users")
public class User {
@Id
@GeneratedValue(generator = "increment")
@GenericGenerator(name="increment", strategy = "increment")
private int userID;
private String name;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
@Transient
private Set<User> friendListSnapshot;
@Transient
private boolean friendListInitialized = false;
public User(){}
public User(int userID, String name) {
this.userID = userID;
this.name = name;
}
public int getUserID() {
return userID;
}
public void setUserID(int userID) {
this.userID = userID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<User> getFriends() {
return friends;
}
public void setFriends(Set<User> friends) {
this.friendsListInitialized = false;
this.friendsListSnapshot = null;
this.friends = friends;
}
public void initFriends(){
((PersistentSet)friends).forceInitialization();
this.friendsListSnapshot = ((Map<User, ?>)((PersistentSet) friends).getStoredSnapshot()).keySet();
this.friendsListInitialized = true;
}
}
如果有人知道为什么 PersistentSet 在 EagerLoaded 时可以序列化，而在 LazyLoaded 时不能序列化，然后强制初始化，请插话。
我有一个相当标准的用例，它给我带来了非标准问题。
我在服务器上有一个 Java 网络应用 运行（使用 Jersey 和 Hibernate）。它有一个 AJAX api 从浏览器中调用 Java 脚本。
此服务公开给 ajax：
import list.nice.bll.UserBLL;
import list.nice.dal.dto.Token;
import list.nice.dal.dto.User;
import org.glassfish.jersey.media.multipart.FormDataBodyPart;
import org.glassfish.jersey.media.multipart.FormDataMultiPart;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.*;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import java.io.*;
import java.net.URISyntaxException;
import java.security.GeneralSecurityException;
@Path("/users")
public class UserInfoService {
@POST
@Path("/getUser")
@Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON)
public Response getUserFromLogin(JAXBElement<User> user){
User rUser = user.getValue();
rUser = UserInfoService.getActiveUser(rUser.getUserID());
return Response.status(Response.Status.OK).header("Access-Control-Allow-Origin", "*").entity(UserInfoService.getActiveUser(rUser.getUserID())).build();
}
}
我有一个用户 class 对应于一个用户 table。每个用户都有朋友，但我不需要我加载的每个用户的朋友（不需要一次获取整个对象图）。
User.java 看起来像这样：
@Entity
@Table(name="users")
public class User {
@Id
@GeneratedValue(generator = "increment")
@GenericGenerator(name="increment", strategy = "increment")
private int userID;
private String name;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
public User(){}
public User(int userID, String name) {
this.userID = userID;
this.name = name;
}
public int getUserID() {
return userID;
}
public void setUserID(int userID) {
this.userID = userID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<User> getFriends() {
return friends;
}
public void setFriends(Set<User> friends) {
this.friends = friends;
}
当我检索活跃用户时，我想立即检索他们的所有朋友，但不是朋友的朋友（以及更多朋友）。所以我的 getActiveUser() 函数看起来像这样：
protected static User getActiveUser(int userID) {
EntityManager entityManager = HibernateUtil.getEntityManagerFactory().createEntityManager();
User user = (User) entityManager.createQuery("from User where userID = :userID").setParameter("userID", userID).getSingleResult();
user.getFriends();
//I have also tried Hibernate.initialize(user.getFriends())
entityManager.close();
return user;
}
对该函数的 Ajax 调用最终得到一个 500 内部服务器错误，但服务器没有给我太多数据（它一直在 运行 就好像什么都没有发生了）。调试控制台中打印的所有内容是：
Feb 12, 2016 1:49:13 PM org.hibernate.engine.jdbc.env.internal.LobCreatorBuilderImpl useContextualLobCreation
INFO: HHH000424: Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException
Feb 12, 2016 1:49:13 PM org.hibernate.type.BasicTypeRegistry register
INFO: HHH000270: Type registration [java.util.UUID] overrides previous : org.hibernate.type.UUIDBinaryType@6505e696
Feb 12, 2016 1:49:13 PM org.hibernate.jpa.internal.util.LogHelper logPersistenceUnitInformation
INFO: HHH000204: Processing PersistenceUnitInfo [
name: myapp.mypackage
...]
Feb 12, 2016 1:49:14 PM org.hibernate.engine.jdbc.env.internal.LobCreatorBuilderImpl useContextualLobCreation
INFO: HHH000424: Disabling contextual LOB creation as createClob() method threw error : java.lang.reflect.InvocationTargetException
Feb 12, 2016 1:49:14 PM org.hibernate.type.BasicTypeRegistry register
INFO: HHH000270: Type registration [java.util.UUID] overrides previous : org.hibernate.type.UUIDBinaryType@6505e696
Feb 12, 2016 1:49:14 PM org.hibernate.hql.internal.QueryTranslatorFactoryInitiator initiateService
INFO: HHH000397: Using ASTQueryTranslatorFactory
但是，我认为这不是有用的信息，因为如果我将加载切换为 EAGER，它会在控制台中提供相同的消息，但工作正常。
除此之外我基本上完全迷失了，但为了完整起见，这是我尝试过但也没有用的一件事：
我决定试一试自定义 XMLAdapter，因为我在调试时注意到 friends 是一个 PersistentSet，我想也许 Jersey 处理得不好。
所以我像这样更改了用户 class：
@XmlJavaTypeAdapter(FriendAdapter.class)
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
FriendAdapter 看起来像这样：
import org.hibernate.collection.internal.PersistentSet;
import javax.xml.bind.annotation.adapters.XmlAdapter;
import java.util.*;
public class FriendAdapter extends XmlAdapter<List<User>, Set> {
@Override
public Set unmarshal(List<Friend> v) throws Exception {
return new HashSet<Friend>(v);
}
@Override
public List<Friend> marshal(Set v) throws Exception {
PersistentSet p = (PersistentSet) v;
if(p.empty()) {
return null;
}
return new ArrayList<Friend>(Arrays.asList((Friend[])v.toArray(new Friend[0])));
}
}
这给了我一个非常奇怪的结果：在序列化之后，进行 ajax 调用的 Web 浏览器将获得（而不是正常的对象数组）一个字符串，它显示为 "myapp.mypackage.User@3c81a180 myapp.mypackage.User@28d2a9cf myapp.mypackage.User@19c74a79"
我应该怎么做才能克服这个问题？急切加载修复了一切，但我不想加载朋友的朋友的朋友。
因此，这不是世界上最好的解决方案，更具战略性地使用 XMLMappers 也可能有效，但这同样有效。我的最终问题是 Hibernate 相对糟糕的代理系统。
我从这些帮助我朝着正确方向前进的其他答案中拼凑出这个解决方案：
Converting Hibernate proxy to real object
为了克服 Hibernates 代理系统，我调整了我的用户 class，添加了一个别名，这样序列化程序就不会尝试直接访问好友列表（因为它是一个 Hibernate 代理）：
@Entity
@Table(name="users")
public class User {
@Id
@GeneratedValue(generator = "increment")
@GenericGenerator(name="increment", strategy = "increment")
private int userID;
private String name;
@ManyToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@JoinTable(name = "friendships", joinColumns = @JoinColumn(name="requesteruserID"), inverseJoinColumns = @JoinColumn(name="requesteduserID"))
@WhereJoinTable(clause = "accepted = 'TRUE'")
private Set<User> friends = new HashSet<User>();
@Transient
private Set<User> friendListSnapshot;
@Transient
private boolean friendListInitialized = false;
public User(){}
public User(int userID, String name) {
this.userID = userID;
this.name = name;
}
public int getUserID() {
return userID;
}
public void setUserID(int userID) {
this.userID = userID;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Set<User> getFriends() {
return friends;
}
public void setFriends(Set<User> friends) {
this.friendsListInitialized = false;
this.friendsListSnapshot = null;
this.friends = friends;
}
public void initFriends(){
((PersistentSet)friends).forceInitialization();
this.friendsListSnapshot = ((Map<User, ?>)((PersistentSet) friends).getStoredSnapshot()).keySet();
this.friendsListInitialized = true;
}
}
如果有人知道为什么 PersistentSet 在 EagerLoaded 时可以序列化，而在 LazyLoaded 时不能序列化，然后强制初始化，请插话。