首页 > 编程语言 > 详细

Spring Data JPA (二)

时间:2020-08-14 01:33:59      阅读:58      评论:0      收藏:0      [点我收藏+]

Spring Data JPA 与JPA和hibernate之间的关系
Spring Data JPA的特性??

(一)、JPA是一套规范,内部是有接口和抽象类组成。hibernate 是一套成熟的ORM框架

SpringData Jpa极大简化了数据库访问层代码,如何简化的?使用了SpringDataJpa 我们的dao层中字需要写接口,就自动具有了增删改查、分页查询等方法

(二)、java代码-->SpringData Jpa(把jpa的规范又封装了一层) --->Jpa规范(封装hibernate) --- >hibernate ---> 查询数据库

java代码写的是SpringData Jpa提供的规范,但SpringData Jpa内部封装了一层jpa规范的操作逻辑,但真正执行的是jpa规范内部的hibernate,hibernate封装了jdbc

(三)、springDataJpa的运行过程和原理剖析

1)、通过JdkDynamicAopProxy的invoke 方法创建了一个动态代理对象

2)、SimpleJpaRepository当中封装了JPA的操作(借助JPA的api完成数据库的CRUD)

3)、通过hibernate完成数据库操作(封装了jdbc)

(四)、复杂查询

1)、借助接口中的定义好的方法完成查询

? findOne(id):根据id查询

2)、jpql的查询方式

? jpql:jpa query language (jpa查询语言)

? 特点:语法或关键字和sql语句类似

? 查询的是类和类中的属性

需要将JPQL语句语句配置到接口方法上
    1)、特有的查询:需要在dao接口上配置方法
    2)、在新添加的方法上,使用注解的形式配置jpql查询语句
    3)、注解:@query

3)、sql语句的查询

1)、特有的查询:需要在dao接口上配置方法

2)、在新添加的方法上,使用注解的形式配置sql查询语句

3)、注解: @Query

    value:jpql语句 | sql语句

    nativeQuery:false (使用jpql查询) | true(使用本地查询 :sql查询)
        是否使用本地查询

4)、方法名称规则查询

是对jpql查询,更加深入的一层封装
我们只需要按照SpringDataJpa提供的方法名称规则定义方法,不需要再去配置jpql语句,
findBy开头:代表查询
对象中属性的名称(首字母大写)
含义:根据属性名称进行查询

img
案例
1)、引入pom.xml

5.0.2.RELEASE 5.0.7.Final 1.6.6 1.2.12 0.9.1.2 5.1.6
<dependencies>
    <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>

    <!--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.validator</groupId>
        <artifactId>hibernate-validator</artifactId>
        <version>6.0.9.Final</version>
    </dependency>

    <!--c3p0 beg-->
    <dependency>
        <groupId>c3p0</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0.version}</version>
    </dependency>

    <!--log end-->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</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>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>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jcl</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <!--el beg使用spring data jpa 必须引入-->

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.version}</version>
    </dependency>


    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>javax.el-api</artifactId>
        <version>3.0.0</version>
    </dependency>
    <dependency>
        <groupId>org.glassfish.web</groupId>
        <artifactId>javax.el</artifactId>
        <version>2.2.4</version>
    </dependency>
</dependencies>

2)、编写一个applicationContext.xml

<!--1、創建entityManagerFactory 对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--实体类所在的包-->
    <property name="packagesToScan"  value="com.rzk.pojo"/>
    <!--jpa的供应商适配器-->
    <property name="persistenceProvider">
        <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
    </property>
    <!--jpa的供应商适配器-->
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <!--配置是否自动创建数据库表-->
            <property name="generateDdl" value="false"/>
            <!--指定数据类型-->
            <property name="database" value="MYSQL"/>
            <!--数据库方言,支持特有语法-->
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
            <!--是否显示sql-->
            <property name="showSql" value="true"/>
        </bean>
    </property>

    <!--jpa的方言:高级特性-->
    <property name="jpaDialect">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
    </property>
</bean>

<!--2、创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
    <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/jap"></property>
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>

<!--3、整合spring dataJpa-->
<jpa:repositories base-package="com.rzk.dao" transaction-manager-ref="transactionManager"
                  entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

<!--4、配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>

3)、dao层

JpaRepository<实体类,你这个类主键的属性>

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor {
}

4)、pojo

DROP TABLE IF EXISTS cst_customer;
CREATE TABLE cst_customer (
cust_id bigint(20) NOT NULL AUTO_INCREMENT,
cust_address varchar(255) DEFAULT NULL,
cust_industry varchar(255) DEFAULT NULL,
cust_level varchar(255) DEFAULT NULL,
cust_name varchar(255) DEFAULT NULL,
cust_phone varchar(255) DEFAULT NULL,
cust_source varchar(255) DEFAULT NULL,
PRIMARY KEY (cust_id)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=gbk;

/**

  • fileName:Customer

  • description:

  • author:rzk

  • createTime:2020/8/5 20:43

  • versioni:1.0.0

  • 1、实体类和表的映射关系

  • @Entity

  • @Table

  • 2、类中属性和表中字段的映射关系

  • @Id

  • @GeneratedValue

  • @Column
    /
    @Entity
    @Table(name = "cst_customer")
    public class Customer {
    /
    *

    • @Id:声明主键配置
    • @GeneratedValue:配置主键的生成策略
    •      GenerationType.IDENTITY:自增
      
    • @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;//客户地址

    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 getCustLevel() {
    return custLevel;
    }

    public void setCustLevel(String custLevel) {
    this.custLevel = custLevel;
    }

    public String getCustIndustry() {
    return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
    this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
    return custPhone;
    }

    public void setCustPhone(String custPhone) {
    this.custPhone = custPhone;
    }

    public String getCustAddress() {
    return custAddress;
    }

    public void setCustAddress(String custAddress) {
    this.custAddress = custAddress;
    }

    @Override
    public String toString() {
    return "Customer{" +
    "custId=" + custId +
    ", custName=‘" + custName + ‘‘‘ +
    ", custSource=‘" + custSource + ‘‘‘ +
    ", custLevel=‘" + custLevel + ‘‘‘ +
    ", custIndustry=‘" + custIndustry + ‘‘‘ +
    ", custPhone=‘" + custPhone + ‘‘‘ +
    ", custAddress=‘" + custAddress + ‘‘‘ +
    ‘}‘;
    }
    }

5)、测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpeTest {

@Autowired
private CustomerDao customerDao;

@Test
public void testSpec(){
    List<Customer> all = customerDao.findAll();
    for (Customer customer : all) {
        System.out.println(customer);
    }
}

/**
* save: 保存或者更新
* 根据传递的对象是否存在主键Id,如果没有id主键属性:
* 保存id主键属性,根据id查询数据,更新数据
*/
@Test
public void testSave(){
Customer customer = new Customer();
customer.setCustName("lisi");
customerDao.save(customer);
}

/**
 * 如果Id有值,就是修改,但是如果其他字段没有传入进来,会把原有的字段清空
 */
@Test
public void testUpdate(){
    Customer customer = new Customer();
    customer.setCustId(1l);
    customer.setCustName("lisi");
    customerDao.save(customer);
}

/**
 * 删除
 */
@Test
public void testDelete(){
    customerDao.delete(3l);
}

/**
 * 查询所有
 */
public void testOne(){
    Customer one = customerDao.findOne(1l);
    System.out.println(one);
}

}

使用JPQL完成查询方法

@Query: 代表是进行查询

? 此方法是用来进行更新操作

@Modifying :当前执行时一个更新操作

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor {
/**
* 案例:根据客户名称查询客户
* 使用jpql的形式查询
* jpql:from Customer where custName = ?
*
*
* 配置jpql语句,使用@Query注解
*/
@Query(value = "from Customer where custName = ?")
public Customer findJpql(String custName);

/**
*
* 使用jpql 完成更新操作
* 案例:根据id更新,客户的名称
* 更新4号客户的名称,将名称改为 hello
* sql : update cut_customer set cust_address=? where cust_id=?
* jpql: update Customer set custName = ? where custId = ?
*
* @Query : 代表是进行查询
* 此方法是用来进行更新操作
* @Modifying
* 当前执行时一个更新操作
/
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying /
如果要执行修改或删除需要添加事务*/
public void updateCustomer(long custId,String custName

 /**
 * jpql模糊查询
 * 
 * @param name
 * @return
 */
@Query(value = "from Customer where custName like ?")
public List<Object []> customerLike(String name);

}

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class JpqlTest {
@Autowired
private CustomerDao customerDao;

@Test
public void testFindJPQL(){
    Customer kzr = customerDao.findJpql("rzk");
    System.out.println(kzr);
}

/**
 * 测试jpql的更新操作
 *  springDataJpa 中使用jpql完成  更新/删除操作
 *          需要手动添加事务的支持
 *          默认会执行结束之后,回滚事务
 *
 * @Rollback:设置是否自动回滚
 *          false | true
 *
 */
@Test
@Transactional // 添加事务的支持
@Rollback(value = false)
public void testUpdateCustomer(){
    customerDao.updateCustomer(4l,"zhangsan");
}

/**
 * jpql 模糊查询
 */
@Test
public void customerLike(){
    List<Object[]> customerLike = customerDao.customerLike("z%");
    System.out.println(customerLike);

}

}

TransactionRequiredException: Executing an update/delete query

添加或删除出现的错误

需要添加事务
使用sql完成查询+模糊查询

dao 层

public interface CustomerDao extends JpaRepository<Customer,Long>, JpaSpecificationExecutor {
/**
* 案例:根据客户名称查询客户
* 使用jpql的形式查询
* jpql:from Customer where custName = ?
*
*
* 配置jpql语句,使用@Query注解
*/
@Query(value = "from Customer where custName = ?")
public Customer findJpql(String custName);

/**
 *
 * @param name
 * @param id
 * @return
 *
 * 案例:根据用户名称和用户id查询
 * jpql : from Customer where cusstName = ? and custId = ?
 *
 * 对于多个占位符参数
 *      赋值的时候,默认的情况下,占位符的位置需要和方法参数中位置保持一致
 *
 *  可以指定占位符的位置
 *      ?索引的方式,指定此占位符的取值来源
 */
@Query(value = "from Customer where custName = ?2 and custId = ?1")
public Customer findCustNameAndId(Long id,String name);

/**
 *
 * 使用jpql 完成更新操作
 *      案例:根据id更新,客户的名称
 *          更新4号客户的名称,将名称改为 hello
 *  sql : update cut_customer set cust_address=? where cust_id=?
 *  jpql: update Customer set custName = ? where custId = ?
 *
 * @Query : 代表是进行查询
 *      此方法是用来进行更新操作
 * @Modifying
 *      当前执行时一个更新操作
 */
@Query(value = "update Customer set custName = ?2 where custId = ?1")
@Modifying  /*如果要执行修改或删除需要添加事务*/
public void updateCustomer(long custId,String custName);

/**
 * 使用sql的形式查询
 *      查询全部的客户
 *  sql : select * from cst_customer;
 *  Query:配置sql查询
 *      value : sql语句
 *      naiveQuery:查询方式
 *          true:sql查询
 *          false:jpql查询
 *
 */
@Query(value = "select  * from cst_customer",nativeQuery = true)
public List<Object []> findSql();

/**
 * 根据用户名 模糊查询
 *
 */
@Query(value = "select * from cst_customer where cust_name like ?",nativeQuery = true)
public List<Object []> findSqlLike(String name);

}

测试

@Test
@Transactional // 添加事务的支持
@Rollback(value = false)
public void testFindSql(){
    List<Object[]> list = customerDao.findSql();
    for (Object[] obj : list) {
        System.out.println(Arrays.toString(obj));
    }
}

@Test
public void testFindLike(){
    List<Object[]> sqlLike = customerDao.findSqlLike("r%");
    for (Object[] objects : sqlLike) {
        System.out.println(Arrays.toString(objects));
    }
}

方法名称规则查询+ 模糊查询

是对jpql查询,更加深入的一层封装
我们只需按照SpringDataJpa 提供的方法名称规则定义方法,不需要再去配置jpql语句,完成查询
findBy开头 : 代表查询
    对象中属性名称(首字母大写)
1)、findBy + 属性名称(根据属性名称进行完成匹配的查询 = )
2)、findby + 属性名称 + “查询方式”(Like | isnull)
    findByCustNameLike
3)、多条件查询
    findBy + 属性名 + 查询方式 + 多条件的连接符 (and | or)

/**
 * 方法名的约定
 *      findBy :查询
 *              对象中的属性名(首字母大写) 查询条件
 *              CustName
 *
 *  findByCustName   根据客户名称查询
 *
 *  在springdataJpa的运行阶段
 *      会根据方法名称进行解析  findBy  from *** (实体类)
 *                                  属性名称   where custName
 *
 */
public Customer findByCustName(String custName);

测试

//测试方法名规则的查询
@Test
public void TestName(){
    Customer customer = customerDao.findByCustName("zhukai");
    System.out.println(customer);
}

回顾

SpringDataJpa,jpa规范,hibernate三者之间的关系
    code ---> springDatajpa ---> jpa规范的API --->hibernate
符合SpringDataJpa规范的dao层接口的编写规则
    需要实现两个接口(jpaRepository,JpaSpecificationExecutor)
    提供响应的泛型
运行过程
    动态代理的方式:动态代理对象
查询

多表查询
SpecificationExecutor动态查询

方法列表

//查询单个对象
T findOne(Specification var1);
//查询列表
List findAll(Specification var1);
//查询全部,分页
//Pageable:分页参数
//返回值:分页pageBean(page:是SpringDataJpa提供的)
Page findAll(Specification var1, Pageable var2);
//查询列表
//Sort:排序参数
List findAll(Specification var1, Sort var2);
//统计查询
long count(Specification var1);

Specification :查询条件

自定义我们自己的Specification 实现类

实现

Root:查询的根对象(查询的任何属性都可以从根对象中获取

CriteriaQuery:顶层查询对象,自定义查询方式

CriteriaBuilder:查询的构造器,封装了很多的查询条件
applicationContext.xml

<!--1、創建entityManagerFactory 对象交给spring容器管理-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!--实体类所在的包-->
    <property name="packagesToScan"  value="com.rzk.pojo"/>
    <!--jpa的供应商适配器-->
    <property name="persistenceProvider">
        <bean class="org.hibernate.jpa.HibernatePersistenceProvider"/>
    </property>
    <!--jpa的供应商适配器-->
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <!--配置是否自动创建数据库表-->
            <property name="generateDdl" value="false"/>
            <!--指定数据类型-->
            <property name="database" value="MYSQL"/>
            <!--数据库方言,支持特有语法-->
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect"/>
            <!--是否显示sql-->
            <property name="showSql" value="true"/>
        </bean>
    </property>

    <!--jpa的方言:高级特性-->
    <property name="jpaDialect">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"/>
    </property>
</bean>

<!--2、创建数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="user" value="root"></property>
    <property name="password" value="123456"></property>
    <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/jap"></property>
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
</bean>

<!--3、整合spring dataJpa-->
<jpa:repositories base-package="com.rzk.dao" transaction-manager-ref="transactionManager"
                  entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>

<!--4、配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory"></property>
</bean>
<!--6、配置包扫描-->
<context:component-scan base-package="com.rzk"></context:component-scan>

实体类

import javax.persistence.*;

/**

  • fileName:Customer

  • description:

  • author:rzk

  • createTime:2020/8/5 20:43

  • versioni:1.0.0

  • 1、实体类和表的映射关系

  • @Entity

  • @Table

  • 2、类中属性和表中字段的映射关系

  • @Id

  • @GeneratedValue

  • @Column
    /
    @Entity
    @Table(name = "cst_customer")
    public class Customer {
    /
    *

    • @Id:声明主键配置
    • @GeneratedValue:配置主键的生成策略
    •      GenerationType.IDENTITY:自增
      
    • @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;//客户地址

    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 getCustLevel() {
    return custLevel;
    }

    public void setCustLevel(String custLevel) {
    this.custLevel = custLevel;
    }

    public String getCustIndustry() {
    return custIndustry;
    }

    public void setCustIndustry(String custIndustry) {
    this.custIndustry = custIndustry;
    }

    public String getCustPhone() {
    return custPhone;
    }

    public void setCustPhone(String custPhone) {
    this.custPhone = custPhone;
    }

    public String getCustAddress() {
    return custAddress;
    }

    public void setCustAddress(String custAddress) {
    this.custAddress = custAddress;
    }

    @Override
    public String toString() {
    return "Customer{" +
    "custId=" + custId +
    ", custName=‘" + custName + ‘‘‘ +
    ", custSource=‘" + custSource + ‘‘‘ +
    ", custLevel=‘" + custLevel + ‘‘‘ +
    ", custIndustry=‘" + custIndustry + ‘‘‘ +
    ", custPhone=‘" + custPhone + ‘‘‘ +
    ", custAddress=‘" + custAddress + ‘‘‘ +
    ‘}‘;
    }
    }

dao层

Predicate toPredicate(Root var1, CriteriaQuery<?> var2, CriteriaBuilder var3);//封装查询条件

多表之间的关系和操作多表的操作步骤
测试
根据客户名称查询,查询客户名为rzk的客户

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpecTest {

@Autowired
private CustomerDao customerDao;

/**
 * 查詢单个
 */
@Test
public void findOneSpec(){
    //匿名内部类
    /**
     * 自定义查询条件
     *      1.实现Specification接口(提供泛型:查询的对象类型)
     *      2.实现toPredicate方法(构造查询条件)
     *      3.需要借助方法参数中的两个参数(
     *          root:获取需要查询的对象属性)
     *          CriteriaBuilder:够着查询条件的,内部封装了很多的查询条件(模糊查询)
     *
     *  案例:根据客户名称查询,查询客户名为rzk的客户
     *         查询条件:
     *              1.查询方式
     *                  cb对象
     *              2.比较的属性名称
     *                  root对象
     */
    Specification<Customer> spec = new Specification<Customer>() {
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
            //1.获取比较的属性
            Path<Object> custName = root.get("custName");
            //2.构造查询条件  ---->   select * from cst_customer where cust_name = "rzk"
            /**
             *  第一个参数: 需要比较的属性(path对象)
             *  第二个参数:当前需要比较的取值
             */
            Predicate rzk = criteriaBuilder.equal(custName, "rzk");//进行精准的匹配  (比较的属性,比较的属性的取值)
            return rzk;
        }
    };
    Customer one = customerDao.findOne(spec);
    System.out.println(one);
}

错误

如果报错这个错

org.springframework.dao.IncorrectResultSizeDataAccessException: result returns more than one elements; nested exception is javax.persistence.NonUniqueResultException: result returns more than one elements

根据客户名(rzk)和客户所属行业查询 多条件查询

/**
 * 多条件查询
 *      案例:根据客户名(传智播客)和客户所属行业查询
 *
 */
@Test
public void findAllSpec(){
    /**
     * root:获取属性
     *      客户名
     *      所属行业
     * CriteriaBuilder:构造查询
     *      1.构造客户名的精准匹配查询
     *      2.构造所属行业的精准匹配查询
     *      3.将以上两个查询联系起来
     *
     */
    Specification<Customer> spec = new Specification<Customer>() {
        @Override
        public Predicate toPredicate(Root<Customer> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
            Path<Object> custName = root.get("custName");//客户名
            Path<Object> custIndustry = root.get("custIndustry");//所属行业

            //构造查询
            //1.构造客户名的精准匹配查询
            Predicate p1 = criteriaBuilder.equal(custName, "rui");//第一个参数,path(属性),第二个参数,属性的取值
            //2.构造客户名的精准匹配查询
            Predicate p2 = criteriaBuilder.equal(custIndustry, "student");
            //3.将多个查询条件组合到一起:组合(满足条件一并且满足条件二,与关系  ,满足条件一或满足条件二,或关系)
            Predicate predicate = criteriaBuilder.and(p1, p2);
            return predicate;
        }
    };

    Customer one = customerDao.findOne(spec);
    System.out.println(one);
    List<Customer> daoAll = customerDao.findAll(spec);
    for (Customer customer : daoAll) {
        System.out.println(customer);
    }

这个异常是说明数据库中的数据本应该是唯一的 但是是重复了 是数据的问题不是代码问题

查询的数据库的条数有两条或以上就会报错

完成多表操作

一对多操作

多对多操作

Spring Data JPA (二)

原文:https://www.cnblogs.com/rzkwz/p/13497687.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!