Mybatis 基础

简介

MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。

MyBatis 消除了几乎所有的 JDBC 代码和参数的手工设置以及结果集的检索。

MyBatis 使用简单的 XML 或注解用于配置和原始映射，将接口和 Java 的POJOs（普通的 Java对象）映射成数据库中的记录。

每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。

用xml文件构建SqlSessionFactory实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但其实可以使用任何Reader实例，包括用文件路径或 file:// 开头的 url 创建的实例。MyBatis有一个实用类----Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。

优点

MyBatis封装了JBDC底层访问数据库的细节，使我们程序猿不需要与JDBC API打交道，就可以访问数据库
MyBatis简单易学，程序猿直接编写SQL语句，适合于对SQL语句性能要求比较高的项目
SQL语句封装在配置文件中，便于统一管理与维护，降低了程序的耦合度
SQL代码从程序代码中彻底分离出来，可重用
提供了动态SQL标签，支持编写动态SQL
提供映射标签，支持对象与数据库的ORM字段关系映射

缺点

过于依赖数据库SQL语句，导致数据库移植性差，更换数据库，如果SQL语句有差异，SQL语句工作量大
由于xml里标签id必须唯一，导致DAO中方法不支持方法重载

SpringBoot 集成 Mybatis

依赖

SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了

        <!-- Mybatis启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!-- mybatis分页插件 PageHelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>       

        <!-- jdbc连接启动器-->
        <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

默认情况下，插件MyBatis-Spring-Boot-Starter将进行如下配置：

自动检查 SpringBoot 的数据源配置并构建 DataSource 对象
通过 SqlSessionFactoryBean 使用数据源构建并注册 SqlSessionFactory 对象
从 SqlSessionFactory 中创建并注册一个 SqlSessionTemplate 实例，其实就是构建一个 SqlSession 对象
自动扫描使用了注解@Mapper的接口映射器，并将这些映射器与SqlSessionTemplate实例进行关联，同时将它们注册到Spring容器中

常用yaml配置

mybatis:
  # 注册XML映射器，即mapper.xml文件位置。如果没有映射文件，请注释掉
  mapper-locations: classpath:mapper/**.xml
  # 配置Java类型别名包扫描路径。通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名(即 XML 中调用的时候可以不用包含全限包名)
  type-aliases-package: com.test.springbootssm.entity
  configuration:
    # 指定MyBatis所用日志的具体实现（输出sql语句），未指定时将自动查找。
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 开启自动驼峰命名规则（camel case）映射。即从经典数据库列名 A_COLUMN（下划线命名）到经典 Java 属性名 aColumn（驼峰命名）的类似映射
    map-underscore-to-camel-case: true

不太常用的yaml配置

mybatis:
  ## 不常用的配置
  check-config-location: true           # 是否检测MyBatis运行参数配置文件
  config-location: classpath:mybatis/mybatis-config.xml        # mybatis配置文件所在路径
  type-handlers-package: test.springboot.handlers             # 配置类型处理器包名
  executor-type: SIMPLE                                       # 指定执行器类型
  configuration:
      default-fetch-size: 20
      default-statement-timeout: 30
      lazy-loading-enabled: true         # 开启延时加载开关
      aggressive-lazy-loading: false     # 将积极加载改为消极加载（即按需加载）,默认值就是false
      lazy-load-trigger-methods: ""     # 指定触发延迟加载的方法
      cache-enabled: true                 # 打开全局缓存开关（二级环境），默认值就是true
      
#MyBatis使用pageHelper分页
pagehelper:
  helper-dialect: mysql        # 配置使用哪种数据库语言，不配置的话pageHelper也会自动检测
  reasonable: true            # 启用查询合理化。如果pageNum<1，则会查询第一页；如果pageNum>pages，则会查询最后一页
  # 支持通过Mapper接口参数来传递分页参数，默认值false，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。
  support-methods-arguments: true

上述配置参数最终是通过mybatis-spring-boot-autoconfigure.jar加载和配置的。

Java方式配置MyBatis运行时参数

MyBatis的运行时参数除了可以在SpringBoot的配置文件中指定，还可以通过Java编码方式设置。实际上就是在Spring容器中注册一个实现了ConfigurationCustomizer接口的Bean。

import org.springframework.context.annotation.Configuration;

@Configuration
public class MyBatisConfig {
    
    @Bean
    ConfigurationCustomizer mybatisConfigurationCustomizer() {
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                // 在SpringBoot中以Java编码方式配置MyBatis运行时参数
                configuration.setMapUnderscoreToCamelCase(true);
                configuration.addMappers("com.test.springboot.mapper");
            }
        };
    }
}

Spring 集成 MyBatis

依赖

        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${version.mybatis}</version>
        </dependency>
        <!-- 通用Mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>${version.mybatis.mapper}</version>
        </dependency>
        <!-- mybatis分页插件 PageHelper -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>${version.pagehelper}</version>
        </dependency>

        <!-- mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${version.mybatis.spring}</version>
        </dependency>

        <!-- spring事务 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>

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

通过Java方式注册MyBatis核心组件

通过Java方式在Spring框架中注册MyBatis的核心组件Bean，并且配置声明式事务管理。

（1）在Spring中注册MyBatis的核心组件Bean：SqlSessionFactory，SqlSession，以及Spring的事务管理器。另外，在构建SqlSessionFactory时还可以注册MyBatis的xml映射器。

@Configuration
@EnableTransactionManagement
public class MyBatisSpringConfig implements TransactionManagementConfigurer {
    @Autowired
    private DataSource dataSource;
    
    // 在Spring中注册SqlSessionFactory，在这里可以设置一下参数：
    // 1.设置分页参数
    // 2.配置MyBatis运行时参数
    // 3.注册xml映射器
    @Bean
    public SqlSessionFactory sqlSessionFactory() {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 设置数据源
        sqlSessionFactoryBean.setDataSource(dataSource);
        // 设置映射POJO对象包名
        // sqlSessionFactoryBean.setTypeAliasesPackage("org.chench.test.springboot.model");
        
        // 分页插件
        /*PageHelper pageHelper = new PageHelper();
        Properties properties = new Properties();
        properties.setProperty("reasonable", "true");
        properties.setProperty("supportMethodsArguments", "true");
        properties.setProperty("returnPageInfo", "check");
        properties.setProperty("params", "count=countSql");
        pageHelper.setProperties(properties);*/
        //添加插件
        //sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageHelper});
        
        // 配置mybatis运行时参数
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        // 自动将数据库中的下划线转换为驼峰格式
        configuration.setMapUnderscoreToCamelCase(true);
        configuration.setDefaultFetchSize(100);
        configuration.setDefaultStatementTimeout(30);
        
        sqlSessionFactoryBean.setConfiguration(configuration);
        
        // 在构建SqlSessionFactory时注册xml映射器
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        try {
            sqlSessionFactoryBean.setMapperLocations(resolver.getResources("classpath:mapper/*.xml"));
            return sqlSessionFactoryBean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 注入sqlSession对象
     * @param sqlSessionFactory
     * @return
     */
    @Bean(value = "sqlSession")
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    // Spring事务管理器
    @Bean(value = "transactionManager")
    @Override
    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return new DataSourceTransactionManager(dataSource);
    }
}

（2）注册MyBatis接口映射器 MyBatis 3支持2种映射器：xml映射器和接口映射器，其中xml映射器可以在构建SqlSessionFactory时进行注册。

@Configuration
@AutoConfigureAfter(MyBatisSpringConfig.class) //注意，由于MapperScannerConfigurer执行的比较早，所以必须有该注解
public class MyBatisMapperScannerConfig {
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
        // 设置sqlSessionFactory名
        mapperScannerConfigurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        // 设置接口映射器基础包名
        mapperScannerConfigurer.setBasePackage("org.chench.test.springboot.mapper");
        Properties properties = new Properties();
        //properties.setProperty("mappers", "org.chench.test.springboot.mapper");
        properties.setProperty("notEmpty", "false");
        properties.setProperty("IDENTITY", "MYSQL");
        mapperScannerConfigurer.setProperties(properties);
        return mapperScannerConfigurer;
    }
}

MyBatis支持2种类型的映射器：XML映射器和接口映射器，在这里以定义并使用接口映射器为例。

定义接口映射器

@Repository
public interface AccountMapper {
    @Select("select * from account where id = #{id}")
    public Account getAccountById(@Param("id") long id);
}

注意： 在这里可以使用Spring容器的注解@Repository声明MyBatis的接口映射器为一个Bean组件，这样在使用接口映射器时可以直接注入这个接口映射器Bean进行使用。

通过xml方式注册MyBatis核心组件

applicationContext-mybaits.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                http://www.springframework.org/schema/aop
                http://www.springframework.org/schema/aop/spring-aop.xsd
                http://www.springframework.org/schema/tx
                http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--datasource-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
        <property name="url" value="jdbc:mysql:///heima23"></property>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    </bean>

     <!--1、spring管理mybatis的核心对象-->
    <!--sqlSessionfactory-->
    <bean id="sqlSessionfactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="cn.test.domain"></property>
    </bean>

    <!--
        spring自动的对执行包下的dao接口创建动态代理对象，存入容器
            mapperScannerConfigurer：
               1、spring容器启动的时候，加载执行包下的所有接口和映射文件
               2、调用session的方法获取dao接口的动态代理对象
               3、将对象存入容器
    -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--dao接口所在的包-->
        <property name="basePackage" value="cn.test.dao"></property>
    </bean>


    <!--2、配置声明式事务（xml）-->
    <!-- i.事务管理器交给容器管理-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--ii.配置事务通知-->
    <tx:advice id="txAdvice">
        <tx:attributes>
            <tx:method name="save*" propagation="REQUIRED" read-only="false"/>
            <tx:method name="update*"/>
            <tx:method name="delete*"/>
            <tx:method name="find*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*"></tx:method>
        </tx:attributes>
    </tx:advice>
    
    <!--iii.配置事务的AOP-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* cn.test.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
    </aop:config>

</beans>

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 namespace="com.test.springbootssm.mapper.UserMapper">
    <!--注意包名不要错了-->
    <select id="findById" parameterType="long" resultType="user">
        select * from tb_user where id=#{id}
    </select>
</mapper>

配置 mapper 接口扫描

方式一

给每一个Mapper接口添加@Mapper注解，由Spring来扫描这些注解，完成Mapper接口的动态代理。

@Mapper
public interface UserMapper {
}

方式二

在启动类上添加扫描包注解（若Mapper接口文件位置统一存放，推荐此种方式）

这种方式的好处是，不用给每一个Mapper都添加注解。

@SpringBootApplication
@MapperScan("com.test.springbootssm.mapper")
public class Application {
    public static void main(String[] args) {
        // 启动代码
        SpringApplication.run(Application.class, args);
    }
}

Mybatis 实现 Dao 层

接口开发规范

接口全限定名与映射文件的namespace属性一致
接口的方法名与statement（子标签）的id属性一致
接口方法参数类型与statement（子标签）的parameterType属性一致
接口方法返回值类型与statement（子标签）的resultType属性一致

UserMapper接口

public interface UserMapper {
    public List<User> findAll();
}

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 namespace="com.test.mapper.UserMapper">

<select id="findAll" resultType="user">
    select * from user
</select>

</mapper>

Mybatis 高级查询

查询结果封装

resultType
如果实体的属性名与数据库表中字段名（或查询字段别名）一致，将查询结果自动封装到实体类中。
- 如果是单条数据，mybatis直接返回封装好数据的对象
- 如果是多条数据，mybatis会将封装好的多个对象放入list集合中

resutlMap
如果实体的属性名与数据库表中字段名不一致，使用ResutlMap实现手动映射封装到实体类中

resutlMap的属性说明：

<resultMap id="userResultMap" type="user">
    <!-- id     此标签唯一标识`-->
    <!-- type     封装后的实体类型`-->
    
<id column="uid" property="id"></id>                          <!-- 表中主键字段封装`-->
<result column="username" property="username"></result>      <!-- 表中普通字段封装`-->
    <!-- column      表中的字段名`-->
    <!-- property     实体的属性名`-->

xml映射文件：

<resultMap id="userResultMap" type="user">
    <id column="uid" property="id"></id>
    <result column="username" property="username"></result>
    <result column="bir" property="birthday"></result>
    <result column="gender" property="sex"></result>
    <result column="address" property="address"></result>
</resultMap>

<select id="findAllResultMap" resultMap="userResultMap">
    SELECT id AS uid,username AS NAME,birthday AS bir,sex AS gender ,address FROM USER
</select>

多条件查询

方式1：将多个参数封装到一个 pojo对象中，进行对象的传递【推荐】
方式2：使用 @Param 注解声明参数【推荐】
缺点：参数过多时不太方便
方式3：xml里sql中使用 #{arg0} #{arg1}... 或 #{param1} #{param2}... 传递参数
缺点：可读性差

mapper接口：

// 方式1
public List<User> findByIdAndUsername3(User user);
// 方式2
public List<User> findByIdAndUsername2(@Param("id") Integer id,@Param("username") String username);
// 方式3
public List<User> findByIdAndUsername1(Integer id,String username);

xml文件：

<!-- 方式1 -->
<select id="findByIdAndUsername3" parameterType="user" resultType="user">
    select * from user where id = #{id} and username = #{username}
</select>

<!-- 方式2（如果查询条件有多个参数  parameterType 可以省略） -->
<select id="findByIdAndUsername2" resultType="user">
    select * from user where id = #{id} and username = #{username}
</select>

<!-- 方式3（如果查询条件有多个参数  parameterType 可以省略） -->
<select id="findByIdAndUsername1" resultType="user">
    <!--  select * from user where id = #{arg0} and username = #{arg1} -->
    select * from user where id = #{param1} and username = #{param2}
</select>

模糊查询

方式1：sql中使用 concat函数进行模糊匹配拼接【推荐】
方式2：sql中使用 || （字符串连接符）进行模糊匹配拼接【推荐】
方式3：java中添加模糊匹配
缺点：在java中出现了sql通配符，产生了耦合性问题，不太推荐使用
```
// java示例
List<User> list = userDao.findLikeUsername("%王%")
```
方式4：sql中拼接模糊匹配（%#{usenme}%）
缺点：只支持mysl5.5以上版本，oracle不支持该写法
方式5：sql中拼接模糊匹配（%${value}%）
${} 字符串拼接 ,如果接收简单数据类型名称只能是：${value}
缺点：这种方式的底层使用的是编译对象statement做的查询，会出现sql注入问题，开发不能使用

xml文件：

<!-- 方式1 -->
<select id="findByUsername4" parameterType="string" resultType="user">
    select * from user where username like concat('%', #{username}, '%');
</select>

<!-- 方式2 -->
<select id="findByUsername4" parameterType="string" resultType="user">
    select * from user where username like ('%' || #{username} || '%');
</select>

<!-- 方式3 -->
<select id="findByUsername1" parameterType="string" resultType="user">
    select * from user where username like #{username}
</select>

<!-- 方式4 -->
<select id="findByUsername1" parameterType="string" resultType="user">
    select * from user where username like '%#{username}%'
</select>

<!-- 方式5-->
<select id="findByUsername3" parameterType="string" resultType="user">
    select * from user where username like '%${value}%'
</select>

分页查询

需要添加 PageHelper 的依赖

        <!-- mybatis分页插件 PageHelper（与SpringBoot集成版） -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.3</version>
        </dependency>

    /**
     * 分页查询所有数据
     * */
    @Override
    public PageInfo<Brand> findPage(Integer page, Integer size) {
        //调用PageHelper的startPage方法，设置当前页、每页条数
        PageHelper.startPage(page, size);
        //调用dao接口方法，查询所有的数据
//        List<Brand> brandList = brandDao.selectAll();
        Page<Brand> list = brandDao.selectAll();
        //把查到的数据封装到PageInfo中，然后返回，PageInFo中包含了所有的数据，总条数等等
        PageInfo<Brand> pageInfo = new PageInfo<>(list);
        //返回即可
        return pageInfo;
    }

动态传递参数方式：#{} 与 ${}

（1）#{}：占位符

\#{} 是预编译处理，MyBatis在处理 #{} 时，它会将sql中的 #{} 替换为？，然后调用 PreparedStatement 的set方法来赋值，传入字符串后，会在值两边加上单引号。

（2）${}：拼接符

${} 是字符串替换，在处理是字符串替换，mybaits在处理时，它会将 sql 中的 { } 替换为变量的值，传入的数据不会在两边加上单引号。

注意：使用${ }会导致sql注入，不利于系统的安全性！

SQL注入：就是通过把SQL命令插入到Web表单提交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。常见的有匿名登录（在登录框输入恶意的字符串）、借助异常获取数据库信息等

#{} 与 ${} 的区别：

#{}：底层 PreparedStatement
    1.sql与参数分离，不会出现sql注入问题
    2.sql只需要编译一次
    3.接收普通数据类型，命名：#{随便写}
    4.接收引用数据类型，命名：#{属性名} 
    5.变量替换后，#{} 对应的变量自动加上单引号 ''

${}：底层 Statement
    1.将sql与参数拼接在一起，会出现sql注入问题
    2.每次执行sql语句都会编译一次
    3.接收普通数据类型，命名：'${value}'
    4.接收引用数据类型，命名: '${属性名}'  ；注意：需要使用单引号‘${xxx}’
    5.变量替换后，${} 对应的变量不会加上单引号 ''

必须使用@param注解的四种情况

1、方法有多个参数

原因：当不使用 @Param 注解时，mybatis 是不认识哪个参数叫什么名字的，尽管在接口中定义了参数的名称，mybatis仍然不认识。mybatis默认以接口中参数定义的顺序和SQL语句中的表达式进行映射。

例如：

mapper接口方法：

@Mapper
public interface UserMapper {
    Integer insert(@Param("username") String username, @Param("address") String address);
}

对应的xml：

<insert id="insert" parameterType="org.javaboy.helloboot.bean.User">
    insert into user (username, address) values (#{username}, #{address});
</insert>

2、方法参数要取别名

mapper接口方法：

@Mapper
public interface UserMapper {
    Integer insert(@Param("name") String username, @Param("address") String address);
}

对应的xml：

<insert id="insert" parameterType="org.javaboy.helloboot.bean.User">
    insert into user (username, address) values (#{name}, #{address});
</insert>

3、XML 中的 SQL 使用了 $ 拼接sql

$会有注入的问题，但是有的时候不得不使用 $ 符号，例如要传入列名或者表名的时候，这个时候必须要添加 @Param 注解

mapper接口方法：

@Mapper
public interface UserMapper {
    List<User> getAllUsers(@Param("order_by")String order_by);
    
    List<User> findAll(@Param("tb_user")String tb_user);
}

对应xml：

<select id="getAllUsers" resultType="org.javaboy.helloboot.bean.User">
    select * from user
    <if test=" order_by !=null and order_by != ''">
        order by ${order_by} desc            <!-- order by 时，必须用 ${} 传入列名 -->
    </if>
</select>

<select id="findAll" resultType="org.javaboy.helloboot.bean.User">
    select * from ${tb_user}
</select>

4、动态 SQL 中使用了参数作为变量

如果在动态 SQL 中使用参数作为变量，那么也需要 @Param 注解，即使你只有一个参数。

例如：

@Mapper
public interface UserMapper {
    List<User> getUserById(@Param("id")Integer id);
}

对应xml：

<select id="getUserById" resultType="org.javaboy.helloboot.bean.User">
    select * from user
    <if test="id != null">
        where id=#{id}
    </if>
</select>

通用 mapper

官方网站：https://mybatis.io/

github源码：https://github.com/abel533/Mapper

gitee源码：https://gitee.com/free/Mapper/wikis/Home

简介、依赖及常用配置

通用 Mapper 是简化 mybatis 操作的一个框架，是为了解决单表增删改查，基于 Mybatis 的插件。开发人员不需要建立 xml 映射文件编写 SQL，不需要在 dao 接口中增加方法，只需要写好实体类，用注解跟数据库的表和字段建立映射关系，然后在dao接口继承BaseMapper<T> 并指定泛型，就能支持相应的增删改查方法。在service实现类中，直接调用相关方法，就可以执行简单的单表CRUD。

SpringBoot官方并没有提供通用Mapper的启动器，不过通用Mapper的作者为自己的插件编写了启动器

注意：一旦引入了通用Mapper的启动器，会覆盖Mybatis官方启动器的功能，因此需要移除对官方Mybatis启动器的依赖。

（把mybatis相关的配置文件删除、把引导类上mapperScan注解删除、把mybatis的启动器删除）

        <!-- 通用Mapper启动器（与SpringBoot集成版） -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

启动类上若有@MapperScan注解，则需修改为通用Mapper中自带的：

import tk.mybatis.spring.annotation.MapperScan;

修改mapper接口

public interface UserMapper extends BaseMapper<User> {
}

在实体类上添加注解@Table，主键上添加@Id

@Data
@Table(name = "tb_user")    // 指定要映射的数据库中的哪个表
public class User {
    /** id */
    @Id        //表示该成员变量是主键id
    private Long id;
    /** 用户名 */
    private String userName;
    /** 密码 */
    private String password;
}

常用API

根据主键id查询：selectByPrimaryKey(id);

添加数据：

insertSelective(brand)：添加数据，如果添加的数据中有为null的字段，则不进行更改。推荐，如果有特需，则用下面方式
insert(brand)：添加数据，不管要添加的数据是否为null，都进行更改，如果为null则将数据库中的该字段修改为null

根据id更新数据：

updateSelective(brand)：更新数据，如果添加的数据中有为null的字段，则不进行更改。推荐，如果有特需，则用下面方式
update(brand)：更新数据，不管要添加的数据是否为null，都进行更改，如果为null则将数据库中的该字段修改为null
注意：根据id更新数据，那么传入的 pojo 对象中的 id 字段一定要有值，否则它不知道修改哪条数据

根据id删除数据：deleteByPrimaryKey(id);

Mybatis 框架基本使用指南

Mybatis 基础

简介

SpringBoot 集成 Mybatis

Spring 集成 MyBatis

xml 映射文件

配置 mapper 接口扫描

Mybatis 实现 Dao 层

Mybatis 高级查询

查询结果封装

多条件查询

模糊查询

分页查询

动态传递参数方式：#{} 与 ${}

必须使用@param注解的四种情况

通用 mapper

简介、依赖及常用配置

常用API

热门文章

最新文章

相关课程

相关电子书