前面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请求来访问服务器,有兴趣的可以自行百度用法