初學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處理

最後大功告成，運行項目。