Spring Data JPA之Spring Data JPA快速入門（三）

丨Jack_Chen丨發表於2020-10-17

一、Spring Data JPA概述

Spring Data JPA 是 Spring 基於 ORM 框架、JPA 規範的基礎上封裝的一套JPA應用框架，可以用極簡的程式碼實現對資料庫的訪問和操作。它提供了包括增刪改查等在內的常用功能，且易於擴充套件！使用SpringDataJpa後，dao層只需要寫介面，就自動具有了增刪改查、分頁查詢等方法。

JPA是一套規範，內部是有介面和抽象類組成的。

hibernate是一套成熟的ORM框架，而且Hibernate實現了JPA規範，hibernate為JPA的一種實現方式，使用JPA的API程式設計，意味著面向介面程式設計。

Spring Data JPA是Spring提供的一套對JPA操作更加高階的封裝，是在JPA規範下的專門用來進行資料持久化的解決方案。

二、Spring Data JPA的快速入門

1.新增依賴

使用Spring Data JPA，需要整合Spring與Spring Data JPA，並且需要提供JPA的服務提供者hibernate，所以需要匯入spring相關座標，hibernate座標，資料庫驅動座標等

 <properties>
        <spring.version>5.2.8.RELEASE</spring.version>
        <hibernate.version>5.4.3.Final</hibernate.version>
        <slf4j.version>1.7.30</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <mysql.version>5.1.6</mysql.version>
    </properties>

    <dependencies>
        <!-- junit單元測試 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>

        <!-- spring beg -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.6.8</version>
        </dependency>

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

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

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

        <!-- spring對orm框架的支援包-->
        <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核心包 -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-core</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate對jpa實現包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>${hibernate.version}</version>
        </dependency>
        <!--hibernate的校驗包-->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-validator</artifactId>
            <version>${hibernate.version}</version>
        </dependency>


        <!-- c3p0連線池-->
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>${c3p0.version}</version>
        </dependency>

        <!-- log相關 -->
        <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>


        <!--MYsql驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>

        <!-- spring data jpa-->
        <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>

        <!-- 使用spring data jpa 必須引入 -->
        <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.Spring Data JPA與Spring整合

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
		http://www.springframework.org/schema/data/jpa
		http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

    <!--spring 和 spring data jpa的配置-->

    <!-- 建立entityManagerFactory物件交給spring容器管理-->
    <bean id="entityManagerFactoty" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--配置掃描的包（實體類所在的包） -->
        <property name="packagesToScan" value="cn.ybzy.domain" />
        <!-- 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>
        
    <!--注入jpa的配置資訊
            載入jpa的基本配置資訊和jpa實現方式（hibernate）的配置資訊
            hibernate.hbm2ddl.auto : 自動建立資料庫表
                create ： 每次都會重新建立資料庫表
                update：有表不會重新建立，沒有表會重新建立表
        -->
        <property name="jpaProperties" >
            <props>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>
    </bean>

    <!--建立資料庫連線池 -->
    <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:///jpa" ></property>
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    </bean>

    <!--整合spring dataJpa-->
    <jpa:repositories base-package="cn.ybzy.dao" transaction-manager-ref="transactionManager"
                   entity-manager-factory-ref="entityManagerFactoty" ></jpa:repositories>

    <!--配置JPA事務管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactoty"></property>
    </bean>

    <!-- txAdvice-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="insert*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!-- aop-->
    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* cn.itcast.service.*.*(..))" />
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut" />
    </aop:config>

    <!-- 配置包掃描-->
    <context:component-scan base-package="cn.ybzy" ></context:component-scan>
</beans>

3.使用JPA註解配置對映關係

 //宣告實體類
@Entity
//建立實體類和表的對映關係
@Table(name="tb_user")
public class User{
	
	//宣告當前私有屬性為主鍵
	@Id
	//配置主鍵的生成策略
	@GeneratedValue(strategy=GenerationType.IDENTITY) 
	//指定和表中user_id欄位的對映關係
	@Column(name="user_id") 
	private Long userId;
	
	@Column(name="user_name") 
	//指定和表中user_name欄位的對映關係
	private String userName;
	
	@Column(name="user_address")
	//指定和表中user_address欄位的對映關係
	private String userAddress;
	
	@Column(name="user_phone")
	//指定和表中user_phone欄位的對映關係
	private String userPhone;
}

4.建立Spring Data JPA規範的Dao層介面

Spring Data JPA是spring提供的一款對於資料訪問層（Dao層）的框架，使用Spring Data
JPA，只需要按照框架的規範提供dao介面，不需要實現類就可以完成資料庫的增刪改查、分頁查詢等方法的定義。

符合Spring Data JPA規範的Dao層介面步驟：

1.建立一個Dao層介面，並實現JpaRepository和JpaSpecificationExecutor

2.提供相應的泛型

/**
 * JpaRepository<實體類型別，主鍵型別>：用來完成基本CRUD操作
 * 
 * JpaSpecificationExecutor<實體類型別>：用於複雜查詢（分頁等查詢操作）
 */
public interface UserDao extends JpaRepository<User,Long> ,JpaSpecificationExecutor<User> {
}

5.執行測試

//宣告spring提供單元測試環境
@RunWith(SpringJUnit4ClassRunner.class) 
//指定spring容器的配置資訊
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class UserDaoTest {
    @Autowired
    private UserDao userDao;
    
    @Test
    public void testFindAll() {
        List<User> list = userDao.findAll();
        for(User user : list) {
            System.out.println(user);
        }
    }
}

三、基於介面的方法列表

編寫符合Spring Data JPA 規範的Dao層介面後，就可以使用Dao層基於父類的方法，進行基本的CRUD操作。

繼承JpaRepository後的方法列表

在這裡插入圖片描述

繼承JpaSpecificationExecutor的方法列表

在這裡插入圖片描述

四、基本的CRUD

//宣告spring提供單元測試環境
@RunWith(SpringJUnit4ClassRunner.class) 
//指定spring容器的配置資訊
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class UserDaoTest {
    @Autowired
    private UserDao userDao;

    /**
     * 根據id查詢
     */
    @Test
    public void testFindOne() {
        User user = userDao.findOne(2l);
        System.out.println(user);
    }

    /**
     * save : 儲存或者更新
     *    根據傳遞的物件是否存在主鍵id，沒有id主鍵屬性：儲存，存在id主鍵屬性，根據id查詢資料，更新資料
     */
    @Test
    public void testSave() {
        User user  = new User();
        user.setUserName("大白");
        user.setUserAddress("中國");
        user.setUserPhone("8888");
        userDao.save(user);
    }

    @Test
    public void testUpdate() {
        User user  = new User();
        user.setUserId(4l);
        user.setUserName("小白白");
        userDao.save(user);
    }

    @Test
    public void testDelete () {
        userDao.delete(4l);
    }

    @Test
    public void testFindAll() {
        List<User> list = userDao.findAll();
        for(User user : list) {
            System.out.println(user);
        }
    }

    /**
     * 統計查詢：查詢使用者的總數量
     *      count:統計總條數
     */
    @Test
    public void testCount() {
    	//查詢全部使用者數量
        long count = userDao.count();
        System.out.println(count);
    }

    /**
     * 測試：判斷id為4的使用者是否存在
     *      1. 查詢id為4的使用者
     *          如果值為空，代表不存在，如果不為空，代表存在
     *      2. 判斷資料庫中id為4的使用者的數量
     *          如果數量為0，代表不存在，如果大於0，代表存在
     */
    @Test
    public void  testExists() {
        boolean exists = userDao.exists(4l);
        System.out.println("id為4的使用者 是否存在："+exists);
    }


    /**
     * 根據id從資料庫查詢
     *      @Transactional : 保證getOne正常執行
     *
     *  findOne：
     *      em.find()           :立即載入
     *  getOne：
     *      em.getReference     :延遲載入
     *      * 返回的是一個客戶的動態代理物件
     *      * 什麼時候用，什麼時候查詢
     */
    @Test
    @Transactional
    public void  testGetOne() {
        User user = userDao.getOne(2l);
        System.out.println(user);
    }

}

五、基於JPQL的查詢

Spring Data JPA提供的查詢方法已經可以解決大部分的應用場景，但是對於某些業務來說，還需要靈活的構造查詢條件，這時就可以使用@Query註解，結合JPQL的語句方式完成查詢。

@Query 註解的使用非常簡單，只需在方法上面標註該註解，同時提供一個JPQL查詢語句即可。

查詢示例

  /**
     *  jpql： from User where userName= ? and userId = ?
     * 
     * 	配置jpql語句，使用的@Query註解
     * 
     *  對於多個佔位符引數，賦值的時候，預設情況下，佔位符的位置需要和方法引數中的位置保持一致。
     *
     *  對於多個佔位符引數，賦值的時候，可以指定佔位符引數的位置
     * 
     *  ? 索引的方式，指定此佔位的取值來源
     */
	@Query(value = "from User where userName= ? and userId = ?")
    public User findUserNameAndId(String name，Long id);
    
   /**
     *  對於多個佔位符引數，賦值的時候，可以指定佔位符引數的位置
     * 
     *  ?1代表引數的佔位符，其中1對應方法中的引數索引
     */
	@Query(value = "from User where userName= ?2 and userId = ?1")
    public User findUserNameAndId(Long id,String name);

 @Test
    public void findUserNameAndId() {
       // User  user=  userDao.findUserNameAndId("大白白",1l);
        User user=  userDao.findUserNameAndId(1l,"大白白");
        System.out.println(user);
    }

更新示例

	/**
     *  sql  ：update tb_user set user_name= ? where user_id = ?
     *  jpql : update User set userName= ? where userId= ?
     *
     *  @Query : 代表進行查詢
     *  @Modifying,該操作標識為更新操作
     *
     */
    @Query(value = " update User set userName= ?2 where userId= ?1 ")
    @Modifying
    public void updateUser(long userId,String userName);

springDataJpa中使用jpql完成更新/刪除操作，需要手動新增事務的支援，預設會在執行結束之後，回滾事務。使用@Rollback : 設定是否自動回滾（false | true）

    @Test
    @Transactional //新增事務的支援
    @Rollback(value = false)
    public void testUpdateUser() {
        userDao.updateUser(10l,"大黑");
    }

六、基於SQL語句的查詢

Spring Data JPA同樣也支援sql語句的查詢。

Query : 配置sql查詢

	value ： sql語句
	
	nativeQuery ： 查詢方式（ true ： sql查詢，false：jpql查詢）

	/**
     * sql形式查詢
     * 
     *  sql ： select * from tb_user;
     * 
     *  Query : 配置sql查詢
     *      value ： sql語句
     *      nativeQuery ： 查詢方式
     *          true ： sql查詢
     *          false：jpql查詢
     *
     */
    //@Query(value = " select * from tb_user" ,nativeQuery = true)
    @Query(value="select * from tb_user where user_name like ?",nativeQuery = true)
    public List<Object [] > findSql(String name);

  @Test
    public void testFindSql() {
        List<Object[]> list = userDao.findSql("白%");
        for(Object [] obj : list) {
            System.out.println(Arrays.toString(obj));
        }
    }

七、基於方法命名規則查詢

方法命名規則查詢就是根據方法的名字，就能建立查詢。只需要按照Spring Data JPA提供的方法命名規則定義方法的名稱，就可以完成查詢工作。Spring Data JPA在程式執行的時候會根據方法名稱進行解析，並自動生成查詢語句進行查詢。

按照Spring Data JPA 定義的規則，查詢方法以findBy開頭，涉及條件查詢時，條件的屬性用條件關鍵字連線，要注意的是：條件屬性首字母需大寫。框架在進行方法名解析時，會先把方法名多餘的字首擷取掉，然後對剩下部分進行解析。

1.方法名約定概要：

查詢：findBy開頭

查詢的條件: 物件中的屬性名（首字母大寫）

預設情況 ： 使用 等於的方式查詢

方式： findBy  + 屬性名稱 + “查詢方式（Like | isnull） + 多條件的連線符（and|or）  + 屬性名 + “查詢方式”

例子：findByUserNameLIkeAndUserPhone

	//依據名稱精準匹配
    public User findByUserName(String userName);
    
    //依據名稱模糊匹配
    public List<User > findByUserNameLike(String userName);
  
    //依據名稱模糊匹配和精準匹配電話的查詢
    public List<User> findByUserNameLikeAndUserPhone(String userName,String userPhone);

  @Test
    public void findByUserNameLikeAndUserPhone() {
        User user= userDao.findByUserNameLikeAndUserPhone("白%", "66666");
        System.out.println(user);
    }

2.關鍵字、方法名約定、生成SQL檢視錶

Keyword	Sample	JPQL
And	findByUserNameAndUserPhone	where tb_user.user_name = ?1 and tb_user.user_phone= ?2
Or	findByUserNameOrUserPhone	where tb_user.user_name = ?1 or tb_user.user_phone= ?2
Equals	findByUserPhoneEquals	where tb_user.user_phone= ?1
Between	findByStartDateBetween	where tb_user.start_date between ?1 and ?2
LessThan	findByAgeLessThan	where tb_user.age < ?1
GreaterThan	findByAgeGreaterThan	where tb_user.age > ?1
GreaterThanEqual	findByAgeGreaterThanEqual	where tb_user.age >= ?1
After	findByStartDateAfter	where tb_user.start_date > ?1
Before	findByStartDateBefore	where tb_user.start_date < ?1
IsNull	findByAgeIsNull	where tb_user.age is null
IsNotNull,NotNull	findByAge(Is)NotNull	where tb_user.age not null
Like	findByUserPhoneLike	where tb_user.user_phone like ?1
NotLike	findByUserPhoneNotLike	where tb_user.user_phone not like ?
StartingWith	findByUserPhoneStartingWith	where tb_user.user_phone like ?1 (parameter bound with appended %)
EndingWith	findByUserPhoneEndingWith	where tb_user.user_phone like ?1 (parameter bound with prepended %)
Containing	findByUserPhoneContaining	where tb_user.user_phone like ?1 (parameter bound wrapped in %)
OrderBy	findByAgeOrderByUserNameDesc	where tb_user.age = ?1 order by tb_user.user_name desc
Not	findByUserNameNot	where tb_user.user_name <> ?1
In	findByAgeIn(Collection ages)	where tb_user.age in ?1
NotIn	findByAgeNotIn(Collection age)	where tb_user.age not in ?1
TRUE	findByActiveTrue()	where tb_user.active = true
FALSE	findByActiveFalse()	where tb_user.active = false
IgnoreCase	findByUserPhoneIgnoreCase	where UPPER(tb_user.user_phone) = UPPER(?1)

八、基於Specifications的動態查詢

在查詢某個實體的時候，給定的條件是不固定的，這時就需要動態構建相應的查詢語句，在Spring DataJPA中可以通過JpaSpecificationExecutor介面查詢。相比JPQL,其優勢是型別安全,更加的物件導向。

JpaSpecificationExecutor中定義的方法

 public interface JpaSpecificationExecutor<T> {
   	//根據條件查詢一個物件
 	T findOne(Specification<T> spec);	
   	//根據條件查詢集合
 	List<T> findAll(Specification<T> spec);
   	//根據條件分頁查詢
 	Page<T> findAll(Specification<T> spec, Pageable pageable);
   	//排序查詢查詢
 	List<T> findAll(Specification<T> spec, Sort sort);
   	//統計查詢
 	long count(Specification<T> spec);
 	
}

JpaSpecificationExecutor介面主要是圍繞著Specification介面定義構造的查詢條件。而Specification介面中只定義了一個方法toPredicate（）；

 public interface Specification<T> {

	/**
	 * @param root Root是一個介面，代表查詢的根物件，可以通過root獲取實體中的屬性
	 * @param query 代表一個頂層查詢物件，用來自定義查詢
	 * @param cb 用來構建查詢，此物件裡有很多條件方法
	 */
	Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder cb);
}

Root介面：

public interface Root<X> extends From<X, X> {
	/**
	 * 返回相對應的實體類
	 */
	EntityType<X> getModel();
}

CriteriaQuery介面：

在這裡插入圖片描述

CriteriaBuilder 介面：
在這裡插入圖片描述

1.根據條件查詢一個物件

    @Test
    public void testSpec1() {
    
        /**
	     * 使用匿名內部類的方式，建立一個Specification的實現類（提供泛型：查詢的物件型別），並實現toPredicate方法（構造查詢條件）。
	     * 
	     * 使用root和CriteriaBuilder兩個引數。
	     *      root獲取需要查詢的物件屬性，
	     *      CriteriaBuilder構造查詢條件，內部封裝了很多的查詢條件
	     */
        Specification<user> spec = new Specification<user>() {
            @Override
            public Predicate toPredicate(Root<user> root, CriteriaQuery<?> query, CriteriaBuilder cb) {

				//構造查詢條件 select * from tb_user where user_name = '大白'
				
                //獲取比較的屬性
                Path<Object> userName = root.get("userName");

                 //第一個引數：需要比較的屬性，第二個引數：當前需要比較的取值
                Predicate predicate = cb.equal(userName, "大白");
                return predicate;
            }
        };
        user user = userDao.findOne(spec);
        System.out.println(user);
    }

2.根據條件查詢集合

    @Test
    public void testSpec2() {
    
       /**
	     * 使用匿名內部類的方式，建立一個Specification的實現類（提供泛型：查詢的物件型別），並實現toPredicate方法（構造查詢條件）。
	     * 
	     * 使用root和CriteriaBuilder兩個引數。
	     *      root獲取需要查詢的物件屬性，
	     *      CriteriaBuilder構造查詢條件，內部封裝了很多的查詢條件
	     */
        Specification<user> spec = new Specification<user>() {
            @Override
            public Predicate toPredicate(Root<user> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
            	//獲取比較的屬性
                Path<Object> userName = root.get("userName");
                Path<Object> userAddress= root.get("userAddress");

                 //第一個引數：需要比較的屬性，第二個引數：當前需要比較的取值
                Predicate p1 = cb.equal(userName, "大白");
              
              	/**
			     * 得到path物件，根據path指定比較的引數型別，再去進行比較,類似比較有gt，lt,ge,le,like...
			     * 
			     *       指定引數型別：path.as(型別的位元組碼物件)
			     *       Predicate like = cb.ge(userName.as(userAge.class),20);
			     *
			     */
                Predicate p2 = cb.like(userAddress.as(String.class),"深圳%");
                
                /**
			     * 將多個查詢條件組合到一起
			     *      adn與關係: 滿足條件一併且滿足條件二
			     *      or或關係: 滿足條件一或滿足條件二即可
			     */
   
             	 //以與的形式拼接多個查詢條件
                Predicate and = cb.and(p1, p2);
                // Predicate or= cb.or(p1, p2);//以或的形式拼接多個查詢條件
                return and;
            }
        };
        List<User> userList = userDao.findAll(spec);
        for (User user : userList) {
            System.out.println(user);
        }
    }

3.根據條件分頁查詢

    @Test
    public void testSpec3() {
	
		//構造查詢條件，這裡不構造
        Specification spec = null;
        
       	/**
         * 要實現分頁功能，需使用PageRequest，PageRequest物件是Pageable介面的實現類
         * 
		 * 呼叫PageRequest物件的構造方法傳入兩個引數，第一個引數：當前查詢的頁數（從0開始），第二個引數：每頁查詢的數量
         */
        Pageable pageable = new PageRequest(0,5);
        //執行分頁查詢
        Page<user> page = userDao.findAll(null, pageable);
        //得到資料集合列表
        System.out.println(page.getContent()); 
        //得到總條數
        System.out.println(page.getTotalElements());
        //得到總頁數
        System.out.println(page.getTotalPages());
    }

4.根據條件排序查詢

 @Test
    public void testSpec4() {
        //構造查詢條件
        Specification<user> spec = new Specification<user>() {
            @Override
            public Predicate toPredicate(Root<user> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //獲取比較的屬性
                Path<Object> userName = root.get("userName");
                //查詢方式：模糊匹配
               Predicate like = cb.like(userName.as(String.class), "大白%");
                return like;
            }
        };

        /**
         * 
         * 建立排序物件,並呼叫構造方法例項化sort物件
         * 
         * 第一個引數：排序的順序（倒序，正序）
         *      Sort.Direction.DESC:倒序
         *      Sort.Direction.ASC ： 升序
         *      
         * 第二個引數：排序的屬性名稱
         */
        Sort sort = new Sort(Sort.Direction.DESC,"userId");
        List<user> list = userDao.findAll(spec, sort);
        for (user user : list) {
            System.out.println(user);
        }
    }

5.根據條件統計查詢

    public void testSpec5(){
        Specification<User> specification = new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path<Object> userAge = root.get("userAge");
                Predicate predicate = cb.ge(userAge.as(Number.class),20);
                return predicate;
            }
        };
        long count = userDao.count(specification);
        System.out.println("count = " + count);
    }

Spring Data Jpa
2020-05-29
Spring
Spring Data JPA的簡單入門
2020-08-10
Spring
Spring Data Jpa API
2018-04-28
SpringAPI
Spring Data JPA 參考文件三
2021-10-18
Spring
Spring Data JPA 的使用
2019-03-02
Spring
Spring Data JPA：解析CriteriaBuilder
2021-08-29
SpringUI
Spring Data JPA：解析CriteriaQuery
2021-08-30
Spring
spring data jpa查詢
2020-10-20
Spring
瞭解 Spring Data JPA
2015-01-29
Spring
spring data jpa 小結
2015-11-03
Spring
Spring Data JPA中TransactionInterceptor
2024-03-29
Spring
Spring Boot：整合Spring Data JPA
2019-06-18
Spring Boot
Spring Data JPA原始碼案例
2021-03-27
Spring原始碼
Spring Data JPA：解析SimpleJpaRepository
2021-08-26
Spring
Spring Data JPA簡單使用
2019-01-01
Spring
Spring Data JPA REST Query Criteria
2019-01-23
SpringREST
JPA/Hibernate/Spring Data概念
2017-09-26
Spring
Spring Data JPA 詳盡指南
2017-09-08
Spring
spring data jpa 常見用法
2017-06-21
Spring
Spring Boot with Spring Data JPA (1) - Concept
2016-10-18
Spring Boot
一文搞定 Spring Data JPA
2020-07-07
Spring
SpringBoot整合Spring Data JPA
2020-09-25
Spring Boot
Spring-Data-JPA criteria 查詢
2017-10-11
Spring
【Spring技術棧】初識Spring Data JPA
2018-08-19
Spring
Spring Boot （五）Spring Data JPA 操作 MySQL 8
2018-09-07
Spring BootMySql
Spring Data JPA中實現更新插入三種方法
2024-04-23
Spring
Spring Data JPA專案實戰（下）
2018-09-09
Spring
@Query註解的用法(Spring Data JPA)
2018-03-14
Spring
Spring Data JPA中ConfigurableTransactionManager
2024-03-29
Spring
Spring Data JPA中事務ReactiveTransactionManager
2024-03-29
SpringReact
Spring Data JPA系列2：SpringBoot整合JPA詳細教程，快速在專案中熟練使用JPA
2022-06-23
Spring Boot
Spring Boot入門系列（二十六）超級簡單！Spring Data JPA 的使用！
2021-09-13
Spring Boot
Spring Data JPA 實現聯表查詢
2020-03-22
Spring
使用Spring Data Jpa遇到問題彙總
2019-04-20
Spring
提高Spring Data JPA應用程式的效能
2019-01-10
Spring
隨記Spring Data JPA的幾個坑
2018-02-02
Spring
springboot(五)：spring data jpa的使用
2017-07-06
Spring Boot
Spring ORM+Hibernate？Out！換 Spring Data JPA 吧！
2016-05-15
SpringORM

Spring Data JPA之Spring Data JPA快速入門（三）

Spring Data JPA之Spring Data JPA快速入門（三）

一、Spring Data JPA概述

二、Spring Data JPA的快速入門

1.新增依賴

2.Spring Data JPA與Spring整合

3.使用JPA註解配置對映關係

4.建立Spring Data JPA規範的Dao層介面

5.執行測試

三、基於介面的方法列表

四、基本的CRUD

五、基於JPQL的查詢

六、基於SQL語句的查詢

七、基於方法命名規則查詢

1.方法名約定概要：

2.關鍵字、方法名約定、生成SQL檢視錶

八、基於Specifications的動態查詢

1.根據條件查詢一個物件

2.根據條件查詢集合

3.根據條件分頁查詢

4.根據條件排序查詢

5.根據條件統計查詢

相關文章