SpringData JPA只是SpringData中的一个子模块

JPA是一套标准接口，而Hibernate是JPA的实现

SpringData JPA 底层默认实现是使用Hibernate

1.      添加pom

<dependencies>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-test</artifactId>

</dependency>

<dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

<version>8.0.11</version><!--$NO-MVN-MAN-VER$-->

</dependency>

<!-- swagger -->

<dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger2</artifactId>

<version>2.8.0</version>

</dependency>

<dependency>

<groupId>io.springfox</groupId>

<artifactId>springfox-swagger-ui</artifactId>

<version>2.8.0</version>

</dependency>

<!-- 开发者工具，当classpath下有文件更新自动触发应用重启 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-devtools</artifactId>

<optional>true</optional>

</dependency>

<dependency>

<groupId>org.hibernate.javax.persistence</groupId>

<artifactId>hibernate-jpa-2.1-api</artifactId>

<version>1.0.2.Final</version>

</dependency>

<!-- 使用缓存 -->

<dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-cache</artifactId>

</dependency>

</dependencies>

2.      db链接设置 application.properties

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

Ø  create：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。

Ø  create-drop：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。

Ø  update：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。

Ø  validate：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

Ø  none: 启动时不做任何操作

#springfox.documentation.swagger.v2.path=/api-docs

#server.contextPath=/v2

server.port=8080

swagger.enable=true

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT&useSSL=false&allowPublicKeyRetrieval=true

spring.datasource.username=root

spring.datasource.password=1234

#只会执行ddl

spring.jpa.hibernate.ddl-auto=update

spring.jpa.show-sql=true

spring.jackson.serialization.indent_output=true

spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect

3.      DDL

dropdatabaseifexists mybatis;

createdatabase mybatis;

use mybatis;

createtablemybatis.CUSTOMERS (

ID bigint auto_increment notnull,

NAMEvarchar(15) notnull,

EMAIL varchar(128) ,

PASSWORDvarchar(8) ,

PHONE int ,

ADDRESS varchar(255),

SEX char(1) ,

IS_MARRIED bit,

DESCRIPTION text,

IMAGE blob,

BIRTHDAY date,

REGISTERED_TIME timestamp,

primarykey (ID)

);

INSERTINTOmybatis.CUSTOMERS (NAME,PHONE,ADDRESS) VALUES ('老赵', '123456' , 'address 1');

INSERTINTOmybatis.CUSTOMERS (NAME,PHONE,ADDRESS) VALUES ('老王', '654321' , 'address 2');

会自动执行DDL

4.      配置SwaggerConfig

5.      使用jpa生成Customers实体

注意：需要在自增的id get方法上加上@GeneratedValue(strategy =GenerationType.AUTO)

@Id

@Column(name = "ID", unique = true, nullable = false)

@GeneratedValue(strategy = GenerationType.AUTO)

public Long getId() {

returnthis.id;

}

6.      生产CustomersJpaRepository和CustomersRepository

注意：sql里的表名必须和对象名完全一致，包括大小写

package com.example.repository;

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

import com.example.domain.Customers;

publicinterface CustomersJpaRepository extends JpaRepository<Customers,Long>{

}

package com.example.repository;

import java.util.List;

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

import org.springframework.data.repository.Repository;

import org.springframework.data.repository.query.Param;

import com.example.domain.Customers;

//注意：sql里的表名必须和对象名完全一致，包括大小写

publicinterface CustomersRepository extends Repository<Customers,Long>{

@Query(value = "fromCustomers o where id=(select max(id) from Customers p)")

public Customers getCustomersByMaxId();

@Query(value = "fromCustomers o where o.name=?1 and o.phone=?2")

public List<Customers> queryParams1(String name, Integer phone);

@Query(value = "fromCustomers o where o.name=:name and o.phone=:phone")

public List<Customers> queryParams2(@Param("name")String name, @Param("phone")Integer phone);

@Query(value = "fromCustomers o where o.name like %?1%")

public List<Customers> queryLike1(String name);

@Query(value = "fromCustomers o where o.name like %:name%")

public List<Customers> queryLike2(@Param("name")String name);

@Query(nativeQuery = true, value = "select count(1) from Customers o")

publiclong getCount();

}

Repository：是SpringData的一个核心接口，它不提供任何方法，开发者需要在自己定义的接口中声明需要的方法。

CrudRepository：继承Repository，提供增删改查方法，可以直接调用。

PagingAndSortingRepository：继承CrudRepository，具有分页查询和排序功能（本类实例）

JpaRepository：继承PagingAndSortingRepository，针对JPA技术提供的接口

JpaSpecificationExecutor：可以执行原生SQL查询

继承不同的接口，有两个不同的泛型参数，他们是该持久层操作的类对象和主键类型。

7.      配置customersService并且加缓存

package com.example.service;

import java.util.List;

import org.springframework.data.repository.query.Param;

import com.example.domain.Customers;

publicinterface CustomersService {

public Customers getCustomersByMaxId();

public List<Customers> queryParams1(String name, Integer phone);

public List<Customers> queryParams2(@Param("name")String name, @Param("phone")Integer phone);

public List<Customers> queryLike1(String name);

public List<Customers> queryLike2(@Param("name")String name);

publiclong getCount();

public List<Customers> findAll();

public Customers findOne(Long id);

publicvoid delete(longid);

publicvoid deleteAll();

publicvoid save(List<Customers> entities);

publicvoid save(Customers entity);

}

package com.example.service.impl;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.cache.annotation.CacheConfig;

import org.springframework.cache.annotation.Cacheable;

import org.springframework.stereotype.Service;

importorg.springframework.transaction.annotation.Transactional;

import com.example.domain.Customers;

import com.example.repository.CustomersJpaRepository;

import com.example.repository.CustomersRepository;

import com.example.service.CustomersService;

@Service(value = "customersService")

@Transactional

@CacheConfig(cacheNames = "customers")

publicclass CustomersServiceImpl implements CustomersService{

@Autowired

private CustomersRepository customersRepository;

@Autowired

private CustomersJpaRepository customersJpaRepository;

@Override

@Cacheable

public Customers getCustomersByMaxId() {

returncustomersRepository.getCustomersByMaxId();

}

@Override

@Cacheable

public List<Customers> queryParams1(String name, Integer phone) {

returncustomersRepository.queryParams1(name, phone);

}

@Override

@Cacheable

public List<Customers> queryParams2(String name, Integer phone) {

return customersRepository.queryParams2(name, phone);

}

@Override

@Cacheable

public List<Customers> queryLike1(String name) {

return customersRepository.queryLike1(name);

}

@Override

@Cacheable

public List<Customers> queryLike2(String name) {

return customersRepository.queryLike2(name);

}

@Override

@Cacheable

publiclong getCount() {

return customersRepository.getCount();

}

@Override

@Cacheable

public List<Customers> findAll() {

returncustomersJpaRepository.findAll();

}

@Override

@Cacheable

public Customers findOne(Long id) {

returncustomersJpaRepository.findOne(id);

}

@Override

@Cacheable

publicvoid deleteAll(){

customersJpaRepository.deleteAll();

}

@Override

@Cacheable

publicvoid delete(longid){

customersJpaRepository.delete(id);

}

@Override

@Cacheable

publicvoid save(List<Customers> entities){

customersJpaRepository.save(entities);

}

@Override

@Cacheable

publicvoid save(Customers entity){

customersJpaRepository.save(entity);

}

}

8.      配置CustomersController

package com.example.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.data.repository.query.Param;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RestController;

import com.example.domain.Customers;

import com.example.service.CustomersService;

@RestController

@RequestMapping("/customers")

publicclass CustomersController {

@Autowired

private CustomersService customersService;

@RequestMapping(value="getCustomersByMaxId", method=RequestMethod.GET)

public Customers getCustomersByMaxId(){

returncustomersService.getCustomersByMaxId();

}

@RequestMapping(value="queryParams1/{name}/{phone}", method=RequestMethod.POST)

public List<Customers> queryParams1(String name, Integer phone){

returncustomersService.queryParams1(name, phone);

}

//http://localhost:8080/customers/queryParams2/%7Bname%7D/%7Bphone%7D?name=老赵&phone=123456

@RequestMapping(value="queryParams2/{name}/{phone}", method=RequestMethod.POST)

public List<Customers> queryParams2(@Param("name")String name, @Param("phone")Integer phone){

returncustomersService.queryParams2(name, phone);

}

@RequestMapping(value="queryLike1/{name}", method=RequestMethod.POST)

public List<Customers> queryLike1(String name){

returncustomersService.queryLike1(name);

}

//http://localhost:8080/customers/queryLike2/%7Bname%7D?name=老王

@RequestMapping(value="queryLike2/{name}", method=RequestMethod.POST)

public List<Customers> queryLike2(@Param("name")String name){

returncustomersService.queryLike2(name);

}

@RequestMapping(value="getCount", method=RequestMethod.GET)

publiclong getCount(){

returncustomersService.getCount();

}

@RequestMapping(value="findAll", method=RequestMethod.GET)

public List<Customers> findAll() {

returncustomersService.findAll();

}

@RequestMapping(value="findOne", method=RequestMethod.POST)

public Customers findOne(Long id) {

returncustomersService.findOne(id);

}

@RequestMapping(value="deleteAll", method=RequestMethod.GET)

publicvoid deleteAll(){

customersService.deleteAll();

}

@RequestMapping(value="delete", method=RequestMethod.POST)

publicvoid delete(longid){

customersService.delete(id);

}

@RequestMapping(value="saveAll", method=RequestMethod.POST)

publicvoid save(List<Customers> entities){

customersService.save(entities);

}

@RequestMapping(value="save", method=RequestMethod.POST)

publicvoid save(Customers entity){

customersService.save(entity);

}

}

9.      配置启动项DemoApplication

package com.example;

import org.springframework.boot.SpringApplication;

importorg.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication

@EnableCaching

publicclass DemoApplication {

publicstaticvoid main(String[] args) {

SpringApplication.run(DemoApplication.class, args);

}

//to visithttp://localhost:8080/swagger-ui.html

}