Spring Boot：整合Spring Data JPA

朝雨憶輕塵發表於2019-06-18

綜合概述

JPA是Java Persistence API的簡稱，是一套Sun官方提出的Java持久化規範。其設計目標主要是為了簡化現有的持久化開發工作和整合ORM技術，它為Java開發人員提供了一種ORM工具來管理Java應用中的關係資料。簡而言之，JPA提供了使用物件導向的方式運算元據庫的功能。JPA充分吸收了現有Hibernate，TopLink，JDO等ORM框架的優勢，具有易於使用、伸縮性強等優點。

Spring Data JPA是Spring基於Spring Data框架對於JPA規範的一套具體實現方案，使用Spring Data JPA可以極大地簡化JPA 的寫法，幾乎可以在不寫具體實現的情況下完成對資料庫的操作，並且除了基礎的CRUD操作外，Spring Data JPA還提供了諸如分頁和排序等常用功能的實現方案。合理的使用Spring Data JPA可以極大的提高我們的日常開發效率和有效的降低專案開發成本。

實現案例

接下來，我們就通過實際案例來講解Spring Data JPA的整合，以及提供JPA相關操作的一些示例。

生成專案模板

為方便我們初始化專案，Spring Boot給我們提供一個專案模板生成網站。

1. 開啟瀏覽器，訪問：https://start.spring.io/

2. 根據頁面提示，選擇構建工具，開發語言，專案資訊等。

3. 點選 Generate the project，生成專案模板，生成之後會將壓縮包下載到本地。

4. 使用IDE匯入專案，我這裡使用Eclipse，通過匯入Maven專案的方式匯入。

新增相關依賴

清理掉不需要的測試類及測試依賴，新增 Maven 相關依賴，這裡需要新增上WEB和Swagger和JPA的依賴，Swagger的新增是為了方便介面測試。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.louis.springboot</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!-- web -->
        <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- jpa -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
        <!-- 打包時拷貝MyBatis的對映檔案 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/sqlmap/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
            <resource>  
                <directory>src/main/resources</directory>  
                    <includes> 
                        <include>**/*.*</include>  
                    </includes> 
                    <filtering>true</filtering>  
            </resource> 
        </resources>
    </build>

</project>

新增相關配置

1.新增資料來源配置

將application.properties檔案改名為application.yml ，並在其中新增MySQL資料來源連線資訊。

注意：

這裡需要首先建立一個MySQL資料庫，並輸入自己的使用者名稱和密碼。這裡的資料庫是springboot。

另外，如果你使用的是MySQL 5.x及以前版本，驅動配置driverClassName是com.mysql.jdbc.Driver。

application.yml

server:
  port: 8080
spring:
  datasource:
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&zeroDateTimeBehavior=convertToNull&autoReconnect=true&characterEncoding=utf-8
    username: root
    password: 123456
  jpa:
    show-sql: true # 預設false，在日誌裡顯示執行的sql語句
    database: mysql
    hibernate.ddl-auto: update #指定為update，每次啟動專案檢測表結構有變化的時候會新增欄位，表不存在時會新建，如果指定create，則每次啟動專案都會清空資料並刪除表，再新建
    properties.hibernate.dialect: org.hibernate.dialect.MySQL5Dialect
    database-platform: org.hibernate.dialect.MySQL5Dialect
    hibernate:
      naming:
        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl #指定jpa的自動錶生成策略，駝峰自動對映為下劃線格式
        #physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

2. 新增swagger 配置

新增一個swagger 配置類，在工程下新建 config 包並新增一個 SwaggerConfig 配置類。

SwaggerConfig.java

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("SpringBoot API Doc")
                .description("This is a restful api document of Spring Boot.")
                .version("1.0")
                .build();
    }

}

編寫業務程式碼

首先，編寫一個實體類，並新增相關注解，具體註解說明參見程式碼。

SysUser.java

package com.louis.springboot.demo.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Index;
import javax.persistence.Table;

@Entity    // @Entity: 實體類, 必須
// @Table: 對應資料庫中的表, 必須, name=表名, Indexes是宣告表裡的索引, columnList是索引的列, 同時宣告此索引列是否唯一, 預設false
@Table(name = "sys_user", indexes = {@Index(name = "id", columnList = "id", unique = true), @Index(name = "name", columnList = "name", unique = true)})
public class SysUser {
    
    @Id // @Id: 指明id列, 必須
    @GeneratedValue(strategy = GenerationType.IDENTITY) // @GeneratedValue： 表明是否自動生成, 必須, strategy也是必寫, 指明主鍵生成策略, 預設是Oracle
    private Long id;
  
    @Column(name = "name", nullable = false) // @Column： 對應資料庫列名,可選, nullable 是否可以為空, 預設true
    private String name; 

    private String password;

    private String email;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

}

然後，編寫一個SysUserDao並繼承JpaRepository，由此我們已經繼承了大部分可用的CURD操作，針對基礎操作，DAO完全不用寫任何方法。

SysUserDao.java

package com.louis.springboot.demo.dao;

import java.io.Serializable;

import org.springframework.data.jpa.repository.JpaRepository;

import com.louis.springboot.demo.model.SysUser;

public interface SysUserDao extends JpaRepository<SysUser, Long>, Serializable {
    
}

使用Spring Data JPA，可以通過兩種方式使用 JPA 進行資料持久化。

方式一：使用Spring Data JPA 提供的介面預設實現，如上面我們的DAO實現。

方式二：自定義符合Spring Data JPA規則的查詢方法，由框架將其自動解析為SQL。

Spring Data JPA提供了一些實現了基本的資料庫操作的介面類，這些介面和類的關係如下。

其中CrudRepository是頂層CURD介面，提供了一些簡單的增刪查改功能，介面定義如下。

CrudRepository.java

package org.springframework.data.repository;

import java.util.Optional;

/**
 * Interface for generic CRUD operations on a repository for a specific type.
 * @author Oliver Gierke
 * @author Eberhard Wolff
 */
@NoRepositoryBean
public interface CrudRepository<T, ID> extends Repository<T, ID> {

    /**
     * Saves a given entity. Use the returned instance for further operations as the save operation might have changed the
     * entity instance completely.
     *
     * @param entity must not be {@literal null}.
     * @return the saved entity will never be {@literal null}.
     */
    <S extends T> S save(S entity);

    /**
     * Saves all given entities.
     *
     * @param entities must not be {@literal null}.
     * @return the saved entities will never be {@literal null}.
     * @throws IllegalArgumentException in case the given entity is {@literal null}.
     */
    <S extends T> Iterable<S> saveAll(Iterable<S> entities);

    /**
     * Retrieves an entity by its id.
     *
     * @param id must not be {@literal null}.
     * @return the entity with the given id or {@literal Optional#empty()} if none found
     * @throws IllegalArgumentException if {@code id} is {@literal null}.
     */
    Optional<T> findById(ID id);

    /**
     * Returns whether an entity with the given id exists.
     *
     * @param id must not be {@literal null}.
     * @return {@literal true} if an entity with the given id exists, {@literal false} otherwise.
     * @throws IllegalArgumentException if {@code id} is {@literal null}.
     */
    boolean existsById(ID id);

    /**
     * Returns all instances of the type.
     *
     * @return all entities
     */
    Iterable<T> findAll();

    /**
     * Returns all instances of the type with the given IDs.
     *
     * @param ids
     * @return
     */
    Iterable<T> findAllById(Iterable<ID> ids);

    /**
     * Returns the number of entities available.
     *
     * @return the number of entities
     */
    long count();

    /**
     * Deletes the entity with the given id.
     *
     * @param id must not be {@literal null}.
     * @throws IllegalArgumentException in case the given {@code id} is {@literal null}
     */
    void deleteById(ID id);

    /**
     * Deletes a given entity.
     *
     * @param entity
     * @throws IllegalArgumentException in case the given entity is {@literal null}.
     */
    void delete(T entity);

    /**
     * Deletes the given entities.
     *
     * @param entities
     * @throws IllegalArgumentException in case the given {@link Iterable} is {@literal null}.
     */
    void deleteAll(Iterable<? extends T> entities);

    /**
     * Deletes all entities managed by the repository.
     */
    void deleteAll();
}

PagingAndSortingRepository在繼承了CrudRepository基礎上實現了排序和分頁的方法。

PagingAndSortingRepository.java

package org.springframework.data.repository;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

/**
 * Extension of {@link CrudRepository} to provide additional methods to retrieve entities using the pagination and
 * sorting abstraction.
 *
 * @author Oliver Gierke
 * @see Sort
 * @see Pageable
 * @see Page
 */
@NoRepositoryBean
public interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID> {

    /**
     * Returns all entities sorted by the given options.
     *
     * @param sort
     * @return all entities sorted by the given options
     */
    Iterable<T> findAll(Sort sort);

    /**
     * Returns a {@link Page} of entities meeting the paging restriction provided in the {@code Pageable} object.
     *
     * @param pageable
     * @return a page of entities
     */
    Page<T> findAll(Pageable pageable);
}

JpaRepository又在繼承PagingAndSortingRepository的基礎上，同時繼承了QueryByExampleExecutor介面，使其擁有了匹配指定樣例查詢的能力。

JpaRepository.java

package org.springframework.data.jpa.repository;

import java.util.List;
import javax.persistence.EntityManager;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.NoRepositoryBean;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.QueryByExampleExecutor;

/**
 * JPA specific extension of {@link org.springframework.data.repository.Repository}.
 *
 * @author Oliver Gierke
 * @author Christoph Strobl
 * @author Mark Paluch
 */
@NoRepositoryBean
public interface JpaRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T> {

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll()
     */
    List<T> findAll();

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Sort)
     */
    List<T> findAll(Sort sort);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable)
     */
    List<T> findAllById(Iterable<ID> ids);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable)
     */
    <S extends T> List<S> saveAll(Iterable<S> entities);

    /**
     * Flushes all pending changes to the database.
     */
    void flush();

    /**
     * Saves an entity and flushes changes instantly.
     *
     * @param entity
     * @return the saved entity
     */
    <S extends T> S saveAndFlush(S entity);

    /**
     * Deletes the given entities in a batch which means it will create a single {@link Query}. Assume that we will clear
     * the {@link javax.persistence.EntityManager} after the call.
     *
     * @param entities
     */
    void deleteInBatch(Iterable<T> entities);

    /**
     * Deletes all entities in a batch call.
     */
    void deleteAllInBatch();

    /**
     * Returns a reference to the entity with the given identifier. Depending on how the JPA persistence provider is
     * implemented this is very likely to always return an instance and throw an
     * {@link javax.persistence.EntityNotFoundException} on first access. Some of them will reject invalid identifiers
     * immediately.
     *
     * @param id must not be {@literal null}.
     * @return a reference to the entity with the given identifier.
     * @see EntityManager#getReference(Class, Object) for details on when an exception is thrown.
     */
    T getOne(ID id);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example);

    /*
     * (non-Javadoc)
     * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort)
     */
    @Override
    <S extends T> List<S> findAll(Example<S> example, Sort sort);
}

上面因為我們的SysUserDao直接繼承了JpaRepository，所以上述所有的介面SysUserDao都是可以直接使用的，當然，除了可以直接使用預設提供的基礎介面外，Spring Data JPA還允許我們自定義查詢方法，對於符合以下命名規則的方法，Spring Data JPA能夠根據其方法名為其自動生成SQL，除了使用示例中的 find 關鍵字，還支援的關鍵字有：query、get、read、count、delete等。

只要按照以下命名規範的定義的方法，Spring Data JPA都能夠幫我們自動生成SQL，無需自己實現。

接著編寫一個服務介面，新增使用者儲存、刪除、查詢全部和分頁查詢的方法。

SysUserService.java

package com.louis.springboot.demo.service;
import java.util.List;
import com.louis.springboot.demo.model.SysUser;
import com.louis.springboot.demo.util.PageQuery;

public interface SysUserService {

    /**
     * 儲存使用者
     * @param user
     */
    public void save(SysUser user);
    
    /**
     * 刪除使用者
     * @param id
     */
    public void delete(SysUser user);
    
    /**
     * 查詢全部使用者
     * @return
     */
    public List<SysUser> findAll();
    
    /**
     * 查詢分頁資料
     * @return
     */
    public Object findPage(PageQuery pageQuery);

}

繼續編寫服務實現類並呼叫DAO實現相應功能，以下DAO方法都是繼承而來的，除此之後，JPA還提供了大量的API可用。

SysUserServiceImpl.java

package com.louis.springboot.demo.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import com.louis.springboot.demo.dao.SysUserDao;
import com.louis.springboot.demo.model.SysUser;
import com.louis.springboot.demo.service.SysUserService;
import com.louis.springboot.demo.util.PageQuery;

@Service
public class SysUserServiceImpl implements SysUserService {
    
    @Autowired
    private SysUserDao sysUserDao;

    @Override
    public void save(SysUser user) {
        sysUserDao.save(user);
    }

    @Override
    public void delete(SysUser user) {
        sysUserDao.delete(user);
    }

    @Override
    public List<SysUser> findAll() {
        return sysUserDao.findAll();
    }

    @Override
    public Object findPage(PageQuery pageQuery) {
        return sysUserDao.findAll(PageRequest.of(pageQuery.getPage(), pageQuery.getSize()));
    }

}

接著編寫一個使用者控制器，呼叫服務介面實現對應功能。

SysUserController.java

package com.louis.springboot.demo.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.louis.springboot.demo.model.SysUser;
import com.louis.springboot.demo.service.SysUserService;
import com.louis.springboot.demo.util.PageQuery;

@RestController
@RequestMapping("user")
public class SysUserController {

    @Autowired
    private SysUserService sysUserService;
    
    @PostMapping(value="/save")
    public Object save(@RequestBody SysUser user) {
        sysUserService.save(user);
        return 1;
    }
    
    @PostMapping(value="/delete")
    public Object delete(@RequestBody SysUser user) {
        sysUserService.delete(user);
        return 1;
    }
    
    @GetMapping(value="/findAll")
    public Object findAll() {
        return sysUserService.findAll();
    }
    
    @PostMapping(value="/findPage")
    public Object findPage(@RequestBody PageQuery pageQuery) {
        return sysUserService.findPage(pageQuery);
    }
    
}

上面對分頁請求進行了簡單的封裝，主要包含查詢頁碼和每頁數量兩個屬性。

PageQuery.java

package com.louis.springboot.demo.util;

public class PageQuery {

    private int page;
    private int size;
    
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public int getSize() {
        return size;
    }
    public void setSize(int size) {
        this.size = size;
    }
    
}

編譯測試執行

1. 右鍵專案 -> Run as -> Maven install，開始執行Maven構建，第一次會下載Maven依賴，可能需要點時間，如果出現如下資訊，就說明專案編譯打包成功了。

2. 開啟資料庫，建立一個springboot資料庫，然後右鍵檔案 DemoApplication.java -> Run as -> Java Application，開始啟動應用，如果一開始資料庫沒有對應的表，在應用啟動時會建立，我們可以通過控制檯檢視到對應的SQL語句。

3. 開啟瀏覽器，訪問：http://localhost:8080/swagger-ui.html，進入swagger介面文件介面。

4. 首先訪問findAll介面，此時並沒有資料，所以返回結果為空。

然後呼叫save介面，分別插入以下三條資料。

{
  
  "id": 1,
  "name": "111",
  "email": "111@qq.com",
  "password": "111"
}

{
  
  "id": 2,
  "name": "222",
  "email": "222@qq.com",
  "password": "222"
}

{
  
  "id": 3,
  "name": "333",
  "email": "333@qq.com",
  "password": "333"
}

接著回來繼續呼叫findAll介面，可以看到我們已經成功的插入了三條資料。

接著測試分頁查詢介面findPage，輸入{ "page": 0, "size": 2 }，標識查詢第一頁，每頁顯示兩條記錄，下面返回正確的分頁查詢資料。

最後我們測試一下刪除介面delete，刪除掉id為1的資料，再次呼叫findAll介面，我們發現目標記錄已經成功被刪除。

參考資料

專案主頁：https://spring.io/projects/spring-data-jpa

參考文件：https://docs.spring.io/spring-data/jpa/docs/current/reference/html/

網上資料：http://www.360doc.com/content/17/0801/09/16915_675758662.shtml

網上資料：https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-jpa/index.html

原始碼下載

碼雲：https://gitee.com/liuge1988/spring-boot-demo.git

Spring Boot整合Spring Data JPA進行資料庫操作
2024-08-14
Spring Boot資料庫
Spring Boot with Spring Data JPA (1) - Concept
2016-10-18
Spring Boot
Spring Boot （五）Spring Data JPA 操作 MySQL 8
2018-09-07
Spring BootMySql
基於spring-boot&spring-data-jpa的web開發環境整合
2018-06-21
SpringbootWeb開發環境
SpringBoot整合Spring Data JPA
2020-09-25
Spring Boot
spring boot 框架spring date jpa整合shiro
2018-01-12
Spring Boot框架
Spring Data Jpa
2020-05-29
Spring
Spring Data JPA之Spring Data JPA快速入門（三）
2020-10-17
Spring
Spring Boot 2.X 如何快速整合jpa？
2019-08-12
Spring Boot
Spring Data Jpa API
2018-04-28
SpringAPI
Spring Boot(五)：Spring Boot Jpa 的使用
2016-09-21
Spring Boot
spring boot 配置 JPA
2018-12-18
Spring Boot
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
SpringBoot第九篇：整合Spring Data JPA
2019-05-23
Spring Boot
Spring Data JPA(二)：SpringBoot整合H2
2019-03-04
Spring Boot
基於Spring Boot與Spring Data JPA的多資料來源配置
2015-06-02
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-route（九）整合JPA運算元據庫
2020-10-08
Springboot
Spring Boot + JPA DataTable原始碼
2021-11-29
Spring Boot原始碼
Spring boot 四 JPA Hibernate
2017-11-04
Spring Boot
Spring Boot整合Spring Batch
2019-05-09
Spring BootBAT
Spring Boot整合Spring Security
2018-12-18
Spring Boot
Spring Boot整合Spring Aop
2020-12-14
Spring Boot
【Spring技術棧】初識Spring Data JPA
2018-08-19
Spring
Spring Boot入門系列（二十六）超級簡單！Spring Data JPA 的使用！
2021-09-13
Spring Boot
Spring Boot 2.0(八)：Spring Boot 整合 Memcached
2018-09-04
Spring Boot