Spring Boot 整合 JPA

The Matrix

JPA介绍

JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关联映射工具来管理Java应用中的关系数据。他的出现主要是为了简化现有的持久化开发工作和整合ORM技术，结束现在Hibernate，TopLink，JDO等ORM框架各自为营的局面。值得注意的是，JPA是在充分吸收了现有Hibernate，TopLink，JDO等ORM框架的基础上发展而来的，具有易于使用，伸缩性强等优点。

注意:JPA是一套规范，不是一套产品，那么像Hibernate,TopLink,JDO他们是一套产品，如果说这些产品实现了这个JPA规范，那么我们就可以叫他们为JPA的实现产品。

Spring Data JPA

Spring Data JPA 是 Spring 基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，可使开发者用极简的代码即可实现对数据的访问和操作。它提供了包括增删改查等在内的常用功能，且易于扩展！学习并使用 Spring Data JPA 可以极大提高开发效率！Spring Data JPA让我们解脱了DAO层的操作，基本上所有CRUD都可以依赖于它来实现。

构建项目

打开pom.xml添加相关依赖

    org.springframework.boot
    spring-boot-starter-parent
    2.0.0.RELEASE
     



    UTF-8
    UTF-8
    1.8

    
                
        
            com.github.pagehelper
            pagehelper
            5.0.0
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-data-jpa
        
        
            org.springframework.boot
            spring-boot-starter-tomcat
        
        
            mysql
            mysql-connector-java
            runtime
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
    

配置数据源以及JPA

spring.datasource.url=jdbc:mysql://127.0.0.1/spring?useUnicode=true&characterEncoding=utf-8&serverTimezone=UTC&useSSL=true
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.properties.hibernate.hbm2ddl.auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.show-sql= true

#pagehelper
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.support-methods-arguments=true
pagehelper.params=count=countSql

spring.jpa.properties.hibernate.hbm2ddl.auto 是hibernate的配置属性

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

创建实体

@Entity
public class User {
    @Id
    @GeneratedValue
    private long id;

    @Column(nullable = false,unique = true)
    private String userName;

    @Column(nullable = false)
    private String passWord;

    @Column(nullable = false)
    private int age;

    ......省略set/get方法
}

继承JpaRepository接口（SpringDataJPA提供的简单数据操作接口、JpaSpecificationExecutor（复杂查询接口）、Serializable（序列化接口）。通过查看JpaRepository接口的API文档，可以看到该接口本身已经实现了创建（save）、更新（save）、删除（delete）、查询（findAll）等基本操作的函数，因此对于这些基础操作的数据访问就不需要开发者再自己定义。

public interface UserRepository extends JpaRepository,
        JpaSpecificationExecutor,
        Serializable{
}

用@RestController注解来编写一个控制器

SpringDataJPA内部使用了类代理的方式让继承了它接口的子接口都以spring管理的Bean的形式存在，我们可以直接使用@Autowired注解在spring管理bean使用。

@RestController
public class UserController {
    @Autowired
    private UserRepository userRepository;

    /*@RequestMapping(value = "/list")
    public List list(){
        return userRepository.findAll();
    }*/
    /**
     * 查询全部列表,并做分页
     *  @param pageNum 开始页数
     * @param pageSize 每页显示的数据条数
     */
    @RequestMapping(value = "/list/{pageNum}/{pageSize}")
    public List list(@PathVariable("pageNum") int pageNum, @PathVariable("pageSize") int pageSize){
        //将参数传给这个方法就可以实现物理分页了，非常简单。
        Sort sort = new Sort(Sort.Direction.ASC, "id");
        Pageable pageable = new PageRequest(pageNum, pageSize, sort);
        Page users = userRepository.findAll(pageable);
        List list =  users.getContent();
        return  list;
    }
    /**
     * 如果需要执行持久化的实体存在主键值则更新数据，如果不存在则添加数据
     */
    @RequestMapping(value = "/save")
    public User save(User user){
       return userRepository.save(user);
    }
    @RequestMapping(value = "/delete")
    public List delete(long id){
        userRepository.deleteById(id);
        return userRepository.findAll();
    }
    @RequestMapping(value = "/find")
    public User find(long id){
        return userRepository.findById(id).get();
    }
}

自定义简单查询

自定义的简单查询就是根据方法名来自动生成SQL

public interface UserRepository extends JpaRepository {
           User findByUserName(String userName);
           User findByUserNameOrEmail(String username, String email);
           Long deleteById(Long id);
           Long countByUserName(String userName);
           List findByEmailLike(String email);
           User findByUserNameIgnoreCase(String userName);
           List findByUserNameOrderByEmailDesc(String email);
           ......
}

分页查询

spring data jpa已经帮我们实现了分页的功能，在查询的方法中，需要传入参数Pageable ,当查询中有多个参数的时候Pageable建议做为最后一个参数传入

Page findALL(Pageable pageable);
    
Page findByUserName(String userName,Pageable pageable);

Pageable 是spring封装的分页实现类，使用的时候需要传入页数、每页条数和排序规则

@Test
public void testPageQuery() throws Exception {
    int page=1,size=10;
    Sort sort = new Sort(Direction.DESC, "id");
    Pageable pageable = new PageRequest(page, size, sort);
    userRepository.findALL(pageable);
    userRepository.findByUserName("testName", pageable);
}

限制查询

有时候我们只需要查询前N个元素，或者支取前一个实体。

ser findFirstByOrderByLastnameAsc();

User findTopByOrderByAgeDesc();

Page queryFirst10ByLastname(String lastname, Pageable pageable);

List findFirst10ByLastname(String lastname, Sort sort);

List findTop10ByLastname(String lastname, Pageable pageable);

自定义SQL查询

在SQL的查询方法上面使用@Query注解，如涉及到删除和修改在需要加上@Modifying.也可以根据需要添加 @Transactional 对事物的支持，查询超时的设置等。

@Modifying
@Query("update User u set u.userName = ?1 where u.id = ?2")
int modifyByIdAndUserId(String  userName, Long id);
    
@Transactional
@Modifying
@Query("delete from User where id = ?1")
void deleteByUserId(Long id);
  
@Transactional(timeout = 10)
@Query("select u from User u where u.emailAddress = ?1")
User findByEmailAddress(String emailAddress);

多表查询

多表查询在spring data jpa中有两种实现方式，第一种是利用hibernate的级联查询来实现，第二种是创建一个结果集的接口来接收连表查询后的结果，这里主要第二种方式。

首先需要定义一个结果集的接口类。

public interface HotelSummary {

    City getCity();

    String getName();

    Double getAverageRating();

    default Integer getAverageRatingRounded() {
        return getAverageRating() == null ? null : (int) Math.round(getAverageRating());
    }

}

查询的方法返回类型设置为新创建的接口

@Query("select h.city as city, h.name as name, avg(r.rating) as averageRating "
        - "from Hotel h left outer join h.reviews r where h.city = ?1 group by h")
Page findByCity(City city, Pageable pageable);

@Query("select h.name as name, avg(r.rating) as averageRating "
        - "from Hotel h left outer join h.reviews r  group by h")
Page findByCity(Pageable pageable);

使用

Page hotels = this.hotelRepository.findByCity(new PageRequest(0, 10, Direction.ASC, "name"));
for(HotelSummary summay:hotels){
        System.out.println("Name" +summay.getName());
    }

在运行中Spring会给接口（HotelSummary）自动生产一个代理类来接收返回的结果，代码汇总使用getXXX的形式来获取

多数据源的支持

---

同源数据库的多源支持

日常项目中因为使用的分布式开发模式，不同的服务有不同的数据源，常常需要在一个项目中使用多个数据源，因此需要配置sping data jpa对多数据源的使用，一般分一下为三步：

• 1 配置多数据源
• 2 不同源的实体类放入不同包路径
• 3 声明不同的包路径下使用不同的数据源、事务支持

异构数据库多源支持

比如我们的项目中，即需要对mysql的支持，也需要对mongodb的查询等。

实体类声明@Entity 关系型数据库支持类型、声明@Document 为mongodb支持类型，不同的数据源使用不同的实体就可以了。

interface PersonRepository extends Repository {
 …
}

@Entity
public class Person {
  …
}

interface UserRepository extends Repository {
 …
}

@Document
public class User {
  …
}

但是，如果User用户既使用mysql也使用mongodb呢，也可以做混合使用

interface JpaPersonRepository extends Repository {
 …
}

interface MongoDBPersonRepository extends Repository {
 …
}

@Entity
@Document
public class Person {
  …
}

也可以通过对不同的包路径进行声明，比如A包路径下使用mysql,B包路径下使用mongoDB

@EnableJpaRepositories(basePackages = "com.repositories.jpa")
@EnableMongoRepositories(basePackages = "com.repositories.mongo")
interface Configuration { }

Spring Data JPA——参考文档 中文版