SpringBoot2.X集成Mybatis2.X实现数据库简单操作注解和XML两种方式

一、创建springboot2.X，并导入相关Starter包

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.jx</groupId>
    <artifactId>mybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mybatis</name>
    <description>Demo project for Spring Boot</description>

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>
        <!--导入连接MySQL的依赖 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.7.RELEASE</version>
                <configuration>
                    <mainClass>com.jx.mybatis.MybatisApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

 

二、创建数据库表

三、编写application.properties文件

# 应用名称
spring.application.name=mybatis
# 应用服务 WEB 访问端口
server.port=8080
#下面这些内容是为了让MyBatis映射
#指定Mybatis的Mapper文件
mybatis.mapper-locations=classpath:/*xml
#指定Mybatis的实体目录
mybatis.type-aliases-package=com.jx.mybatis.mybatis.entity


#mysql
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis?serverTimezone=Asia/Shanghai&useunicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#spring.datasource.max-idle=10
#spring.datasource.max-wait=10000
#spring.datasource.min-idle=5
#spring.datasource.initial-size=5

 

四、编写代码

4.1、XML文件形式

4.1.1编写实体类user

package com.jx.mybatis.entity;

import org.springframework.stereotype.Component;

import java.io.Serializable;

@Component
public class User implements Serializable {
    private Integer userID ;
    private String userName;
    private String passWord;

    public Integer getUserID() {
        return userID;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }

    public void setUserID(Integer userID) {
        this.userID = userID;
    }
}

 

4.1.2、编写UserMapper

package com.jx.mybatis.Mapper;

import com.jx.mybatis.entity.User;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

@Repository
public interface UserMapper {
    User findByID(Integer id);
    void insertUser(User user);
    //传入多参数时，需要使用@Param注解命名一个别名，在Mapper.xml文件中使用别名参数，
    // 若不加@Param注解，会使用“param”为前缀，加上实际参数的位置，如{param1}，{param2}
//    void updateUser(@Param("userID") Integer id, @Param("user") User changeUser);
    void updateUser(User changeUser);
    void deleteUser(Integer id);
}

 

4.1.3、在resources下编写UserMapper.xml

<?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.xml文件中的namespace即是mapper接口的类路径。与接口绑定-->
<mapper namespace="com.jx.mybatis.Mapper.UserMapper">
    <!--
    resultMap映射管理器映射数据库表与实体类的映射关系,该标签与insert标签中的resultMap属性同时使用
    id 表示这个映射管理器的唯一标识，外部通过该值引用
    type 表示需要映射的实体类；
    -->
   <!-- <resultMap id="userResultMap" type="com.jx.mybatis.entity.User">
        &lt;!&ndash;
        id 设置数据库表主键字段与实体类属性映射关系
        result 设置数据库表普通字段与实体类属性映射关系
        &ndash;&gt;
       <id column = "user_id" jdbcType="INT" property="userID"/>
        <result column="user_name" jdbcType="VARCHAR" property="userName"/>
        <result column="pass_word" jdbcType="VARCHAR" property="passWord" />
    </resultMap>-->

    <!--
    当Sql语句比较简单时候，用注解绑定，当SQL语句比较复杂时候，用xml绑定。一般情况下，用xml绑定的比较多。
    使用MyBatis的mapper接口调用时要注意的事项有：

    （1）Mapper接口方法名和mapper.xml中定义的每个sql的id相同；

    （2）Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同；

    （3）Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同；

    （4）Mapper.xml文件中的namespace即是mapper接口的类路径。

    insert、select、update、delete标签中：
    id: 表示此段sql执行语句的唯一标识，也是接口的方法名称,【必须一致才能找到】
    parameterType: 表示该sql语句中需要传入的参数类型，类型要与对应的接口方法的类型一致
                   【这个属性是可选的，因为 MyBatis 可以通过类型处理器（TypeHandler）推断出具体传入语句的参数，默认值为未设置（unset）】
                   如果查询一条数据中，传入的是主键id,它的参数类型是Integer。
                   如果插入一条数据中，传入的参数是一个类对象，这里应该写类的完整路径 包名+类名，如com.jx.mybatis.entity.类名
    parameterMap:【老式风格的参数映射。此元素已被废弃，并可能在将来被移除！请使用行内参数映射和parameterType 属性】

                传入参数类型，此类型需要配合映射文件中的<parameterMap>标签使用
    resultMap: 查询语句返回的结果类型，此类型需要和映射文件中的<resultMap>标签配合使用，返回结果会自动装配为resultMap映射的类对象
    resultType: 查询语句返回的结果类型，同parameterType一样，这里标识的是返回值的参数类型。
                匹配普通java类型或自定义的pojo，该属性需要在数据库表列与实体类属性名一致时使用
                如果数据库表列名与实体类对应属性名不一致，可以在查询语句中使用别名，如 数据库列名 as 实体类属性名

    当实体类中的属性和数据库中的字段对应时，我们使用resultType和parameterType就可以完成CRUD
    当实体类中的属性和数据库中的字段不对应时，就要用resultMap和parameterMap【失效，未来可能删除该属性】（现在都使用parameterType）了
    当实体类中的属性和数据库中的字段不对应时，若要使用resultType和parameterType,数据库查询字段需要使用别名（别名名称和实体类属性名一致）查询
    resultMap和resultType不能同时在一个select语句里使用
    -->
    <!--id使用自增长策略，插入值是id列插入空值-->
    <insert id="insertUser" parameterType="com.jx.mybatis.entity.User"  >
            insert into user(user_id,user_name,pass_word) value(null,#{userName},#{passWord})
    </insert>
    <!--当实体类中的属性和数据库中的字段不对应时，就要用resultMap和parameterMap【失效，未来可能删除该属性】（现在都使用parameterType）了-->
    <!--resultMap属性指向上面的resultMap的ID，表示当前查询结果集封装为指定resultMap里type对应的类型的对象-->
    <!--<select id="findByID" resultMap="userResultMap" parameterType="java.lang.Integer">
            select * from user where user_id =#{id}
    </select>-->

    <!--如果数据库表列名与实体类对应属性名不一致，要使用resultType，可以在查询语句中使用别名，如 数据库列名 as 实体类属性名，否则使用resultMap-->
    <select id="findByID" resultType="com.jx.mybatis.entity.User" parameterType="java.lang.Integer">
            select user_id as userID,user_name as userName,pass_word as passWord  from user where user_id =#{id}
    </select>
    <!--
    当传入实体类对象参数时，
    1、DAO层为单参数，例如在本例子中UserMapper类方法updateUser（User user);可直接使用userName属性
    2、DAO层方法为多参数，例如UserMapper类方法updateUser（@Param("userID") Integer id, @Param("user") User changeUser);
    Mapper.xml文件传参需要 对象.属性名传参,user.userName
    -->
    <!--<update id="updateUser" parameterType="com.jx.mybatis.entity.User">
            update user set user_name = #{user.userName},pass_word = #{user.passWord} where user_id = #{userID}

    </update>-->
    <update id="updateUser" parameterType="com.jx.mybatis.entity.User">
            update user set user_name = #{userName},pass_word = #{passWord} where user_id = #{userID}

    </update>
    <delete id="deleteUser" parameterType="com.jx.mybatis.entity.User">
            delete from user where user_id = #{userID}
    </delete>
</mapper>

 

4.1.4、编写UserController

package com.jx.mybatis.controller;

import com.jx.mybatis.Mapper.UserMapper;
import com.jx.mybatis.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("user")
public class UserController {

    @Autowired
    private UserMapper userMapper;
    @RequestMapping("/get/{id}")
    public User getUser(@PathVariable Integer id){
        User user = userMapper.findByID(id);
        return user;
    }
    @RequestMapping("/add/{userName}/{passWord}")
    public void addUser(@PathVariable String userName,@PathVariable String passWord){
        User user = new User();
        user.setUserName(userName);
        user.setPassWord(passWord);
        userMapper.insertUser(user);
    }
    @RequestMapping("/update/{userID}/{userName}/{passWord}")
    public void updateUser(@PathVariable Integer userID,@PathVariable String userName,@PathVariable String passWord){
        User user = new User();
        user.setUserID(userID);
        user.setUserName(userName);
        user.setPassWord(passWord);

//        userMapper.updateUser(userID,user);
        userMapper.updateUser(user);
    }
    @RequestMapping("/delete/{userID}")
    public void deleteUser(@PathVariable Integer userID){
        userMapper.deleteUser(userID);
    }
}

4.1.5、在主启动类开启扫描

package com.jx.mybatis;

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

@MapperScan("com/jx/mybatis/Mapper")
@SpringBootApplication
public class MybatisApplication {

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

}

至此mybatis的XML文件方式配置完成

4.2、注解方式

4.2.1、编写Permission实体类

package com.jx.mybatis.entity;

import org.springframework.stereotype.Component;

import java.io.Serializable;

@Component
public class Permission implements Serializable {
    private Integer permissionID;
    private String user_Role;

    public Integer getPermissionID() {
        return permissionID;
    }

    public void setPermissionID(Integer permissionID) {
        this.permissionID = permissionID;
    }

    public String getUser_Role() {
        return user_Role;
    }

    public void setUser_Role(String user_Role) {
        this.user_Role = user_Role;
    }
}

 

4.2.2、编写PermissionMapper类

package com.jx.mybatis.Mapper;

import com.jx.mybatis.entity.Permission;
import org.apache.ibatis.annotations.*;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public interface PermissionMapper {
    /*
    * @Result，@Results，@ResultMap是结果集映射的三大注解。
    * 首先说明一下@Results各个属性的含义
    * id为当前结果集声明唯一标识
    * value值为结果集映射关系
    * @Result代表一个字段的映射关系,column指定数据库字段的名称，property指定实体类属性的名称，jdbcType数据库字段类型
    * @Result里的id值为true表明主键，默认false
    * 使用@ResultMap来引用映射结果集
    * */
    @Results(id = "permissionMResultMap", value ={
        @Result(column = "id",property = "permissionID" ,id=true),
        @Result(column = "role",property = "user_Role" )
    })

    @Select("select * from permission where id = #{permissionID}" )
    Permission findByID(Integer id);

    @Select("select * from permission")
    /*
    * 引用上面定义的结果映射器@Results，@ResultMap的value为@Results的ID定义的值
    * */
    @ResultMap(value = "permissionMResultMap")
    List<Permission> findAll();

    @Insert("insert into permission(id,role) value(null,#{user_Role})")
    void insertPermission(Permission permission);

    @Delete("delete from permission where id = #{permissionID}")
    void deletePermission(Integer id);

    @Update("update permission set role = #{user_Role} where id = #{permissionID}")
    void updatePermission(Permission permission);
}

4.2.3、编写PermissionController类

package com.jx.mybatis.controller;

import com.jx.mybatis.Mapper.PermissionMapper;
import com.jx.mybatis.entity.Permission;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/permission")
public class PermissionController {
    @Autowired
    private PermissionMapper permissionMapper;
    @RequestMapping("/getAll")
    public List<Permission> getAllPermission(){
        List<Permission> list =  permissionMapper.findAll();
        return list;
    }
    @RequestMapping("/get/{id}")
    public Permission getPermission(@PathVariable Integer id){
       return  permissionMapper.findByID(id);
    }
    @RequestMapping("/add/{role}")
    public void addPermission(@PathVariable String role){
        Permission permission = new Permission();
        permission.setUser_Role(role);
        permissionMapper.insertPermission(permission);

    }
    @RequestMapping("/delete/{id}")
    public void deletePermission(@PathVariable Integer id){
        permissionMapper.deletePermission(id);
    }
    @RequestMapping("/update/{id}/{role}")
    public void updataPermission(@PathVariable Integer id,@PathVariable String role){
        Permission permission = new Permission();
        permission.setPermissionID(id);
        permission.setUser_Role(role);
        permissionMapper.updatePermission(permission);
    }

}

至此，注解形式编写完毕。