Spring Boot 使用SpringData Jpa 实现简单的增删改查WEB项目

使用IDEA开发 Springdata-jpa

1.首先创建一个Spring Boot项目

2、配置yml文件

application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
    username: root
    password: root
  jpa:
    show-sql: true  #显示sql语句
    hibernate:
      ddl-auto: update
      naming:
        implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl
        physical-strategy: org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
    database: mysql #配置现在所使用的数据库

3、添加实体类

@Data 自动封装属性
@Entity注解用于生成数据库表，
@Table用于指定表的名称，
@GeneratedValue用于根据规则生成主键，
@Id表示这是一个主键。(还有一些标签可以自己去看一下springdata-jpa的官方文档)

Spring Data Jpa 可以根据实体类 在数据库里自动生成表(注意:yml数据里面首先需要一个数据库,然后必须连接)

package com.haungyu.springbootjpa.entity;

import lombok.Data;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

/**
 * @date :2019/6/3 21:39
 * 学生类
 */
@Data
@Entity
@Table(name = "student")
public class Student {
    @Id
    private Long id;
    private String name;
    private String sex;
    private Integer gradeId;
}



package com.haungyu.springbootjpa.entity;

import lombok.Data;

import javax.persistence.*;

/**
 * @date :2019/6/3 21:42
 * 年级表
 */
@Data
@Entity
@Table(name = "grade")
public class Grade {
    @Id//主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//自动增长
    private Integer gradeId;
    private String gradeName
    
}

建好实体类后，启动项目

然后编写Dao层接口

DAO的接口：

Repository （空接口）

CrudRepository （增删改查）

PagingAndSortingRepository （分页和排序）

JpaRepository （扩展增删改查、批量操作）

JpaSpecificationExecutor：用来做负责查询的接口

Specification：是Spring Data JPA提供的一个查询规范，要做复杂的查询，类似hibernate QBC查询

JpaRepository继承PagingAndSortingRepository，CrudRepository：

CrudRepository 提供 save、 delete、 deteleAll、 findAll、 findOne、 count等方法

PagingAndSortingRepository提供排序及分页findAll(Sort) （基于排序的查询）、findAll(Pageable)（ 基于分页的查询）

编写Service层

因为id我没有给自增 所以要手动给id并且不能重复

先创建工具类（util）

package com.huipeng.springbootjpa.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;
    }


}

package com.huipeng.springbootjpa.service;

import com.haungyu.springbootjpa.entity.Student;

import java.util.List;

/**
 * @date :2019/6/3 22:11
 *
 */
public interface StudnetService {

    /** 查询所有 */
    List<Student> findAll();

    /** 新增和修改  */
    void save(Student student);

    /** 删除 */
    void delete(Long id);
    
     /**查询单个对象 */
    Student findById(Long id);
}

package com.huipeng.springbootjpa.service.impl;

import com.haungyu.springbootjpa.dao.StudentDao;
import com.haungyu.springbootjpa.entity.Student;
import com.haungyu.springbootjpa.service.StudnetService;
import com.haungyu.springbootjpa.util.IdWorker;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * @date :2019/6/3 22:16
 */
@Service
public class StudnetServiceImpl implements StudnetService {

    @Autowired
    private StudentDao stu;

    IdWorker idWorker  = new IdWorker();

    @Override
    public List<Student> findAll() {
        return stu.findAll();
    }

    @Override
    public void save(Student student) {
        //当 对象的id为空时，新增一个id，不为空时 修改信息
        if (student.getId()==null){
            //添加 id
            student.setId(idWorker.nextId());
        }
        stu.save(student);
    }

    @Override
    public void delete(Long id) {
        //根据id删除信息
        stu.deleteById(id);
    }
 @Override
    public Student findById(Long id) {
       return stu.findById(id).get();
    }
}

编写Controller 控制层

package com.huipeng.springbootjpa.controller;

import com.haungyu.springbootjpa.entity.Student;
import com.haungyu.springbootjpa.service.StudnetService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.List;

/**
 * @date :2019/6/3 22:23
 * 学生类的控制层
 */
@Controller
public class StudentController {
    @Autowired
    private StudnetService stu;

    @RequestMapping("/index")
    public String findAll(Model model){
        //查询所有
        List<Student> list = stu.findAll();
        model.addAttribute("list",list);
        return "index";
    }


    @RequestMapping("/updateById/{id}")
    public String updateById(@PathVariable("id") Long id,Model model){
        System.out.println("============"+id);
        if (id!=0){
            //根据id查询对象
            Student student = stu.findById(id);
            model.addAttribute("stu",student);
        }
        return "update";
    }

    /**

     * @Description //TODO 删除
     * @Date 16:26 2019/6/3
     * @Param
     * @return
     **/
    @RequestMapping("/delete/{id}")
    public String delete(@PathVariable("id") Long id){
        stu.delete(id);
        return "redirect:/index";
    }

    /**
     * @Author 甘环宇
     * @Description //TODO  新增，修改
     * @Date 18:21 2019/6/3
     * @Param
     * @return
     **/
    @RequestMapping("/update")
    public String update(Student student){
        stu.save(student);
        return "redirect:/index";
    }
}

编写html 页面

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="">
    <a th:href="@{'/updateById/0'}">新增学生</a>
    <table cellpadding="10" cellspacing="0" border="1">
        <tr>
            <th>学生编号</th>
            <th>学生姓名</th>
            <th>学生性别</th>
            <th>学生班级</th>
            <th>操作</th>
        </tr>

        <tr th:each="li:${list}">
            <td th:text="${li.id}"></td>
            <td th:text="${li.name}">1</td>
            <td th:text="${li.sex}">1</td>
            <td th:text="${li.gradeId}">1</td>
            <td><a th:href="@{'/delete/'+${li.id}}">删除</a></td>
            <td><a th:href="@{'/updateById/'+${li.id}}">修改</a></td>
        </tr>
    </table>
</form>
</body>
</html>

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">

<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<form action="/update">
    <input type="hidden" name="id"  th:value="${stu!=null}?${stu.id}">
    姓名:<input type="text" name="name" th:value="${stu!=null}?${stu.name}"><br/>
    性别:<input type="text" name="sex" th:value="${stu!=null}?${stu.sex}"><br/>
    班级:<select name="gradeId">
    <option value="1">S1</option>
    <option value="2">S2</option>
    <option value="3">Y2</option>
</select><br/>
    <input type="submit" th:value="${stu!=null}?修改:新增">
</form>
</body>
</html>

简单的增删改查就写玩了,不喜勿喷