一. 数据库数据表的创建
CREATE DATABASE IF NOT EXISTS spring_data;
USE spring_data;
/*创建客户表*/
CREATE TABLE cst_customer (
cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
PRIMARY KEY (`cust_id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
二. 工程的创建
1. 导入依赖
<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>
2. 创建数据库中客户表的实体类
package com.cast.domain;
import java.io.Serializable;
import javax.persistence.*;
/**
* 封装数据库中表的实体类
*/
@Entity //该类是一个数据库表实体封装类
@Table(name = "cst_customer") //指定数据库中对应表名
public class Customer implements Serializable {
@Id //主键
@GeneratedValue(strategy = GenerationType.IDENTITY) //主键自增
@Column(name = "cust_id") //数据库表中的列名
private Long custId; //客户的主键
@Column(name = "cust_name")
private String custName; //客户名称
@Column(name="cust_source")
private String custSource; //客户来源
@Column(name="cust_level")
private String custLevel; //客户级别
@Column(name="cust_industry")
private String custIndustry; //客户所属行业
@Column(name="cust_phone")
private String custPhone; //客户的联系方式
@Column(name="cust_address")
private String custAddress; //客户地址
// getter setter 方法....
// toString() 方法....
}
ps:
* @Id: 声明主键的配置
* @GeneratedValue: 配置主键的生成策略
* strategy
* GenerationType.IDENTITY :自增,mysql
* * 底层数据库必须支持自动增长(底层数据库支持的自动增长方式,对id自增)
* GenerationType.SEQUENCE : 序列,oracle
* * 底层数据库必须支持序列
* GenerationType.TABLE : jpa提供的一种机制,通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO : 由程序自动的帮助我们选择主键生成策略
* @Column: 配置属性和字段的映射关系
* name:数据库表中字段的名称
3. 建立配置文件
必须在 resources 下创建一个名为 META-INF 的文件夹,在此文件夹下创建一个名为 persistence.xml 的配置文件:
<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--jpa的实现方式 -->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<properties>
<!-- 配置连接数据库的信息 -->
<property name="javax.persistence.jdbc.user" value="root"/>
<property name="javax.persistence.jdbc.password" value="root"/>
<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/spring_data"/>
<!-- 配置jpa实现方(hibernate)的配置信息 -->
<property name="hibernate.show_sql" value="true" />
<!-- value 的值为 create 表示删除原有的表再创建一张新表做操作 -->
<!-- value 的值为 update 表示在原有的表上继续做操作 -->
<property name="hibernate.hbm2ddl.auto" value="update" />
</properties>
</persistence-unit>
</persistence>
4. 创建工具类
package com.cast.utils;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
/**
* 解决实体管理器工厂的浪费资源和耗时问题
*/
public class JpaUtil {
private static EntityManagerFactory factory;
static {
//加载配置文件,创建entityManagerFactory 参数与配置文件中一致
factory = Persistence.createEntityManagerFactory("myJpa");
}
/**
* 获取EntityManager对象
*/
public static EntityManager getEntityManager() {
return factory.createEntityManager();
}
}
三. Jpa测试方法的编写
* Jpa的操作步骤
* 1.加载配置文件创建工厂(实体管理器工厂)对象
* 2.通过实体管理器工厂获取实体管理器
* 3.获取事务对象,开启事务
* 4.完成增删改查操作
* 5.提交事务(回滚事务)
* 6.释放资源
1. 保存
@Test
public void testSave() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//创建一个新对象并设置对象属性
Customer customer = new Customer();
customer.setCustName("张三");
customer.setCustAddress("湖北省武汉市");
customer.setCustIndustry("it行业");
customer.setCustLevel("一级");
customer.setCustPhone("1343434343");
customer.setCustSource("网络");
//4.执行保存操作
em.persist(customer);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}
2. 根据 id 查询
立即加载
@Test
public void testFindOne() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager entityManager = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.执行根据 id 查询操作 - 立即加载
Customer customer = entityManager.find(Customer.class, 1L);
System.out.print(customer);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
entityManager.close();
}
延迟加载(懒加载)
@Test
public void testReference() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager entityManager = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.执行根据 id 查询操作 - 延迟加载(懒加载)
Customer customer = entityManager.getReference(Customer.class, 1L);
System.out.print(customer);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
entityManager.close();
}
3. 根据 id 修改
@Test
public void testUpdate() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager entityManager = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.执行根据 id 修改操作
//先查询
Customer customer = entityManager.find(Customer.class, 1L);
//再修改
customer.setCustIndustry("it教育");
//最后更新
entityManager.merge(customer);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
entityManager.close();
}
4. 根据 id 删除
@Test
public void testRemove() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager entityManager = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = entityManager.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.执行根据id删除操作
//先查找
Customer customer = entityManager.find(Customer.class, 1L);
//再删除
entityManager.remove(customer);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
entityManager.close();
}
四. Jpql语句测试方法的编写
1. 查询全部
@Test
public void testFindAll() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.查询全部
String jpql = "from Customer";
//创建Query查询对象,query对象才是执行jqpl的对象
Query query = em.createQuery(jpql);
//发送查询,并封装结果集
List list = query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}
2. 倒序查询
@Test
public void testOrders() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.倒序查询
String jpql = "from Customer order by custId desc";
Query query = em.createQuery(jpql);//创建Query查询对象,query对象才是执行jqpl的对象
//发送查询,并封装结果集
List list = query.getResultList();
for (Object obj : list) {
System.out.println(obj);
}
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}
3. 聚合查询
@Test
public void testCount() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.统计查询
String jpql = "select count(custId) from Customer";
Query query = em.createQuery(jpql);
Object result = query.getSingleResult();
System.out.println(result);
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}
4. 分页查询
@Test
public void testPaged() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.分页查询
String jpql = "from Customer";
Query query = em.createQuery(jpql);
//起始索引
query.setFirstResult(0);
//每页查询的条数
query.setMaxResults(2);
List list = query.getResultList();
for(Object obj : list) {
System.out.println(obj);
}
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}
5. 条件查询
@Test
public void testCondition() {
//1.加载配置文件创建工厂(实体管理器工厂)对象
//2.通过实体管理器工厂获取实体管理器
EntityManager em = JpaUtil.getEntityManager();
//3.获取事务对象,开启事务
EntityTransaction tx = em.getTransaction(); //获取事务对象
tx.begin(); //开启事务
//4.条件查询
String jpql = "from Customer where custName like ? ";
Query query = em.createQuery(jpql);
query.setParameter(1, "张%");
List list = query.getResultList();
for(Object obj : list) {
System.out.println(obj);
}
//5.提交事务(回滚事务)
tx.commit();
//6.释放资源
em.close();
}