Hibernate（4）——主键生成策略、CRUD 基础API区别的总结 和 注解的使用

/**
 * StudentDao
 *
 * @author Wang Yishuai.
 * @date 2016/3/11 0011.
 * @Copyright(c) 2016 Wang Yishuai,USTC,SSE.
 */
public class StudentDao {
    private static final Logger LOG = LoggerFactory.getLogger(StudentDao.class);

    private Session session;

    @Before
    public void init() {
        Configuration configuration = new Configuration().configure();
        SessionFactory sessionFactory = configuration.buildSessionFactory();
        this.session = sessionFactory.getCurrentSession();
    }

    @After
    public void clear() {

    }

    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();

        Student student = new Student();

        try {
            //student.setSname("dashuai");
            student.setSname("dadadad");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }
}

<hibernate-mapping>
    <!-- class 里面的属性必须和对应的类名，表名保持一致，实现映射-->
    <class name="zhujian.vo.Student" table="students">
        <!-- id代表数据库表的主键， name="userId"，对应数据库表里的字段column="userId"-->
        <id name="sid" column="sid" type="string">
            <generator class="assigned"/>
        </id>
        <!-- 数据库里其他普通字段和实体属性的映射，属性的类型需要小写-->
        <property name="sname" column="sname" type="string"/>
    </class>
</hibernate-mapping>

<id name="id" column="id" type="long">
<generator class="sequence">
<param name="sequence">seq_name</param>
</generator>
</id> 

<id name="id" column="id">
<generator class="native" /></id>

<id name="id" column="id">
<generator class="uuid.hex" /></id>

<?xml version=‘1.0‘ encoding=‘UTF-8‘?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory name="MySQL">
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/bbs</property>
        <property name="connection.username">root</property>
        <property name="connection.password">123</property>
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>
        <property name="current_session_context_class">thread</property>

        <mapping class="net.nw.vo.Students"/>
    </session-factory>
</hibernate-configuration>

package net.nw.vo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

//学生实体类
@Entity
public class Students {
    private int sid;

    private String sname;
    
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getSid() {
        return sid;
    }

    public void setSid(int sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }
}

import net.nw.vo.Students;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;


public class HibernateTest {

    public static void main(String[] args) {
        AnnotationConfiguration annotationConfiguration = new AnnotationConfiguration().configure();
        SessionFactory sessionFactory = annotationConfiguration.buildSessionFactory();
        Session session = sessionFactory.getCurrentSession();
        Transaction transaction = session.beginTransaction();

        try {
            Students s = new Students();
            //s.setSid(1);
            s.setSname("xxxx");
            session.save(s);
            transaction.commit();
        } catch (Exception ex) {
            transaction.rollback();
            ex.printStackTrace();
        }
    }
}

Configuration cfg = new Configuration().configure(); 
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry(); 
SessionFactory factory = cfg.buildSessionFactory(serviceRegistry); 
Session s = factory.openSession();

    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();
        Student student = new Student();

        try {
            student.setSname("xiaoli");
            // 之前的student是瞬时态的
            session.save(student);
            // 之后变为持久态
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }

    @Test
    public void save() {
        Transaction transaction = session.beginTransaction();
//        Student student = new Student();

        try {
//            student.setSname("xiaoli");

            // 从数据库读取xiaoli，该对象是持久态的
            Student student = (Student) session.get(Student.class, 7);
            // 重新赋值，再保存
            student.setSname("小李");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }

    select
        student0_.sid as sid2_0_,
        student0_.sname as sname2_0_ 
    from
        students student0_ 
    where
        student0_.sid=?

    update
        students 
    set
        sname=? 
    where
        sid=?

Student student = (Student) session.get("zhujian.vo.Student", 1);
            LOG.info("sid = {}, sname = {}", student.getSid(), student.getSname());

    @Test
    public void retrive() {
        Transaction transaction = session.beginTransaction();

        try {
            Student student = (Student) session.load(Student.class, 2);
            student.setSname("小李");
            session.save(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }

            Student student = (Student) session.get(Student.class, 6);
            LOG.info("student sid = {}, student sname = {}", student.getSid(), student.getSname());

            Student student1 = (Student) session.get(Student.class, 6);
            LOG.info("student1 sid = {}, student1 sname = {}", student1.getSid(), student1.getSname());

            Student student = (Student) session.load(Student.class, 6);
            LOG.info("sid = {}, sname = {}", student.getSid(), student.getSname());

            Student student1 = (Student) session.load(Student.class, 6);
            LOG.info("student1 sid = {}, student1 sname = {}", student.getSid(), student.getSname());

public Object get(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        boolean success = false;

        Object var5;
        try {
            this.fireLoad(event, LoadEventListener.GET);
            success = true;
            var5 = event.getResult();
        } finally {
            this.afterOperation(success);
        }

        return var5;
    }


    public Object load(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        boolean success = false;

        Object var5;
        try {
            this.fireLoad(event, LoadEventListener.LOAD);
            if(event.getResult() == null) {
                this.getFactory().getEntityNotFoundDelegate().handleEntityNotFound(entityName, id);
            }

            success = true;
            var5 = event.getResult();
        } finally {
            this.afterOperation(success);
        }

        return var5;
    }

    LoadEventListener.LoadType GET = (new LoadEventListener.LoadType("GET")).setAllowNulls(true).setAllowProxyCreation(false).setCheckDeleted(true).setNakedEntityReturned(false);
    LoadEventListener.LoadType LOAD = (new LoadEventListener.LoadType("LOAD")).setAllowNulls(false).setAllowProxyCreation(true).setCheckDeleted(true).setNakedEntityReturned(false);

    private void fireLoad(LoadEvent event, LoadType loadType) {
        this.errorIfClosed();
        this.checkTransactionSynchStatus();
        LoadEventListener[] loadEventListener = this.listeners.getLoadEventListeners();

        for(int i = 0; i < loadEventListener.length; ++i) {
            loadEventListener[i].onLoad(event, loadType);
        }

    }

    public void onLoad(LoadEvent event, LoadType loadType) throws HibernateException {
        EventSource source = event.getSession();
        EntityPersister persister;
        if(event.getInstanceToLoad() != null) {
            persister = source.getEntityPersister((String)null, event.getInstanceToLoad());
            event.setEntityClassName(event.getInstanceToLoad().getClass().getName());
        } else {
            persister = source.getFactory().getEntityPersister(event.getEntityClassName());
        }

        if(persister == null) {
            throw new HibernateException("Unable to locate persister: " + event.getEntityClassName());
        } else {
            if(!persister.getIdentifierType().isComponentType() || EntityMode.DOM4J != event.getSession().getEntityMode()) {
                Class keyToLoad = persister.getIdentifierType().getReturnedClass();
                if(keyToLoad != null && !keyToLoad.isInstance(event.getEntityId())) {
                    throw new TypeMismatchException("Provided id of the wrong type for class " + persister.getEntityName() + ". Expected: " + keyToLoad + ", got " + event.getEntityId().getClass());
                }
            }

            EntityKey keyToLoad1 = new EntityKey(event.getEntityId(), persister, source.getEntityMode());

            try {
                if(loadType.isNakedEntityReturned()) {
                    event.setResult(this.load(event, persister, keyToLoad1, loadType));
                } else if(event.getLockMode() == LockMode.NONE) {
                    event.setResult(this.proxyOrLoad(event, persister, keyToLoad1, loadType));
                } else {
                    event.setResult(this.lockAndLoad(event, persister, keyToLoad1, loadType, source));
                }

            } catch (HibernateException var7) {
                log.info("Error performing load command", var7);
                throw var7;
            }
        }
    }

    protected Object proxyOrLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
        if(log.isTraceEnabled()) {
            log.trace("loading entity: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
        }

        if(!persister.hasProxy()) {
            return this.load(event, persister, keyToLoad, options);
        } else {
            PersistenceContext persistenceContext = event.getSession().getPersistenceContext();
            Object proxy = persistenceContext.getProxy(keyToLoad);
            return proxy != null?this.returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy):(options.isAllowProxyCreation()?this.createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext):this.load(event, persister, keyToLoad, options));
        }
    }

    protected Object load(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
        if(event.getInstanceToLoad() != null) {
            if(event.getSession().getPersistenceContext().getEntry(event.getInstanceToLoad()) != null) {
                throw new PersistentObjectException("attempted to load into an instance that was already associated with the session: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
            }

            persister.setIdentifier(event.getInstanceToLoad(), event.getEntityId(), event.getSession().getEntityMode());
        }

        Object entity = this.doLoad(event, persister, keyToLoad, options);
        boolean isOptionalInstance = event.getInstanceToLoad() != null;
        if((!options.isAllowNulls() || isOptionalInstance) && entity == null) {
            event.getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound(event.getEntityClassName(), event.getEntityId());
        }

        if(isOptionalInstance && entity != event.getInstanceToLoad()) {
            throw new NonUniqueObjectException(event.getEntityId(), event.getEntityClassName());
        } else {
            return entity;
        }
    }

 1 protected Object doLoad(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options) {
 2         if(log.isTraceEnabled()) {
 3             log.trace("attempting to resolve: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
 4         }
 5 
 6         Object entity = this.loadFromSessionCache(event, keyToLoad, options);// 先从session缓存（一级缓存）中加载对象
 7 
 8         if(entity == REMOVED_ENTITY_MARKER) {
 9             log.debug("load request found matching entity in context, but it is scheduled for removal; returning null");
10             return null;
11         } else if(entity == INCONSISTENT_RTN_CLASS_MARKER) {
12             log.debug("load request found matching entity in context, but the matched entity was of an inconsistent return type; returning null");
13             return null;
14         } else if(entity != null) {// 在一级缓存里查找到对象就返回该对象
15             if(log.isTraceEnabled()) {
16                 log.trace("resolved object in session cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
17             }
18 
19             return entity;
20         } else { // 一级缓存找不到，get方法去二级缓存找
21             entity = this.loadFromSecondLevelCache(event, persister, options);
22             if(entity != null) {// 如果存在且找到就返回该对象
23                 if(log.isTraceEnabled()) {
24                     log.trace("resolved object in second-level cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
25                 }
26 
27                 return entity;
28             } else { // 最后缓存找不到，才去数据库查询
29                 if(log.isTraceEnabled()) {
30                     log.trace("object not resolved in any cache: " + MessageHelper.infoString(persister, event.getEntityId(), event.getSession().getFactory()));
31                 }
32 
33                 return this.loadFromDatasource(event, persister, keyToLoad, options);
34             }
35         }
36     }

PersistenceContext persistenceContext = event.getSession().getPersistenceContext();// load方式先从事件的上下文环境中查找（一级缓存session）
// 返回的对象赋值给proxy，名字都那么明显了，代理对象
Object proxy = persistenceContext.getProxy(keyToLoad);
// 如果是空的，就创建代理对象，不是空的，先判断是否允许创建代理（还记得之前的LOAD和GET常量么，就在这里起作用），load肯定允许，那么开始创建代理
return proxy != null?this.returnNarrowedProxy(event, persister, keyToLoad, options, persistenceContext, proxy):(options.isAllowProxyCreation()?this.createProxyIfNecessary(event, persister, keyToLoad, options, persistenceContext):this.load(event, persister, keyToLoad, options));

// 该内部的私有方法中第一个log就说了：实体代理类先从session中查找
private Object returnNarrowedProxy(LoadEvent event, EntityPersister persister, EntityKey keyToLoad, LoadType options, PersistenceContext persistenceContext, Object proxy) {
        log.trace("entity proxy found in session cache");
        // 执行的是懒加载
        LazyInitializer li = ((HibernateProxy)proxy).getHibernateLazyInitializer();
        if(li.isUnwrap()) {// 没有解包，就直接返回该代理对象
            return li.getImplementation();
        } else {
            Object impl = null;
            // load查找允许创建代理，那么这个if肯定不进入执行
            if(!options.isAllowProxyCreation()) {
                impl = this.load(event, persister, keyToLoad, options);
                // 没有找到就返回异常信息
                if(impl == null) {
                    event.getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound(persister.getEntityName(), keyToLoad.getIdentifier());
                }
            }
   
            // 重写使用代理包装一下再返回
            return persistenceContext.narrowProxy(proxy, persister, keyToLoad, impl);
        }
    }

        try {
            Student student = new Student();
            // 创建瞬时态对象student
            student.setSid(9);
            student.setSname("隔壁老王");
            // 更新瞬时态对象
            session.update(student);
            transaction.commit();
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }

    @Test
    public void updateObj() {
        Transaction transaction = session.beginTransaction();

        try {
            Student student = (Student) session.get(Student.class, 1);
            transaction.commit(); // 读取一个持久对象，什么都不做，提交事务，session自动关闭（使用的线程封闭的session）
            // 此时student变为游离态
            // 重新开启session和事务
            session = sessionFactory.getCurrentSession();
            Transaction transaction1 = session.beginTransaction();
            session.update(student); // ok
            transaction1.commit();// ok
        } catch (Exception e) {
            LOG.error("save error", e);
            transaction.rollback();
        }
    }

Students s1 = new Students();

s1.setSid(4);// 假设id=4的对象存在数据库

s1.setSname(“masi”);//s1是托管态的

Students s2 =(Students)session.merge(s1);