第一步,在maven中导入坐标依赖
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.hibernate.version>5.0.7.Final</project.hibernate.version>
</properties>
<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>${project.hibernate.version}</version>
</dependency>
<!-- c3p0 -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-c3p0</artifactId>
<version>${project.hibernate.version}</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>
第二步.配置jpa的核心配置文件
在java工程的src路径下创建一个名为META-INF的文件夹,在此文件夹下创建一个名为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/ssh" />
<!-- 数据库用户名 -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- 数据库密码 -->
<property name="javax.persistence.jdbc.password" value="111111" />
<!--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>
第三步. 编写实体类和数据库表的映射配置
/**
* * 所有的注解都是使用JPA的规范提供的注解,
* * 所以在导入注解包的时候,一定要导入javax.persistence下的
*/
@Entity //声明实体类
@Table(name="cst_customer") //建立实体类和表的映射关系
public class Customer {
@Id//声明当前私有属性为主键
@GeneratedValue(strategy=GenerationType.IDENTITY) //配置主键的生成策略
@Column(name="cust_id") //指定和表中cust_id字段的映射关系
private Long custId;
@Column(name="cust_name") //指定和表中cust_name字段的映射关系
private String custName;
@Column(name="cust_source")//指定和表中cust_source字段的映射关系
private String custSource;
@Column(name="cust_industry")//指定和表中cust_industry字段的映射关系
private String custIndustry;
@Column(name="cust_level")//指定和表中cust_level字段的映射关系
private String custLevel;
@Column(name="cust_address")//指定和表中cust_address字段的映射关系
private String custAddress;
@Column(name="cust_phone")//指定和表中cust_phone字段的映射关系
private String custPhone;
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public String getCustIndustry() {
return custIndustry;
}
public void setCustIndustry(String custIndustry) {
this.custIndustry = custIndustry;
}
public String getCustLevel() {
return custLevel;
}
public void setCustLevel(String custLevel) {
this.custLevel = custLevel;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
}
NOTICE:如果实体类中的属性名与表中的字段名相同则可省略@Column中的name属性
第四步 实现保存操作
在单元测试模块创建测试类
import com.itcast.pojo.Customer;
import org.junit.Test;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
public class JpaTest {
@Test
//测试保存一个客户信息到数据库中
public void save(){
//加载配置文件创建工厂(实体管理器工厂)对象
EntityManagerFactory factory= Persistence.createEntityManagerFactory("myJpa");
//通过工厂对象获取实体管理器
EntityManager entityManager = factory.createEntityManager();
//通过实体管理器获取事务对象,开启事务
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();//开启事务
try {
//通过实体管理器完成crud操作
Customer customer=new Customer();
customer.setCustName("1111");
customer.setCustIndustry("2222");
entityManager.persist(customer);//完成保存操作
//提交事务
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
//出现异常,回滚事务
transaction.rollback();
}
//释放资源
entityManager.close();
factory.close();
}
}
二.JPA中的主键生成策略
通过annotation(注解)来映射hibernate实体的,基于annotation的hibernate主键标识为@Id, 其生成规则由@GeneratedValue设定的.这里的@id和@GeneratedValue都是JPA的标准用法。
JPA提供的四种标准用法为TABLE,SEQUENCE,IDENTITY,AUTO。
具体说明如下:
1.IDENTITY:主键由数据库自动生成(主要是自动增长型),需要底层数据库支持主键的自增,主要应用于mysql
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long custId;
2.SEQUENCE:根据底层数据库的序列来生成主键,条件是数据库支持序列。主要应用于orcale数据库
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator="payablemoney_seq")
@SequenceGenerator(name="payablemoney_seq", sequenceName="seq_payment")
private Long custId;
3.AUTO:主键由程序控制
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long custId;
4.TABLE:使用一个特定的数据库表格来保存主键
@Id
@GeneratedValue(strategy = GenerationType.TABLE, generator="payablemoney_gen")
@TableGenerator(name = "pk_gen",
table="tb_generator",
pkColumnName="gen_name",
valueColumnName="gen_value",
pkColumnValue="PAYABLEMOENY_PK",
allocationSize=1
)
private Long custId;
三.JPA的API介绍
3.1 Persistence对象
Persistence对象主要作用是用于获取EntityManagerFactory对象的 。通过调用该类的createEntityManagerFactory静态方法,根据配置文件中持久化单元名称创建EntityManagerFactory。
//1. 创建 EntitymanagerFactory
String unitName = "myJpa";
EntityManagerFactory factory= Persistence.createEntityManagerFactory(unitName);
3.2 EntityManagerFactory
EntityManagerFactory 接口主要用来创建 EntityManager 实例
//2.创建实体管理类
EntityManager em = factory.createEntityManager();
由于EntityManagerFactory 是一个线程安全的对象(即多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题),并且EntityManagerFactory 的创建极其浪费资源,所以在使用JPA编程时,我们可以对EntityManagerFactory 的创建进行优化,只需要做到一个工程只存在一个EntityManagerFactory 即可
3.3 EntityManager
在 JPA 规范中, EntityManager是完成持久化操作的核心对象。实体类作为普通 java对象,只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
我们可以通过调用EntityManager的方法完成获取事务,以及持久化数据库的操作
方法说明:
getTransaction : 获取事务对象
persist : 保存操作
merge : 更新操作
remove : 删除操作
find/getReference : 根据id查询
3.4 EntityTransaction
在 JPA 规范中, EntityTransaction是完成事务操作的核心对象,对于EntityTransaction在我们的java代码中承接的功能比较简单
begin:开启事务
commit:提交事务
rollback:回滚事务
四.抽取JPAUtil工具类
静态代码块的模式
//Jpa的工具包
public class JPaUtil {
private static EntityManagerFactory entityManagerFactory;
static {
// 注意:该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
entityManagerFactory= Persistence.createEntityManagerFactory(“myJpa”);
}
//定义一个方法获取entitymanager对象
public static EntityManager getEntityManager(){
EntityManager entityManager = entityManagerFactory.createEntityManager();
return entityManager;
}
}
五.JPA中的复杂查询
JPQL全称Java Persistence Query Language
基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言,旨在以面向对象表达式语言的表达式,将SQL语法和简单查询语义绑定在一起•使用这种语言编写的查询是可移植的,可以被编译成所有主流数据库服务器上的SQL。
其特征与原生SQL语句类似,并且完全面向对象,通过类名和属性访问,而不是表名和表的属性。
查询所有客户
//测试查询全部客户
@Test
public void selectAll(){
EntityManager entityManager = JPaUtil.getEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
try {
String jpql = "from Customer";
Query query = entityManager.createQuery(jpql);
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
entityManager.close();
}
排序查询所有客户
//测试降序查询全部客户
@Test
public void selectAllDesc(){
EntityManager entityManager = JPaUtil.getEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
try {
String jpql = "from Customer order by custId desc";
Query query = entityManager.createQuery(jpql);
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
entityManager.close();
}
统计查询所有客户
//测试统计查询全部客户
@Test
public void selectAllCount(){
EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
transaction.begin();
try {
String jpql = "select count(custId) from Customer";
Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
long singleResult = (long)query.getSingleResult();
System.out.println(singleResult);
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
entityManager.close();
}
分页查询所有用户
//测试分页查询全部客户
@Test
public void selectAllByPage(){
EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
transaction.begin();
try {
String jpql = "from Customer";
Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
query.setFirstResult(0);//起始索引
query.setMaxResults(5);//每页查询的条数
List<Customer> resultList = query.getResultList();
for (Customer customer : resultList) {
System.out.println(customer);
}
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
entityManager.close();
}
根据条件查询用户
//条件查询
@Test
public void selectCondition(){
EntityManager entityManager = JPaUtil.getEntityManager();//获取实体管理器对象
EntityTransaction transaction = entityManager.getTransaction();//获取事务管理器对象
transaction.begin();
try {
String jpql = "from Customer where custId= ?";
Query query = entityManager.createQuery(jpql);//根据sql语句创建query查询对象
query.setParameter(1,2l);//给参数赋值
List<Customer> resultList = query.getResultList();
for (Customer customer : resultList) {
System.out.println(customer);
}
transaction.commit();
} catch (Exception e) {
e.printStackTrace();
transaction.rollback();
}
entityManager.close();
}