SpringData学习笔记
传统的JDBC操作
传统的jdbc操作 ， 操作比较繁琐还需要为占位符赋值
解决方案： 将JDBC操作封装到一个工具类中，
将sql 语句相关操作封装到一个对象中 。 大部分的语句都是固定的 ， 我们只需要将变动的地方作为参数传入
但是这个地方要注意 ， 建立数据表与实体类的连接 ， 建立列于字段的连接
ORM思想：
主要目的:操作实体类就相当于操作数据库表
建立两个映射关系:
- 实体类和表的映射关系
- 实体类中属性和表中字段的映射关系不再重点关注: sql语句
实现了ORM思想的框架: mybatis， hibernatel
hibernate是一个开放源代码的对象关系映射框架，它对JDBc进行了非常轻量级的对象封装，它将PoJo与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成sQL 语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
JPA规范
jpa规范,内部是由接口和抽象类组成
JPA不干活 ，真正干活的是根据这个规范实现的生产厂商
规范的好处 ， JPA提供了一个固定的接口 ，具体的实现交给 各个厂家来实现。这样在切换 数据库厂家的时候， 就不用修改Java代码 ， 只需要修改一下配置就可以。
JPA 通过注解 描述 实体类 与 数据库表 之间的映射关系 ， 并将运行期的实体对象持久化到数据库中
JPA基本操作
Maven项目案例
案例：客户的增删改查
搭建环境的过程
1.创建maven工程导入坐标
2.需要配置jpa的核心配置文件
3.编写客户的实体类
4.配置实体类和表,类中属性和表中字段的映射关系
5.保存客户到数据库中
1.创建maven工程导入坐标
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<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>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.12.1</version>
</dependency>
<!-- Mysql and MariaDB -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.16</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
</dependencies>
2.需要配置jpa的核心配置文件
- 位置:配置到类路径下的一个叫做 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:持久化单元名称
transaction-type:事务管理的方式
JTA:分布式事务管理 ，如果不同的表分散到不同的数据库， 一个数据库就对应一个数据库连接，就必须使用分布式事务管理
RESOURCE_LOCAL:本地事务管理
-->
<persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
<!--jpa的实现方式 : Hibernate实现-->
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<!--可选配置：配置jpa实现方式的配置信息-->
<properties>
<!-- 数据库信息
用户名，javax.persistence.jdbc.user
密码， javax.persistence.jdbc.password
驱动， javax.persistence.jdbc.driver
数据库地址 javax.persistence.jdbc.url
-->
<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.cj.jdbc.Driver"/>
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://192.168.20.40/jpa?characterEncoding=utf8&useSSL=false&zeroDateTimeBehavior=convertToNull&serverTimezone=GMT"/>
<!--配置jpa实现方(hibernate)的配置信息
显示sql ： false|true
自动创建数据库表 ： hibernate.hbm2ddl.auto
create : 程序运行时创建数据库表（如果有表，先删除表再创建）
update ：程序运行时创建表（如果有表，不会创建表）
none ：不会创建表
-->
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
</properties>
</persistence-unit>
</persistence>
3.编写客户的实体类 配置实体类和表,类中属性和表中字段的映射关系
没有 get / set 方法 不影响 表的创建
@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "cst_customer")
@Entity
public class Customer {
/**
* @Id：声明主键的配置
* @GeneratedValue:配置主键的生成策略
* strategy
* GenerationType.IDENTITY ：自增，mysql
* * 底层数据库必须支持自动增长（底层数据库支持的自动增长方式，对id自增）
* GenerationType.SEQUENCE : 序列，oracle
* * 底层数据库必须支持序列
* GenerationType.TABLE : jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO ： 由程序自动的帮助我们选择主键生成策略
* @Column:配置属性和字段的映射关系
* name：数据库表中字段的名称
*/
@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;//客户地址
}
4.保存客户到数据库中 , 测试
public class JpaTest {
/**
* 1.加载配置文件创建工厂（实体管理器工厂）对象2.通过实体管理器工厂获取实体管理器
* 3.获取事务对象,开启事务
* 4.完成增册改查操催
* 5.提交事务（回滚事务)6.释放资源
*/
@Test
public void testSave(){
// 1.加载配置文件创建工厂（实体管理器工厂）对象
EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
// 2.通过实体管理器工厂获取实体管理器
EntityManager em = factory.createEntityManager();
// 3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();// 开启事务
// 4.完成增删改查操作
Customer customer = new Customer();
customer.setCustName("传智播客");
customer.setCustIndustry("教育");
// 保存
//Hibernate: insert into cst_customer (cust_address, cust_industry, cust_level, cust_name, cust_phone, cust_source) values (?, ?, ?, ?, ?, ?)
em.persist(customer);
// 5.提交事务
tx.commit();
// 6.释放资源
em.close();
factory.close();
}
}
JPA的操作步骤
1. 加载配置文件创建实体管理工厂
Persistence对象:
作用: 用来根据持久化单元名称 , 创建实体管理器工厂 ,
里面有一个静态方法 : createEntityManagerFactory(持久化单元名称),
2. 根据实体管理工厂，创建实体管理器
EntityManagerFactory 接口 : 主要用来创建 EntityManager 实例,
方法: createEntityManager
内部维护了很多内容:
- 维护了 数据库信息
- 维护了 缓存信息
- 维护了 所有的实体管理器对象
- 在创建 EntityManagerFactory 的过程中 会根据配置创建数据库表
EntityManagerFactory 的创建过程比较浪费资源
特点: 是一个线程安全的对象
多个线程访问同一个EntityManagerFactory 对象不会有线程安全问题
思考:如何解决EntityManagerFactory 创建过程浪费资源比较耗时的问题
解决方法 : 使用静态代码块的方式来创建 EntityManagerFactory 对象
创建事务对象，开启事务
EntityManager对象 : 实体管理器
EntityManager是完成持久化操作的核心对象
实体类作为普通 java对象，只有在调用 EntityManager将其持久化后才会变成持久化对象。EntityManager对象在一组实体类与底层数据源之间进行 O/R 映射的管理。它可以用来管理和更新 Entity Bean, 根椐主键查找 Entity Bean, 还可以通过JPQL语句查询实体。
getTransaction : 获取事务对象
persist ： 保存操作
merge ： 更新操作
remove ： 删除操作
find/getReference ： 根据id查询
通过 getTransaction 方法获取 EntityTransaction 对象
begin : 开启事务
commit : 提交事务
rollback : 事务回滚
增删改查操作
提交事务
释放资源
解决实体管理器工厂的浪费资源和耗时问题 ,静态代码块封装工具类
public final class JpaUtils {
/**
* 第一次访问 getEntityManager 方法 ,通过静态代码块创建一个 factory 对象,
* 载调用方法创建一个 entityManager 对象
* 第二次访问 getEntityManager 方法 ,直接通过已经创建好的 factory 对象,
* 再创建 一个 entityManager 对象
*/
// JPA的实体管理器工厂：相当于Hibernate的SessionFactory
//一个静态的成员变量 , 可以提取出来作为公有的属性
private static EntityManagerFactory factory;
// 使用静态代码块为公有属性赋值
static {
// 注意：该方法参数必须和persistence.xml中persistence-unit标签name属性取值一致
factory = Persistence.createEntityManagerFactory("myPersistUnit");
}
/**
* 使用管理器工厂生产一个管理器对象
* 获取EntityManager 对象
* @return
*/
public static EntityManager getEntityManager() {
// EntityManager entityManager = factory.createEntityManager();
return factory.createEntityManager();
}
}
工具类的使用验证
@Test
public void testSave(){
// 1.加载配置文件创建工厂（实体管理器工厂）对象
// EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
// 2.通过实体管理器工厂获取实体管理器
// EntityManager em = factory.createEntityManager();
//使用工具类创建 EntityManager 对象
EntityManager em = JpaUtils.getEntityManager();
// 3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();
tx.begin();// 开启事务
// 4.完成增删改查操作
Customer customer = new Customer();
customer.setCustName("传智播客");
customer.setCustIndustry("教育");
// 保存
em.persist(customer);
// 5.提交事务
tx.commit();
// 6.释放资源
em.close();
//因为 EntityManagerFactory 是公共的 , 所以不用关闭
//factory.close();
}
entityManager方法中简单的增删改查
- persist 添加
- find 立即查询 / getTransaction 延迟查询
- remove 删除
- merge 修改
persist 添加 : 创建实体对象 ,赋值 , 然后执行persist方法, 执行insert语句
@Test
public void testPersist(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
/**
* 创建实体对象 ,赋值 , 然后执行persist方法, 执行insert语句
*/
Customer customer = new Customer();
customer.setCustName("黑马教育");
customer.setCustIndustry("学院");
em.persist(customer);
tx.commit();
em.close();
}
find 立即查询 ： 根据id 查询客户 立即加载
@Test
public void testfind(){
/**
* find方法 : 立即查询
* 获取的是当前对象本身
* 在调用find方法的时候就会发送sql语句查询数据库
*/
//获取entityManager, 和开启事务都是固定的
EntityManager entityManager = JpaUtils.getEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
Customer customer = entityManager.find(Customer.class, 1L);
System.out.println(customer);
//提交事务, 关闭entityManager也是固定的
transaction.commit();
entityManager.close();
}
getTransaction 延迟查询: 根据id 查询客户 延迟加载
推荐使用 延迟加载 防止出现了定义但是没有使用 浪费资源的情况
@Test
public void testGetReference(){
/**
* getReference 方法 : 延迟加载
* 获取的是一个动态代理对象
* 调用 getReference 方法不会立即发送sql语句查询数据库
* 当要使用查询结果对象的时候才会发送sql查询语句
*/
EntityManager entityManager = JpaUtils.getEntityManager();
EntityTransaction transaction = entityManager.getTransaction();
transaction.begin();
Customer reference = entityManager.getReference(Customer.class, 1L);
transaction.commit();
entityManager.close();
}
remove 删除 : 删除对象 , 先把对象查询出来 ,然后再删除对象
必须数据库中查询出来的的持久化对象
@Test
// 删除
public void testRemove(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
/**
* remove方法删除的是一个对象
* 所以使用的时候要先根据id 将对象查询出来然后再进行删除
*/
Customer customer = em.getReference(Customer.class, 1L); //先查出来对象
em.remove(customer); //在删除对象
tx.commit();
em.close();
}
merge 修改 : 先查询 , 然后修改对象属性, 最后 执行merge方法
@Test
public void testUpdate(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
/**
* merge方法 参数也是对象
* 要进行修改操作, 先查询出对象, 然后修改对象属性, 最后用merge方法执行update语句
*/
Customer customer = em.getReference(Customer.class, 3L);
customer.setCustIndustry("餐饮");
em.merge(customer);
tx.commit();
em.close();
}
JPA中的复杂查询（JPQL）
JPQL 与 原生SQL语句类似 , 但是完全面向对象,通过类名和属性进行访问, 而不是表名和表的列名
- sql : 查询表和表中的字段
- jpql : 查询实体类和类中的属性
- jpql 与 sql 语法相似
使用JPQL需要先用EntityManager 对象的createQuery方法获取Query 对象
然后用Query的对象去调用具体的执行方法
//定于 jpql 语句
String jpql = "from Customer";
//获取query 对象
Query query = em.createQuery(jpql);
//调用 query 的具体方法
List resultList = query.getResultList();
query对象方法
getResultList() 获取结果集
getSingleResult() 获取单一结果
setFirstResult(1); 设置分页 起始索引 ,索引从0开始
setMaxResults(3); 设置分页 查询的条数
setParameter(1,“黑马%”) 设置占位符的参数
1. 查询全部
@Test
public void testPersist(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
/**
* 创建jpql 语句
* 创建Query 对象, query才是执行jpql的
* 调用query对象的 getResultList方法
*/
String jpql = "from Customer";
Query query = em.createQuery(jpql);
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
tx.commit();
em.close();
}
2. 排序,倒序
@Test
public void testOrderBy(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String jpql = "from Customer order by custId desc";
Query query = em.createQuery(jpql);
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
tx.commit();
em.close();
}
3. 统计查询
JPQL中不能写select * 但是可以写 select 相关的函数
@Test
public void testCount(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String jpql = "select count(custId) from Customer ";
Query query = em.createQuery(jpql);
Object singleResult = query.getSingleResult();
System.out.println(singleResult);
tx.commit();
em.close();
}
4. 分页查询
@Test
public void testPrage(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
/**
* select * from cst_customer limit (0,2)
* 先设置查询所有 , 然后 设置起始索引 和 查询条数
*/
String jpql = "from Customer"; //查询所有
Query query = em.createQuery(jpql);
query.setFirstResult(1); //设置起始索引 ,索引从0开始
query.setMaxResults(3); //设置查询的条数
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
tx.commit();
em.close();
}
5. 条件查询
@Test
public void testWhere(){
EntityManager em = JpaUtils.getEntityManager();
EntityTransaction tx = em.getTransaction();
tx.begin();
String jpql = "from Customer where custName like ?"; //查询所有
Query query = em.createQuery(jpql);
query.setParameter(1,"黑马%"); //设置占位符参数
List resultList = query.getResultList();
for (Object o : resultList) {
System.out.println(o);
}
tx.commit();
em.close();
}
Spring Data JPA
Spring Data JPA是Spring 基于ORM框架、JPA规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展!学习并使用Spring Data JPA可以极大提高开发效率!
Spring Data JPA 让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现,在实际的工作工程中，推荐使用Spring Data JPA + ORM(如: hibernate）完成操作，这样在切换不同的ORM框架时提供了极大的方便，同时也使数据库层操作更加简单，方便解耦。
SpringData Jpa极大简化了数据库访问层代码。如何简化的呢?使用了 springDataJpa.我们的dao层中只需要写接口，就自动具有了增删改查、分页查询等方法。
JPA是一套规范，内部是有接口和抽象类组成的。hibernate是一套成熟的ORM框架，而且Hibernate实现了JPA规范，所以也可以称hibernate为JPA的一种实现方式，我们使用JPA的API编程，意味着站在更高的角度上看待问题（面向接口编程）。
Spring Data JPA是Spring提供的一套对JPA操作更加高级的封装，是在JPA规范下的专门用来进行数据持久化的解决方案。
一、入门案例
案例:客户的基本cRUDi.
搭建环境
- 创建工程导入坐标
- 配置spring的配置文件
编写实体类(customer) ，使用jpa注解配置映射关系ii.编写一个符合springDataJpa的dao层接口
新建Maven项目
环境搭建
导入依赖 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>jpa</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.version>4.2.4.RELEASE</spring.version>
<hibernate.version>5.0.7.Final</hibernate.version>
<slf4j.version>1.7.30</slf4j.version>
<log4j.version>2.12.1</log4j.version>
<c3p0.version>0.9.1.2</c3p0.version>
<mysql.version>8.0.16</mysql.version>
</properties>
<dependencies>
<!-- junit单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- spring beg -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- spring end -->
<!-- hibernate beg -->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-validator</artifactId>
<version>5.2.1.Final</version>
</dependency>
<!-- hibernate end -->
<!-- c3p0 beg -->
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>${c3p0.version}</version>
</dependency>
<!-- c3p0 end -->
<!-- log end -->
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.9.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- el beg 使用spring data jpa 必须引入 -->
<dependency>
<groupId>javax.el</groupId>
<artifactId>javax.el-api</artifactId>
<version>2.2.4</version>
</dependency>
<dependency>
<groupId>org.glassfish.web</groupId>
<artifactId>javax.el</artifactId>
<version>2.2.4</version>
</dependency>
<!-- el end -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
</dependencies>
</project>
SPringData 与 JPA 配置
在resources文件下 ,新建 applicationContext.xml配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/data/jpa
http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">
<!--spring 和 spring data jpa 的配置-->
<!--1.创建entityManagerFactory对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!-- 实体类所在包的路径-->
<property name="packagesToScan" value="cn.itcast.domain"/>
<!--jpa的供应商适配器 -->
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<!--配置是否自动创建数据库表 -->
<property name="generateDdl" value="true" />
<!--指定数据库类型 -->
<property name="database" value="MYSQL" />
<!--数据库方言：支持的特有语法 -->
<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
<!--是否显示sql -->
<property name="showSql" value="true" />
</bean>
</property>
</bean>
<!--2. 创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="root"/>
<property name="password" value="root"/>
<property name="jdbcUrl" value="jdbc:mysql://192.168.20.40/jpa?userSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai"/>
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
</bean>
<!--3.整合spring dataJpa-->
<!-- dao接口所在的路径-->
<jpa:repositories base-package="cn.itcast.dao" transaction-manager-ref="transactionManager"
entity-manager-factory-ref="entityManagerFactory" />
<!--4.配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>
<!-- 4.txAdvice-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="insert*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 5.aop-->
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
</aop:config>
<!--5.声明式事务 -->
<!-- 6. 配置包扫描，使用注解开发 -->
<context:component-scan base-package="cn.itcast" />
</beans>
遇到问题: applicationcontext配置文件数据库连接池爆红
解决方案:
maven导入依赖失败问题——最系统、最彻底的解决方案
暴力解决: 删除项目 ,从新建立项目
编写代码
编写实体类 添加get/ set方法 重写tostring方法
@Table(name = "cst_customer")
@Entity
public class Customer {
@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;//客户地址
}
编写Dao接口 Dao接口继承的接口中已经封装了许多 数据库操作不用自己再写
/**
* 符合SpringDataJpa的dao层接口规范
* JpaRepository < 操作的实体类类型，实体类中主键属性的类型>
* * 封装了基本CRUD操作
* JpaSpecificationExecutor< 操作的实体类类型 >
* * 封装了复杂查询（分页）
*/
public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor<Customer> {
}
编写测试类
测试类上需要使用@ContextConfiguration注解,指定spring容器的配置信息
package cn.itcast.test;
import cn.itcast.dao.CustomerDao;
import cn.itcast.domain.Customer;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class) //声明spring提供的单元测试环境
@ContextConfiguration(locations = "classpath:applicationContext.xml")//指定spring容器的配置信息
public class CustomerDaoTest {
@Autowired
private CustomerDao customerDao;
/**
* 根据id查询
*/
@Test
public void testFindOne() {
Customer customer = customerDao.findOne(4l);
System.out.println(customer);
}
/**
* save : 保存或者更新
* 根据传递的对象是否存在主键id，
* 如果没有id主键属性：保存
* 存在id主键属性，根据id查询数据，更新数据
*/
@Test
public void testSave() {
Customer customer = new Customer();
customer.setCustName("黑马程序员");
customer.setCustLevel("vip");
customer.setCustIndustry("it教育");
customerDao.save(customer);
}
@Test
public void testUpdate() {
Customer customer = new Customer();
customer.setCustId(4l);
customer.setCustName("黑马程序员很厉害");
customerDao.save(customer);
}
@Test
public void testDelete () {
customerDao.delete(3l);
}
/**
* 查询所有
*/
@Test
public void testFindAll() {
List<Customer> list = customerDao.findAll();
for(Customer customer : list) {
System.out.println(customer);
}
}
/**
* 测试统计查询：查询客户的总数量
* count:统计总条数
*/
@Test
public void testCount() {
long count = customerDao.count();//查询全部的客户数量
System.out.println(count);
}
/**
* 测试：判断id为4的客户是否存在
* 传统写法：
* 1. 可以查询以下id为4的客户
* 如果值为空，代表不存在，如果不为空，代表存在
* 2. 判断数据库中id为4的客户的数量
* 如果数量为0，代表不存在，如果大于0，代表存在
*/
@Test
public void testExists() {
boolean exists = customerDao.exists(4l);
System.out.println("id为4的客户 是否存在："+exists);
}
/**
* 根据id从数据库查询
* @Transactional : 保证getOne正常运行
*
* findOne：
* em.find() :立即加载
* getOne：
* em.getReference :延迟加载
* * 返回的是一个客户的动态代理对象
* * 什么时候用，什么时候查询
*/
@Test
@Transactional
public void testGetOne() {
Customer customer = customerDao.getOne(4l);
System.out.println(customer);
}
}
总结:
实体类 : 使用JPA注解配置映射关系
Dao接口 : 继承 extends JpaRepository<Customer,Long>与JpaSpecificationExecutor< Customer >
测试类:
- findone id):根据id查询
- save(customer):保存或者更新（依据:传递的实体类对象中，是否包含id属性)
- delete (id):根据id删除
- findAll():查询全部
二、SpringData运行过程及原理剖析
我们知道一个接口真正起作用的是接口的实现类 ，但是在入门案例的Dao接口中没有写接口的相关实现 ,
说明在程序的执行过程中， 自动帮我们生成了 接口的实现类的对象——动态代理
- 客户接口开始
- SpringData JPA创建动态代理对象 simpleJpaRepository
- 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象（SimpleJpaRepository）
- SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CURD）
- 通过hibernate完成数据库操作（封装了jdbc）
问题： 系统怎么知道要为Dao生成动态代理对象?
在application Context.xml文件中有配置:
源码分析
通过debug进行调试
{$Proxy32@5834} 可以知道是一个动态代理对象
右击选择Jump To Type Source 可以跳转到对应的代理工具类 ： JdkDynamicAopProxy
InvocationHandLer是JDK动态代理的一个参数 ， InvocationHandLer里面定义了如何去创建动态代理对象的一个方法
当我们执行到invoke方法的时候就会去帮我们自动创建 接口的实现类
Object target = null; 是生成的动态代理对象
对target 进行赋值 ： SimpleJpaRepository
SimpleJpaRepository 就是SpringDataJPA帮助我们生成的实现了 Dao接口的 动态代理对象
右击选择Jump To Type Source跳转到 SimpleJpaRepository
SimpleJpaRepository 中 实现了JpaRepository 接口 与 JpaSpecificationExecutor 接口
而我们定义的Dao接口继承了 这两个接口 ， 就可以认为 SimpleJpaRepository 是Dao接口的实现类
SimpleJpaRepository 中实现了我们使用的 CRUD方法
当我们在测试类中使用 findOn() 方法的时候 ， 就会调用 SimpleJpaRepository 中实现的SimpleJpaRepository 方法
注意 em.find ()
em 就是 EntityManager
EntityManager 是JPA 中的实体管理器
在EntityManager 中有find方法 来进行根据ID查询
三、复杂查询
Ⅰ、接口查询
继承JpaRepository的方法列表
使用JpaRepository 接口中的方法
//根据id查询
Customer customer = customerDao.findOne(4l);
/**
* 根据id从数据库查询
* getone需要加上@Transactional注解 , 不加会报错 , 因为getone涉及到事务
* @Transactional : 保证getOne正常运行
*
* findOne：
* em.find() :立即加载
* getOne：
* em.getReference :延迟加载
* * 返回的是一个客户的动态代理对象
* * 什么时候用，什么时候查询
*/
//根据id查询
@Transactional
@Test
Customer customer = customerDao.getOne(4l);
//customer没有id 就保存 , customer有 id 就更新
customerDao.save(customer);
//根据id删除
customerDao.delete(3l);
//查询所有数据
List<Customer> list = customerDao.findAll();
//统计数据
long count = customerDao.count();
//判断是否存在
boolean exists = customerDao.exists(4l);
继承JpaSpecificationExecutor方法列表
Ⅱ、 jpql查询方式
jpql：jpa query language (jpa查询语言)
特点:
- 语法或关键字和sql语句类似
*查询的是类和类中的属性
需要将JPQL语句配置到接口方法上
在Dao接口方法上添加@Query注解 : @Query(value=“要使用的JPQL语句”)
查询语句
public interface CustomerDao extends JpaRepository<Customer, Long>,JpaSpecificationExecutor<Customer> {
//@Query 使用jpql的方式查询。
@Query(value="from Customer")
public List<Customer> findAllCustomer();
//@Query 使用jpql的方式查询。?1代表参数的占位符，其中1对应方法中的参数索引
//多个参数占位符 要和 参数位置对应
@Query(value="from Customer where custName = ?1 and custId = ?2")
public Customer findCustomer(String custName ,Long custId);
}
更新
此外，也可以通过使用 @Query 来执行一个更新操作，为此，我们需要在使用 @Query 的同时，用 @Modifying 来将该操作标识为修改查询，这样框架最终会生成一个更新的操作，而非查询。
@Query(value="update Customer set custName = ?1 where custId = ?2")
@Modifying
public void updateCustomer(String custName,Long custId);
.测试方法需要增加事务支持：
更新操作涉及到事务 ,所以在测试的时候需要为更新操作添加@Transactional注解
@Test
public void testfindCustomer() {
Customer customer = customerDao.findCustomer("传智播客",2L);
System.out.println(customer);
}
/*
* springDataJpa中使用jpql完成 更新/删除操作
* 需要手动添加事务的支持
* 默认会执行结束之后，回滚事务 ,不会提交事务
* */
@Test
@Transactional //添加事务支持
@Rollback(false) //不进行事务回滚
public void testUpdate1(){
customerDao.updateCustomer("尚硅谷",5L);
}
Ⅲ、sql查询方式
在Dao接口方法上添加@Query注解 : @Query(value=“要使用的SQL语句”,nativeQuery = true)
注意模糊查询 ， 要在查询条件参数中添加 %
/**
* 使用sql的形式查询：
* 查询全部的客户
* sql ： select * from cst_customer;
* Query : 配置sql查询
* value ： sql语句
* nativeQuery ： 查询方式
* true ： sql查询
* false：jpql查询
*
*/
//@Query(value = " select * from cst_customer" ,nativeQuery = true)
@Query(value="select * from cst_customer where cust_name like ?1",nativeQuery = true)
public List<Object [] > findSql(String name);
测试
@Test
public void testfindSql(){
List<Object[]> sql = customerDao.findSql("黑马%");
for (Object[] objects : sql) {
System.out.println(Arrays.toString(objects));
}
}
Ⅳ、方法命名规则查询
是对jpql查询，更加深入的一层封装
我们只需要按照SpringDataJpa提供的方法名称规则来定义方法，不需要再去配置jpql语句，就能完成查询
只用写方法 , 不用写JPQL语句或SQL语句
举例
/**
* 方法名的约定：
* findBy : 查询
* 对象中的属性名（首字母大写） ： 查询的条件
* CustName
* * 默认情况 ： 使用 等于的方式查询
* 特殊的查询方式
*
* findByCustName -- 根据客户名称查询
*
* 再springdataJpa的运行阶段
* 会根据方法名称进行解析 findBy from xxx(实体类)
* 属性名称 where custName =
*
* 1.findBy + 属性名称 （根据属性名称进行完成匹配的查询=）
* 2.findBy + 属性名称 + “查询方式（Like | isnull）”
* findByCustNameLike
* 3.多条件查询
* findBy + 属性名 + “查询方式” + “多条件的连接符（and|or）” + 属性名 + “查询方式”
*/
public Customer findByCustName(String custName);
//根据名字模糊匹配
public List<Customer> findByCustNameLike(String custName);
//多条件查询 ,//使用客户名称模糊匹配和客户所属行业精准匹配的查询
public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
测试
//测试方法命名规则的查询
@Test
public void testNaming(){
Customer customer = customerDao.findByCustName("博学谷");
System.out.println(customer);
}
//根据名字模糊查询
@Test
public void testLike(){
List<Customer> byCustNameLike = customerDao.findByCustNameLike("黑马%");
for (Customer customer : byCustNameLike) {
System.out.println(customer);
}
}
//使用客户名称模糊匹配和客户所属行业精准匹配的查询
@Test
public void testFindByCustNameLikeAndCustIndustry(){
Customer customer = customerDao.findByCustNameLikeAndCustIndustry("黑马%", "学院");
System.out.println(customer);
}
四、总结:
i.springDatajpa，jpa规范，hibernate三者之间的关系
code – > springDatajpa --> jpa规范的API --> hibernate
ii.符合springDataJpa规范的dao层接口的编写规则
需要实现两个接口（JpaRepository，JapSpecificationExecutor）
提供响应的泛型
iii.运行过程
动态代理的方式：动态代理对象
iiii.查询
Specifications动态查询
前面不管是JPQL 还是 SQL 还是 方法命名规则查询 ， 他们的查询条件都是固定的
但是在企业开发中很多查询条件都不是固定的 ， 那么一个需求就需要写一个crud方法 ， 比较麻烦
有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。
借助Specification参数实现 ，动态拼接 Specification参数条件，实现不同条件的动态查询
一、Specifications动态查询
JpaSpecificationExecutor 方法列表
T findOne(Specification<T> spec); //查询单个对象
List<T> findAll(Specification<T> spec); //查询列表
//查询全部，分页
//pageable：分页参数
//返回值：分页pageBean（page：是springdatajpa提供的）
Page<T> findAll(Specification<T> spec, Pageable pageable);
//查询列表
//Sort：排序参数
List<T> findAll(Specification<T> spec, Sort sort);
long count(Specification<T> spec);//统计查询
对于JpaSpecificationExecutor，这个接口基本是围绕着Specification接口来定义的。我们可以简单的理解为，Specification构造的就是查询条件。
Specification接口中只定义了如下一个方法：
* Specification ：是查询条件
自定义我们自己的Specification实现类
实现 Specification 的 toPredicate 方法
//root：查询的根对象（查询的任何属性都可以从根对象中获取）
//CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
//CriteriaBuilder：查询的构造器，封装了很多的查询条件
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件
单个条件查询
动态查询单个对象 ， Dao接口中不用写东西
@Test
public void testSpec() {
//匿名内部类
/**
* 自定义查询条件
* 1.实现Specification接口（提供泛型：查询的对象类型）
* 2.实现toPredicate方法（构造查询条件）
* 3.需要借助方法参数中的两个参数（
* root：获取需要查询的对象属性
* CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
* ）
* 案例：根据客户名称查询，查询客户名为传智播客的客户
* 查询条件
* 1.查询方式
* cb对象
* 2.比较的属性名称
* root对象
*/
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//1.获取比较的属性
Path<Object> custName = root.get("custName");
//2.构造查询条件 ： select * from cst_customer where cust_name = '传智播客'
/**
* 第一个参数：需要比较的属性（path对象）
* 第二个参数：当前需要比较的取值
*/
Predicate predicate = cb.equal(custName, "传智播客");//进行精准的匹配 （比较的属性，比较的属性的取值）
return predicate;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
多条件查询
/**
* 多条件查询
* 案例：根据客户名（传智播客）和客户所属行业查询（it教育）
*
*/
@Test
public void testSpec1() {
/**
* root:获取属性
* 客户名
* 所属行业
* cb：构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*/
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
Path<Object> custName = root.get("custName");//客户名
Path<Object> custIndustry = root.get("custIndustry");//所属行业
//构造查询
//1.构造客户名的精准匹配查询
Predicate p1 = cb.equal(custName, "传智播客");//第一个参数，path（属性），第二个参数，属性的取值
//2..构造所属行业的精准匹配查询
Predicate p2 = cb.equal(custIndustry, "it教育");
//3.将多个查询条件组合到一起：组合（满足条件一并且满足条件二：与关系，满足条件一或满足条件二即可：或关系）
Predicate and = cb.and(p1, p2);//以与的形式拼接多个查询条件
// cb.or();//以或的形式拼接多个查询条件
return and;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
模糊查询 和 排序查询
/**
* 案例：完成根据客户名称的模糊匹配，返回客户列表
* 客户名称以 ’传智播客‘ 开头
*
* equal ：直接的到path对象（属性），然后进行比较即可
* Predicate p2 = cb.equal(custIndustry, "教育");
*
* gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
* 指定参数类型：path.as(类型的字节码对象)
* Predicate like = cb.like(custName.as(String.class), "传智%");
*/
@Test
public void testSpec3() {
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
@Override
public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
//查询属性：客户名
Path<Object> custName = root.get("custName");
//查询方式：模糊匹配
Predicate like = cb.like(custName.as(String.class), "传智%");
return like;
}
};
// List<Customer> list = customerDao.findAll(spec);
// for (Customer customer : list) {
// System.out.println(customer);
// }
//添加排序
//创建排序对象,需要调用构造方法实例化sort对象
//第一个参数：排序的顺序（倒序，正序）
// Sort.Direction.DESC:倒序
// Sort.Direction.ASC ： 升序
//第二个参数：排序的属性名称
Sort sort = new Sort(Sort.Direction.DESC,"custId");
List<Customer> list = customerDao.findAll(spec, sort);
for (Customer customer : list) {
System.out.println(customer);
}
}
分页查询
/**
* 分页查询
* Specification: 查询条件
* Pageable：分页参数
* 分页参数：查询的页码，每页查询的条数
* findAll(Specification,Pageable)：带有条件的分页
* findAll(Pageable)：没有条件的分页
* 返回：Page（springDataJpa为我们封装好的pageBean对象，数据列表，共条数）
*/
@Test
public void testSpec4() {
Specification spec = null;
//PageRequest对象是Pageable接口的实现类
/**
* 创建PageRequest的过程中，需要调用他的构造方法传入两个参数
* 第一个参数：当前查询的页数（从0开始）
* 第二个参数：每页查询的数量
*/
Pageable pageable = new PageRequest(0,2);
//分页查询
Page<Customer> page = customerDao.findAll(null, pageable);
System.out.println(page.getContent()); //得到数据集合列表
System.out.println(page.getTotalElements());//得到总条数
System.out.println(page.getTotalPages());//得到总页数
}
方法对应的关系
二 、多表之间的关系和操作多表的操作步骤
表关系
一对一
一对多：
一的一方：主表
多的一方：从表
外键：需要再从表上新建一列作为外键，他的取值来源于主表的主键
多对多：
中间表：中间表中最少应该由两个字段组成，这两个字段做为外键指向两张表的主键，又组成了联合主键
讲师对学员：一对多关系
实体类中的关系
包含关系：可以通过实体类中的包含关系描述表关系
继承关系
分析步骤
1.明确表关系
2.确定表关系（描述 一对多： 外键 | 多对多： 中间表）
3.编写实体类，再实体类中描述表关系（包含关系）
4.配置映射关系
三、 完成多表操作
i.一对多操作
案例：客户和联系人的案例（一对多关系）
客户：一家公司
联系人：这家公司的员工 , 一家公司有多个员工
一个客户可以具有多个联系人
一个联系人从属于一家公司
分析步骤
1.明确表关系
一对多关系
2.确定表关系（描述 外键|中间表）
主表：客户表
从表：联系人表
* 在从表（联系人）上添加外键
3.编写实体类，在实体类中描述表关系（包含关系）
客户：在客户的实体类中包含一个联系人的集合
联系人：在联系人的实体类中包含一个客户的对象
4.配置映射关系
* 使用jpa注解配置一对多映射关系
级联：
操作一个对象的同时操作他的关联对象
级联操作：
1.需要区分操作主体
2.需要在操作主体的实体类上，添加级联属性（需要添加到多表映射关系的注解上）
3.cascade（配置级联）
级联添加，
案例：当我保存一个客户的同时保存联系人
级联删除
案例：当我删除一个客户的同时删除此客户的所有联系人
ii.多对多操作
案例：用户和角色（多对多关系）
用户：
角色：
分析步骤
1.明确表关系
多对多关系
2.确定表关系（描述 外键|中间表）
中间间表
3.编写实体类，再实体类中描述表关系（包含关系）
用户：包含角色的集合
角色：包含用户的集合
4.配置映射关系
iii.多表的查询
1.对象导航查询
查询一个对象的同时，通过此对象查询他的关联对象
案例：客户和联系人
从一方查询多方
* 默认：使用延迟加载（****）
从多方查询一方
* 默认：使用立即加载
转自： https://blog.csdn.net/DDDDeng_/article/details/108197565
154
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
