Spring data JPA入门
1.ORM思想
主要目的：操作实体类就相当于操作数据库表
建立两个映射关系:
实体类和表的映射关系
实体类中属性和表中字段的映射关系
实现了ORM思想的框架有： mybatis , hibernate
2.hibernate框架介绍
hibernate是一个开源的对象关系映射框架
它对JDBC进行了非常轻量机的对象封装
它将POJO与数据库表建立映射关系，是一个全自动的orm框架
3.JPA规范
jpa规范，实现jpa规范，内部是由接口和抽象类组成
4.JPA的基本操作
案例：是客户的相关操作（增删改查）
客户：就是一家公司
客户表：
jpa的操作步骤
1.加载配置文件创建工厂（实体管理器工厂）对象
Persisitence: 静态方法（根据持久化单元名称创建实体管理器工厂）
作用：创建实体管理器工厂
2.通过实体管理器工厂获取实体管理器
3.获取事务对象，开启事务
4.完成增删改查
* testSave()--persist() 增
* testRemove()--remove() 删
* testUpdate()--merge() 改
* testFind()--find() 查（立即加载）
* testReference()--getReference() 查（延迟加载）
5.提交事务（回滚事务）
6.释放资源
搭建环境的过程
1.创建maven工程导入坐标
2.需要配置jpa的核心配置文件
*位置：配置到类路径下的一个交META-INF的文件夹下
*命名：persistence.xml
3.编写客户的实体类
4.配置实体类和表，类中属性和表中字段的映射关系
5.保存客户到数据库中
入门实例
1.搭建环境
创建maven工程然后导入坐标
1、File----Mudule—>选择maven模块，jdk选择1.8，不要选择任何框架—>添加groupId和articleId。
2、导入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>8.0.23</version>
</dependency>
</dependencies>
3.查看pom.xml，运行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>cn.itcast</groupId>
<artifactId>FirstJPA</artifactId>
<version>1.0-SNAPSHOT</version>
<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>8.0.23</version>
</dependency>
</dependencies>
</project>
配置jpa的核心配置文件
- 在java工程的\src\main\resources路径下创建一个名为
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.cj.jdbc.Driver" />
<!-- 数据库地址 -->
<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test?serverTimezone=UTC" />
<!-- 数据库用户名 -->
<property name="javax.persistence.jdbc.user" value="root" />
<!-- 数据库密码 -->
<property name="javax.persistence.jdbc.password" value="123456" />
<!--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>
- tips：可以选择目标----选中
persistence.xml----》File----》New----》Edit File Template 
2.创建客户的数据库表和客户的实体类
- 创建客户的数据库表：【这个语句可以不执行，根据在
persistence.xml配置hibernate.hbm2ddl.auto策略变化即可】
/*创建客户表*/
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;
1234567891011
- 创建数据库的实体类
public class Customer implements Serializable {
private Long custId;
private String custName;
private String custSource;
private String custIndustry;
private String custLevel;
private String custAddress;
private String custPhone;
**get和set方法省略**
}
3.编写实体类和数据库表的映射配置[重点]
在实体类上使用jpa注解的形式配置映射关系
/*
客户实体类
配置映射关系
1.实体类和表的映射关系
@Entity:声明实体类
@Table：配置实体类和表的映射关系
name : 配置数据库表的名称
2.实体类中属性和表中字段的映射关系
*/
@Entity
@Table(name = "cst_customer")
public class Customer {
/*
* @Id:声明主键的配置
* @GeneratedValue:配置主键的生成策略
* strategy = GenerationType.IDENTITY) 自增
* *底层数据库必须支持自增，mysql
* GenerationType.SEQUENCE 序列
* *底层数据库必须支持序列，oracle
* GenerationType.TABLE jpa提供的一种机制，通过一张数据库表的形式帮助我们完成主键自增
* GenerationType.AUTO 程序自动帮助我们选择主键生成策略
*/
/*
@Entity
作用：指定当前类是实体类。
@Table
作用：指定实体类和表之间的对应关系。
属性：
name：指定数据库表的名称
@Id
作用：指定当前字段是主键。
@GeneratedValue
作用：指定主键的生成方式。。
属性：
strategy ：指定主键生成策略。
@Column
作用：指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
*/
@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;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custName='" + custName + '\'' +
", custSource='" + custSource + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custAddress='" + custAddress + '\'' +
", custPhone='" + custPhone + '\'' +
'}';
}
}
常用注解的说明
@Entity
作用：指定当前类是实体类。
@Table
作用：指定实体类和表之间的对应关系。
属性：
name：指定数据库表的名称
@Id
作用：指定当前字段是主键。
@GeneratedValue
作用：指定主键的生成方式。。
属性：
strategy ：指定主键生成策略。
@Column
作用：指定实体类属性和数据库表之间的对应关系
属性：
name：指定数据库表的列名称。
unique：是否唯一
nullable：是否可以为空
inserttable：是否可以插入
updateable：是否可以更新
columnDefinition: 定义建表时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表），该属性定义该列所在从表的名字搭建开发环境[重点]
4.实现数据库的保存操作(CRUD)
简单CRUD
public class jpaTest {
/*
* 测试jpa的保存
* 案例：保存一个客户到数据库中
* jpa的操作步骤
* 1.加载配置文件创建工厂（实体管理器工厂）对象
* 2.通过实体管理器工厂获取实体管理器
* 3.获取事务对象，开启事务
* 4.完成增删改查
* testSave()--persist()
* testRemove()--remove()
* testUpdate()--merge()
* testFind()--find() 立即加载
* testReference()--getReference() 延迟加载
* 5.提交事务（回滚事务）
* 6.释放资源
*/
@Test
public void testSave() {
// //1.加载配置文件创建工厂（实体管理器工厂）对象
// EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");
// //2.通过实体管理器工厂获取实体管理器
// EntityManager em = factory.createEntityManager();
EntityManager em = JpaUtils.getEntityManager();
//3.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 4.完成增删改查
Customer c = new Customer();
c.setCustName("传智播客");
c.setCustIndustry("教育");
//保存操作
em.persist(c);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
// factory.close();
}
/*
* find（）
* 立即加载
*/
@Test
public void testFind() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.完成增删改查 -- 根据id查询客户
/*
* find : 根据id查询数据
* class ：查询数据结果需要包装的实体类类型的字节码
* id ： 查询主键的取值
*/
Customer customer = em.find(Customer.class, 1l);
System.out.println(customer);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* getReference()方法
* 延迟加载（懒加载）
* * 得到动态代理对象
* * 什么时候用什么时候才查询sql
* 不会浪费时间去查询
*/
@Test
public void testReference() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.完成增删改查 -- 根据id查询客户
Customer customer = em.getReference(Customer.class, 1l);
System.out.println(customer);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 删除操作
*/
@Test
public void testRemove() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.完成增删改查 -- 删除客户
// i 根据id查询客户
// ii 调用remove（）删除客户
Customer customer = em.getReference(Customer.class, 1L);
em.remove(customer);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 更新操作，修改客户
*/
@Test
public void testUpdate() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.完成增删改查 -- 修改客户
// i 根据id查询客户
// ii 调用merge（）修改客户
Customer customer = em.find(Customer.class, 1L);
customer.setCustIndustry("芜湖教育");
customer.setCustAddress("芜湖");
em.merge(customer);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
}
jpql查询
public class jpqlTest {
/*
* 进行jpql查询
* 1.创建Query查询对象；
* 2.对参数赋值
* 3。查询并得到返回结果
*/
/*
* 查询全部
* jpql：from cn.itcast.domain.Customer
* Mysql: SELECT * FROM cst_customer
*/
@Test
public void testFindAll() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.查询全部
String jpql = "from cn.itcast.domain.Customer";
//String jpql = "from Customer";
Query query = em.createQuery(jpql); //建立Query查询对象
//发送结果并封装结果集
List result= query.getResultList();
for (Object obj: result) {
System.out.println(obj);
}
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 查询全部:倒序 desc
* jpql：from Customer order by XXX(属性名) desc
* Mysql: SELECT * FROM cst_customer OEDER BY cust_id DESC
*/
@Test
public void testOrders() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.查询全部
String jpql = "from Customer order by custId desc";
Query query = em.createQuery(jpql); //建立Query查询对象
//发送结果并封装结果集
List result= query.getResultList();//List结果集
for (Object obj: result) {
System.out.println(obj);
}
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 查询全部:统计客户总数
* jpql：select count(custId) from Customer
* Mysql: SELECT COUNT(cust_id ) FROM cst_customer
*/
@Test
public void testCount() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.查询全部
String jpql = "select count(custId) from Customer";
Query query = em.createQuery(jpql); //建立Query查询对象
//发送结果并封装结果集
Object result = query.getSingleResult();//唯一结果集
System.out.println(result);
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 查询全部:分页查询
* jpql：from Customer
* Mysql: SELECT * FROM cst_customer limit ?,?
*/
@Test
public void testPage() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.查询全部
String jpql = "from Customer";
Query query = em.createQuery(jpql); //建立Query查询对象
//对参数赋值
query.setFirstResult(0);//起始索引，（0， 不包含0
query.setMaxResults(2);//查询条数，2条
//发送结果并封装结果集
List result= query.getResultList();//List结果集
for (Object obj: result) {
System.out.println(obj);
}
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
/*
* 查询全部:条件查询
* jpql：from Customer where custName like ?
* Mysql: SELECT * FROM cst_customer WHERE cust_name LIKE ?
*/
@Test
public void testCondition() {
//1.通过工具类获取EntityManager对象
EntityManager em = JpaUtils.getEntityManager();
//2.获取事务对象，开启事务
EntityTransaction tx = em.getTransaction();//获取事务对象
tx.begin();//开启事务
// 3.查询全部
String jpql = "from Customer where custName like ?";
Query query = em.createQuery(jpql); //建立Query查询对象
//对参数赋值
query.setParameter(1,"%传智播客%");//%X%表示包含字段即可
//发送结果并封装结果集
List result= query.getResultList();//List结果集
for (Object obj: result) {
System.out.println(obj);
}
//5.提交事务
tx.commit();
//6.释放资源
em.close();
}
}
Spring Data JPA基础
一、Spring Data JPA的概述
JPA(Java Persistence API)意即Java持久化API，是Sun官方在JDK5.0后提出的Java持久化规范（JSR 338，这些接口所在包为javax.persistence，详细内容可参考https://github.com/javaee/jpa-spec）
JPA的出现主要是为了简化持久层开发以及整合ORM技术，结束Hibernate、TopLink、JDO等ORM框架各自为营的局面。JPA是在吸收现有ORM框架的基础上发展而来，易于使用，伸缩性强。总的来说，JPA包括以下3方面的技术：
- ORM映射元数据： 支持XML和注解两种元数据的形式，元数据描述对象和表之间的映射关系
- API： 操作实体对象来执行CRUD操作
- 查询语言： 通过面向对象而非面向数据库的查询语言（
JPQL）查询数据，避免程序的SQL语句紧密耦合
JPA架构
Spring官方的解释https://spring.io/projects/spring-data-jpa#overview
二、Spring Data JPA的入门操作
案例：客户的基本CRUD
i.搭建环境
创建工程导入坐标
配置spring的配置文件（配置spring data jpa 整合）
编写实体类Customer，使用jpa注解配置映射关系
ii.编写一个符合spring data jpa 的 dao层接口
*只需要编写一个dao层的接口，不需要编写一个dao层的实现类
*dao层规范
1.需要继承两个接口（JpaRepository， JpaSpecificationExecutor）
2.需要提供响应的泛型
三、Spring Data JPA的运行过程和原理剖析
在这里插入图片描述
- 通过JdkDynamicAopProxy的invoke方法创建了一个动态代理对象（SimpleJpaRepository）
- SimpleJpaRepository当中封装了JPA的操作（借助JPA的api完成数据库的CURD）
- 通过hibernate完成数据库操作（封装了jdbc）
Spring Data JPA的查询方式
接口查询
继承JpaRepository的方法列表
继承JpaSpecificationExecutor方法列表
四、复杂查询
1.JPQL查询
jpql：jpa query language (jpa查询语言)
特点:
语法或关键字和sql语句类似
查询的是类和类中的属性
需要将JPQL语句配置到接口方法上
特有的查询：需要在dao接口上配置的方法
在新添加的方法上，使用注解的形式配置jpql查询语句
注解：@Query
//CustomerDao.java@Query(value = "from Customer where custName = ?1")public Customer findJpql(String name);//@Query 使用jpql的方式查询。 ?1代表参数的占位符，其中1对应方法中的参数索引@Query(value="from Customer where custName = ?1 and custId = ?2")public Customer findCustomerNameAndId(String name,Long id);//@Query :代表用来查询//@Modifying:代表正在执行的是更新操作。 //删除与更新情况相同@Query(value="update Customer set custName = ?1 where custId = ?2")@Modifyingpublic void updateCustomer(String name,Long id);
//jpqlTest.javapublic class jpqlTest { @Autowired private CustomerDao customerDao; @Test public void testFindJPQL(){ Customer customer = customerDao.findJpql("传智播客"); System.out.println(customer); } @Test public void testFindNameAndId(){ Customer customer = customerDao.findCustomerNameAndId("传智播客", 1L); System.out.println(customer); } /* * springDataJpa中使用jpql完成 更新/删除操作 * 需要手动添加事务的支持 * 默认会执行结束之后，回滚事务 * */ @Test @Transactional//添加事务支持 @Rollback(value = false)//无事务回滚 public void testUpdateCustomer(){ //更新（删除与更新相似） customerDao.updateCustomer("牛逼",5L); }}
2.SQL查询
-
特有的查询：需要在dao接口上配置方法
-
在新添加的方法上，使用注解的形式配置sql查询语句
-
注解 ：@Query
value : jpql语句 | sql语句
nativeQuery : false（使用jpql查询） | true（使用本地查询 ：sql查询）
//CustomerDao.java/* * 使用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);
//jpqlTest.java//测试sql@Testpublic void testFindSql(){ List<Object[]> objects = customerDao.findSql("%传智播客%"); for (Object[] obj: objects) { System.out.println(Arrays.toString(obj)); }}
方法命名规则查询
- 是对jpql查询，更加深入的一层封装
- 我们只需要按照SpringDataJpa提供的方法名称规则来定义方法，不需要再去配置jpql语句，就能完成查询
精准匹配
- findBy开头： 代表查询，对象中属性的名称（首字母大写）
- 含义：根据属性名称进行查询
//CustomerDao.java
/*
* 方法名的约定：
* 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);
//jpqlTest.java
//测试方法命名规则的查询
@Test
public void testNaming(){
Customer customer = customerDao.findByCustName("传智播客");
System.out.println(customer);
}
模糊匹配
- findBy + 属性名称 + “查询方式（Like | isnull）”
public List<Customer> findByCustNameLike(String custName);
@Testpublic void testNamingLike(){ List<Customer> objects = customerDao.findByCustNameLike("%传智播客%"); for (Customer obj: objects) { System.out.println(obj); }}
多条件查询
- findBy + 属性名 + “查询方式” + “多条件的连接符（and/or)
//使用客户名称模糊匹配和客户所属行业精准匹配的查询public Customer findByCustNameLikeAndCustIndustry(String custName,String custIndustry);
//测试方法命名规则的查询@Testpublic void testNameAndIndustry(){ Customer obj = customerDao.findByCustNameLikeAndCustIndustry("传智播客%","教育"); System.out.println(obj);}
Specification动态查询
有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。
1.T findOne(Specification spec); //查询单个对象2.List findAll(Specification spec); //查询列表3.查询全部，分页 pageable：分页参数 返回值：分页pageBean（page：是springdatajpa提供的） Page findAll(Specification spec, Pageable pageable);4.查询列表 Sort：排序参数 List findAll(Specification spec, Sort sort);5.long count(Specification spec);//统计查询
1.Specification：条件查询
- 自定义我们自己的Specification实现类
//root：查询的根对象（查询的任何属性都可以从根对象中获取）
//CriteriaQuery：顶层查询对象，自定义查询方式（了解：一般不用）
//CriteriaBuilder：查询的构造器，封装了很多的查询条件
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb); //封装查询条件
单条件查询
/*
* 根据条件，查询单个对象
*/
@Test
public void testSpec(){
//匿名内部类
/*
* 自定义查询条件
* 1.实现Specification接口（提供泛型：查询的对象类型）
* 2.实现toPredicate方法（构造查询条件）
* 3.需要借助方法参数中的两个参数（
* root：获取需要查询的对象属性
* CriteriaBuilder：构造查询条件的，内部封装了很多的查询条件（模糊匹配，精准匹配）
* ）
* 案例：根据客户名称查询，查询客户名为传智播客的客户
* 查询条件
* 1.查询方式
* cb对象
* 2.比较的属性名称
* root对象
*
*/
Specification<Customer> spec = new Specification<Customer>() {
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 one = customerDao.findOne(spec);
System.out.println(one);
}
多条件查询
/*
* 多条件查询
* 案例：根据客户名（传智播客）和客户所属行业查询（it教育）
*/
@Test
public void testSpec1() {
/*
* root:获取属性
* 客户名
* 所属行业
* cb：构造查询
* 1.构造客户名的精准匹配查询
* 2.构造所属行业的精准匹配查询
* 3.将以上两个查询联系起来
*/
Specification<Customer> spec = new Specification<Customer>() {
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, "芜湖");
//3.将多个查询条件组合到一起：组合（满足条件一并且满足条件二：与关系，满足条件一或满足条件二即可：或关系）
Predicate and = cb.and(p1, p2);//以与的形式拼接多个查询条件
// cb.or();//以或的形式拼接多个查询条件
return and;
}
};
Customer customer = customerDao.findOne(spec);
System.out.println(customer);
}
模糊查询
/*
* 案例：完成根据客户名称的模糊匹配，返回客户列表
* 客户名称以 ’传智播客‘ 开头
*
* equal ：直接的到path对象（属性），然后进行比较即可
* gt，lt,ge,le,like : 得到path对象，根据path指定比较的参数类型，再去进行比较
* 指定参数类型：path.as(类型的字节码对象)
*/
@Test
public void testSpec3() {
//构造查询条件
Specification<Customer> spec = new Specification<Customer>() {
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);
}
}
2.多表之间的关系和操作多表的步骤
表关系
-
一对一
-
一对多：
-
一的一方：主表
-
多的一放：从表
-
外键：需要在从表上新建一列作为外键，他的取值来源于主表的主键
-
-
多对多
- 中间表：中间表中最少应该由两个字段组成，这两个字段作为外键指向两张表的主键，又组成了联合主键。
实体类中的关系
- 包含关系：可以通过实体类中的包含关系描述表关系
- 继承关系
分析步骤
- 明确表关系
- 确定表关系（描述 外键 | 中间表）
- 编写实体类，在实体类中描述表关系（包含关系）
- 配置映射关系
3.多表操作
注：MySQL配置
/*创建客户表*/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=94 DEFAULT CHARSET=utf8;/*创建联系人表*/CREATE TABLE cst_linkman ( lkm_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '联系人编号(主键)', lkm_name varchar(16) DEFAULT NULL COMMENT '联系人姓名', lkm_gender char(1) DEFAULT NULL COMMENT '联系人性别', lkm_phone varchar(16) DEFAULT NULL COMMENT '联系人办公电话', lkm_mobile varchar(16) DEFAULT NULL COMMENT '联系人手机', lkm_email varchar(64) DEFAULT NULL COMMENT '联系人邮箱', lkm_position varchar(16) DEFAULT NULL COMMENT '联系人职位', lkm_memo varchar(512) DEFAULT NULL COMMENT '联系人备注', lkm_cust_id bigint(32) NOT NULL COMMENT '客户id(外键)', PRIMARY KEY (`lkm_id`), KEY `FK_cst_linkman_lkm_cust_id` (`lkm_cust_id`), CONSTRAINT `FK_cst_linkman_lkm_cust_id` FOREIGN KEY (`lkm_cust_id`) REFERENCES `cst_customer` (`cust_id`) ON DELETE NO ACTION ON UPDATE NO ACTION) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
（1）一对多操作
案例：客户和联系人的案例（一对多关系）
客户：一家公司
联系人：这家公司的员工
一个客户可以具有多个联系人
一个联系人从属于一家公司
分析步骤
1.明确表关系
一对多关系
2.确定表关系（描述 外键|中间表）
主表：客户表
从表：联系人表
*再从表上添加外键
3.编写实体类，再实体类中描述表关系（包含关系）
客户：在客户的实体类中包含一个联系人的集合
联系人：在联系人的实体类中包含一个客户的对象
4.配置映射关系
使用jpa注解配置一对多映射关系
级联
操作一个对象的同时操作他的关联对象
级联操作：
1.需要区分操作主体
2.需要在操作主体的实体类上，添加级联属性（需要添加到多表映射关系的注解上）
3.cascade级联
级联添加
当我保存一个客户的同时保存联系人
级联删除
但我删除一个客户的同时删除此客户所有的联系人
Customer.java
package cn.itcast.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
/*
* 1.实体类和表的映射关系
* @Entity
* @Table
* 2.类中属性和表中字段的映射关系
* @Id
* @GeneratedValue
* @Column
*
* */
@Entity
@Table(name = "cst_customer")
public class Customer {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="cust_id")
private Long custId;
@Column(name="cust_address")
private String custAddress;
@Column(name="cust_industry")
private String custIndustry;
@Column(name="cust_level")
private String custLevel;
@Column(name="cust_name")
private String custName;
@Column(name="cust_phone")
private String custPhone;
@Column(name="cust_source")
private String custSource;
//配置客户和联系人之间的关系（一对多关系）
/*
* 使用注解的形式配置多表关系
* 1.声明关系
* @OneToMany : 配置一对多关系
* targetEntity ：对方对象的字节码对象
* 2.配置外键（中间表）
* @JoinColumn : 配置外键
* name：外键字段名称
* referencedColumnName：参照的主表的主键字段名称
*
* * 在客户实体类上（一的一方）添加了外键了配置，所以对于客户而言，也具备了维护外键的作用
*
*/
// testAdd()、testAdd1()使用以下注解
// @OneToMany(targetEntity = LinkMan.class)
// @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
// testAdd2()使用以下注解
// @OneToMany(mappedBy = "customer")
/*
* 放弃外键维护权
* mappedBy：对方配置关系的属性名称\
* cascade : 配置级联（可以配置到设置多表的映射关系的注解上）
* CascadeType.ALL : 所有
* MERGE ：更新
* PERSIST ：保存
* REMOVE ：删除
*
* fetch : 配置关联对象的加载方式
* EAGER ：立即加载
* LAZY ：延迟加载
*/
@OneToMany(mappedBy = "customer",cascade = CascadeType.ALL)
private Set<LinkMan> linkMans = new HashSet<>();
public Long getCustId() {
return custId;
}
public void setCustId(Long custId) {
this.custId = custId;
}
public String getCustAddress() {
return custAddress;
}
public void setCustAddress(String custAddress) {
this.custAddress = custAddress;
}
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 getCustName() {
return custName;
}
public void setCustName(String custName) {
this.custName = custName;
}
public String getCustPhone() {
return custPhone;
}
public void setCustPhone(String custPhone) {
this.custPhone = custPhone;
}
public String getCustSource() {
return custSource;
}
public void setCustSource(String custSource) {
this.custSource = custSource;
}
public Set<LinkMan> getLinkMans() {
return linkMans;
}
public void setLinkMans(Set<LinkMan> linkMans) {
this.linkMans = linkMans;
}
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
// ", linkMans=" + linkMans + 加了这行，输出对象时会直接报错，栈溢出（集合对象无法直接输出）
'}';
}
}
LinkMan.java
package cn.itcast.domain;
import javax.persistence.*;
@Entity
@Table(name = "cst_linkman ")
public class LinkMan {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "lkm_id")
private Long lkmId; //联系人编号(主键)
@Column(name = "lkm_name")
private String lkmName;//联系人姓名
@Column(name = "lkm_gender")
private String lkmGender;//联系人性别
@Column(name = "lkm_phone")
private String lkmPhone;//联系人办公电话
@Column(name = "lkm_mobile")
private String lkmMobile;//联系人手机
@Column(name = "lkm_email")
private String lkmEmail;//联系人邮箱
@Column(name = "lkm_position")
private String lkmPosition;//联系人职位
@Column(name = "lkm_memo")
private String lkmMemo;//联系人备注
/*
* 配置联系人到客户的多对一关系
* 使用注解的形式配置多对一关系
* 1.配置表关系
* @ManyToOne : 配置多对一关系
* targetEntity：对方的实体类字节码
* 2.配置外键（中间表）
*
* * 配置外键的过程，配置到了多的一方，就会在多的一方维护外键
*
*/
@ManyToOne(targetEntity = Customer.class,fetch = FetchType.LAZY)
// testAdd()、testAdd1()、testAdd2()使用以下注解
// @ManyToOne(targetEntity = Customer.class)
@JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
private Customer customer;
public Long getLkmId() {
return lkmId;
}
public void setLkmId(Long lkmId) {
this.lkmId = lkmId;
}
public String getLkmName() {
return lkmName;
}
public void setLkmName(String lkmName) {
this.lkmName = lkmName;
}
public String getLkmGender() {
return lkmGender;
}
public void setLkmGender(String lkmGender) {
this.lkmGender = lkmGender;
}
public String getLkmPhone() {
return lkmPhone;
}
public void setLkmPhone(String lkmPhone) {
this.lkmPhone = lkmPhone;
}
public String getLkmMobile() {
return lkmMobile;
}
public void setLkmMobile(String lkmMobile) {
this.lkmMobile = lkmMobile;
}
public String getLkmEmail() {
return lkmEmail;
}
public void setLkmEmail(String lkmEmail) {
this.lkmEmail = lkmEmail;
}
public String getLkmPosition() {
return lkmPosition;
}
public void setLkmPosition(String lkmPosition) {
this.lkmPosition = lkmPosition;
}
public String getLkmMemo() {
return lkmMemo;
}
public void setLkmMemo(String lkmMemo) {
this.lkmMemo = lkmMemo;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
@Override
public String toString() {
return "LinkMan{" +
"lkmId=" + lkmId +
", lkmName='" + lkmName + '\'' +
", lkmGender='" + lkmGender + '\'' +
", lkmPhone='" + lkmPhone + '\'' +
", lkmMobile='" + lkmMobile + '\'' +
", lkmEmail='" + lkmEmail + '\'' +
", lkmPosition='" + lkmPosition + '\'' +
", lkmMemo='" + lkmMemo + '\'' +
", customer=" + customer +
'}';
}
}
OneToManyTest.java
package cn.itcast;
import cn.itcast.dao.CustomerDao;
import cn.itcast.dao.LinkManDao;
import cn.itcast.domain.Customer;
import cn.itcast.domain.LinkMan;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class OneToManyTest {
@Autowired
private LinkManDao linkManDao;
@Autowired
private CustomerDao customerDao;
/*
* 保存一个客户，保存一个联系人
* 效果：客户和联系人作为独立的数据保存到数据库中
* 联系人的外键为空
* 原因？
* 实体类中没有配置关系
*/
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testAdd() {
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("百度");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("小李");
/*
* 配置了客户到联系人的关系
* 从客户的角度上：发送两条insert语句，发送一条更新语句更新数据库（更新外键）
* 由于我们配置了客户到联系人的关系：客户可以对外键进行维护
*/
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
linkManDao.save(linkMan);
}
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testAdd1() {
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("百度");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("小李");
/*
* 配置联系人到客户的关系（多对一）
* 只发送了两条insert语句
* 由于配置了联系人到客户的映射关系（多对一）
*
*
*/
linkMan.setCustomer(customer);
customerDao.save(customer);
linkManDao.save(linkMan);
}
/*
* 会有一条多余的update语句
* * 由于一的一方可以维护外键：会发送update语句
* * 解决此问题：只需要在一的一方放弃维护权即可
*
*/
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testAdd2() {
//创建一个客户，创建一个联系人
Customer customer = new Customer();
customer.setCustName("百度");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("小李");
linkMan.setCustomer(customer);//由于配置了多的一方到一的一方的关联关系（当保存的时候，就已经对外键赋值）
customer.getLinkMans().add(linkMan);//由于配置了一的一方到多的一方的关联关系（发送一条update语句）
customerDao.save(customer);
linkManDao.save(linkMan);
}
/*
* 级联添加：保存一个客户的同时，保存客户的所有联系人
* 需要在操作主体的实体类上，配置casacde属性
*/
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testCascadeAdd() {
Customer customer = new Customer();
customer.setCustName("百度1");
LinkMan linkMan = new LinkMan();
linkMan.setLkmName("小李1");
linkMan.setCustomer(customer);
customer.getLinkMans().add(linkMan);
customerDao.save(customer);
}
/*
* 级联删除：
* 删除1号客户的同时，删除1号客户的所有联系人
*/
@Test
@Transactional //配置事务
@Rollback(false) //不自动回滚
public void testCascadeRemove() {
//1.查询1号客户
Customer customer = customerDao.findOne(1L);
//2.删除1号客户
customerDao.delete(customer);
}
}
（2）多表的查询(一对多)
-
对象导航查询
查询一个对象的同时，通过此对象查询他的关联对象
案例：一个客户对应多个联系人
- 从一方查询多方
默认：使用延迟加载
-
从多方查询一方
默认：使用立即加载
ObjectQueryTest.java
package cn.itcast;import cn.itcast.dao.CustomerDao;import cn.itcast.dao.LinkManDao;import cn.itcast.domain.Customer;import cn.itcast.domain.LinkMan;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.Set;@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations = "classpath:applicationContext.xml")public class ObjectQueryTest { @Autowired private CustomerDao customerDao; @Autowired private LinkManDao linkManDao; //could not initialize proxy - no Session //测试对象导航查询（查询一个对象的时候，通过此对象查询所有的关联对象） @Test @Transactional // 解决在java代码中的no session问题 public void testQuery1() { //查询id为1的客户 Customer customer = customerDao.getOne(1L); //对象导航查询，此客户下的所有联系人 Set<LinkMan> linkMans = customer.getLinkMans(); for (LinkMan linkMan : linkMans) { System.out.println(linkMan); } } /* * 对象导航查询： * 默认使用的是延迟加载的形式查询的 * 调用get方法并不会立即发送查询，而是在使用关联对象的时候才会差和讯 * 延迟加载！ * 修改配置，将延迟加载改为立即加载 * fetch，需要配置到多表映射关系的注解上 * */ @Test @Transactional // 解决在java代码中的no session问题 public void testQuery2() { //查询id为1的客户 Customer customer = customerDao.findOne(1L); //对象导航查询，此客户下的所有联系人 Set<LinkMan> linkMans = customer.getLinkMans(); System.out.println(linkMans.size()); } /* * 从联系人对象导航查询他的所属客户 * * 默认 ： 立即加载 * 延迟加载： * */ @Test @Transactional // 解决在java代码中的no session问题 public void testQuery3() { LinkMan linkMan = linkManDao.findOne(2L); //对象导航查询所属的客户 Customer customer = linkMan.getCustomer(); System.out.println(customer); }}
（3）多对多操作
分析步骤
1.明确表关系
多对多关系
2.确定表关系（描述 外键|中间表）
中间间表
3.编写实体类，再实体类中描述表关系（包含关系）
用户：包含角色的集合
角色：包含用户的集合
4.配置映射关系
级联
*（详细查看代码）
User.java
package cn.itcast.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "sys_user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name="user_id")
private Long userId;
@Column(name="user_name")
private String userName;
@Column(name="age")
private Integer age;
/*
* 配置用户到角色的多对多关系
* 配置多对多的映射关系
* 1.声明表关系的配置
* @ManyToMany(targetEntity = Role.class) //多对多
* targetEntity：代表对方的实体类字节码
* 2.配置中间表（包含两个外键）
* @JoinTable
* name : 中间表的名称
* joinColumns：配置当前对象在中间表的外键
* @JoinColumn的数组
* name：外键名
* referencedColumnName：参照的主表的主键名
* inverseJoinColumns：配置对方对象在中间表的外键
*/
@ManyToMany(targetEntity = Role.class,cascade = CascadeType.ALL) //级联
// @ManyToMany(targetEntity = Role.class)
@JoinTable(name = "sys_user_role",
//joinColumns,当前对象在中间表中的外键
joinColumns = {@JoinColumn(name = "sys_user_id",referencedColumnName = "user_id")},
//inverseJoinColumns，对方对象在中间表的外键
inverseJoinColumns = {@JoinColumn(name = "sys_role_id",referencedColumnName = "role_id")}
)
private Set<Role> roles = new HashSet<>();
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Set<Role> getRoles() {
return roles;
}
public void setRoles(Set<Role> roles) {
this.roles = roles;
}
@Override
public String toString() {
return "User{" +
"userId=" + userId +
", userName='" + userName + '\'' +
", age=" + age +
", roles=" + roles +
'}';
}
}
Role.java
package cn.itcast.domain;
import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "sys_role")
public class Role {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "role_id")
private Long roleId;
@Column(name = "role_name")
private String roleName;
//配置多对多
@ManyToMany(mappedBy = "roles") //配置多表关系(对方配置映射关系的属性)
private Set<User> users = new HashSet<>();
public Long getRoleId() {
return roleId;
}
public void setRoleId(Long roleId) {
this.roleId = roleId;
}
public String getRoleName() {
return roleName;
}
public void setRoleName(String roleName) {
this.roleName = roleName;
}
public Set<User> getUsers() {
return users;
}
public void setUsers(Set<User> users) {
this.users = users;
}
@Override
public String toString() {
return "Role{" +
"roleId=" + roleId +
", roleName='" + roleName + '\'' +
", users=" + users +
'}';
}
}
ManyToManyTest.java
package cn.itcast.test;
import cn.itcast.dao.RoleDao;
import cn.itcast.dao.UserDao;
import cn.itcast.domain.Role;
import cn.itcast.domain.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class ManyToManyTest {
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
/*
* 保存一个用户，保存一个角色
*
* 多对多放弃维护权，被动的一方放弃
* */
@Test
@Transactional
@Rollback(false)
public void testAdd(){
User user = new User();
user.setUserName("小李");
Role role = new Role();
role.setRoleName("java程序员");
//配置用户到角色关系，可以对中间表中的数据进行维护
user.getRoles().add(role);
role.getUsers().add(user);
userDao.save(user);
roleDao.save(role);
}
@Test
@Transactional
@Rollback(false)
public void testCascade(){
User user = new User();
user.setUserName("小张");
Role role = new Role();
role.setRoleName("C++程序员");
//配置用户到角色关系，可以对中间表中的数据进行维护
user.getRoles().add(role);
role.getUsers().add(user);
userDao.save(user);
}
@Test
@Transactional
@Rollback(false)
public void testCascadeDelete(){
User user = userDao.findOne(1L);
//配置用户到角色关系，可以对中间表中的数据进行维护
userDao.delete(user);
}
//一个简单的综合测试
@Test
@Transactional
@Rollback(false)
public void test(){
User user = new User();
user.setUserName("小张");
Role role1 = roleDao.findOne(2L);
Role role = new Role();
role.setRoleName("C++程序员");
User user1 = userDao.findOne(3L);
user.getRoles().add(role1);
user1.getRoles().add(role);
userDao.save(user);
userDao.save(user1);
}
}
帮助
log4j2导入失败的问题
导入下面的xml信息
<?xml version="1.0" encoding="UTF-8"?>
<!--status:Log4j2内部日志的输出级别,设置为TRACE对学习Log4j2非常有用 -->
<!--monitorInterval:定时检测配置文件的修改,有变化则自动重新加载配置,时间单位为秒,最小间隔为5s -->
<Configuration status="WARN" monitorInterval="600">
<!--properties:设置全局变量 -->
<properties>
<!--LOG_HOME:指定当前日志存放的目录 -->
<property name="LOG_HOME">logs</property>
<!--FILE_NAME:指定日志文件的名称 -->
<property name="FILE_NAME">test</property>
</properties>
<!--Appenders:定义日志输出目的地，内容和格式等 -->
<Appenders>
<!--Console:日志输出到控制台标准输出 -->
<Console name="Console" target="SYSTEM_OUT">
<!--pattern:日期,线程名,日志级别,日志名称,日志信息,换行 -->
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level [%L] - %msg%n" />
</Console>
<!--RollingFile:日志输出到文件,下面的文件都使用相对路径 -->
<!--fileName:当前日志输出的文件名称 -->
<!--filePattern:备份日志文件名称，备份目录为logs下面以年月命名的目录，备份时使用gz格式压缩 -->
<RollingFile name="RollingFile" fileName="${LOG_HOME}/${FILE_NAME}.log"
filePattern="${LOG_HOME}/$${date:yyyy-MM}/${FILE_NAME}-%d{yyyy-MM-dd}-%i.log.gz">
<PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level [%L] - %msg%n" />
<!--Policies:触发策略决定何时执行备份 -->
<Policies>
<!--TimeBasedTriggeringPolicy:日志文件按照时间备份 -->
<!--interval:每1天生成一个新文件，时间单位需要结合filePattern时间%d{yyyy-MM-dd} -->
<!--同理，如果要每1小时生成一个新文件，则改成%d{yyyy-MM-ddHH} -->
<!--modulate:对备份日志的生成时间纠偏，纠偏以0为基准进行，"0+interval"决定启动后第一次备份时间 -->
<TimeBasedTriggeringPolicy interval="1" modulate="true" />
<!--SizeBasedTriggeringPolicy:日志文件按照大小备份 -->
<!--size:指定日志文件最大为100MB，单位可以为KB、MB或GB -->
<SizeBasedTriggeringPolicy size="100MB" />
</Policies>
<!--DefaultRolloverStrategy:翻转策略决定如何执行备份 -->
<!--max:最多保存5个备份文件，结合时间使用后，在每个时间段内最多有5个备份，多出来的会被覆盖 -->
<!--compressionLevel:配置日志压缩级别，范围0-9，0不压缩，1压缩速度最快，9压缩率最好，目前只对于zip压缩文件类型有效 -->
<DefaultRolloverStrategy max="5" compressionLevel="1">
<!--Delete:删除匹配到的过期备份文件 -->
<!--maxDepth:由于备份文件保存在${LOG_HOME}/$${date:yyyy-MM},所以目录深度设置为2 -->
<Delete basePath="${LOG_HOME}" maxDepth="2">
<!--IfFileName:匹配文件名称 -->
<!--glob:匹配2级目录深度下的以.log.gz结尾的备份文件 -->
<IfFileName glob="*/*.log.gz" />
<!--IfLastModified:匹配文件修改时间 -->
<!--age:匹配超过180天的文件，单位D、H、M、S分别表示天、小时、分钟、秒-->
<IfLastModified age="180D" />
</Delete>
</DefaultRolloverStrategy>
</RollingFile>
</Appenders>
<!--Loggers:定义日志级别和使用的Appenders -->
<Loggers>
<!--name: 打印日志的类的包路径 -->
<!--additivity: true当前的Logger打印的日志附加到Root，false仅仅打印到RollingFile -->
<Logger name="org.apache.logging.log4j" level="ERROR" additivity="true">
<AppenderRef ref="RollingFile" />
</Logger>
<!--Root:日志默认打印到控制台 -->
<!--level日志级别: ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < OFF -->
<Root level="ERROR">
<AppenderRef ref="Console" />
</Root>
</Loggers>
</Configuration>
堆栈溢出
查看ToString()方法,集合等对象无法直接转化为String类型，将其注释掉即可解决
//例
private Set<LinkMan> linkMans = new HashSet<>();
@Override
public String toString() {
return "Customer{" +
"custId=" + custId +
", custAddress='" + custAddress + '\'' +
", custIndustry='" + custIndustry + '\'' +
", custLevel='" + custLevel + '\'' +
", custName='" + custName + '\'' +
", custPhone='" + custPhone + '\'' +
", custSource='" + custSource + '\'' +
//", linkMans=" + linkMans +
'}';
}
2153
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
