JAP+Hibernate持久化框架

​

简介

简述：现在操作数据库的框架有很多，比如Mybatis、Hibernate、JPA,因为项目使用的hibernate+jpa,现阶段主要学习方向也在这一块。JPA 是 JCP 组织发布的 Java EE 标准之一，因此任何声称符合 JPA 标准的框架都遵循同样的架构，提供相同的访问API，这保证了基于JPA开发的企业应用能够经过少量的修改就能够在不同的JPA框架下运行。Hibernate可以很好的与JPA整合起来，简化操作数据库。

JAP+Hibernate操作不同关系表

一对一（OneToOne）

//主表对象 ApplyEntity
@OneToOne(fetch = FetchType.EAGER, mappedBy = "apply", cascade = { CascadeType.ALL })
CreditApplyCustomerEntity			customerEntity;
//副表对象 CreditApplyCustomerEntity
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "FK_APPLY")
private ApplyEntity			apply;

一对多（OneToMany）

//主表对象  ApplyEntity
@OneToMany(mappedBy = "apply", cascade = { CascadeType.ALL }, fetch = FetchType.LAZY)
List<Contract>	contractList	= new ArrayList<Contract>();
//副表对象 Contract
@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "FK_APPLY")
ApplyEntity						apply;

fetch理解

在定义它们的时候可以通过fetch属性指定加载方式，有两个值:
FetchType.LAZY：延迟加载
FetchType.EAGER：急加载

JPA+Hibernate利用Criteria

这时会使用到FetchMode,关于setFetchMode:
FetchMode是让两个表建立连接，仅此而已。

对 Hibernate的Criteria 的用法进行总结：(参考：Hibernate中Criteria的完整用法）
Hibernate 设计了 CriteriaSpecification 作为 Criteria 的父接口，提供了 Criteria和DetachedCriteria

Criteria 和 DetachedCriteria 的主要区别

Criteria 和 DetachedCriteria 的主要区别在于创建的形式不一样

• Criteria 是在线的，所以它是由 Hibernate Session 进行创建的；
• DetachedCriteria 是离线的，创建时无需Session，DetachedCriteria 提供了 2 个静态方法 forClass(Class) 或 forEntityName(Name)
• 进行DetachedCriteria 实例的创建。 Spring 的框架提供了getHibernateTemplate().findByCriteria(detachedCriteria) 方法可以很方便地根据DetachedCriteria 来返回查询结果。
• Criteria 和 DetachedCriteria 均可使用 Criterion 和 Projection 设置查询条件。可以设
  置 FetchMode( 联合查询抓取的模式 ) ，设置排序方式。对于 Criteria 还可以设置 FlushModel
  （冲刷 Session 的方式）和 LockMode （数据库锁模式）。

Criterion 和 Projection 进行详细说明。

Criterion 是 Criteria 的查询条件。Criteria 提供了 add(Criterion criterion) 方法来
添加查询条件。

• Criterion 接口的主要实现包括： Example 、 Junction 和 SimpleExpression 。而
  Junction 的实际使用是它的两个子类 conjunction 和 disjunction ，分别是使用 AND 和 OR 操
  作符进行来联结查询条件集合。

• Criterion 的实例可以通过 Restrictions 工具类来创建，Restrictions 提供了大量的静态
  方法，如 eq （等于）、 ge （大于等于）、 between 等来方法的创建 Criterion 查询条件
  （SimpleExpression 实例）。除此之外， Restrictions 还提供了方法来创建 conjunction 和
  disjunction 实例，通过往该实例的 add(Criteria) 方法来增加查询条件形成一个查询条件集合

• 至于 Example 的创建有所不同， Example 本身提供了一个静态方法 create(Object
  entity) ，即根据一个对象（实际使用中一般是映射到数据库的对象）来创建。然后可以设置一些
  过滤条件：

Example exampleUser =Example.create(u)
// 忽略大小写
.ignoreCase() 
// 对 String 类型的属性，无论在那里值在那里都匹配。相当于 %value%
.enableLike(MatchMode.ANYWHERE);

Project 主要是让 Criteria 能够进行报表查询，并可以实现分组。

• Project 主要有
  SimpleProjection 、 ProjectionList 和 Property 三个实现。其中 SimpleProjection 和
  ProjectionList 的实例化是由内建的 Projections 来完成，如提供的 avg 、 count 、 max 、
  min 、 sum 可以让开发者很容易对某个字段进行统计查询。
• Property 是对某个字段进行查询条件的设置，如通过Porperty.forName(“color”).in
  (new String[]{“black”,”red”,”write”}); 则可以创建一个 Project 实例。通过
  criteria 的 add(Project) 方法加入到查询条件中去。

使用 Criteria 进行查询，主要要清晰的是 Hibernate 提供了那些类和方法来满足开发中查
询条件的创建和组装，下面介绍几种用法：

创建一个Criteria 实例

org.hibernate.Criteria接口表示特定持久类的一个查询。Session是 Criteria实例的工厂。

Criteria crit = sess.createCriteria(Cat.class);
crit.setMaxResults(50);
List cats = crit.list();

限制结果集内容

一个单独的查询条件是org.hibernate.criterion.Criterion 接口的一个实例。
org.hibernate.criterion.Restrictions类 定义了获得某些内置Criterion类型的工厂方法。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.between("weight", minWeight, maxWeight) )
.list();

约束可以按逻辑分组。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.add( Restrictions.or(
Restrictions.eq( "age", new Integer(0) ),
Restrictions.isNull("age")
) ).list();

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.in( "name", new String[] { "Fritz", "Izi", "Pk" } ) )
.add( Restrictions.disjunction()
.add( Restrictions.isNull("age") )
.add( Restrictions.eq("age", new Integer(0) ) )
.add( Restrictions.eq("age", new Integer(1) ) )
.add( Restrictions.eq("age", new Integer(2) ) )
) ).list();

Hibernate提供了相当多的内置criterion类型(Restrictions 子类), 但是尤其有用的是可以允许
你直接使用SQL。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.sql("lower({alias}.name) like lower(?)", "Fritz%",Hibernate.STRING) ).list();
{alias}占位符应当被替换为被查询实体的列别名。
Property实例是获得一个条件的另外一种途径。你可以通过调用Property.forName() 创建一个Property。
Property age = Property.forName("age");
List cats = sess.createCriteria(Cat.class)
.add( Restrictions.disjunction()
.add( age.isNull() )
.add( age.eq( new Integer(0) ) )
.add( age.eq( new Integer(1) ) )
.add( age.eq( new Integer(2) ) )
) ).add( Property.forName("name").in( new String[] { "Fritz", "Izi", "Pk" } ) ).list();

结果集排序

你可以使用org.hibernate.criterion.Order来为查询结果排序。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.addOrder( Order.asc("name") )
.addOrder( Order.desc("age") )
.setMaxResults(50).list();

List cats = sess.createCriteria(Cat.class)
.add( Property.forName("name").like("F%") )
.addOrder( Property.forName("name").asc() )
.addOrder( Property.forName("age").desc() )
.setMaxResults(50).list();

关联

你可以使用createCriteria()非常容易的在互相关联的实体间建立 约束。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "F%")
.createCriteria("kittens")
.add( Restrictions.like("name", "F%").list();

注意第二个 createCriteria()返回一个新的 Criteria实例，该实例引用kittens 集合中的元素。
接下来，替换形态在某些情况下也是很有用的。

List cats = sess.createCriteria(Cat.class)
.createAlias("kittens", "kt")
.createAlias("mate", "mt")
.add( Restrictions.eqProperty("kt.name", "mt.name") ).list();

createAlias()并不创建一个新的 Criteria实例。

Cat实例所保存的之前两次查询所返回的kittens集合是 没有被条件预过滤的。如果你希望只获得
符合条件的kittens， 你必须使用returnMaps()。

List cats = sess.createCriteria(Cat.class)
.createCriteria("kittens", "kt")
.add( Restrictions.eq("name", "F%") )
.returnMaps().list();
Iterator iter = cats.iterator();
while ( iter.hasNext() ) {
Map map = (Map) iter.next();
Cat cat = (Cat) map.get(Criteria.ROOT_ALIAS);
Cat kitten = (Cat) map.get("kt");
}

动态关联抓取

你可以使用setFetchMode()在运行时定义动态关联抓取的语义。

List cats = sess.createCriteria(Cat.class)
.add( Restrictions.like("name", "Fritz%") )
.setFetchMode("mate", FetchMode.EAGER)
.setFetchMode("kittens", FetchMode.EAGER).list();
这个查询可以通过外连接抓取mate和kittens。

查询示例

org.hibernate.criterion.Example类允许你通过一个给定实例 构建一个条件查询。

Cat cat = new Cat();
cat.setSex('F');
cat.setColor(Color.BLACK);
List results = session.createCriteria(Cat.class)
.add( Example.create(cat) ).list();

版本属性、标识符和关联被忽略。默认情况下值为null的属性将被排除。
可以自行调整Example使之更实用。

Example example = Example.create(cat)
.excludeZeroes() //exclude zero valued properties
.excludeProperty("color") //exclude the property named "color"
.ignoreCase() //perform case insensitive string comparisons
.enableLike(); //use like for string comparisons
List results = session.createCriteria(Cat.class)
.add(example).list();

甚至可以使用examples在关联对象上放置条件。

List results = session.createCriteria(Cat.class)
.add( Example.create(cat) )
.createCriteria("mate")
.add( Example.create( cat.getMate() ) ).list();

投影(Projections)、聚合（aggregation）和分组（grouping）

org.hibernate.criterion.Projections是 Projection 的实例工厂。我们通过调用
setProjection()应用投影到一个查询。

List results = session.createCriteria(Cat.class)
.setProjection( Projections.rowCount() )
.add( Restrictions.eq("color", Color.BLACK) ).list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount() )
.add( Projections.avg("weight") )
.add( Projections.max("weight") )
.add( Projections.groupProperty("color") )).list();

在一个条件查询中没有必要显式的使用 “group by” 。某些投影类型就是被定义为 分组投影，他
们也出现在SQL的group by子句中。
可以选择把一个别名指派给一个投影，这样可以使投影值被约束或排序所引用。下面是两种不同的

实现方式：

List results = session.createCriteria(Cat.class)
.setProjection( Projections.alias( Projections.groupProperty("color"), "colr" ) )
.addOrder( Order.asc("colr") ).list();

List results = session.createCriteria(Cat.class)
.setProjection( Projections.groupProperty("color").as("colr") )
.addOrder( Order.asc("colr") ).list();

alias()和as()方法简便的将一个投影实例包装到另外一个 别名的Projection实例中。简而言之，

当你添加一个投影到一个投影列表中时 你可以为它指定一个别名：

List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount(), "catCountByColor" )
.add( Projections.avg("weight"), "avgWeight" )
.add( Projections.max("weight"), "maxWeight" )
.add( Projections.groupProperty("color"), "color" ))
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") ).list();

List results = session.createCriteria(Domestic.class, "cat")
.createAlias("kittens", "kit")
.setProjection( Projections.projectionList()
.add( Projections.property("cat.name"), "catName" )
.add( Projections.property("kit.name"), "kitName" ))
.addOrder( Order.asc("catName") )
.addOrder( Order.asc("kitName") ).list();

也可以使用Property.forName()来表示投影：

List results = session.createCriteria(Cat.class)
.setProjection( Property.forName("name") )
.add( Property.forName("color").eq(Color.BLACK) ).list();
List results = session.createCriteria(Cat.class)
.setProjection( Projections.projectionList()
.add( Projections.rowCount().as("catCountByColor") )
.add( Property.forName("weight").avg().as("avgWeight") )
.add( Property.forName("weight").max().as("maxWeight") )
.add( Property.forName("color").group().as("color" ))
.addOrder( Order.desc("catCountByColor") )
.addOrder( Order.desc("avgWeight") ).list();

离线(detached)查询和子查询

DetachedCriteria类使你在一个session范围之外创建一个查询，并且可以使用任意的 Session来
执行它。

DetachedCriteria query = DetachedCriteria.forClass(Cat.class)
.add( Property.forName("sex").eq('F') );
//创建一个Session
Session session = .;
Transaction txn = session.beginTransaction();
List results = query.getExecutableCriteria(session).setMaxResults(100).list();
txn.commit();
session.close();

DetachedCriteria也可以用以表示子查询。条件实例包含子查询可以通过 Subqueries或者
Property获得。

DetachedCriteria avgWeight = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight").avg() );
session.createCriteria(Cat.class)
.add( Property.forName("weight).gt(avgWeight) ).list();
DetachedCriteria weights = DetachedCriteria.forClass(Cat.class)
.setProjection( Property.forName("weight") );
session.createCriteria(Cat.class)
.add( Subqueries.geAll("weight", weights) ).list();

相互关联的子查询也是有可能的：

DetachedCriteria avgWeightForSex = DetachedCriteria.forClass(Cat.class, "cat2")
.setProjection( Property.forName("weight").avg() )
.add( Property.forName("cat2.sex").eqProperty("cat.sex") );
session.createCriteria(Cat.class, "cat")
.add( Property.forName("weight).gt(avgWeightForSex) ).list();

项目示例

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.cy</groupId>
  <artifactId>jpaCombineHibernate</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  
  <dependencies>
        <!-- junit -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
 
        <!-- hibernate对jpa的支持包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.0.7.Final</version>
        </dependency>
 
        <!-- c3p0 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-c3p0</artifactId>
            <version>5.0.7.Final</version>
        </dependency>
 
        <!-- log日志 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
 
        <!-- Mysql and MariaDB -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
               <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

设计表

create table (
int id primary key not null comment '主键Id',
content varchar(255) comment '内容',
create_time timstamp comment '创建时间',
read_count varchar(255) comment '读取行数',
title varchar(32) comment '标题',
user varchar(100) comment '用户'
)

创建对象：

package com.cy.pj.pojo;

import java.util.Date;

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

@Entity
@Table(name = Article.TABLE)
public class Article {
	
	public static final String TABLE = "spider";
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Integer id;
	@Column(name = "content")
	private String content;
	@Column(name = "created_time")
	private Date createdTime;
	@Column(name="read_count")
	private Integer readCount;
	@Column(name="title")
	private String title;
	@Column(name="user")
	private String user;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getContent() {
		return content;
	}
	public void setContent(String content) {
		this.content = content;
	}
	public Date getCreatedTime() {
		return createdTime;
	}
	public void setCreatedTime(Date createdTime) {
		this.createdTime = createdTime;
	}
	public Integer getReadCount() {
		return readCount;
	}
	public void setReadCount(Integer readCount) {
		this.readCount = readCount;
	}
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	public String getUser() {
		return user;
	}
	public void setUser(String user) {
		this.user = user;
	}
	@Override
	public String toString() {
		return "Article [id=" + id + ", content=" + content + ", createdTime=" + createdTime + ", readCount="
				+ readCount + ", title=" + title + ", user=" + user + "]";
	}
	
}

配置文件：persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <!--配置持久化单元
        name：持久化单元名称
        transaction-type：事务类型
             RESOURCE_LOCAL：本地事务管理
             JTA：分布式事务管理 -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--配置JPA规范的服务提供商 -->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <!-- 数据库驱动 -->
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />
            <!-- 数据库地址 -->
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test" />
            <!-- 数据库用户名 -->
            <property name="javax.persistence.jdbc.user" value="root" />
            <!-- 数据库密码 -->
            <property name="javax.persistence.jdbc.password" value="root" />
 
            <!--jpa提供者的可选配置：我们的JPA规范的提供者为hibernate，所以jpa的核心配置中兼容hibernate的配 -->
            <property name="hibernate.show_sql" value="true" />
            <property name="hibernate.format_sql" value="true" />
            <property name="hibernate.hbm2ddl.auto" value="create" />
        </properties>
    </persistence-unit>
</persistence>

编写测试类：

package com.cy.pj.demo;

import java.util.Date;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import org.junit.Test;

import com.cy.pj.pojo.Article;

public class JpaDemo {
	
	@Test
	public void test1() {
		EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
		EntityManager entityManager = factory.createEntityManager();
		EntityTransaction transaction = entityManager.getTransaction();
		transaction.begin();
		Article article = new Article();
		article.setContent("this is content");
		article.setCreatedTime(new Date());
		article.setReadCount(0);
		article.setTitle("this is title");
		article.setUser("this is user");
		entityManager.persist(article);
		transaction.commit();
		entityManager.close();
		factory.close();
	}
}

​