Hibernate笔记

开始

　　好记心不如烂笔头，很多技术如果长时间容易遗忘，故特用此文记录下一些Hibernate的使用技巧。希望将来的自己和所有看到这篇文章的童鞋都能从中获益。

Hibernate的使用场景。

在一些对性能要求不是很高，但对开发速度有要求的小型项目中，Hibernate能显著降低代码量和提高增删改业务的开发效率。

---

 

• 对象映射关系-基础配置。

　　拿部门，员工这种典型一对多关系来做例子。

　　首先是公共父类，可以定义一些所有表都需要用到的公共字段，还有主键生成规则。

　　ID：默认所有表的逻辑主键，需要用@GeneratedValue定义值的生成策略。generator里面指定的是一个生成器Key，在子类中可以通过这个Key关联，然后再定义每个表的具体生成策略。

@MappedSuperclass
@AccessType(Type.FIELD)
public class PublicPO extends PublicObj {

    /** id 逻辑主键 */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO, generator = "caGenerator")
    @Column(name = "id")
    private Long id;

    /** 创建人 */
    @Column(name = "CREATE_BY", updatable = false)
    private String createBy;

    /** 创建时间 */
    @Column(name = "CREATE_TIME", updatable = false)
    private Date createTime;

    /** 更新人 */
    @Column(name = "UPDATE_BY")
    private String updateBy;

    /** 更新时间 */
    @Column(name = "UPDATE_TIME")
    private Date updateTime;

    public Long getId() {
        return id;
    }

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

    public String getCreateBy() {
        return createBy;
    }

    public void setCreateBy(String createBy) {
        this.createBy = createBy;
    }

    public String getUpdateBy() {
        return updateBy;
    }

    public void setUpdateBy(String updateBy) {
        this.updateBy = updateBy;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

}

部门类（Department）继承公共父类，同时定义的主键生成策略为序列，指定序列名。

部门和员工为一对多关系，所以部门中有一个List<Employee>属性，mappedBy = "department" 意思是让employee来维护关联关系；orphanRemoval = true 意思是自动删除不再和部门关联的员工。

由于部门之间还有父子关系，所以部门中还会有一个Department类型的属性，为多对一自连接关系。代码如下：

@Entity
@Table(name = "s_department")
@SequenceGenerator(name = "caGenerator", sequenceName = "seq_department", allocationSize = 1)
public class Department extends PublicPO {

    @Column(name = "NAME")
    private String name;

    @Column(name = "TYPE")
    private String type;

    @Column(name = "STRATEGY")
    private String strategy;

    @Column(name = "status")
    private Integer status;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "PARENT_ID")
    private Department parent;
    
    @OneToMany(cascade = {CascadeType.ALL}, fetch = FetchType.LAZY, mappedBy = "department", orphanRemoval = true)
    private List<Employee> employeeList;

    public String getName() {
        return name;
    }

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

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getStrategy() {
        return strategy;
    }

    public void setStrategy(String strategy) {
        this.strategy = strategy;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    public Department getParent() {
        return parent;
    }

    public void setParent(Department parent) {
        this.parent = parent;
    }

    public List<Employee> getEmployeeList() {
        return employeeList;
    }

    public void setEmployeeList(List<Employee> employeeList) {
        this.employeeList = employeeList;
    }
}

员工类

@Entity
@Table(name = "s_employee")
@SequenceGenerator(name = "caGenerator", sequenceName = "seq_employee", allocationSize = 1)
public class Employee extends PublicPO{

    @Column(name = "NAME")
    private String name;

    @Column(name = "DESC")
    private String desc;
    
    @Column(name = "AGE")
    private Integer age;

    @Column(name = "hire_date")
    private Date hireDate;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "DEPARTMENT_ID")
    private Department department;

    public String getName() {
        return name;
    }

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

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Integer getAge() {
        return age;
    }

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

    public Date getHireDate() {
        return hireDate;
    }

    public void setHireDate(Date hireDate) {
        this.hireDate = hireDate;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

 部门下新增员工和修改员工的设计思路。

首先有一个前提，就是前端页面每次都会把一个部门下的所有员工全部传给后台。后台处理提供2种思路

1.先删后增。先将部门和部门下的所有员工信息全部删除，然后再把前台传过来的数据存入数据库。

方案优点：不需要人工判断，后台传入的ID是否在数据库存在，存在就修改，不存在则新增。

方案缺点：如果部门和员工信息关联的表比较多，那从前台传过来的信息就会很多，而且将来如果多一个关联对象，可能还要修改代码。

2.让hibernate自己去判断修改还是新增。在调用对象的SAVE方法时，PO要从前台VO直接转而不要通过JPA的查询方法查出。如果需要校验可以放在另一个事务里或者使用MyBatis。

方案优点：不需要人工判断，代码量少。

方案缺点：对于程序猿要求比较高，需要他比较熟悉Hibernate底层的处理机制。

注意点：

如果数据库中1个部门存在5个员工，而调用save时list中只有4个，那当orphanRemoval = true时，Hibernate是会自动删除那个缺失的员工的。

对于员工从一个部门调到另一个部门的情况，即某员工A的部门ID从1改成了2.这种需要先将该员工的id设置为空，然后找到新部门的部门ID。否则Hibernate发现原来部门的员工少了一个会自动删除这个员工。

3.人工判断数据是否存在,存在则修改,不存在则新增.先根据ID判断是新增还是修改.先判断主表在判断子表.

方案优点：逻辑全靠程序猿自己控制,不怎么依赖Hibernate,定制性比较强.

方案缺点：判断逻辑比较多，比较依赖程序猿的细致程度。

---

CascadeType中几个值的具体含义

CascadeType.REFRESH：级联刷新，当多个用户同时作操作一个实体，为了用户取到的数据是最新的实时的，在使用实体中的数据之前就可以调用一下refresh()方法！

CascadeType.REMOVE：级联删除，当调用部门的remove()方法时，会删除部门List中的所有员工数据！

CascadeType.MERGE：级联更新，当调用了Merge()方法时，如果部门中的数据改变了会相应的更新员工信息中的数据。

CascadeType.PERSIST：级联保存，当调用了部门的Persist()方法，会级联保存相应List中的员工数据

CascadeType.ALL：包含以上所有级联属性。

（注：以上几种级联操作，只能实在满足数据库的约束时才能生效，比如上边的部门和员工存在主外键关联，那执行REMOVE()方法时可能不一定能级联删除）

---

Hibernate怎么实现仅仅查询自己想要的字段？

• 使用高级查询DetachedCriteria实现，代碼如下：

String alias = "user_"; //查詢時的table別名  
DetachedCriteria dc = DetachedCriteria.forClass(User.class,alias);  
ProjectionList pList = Projections.projectionList();  
pList.add(Projections.property(alias + "." + "id").as("id"));  
pList.add(Projections.property(alias + "." + "name").as("name"));  
pList.add(Projections.property(alias + "." + "age").as("age"));  
pList.add(Projections.property(alias + "." + "sex").as("sex"));  
dc.setProjection(pList);  
dc.setResultTransformer(Transformers.aliasToBean(User.class));  
resultList = memberService.findByDetached(dc).size();  

• 通过HQL语句new POJO()实现，代码如下：

public class Link {

    private String id;  
    private String name;  
    private String url;  
    private Integer index;  

    public Link(){}

    //因为：String hql = "select new Link(id,name) from Link";  
    //所以必须要有接受2个参数的构造函数  
    public Link(String id,String name){  
        this.id = id;  
        this.name = name;  
    }

    public String getName() {  
        return name;  
    }

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

    public String getUrl() {  
        return url;  
    }

    public void setUrl(String url) {  
        this.url = url;  
    }
} 

然后使用HQL时，使用这个对象

String hql = "select new Link(id,name) from Link";
Query query = session.createQuery(hql);
//默认查询出来的list里存放的是一个Object对象，但是在这里list里存放的不再是默认的Object对象了，而是Link对象了
List<Link> links = query.list();
for(Link link : links){
    String id = link.getId();
    String name = link.getName();
    System.out.println(id + " : " + name);
}

第三种方式是在HQL语句中直接写字段名，类似SQL，代码如下：

String hql = "select id,name from Link";
Query query = session.createQuery(hql);
//默认查询出来的list里存放的是一个Object数组，还需要转换成对应的javaBean。
List<Object[]> links = query.list();
for(Object[] link : links){
    String id = link[0];
    String name = link[1];
    System.out.println(id + " : " + name);
}

---

常见问题处理：

• Hibernate的HQL和SQL混用时为什么查询不到SQL的更新结果？

如果sql在hql的后面执行，那在执行sql查询之前一定要调用flush方法，否则在SQL中无法获取HQL的执行结果

HQL在SQL后面执行，那必须先调用Refresh方法。否则HQL查询不到SQL的更新结果。

• 对于Hibernate的flush和refresh方法的使用说明.

1）这两个方法都是EntityManager类的，但flush方法没参数，refresh方法必须传入一个对象。

2）Flush主要是将Hibernate缓存中的数据同步到数据库。如果先用了HQL更新了数据,那调用SQL前最好调用这个方法将数据同步到数据库。否则SQL就会查询不到HQL的更新结果。

3）Refresh是将游离态的对象重新变为持久态，同时也会将数据库中某张表的数据同步到指定的对象上。如果用SQL更新了数据，那用HQL查询前最好调用一下这个方法。

• 在saveOrUpdate带子表的对象时，子表中的记录翻倍，是怎么回事？

这种情况一般发生在两种场景下，

第一种情况。该对象已经有子表数据，然后在此基础上新增。对应到代码中，就是先把list属性get出来，然后add进去多个子表记录，然后saveOrUpdate主表记录。此时新增的子表数据会出现双倍的情况。解决方案：save之前flush一下；

第二种情况，在代码中首先saveOrUpdate一下一个带有子表记录的对象。然后在调用update方法更新一些字段，此时子表的记录也会变成双倍。解决方案：每次对数据库操作后都flush一下，然后再进行第二次操作。

• 调用remove方法时,报错EntityNotFoundException: deleted entity passed to persist?

答：一对多的关系中，如果删除多的一方时，需要先断开多合一的连接，在进行删除。举例来说department和employee是一对多关系,当删除employee时,可以先employee.getDepartment().getEmployees().remove(employee),然后调用remove方法把employee删除.

• Hibernate如何配置打印SQL语句参数.

1、配置Spring数据库配置文件，例如：spring-jpa.xml:
<prop key="hibernate.show_sql">true</prop>--强制打印sql
<prop key="hibernate.format_sql">true</prop>--格式化sql
<prop key="hibernate.use_sql_comments">true</prop>--添加sql的注释，说明sql的触发来源
2、配置log4j或者logback:

<logger name="org.hibernate.SQL" level="DEBUG" />
<logger name="org.hibernate.engine.QueryParameters" level="DEBUG" />
<logger name="org.hibernate.engine.query.HQLQueryPlan" level="DEBUG" />
<logger name="org.hibernate.type.descriptor.sql.BasicBinder" level="TRACE"/>
<logger name="org.hibernate.type.descriptor.sql.BasicExtractor" level="TRACE"/>