SpringBoot使用通用Mapper实现单表的增删改查

项目结构

配置文件

1. pom.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <project xmlns="http://maven.apache.org/POM/4.0.0"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
   
       <groupId>com.xiaoge</groupId>
       <artifactId>springboot-crud</artifactId>
       <version>1.0-SNAPSHOT</version>
   
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.0.4.RELEASE</version>
       </parent>
   
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-web</artifactId>
           </dependency>
   
           <dependency>
               <groupId>org.projectlombok</groupId>
               <artifactId>lombok</artifactId>
           </dependency>
   
           <!-- HikariCP连接池 -->
           <!--<dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-jdbc</artifactId>
           </dependency>-->
   
           <!-- 数据库驱动 -->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
           </dependency>
   
           <!-- mybatis启动器 -->
           <!--<dependency>
               <groupId>org.mybatis.spring.boot</groupId>
               <artifactId>mybatis-spring-boot-starter</artifactId>
               <version>1.3.4</version>
           </dependency>
   -->
           <!--
                   通用mapper自动帮你实现单表的增删改查
                       通用mapper会自动帮我们引入mybatis启动器 和 连接池, 所以上面的依赖可以注释了
            -->
           <dependency>
               <groupId>tk.mybatis</groupId>
               <artifactId>mapper-spring-boot-starter</artifactId>
               <version>2.0.3</version>
           </dependency>
   
           <!-- 引用test启动器 -->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
           </dependency>
       </dependencies>
   
   </project>
   

2. application.yml

   # 修改服务器端口
   server:
     port: 8088
     # 修改映射路径, 一切访问的资源都必须以/开头, 要不然访问不到
     servlet:
       path: "/"
   
   # 设置日志级别
   logging:
     level:
       # 配置的map key是cn.xiaoge value是debug
       cn.xiaoge: debug
       # 把spring的级别也设置成 debug
       # org.springframework: debug
   
   # 配置连接池参数
   spring:
     datasource:
       driver-class-name: com.mysql.jdbc.Driver
       url: jdbc:mysql://127.0.0.1:3306/yun6
       username: root
       password: root
   
   # 配置mybatis
   mybatis:
     # configuration:
       # 配置mybatis自动驼峰匹配 (通用mapper会帮你开启)
       # map-underscore-to-camel-case: true
     # 别名包
     type-aliases-package: cn.xiaoge.pojo
     # 配置mapper文件地址
     # mapper-locations: mapper/*.xml
   
   

实体类

1. User

   package cn.xiaoge.pojo;
   
   import lombok.Data;
   import tk.mybatis.mapper.annotation.KeySql;
   
   import javax.persistence.Id;
   import javax.persistence.Table;
   import javax.persistence.Transient;
   import java.util.Date;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 16:29
    **/
   @Data
   @Table(name = "tb_user") // 告诉通用mapper, 实体类对应的表, 这样他才能生成sql
   public class User {
   
       // id
       @Id // 告诉通用mapper这是主键
       @KeySql(useGeneratedKeys = true) // id自增长
       private Long id;
   
       // 用户名
       private String username;
   
       // 密码
       private String password;
   
       // 姓名
       private String name;
   
       // 年龄
       private Integer age;
   
       // 性别, 1男性, 2女性
       private Integer sex;
   
       // 出生日期
       private Date birthday;
   
       // 创建时间
       private Date created;
   
       // 更新时间
       private Date updated;
   
       // 备注
       @Transient // 告诉通用mapper 不需要持久化数据库, 它不会作为sql语句的字段
       private String note;
   }
   
   

持久层

1. UserMapper

   package cn.xiaoge.mapper;
   
   import cn.xiaoge.pojo.User;
   import tk.mybatis.mapper.common.Mapper;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 19:08
    **/
   // 继承通用mapper, 泛型是你的实体类, 这样就不用再写增删改查了, 记住单表才用通用mapper
   public interface UserMapper extends Mapper<User> {
   }
   

业务层

1. UserService接口

   package cn.xiaoge.service;
   
   import cn.xiaoge.pojo.User;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 19:50
    **/
   public interface UserService {
   
       public User queryById(Long id);
   
       public void insertUser(User user);
   
   }
   
   

2. UserServiceImpl实现类

   package cn.xiaoge.service.impl;
   
   import cn.xiaoge.mapper.UserMapper;
   import cn.xiaoge.pojo.User;
   import cn.xiaoge.service.UserService;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.stereotype.Service;
   import org.springframework.transaction.annotation.Transactional;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 19:50
    **/
   @Service
   public class UserServiceImpl implements UserService {
   
       @Autowired
       private UserMapper userMapper;
   
       @Override
       public User queryById(Long id) {
           User user = userMapper.selectByPrimaryKey(id);
           return  user;
       }
   
       @Transactional // 给这个方法添加事务
       @Override
       public void insertUser(User user) {
           userMapper.insert(user);
       }
   
       /*
           这里不用写事务, 在你引入jdbc时  事务就已经配置好了,
           我们只需要给需要事务的方法, 加上@Transactional注解就ok了
        */
   }
   
   

拦截器

1. Myinterceptor

   package cn.xiaoge.interceptor;
   
   import lombok.extern.slf4j.Slf4j;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.web.servlet.HandlerInterceptor;
   import org.springframework.web.servlet.ModelAndView;
   
   import javax.servlet.http.HttpServletRequest;
   import javax.servlet.http.HttpServletResponse;
   
   
   /**
    * @program: springbootcrud
    * @description: 自定义拦截器
    * @author: Mr.Xiao
    * @create: 2020-05-02 17:03
    **/
   @Slf4j
   public class Myinterceptor implements HandlerInterceptor {
   
       // 创建日志对象, 传递类告诉spring boot是哪个类在记录日志, 由于上面加了注解, 所以这里不需要自己定义了, 注解默认是log
       // private static final Logger log = LoggerFactory.getLogger(Myinterceptor.class);
   
       /*
           controller执行前执行
        */
       @Override
       public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
           log.debug("preHandle method is running");
           return true;
       }
   
       /*
           controller执行后执行
        */
       @Override
       public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
           log.debug("postHandle method is running");
       }
   
       /*
           jsp文件执行后执行
        */
       @Override
       public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
           log.debug("afterCompletion method is running");
       }
   }
   
   

2. MvcConfig

   package cn.xiaoge.config;
   
   import cn.xiaoge.interceptor.Myinterceptor;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
   import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
   
   /**
    * @program: springbootcrud
    * @description: spring boot java方式配置, 拦截器
    * @author: Mr.Xiao
    * @create: 2020-05-02 17:16
    **/
   @Configuration
   public class MvcConfig implements WebMvcConfigurer {
   
       /**
        * 添加拦截器
        * @param registry
        */
       @Override
       public void addInterceptors(InterceptorRegistry registry) {
           // 添加一个拦截器, 添加拦截路径, 拦截一切路径
           registry.addInterceptor(new Myinterceptor()).addPathPatterns("/**");
       }
   }
   
   

表现层

1. UserController

   package cn.xiaoge.web;
   
   import cn.xiaoge.pojo.User;
   import cn.xiaoge.service.UserService;
   import lombok.extern.slf4j.Slf4j;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.web.bind.annotation.GetMapping;
   import org.springframework.web.bind.annotation.PathVariable;
   import org.springframework.web.bind.annotation.RequestMapping;
   import org.springframework.web.bind.annotation.RestController;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 16:47
    **/
   @Slf4j
   @RestController
   @RequestMapping("/user")
   public class UserController {
   
       @Autowired
       private UserService userService;
   
       @GetMapping("/{id}")
       public User findById(@PathVariable("id") Long id){
           User user = userService.queryById(id);
   
           System.out.println("user: " + user);
   
           log.debug("hello method is running");
   
           return user;
       }
   
   
   }
   

引导类

1. BootCrudApplication

   package cn.xiaoge;
   
   import org.springframework.boot.SpringApplication;
   
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import tk.mybatis.spring.annotation.MapperScan; // 通用mapper的
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 16:40
    **/
   @SpringBootApplication
   @MapperScan("cn.xiaoge.mapper") // 会自动去扫描cn.xiaoge.mapper下的所有接口, 并自动去注册, 也会帮你把单表的sql生成
   public class BootCrudApplication {
   
       public static void main(String[] args) {
   
           SpringApplication.run(BootCrudApplication.class);
   
       }
   
   }
   
   

测试

1. UserMapperTest(springboot整合junit)

   package cn.xiaoge.mapper;
   
   import cn.xiaoge.BootCrudApplication;
   import cn.xiaoge.pojo.User;
   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;
   
   /**
    * @program: springbootcrud
    * @description:
    * @author: Mr.Xiao
    * @create: 2020-05-02 19:41
    **/
   @RunWith(SpringRunner.class)
   @SpringBootTest(classes = BootCrudApplication.class)
   public class UserMapperTest {
   
       @Autowired
       private UserMapper userMapper; // 通用mapper会自动注入, 爆红不用管
   
       @Test
       public void testQuery(){
           User user = userMapper.selectByPrimaryKey(1L);
           System.out.println(user);
       }
   
   }