前往小程序，Get更优阅读体验！
立即前往
文档建议反馈控制台
首页
学习
活动
专区
圈层
工具
MCP广场
文章/答案/技术大牛
发布
首页
学习
活动
专区
圈层
工具
MCP广场
返回腾讯云官网
社区首页 >专栏 >SpringDataJPA

SpringDataJPA

原创
作者头像
Java鱼头
发布于 2022-12-01 14:54:21
发布于 2022-12-01 14:54:21
1.6K00
代码可运行
举报
文章被收录于专栏：Java-docJava-doc
运行总次数：0
代码可运行
关联问题
换一批

三、SpringDataJPA介绍

1. 入门案例

1.1 创建项目

创建一个普通的Maven项目

1.2 添加相关的依赖

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.8</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>5.0.7.Final</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.9.0.RELEASE</version>
        </dependency>
    </dependencies>

1.3 添加配置文件

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/logistics?characterEncoding=utf-8&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456
​

Spring的配置文件

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
<?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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.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
">
    <!-- 引入db.properties文件 -->
    <context:property-placeholder location="classpath:db.properties" />
    <!-- 创建druid 的数据源 -->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="url" value="${jdbc.url}" />
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password"  value="${jdbc.password}" />
    </bean>
​
    <!-- 配置Hibernate的SessionFactory对象 id必须得是 ： entityManagerFactory -->
    <bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
          id="entityManagerFactory">
        <!-- 关联数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- 配置Hibernate的属性信息 -->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="database" value="MYSQL"/>
                <property name="generateDdl" value="true"/>
                <property name="showSql" value="true"/>
            </bean>
            <!--<props>
                <prop key="show_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>-->
        </property>
        <!-- 扫描路径 -->
        <property name="packagesToScan">
            <list>
                <value>com.bobo.pojo</value>
            </list>
        </property>
    </bean>
​
​
    <!--  配置事务管理-->
    <bean class="org.springframework.orm.jpa.JpaTransactionManager" id="transactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
​
    <!-- 配置开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager" />
​
    <!-- 配置扫描路径 -->
    <context:component-scan base-package="com.bobo" />
​
    <!--  Spring Data Jpa 配置-->
    <!-- 配置Dao的扫描 -->
    <jpa:repositories base-package="com.bobo.dao" />
</beans>

1.4 创建POJO对象

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.pojo;
​
​
import javax.persistence.*;
import java.io.Serializable;
​
@Entity
@Table(name="t_user")
public class Users implements Serializable {
​
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="user_id")
    private Integer userId;
​
    @Column(name="user_name")
    private String userName;
​
    @Column(name="real_name")
    private String realName;
​
    public Integer getUserId() {
        return userId;
    }
​
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
​
    public String getUserName() {
        return userName;
    }
​
    public void setUserName(String userName) {
        this.userName = userName;
    }
​
    public String getRealName() {
        return realName;
    }
​
    public void setRealName(String realName) {
        this.realName = realName;
    }
​
    @Override
    public String toString() {
        return "Users{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", realName='" + realName + '\'' +
                '}';
    }
}
​

1.5 创建持久层

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.JpaRepository;
​
public interface UserDao extends JpaRepository<Users,Integer> {
​
}

1.6 单元测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDao;
import com.bobo.pojo.Users;
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("classpath:applicationContext.xml")
public class Test1 {
​
    @Autowired
    private UserDao dao;
​
​
    @Test
    @Transactional
    @Rollback(false)
    public void test1(){
        Users user = new Users();
        user.setUserName("admin-jpa");
        user.setRealName("测试");
        dao.save(user);
    }
}
​

2. Repository接口

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
public interface Repository<T, ID extends Serializable> {
}

Repository 接口是 Spring Data JPA 中为我我们提供的所有接口中的顶层接口,而且是个标志接口，Repository 提供了两种查询方式的支持 1）基于方法名称命名规则查询 2）基于@Query 注解查询

2.1 基于方法名称命名规则查询

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.dao;
​
import com.bobo.pojo.Users;
import org.springframework.data.repository.Repository;
​
import javax.persistence.criteria.CriteriaBuilder;
import java.util.List;
​
/**
 * Repository接口的使用
 */
public interface UserDaoRepository extends Repository<Users, Integer> {
​
    List<Users> findByUserNameIs(String string);
​
    List<Users> findByUserNameLike(String username);
​
    List<Users> findByUserNameAndRealNameIs(String name,String realName);
}
​

测试代码

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoRepository;
import com.bobo.pojo.Users;
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;
​
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test2 {
​
    @Autowired
    private UserDaoRepository dao;
​
    @Test
    @Transactional
    @Rollback(false)
    public void query1(){
        List<Users> list = this.dao.findByUserNameIs("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query2(){
        List<Users> list = this.dao.findByUserNameLike("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query3(){
        List<Users> list = this.dao.findByUserNameAndRealNameIs("Tom","张三丰");
        for (Users users : list) {
            System.out.println(users);
        }
    }
}
​

2.2 基于@Query 注解查询

通过上面的命令的方式使用的情况，如果查询条件比较复杂的情况下，那么方法的名称会很长，不是很方便而且容易出错，这时我们可以通过@Query注解来实现

2.2.1 JPQL语句

JPQL：是通过Hibernate的HQL语句演变而来的，他和HQL语句很相似

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
/**
 * Repository接口的使用
 * @Query
 *    JPQL语句
 *    SQL语句
 *    更新操作
 */
public interface UserDaoRepository2 extends Repository<Users, Integer> {
​
    @Query(value = " from Users where userName =?")
    List<Users> queryUsersByNameUseJPQL(String name);
​
    @Query(value = " from Users where userName like ?")
    List<Users> queryUserLikeNameUseJPQL(String name);
​
    @Query(value = " from Users where userName= ? and realName = ?")
    List<Users> queryUserByNameAndRealName(String userName,String realName);
​
}

单元测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoRepository;
import com.bobo.dao.UserDaoRepository2;
import com.bobo.pojo.Users;
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;
​
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test3 {
​
    @Autowired
    private UserDaoRepository2 dao;
​
    @Test
    @Transactional
    @Rollback(false)
    public void query1(){
        List<Users> list = this.dao.queryUsersByNameUseJPQL("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query2(){
        List<Users> list = this.dao.queryUserLikeNameUseJPQL("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query3(){
        List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");
        for (Users users : list) {
            System.out.println(users);
        }
    }
}
​
2.2.2 SQL语句

声明接口

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.dao;
​
import com.bobo.pojo.Users;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
​
import java.util.List;
​
/**
 * Repository接口的使用
 * @Query
 *    JPQL语句
 *    SQL语句
 *    更新操作
 */
public interface UserDaoRepository3 extends Repository<Users, Integer> {
​
    // 在使用@Query注解 查询SQL语句的时候 nativeQuery默认是false，我们需要设置为true
    @Query(value = "select * from t_user where user_name=?",nativeQuery = true)
    List<Users> queryUsersByNameUseSQL(String name);
​
    @Query(value = "select * from t_user where user_name like ?" ,nativeQuery = true)
    List<Users> queryUserLikeNameUseSQL(String name);
​
    @Query(value = "select * from t_user where user_name = ? and real_name = ?" , nativeQuery = true)
    List<Users> queryUserByNameAndRealName(String userName,String realName);
​
}
​

单元测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoRepository2;
import com.bobo.dao.UserDaoRepository3;
import com.bobo.pojo.Users;
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;
​
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test4 {
​
    @Autowired
    private UserDaoRepository3 dao;
​
    @Test
    @Transactional
    @Rollback(false)
    public void query1(){
        List<Users> list = this.dao.queryUsersByNameUseSQL("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query2(){
        List<Users> list = this.dao.queryUserLikeNameUseSQL("Tom");
        for (Users users : list) {
            System.out.println(users);
        }
    }
​
    @Test
    @Transactional
    @Rollback(false)
    public void query3(){
        List<Users> list = this.dao.queryUserByNameAndRealName("Tom","张三丰");
        for (Users users : list) {
            System.out.println(users);
        }
    }
}
​

2.2.3 完成更新数据

@Query注解可以完成数据更新操作，但是不能实现数据的添加和删除操作

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    @Query(value = "update Users set userName = ? where userId=?")
    @Modifying// 被@Modifying修饰的方法是一个更新操作
    void updateUserNameById(String userName,Integer userId);

测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    @Test
    @Transactional
    @Rollback(false)
    public void updateTest(){
        this.dao.updateUserNameById("Tommm",25);
    }

3. CrudRepository接口

CrudRepository接口继承自Repository接口，所以Repository接口具有的功能CrudRepository接口都具有，而且又扩展了CRUD相关的功能

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
​
@NoRepositoryBean
public interface CrudRepository<T, ID extends Serializable> extends Repository<T, ID> {
    <S extends T> S save(S var1);
​
    <S extends T> Iterable<S> save(Iterable<S> var1);
​
    T findOne(ID var1);
​
    boolean exists(ID var1);
​
    Iterable<T> findAll();
​
    Iterable<T> findAll(Iterable<ID> var1);
​
    long count();
​
    void delete(ID var1);
​
    void delete(T var1);
​
    void delete(Iterable<? extends T> var1);
​
    void deleteAll();
}

应用声明接口

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
/**
 * CrudRepository接口的使用
 */
public interface UserDaoCrudRepository extends CrudRepository<Users,Integer> {
}

单元测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoCrudRepository;
import com.bobo.dao.UserDaoRepository3;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.experimental.theories.suppliers.TestedOn;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.support.CustomSQLErrorCodesTranslation;
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;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test5 {
​
    @Autowired
    private UserDaoCrudRepository dao;
​
    /**
     * 添加数据
     */
    @Test
    public void test1(){
        Users user = new Users();
        user.setRealName("成龙");
        user.setUserName("chengnong");
        dao.save(user);
    }
​
    /**
     * 批量添加数据
     */
    @Test
    public void test2(){
        List<Users> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Users user = new Users();
            user.setRealName("成龙"+i);
            user.setUserName("chengnong"+i);
            list.add(user);
        }
        dao.save(list);
    }
​
    /**
     * 查询单条数据
     */
    @Test
    public void test3(){
        Users user = dao.findOne(25);
        System.out.println(user);
    }
​
    /**
     * 查询所有的数据
     */
    @Test
    public void test4(){
        Iterable<Users> list = dao.findAll();
        Iterator<Users> iterator = list.iterator();
        while(iterator.hasNext()){
            Users user = iterator.next();
            System.out.println(user);
        }
    }
​
    /**
     * 删除数据
     */
    @Test
    public void delete1(){
        dao.delete(32);
    }
​
    /**
     * 更新数据
     */
    @Test
    public void update1(){
        // 根据save方法来实现 如果Users对象的userId属性不为空则update
        Users user = dao.findOne(34);
        user.setUserName("hahahaha");
        dao.save(user);
    }
​
    /**
     * 更新数据 方式二
     */
    @Test
    @Transactional
    @Rollback(false)
    public void update2(){
        Users user = dao.findOne(34);
        user.setUserName("aaaa"); // User 是一个持久化的状态
    }
}
​

4.PagingAndSortingRepository接口

PagingAndSortingRepository继承自CrudRepository接口，那么显然PagingAndSortingRepository就具备了CrudRepository接口的相关的功能，同时也扩展了分页和排序的功能

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID extends Serializable> extends CrudRepository<T, ID> {
    // 排序的支持
    Iterable<T> findAll(Sort var1);
    // 分页的支持
    Page<T> findAll(Pageable var1);
}

创建接口文件

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.dao;
​
import com.bobo.pojo.Users;
import org.springframework.data.repository.PagingAndSortingRepository;
​
/**
 * PagingAndSortingRepository接口的使用
 *    新增的功能是
 *       分页
 *       排序
 *    注意本接口不支持条件查询
 */
public interface UserDaoPageAndSortRepository extends PagingAndSortingRepository<Users,Integer> {
}
​

分页测试

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoCrudRepository;
import com.bobo.dao.UserDaoPageAndSortRepository;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
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;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test6 {
​
    @Autowired
    private UserDaoPageAndSortRepository dao;
​
    /**
     * 分页查询
     */
    @Test
    public void test1(){
        int page = 1; // page:当前分页的索引  从0开始
        int size = 5; // size:每页显示的条数
        PageRequest pageable = new PageRequest(page,size);
        Page<Users> pages = dao.findAll(pageable);
        System.out.println("总的条数:" + pages.getTotalElements());
        System.out.println("总的页数:" + pages.getTotalPages());
        List<Users> list = pages.getContent();
        for (Users user : list) {
            System.out.println(user);
        }
    }
}
​

排序功能

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
   /**
     * 排序
     */
    @Test
    public void test2(){
​
        // Sort.Direction.DESC 降序 ASC 升序
        Sort sort = new Sort(Sort.Direction.DESC,"userId");
        List<Users> list = (List<Users>) this.dao.findAll(sort);
        for (Users users : list) {
            System.out.println(users);
        }
    }

多条件排序

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    /**
     * 多条件排序
     */
    @Test
    public void test3(){
        Sort.Order order1 = new Sort.Order(Sort.Direction.DESC,"realName");
        Sort.Order order2 = new Sort.Order(Sort.Direction.ASC,"userId");
        Sort sort = new Sort(order1,order2);
        List<Users> list = (List<Users>) this.dao.findAll(sort);
        for (Users users : list) {
            System.out.println(users);
        }
​
    }

5. JpaRepository接口

JpaRepository接口是我们开发时使用最多接口，其特点是可以帮助我们将其他接口的方法的返回值做适配处理，可以使我们在开发的时候更方便的使用这些方法

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
@NoRepositoryBean
public interface JpaRepository<T, ID extends Serializable> extends PagingAndSortingRepository<T, ID> {
    List<T> findAll();
​
    List<T> findAll(Sort var1);
​
    List<T> findAll(Iterable<ID> var1);
​
    <S extends T> List<S> save(Iterable<S> var1);
​
    void flush();
​
    <S extends T> S saveAndFlush(S var1);
​
    void deleteInBatch(Iterable<T> var1);
​
    void deleteAllInBatch();
​
    T getOne(ID var1);
}

6. JpaSpecificationExecutor

提供的有多条件查询，并支持分页和排序功能，此接口不能单独使用，需要和其他的接口一块使用

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
/**
 * JpaSpecificationExecutor的使用
 *    JpaSpecificationExecutor 是不能够单独使用的。需要配置JPA中的其他的接口一块来使用
 */
public interface UserDaoSpecfication extends JpaRepository<Users,Integer>, JpaSpecificationExecutor {
}

6.1 单条件查询

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
package com.bobo.test;
​
import com.bobo.dao.UserDaoSpecfication;
import com.bobo.pojo.Users;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
​
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.List;
​
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Test7 {
​
    @Autowired
    private UserDaoSpecfication dao;
​
    @Test
    public void test1(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root 根对象  封装查询条件的对象
             * @param criteriaQuery 基本的查询
             * @param criteriaBuilder 创建查询条件
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Users> root
                    , CriteriaQuery<?> criteriaQuery
                    , CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                return pre;
            }
        };
​
        List<Users> list = dao.findAll(speci);
        for (Users users : list) {
            System.out.println(users);
        }
    }
}
​

6.2 多条件

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    /**
     * 多条件查询
     */
    @Test
    public void test2(){
        Specification<Users> spec = new Specification<Users>() {
            /**
             * 指定查询的条件
             * @param root
             * @param criteriaQuery
             * @param criteriaBuilder
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Users> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                List<Predicate> list = new ArrayList<>();
                list.add(criteriaBuilder.equal(root.get("userName"),"Tommm"));
                list.add(criteriaBuilder.equal(root.get("realName"),"张三丰"));
                Predicate[] arr = new Predicate[list.size()];
                return criteriaBuilder.and(list.toArray(arr));
            }
        };
        List<Users> list = dao.findAll(spec);
        for (Users users : list) {
            System.out.println(users);
        }
    }

6.3 分页

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    /**
     * 单条件+分页
     */
    @Test
    public void test3(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root 根对象  封装查询条件的对象
             * @param criteriaQuery 基本的查询
             * @param criteriaBuilder 创建查询条件
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Users> root
                    , CriteriaQuery<?> criteriaQuery
                    , CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                return pre;
            }
        };
​
        Pageable pagealbe = (Pageable) new PageRequest(0,3);
        Page page = dao.findAll(speci, pagealbe);
        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        List content = page.getContent();
        System.out.println(content);
​
    }

6.4 排序

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    /**
     * 单条件+排序
     */
    @Test
    public void test4(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root 根对象  封装查询条件的对象
             * @param criteriaQuery 基本的查询
             * @param criteriaBuilder 创建查询条件
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Users> root
                    , CriteriaQuery<?> criteriaQuery
                    , CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                return pre;
            }
        };
​
        Sort sort = new Sort(Sort.Direction.DESC,"userId");
        List<Users> list = dao.findAll(speci, sort);
        System.out.println(list);
​
    }

6.5 分页和排序

代码语言：javascript
代码运行次数：0
运行
AI代码解释
复制
    /**
     * 单条件+分页 + 排序
     */
    @Test
    public void test5(){
        Specification<Users> speci = new Specification<Users>() {
            /**
             * 定义查询条件
             * @param root 根对象  封装查询条件的对象
             * @param criteriaQuery 基本的查询
             * @param criteriaBuilder 创建查询条件
             * @return
             */
            @Override
            public Predicate toPredicate(Root<Users> root
                    , CriteriaQuery<?> criteriaQuery
                    , CriteriaBuilder criteriaBuilder) {
                Predicate pre = criteriaBuilder.equal(root.get("userName"),"Tommm");
                return pre;
            }
        };
        Sort sort = new Sort(Sort.Direction.DESC,"userId");
        // 封装分页对象的时候我们可以直接指定 排序的规则
        Pageable pagealbe = (Pageable) new PageRequest(0,3,sort);
        Page page = dao.findAll(speci, pagealbe);
        System.out.println(page.getTotalElements());
        System.out.println(page.getTotalPages());
        List content = page.getContent();
        System.out.println(content);
​
    }

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

存储
spring
单元测试
腾讯云测试服务

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

存储
spring
单元测试
腾讯云测试服务
#SpringDataJPA
评论
登录后参与评论
1 条评论
热度
最新
Java鱼头
笔记传送门：kdocs.cn/l/cgtkYcGAJdye
笔记传送门：kdocs.cn/l/cgtkYcGAJdye
回复回复点赞举报
登录 后参与评论
推荐阅读
Spring整合HibernateJPA
编程算法apispringjava
现如今的ORM框架还是比较多的比如Hibernate，TopLink以及OpenJPA等等，为了简化ORM框架的使用，JPA随之产生。
Java鱼头
2022/12/01
4041
Spring的学习笔记（十七）——SpringDataJpa动态查询和复杂的多表操作
编程算法java
有时我们在查询某个实体的时候，给定的条件是不固定的，这时就需要动态构建相应的查询语句，在Spring Data JPA中可以通过JpaSpecificationExecutor接口查询。相比JPQL,其优势是类型安全,更加的面向对象。
不愿意做鱼的小鲸鱼
2022/09/26
4.3K0
Spring全家桶之SpringData——Spring Data JPA
spring数据库sql存储jar
举例: @JoinTable(name=“t_roles_menus”,joinColumns=@JoinColumn(name=“role_id”),inverseJoinColumns=@JoinColumn(name=“menu_id”))
时间静止不是简史
2020/07/24
4K0
Spring全家桶之SpringData——Spring Data JPA
Spring整合Hibernate、Hibernate JPA、Spring Data JPA、Spring Data Redis
springxml存储
环境说明，使用Jdk1.8版本，spring4.2.0.RELEASE版本、hibernate5.0.7.Final版本，spring-data-jpa-1.9.0.RELEASE版本、spring-data-redis-1.6.0.RELEASE版本。
别先生
2020/05/27
5.8K0
Spring整合Hibernate JPA
java
JPA:就是由Sun公司提供的一套对于持久层操作的标准(接口加文档),没有具体的实现。
害恶细君
2022/11/22
1.3K0
Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate Jpa
javaspringjar
注意 1. sql语句 ,是通过对象查询的表 ,虽然可以出现select 但是却不能出现通配符 *,故可以省略 Select * 2 .区别 getCurrentSession 与openSession 方法的用法 getCurrentSession:当前session 必须要有事务边界， 且只能处理唯一的一个事务。当事务提交或者回滚后session 自动失效 openSession:每次都会打开一个新的session.加入每次使用多次。则获得的是不同session 对象。使用完毕后我们需要手动的调用colse方法关闭session
时间静止不是简史
2020/07/25
3.1K0
Spring与SpringBoot整合Spring Data JPA及使用
springjava面向对象编程存储
Spring Data JPA是Spring Data项目下的一个模块。提供了一套基于JPA标准操作数据库的简化方案，底层默认是依赖Hibernate JPA来实现的。
害恶细君
2022/11/22
4.7K0
Spring与SpringBoot整合Spring Data JPA及使用
Spring整合Hibernate
spring
Spring整合Hibernate1. 创建项目 创建一个普通的Maven项目即可图片2.添加相关的依赖 <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-orm</artifactId> <version>5.1.6.RELEASE</version> </dependency
Java鱼头
2022/12/01
9061
jdbc java_SpringBoot打包
java腾讯云测试服务存储面向对象编程https
一、SpringBootData JPA介绍   SpringData：其实SpringData就是Spring提供了一个操作数据的框架。而SpringData JPA只是SpringData框架下的一个基于JPA标准操作数据的模块。   SpringData JPA：基于JPA的标准数据进行操作。简化操作持久层的代码。只需要编写接口就可以。 二、SpringBoot整合SpringData JPA 1、导入maven依赖  在原有的SprigBoot的maven依赖的基础下加上JPA的依赖
全栈程序员站长
2022/11/01
1.7K0
jdbc java_SpringBoot打包
SpringDataJPA之JpaRepository和JpaSpecificationExecutor接口
单元测试
  JpaRepository 接口是我们开发时使用的最多的接口。其特点是可以帮助我们将其他接口的方法的返回值做适配处理。可以使得我们在开发时更方便的使用这些方法。
用户4919348
2019/05/19
9.7K0
Spring Boot整合Spring Data JPA
springjava存储编程算法面向对象编程
首先说明一下，这里使用的是Springboot2.2.6.RELEASE版本，由于Springboot迭代很快，所以要注意版本问题。
别先生
2020/05/27
3.8K0
Spring的学习笔记（十六）——SpringDataJpa配置和相关的操作
springjava编程算法sql数据库
Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据库的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！
不愿意做鱼的小鲸鱼
2022/09/26
1.6K0
Spring的学习笔记（十六）——SpringDataJpa配置和相关的操作
SpringDataJPA之快速入门
javaspringmaven数据库sql
  Spring Data JPA：Spring Data JPA 是 spring data 项目下的一个模块。提供了一套基于 JPA标准操作数据库的简化方案。底层默认的是依赖 Hibernate JPA 来实现的。   Spring Data JPA 的技术特点：我们只需要定义接口并集成 Spring Data JPA 中所提供的接口就可以了。不需要编写接口实现类。
用户4919348
2019/05/19
5400
SpringBoot整合SpringDataJPA
pojo测试接口
SpringBoot整合SpringDataJPA 1. 添加依赖 图片 2. 添加配置文件 # jdbc 的相关信息 spring.datasource.driverClassName=com.
Java鱼头
2022/12/01
4061
SpringDataJPA之CrudRepository接口
存储
  CrudRepository接口继承自Repository接口，所以Repository接口具有的功能CrudRepository接口都具有，同时又扩展了CRUD相关的功能
用户4919348
2019/05/19
3.1K0
基于SpringBoot聊单元测试的分层
单元测试spring面向对象编程编程算法json
之前分享了关于质量内建的话题关于单元测试引起了大家的讨论，对于单元测试这件事情本身是比较熟悉的，但大家的反馈是比较难执行，矛盾在于很多测试做不了单元测试，或者让测试做性价比不是很高，这件事情推给开发之后又容易不了了之，其中一个很重要的点是，测试和开发没有同频对话的能力，各种细节难以敲定，落地的实际价值不容易度量，所以这篇文章我就基于常见的springboot框架，聊一聊单元测试分层的几种实践方式，从测试的视角给同学们一些知识面的拓展，也让大家熟悉下单元测试的常见玩法。
周辰晨
2022/09/20
8570
基于SpringBoot聊单元测试的分层
使用JUnit4测试Spring
springjavaxml腾讯云测试服务网络安全
注意被测试对象在Spring中不能配置AOP切面代理，否则注入到TestCase时，会产生类型不匹配的异常。因为被代理后的类型发生了变化，注入到TestCase中时，与原始的类型有区别。
WindWant
2020/09/11
6080
spring事务管理
https网络安全spring数据库sql
事务是一个不可分割操作序列，也是数据库并发控制的基本单位，其执行的结果必须使数据库从一种一致性状态变到另一种一致性状态。
逍遥壮士
2020/09/18
8100
spring事务管理
❤️爆肝万字！一文最全总结之Spring从入门到入土❤️（建议收藏）
aop腾讯云测试服务spring编程算法网络安全
Spring框架是企业使用最多的框架，没有之一。Spring是一站式框架，称之为一站式框架的原因是Spring可以整合其他框架。
Maynor
2021/10/09
5360
❤️爆肝万字！一文最全总结之Spring从入门到入土❤️（建议收藏）
Java大数据开发工程师__Spring学习笔记(待更新)
spring腾讯云测试服务java编程算法aop
1.1介绍 Spring框架是企业使用最多的框架，没有之一。Spring是一站式框架，称之为一站式框架的原因是Spring可以整合其他框架。
Maynor
2021/12/07
7060
推荐阅读
编辑精选文章
万字详解高可用架构设计Go 开发者必备：Protocol Buffers 入门指南10分钟带你彻底搞懂分布式链路跟踪
Spring整合HibernateJPA
4041
Spring的学习笔记（十七）——SpringDataJpa动态查询和复杂的多表操作
4.3K0
Spring全家桶之SpringData——Spring Data JPA
4K0
Spring整合Hibernate、Hibernate JPA、Spring Data JPA、Spring Data Redis
5.8K0
Spring整合Hibernate JPA
1.3K0
Spring全家桶之SpringData——Spring 整合Hibernate与Hibernate Jpa
3.1K0
Spring与SpringBoot整合Spring Data JPA及使用
4.7K0
Spring整合Hibernate
9061
jdbc java_SpringBoot打包
1.7K0
SpringDataJPA之JpaRepository和JpaSpecificationExecutor接口
9.7K0
Spring Boot整合Spring Data JPA
3.8K0
Spring的学习笔记（十六）——SpringDataJpa配置和相关的操作
1.6K0
SpringDataJPA之快速入门
5400
SpringBoot整合SpringDataJPA
4061
SpringDataJPA之CrudRepository接口
3.1K0
基于SpringBoot聊单元测试的分层
8570
使用JUnit4测试Spring
6080
spring事务管理
8100
❤️爆肝万字！一文最全总结之Spring从入门到入土❤️（建议收藏）
5360
Java大数据开发工程师__Spring学习笔记(待更新)
7060
相关推荐
Spring整合HibernateJPA
更多 >
Java鱼头0
LV.3
小作坊高级摸鱼攻城狮
文章
39
获赞
62
专栏
1
目录
  • 三、SpringDataJPA介绍
    • 1. 入门案例
      • 1.1 创建项目
      • 1.2 添加相关的依赖
      • 1.3 添加配置文件
      • 1.4 创建POJO对象
      • 1.5 创建持久层
      • 1.6 单元测试
    • 2. Repository接口
      • 2.1 基于方法名称命名规则查询
      • 2.2 基于@Query 注解查询
    • 3. CrudRepository接口
    • 4.PagingAndSortingRepository接口
    • 5. JpaRepository接口
    • 6. JpaSpecificationExecutor
      • 6.1 单条件查询
      • 6.2 多条件
      • 6.3 分页
      • 6.4 排序
      • 6.5 分页和排序
加入讨论
的问答专区 >
小雨云0
    领券

    腾讯云开发者

    扫码关注腾讯云开发者

    扫码关注腾讯云开发者

    领取腾讯云代金券

    热门产品

    热门推荐

    更多推荐

    Copyright © 2013 - 2025 Tencent Cloud. All Rights Reserved. 腾讯云 版权所有 

    深圳市腾讯计算机系统有限公司 ICP备案/许可证号：粤B2-20090059 深公网安备号 44030502008569

    腾讯云计算（北京）有限责任公司 京ICP证150476号 |  京ICP备11018762号 | 京公网安备号11010802020287

    问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档

    Copyright © 2013 - 2025 Tencent Cloud.

    All Rights Reserved. 腾讯云 版权所有

    登录 后参与评论
    1
    1
    目录