初学Spring-data-jpa+jpa配置+Springboot和Spring-data-jpa做简单操作+分布式服务设置一个永远不重复的ID
关于Spring-data-jpa的配置+Springboot+Spring-data-jpa的简单操作+分布式服务设置一个永远不重复的ID
初学Spring全家桶家族中的Spring-data-jpa发现可以更简单的实现一些基本的增删改查，以下是一些基础操作，希望可以给初学者一些帮助。
spring家族
Spring Boot
spring Cloud
Spring framework
Spring-data
Spring data-jpa(简单的增删改查)
...
jpa配置
jpa的底层是基于hibernate
多表联查的时候会用到一对多,多对一的关系等
springboot一旦是一个web程序,记得配置数据源
springdata-jpa一般是不需要自己写sql语句的
springdata-jpa.hibernate.ddl-auto:update/create
如果是使用create:每次都会新建一个对应的表,覆盖原有的表
update:不会覆盖原有的表,只会更新表结构和表数据
当没有设置驼峰命名的时候,默认会以gradeId---->grade_id
具体代码如下:
#springboot数据源
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/studentjpa?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
password: root
username: root
#配置spring-data-jpa
jpa:
show-sql: true #控制台输出sql语句
database: mysql #jpa使用的数据库
hibernate:
ddl-auto: update
naming:
physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
server:
port: 8081
实体类快速建表
Spring Data Jpa 可以根据实体类 在数据库里自动生成表
实体类的注解
@Data 自动封装属性
@Table(name = "student") 对应数据库中的表，用于指定表的名称
@Entity 注解用于生成数据库表，
Id列的注解
@Id 表示这是一个主键。
@GeneratedValue(strategy = )用于根据规则生成主键，
/*Id表示主键 主键有生成策略*/
/*GenerationType.IDENTITY唯一列还自动增长*/
/*GenerationType.AUTO自动增长*/
/*Oracle中是没有自动增长的 设置GenerationType.SEQUENCE 使用序列进行增长*/
/*GeneratedValue 自动增长生成的value值*/
普通列注解
@Column
启动后自动建表成功
Dao(数据访问层)接口
DAO的接口：
继承JpaRepository<Student,Integer>, JpaSpecificationExecutor<Student>
JpaRepository 扩展简单的增删改查、批量操作
JpaSpecificationExecutor 用来做负责查询的接口
其他:
Repository 空接口
CrudRepository 增删改查
PagingAndSortingRepository 分页和排序
Specification 是Spring Data JPA提供的一个查询规范，要做复杂的查询，类似hibernate QBC查询
JpaRepository继承PagingAndSortingRepository，CrudRepository：
CrudRepository 提供 save、 delete、 deteleAll、 findAll、 findOne、 count等方法
PagingAndSortingRepository提供排序及分页findAll(Sort) （基于排序的查询）、findAll(Pageable)（ 基于分页的查询）
Dao层代码
package com.szh.springdatajpa.dao;
import com.szh.springdatajpa.pojo.Student;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.jpa.repository.Query;
import java.util.List;
/**
* 学生数据访问层
*
* @author 宋政宏
* @date 2019-05-17
*/
public interface StudentDao extends JpaRepository<Student,Integer>, JpaSpecificationExecutor<Student> {
/*nativeQuery 原声的sql语句查询*/
/*根据姓名模糊查询*/
@Query(value = "select * from student where name like concat('%',?,'%')",nativeQuery = true)
List<Student> selByName(String name);
/*查询前两行信息*/
List<Student> findTop2By();
/*根据姓名模糊查询*/
List<Student> findByNameContaining(String name);
/*根据姓名或性别模糊查询*/
//List<Student> findByNameLikeOrSexNotIn()
}
Service层(实现层)的接口和类
interface接口
Service接口中有新增，修改，查询，根据id查询，根据id删除，根据姓名模糊查询，查询前俩行信息，模糊查询，分页查询等方法
package com.szh.springdatajpa.service;
import com.szh.springdatajpa.pojo.Student;
import org.springframework.data.domain.Page;
import java.util.List;
/**
* 学生实现层接口
*
* @author 宋政宏
* @date 2019-05-17
*/
public interface StudentService {
/*新增学生信息*/
Student add(Student student);
/*修改学生信息*/
Student upd(Student student);
/*查询所有学生信息*/
List<Student>selAll();
/*根据id查询学生信息*/
Student selById(Integer id);
/*根据id删除学生信息*/
String del(Integer id);
/*根据姓名模糊查询*/
List<Student> selByName(String name);
/*查询前俩行信息*/
List<Student> findTop2();
/*模糊查询*/
List<Student> findByNameLike(String name);
/*分页查询*/
Page<Student> findByPage(Integer pageNum, Integer size);
}
Impl类
package com.szh.springdatajpa.service.impl;
import com.szh.springdatajpa.dao.StudentDao;
import com.szh.springdatajpa.pojo.Student;
import com.szh.springdatajpa.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Optional;
/**
* 学生实现类
*
* @author 宋政宏
* @date 2019-05-17
*/
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentDao studentDao;
/*新增学生信息*/
@Override
public Student add(Student student) {
Student add = studentDao.save(student);
return add;
}
/*修改学生信息*/
@Override
public Student upd(Student student) {
//有id的时候是修改，没有id的时候是新增
Student upd = studentDao.save(student);
return upd;
}
/*查询所有学生信息*/
@Override
public List<Student> selAll() {
List<Student> sa = studentDao.findAll();
return sa;
}
/*根据id查询学生信息*/
@Override
public Student selById(Integer id) {
Optional<Student> selbyid = studentDao.findById(id);
return selbyid.get();
}
/*根据id删除学生信息*/
@Override
public String del(Integer id) {
studentDao.deleteById(id);
return "删除成功";
}
/*根据姓名模糊查询*/
@Override
public List<Student> selByName(String name) {
return studentDao.selByName(name);
}
/*查询前两条信息*/
@Override
public List<Student> findTop2(){
return studentDao.findTop2By();
}
/*模糊查询*/
@Override
public List<Student> findByNameLike(String name){
return studentDao.findByNameContaining(name);
}
/*分页查询*/
@Override
public Page<Student> findByPage(Integer pageNum,Integer size){
PageRequest pageRequest = PageRequest.of(pageNum - 1, size);
return studentDao.findAll(pageRequest);
}
}
Controller(控制层)类
@RestController:@Controller+@ResponseBody 以json数据进行返回
package com.szh.springdatajpa.controller;
import com.szh.springdatajpa.pojo.Student;
import com.szh.springdatajpa.service.StudentService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
*学生控制层
*
* @author 宋政宏
* @date 2019-05-17
*/
@RestController
public class StudentController {
@Autowired
private StudentService studentService;
/**
* 新增学生信息
* @param student
* @return
*/
@PostMapping("/student")
public Student add(Student student){
return studentService.add(student);
}
/**
* 修改学生信息
* @param student
* @return
*/
@PutMapping("/update")
public Student upd(Student student){
return studentService.upd(student);
}
/**
* 查询所有学生信息
* @param
* @return
*/
@GetMapping("/selAll")
public List<Student> selAll(){
return studentService.selAll();
}
/**
* 根据id查询学生信息
* @param id
* @return
*/
@GetMapping("/selById/{id}")
public Student selById(@PathVariable("id")Integer id){
return studentService.selById(id);
}
/**
* 删除学生信息
* @param id
* @return
*/
@DeleteMapping("/delete/{id}")
public String delete(@PathVariable("id") Integer id){
return studentService.del(id);
}
/**
* 根据姓名模糊查询
*
* @param name
* @return
*/
@GetMapping("/selByName")
public List<Student> selByName(String name){
return studentService.selByName(name);
}
/**
* 查询前两行学生信息
*
* @param
* @return
*/
@GetMapping("/findTop2")
public List<Student> findTop2(){
return studentService.findTop2();
}
/**
* 模糊查询
*
* @param
* @return
*/
@GetMapping("/findByNameLike")
public List<Student> findByNameLike(String name){
return studentService.findByNameLike(name);
}
@GetMapping("/findByPage")
public List<Student> findByPage(Integer pageNum,Integer size){
Page<Student> page = studentService.findByPage(pageNum, size);
//return "总条数是"+page.getTotalElements();
return page.getContent();
}
}
最后运行项目打开Postman工具测试功能!
查询成功！
设置一个永远不重复的ID
解决高并发id的问题
UUID 分布式服务自己设置Id
SpringdatajpaApplication运行类自定义Bean属性
/*自定义Bean属性*/
@Bean
public IdWorker idWorker(){
return new IdWorker(1,1);
}
新建util包创建IdWorker类
IdWorker类的代码:
package com.changan.springdatajpa.util;
import java.lang.management.ManagementFactory;
import java.net.InetAddress;
import java.net.NetworkInterface;
/**
* <p>名称：IdWorker.java</p>
* <p>描述：分布式自增长ID</p>
* <pre>
* Twitter的 Snowflake JAVA实现方案
* </pre>
* 核心代码为其IdWorker这个类实现，其原理结构如下，我分别用一个0表示一位，用—分割开部分的作用：
* 1||0---0000000000 0000000000 0000000000 0000000000 0 --- 00000 ---00000 ---000000000000
* 在上面的字符串中，第一位为未使用（实际上也可作为long的符号位），接下来的41位为毫秒级时间，
* 然后5位datacenter标识位，5位机器ID（并不算标识符，实际是为线程标识），
* 然后12位该毫秒内的当前毫秒内的计数，加起来刚好64位，为一个Long型。
* 这样的好处是，整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞（由datacenter和机器ID作区分），
* 并且效率较高，经测试，snowflake每秒能够产生26万ID左右，完全满足需要。
* <p>
* 64位ID (42(毫秒)+5(机器ID)+5(业务编码)+12(重复累加))
*
* @author Polim
*/
public class IdWorker {
// 时间起始标记点，作为基准，一般取系统的最近时间（一旦确定不能变动）
private final static long twepoch = 1288834974657L;
// 机器标识位数
private final static long workerIdBits = 5L;
// 数据中心标识位数
private final static long datacenterIdBits = 5L;
// 机器ID最大值
private final static long maxWorkerId = -1L ^ (-1L << workerIdBits);
// 数据中心ID最大值
private final static long maxDatacenterId = -1L ^ (-1L << datacenterIdBits);
// 毫秒内自增位
private final static long sequenceBits = 12L;
// 机器ID偏左移12位
private final static long workerIdShift = sequenceBits;
// 数据中心ID左移17位
private final static long datacenterIdShift = sequenceBits + workerIdBits;
// 时间毫秒左移22位
private final static long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits;
private final static long sequenceMask = -1L ^ (-1L << sequenceBits);
/* 上次生产id时间戳 */
private static long lastTimestamp = -1L;
// 0，并发控制
private long sequence = 0L;
private final long workerId;
// 数据标识id部分
private final long datacenterId;
public IdWorker(){
this.datacenterId = getDatacenterId(maxDatacenterId);
this.workerId = getMaxWorkerId(datacenterId, maxWorkerId);
}
/**
* @param workerId
* 工作机器ID
* @param datacenterId
* 序列号
*/
public IdWorker(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
/**
* 获取下一个ID
*
* @return
*/
public synchronized long nextId() {
long timestamp = timeGen();
if (timestamp < lastTimestamp) {
throw new RuntimeException(String.format("Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
if (lastTimestamp == timestamp) {
// 当前毫秒内，则+1
sequence = (sequence + 1) & sequenceMask;
if (sequence == 0) {
// 当前毫秒内计数满了，则等待下一秒
timestamp = tilNextMillis(lastTimestamp);
}
} else {
sequence = 0L;
}
lastTimestamp = timestamp;
// ID偏移组合生成最终的ID，并返回ID
long nextId = ((timestamp - twepoch) << timestampLeftShift)
| (datacenterId << datacenterIdShift)
| (workerId << workerIdShift) | sequence;
return nextId;
}
private long tilNextMillis(final long lastTimestamp) {
long timestamp = this.timeGen();
while (timestamp <= lastTimestamp) {
timestamp = this.timeGen();
}
return timestamp;
}
private long timeGen() {
return System.currentTimeMillis();
}
/**
* <p>
* 获取 maxWorkerId
* </p>
*/
protected static long getMaxWorkerId(long datacenterId, long maxWorkerId) {
StringBuffer mpid = new StringBuffer();
mpid.append(datacenterId);
String name = ManagementFactory.getRuntimeMXBean().getName();
if (!name.isEmpty()) {
/*
* GET jvmPid
*/
mpid.append(name.split("@")[0]);
}
/*
* MAC + PID 的 hashcode 获取16个低位
*/
return (mpid.toString().hashCode() & 0xffff) % (maxWorkerId + 1);
}
/**
* <p>
* 数据标识id部分
* </p>
*/
protected static long getDatacenterId(long maxDatacenterId) {
long id = 0L;
try {
InetAddress ip = InetAddress.getLocalHost();
NetworkInterface network = NetworkInterface.getByInetAddress(ip);
if (network == null) {
id = 1L;
} else {
byte[] mac = network.getHardwareAddress();
id = ((0x000000FF & (long) mac[mac.length - 1])
| (0x0000FF00 & (((long) mac[mac.length - 2]) << 8))) >> 6;
id = id % (maxDatacenterId + 1);
}
} catch (Exception e) {
System.out.println(" getDatacenterId: " + e.getMessage());
}
return id;
}
}
然后修改上面Service层(实现层)的Impl类
这是Impl类中新增Id处理
最后大功告成，运行项目。
浙公网安备 33010602011771号