Spirng Boot整合Mybatis实现增删改查案例-注解版

itlemon

发布于 2020-04-03 16:03:52

6380

发布于 2020-04-03 16:03:52

文章被收录于专栏：深入理解Java深入理解Java

前面的文章介绍了Spring Boot整合JPA实现数据库的访问功能，这里再次介绍Spring Boot整合Mybatis实现数据的增删改查功能。

一、Maven依赖

这里贴出Spring Boot整合Mybatis的完整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>springboot.example</groupId>
    <artifactId>springboot-mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <description>Spring Boot整合Mybatis案例</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.9.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- 数据库 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

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

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        
        <!-- Druid连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.6</version>
        </dependency>

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

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

这里不仅整合了Mybatis，还集成了Druid连接池。观察上面的依赖，我还加入了lombok插件依赖，这个已经被集成到了Spring Boot中，它可以动态地生成实体类的getter和setter等方法，使得实体类更加简洁，继续往下看，你会发现我的实体类没有getter和setter等方法，那是因为我加入了@Data注解，它会运行是创建getter和setter等方法。不明白的可以百度搜索一下lombok的用法，在使用它的时候，你的IDE必须得安装它的插件，如果你嫌麻烦，直接手动删除依赖，删除实体类的@Data注解，使用IDE生成getter和setter等方法。

二、配置文件

spring:
  profiles:
    active: dev # 启用开发配置

---
# 开发配置
spring:
  profiles: dev
  jackson:
      date-format: yyyy-MM-dd HH:mm:ss
      time-zone: Asia/Chongqing
  # 数据库配置
  datasource:
    driverClassName: com.mysql.jdbc.Driver
    url: jdbc:mysql://192.168.25.1:3306/test?characterEncoding=utf8
    username: root
    password: root
    # 配置Durid连接池
    type: com.alibaba.druid.pool.DruidDataSource
  jpa:
      database: MYSQL
      show-sql: true
      hibernate:
        ddl-auto: update
      properties:
        hibernate:
          dialect: org.hibernate.dialect.MySQL5Dialect
server:
  port: 8080

这里配置JPA仅仅是为了启动项目的时候会自动根据实体类到数据库中创建相应的表，没有其他作用，实际项目中应该将其去掉。

三、主要代码

1 主程序

package com.lemon.springboot.application;

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

/**
 * @author lemon
 * @date 2018/1/4 下午9:24
 */
@SpringBootApplication
@EnableAutoConfiguration
@EntityScan(basePackages = {"com.lemon.springboot.entity"})
@MapperScan(basePackages = {"com.lemon.springboot.dao"})
public class MainApplication {

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

因为需要使用JPA自动生成表，所以加上了@EntityScan注解，@MapperScan用来扫描mapper类。

2 实体类

package com.lemon.springboot.entity;

import lombok.Data;

import javax.persistence.*;

/**
 * @author lemon
 * @date 2018/1/4 下午9:27
 */
@Data
@Entity
@Table(name = "product")
public class Product {

    @Id
    @GeneratedValue
    @Column(name = "product_id")
    private Integer productId;

    @Column(name = "product_name")
    private String productName;

    @Column(name = "product_stock")
    private Integer productStock;
}

@Data注解可以动态为实体类生成getter和setter等方法。

3 Mapper类

package com.lemon.springboot.dao;

import com.lemon.springboot.entity.Product;
import org.apache.ibatis.annotations.*;

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

/**
 * Mybatis接口
 *
 * @author lemon
 * @date 2018/1/3 下午10:06
 */
public interface ProductMapper {

    /**
     * 按照map方式插入数据，map是键值对，插入的时候#{}里面的值将从map中取
     *
     * @param map 需要插入的数据
     * @return 插入成功返回1，失败返回0
     */
    @Insert("insert into product(product_name, product_stock) values(#{product_name, jdbcType=VARCHAR}, #{product_stock, jdbcType=INTEGER})")
    int insertByMap(Map<String, Object> map);

    /**
     * 直接根据对象属性来进行插入，也就是说直接插入对象到数据库，要保持字段和SQL语句内的预留字段一致
     *
     * @param product 商品对象
     * @return 插入成功返回1，失败返回0
     */
    @Insert("insert into product(product_name, product_stock) values(#{productName, jdbcType=VARCHAR}, #{productStock, jdbcType=INTEGER})")
    int insertByObject(Product product);

    /**
     * 根据ID来查询商品，由于ID是独一唯二的，所以只会查询到一条数据或者0条，用Product对象来接收数据,
     * 注意：接收数据要进行映射才可以接收成功，用Results注解来映射
     *
     * @param productId 商品ID
     * @return Product对象
     */
    @Select("select * from product where product_id = #{productId}")
    @Results({
            @Result(column = "product_id", property = "productId"),
            @Result(column = "product_name", property = "productName"),
            @Result(column = "product_stock", property = "productStock")
    })
    Product findByProductId(Integer productId);

    /**
     * 当商品名字重复是时候，我们根据商品名字查询，将查询到多条数据，这时候应该使用List来接收数据
     *
     * @param productName 商品名字
     * @return 商品的集合
     */
    @Select("select * from product where product_name = #{productName}")
    @Results({
            @Result(column = "product_id", property = "productId"),
            @Result(column = "product_name", property = "productName"),
            @Result(column = "product_stock", property = "productStock")
    })
    List<Product> findByProductName(String productName);

    /**
     * 根据一个字段ID来修改商品名称，当传入多个参数的时候，需要使用@Param注解来是SQL语句中名字和参数名字一致，这样就不会出错
     *
     * @param productId   商品ID
     * @param productName 商品名称
     * @return 更新成功返回1，失败返回0
     */
    @Update("update product set product_name = #{productName} where product_id = #{productId}")
    int updateByProductId(@Param("productId") Integer productId, @Param("productName") String productName);

    /**
     * 根据一个对象来更新数据
     *
     * @param product 商品对象
     * @return 更新成功返回1，失败返回0
     */
    @Update("update product set product_name = #{productName} where product_id = #{productId}")
    int updateByObject(Product product);

    /**
     * 根据ID来删除记录，也可以根据对象来删除，道理和上面的更新一致
     *
     * @param productId 商品ID
     * @return 删除成功返回1，失败返回0
     */
    @Delete("delete from product where product_id = #{productId}")
    int deleteByProductId(Integer productId);
}

这个接口实现了简单的增删改查，具体使用方法，一看就明白，注释很清楚。

四、测试

这里做出了简单的测试类：

package com.lemon.springboot.dao;

import com.lemon.springboot.application.MainApplication;
import com.lemon.springboot.entity.Product;
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.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author lemon
 * @date 2018/1/4 下午9:30
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = MainApplication.class)
public class ProductMapperTest {

    @Autowired
    private ProductMapper mapper;

    @Test
    public void insertByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("product_name", "apple");
        map.put("product_stock", 200);
        int result = mapper.insertByMap(map);
        // 下面这一句是检测返回结果是否为1，不为1将报错
        Assert.assertEquals(1, result);
    }

    @Test
    public void insertByObject() {
        Product product = new Product();
        product.setProductName("banana");
        product.setProductStock(10);
        int result = mapper.insertByObject(product);
        // 下面这一句是检测返回结果是否为1，不为1将报错
        Assert.assertEquals(1, result);
    }

    @Test
    public void findByProductId() {
        Product result = mapper.findByProductId(1);
        System.out.println(result);
        Assert.assertNotNull(result);
    }

    @Test
    public void findByProductName() {
        // 由于前面只插入了一个名字为apple的商品，请你在运行这个案例之前在运行一下第一个或者第二个例子，你设置名字还是apple，库存改一下，这样数据库就有两条数据了，方便测试
        List<Product> result = mapper.findByProductName("apple");
        System.out.println("一共查询的数据条数是：" + result.size());
        Assert.assertNotEquals(0, result.size());
    }

    @Test
    public void updateByProductId() {
        // 将第一条记录的名字由apple改成orange橙子
        int result = mapper.updateByProductId(1, "orange");
        Assert.assertNotEquals(0, result);
    }

    @Test
    public void updateByObject() {
        // 我们将第一条记录的名字修改成火龙果
        Product product = new Product();
        product.setProductId(1);
        product.setProductName("pitaya");
        int result = mapper.updateByObject(product);
        // 下面这一句是检测返回结果是否为1，不为1将报错
        Assert.assertEquals(1, result);
    }

    @Test
    public void deleteByProductId() {
        int result = mapper.deleteByProductId(1);
        Assert.assertEquals(1, result);
    }
}

这个测试类最好从第一个案例依个测试。