hibernate对象识别

Java语言中判断对象是否相等有两种方式，一种是使用“==”来比较，一种是使用equals()方法来比较，前者是比较两个对象的引用地址是否相同，即两个引用地址是否指向同一个对象，而后者是比较对象的内容是否一致。
    equals()方法是Object类中定义的方法，所有Java类都可以直接或间接继承这个方法，通过方法覆盖就可以实现自己的equals()方法，而这个方法的原始定义如下：

Java代码

1.     public boolean equals(Object obj){ 
2.         return (this==obj); 
3. } 

	public boolean equals(Object obj){
		return (this==obj);
}

    可以看出，默认情况下“==”和equals()方法的比较原则是相同的，而Java类库中String，Date和基本类型的封装类都重写了该方法，所以它们有着自己的判断标准，即判断对象的内容是否相等。
    在Hibernate中，对象识别是非常重要的一种开发手段，因为持久化对象对应了数据库表中的记录，为了区分表中的记录，我们使用主键来唯一标识，而对于持久化对象，我们使用了标识符。那么，为了比较对象是否相等，实质就是比较标识符属性是否一致。
首先，我们创建一个持久化类，如下：

Java代码

1. public class User implements java.io.Serializable { 
2.     private Integer id; 
3.     // 省略其他属性 
4.     public User() { 
5.     } 
6.     public Integer getId() { 
7.         return id; 
8.     } 
9.     public void setId(Integer id) { 
10.         this.id = id; 
11.     } 
12.     // 省略其他getter和setter方法 
13.     @Override 
14.     public boolean equals(Object obj) { 
15.         if (this == obj) 
16.             return true; 
17.         if (obj == null) 
18.             return false; 
19.         if (getClass() != obj.getClass()) 
20.             return false; 
21.         User other = (User) obj; 
22.         if (id == null) { 
23.             if (other.id != null) 
24.                 return false; 
25.         } else if (!id.equals(other.id)) 
26.             return false; 
27.         return true; 
28.     } 
29.     @Override 
30.     public String toString() { 
31.         return "User [city=" + city + ", department=" + department 
32.                 + ", hireTime=" + hireTime + ", id=" + id + ", name=" + name 
33.                 + ", phone=" + phone + "]"; 
34.     } 
35. } 

public class User implements java.io.Serializable {
	private Integer id;
	// 省略其他属性
	public User() {
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	// 省略其他getter和setter方法
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "User [city=" + city + ", department=" + department
				+ ", hireTime=" + hireTime + ", id=" + id + ", name=" + name
				+ ", phone=" + phone + "]";
	}
}

    持久化类的其他属性参照toString()方法里的参数即可。我们使用Eclipse为我们自动生成了equals()方法，比较内容只是属性标识符(主键)，因为持久化类对应数据库表中的记录，而记录由主键唯一标识，所以使用标识符属性来作为equals()方法比较的内容就最合适了。
    在Hibernate中判断两个持久化对象是否相等，需要全面考虑，因为这里面的判断因素比较多。首先在相同的Session对象中，只要标识符属性值相同，那么两个持久化对象就相等，看下面的代码：

Java代码

1. Session session = sessionFactory.getCurrentSession(); 
2. Transaction tx = session.beginTransaction(); 
3. User user1 = (User) session.get(User.class, new Integer(2)); 
4. User user2 = (User) session.get(User.class, new Integer(2)); 
5. tx.commit(); 
6. ystem.out.println(user1 == user2); 

	Session session = sessionFactory.getCurrentSession();
	Transaction tx = session.beginTransaction();
	User user1 = (User) session.get(User.class, new Integer(2));
	User user2 = (User) session.get(User.class, new Integer(2));
	tx.commit();
System.out.println(user1 == user2);

    运行这段代码，得到true的结果，说明user1和user2两个引用指向了同一个对象，同时看到Hibernate执行这段代码的时候，只进行了一次数据库查询，说明第二个get()没有再次查找数据库，这就是Hibernate的缓存策略在起作用了。get()方法执行时会先在Hibernate的一级缓存中查找对象，没有找到才会查询数据库，而前面的一次查询，Hibernate将取出的对象放入了一级缓存中，所以第二个get()没有执行数据库操作，而是把user2的引用指向了第一个get()查询出的对象。所以user1==user2是成立的。
    再看看不同Session的情况，因为Session对象在Hibernate中是一种生命周期较短的对象，一个应用不可能长时间使用同一个Session对象，所以要比较不同Session对象中的持久化对象是否相等，就需要比较标识符属性了，看下面的代码：

Java代码

1.     Session session = sessionFactory.getCurrentSession(); 
2.     Transaction tx = session.beginTransaction(); 
3.     User user1 = (User) session.get(User.class, new Integer(2)); 
4.     tx.commit(); 
5.     session = sessionFactory.getCurrentSession(); 
6.     tx = session.beginTransaction(); 
7.     User user2 = (User) session.get(User.class, new Integer(2)); 
8.     tx.commit(); 
9. System.out.println(user1 == user2); 
10. System.out.println(user1.getId().equals(user2.getId())); 

	Session session = sessionFactory.getCurrentSession();
	Transaction tx = session.beginTransaction();
	User user1 = (User) session.get(User.class, new Integer(2));
	tx.commit();
	session = sessionFactory.getCurrentSession();
	tx = session.beginTransaction();
	User user2 = (User) session.get(User.class, new Integer(2));
	tx.commit();
System.out.println(user1 == user2);
System.out.println(user1.getId().equals(user2.getId()));

    随着commit()方法的调用，事务提交，Session对象关闭，那么两个持久化对象不属于同一个Session，所以当第二次获得Session时，Hibernate就又进行了一次数据库操作，所以两个对象是不同的，user1和user2的指向也是不同的，而它们都代表数据库表中的同一条记录么？就需要比较标识符的属性，而标识符的属性是相同的，所以equals()方法的判断就是正确的。而如果已经在持久化类中重写了equalse()方法，那么就可以如下书写：

Java代码

1. System.out.println(user1.equals(user2)); 

System.out.println(user1.equals(user2));

    得到的结果也是正确的，equals()方法的实现就是前面持久化类中的，而这个方法是可以借助Eclipse完成的，只需勾选需要比较的属性即可。