SpringBoot学习-支持JPA

前面MyBaties玩的差不多了，因为新公司的项目用的是JPA，所以现在再来玩玩spring-data-jpa~
其实也是比较简单的，老规矩，首先是Maven配置

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

<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
</dependency>

然后是在配置文件中的参数设置

#打印SQL
spring.jpa.show-sql=true
logging.level.org.hibernate.type.descriptor.sql.BasicBinder = trace
logging.level.org.springframework.data=DEBUG
spring.jpa.hibernate.ddl-auto=update
spring.jpa.database-platform=org.hibernate.dialect.MySQLDialect
#数据源
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.hibernate.ddl-auto参数的作用主要用于：自动创建|更新|验证数据库表结构

validate 加载hibernate时，验证创建数据库表结构
create 每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
create-drop 加载hibernate时创建，退出是删除表结构
update 加载hibernate自动更新数据库结构

spring.jpa.database-platform参数是指定数据库方言

这样配置部分就完成了，再来瞅瞅怎么使用
文件目录：

User实体类：

package com.example.demo.entities;

import org.hibernate.annotations.GenericGenerator;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedDate;

import javax.persistence.*;

import java.util.Date;

import static javax.persistence.GenerationType.TABLE;
import static javax.persistence.TemporalType.TIMESTAMP;
/**
 * Created by lean on 2017/9/18.
 */
@Entity
@Table(name = "tab_user")
public class User {

    @Id
    @Column(name = "user_id")
    @GeneratedValue(strategy = TABLE, generator = "sequence_generator")
    @GenericGenerator(
            name = "sequence_generator",
            strategy = "org.hibernate.id.enhanced.TableGenerator",
            parameters = {
                    @org.hibernate.annotations.Parameter(name = "segment_value", value = "user"),
                    @org.hibernate.annotations.Parameter(name = "increment_size", value = "100"),
                    @org.hibernate.annotations.Parameter(name = "optimizer", value = "pooled")
            })
    private Long id;

    @Column(name = "user_name",nullable = false)
    private String name;

    @Column(name = "password",nullable = false)
    private String password;

    @CreatedDate
    @Temporal(TIMESTAMP)
    @Column(name = "create_time")
    private Date createTime = new Date();

    @LastModifiedDate
    @Temporal(TIMESTAMP)
    @Column(name = "modified_date")
    protected Date modifiedDate;

    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 Date getCreateTime() {
        return createTime;
    }

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

    public Date getModifiedDate() {
        return modifiedDate;
    }

    public void setModifiedDate(Date modifiedDate) {
        this.modifiedDate = modifiedDate;
    }
}

InitRepository初始数据层：（作为公用父类，可以放置一些通用查询方法）

package com.example.demo.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.NoRepositoryBean;
import java.io.Serializable;

/**
 * @param <T>  Entity
 * @param <ID> ID
 * Created by lean on 2017/9/18.
 */
@NoRepositoryBean
public interface InitRepository<T,ID extends Serializable>
        extends JpaRepository<T,ID>,JpaSpecificationExecutor<T> {
}

UserRepository用户实体类对应数据层:

package com.example.demo.repository;

import com.example.demo.entities.User;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;

/**
 * Created by lean on 2017/9/18.
 */
@Repository
public interface UserRepository extends InitRepository<User,Long> {
}

接口：

package com.example.demo.service;

import java.util.HashMap;

/**
 * Created by lean on 2017/9/18.
 */
public interface TestService {

    HashMap<String,Object> testQuery(HashMap<String, Object> request);

    HashMap<String,Object> testQueryOne(HashMap<String, Object> request);
}

接口实现类：

package com.example.demo.service.impl;

import com.example.demo.entities.User;
import com.example.demo.repository.UserRepository;
import com.example.demo.service.TestService;
import com.example.demo.utils.DataTransUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

/**
 * Created by lean on 2017/9/18.
 */
@Service
public class TestServiceImpl implements TestService {

    @Autowired
    private UserRepository userRepository;

    @Override
    @Transactional(readOnly = true)
    public HashMap<String, Object> testQuery(HashMap<String, Object> request) {
        List<User> users = userRepository.findAll(new Specification<User>() {
            @Override
            public Predicate toPredicate(Root<User> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {

                List<Predicate> predicateList = new ArrayList<>();
                predicateList.add(criteriaBuilder.equal(root.get("id"),request.get("id")));
                String str = "";
                if(request.get("name") != null){
                    str = String.valueOf(request.get("name"));
                }
                predicateList.add(criteriaBuilder.like(root.get("name"),"%"+str+"%"));

                criteriaQuery.where(predicateList.toArray(new Predicate[predicateList.size()]));
                return criteriaQuery.getRestriction();
            }
        });


        return DataTransUtil.returnData(users);
    }

    @Override
    public HashMap<String, Object> testQueryOne(HashMap<String, Object> request) {
        User user = userRepository.findOne(Long.valueOf(String.valueOf(request.get("id"))));
        return DataTransUtil.returnData(user);
    }
}

工具类：

package com.example.demo.utils;

import org.springframework.util.StringUtils;

import java.util.HashMap;

/**
 * Created by lean on 2017/9/18.
 */
public class DataTransUtil {

    private static Integer defaultCode = 1;
    private static String defaultMessage = "succesful";

    public static HashMap<String,Object> returnData(Integer code,String message,Object data){
        HashMap<String,Object> map = new HashMap<>();

        if(null != code){
            map.put("code",code);
        }else{
            map.put("code",defaultCode);
        }
        if(!StringUtils.isEmpty(message)){
            map.put("message",message);
        }else{
            map.put("message",defaultMessage);
        }
        map.put("data",data);

        return map;
    }

    public static HashMap<String,Object> returnData(Object data){
        return returnData(null,null,data);
    }

}

Controller层：

package com.example.demo.controller;

import com.example.demo.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
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 java.util.HashMap;

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

//import static org.springframework.web.bind.annotation.RequestMethod.GET;

/**
 * Created by lean on 2017/9/18.
 */
@RestController
public class InitController {
    @Autowired
    private TestService testService;

    @RequestMapping(value = "/test",method = {POST})
    public HashMap<String,Object> initTest(@RequestBody HashMap<String,Object> request){
        return testService.testQuery(request);
    }

//    @RequestMapping(value = "/queryOne",method = {POST})
    @PostMapping(value = "queryOne")
    public HashMap<String,Object> testQueryOne(@RequestBody HashMap<String,Object> request){
        return testService.testQueryOne(request);
    }
}

具体的JPA和SpringData中的查询就不详细描述了，以后有兴趣再单独写个博客玩玩
运行结果：

注：
这里我使用的web测试工具是火狐的插件restclient，可以模仿http请求来访问服务器，有兴趣的可以自行百度用法