Mybatis 框架基本使用指南

骑猪看日落 2023-10-01 11:04 13阅读 0赞

# 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[官网][Link 1]自己实现了

<dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.3</version>
            </dependency>
    		
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>1.2.3</version>
            </dependency>       
    
    		
    		<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 ##

**依赖**

<dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${version.mybatis}</version>
            </dependency>
    		
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper</artifactId>
                <version>${version.mybatis.mapper}</version>
            </dependency>
    		
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper</artifactId>
                <version>${version.pagehelper}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${version.mybatis.spring}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
            </dependency>
    
            
            <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">
    
        
        <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>
    
         
        
        <bean id="sqlSessionfactory" class="org.mybatis.spring.SqlSessionFactoryBean">
            <property name="dataSource" ref="dataSource"></property>
            <property name="typeAliasesPackage" value="cn.test.domain"></property>
        </bean>
    
        
        <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
            
            <property name="basePackage" value="cn.test.dao"></property>
        </bean>
    
    
        
        
        <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <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>
        
        
        <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映射文件 ##

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]

<?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层 ##

**接口开发规范**

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

![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

**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 column="uid" property="id"></id>  						
        <result column="username" property="username"></result>  	
            
            
    
    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文件：

<select id="findByIdAndUsername3" parameterType="user" resultType="user">
        select * from user where id = #{id} and username = #{username}
    </select>
    
    
    <select id="findByIdAndUsername2" resultType="user">
        select * from user where id = #{id} and username = #{username}
    </select>
    
    
    <select id="findByIdAndUsername1" resultType="user">
        
        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文件：

<select id="findByUsername4" parameterType="string" resultType="user">
        select * from user where username like concat('%', #{username}, '%');
    </select>
    
    
    <select id="findByUsername4" parameterType="string" resultType="user">
    	select * from user where username like ('%' || #{username} || '%');
    </select>
    
    
    <select id="findByUsername1" parameterType="string" resultType="user">
        select * from user where username like #{username}
    </select>
    
    
    <select id="findByUsername1" parameterType="string" resultType="user">
        select * from user where username like '%#{username}%'
    </select>
    
    
    <select id="findByUsername3" parameterType="string" resultType="user">
        select * from user where username like '%${value}%'
    </select>

### 分页查询 ###

需要添加 PageHelper 的依赖

<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			
        </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>

# 报错处理 #

## 使用 foreach 批量操作，报错 ORA-00911: 无效字符的错误 ##

**连接数据库：Oracle**

**错误写法**

<delete id="deleteEntityAll" parameterType="java.lang.reflect.Array">
            <foreach collection="array" item="item" index="index"  separator=";">
                delete from GKCP_TC_JL  where JH = #{item.jh} and to_char(TCRQ,'YYYY-MM-DD') = #{item.tcrq}
            </foreach>
        </delete>

这样写生成的SQL语句用 ; 隔开，在sql工具中可以识别，但是mybatis不识别

**解决方案**：在foreach中增加节点操作符可以解决（Oracle的匿名块）

**正确写法**：

<delete id="deleteEntityAll" parameterType="java.lang.reflect.Array">
            <foreach collection="array" item="item" index="index" open="begin" close=";end;" separator=";">
                delete from GKCP_TC_JL  where JH = #{item.jh} and to_char(TCRQ,'YYYY-MM-DD') = #{item.tcrq}
            </foreach>
        </delete>

[Link 1]: https://github.com/mybatis/spring-boot-starter
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/d6add6e3c8904b09a08676b5fb5d5cb6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA==,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/e7200d9e60e747e4834c5b455d284610.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBA5aKo6bimX0Nvcm1vcmFudA==,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center