一、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);
    }