Spring Boot之集成JPA访问数据库

为了解决这种情况(当然也不可能完全解决啦)，我们会借用一些ORM框架来减少我们的工作负担。本章我们来学习如何在Spring Boot中集成JPA框架来访问数据库。

JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

JPA的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等价物。JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

为了抽象出不同对象的“增删改查”操作，通常我们会写一个模板Dao来简化我们的开发，而Spring-data-jpa可以更加减轻我们的开发工作量，使得数据访问层变成只是一层接口的编写方式，如下所示：

 

package com.bluecoffee.repository;

import com.bluecoffee.domain.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

/**
 * Created by qianlong on 16/9/27.
 */
public interface BookDao extends JpaRepository<Book,Long> {

    Book findByTitle(String title);

    Book findByTitleAndAuthor(String title,String author);

    @Query("from Book b where b.title=:title")
    Book findBook(@Param("title") String bookTitle);
}

我们只需要通过编写一个继承自JpaRepository的接口就能完成数据访问，下面以一个具体实例来体验Spring-data-jpa给我们带来的强大功能。

使用示例

Spring-data-jpa依赖于Hibernate。如果您已经对Hibernate有一定了解，那你可以毫不费力的看懂并上手使用Spring-data-jpa。如果您还是Hibernate新手，您可以先按如下方式入门，再建议回头学习一下Hibernate以帮助这部分的理解和进一步使用。

引入JPA依赖

pom.xml中添加JPA和MySQL数据库驱动的依赖

 

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.39</version>
        </dependency>

配置数据库连接信息

 

spring.datasource.url=jdbc:mysql://localhost:3306/spring_boot
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#spring.jpa.properties.hibernate.hbm2ddl.auto=create
#spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop
spring.jpa.properties.hibernate.hbm2ddl.auto=update
#spring.jpa.properties.hibernate.hbm2ddl.auto=validate

spring.jpa.properties.hibernate.hbm2ddl.auto是hibernate的配置属性，其主要作用是：自动创建、更新、验证数据库表结构。该参数的几种配置如下：

• create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。
• create-drop：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
• update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。
• validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

创建实体

 

package com.bluecoffee.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import java.util.Date;

/**
 * Created by qianlong on 16/10/2.
 */
@Entity
public class Book {

    @Id
    @GeneratedValue
    private Long bookId;

    @Column(nullable = false)
    private String title;

    @Column(nullable = true)
    private String author;

    @Column(name = "create_time" ,nullable = true)
    private Date createTime;

    public Book(){}

    public Book(String title,String author,Date createTime){
        this.title = title;
        this.author = author;
        this.createTime = createTime;
    }

    public Long getBookId() {
        return bookId;
    }

    public void setBookId(Long bookId) {
        this.bookId = bookId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
}

在上述代码中，注解@GeneratedValue表示bookId我们设置为主键从1开始自增，但是通常我们在实际业务开发过程中，主键需要从自定义序列中获取，我们会建一张表，然后在表中维护不同表主键的自增序列，做法如下：

新建序列号生成表

 

DROP TABLE IF EXISTS `sequence_generator`;
CREATE TABLE `sequence_generator` (
  `id` decimal(10,0) NOT NULL,
  `sequence_name` varchar(255) NOT NULL,
  `sequence_value` decimal(10,0) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

对book_store表新建自增序列

 

INSERT INTO `sequence_generator` VALUES ('1', 'book_store_pk', '10000000');

修改实体类中主键生成规则

 

 package com.bluecoffee.domain;

import javax.persistence.*;

/**
 * Created by qianlong on 16/10/2.
 */
@Entity
@Table(name="book_store")
public class BookStore {

    @Id
    @GeneratedValue(strategy = GenerationType.TABLE, generator="pk_gen")
    @TableGenerator(name = "pk_gen",
            table="sequence_generator",
            pkColumnName="sequence_name",
            valueColumnName="sequence_value",
            pkColumnValue="book_store_pk",
            allocationSize=1
    )
    private Long bookId;

    @Column(nullable = true)
    private String address;

    @Column(nullable = true)
    private String storeManager;

    public BookStore(){};

    public BookStore(String address,String storeManager){
        this.address = address;
        this.storeManager = storeManager;
    }

    public Long getBookId() {
        return bookId;
    }

    public void setBookId(Long bookId) {
        this.bookId = bookId;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getStoreManager() {
        return storeManager;
    }

    public void setStoreManager(String storeManager) {
        this.storeManager = storeManager;
    }
}

@GeneratedValue(strategy = GenerationType.TABLE, generator="pk_gen") 代表主键生成策略是从表中获取序列，序列号生成器名称为“pk_gen”

@TableGenerator的定义(Java代码)：

 

@Target({TYPE, METHOD, FIELD})   

@Retention(RUNTIME)  

public @interface TableGenerator {  

  String name();  

  String table() default "";  

  String catalog() default "";  

  String schema() default "";  

  String pkColumnName() default "";  

  String valueColumnName() default "";  

  String pkColumnValue() default "";  

  int initialValue() default 0;  

  int allocationSize() default 50;  

  UniqueConstraint[] uniqueConstraints() default {};  

}  

name：序列号生成器名称，与@GeneratedValue中的generator一致
table：表生成策略所持久化的表名，例如，这里表使用的是数据库中的“sequence_generator”。
pkColumnName：表示在持久化表中，该主键生成策略所对应键值的名称。例如在“sequence_generator”中将“sequence_name”作为主键的键值
valueColumnName：表示在持久化表中，该主键当前所生成的值，它的值将会随着每次创建累加。例如，在“sequence_generator”中将“sequence_value”作为主键的值
pkColumnValue：表示在持久化表中，该生成策略所对应的主键。例如在“sequence_generator”表中，将“sequence_name”的值为“book_store_pk”。
allocationSize：表示每次主键值增加的大小，例如设置成1，则表示每次创建新记录后自动加1，默认为50。
initialValue：表示主键初识值，默认为0。
UniqueConstraint：与@Table标记中的用法类似。

创建数据访问dao

 

package com.bluecoffee.repository;

import com.bluecoffee.domain.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

/**
 * Created by qianlong on 16/9/27.
 */
public interface BookDao extends JpaRepository<Book,Long> {

    Book findByTitle(String title);

    Book findByTitleAndAuthor(String title,String author);

    @Query("from Book b where b.title=:title")
    Book findBook(@Param("title") String bookTitle);
}

BookDao继承了==JpaRepository==，我们通过查看JpaRepository的API接口文档可以看到该接口已经实现了创建（save）、更新（save）、删除（delete）、查询（findAll、findOne）等基本操作的函数，因此对于这些基础操作的数据访问就不需要我们再开发了。

• Book findByTitle(String title);
• Book findByTitleAndAuthor(String title,String author);

findByTitle和findByTitleAndAuthor方法实现了根据书名和作者查询的方法，可以看到我们并没有编写任何SQL就完成了查询功能，这就是spring-data-jpa的一大特色：通过解析方法名创建查询。 但是我们需要注意，查询访问名称必须遵循JPA的规范，查询方法名称必须以find开头，否则就需要自己通过@Query 注解来创建查询，需要编写JPQL语句，并通过类似“:title”来映射@Param指定的参数，如下所示：

 

    @Query("from Book b where b.title=:title")
    Book findBook(@Param("title") String bookTitle);

分页查询

 

    @Query("select book from Book book where book.author = :author")
    Page findBookPage(Pageable pageable,@Param("author") String author);

单元测试

最后我们来通过编写单元测试来验证，如下代码所示：

 

package com.bluecoffee;

import com.bluecoffee.Repository.BookDao;
import com.bluecoffee.Repository.BookStoeDao;
import com.bluecoffee.domain.Book;
import com.bluecoffee.domain.BookStore;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.Date;
import java.util.Iterator;

/**
 * Created by qianlong on 16/9/27.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Application.class)
public class BookDaoTest {

    @Autowired
    private BookDao bookDao;

    @Autowired
    private BookStoeDao bookStoeDao;

    @Test
    public void testBook(){
        try{
            //先清空已有数据
            bookDao.deleteAll();

            //生成10本书
            for(int i=1;i<=10;i++){
                bookDao.save(new Book("book"+i,"author"+i,new Date()));
            }

            // 测试findAll, 查询所有记录
            Assert.assertEquals(10, bookDao.findAll().size());

            // 测试findByTitle, 查询书名为book5的书
            Assert.assertEquals("author5", bookDao.findByTitle("book5").getAuthor());

            // 测试findBook, 查询书名为book7的书
            Assert.assertEquals("author7", bookDao.findBook("book7").getAuthor());

            // 测试findByTitleAndAuthor, 查询书名为book1,作者为author1的书
            Assert.assertEquals("author1", bookDao.findByTitleAndAuthor("book1","author1").getAuthor());

            // 测试findByTitleAndAuthor, 查询书名为book2,作者为author1的书
            Assert.assertEquals(null, bookDao.findByTitleAndAuthor("book2", "author1"));

            //测试删除book3
            bookDao.delete(bookDao.findBook("book3"));

            //测试删除是否成功
            Assert.assertEquals(9, bookDao.findAll().size());

            //分页查询
            bookDao.deleteAll();
            for(int i=1;i<=10;i++){
                bookDao.save(new Book("book"+i,"Alex Qian",new Date()));
            }
            Sort sort = new Sort(Sort.Direction.DESC, "bookId");
            int page = 1;
            int size = 5;
            Pageable pageable = new PageRequest(page, size, sort);
            Page<Book> pages = bookDao.findBookPage(pageable,"Alex Qian");

            Iterator<Book> it= pages.iterator();

            Assert.assertEquals(size,pages.getSize());
            Assert.assertEquals(2,pages.getTotalPages());

            while(it.hasNext()){
                Book book = (Book)it.next();
                System.out.println("title/author/createTime:"+book.getTitle()+"/"+book.getAuthor()+"/"+book.getCreateTime());
            }

        }catch (Exception ex){
            Assert.fail(ex.getMessage());
        }
    }

    @Test
    public void testBookStore(){
        try{
            bookStoeDao.deleteAll();

            //生成5个书店
            for(int i=1;i<=5;i++){
                bookStoeDao.save(new BookStore("address_"+i,"manager_"+i));
            }
            // 测试findAll, 查询所有记录
            Assert.assertEquals(5, bookStoeDao.findAll().size());
            Assert.assertEquals(1, bookStoeDao.getBookStoreByManager("manager_2").size());
            Assert.assertEquals("manager_2", bookStoeDao.getBookStoreByManager("manager_2").get(0).getStoreManager());

        }catch (Exception ex){
            Assert.fail(ex.getMessage());
        }
    }

}

完整代码戳这里: Chapter 4-1-1 - Spring Boot集成JPA访问数据库