昨天在工作中遇到一个特殊的场景，点击修改，对一条发布状态的记录进行复制，并生成一个草稿版本，也就是同一条记录的不同状态，也就出现需要从数据库get之后把id置空重新保存，这里出现一个问题，但Hibernate的持久化对象是无法对id进行修改操作的，需要重新new一个全新的对象存储才可以，但Java中的机制，如果采用new Object()并赋值的的方式并不是真的产生一个新的对象，而是引用赋值，即传递内存地址，学过C语言的很容易理解。
要实现这种需求，就要复制出一个全新的对象，Java提供了一种解决办法——对象克隆。
对象克隆的方法：
实体类实现Cloneable接口，然后在实体类中重写clone()方法,以User类为例，如下所示：

package com.domain;

/**
 * Created by Jiro.Chen on 2017/11/6.
 */
public class User implements Cloneable {
    private String id;
    private String name;
    private Integer age;
    private String address;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != null ? !id.equals(user.id) : user.id != null) return false;
        if (name != null ? !name.equals(user.name) : user.name != null) return false;
        if (age != null ? !age.equals(user.age) : user.age != null) return false;
        if (address != null ? !address.equals(user.address) : user.address != null) return false;

        return true;
    }

    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (age != null ? age.hashCode() : 0);
        result = 31 * result + (address != null ? address.hashCode() : 0);
        return result;
    }
    
    @Override
    public Object clone(){
        User user = null;
        try {
            user = (User)super.clone();
        }catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return user;
    }
}
这样使用的时候，User user1 =  new User();    User user2 = user1.clone();即可将user1的所有属性值复制给user2，但他们是两个对象，而不是同一个对象的引用。之后可以进行id的修改，然后用Hibernate进行保存，生成一条新的记录。

hibernate操作持久化对象是通过session缓存来实现的。在下面的会一步一步进行解析其工作原理。
什么是缓存?

缓存介于应用程序和永久性存储源之间，他的作用是降低应用程序直接读写永久性存储源的频率，从而提高应用的运行效率；
缓存内的数据是永久性存储源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件同步缓存和永久性存储源的数据。

什么是session缓存？
session接口的实现类sessionImpl中定义了一系列的Java集合，这些集合构成了session的缓存。

Session session = sessionFactory.openSession(); 
......
session.close();



session缓存是如何工作的？


当session执行查询方法时，先从session缓存中读取数据，如果缓存中有则直接读取，如果缓存中没有，从数据库中查询并加载到session缓存中，再从缓存中读取；

当session执行save()、update()方法时，将对象持久化到数据库中并将对象加载到session缓存中；
session清理缓存？
session在某一时间点按照缓存中对象的属性变化来同步更新数据库的这一过程被称为“session清理缓存”
清理缓存的时间点：
当调用`transaction.commit() `方法时，会先清理缓存，在向数据库提交事务；
当显式调用`Session.flush() `时，会清理缓存；
当调用session的查询（不包括load()和get()方法）时，如果缓存中对象的属性有变化则清理缓存；

session缓存的三个作用：
减少数据库的访问次数，提高数据访问的效率
保证缓存中的对象与数据库中相关的记录同步
避免死循环以及死循环引起的堆栈溢出异常；【OID机制】

hibernate对象的生命周期：
实体对象的四种状态：
transient(临时状态)：刚刚被new创建，还没有被持久化，不在session缓存中
persistent(持久化状态)：已经被持久化，并加入到session缓存中
detached(游离状态)：已经被持久化，但不再处于session缓存中
removed(删除状态)：session已经计划将其从数据库中删除，并且不在处于session缓存中；


hibernate操作持久化对象：
session的save方法
把对象加入缓存中，使其变成持久化对象
根据映射文件配置的标识符生成器为对象分配一个OID；
计划执行一个insert，把对象当前属性值组装到insert语句中
事务提交后（transaction.commit())永久的将数据保存在数据库中

session的update方法
把游离对象重新加入session缓存中，使其变为持久化对象
计划执行一个update，将对象当前属性组装到update语句，执行update语句；
事务提交后（transaction.commit()）永久的将数据保存到数据库中；
不管对象属性有没有改变都会执行update（通过设置<class>的select-before-update=true改变）

session的savaOrupdate()方法


session的delete()方法
检查传入的参数是否是持久化对象，如果是将其移出session缓存
计划执行一个delete，但是并不执行
当session清理缓存时才执行delete，比如执行`session.flush()`

hibernate区分临时对象
对象的OID为null
映射文件中设置了<id>的unsaved-value属性，并且对象的id值与unsaved-value设置的值相等；

session的load()和get()方法
相同点：
load和get方法都是根据OID加载持久化对象

不同点：
如果数据库中不存在与OID对应的记录：
	load会抛出ObjectNotFoundException异常
	get会返回null；
默认加载策略
	load使用类的延迟加载策略
	get使用类的立即加载策略

描述：需要将数据的一条记录进行复制保存为一条新记录。

思路：从数据库中取得一条记录封装到对象中，然后改变此对象的主键，保存此对象即可。

   分析：看起来很简单快捷吧，但事实并非如此，执行出错“identifier of the object was alter from 1 to 10”，因为从数据库中取得的对象是持久化对象。在hibernate的缓存中有一个备份。当你修改了持久化对象，提交事务时，hibernate就会比较当前对象和在缓存中备份的对象，如果不一样则更新数据库。这里需要注意：更新是根据主键更新的：也就是 update tablename set ... where
 主键=‘？’。 但是如果你把主键的值改了，hibernate在更新的时候就无法更新数据库了，所以就产生了上面的错误。

解决的办法有三种：

解决办法一：evict（object） ：在改变对象主键之前。利用evict方法清理hibernate缓存，此对象将不再是持久化对象，所以不会去更新数据库。成功。但是hibernate不提倡用此方法

解决办法二：重新new一个对象，把原来的对象的属性值一一set进来，然后保存。重新new的对象是瞬时对象，保存成功。但如果存在大量的属性，或者此表存在子表数量多，那么必须为每个表的对象都new一次，然后赋值。这将很耗时，非常讨厌。
解决办法三：利用java反射机制复制一个对象出来，效果的new一个对象一样，但是简单了很多(ps:java反射机制复制对象，到底能提高多少效率，值得商榷)，代码如下：





[java] view
 plaincopy





import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method; 



public class CopyObject {
public static Object copy(Object object) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {  
   Object objectCopy = null; 
   if(null == object) return null;  

        Class<?> classType = object.getClass();        

        //取原对象的属性

        Field fields[] = classType.getDeclaredFields();

        //创建赋值对象

        objectCopy = classType.getConstructor(new Class[] {}).newInstance(new Object[] {});    

        Field field = null;  

        String suffixMethodName;  

        Method getMethod, setMethod;  

        Object value = null;  

        for(int i = 0; i < fields.length; i++) {  

            field = fields[i];  

            suffixMethodName = field.getName().substring(0, 1).toUpperCase() + (field.getName().length()>1?field.getName().substring(1):"");       

            getMethod = classType.getMethod("get" + suffixMethodName, new Class[] {});    

            setMethod = classType.getMethod("set" + suffixMethodName, new Class[] { field.getType() });  

            value = getMethod.invoke(object, new Object[] {});  

            if(null == value){  

                if(field.getType().getName().equalsIgnoreCase("java.lang.String")){  

                    setMethod.invoke(objectCopy, new Object[] { "" });  

                }  

            }else{  

                setMethod.invoke(objectCopy, new Object[] { value });  

            }  

        }

        return objectCopy;   
}

}

最近在用hibernate的时候产生一个问题。我的目的是复制一条记录。思路：从数据库中取得一条记录封装到对象中，然后改变此对象的主键，最后保存此对象。看似很正确的思路却产生了错误：identifier of the object was alter from 1 to 10。 这是为什么呢？开始从网上搜索,最终找到了原因：从数据库中取得的对象是持久化对象。在hibernate的缓存中有一个备份。当你修改了持久化对象，提交事务时，hibernate就会比较当前对象和在缓存中备份的对象，如果不一样则更新数据库。这里需要注意：更新是根据主键更新的：也就是
 update tablename set ... where 主键=‘？’。 但是如果你把主键的值改了，hibernate在更新的时候就无法更新数据库了，所以就产生了上面的错误。 所以为了达到我的目的，持久化对象是不能修改的。怎么解决的，哭死冥想，终于解决了..而解决的办法有三种：解决办法一：evict（object） ：在改变对象主键之前。利用evict方法清理hibernate缓存，此对象将不再是持久化对象，所以不会去更新数据库。成功。但是hibernate不提倡用此方法解决办法二：重新new一个对象，把原来的对象的属性值一一set进来，然后保存。重新new的对象是瞬时对象，保存成功。但如果存在大量的属性，或者此表存在子表数量多，那么必须为每个表的对象都new一次，然后赋值。这将很耗时，非常讨厌。解决办法三：利用java反射机制复制一个对象出来，效果的new一个对象一样，但是简单了很多，代码如下：public
 static Object copy(Object object) throws Exception {Class<?> classType = object.getClass();Object objectCopy = classType.getConstructor(new Class[] {}).newInstance(new Object[] {});Field fields[] = classType.getDeclaredFields();for (int i = 0; i < fields.length;
 i++) {Field field = fields[i];String fieldName = field.getName();String firstLetter = fieldName.substring(0, 1).toUpperCase();String getMethodName = "get" + firstLetter + fieldName.substring(1);String setMethodName = "set" + firstLetter + fieldName.substring(1);Method
 getMethod = classType.getMethod(getMethodName,new Class[] {});Method setMethod = classType.getMethod(setMethodName,new Class[] { field.getType() });Object value = getMethod.invoke(object, new Object[] {});setMethod.invoke(objectCopy, new Object[] { value });}return
 objectCopy;} 到此为止，问题解决....