學習Spring Data JPA

本文轉載自查看原文 2017-05-24 11:27 2229 SpringData

簡介

Spring Data 是spring的一個子項目，在官網上是這樣解釋的：

Spring Data 是為數據訪問提供一種熟悉且一致的基於Spring的編程模型，同時仍然保留底層數據存儲的特殊特性。它可以輕松使用數據訪問技術，可以訪問關系和非關系數據庫。

簡而言之就是讓訪問數據庫能夠更加便捷。

Spring Data 又包含多個子項目：

Spring Data JPA
Spring Data Mongo DB
Spring Data Redis
Spring Data Solr

本文章主要介紹Spring Data JPA的相關知識：

傳統方式訪問數據庫

使用原始JDBC方式進行數據庫操作

創建數據表：

開發JDBCUtil工具類

獲取Connection，釋放資源，配置的屬性放在配置文件中，通過代碼的方式將配置文件中的數據加載進來。

package com.zzh.util;


import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class JDBCUtil {

    public static Connection getConnection() throws Exception {

        InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
        Properties properties = new Properties();
        properties.load(inputStream);

        String url = properties.getProperty("jdbc.url");
        String user = properties.getProperty("jdbc.user");
        String password = properties.getProperty("jdbc.password");
        String driverClass = properties.getProperty("jdbc.driverClass");
        Class.forName(driverClass);
        Connection connection = DriverManager.getConnection(url, user, password);
        return connection;
    }

    public static void release(ResultSet resultSet, Statement statement,Connection connection) {
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null) {
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

建立對象模型和DAO

package com.zzh.dao;

import com.zzh.domain.Student;
import com.zzh.util.JDBCUtil;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by zhao on 2017/5/22.
 */
public class StudentDAOImpl implements StudentDAO{

    /**
     * 查詢學生
     */
    @Override
    public List<Student> query() {

        List<Student> students = new ArrayList<>();

        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String sql = "select * from student";
        try {
            connection = JDBCUtil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            resultSet = preparedStatement.executeQuery();

            Student student = null;
            while (resultSet.next()) {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");

                student = new Student();
                student.setId(id);
                student.setAge(age);
                student.setName(name);

                students.add(student);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(resultSet,preparedStatement,connection);
        }
        return students;
    }

    /**
     * 添加學生
     */
    @Override
    public void save(Student student) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String sql = "insert into student(name,age) values (?,?)";
        try {
            connection = JDBCUtil.getConnection();
            preparedStatement = connection.prepareStatement(sql);
            preparedStatement.setString(1, student.getName());
            preparedStatement.setInt(2,student.getAge());
            preparedStatement.executeUpdate();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            JDBCUtil.release(resultSet,preparedStatement,connection);
        }
    }
}

可以看到基於原始的jdbc的編程，同一個dao方法中有太多的重復代碼。

使用Spring JdbcTemplate進行數據庫操作

Spring內置模板JdbcTemplate的出現大大提高了開發效率。

創建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:context="http://www.springframework.org/schema/context"
       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-4.0.xsd">

    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <bean id="studentDAO" class="com.zzh.dao.StudentDAOSpringJdbcImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"/>
    </bean>
</beans>

編寫查詢學生和保存學生方法

package com.zzh.dao;

import com.zzh.domain.Student;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;


public class StudentDAOSpringJdbcImpl implements StudentDAO{

    private JdbcTemplate jdbcTemplate;

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }


    @Override
    public List<Student> query() {
        final List<Student> students = new ArrayList<>();
        String sql = "select * from student";

        jdbcTemplate.query(sql, new RowCallbackHandler() {
            @Override
            public void processRow(ResultSet resultSet) throws SQLException {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                int age = resultSet.getInt("age");

                Student student = new Student();
                student.setId(id);
                student.setAge(age);
                student.setName(name);

                students.add(student);
            }
        });
        return students;
    }

    @Override
    public void save(Student student) {

        String sql = "insert into student(name,age) values (?,?)";
        jdbcTemplate.update(sql, new Object[]{student.getName(), student.getAge()});
    }
}

弊端分析

DAO中有太多的代碼
DAOImpl有大量重復的代碼
開發分頁或者其他的功能還要重新封裝

Spring Data

用上面的兩種方式進行數據庫操作可以感受到代碼的重復性和易用性都是有缺點的，現在先以一個小例子進行spring data操作數據庫的基本示范，之后再逐步分析他的具體功能。

小例子

添加pom依賴：

<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
    <version>1.8.0.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>4.3.6.Final</version>
</dependency>

創建一個新的spring配置文件：beans-new.xml:

<?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/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}"/>
        <property name="username" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>

    <!-- 配置EntityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>

        </property>
        <property name="packagesToScan" value="com.zzh"/>

        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
    </bean>

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

    <!--支持注解的事物-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--spring data-->
    <jpa:repositories base-package="com.zzh" entity-manager-factory-ref="entityManagerFactory"/>

    <context:component-scan base-package="com.zzh"/>
</beans>

LocalContainerEntityManagerFactoryBean：

適用於所有環境的FactoryBean，能全面控制EntityManagerFactory配置，非常適合那種需要細粒度定制的環境。

jpaVendorAdapter：

用於設置JPA實現廠商的特定屬性，如設置hibernate的是否自動生成DDL的屬性generateDdl，這些屬性是廠商特定的。目前spring提供HibernateJpaVendorAdapter，OpenJpaVendorAdapter，EclipseJpaVendorAdapter，TopLinkJpaVenderAdapter四個實現。

jpaProperties：

指定JPA屬性；如Hibernate中指定是否顯示SQL的“hibernate.show_sql”屬性.

建立實體類Employee：

自定義接口並繼承Repository接口

繼承的Repository接口泛型里的第一個參數是要操作的對象，即Employee；第二個參數是主鍵id的類型，即Integer。
方法即為根據名字找員工，這個接口是不用寫實現類的。為什么可以只繼承接口定義了方法就行了呢，因為spring data底層會根據一些規則來進行相應的操作。
所以方法的名字是不能隨便寫的，不然就無法執行想要的操作。

package com.zzh.repository;

import com.zzh.domain.Employee;
import org.springframework.data.repository.Repository;

public interface EmployeeRepository extends Repository<Employee,Integer>{
    Employee findByName(String name);
}

創建測試類

findByName方法體中先不用寫，直接執行空的測試方法，我們的Employee表就自動被創建了，此時表中沒有數據，向里面添加一條數據用於測試：

package com.zzh.repository;


import com.zzh.domain.Employee;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class EmployeeRepositoryTest {

    private ApplicationContext ctx = null;

    private EmployeeRepository employeeRepository = null;

    @Before
    public void setUp() throws Exception {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeeRepository = ctx.getBean(EmployeeRepository.class);
    }

    @After
    public void tearDown() throws Exception {
        ctx = null;
    }

    @Test
    public void findByName() throws Exception {
        Employee employee = employeeRepository.findByName("zhangsan");
        System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
    }

}

再執行測試類方法體中的內容：

Repository接口

Repository接口是Spring Data的核心接口，不提供任何方法
使用 @ RepositoryDefinition注解跟繼承Repository是同樣的效果，例如 @ RepositoryDefinition（domainClass = Employee.class, idClass = Integer.class)
Repository接口定義為：public interface Repository<T, ID extends Serializable> {}，Repository是一個空接口，標記接口；只要將自定義的接口繼承Repository，就會被spring來管理。

Repository的子接口

CrudRepository ：繼承 Repository，實現了CRUD相關的方法。
PagingAndSortingRepository : 繼承 CrudRepository，實現了分頁排序相關的方法。
JpaRepository ：繼承 PagingAndSortingRepository ，實現了JPA規范相關的方法。

Repository中查詢方法定義規則

上面一個例子中使用了findByName作為方法名進行指定查詢，但是如果把名字改為其他沒有規則的比如test就無法獲得正確的查詢結果。

有如下規則：

最右邊是sql語法，中間的就是spring data操作規范，現在寫一些小例子來示范一下：

先在employee表中初始化了一些數據：

在繼承了Repository接口的EmployeeRepository接口中新增一個方法：

條件是名字以test開頭，並且年齡小於22歲，在測試類中進行測試：

得到結果：

在換一個名字要在某個范圍以內並且年齡要小於某個值：

測試類：

得到結果，只有test1和test2，因為在test1，test2和test3里面，年齡還要小於22，所以test3被排除了：

弊端分析：

對於按照方法名命名規則來使用的弊端在於：

方法名會比較長
對於一些復雜的查詢很難實現

Query注解

只需要將 @ Query標記在繼承了Repository的自定義接口的方法上，就不再需要遵循查詢方法命名規則。
支持命名參數及索引參數的使用
本地查詢

案例使用：

查詢Id最大的員工信息：

 @Query("select o from Employee o where id=(select max(id) from Employee t1)")
    Employee getEmployeeById();

注意：Query語句中第一個Employee是類名

測試類：

@Test
    public void getEmployeeByMaxId() throws Exception {
        Employee employee = employeeRepository.getEmployeeByMaxId();
        System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
    }

根據占位符進行查詢

注意占位符后從1開始

    @Query("select o from Employee o where o.name=?1 and o.age=?2")
    List<Employee> queryParams1(String name, Integer age);

測試方法：

@Test
    public void queryParams1() throws Exception {
        List<Employee> employees = employeeRepository.queryParams1("zhangsan", 20);
        for (Employee employee : employees) {
            System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
        }
    }

根據命名參數的方式

   @Query("select o from Employee o where o.name=:name and o.age=:age")
    List<Employee> queryParams2(@Param("name") String name, @Param("age") Integer age);

like查詢語句

@Query("select o from Employee o where o.name like %?1%")
    List<Employee> queryLike1(String name);

@Test
    public void queryLike1() throws Exception {
        List<Employee> employees = employeeRepository.queryLike1("test");
        for (Employee employee : employees) {
            System.out.println("id:" + employee.getId() + " name:" + employee.getName() + " age:" + employee.getAge());
        }
    }

查詢包含test的記錄：

P.s 這里查詢也得到了結果，不過我的idea卻在sql語句里面提示有錯，我懷疑是我的idea版本的問題，我的是2017.1.3版本的：

like語句使用命名參數

    @Query("select o from Employee o where o.name like %:name%")
    List<Employee> queryLike2(@Param("name") String name);

本地查詢

所謂本地查詢，就是使用原生的sql語句進行查詢數據庫的操作。但是在Query中原生態查詢默認是關閉的,需要手動設置為true：

    @Query(nativeQuery = true, value = "select count(1) from employee")
    long getCount();

方法是拿到記錄數,這里使用的employee是表而不是類,也是原生態查詢的特點。

更新操作整合事物使用

在dao中定義方法根據id來更新年齡（Modifying注解代表允許修改）

    @Modifying
    @Query("update Employee o set o.age = :age where o.id = :id")
    void update(@Param("id") Integer id, @Param("age") Integer age);

要注意，執行更新或者刪除操作是需要事物支持，所以通過service層來增加事物功能,在update方法上添加Transactional注解。

package com.zzh.service;

import com.zzh.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {

    @Autowired
    private EmployeeRepository employeeRepository;

    @Transactional
    public void update(Integer id, Integer age) {
        employeeRepository.update(id,age);
    }
}

刪除操作

刪除操作同樣需要Query注解，Modifying注解和Transactional注解

    @Modifying
    @Query("delete from Employee o where o.id = :id")
    void delete(@Param("id") Integer id);

    @Transactional
    public void delete(Integer id) {
        employeeRepository.delete(id);
    }

CrudRepository接口

創建接口繼承CrudRepository

package com.zzh.repository;


import com.zzh.domain.Employee;
import org.springframework.data.repository.CrudRepository;

public interface EmployeeCrudRepository extends CrudRepository<Employee,Integer>{

}

在service層中調用

    @Autowired
    private EmployeeCrudRepository employeeCrudRepository;

存入多個對象：

    @Transactional
    public void save(List<Employee> employees) {
        employeeCrudRepository.save(employees);
    }

創建測試類,將要插入的100條記錄放在List中：

package com.zzh.repository;

import com.zzh.domain.Employee;
import com.zzh.service.EmployeeService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.ArrayList;
import java.util.List;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeCrudRepositoryTest {

    @Autowired
    private EmployeeService employeeService;

    @Test
    public void testSave() {
        List<Employee> employees = new ArrayList<>();

        Employee employee = null;
        for (int i = 0; i < 100; i++) {
            employee = new Employee();
            employee.setName("test" + i);
            employee.setAge(100 - i);
            employees.add(employee);
        }
        employeeService.save(employees);
    }
}

為了不影響之前的employee表，現在在Employee類上面加上Table注解，指定一個新的表名，之前沒有加這個注解默認使用了類名當作表名，也就是employee，現在指定新表test_employee。

執行測試類中的方法，控制台輸出了很多插入語句，打開數據庫查看，新表創建成功，同時插入了100條數據：

CrudRepository總結

可以發現在自定義的EmployeeCrudRepository中，只需要聲明接口並繼承CrudRepository就可以直接使用了。

PagingAndSortingRepository接口

該接口包含分頁和排序的功能
帶排序的查詢：findAll(Sort sort)
帶排序的分頁查詢：findAll(Pageable pageable)

自定義接口

package com.zzh.repository;


import com.zzh.domain.Employee;
import org.springframework.data.repository.PagingAndSortingRepository;

public interface EmployeePagingAndSortingRepository extends PagingAndSortingRepository<Employee, Integer> {

}

測試類

分頁：

package com.zzh.repository;

import com.zzh.domain.Employee;
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.data.domain.Pageable;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeePagingAndSortingRepositoryTest {

    @Autowired
    private EmployeePagingAndSortingRepository employeePagingAndSortingRepository;

    @Test
    public void testPage() {

        //第0頁，每頁5條記錄
        Pageable pageable = new PageRequest(0, 5);
        Page<Employee> page = employeePagingAndSortingRepository.findAll(pageable);

        System.out.println("查詢的總頁數："+ page.getTotalPages());
        System.out.println("總記錄數："+ page.getTotalElements());
        System.out.println("當前第幾頁："+ page.getNumber()+1);
        System.out.println("當前頁面對象的集合："+ page.getContent());
        System.out.println("當前頁面的記錄數："+ page.getNumberOfElements());
    }

}

排序：

在PageRequest的構造函數里還可以傳入一個參數Sort，而Sort的構造函數可以傳入一個Order，Order可以理解為關系型數據庫中的Order；Order的構造函數Direction和property參數代表按照哪個字段進行升序還是降序。

現在按照id進行降序排序：

 @Test
    public void testPageAndSort() {

        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
        Sort sort = new Sort(order);

        Pageable pageable = new PageRequest(0, 5, sort);
        Page<Employee> page = employeePagingAndSortingRepository.findAll(pageable);

        System.out.println("查詢的總頁數："+ page.getTotalPages());
        System.out.println("總記錄數："+ page.getTotalElements());
        System.out.println("當前第幾頁：" + page.getNumber() + 1);
        System.out.println("當前頁面對象的集合："+ page.getContent());
        System.out.println("當前頁面的記錄數："+ page.getNumberOfElements());
    }

可以看到id是從100開始降序排列。

JpaRepository接口

創建接口繼承JpaRepository

package com.zzh.repository;


import com.zzh.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;

public interface EmployeeJpaRepository extends JpaRepository<Employee,Integer>{
}

測試類

按id查找員工

package com.zzh.repository;

import com.zzh.domain.Employee;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeJpaRepositoryTest {

    @Autowired
    private EmployeeJpaRepository employeeJpaRepository;

    @Test
    public void testFind() {
        Employee employee = employeeJpaRepository.findOne(99);
        System.out.println(employee);
    }
}

查看員工是否存在

@Test
    public void testExists() {
        Boolean result1 = employeeJpaRepository.exists(25);
        Boolean result2 = employeeJpaRepository.exists(130);
        System.out.println("Employee-25: " + result1);
        System.out.println("Employee-130: " + result2);
    }

JpaSpecificationExecutor接口

Specification封裝了JPA Criteria查詢條件
沒有繼承其他接口。

自定義接口

這里要尤為注意，為什么我除了繼承JpaSpecificationExecutor還要繼承JpaRepository，就像前面說的，JpaSpecificationExecutor沒有繼承任何接口，如果我不繼承JpaRepository，那也就意味着不能繼承Repository接口，spring就不能進行管理，后面的自定義接口注入就無法完成。

package com.zzh.repository;


import com.zzh.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;


public interface EmployeeJpaSpecificationExecutor extends JpaSpecificationExecutor<Employee>,JpaRepository<Employee,Integer> {
}

測試類

測試結果包含分頁，降序排序，查詢條件為年齡大於50

package com.zzh.repository;

import com.zzh.domain.Employee;
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.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.persistence.criteria.*;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:beans-new.xml"})
public class EmployeeJpaSpecificationExecutorTest {

    @Autowired
    private EmployeeJpaSpecificationExecutor employeeJpaSpecificationExecutor;

    /**
     * 分頁
     * 排序
     * 查詢條件: age > 50
     */
    @Test
    public void testQuery() {

        Sort.Order order = new Sort.Order(Sort.Direction.DESC, "id");
        Sort sort = new Sort(order);

        Pageable pageable = new PageRequest(0, 5, sort);

        /**
         * root:查詢的類型（Employee）
         * query：添加查詢條件
         * cb:構建Predicate
         */
        Specification<Employee> specification = new Specification<Employee>() {
            @Override
            public Predicate toPredicate(Root<Employee> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Path path = root.get("age");
                return cb.gt(path, 50);
            }
        };

        Page<Employee> page = employeeJpaSpecificationExecutor.findAll(specification, pageable);

        System.out.println("查詢的總頁數："+ page.getTotalPages());
        System.out.println("總記錄數："+ page.getTotalElements());
        System.out.println("當前第幾頁：" + page.getNumber() + 1);
        System.out.println("當前頁面對象的集合："+ page.getContent());
        System.out.println("當前頁面的記錄數："+ page.getNumberOfElements());

    }

}

可以看到id是從50開始，而不是100，因為設定了查詢條件age>50

總結

本篇文章首先介紹以原始的jdbc方式和Spring JdbcTemplate進行數據庫相關操作，接着講解了Spring Data Jpa的Repository接口和增刪查改有關的注解，最后介紹了Repository的一些子接口相關的crud，分頁和排序。

GitHub地址：SpringDataJpa

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Spring Data JPA學習 spring data jpa入門學習 JPA & Spring Data JPA學習與使用小記學習Spring-Data-Jpa(二)---JPA基本注解學習Spring-Data-Jpa(七)---JpaRepository 學習Spring-Data-Jpa(二十)---@EnableJpaRepositories Spring Data JPA學習(一）之環境搭建 Spring-data-jpa 學習筆記（二） Spring-data-jpa 學習筆記（一）學習Spring-Data-Jpa(十八)---JPA的繼承策略