Spring Boot - 通用Mapper插件和分页助手插件

柔情只为你懂 2023-10-12 19:37 77阅读 0赞

## 实体类 ##

package com.lfsun.springbootormmybatismapperpage.entity;
    
    import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import tk.mybatis.mapper.annotation.KeySql;
    
    import javax.persistence.Id;
    import javax.persistence.Table;
    import java.io.Serializable;
    import java.util.Date;
    
    /**
     * <p>
     * 用户实体类
     * </p>
     */
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Builder
    @Table(name = "orm_user")
    public class User implements Serializable {
        
        private static final long serialVersionUID = -1840831686851699943L;
    
        /**
         * 主键
         */
        @Id
        @KeySql(useGeneratedKeys = true)
        private Long id;
    
        /**
         * 用户名
         */
        private String name;
    
        /**
         * 加密后的密码
         */
        private String password;
    
        /**
         * 加密使用的盐
         */
        private String salt;
    
        /**
         * 邮箱
         */
        private String email;
    
        /**
         * 手机号码
         */
        private String phoneNumber;
    
        /**
         * 状态，-1：逻辑删除，0：禁用，1：启用
         */
        private Integer status;
    
        /**
         * 创建时间
         */
        private Date createTime;
    
        /**
         * 上次登录时间
         */
        private Date lastLoginTime;
    
        /**
         * 上次更新时间
         */
        private Date lastUpdateTime;
    }

## UserMapper ##

package com.lfsun.springbootormmybatismapperpage.mapper;
    
    
    import com.lfsun.springbootormmybatismapperpage.entity.User;
    import org.springframework.stereotype.Component;
    import tk.mybatis.mapper.common.Mapper;
    import tk.mybatis.mapper.common.MySqlMapper;
    
    
    
    @Component
    public interface UserMapper extends Mapper<User>, MySqlMapper<User> {
        
    }

## 启动类 ##

package com.lfsun.springbootormmybatismapperpage;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import tk.mybatis.spring.annotation.MapperScan;
    
    @SpringBootApplication
    @MapperScan(basePackages = {
        "com.lfsun.springbootormmybatismapperpage.mapper"})
    public class SpringBootOrmMybatisMapperPageApplication {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(SpringBootOrmMybatisMapperPageApplication.class, args);
        }
    
    }

## application.yml ##

spring:
      datasource:
        url: jdbc:mysql://127.0.0.1:3306/springboot_study?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8
        username: root
        password: 123321
        driver-class-name: com.mysql.cj.jdbc.Driver
        type: com.zaxxer.hikari.HikariDataSource
        initialization-mode: always
        continue-on-error: true
        schema:
          - "classpath:db/schema.sql"
        data:
          - "classpath:db/data.sql"
        hikari:
          minimum-idle: 5
          connection-test-query: SELECT 1 FROM DUAL
          maximum-pool-size: 20
          auto-commit: true
          idle-timeout: 30000
          pool-name: SpringBootDemoHikariCP
          max-lifetime: 60000
          connection-timeout: 30000
    logging:
      level:
        com.lfsun: debug
        com.lfsun.springbootormmybatismapperpage.mapper: trace
    mybatis:
      configuration:
        # 下划线转驼峰
        map-underscore-to-camel-case: true
      mapper-locations: classpath:mappers/*.xml
      type-aliases-package: com.lfsun.springbootormmybatismapperpage.entity
    mapper:
      mappers:
        - tk.mybatis.mapper.common.Mapper
      not-empty: true
      style: camelhump
      wrap-keyword: "`{0}`"
      safe-delete: true
      safe-update: true
      identity: MYSQL
    pagehelper:
      auto-dialect: true
      helper-dialect: mysql
      reasonable: true
      params: count=countSql

## 测试 ##

package com.lfsun.springbootormmybatismapperpage.mapper;
    
    import cn.hutool.core.collection.CollUtil;
    import cn.hutool.core.date.DateTime;
    import cn.hutool.core.util.IdUtil;
    import cn.hutool.crypto.SecureUtil;
    import com.github.pagehelper.PageHelper;
    import com.github.pagehelper.PageInfo;
    
    import com.lfsun.springbootormmybatismapperpage.SpringBootOrmMybatisMapperPageApplicationTests;
    import com.lfsun.springbootormmybatismapperpage.entity.User;
    import lombok.extern.slf4j.Slf4j;
    import org.assertj.core.util.Lists;
    import org.junit.Assert;
    import org.junit.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import tk.mybatis.mapper.entity.Example;
    
    import java.util.List;
    import java.util.stream.Collectors;
    
    /**
     * <p>
     * UserMapper 测试
     * </p>
     */
    @Slf4j
    public class UserMapperTest extends SpringBootOrmMybatisMapperPageApplicationTests {
        
    
        @Autowired
        private com.lfsun.springbootormmybatismapperpage.mapper.UserMapper userMapper;
    
        /**
         * 测试通用Mapper - 保存
         */
        @Test
        public void testInsert() {
        
            String salt = IdUtil.fastSimpleUUID();
            User testSave3 = User.builder().name("testSave3").password(SecureUtil.md5("123456" + salt)).salt(salt).email("testSave3@lfsun.com").phoneNumber("12312312203").status(1).lastLoginTime(new DateTime()).createTime(new DateTime()).lastUpdateTime(new DateTime()).build();
            userMapper.insertUseGeneratedKeys(testSave3);
            Assert.assertNotNull(testSave3.getId());
            log.debug("【测试主键回写#testSave3.getId()】= {}", testSave3.getId());
        }
    
        /**
         * 测试通用Mapper - 批量保存
         */
        @Test
        public void testInsertList() {
        
            List<User> userList = Lists.newArrayList();
            for (int i = 4; i < 14; i++) {
        
                String salt = IdUtil.fastSimpleUUID();
                User user = User.builder().name("testSave" + i).password(SecureUtil.md5("123456" + salt)).salt(salt).email("testSave" + i + "@lfsun.com").phoneNumber("12312312200" + i).status(1).lastLoginTime(new DateTime()).createTime(new DateTime()).lastUpdateTime(new DateTime()).build();
                userList.add(user);
            }
            int i = userMapper.insertList(userList);
            Assert.assertEquals(userList.size(), i);
            List<Long> ids = userList.stream().map(User::getId).collect(Collectors.toList());
            log.debug("【测试主键回写#userList.ids】= {}", ids);
        }
    
        /**
         * 测试通用Mapper - 删除
         */
        @Test
        public void testDelete() {
        
            Long primaryKey = 3L;
            int i = userMapper.deleteByPrimaryKey(primaryKey);
            Assert.assertEquals(1, i);
            User user = userMapper.selectByPrimaryKey(primaryKey);
            Assert.assertNull(user);
        }
    
        /**
         * 测试通用Mapper - 更新
         */
        @Test
        public void testUpdate() {
        
            Long primaryKey = 1L;
            User user = userMapper.selectByPrimaryKey(primaryKey);
            user.setName("通用Mapper名字更新");
            int i = userMapper.updateByPrimaryKeySelective(user);
            Assert.assertEquals(1, i);
            User update = userMapper.selectByPrimaryKey(primaryKey);
            Assert.assertNotNull(update);
            Assert.assertEquals("通用Mapper名字更新", update.getName());
            log.debug("【update】= {}", update);
        }
    
        /**
         * 测试通用Mapper - 查询单个
         */
        @Test
        public void testQueryOne() {
        
            User user = userMapper.selectByPrimaryKey(1L);
            Assert.assertNotNull(user);
            log.debug("【user】= {}", user);
        }
    
        /**
         * 测试通用Mapper - 查询全部
         */
        @Test
        public void testQueryAll() {
        
            List<User> users = userMapper.selectAll();
            Assert.assertTrue(CollUtil.isNotEmpty(users));
            log.debug("【users】= {}", users);
        }
    
        /**
         * 测试分页助手 - 分页排序查询
         */
        @Test
        public void testQueryByPageAndSort() {
        
            //initData();
            int currentPage = 1;
            int pageSize = 5;
            String orderBy = "id desc";
            int count = userMapper.selectCount(null);
            PageHelper.startPage(currentPage, pageSize, orderBy);
            List<User> users = userMapper.selectAll();
            PageInfo<User> userPageInfo = new PageInfo<>(users);
            Assert.assertEquals(5, userPageInfo.getSize());
            Assert.assertEquals(count, userPageInfo.getTotal());
            log.debug("【userPageInfo】= {}", userPageInfo);
        }
    
        /**
         * 测试通用Mapper - 条件查询
         */
        @Test
        public void testQueryByCondition() {
        
            //initData();
            Example example = new Example(User.class);
            // 过滤
            example.createCriteria().andLike("name", "%Save1%").orEqualTo("phoneNumber", "123123122011");
            // 排序
            example.setOrderByClause("id desc");
            int count = userMapper.selectCountByExample(example);
            // 分页
            PageHelper.startPage(1, 3);
            // 查询
            List<User> userList = userMapper.selectByExample(example);
            PageInfo<User> userPageInfo = new PageInfo<>(userList);
            Assert.assertEquals(3, userPageInfo.getSize());
            Assert.assertEquals(count, userPageInfo.getTotal());
            log.debug("【userPageInfo】= {}", userPageInfo);
        }
    
        /**
         * 初始化数据
         */
        private void initData() {
        
            testInsertList();
        }
    
    }