SpringBoot杂碎知识 (七)持久层框架

目录

jdbcTemplate 

JPA

mybatis

---

springboot具有非常棒的持久层框架支持，下面我将介绍我用过的三种持久层框架进行简述使用。

由于这里操作的都是一张表，这里贴出通用的yml和建表语句  切记这里使用的是mysql8 ，5.8之前的朋友请修改后缀去掉com.mysql.cj.jdbc.Driver 中的cj。

DROP TABLE IF EXISTS `Test`;
CREATE TABLE `Test`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '姓名',
  `age` int(11) NULL DEFAULT NULL COMMENT '年龄',
  `inhere` tinyint(4) NULL DEFAULT NULL COMMENT '在不在',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

spring:
  datasource:
    url: jdbc:mysql://192.168.8.100:3306/FuLinTest?characterEncoding=utf8&useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

---

jdbcTemplate 

首先呢看下项目结构

记得使用之前千万不要不加依赖哈哈

        <!-- jdbcTemplate -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

然后贴出实体类

package com.maoxs.pojo;

import lombok.Data;

import java.io.Serializable;

@Data
public class MyTest implements Serializable {
    private Long id;
    private String name;
    private int age;
    private Boolean inhere;

    public MyTest() {
    }

    public MyTest(String name, int age, Boolean inhere) {
        this.name = name;
        this.age = age;
        this.inhere = inhere;
    }

    public MyTest(Long id, String name, int age, Boolean inhere) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.inhere = inhere;
    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("MyTest{");
        sb.append("id=").append(id);
        sb.append(", name='").append(name).append('\'');
        sb.append(", age=").append(age);
        sb.append(", inhere=").append(inhere);
        sb.append('}');
        return sb.toString();
    }
}

然后是dao层的实现类和接口

package com.maoxs.dao;

import com.maoxs.pojo.MyTest;

public interface MyTestDao {

    MyTest selectOne(Long id);

    int insert(MyTest myTest);

    int delete(Long id);

    int update(MyTest myTest);

}

package com.maoxs.dao.impl;

import com.maoxs.dao.MyTestDao;
import com.maoxs.pojo.MyTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class MyTestDaoImpl implements MyTestDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public MyTest selectOne(Long id) {
        String sql = "select id,name,age,inhere from Test where id=? ";
        return jdbcTemplate.queryForObject(sql, (resultSet, i) -> {
            MyTest myTest = new MyTest();
            myTest.setId(resultSet.getLong("id"));
            myTest.setName(resultSet.getString("name"));
            myTest.setAge(resultSet.getInt("age"));
            myTest.setInhere(resultSet.getBoolean("inhere"));
            return myTest;
        }, id);
    }

    @Override
    public int insert(MyTest myTest) {
        String sql = "insert into Test (name,age,inhere) values(?,?,?)";
        return jdbcTemplate.update(sql, myTest.getName(), myTest.getAge(), myTest.getInhere());
    }

    @Override
    public int delete(Long id) {
        String sql = "delete from Test where id=?";
        return jdbcTemplate.update(sql, id);
    }

    @Override
    public int update(MyTest myTest) {
        String sql = "update Test set name=?,age=?,inhere=? where id=?";
        return jdbcTemplate.update(sql, myTest.getName(), myTest.getAge(), myTest.getInhere(), myTest.getId());
    }
}

然后呢编写测试看看都能用不

package com.maoxs;

import com.maoxs.dao.MyTestDao;
import com.maoxs.pojo.MyTest;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Collections;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootJdbcApplicationTests {
    @Autowired
    private MyTestDao myTestDao;

    @Test
    public void insert() {
        MyTest myTest = new MyTest("fulin", 18, true);
        myTestDao.insert(myTest);
    }

    @Test
    public void selectOne() {
        System.out.println(myTestDao.selectOne(1L));
    }


    @Test
    public void update() {
        MyTest myTest = new MyTest(1L, "fulin", 18, true);
        myTestDao.update(myTest);
    }

    @Test
    public void delete() {
        myTestDao.delete(13L);
    }

}

ok 我这边测试都通过了

这里提个小插曲可能原生的方法用起来真不方便还么有分页我这边提供了一个工具类 别喷就行了 只是mysql的

package com.maoxs.util;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.util.Assert;

/**
 * spirng jdbc 基本支撑类
 *
 * @author fulin
 */
public abstract class JdbcDaoImpl {

    @Autowired
    protected JdbcTemplate jdbcTemplate;

    /**
     * 获取当前事务最后一次更新的主键值
     */
    public Long getLastId() {
        return jdbcTemplate.queryForObject("select last_insert_id() as id", Long.class);
    }

    /**
     * 获取对象信息
     */
    public <T> T queryForObject(String sql, Class<T> clazz, Object... args) {
        Assert.hasText(sql, "sql 语句不能为空");
        return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<T>(clazz), args);
    }

    /**
     * 获取对象集合信息
     */
    public <T> List<T> queryForObjectList(String sql, Class<T> clazz, Object... args) {
        Assert.hasText(sql, "sql 语句不能为空");
        return jdbcTemplate.query(sql, args, new BeanPropertyRowMapper<T>(clazz));
    }

    /**
     * 分页，jdbcTemplate 不支持like自定义，只能拼装
     */
    public Page<Map<String, Object>> queryForPage(String sql, int pageCurrent, int pageSize, Object... args) {
        Assert.hasText(sql, "sql 语句不能为空");
        Assert.isTrue(pageCurrent >= 1, "pageNo 必须大于等于1");
        String sqlCount = Sql.countSql(sql);
        int count = jdbcTemplate.queryForObject(sqlCount, Integer.class, args);
        pageCurrent = Sql.checkPageCurrent(count, pageSize, pageCurrent);
        pageSize = Sql.checkPageSize(pageSize);
        int totalPage = Sql.countTotalPage(count, pageSize);
        String sqlList = sql + Sql.limitSql(count, pageCurrent, pageSize);
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sqlList, args);
        return new Page<Map<String, Object>>(count, totalPage, pageCurrent, pageSize, list);
    }

    /**
     * 分页，jdbcTemplate 不支持like是定义，只能拼装
     */
    public <T> Page<T> queryForPage(String sql, int pageCurrent, int pageSize, Class<T> clazz, Object... args) {
        Assert.hasText(sql, "sql 语句不能为空");
        Assert.isTrue(pageCurrent >= 1, "pageNo 必须大于等于1");
        Assert.isTrue(clazz != null, "clazz 不能为空");
        String sqlCount = Sql.countSql(sql);
        int count = jdbcTemplate.queryForObject(sqlCount, Integer.class, args);
        pageCurrent = Sql.checkPageCurrent(count, pageSize, pageCurrent);
        pageSize = Sql.checkPageSize(pageSize);
        int totalPage = Sql.countTotalPage(count, pageSize);
        String sqlList = sql + Sql.limitSql(count, pageCurrent, pageSize);
        List<T> list = jdbcTemplate.query(sqlList, new BeanPropertyRowMapper<T>(clazz), args);
        return new Page<T>(count, totalPage, pageCurrent, pageSize, list);
    }

}

package com.maoxs.util;

import java.io.Serializable;
import java.util.List;

/**
 * 数据分页组件
 *
 * @author fulin
 */
public class Page<T> implements Serializable {
    private static final long serialVersionUID = -5764853545343945831L;

    /**
     * 默认每页记录数(20)
     */
    public static final int DEFAULT_PAGE_SIZE = 20;

    /**
     * 最大每页记录数(1000)
     */
    public static final int MAX_PAGE_SIZE = 1000;

    /**
     * 当前分页的数据集
     */
    private List<T> list;

    /**
     * 总记录数
     */
    private int totalCount;

    /**
     * 总页数
     */
    private int totalPage;

    /**
     * 当前页
     */
    private int pageCurrent;

    /**
     * 每页记录数
     */
    private int pageSize;

    /**
     * 排序字段
     */
    private String orderField;

    /**
     * 排序方式：asc or desc
     */
    private String orderDirection;

    /**
     * 默认构造函数
     */
    public Page() {
    }

    /**
     * 构造函数
     *
     * @param totalCount  总记录数
     * @param totalPage   总页数
     * @param pageCurrent
     * @param pageSize
     * @param list
     */
    public Page(int totalCount, int totalPage, int pageCurrent, int pageSize, List<T> list) {
        this.totalCount = totalCount;
        this.totalPage = totalPage;
        this.pageCurrent = pageCurrent;
        this.pageSize = pageSize;
        this.list = list;
    }

    public List<T> getList() {
        return list;
    }

    public void setList(List<T> list) {
        this.list = list;
    }

    public int getTotalCount() {
        return totalCount;
    }

    public void setTotalCount(int totalCount) {
        this.totalCount = totalCount;
    }

    public int getTotalPage() {
        return totalPage;
    }

    public void setTotalPage(int totalPage) {
        this.totalPage = totalPage;
    }

    public int getPageCurrent() {
        return pageCurrent;
    }

    public void setPageCurrent(int pageCurrent) {
        this.pageCurrent = pageCurrent;
    }

    public int getPageSize() {
        return pageSize;
    }

    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    public String getOrderField() {
        return orderField;
    }

    public void setOrderField(String orderField) {
        this.orderField = orderField;
    }

    public String getOrderDirection() {
        return orderDirection;
    }

    public void setOrderDirection(String orderDirection) {
        this.orderDirection = orderDirection;
    }

}

package com.maoxs.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * sql工具类
 *
 * @author fulin
 */
public class Sql {
    private Sql() {
    }

    /**
     * 检测sql，防止sql注入
     *
     * @param sql sql
     * @return 正常返回sql；异常返回""
     */
    public static String checkSql(String sql) {
        String inj_str = "'|and|exec|insert|select|delete|update|count|*|%|chr|mid|master|truncate|char|declare|;|or|-|+|,";
        String inj_stra[] = inj_str.split("\\|");
        for (int i = 0; i < inj_stra.length; i++) {
            if (sql.indexOf(inj_stra[i]) >= 0) {
                return "";
            }
        }
        return sql;
    }

    /**
     * 计算总页数
     *
     * @param totalCount 总记录数.
     * @param pageSize   每页记录数.
     * @return totalPage 总页数.
     */
    public static int countTotalPage(final int totalCount, final int pageSize) {
        if (totalCount % pageSize == 0) {
            return totalCount / pageSize; // 刚好整除
        } else {
            return totalCount / pageSize + 1; // 不能整除则总页数为：商 + 1
        }
    }

    /**
     * 校验当前页数pageCurrent<br/>
     * 1、先根据总记录数totalCount和每页记录数pageSize，计算出总页数totalPage<br/>
     * 2、判断页面提交过来的当前页数pageCurrent是否大于总页数totalPage，大于则返回totalPage<br/>
     * 3、判断pageCurrent是否小于1，小于则返回1<br/>
     * 4、其它则直接返回pageCurrent
     *
     * @param totalCount  要分页的总记录数
     * @param pageSize    每页记录数大小
     * @param pageCurrent 输入的当前页数
     * @return pageCurrent
     */
    public static int checkPageCurrent(int totalCount, int pageSize, int pageCurrent) {
        int totalPage = countTotalPage(totalCount, pageSize); // 最大页数
        if (pageCurrent > totalPage) {
            // 如果页面提交过来的页数大于总页数，则将当前页设为总页数
            // 此时要求totalPage要大于获等于1
            if (totalPage < 1) {
                return 1;
            }
            return totalPage;
        } else if (pageCurrent < 1) {
            return 1; // 当前页不能小于1（避免页面输入不正确值）
        } else {
            return pageCurrent;
        }
    }

    /**
     * 校验页面输入的每页记录数pageSize是否合法<br/>
     * 1、当页面输入的每页记录数pageSize大于允许的最大每页记录数MAX_PAGE_SIZE时，返回MAX_PAGE_SIZE
     * 2、如果pageSize小于1，则返回默认的每页记录数DEFAULT_PAGE_SIZE
     *
     * @param pageSize 页面输入的每页记录数
     * @return checkPageSize
     */
    public static int checkPageSize(int pageSize) {
        if (pageSize > Page.MAX_PAGE_SIZE) {
            return Page.MAX_PAGE_SIZE;
        } else if (pageSize < 1) {
            return Page.DEFAULT_PAGE_SIZE;
        } else {
            return pageSize;
        }
    }

    /**
     * 计算当前分页的开始记录的索引
     *
     * @param pageCurrent 当前第几页
     * @param pageSize    每页记录数
     * @return 当前页开始记录号
     */
    public static int countOffset(final int pageCurrent, final int pageSize) {
        return (pageCurrent - 1) * pageSize;
    }

    /**
     * 根据总记录数，对页面传来的分页参数进行校验，并返分页的SQL语句
     *
     * @param pageCurrent 当前页
     * @param pageSize    每页记录数
     * @param pageBean    DWZ分页查询参数
     * @return limitSql
     */
    public static String limitSql(int totalCount, int pageCurrent, int pageSize) {
        // 校验当前页数
        pageCurrent = checkPageCurrent(totalCount, pageSize, pageCurrent);
        pageSize = checkPageSize(pageSize); // 校验每页记录数
        return " limit " + countOffset(pageCurrent, pageSize) + "," + pageSize;
    }

    /**
     * 根据分页查询的SQL语句，获取统计总记录数的语句
     *
     * @param sql 分页查询的SQL
     * @return countSql
     */
    public static String countSql(String sql) {
        String countSql = sql.substring(sql.toLowerCase().indexOf("from")); // 去除第一个from前的内容
        return "select count(*) " + removeOrderBy(countSql);
    }

    /**
     * 移除SQL语句中的的order by子句（用于分页前获取总记录数，不需要排序）
     *
     * @param sql 原始SQL
     * @return 去除order by子句后的内容
     */
    private static String removeOrderBy(String sql) {
        Pattern pat = Pattern.compile("order\\s*by[\\w|\\W|\\s|\\S]*", Pattern.CASE_INSENSITIVE);
        Matcher mc = pat.matcher(sql);
        StringBuffer strBuf = new StringBuffer();
        while (mc.find()) {
            mc.appendReplacement(strBuf, "");
        }
        mc.appendTail(strBuf);
        return strBuf.toString();
    }
}

具体分页怎么使用呢这边在贴一份使用

@Repository
public class MyTestDaoImpl extends JdbcDaoImpl implements MyTestDao {


    /**
     * 分页
     *
     * @param pageCurrent 第几页
     * @param pageSize    每页显示多少条
     * @return
     */
    @Override
    public Page<MyTest> queryForPage(int pageCurrent, int pageSize) {
        String sql = "select * from Test";
        return queryForPage(sql, pageCurrent, pageSize, MyTest.class);
    }

}

---

JPA

首先呢还是先看下项目结构

然后使用的时候千万不要忘了加依赖

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

先看下实体，不要写错注解

package com.maoxs.pojo;

import lombok.Data;

import javax.persistence.*;
import java.io.Serializable;

@Data
@Entity
@Table(name = "MyTest")
public class MyTest implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @Column
    private String name;
    @Column
    private int age;
    @Column
    private Boolean inhere;

}

SpringBoot创建DAO层很多种方法其中japrepository是最强大的而且最有特色的一种，我们可以针对不同的实体创建repository接口。Spring会根据方法名称的规则进行自动生成实现，强大的不要不要的。在SpringBoot中默认已经提供了非常多的常规CRUD操作的repository，以下就是Spring为我们提供的repository接口

package com.maoxs.dao;

import com.maoxs.pojo.MyTest;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface TestDao extends JpaRepository<MyTest, Long> {
}

别看啥都没有功能超级牛逼  具体可以去jpa官网学习下怎么使用的  JPA 学习手册

在看下service

package com.maoxs.service;

import com.maoxs.pojo.MyTest;

import java.util.List;

public interface TestService {
    void add(MyTest tset) throws Exception;

    void update(MyTest myTest) throws Exception;

    void del(Long id) throws Exception;

    List<MyTest> select() throws Exception;
}

package com.maoxs.service.impl;

import com.maoxs.dao.TestDao;
import com.maoxs.pojo.MyTest;
import com.maoxs.service.TestService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class TestServiceImpl implements TestService {
    @Autowired
    private TestDao testDao;


    @Override
    public void add(MyTest tset) throws Exception {
        testDao.save(tset);
    }

    @Override
    public void update(MyTest myTest) throws Exception {
        testDao.saveAndFlush(myTest);
    }

    @Override
    public void del(Long id) throws Exception{
        testDao.deleteById(id);
    }

    @Override
    public List<MyTest> select() throws Exception {
        return testDao.findAll();
    }
}

然后写个测试类测试下

package com.maoxs;

import com.maoxs.pojo.MyTest;
import com.maoxs.service.TestService;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootJpaApplicationTests {

    @Autowired
    private TestService testService;


    @Test
    public void add() throws Exception {
        MyTest t = new MyTest();
        t.setAge(11);
        t.setInhere(false);
        t.setName("DesrCat");
        testService.add(t);
    }

    @Test
    public void update() throws Exception {
        MyTest t = new MyTest();
        t.setAge(180);
        t.setInhere(false);
        t.setName("昴先生111");
        t.setId(1L);
        testService.update(t);
    }

    @Test
    public void select() throws Exception {
        List<MyTest> select = testService.select();
        Assert.assertTrue(select.size() > 0);
        System.out.println(Collections.unmodifiableCollection(select));
    }

    @Test
    public void del() throws Exception {
        testService.del(11L);
    }


}

我这里是都通过了你呢?

---

mybatis

这里看下项目结构

依赖依赖依赖依赖

        <!--mybatis  -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

这里的yml需要加入

mybatis:
  mapper-locations: classpath:/mapper/*.xml
  type-aliases-package: com.maoxs.pojo

 然后呢是实体

package com.maoxs.pojo;

import lombok.Data;

import java.io.Serializable;

@Data
public class MyTest implements Serializable {
    private Long id;
    private String name;
    private int age;
    private Boolean inhere;

}

然后呢是dao

package com.maoxs.dao;

import com.maoxs.pojo.MyTest;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface MyTestMapper {
    List<MyTest> findAll();
}

mapper

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.maoxs.dao.MyTestMapper">
    <sql id="base_sql">
         a.id as  id,
         a.name as  name,
         a.age as  age,
         a.inHere as inHere
    </sql>
    <select id="findAll" resultType="com.maoxs.pojo.MyTest">
        select
        <include refid="base_sql"/>
        from
        Test a
    </select>

</mapper>

切记在启动类上加入MapperScan 注解

package com.maoxs;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.maoxs")
public class SpringbootMybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisApplication.class, args);
    }
}

然后是测试类

package com.maoxs;

import com.maoxs.dao.MyTestMapper;
import com.maoxs.pojo.MyTest;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Collections;
import java.util.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootMybatisApplicationTests {

    @Autowired
    private MyTestMapper myTestMapper;

    @Test
    public void findAll() {
        List<MyTest> all = myTestMapper.findAll();
        System.out.println(Collections.unmodifiableCollection(all));
    }

}

mybatis就不多说了，应该经常用吧实在不会的小伙伴 点击   mybatis 学习手册

---

然后呢就推荐大家使用mybatis的一个开源插件myabtis-plus

//TODO 后期呢我会放上使用帖子

mybatis-plus 学习手册

注：如果不对联系本宝宝及时改正~