SSM框架学习之Mybatis
Mybatis学习
- 什么是 MyBatis？
- 基本环境搭建
-
- 创建Maven工程，并修改pom.xml
- 新建数据表
- 新建实体类并使用lombok
- 创建配置文件config.xml
- 1.使用原生接口开发
-
- 在Mapper.xml中写SQL语句，对每一个实体类创建对应的Mapper.xml，定义对应的SQL语句
- 在config.xml中注册AccountMapper.xml
- 调用MyBatis原生接口执行操作
- 2.Mapper代理实现自定义接口
-
- 自定义接口
- 创建接口对应的Mapper.xml，定义接口方法对应的SQL语句
- 在config.xml中注册AccountRepository.xml
- 调用接口的代理对象完成相关的业务
- 3. Mapper.xml
- 4. 级联查询
- 逆向工程
-
- 如何使用
- MyBatis延迟加载
- MyBatis缓存
- MyBatis 动态 SQL
什么是 MyBatis？
MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
基本环境搭建
创建Maven工程，并修改pom.xml
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.11version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.12version>
<scope>providedscope>
dependency>
dependencies>
新建数据表
use mybatis;
creat table t_account(
id int primary key auto_increment,
username varchar(11),
password varchar(11),
age int
)
新建实体类并使用lombok
import lombok.Data;
@Data
public class Account {
private long id;
private String username;
private String password;
private int age;
}
创建配置文件config.xml
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
dataSource>
environment>
environments>
configuration>
1.使用原生接口开发
在Mapper.xml中写SQL语句，对每一个实体类创建对应的Mapper.xml，定义对应的SQL语句
<mapper namespace="com.toolate.mapper.AccountMapper">
<insert id="save" parameterType="com.toolate.entity.Account">
insert into t_account(username,password,age) values(#{username},#{password},#{age})
insert>
mapper>
- namespace 通常设置为文件所在包+文件名
- insert 标签对应插入操作
- select 标签对应查询操作
- update 标签对应更新操作
- delete 标签对应删除操作
- id 是实际调用MyBatis方法时需要用到的参数
- parameterType是调用对应方法时参数的数据类型
在config.xml中注册AccountMapper.xml
<mappers>
<mapper resource="com/toolate/mapper/AccountMapper.xml">mapper>
mappers>
调用MyBatis原生接口执行操作
public class InsertTest {
public static void main(String[] args) {
InputStream inputStream = Insert.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
String statement = "com.toolate.mapper.AccountMapper.save";
Account account = new Account(1L, "张三", "123456", 20);
sqlSession.insert(statement,account);//将account作为参数传给sqlSession执行
sqlSession.commit();
}
}
- 在使用MyBatis时可以在config.xml中添加以下设置从而在控制台中输出执行的SQL语句
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
settings>
2.Mapper代理实现自定义接口
- 自定义接口，定义相关的业务方法
- 编写与方法相对应的Mapper.xml
自定义接口
public interface AccountRepository {
public int save(Account account);
public int update(Account account);
public int deleteById(long id);
public List<Account> findAll();
public Account findById(long id);
}
创建接口对应的Mapper.xml，定义接口方法对应的SQL语句
- statement标签可以根据SQL执行的业务选择insert、delete、update、select
- MyBatis框架会根据规则自动创建接口实现类的代理对象
- 规则如下：
- Mapper.xml中namespace为接口的全类名。
- Mapper.xml中statement的id为接口中对应的方法名。
- Mapper.xml中statement的parameterType和接口中对应方法的参数类型一致。
- Mapper.xml中statement的resultType和接口中对应方法的返回值类型一致。
- 创建对应的Mapper文件
<mapper namespace="com.toolate.repository.AccountRepository">
<insert id="save" parameterType="com.toolate.entity.Account">
insert into t_account(username,password,age) values(#{username},#{password},#{age})
insert>
<update id="update" parameterType="com.toolate.entity.Account">
update t_account set username = #{username},password = #{password},age = #{age}
update>
<delete id="deleteById" parameterType="long">
delete from t_account where id = #{id}
delete>
<select id="findAll" resultType="com.toolate.entity.Account">
select * from t_account
select>
<select id="findById" parameterType="long" resultType="com.toolate.entity.Account">
select * from t_account where id = #{id}
select>
mapper>
在config.xml中注册AccountRepository.xml
<mapper resource="com/toolate/repository/AccountRepository.xml">mapper>
调用接口的代理对象完成相关的业务
public class test02 {
public static void main(String[] args) {
//加载配置文件
InputStream inputStream = test02.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(inputStream);
SqlSession sqlSession = sessionFactory.openSession();
//获取实现方法的代理对象
AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
//查询全部对象
// List list = accountRepository.findAll();
// for (Account account : list) {
// System.out.println(account);
// }
//添加对象
// Account account = new Account(14L, "王五", "111111", 23);
// accountRepository.save(account);
// sqlSession.commit();
//通过id查询对象
// Account account = accountRepository.findById(13L);
// System.out.println(account);
//修改对象
// Account account = new Account(12, "小李", "654321", 25);
// int result = accountRepository.updateById(account);
// sqlSession.commit();
// System.out.println(result);
//通过id删除对象
// int result = accountRepository.deleteById(13L);
// System.out.println(result);
// sqlSession.commit();
sqlSession.close();
}
}
3. Mapper.xml
- statement 标签：select、update、delete、insert分别对应查询、修改、删除、添加操作。
- parameteType：参数数据类型
- 1、基本数据类型，通过id查询account
<select id="findById" parameterType="long" resultType="com.toolate.entity.Account">
select * from t_account where id = #{id}
select>
- 2、String类型，通过name查询account
<select id="findByName" parameterType="String" resultType="com.toolate.entity.Account">
select * from t_account where username = #{username}
select>
- 3、包装类，通过id查询account
<select id="findById" parameterType="java.long.Long" resultType="com.toolate.entity.Account">
select * from t_account where id = #{id}
select>
- 4、多个参数，通过name和age查询account
<select id="findByNameAndAge" resultType="com.toolate.entity.Account">
select * from t_account where username = #{param1} and age = #{param2}
select>
可以用param1、param2或arg0和arg1表示第一和第二个参数
- 5、Java Bean
<update id="update" parameterType="com.toolate.entity.Account">
update t_account set username = #{username},password = #{password},age = #{age}
update>
- resultType：结果类型
- 1、基本数据类型，统计Account总数
<select id="count" resultType="int">
select count(id) from t_account
select>
- 2、包装类，统计Account总数
<select id="count2" resultType="java.lang.Integer">
select count(id) from t_account
select>
- 3、String类型，通过id查询Account的name
<select id="findNameById" resultType="java.lang.String">
select username from t_account where id = #{id}
select>
- 4、Java Bean类型
<select id="findById" parameterType="long" resultType="com.toolate.entity.Account">
select * from t_account where id = #{id}
select>
4. 级联查询
- 一对多
Student
@Data
public class Student {
private long id;
private String name;
private Classes classes;
}
Classes
@Data
public class Classes {
private long id;
private String name;
private List<Student> students;
}
StudentRepository
public interface StudentRepository {
public Student findById(long id);
}
StudentRepository.xml
通过association来使两表级联查询关系相互映射
<resultMap id="studentMap" type="com.toolate.entity.Student">
<id column="id" property="id">id>
<result column="name" property="name">result>
<association property="classes" javaType="com.toolate.entity.Classes">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
association>
resultMap>
<select id="findById" parameterType="long" resultMap="studentMap">
SELECT s.id,s.name,c.id as cid,c.name as cname from student s,classes c where s.id = #{id} and s.cid = c.id;
select>
结果如下：
Student(id=1, name=张三, classes=Classes(id=2, name=6班, students=null))
ClassesRepository
public interface ClassesRepository {
public Classes findById(long id);
}
ClassesRepository.xml
<mapper namespace="com.toolate.repository.ClassesRepository">
<resultMap id="classesMap" type="com.toolate.entity.Classes">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
<collection property="students" ofType="com.toolate.entity.Student">
<id column="id" property="id">id>
<result column="name" property="name">result>
collection>
resultMap>
<select id="findById" parameterType="long" resultMap="classesMap">
SELECT s.id,s.name,c.id as cid,c.name as cname from student s,classes c where c.id = #{id} and s.cid = c.id;
select>
mapper>
- 多对多
Customer
import java.util.List;
@Data
public class Customer {
private long id;
private String name;
private List<Goods> goods;
}
Goods
import java.util.List;
@Data
public class Goods {
private long id;
private String name;
private List<Customer> customers;
}
CustomerRepository
package com.toolate.repository;
import com.toolate.entity.Customer;
public interface CustomerRepository {
public Customer findById(long id);
}
GoodsRepository
package com.toolate.repository;
import com.toolate.entity.Goods;
public interface GoodsRepository {
public Goods findById(long id);
}
CustomerRepository.xml
<mapper namespace="com.toolate.repository.CustomerRepository">
<resultMap id="customerMap" type="com.toolate.entity.Customer">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
<collection property="goods" ofType="com.toolate.entity.Goods">
<id column="gid" property="id">id>
<result column="gname" property="name">result>
collection>
resultMap>
<select id="findById" parameterType="long" resultMap="customerMap">
SELECT c.id cid,c.name cname,g.id gid,g.name gname from customer c, goods g,customer_goods cg where c.id = #{id} and cg.cid = c.id and cg.gid = g.id;
select>
mapper>
GoodsRepository.xml
<mapper namespace="com.toolate.repository.GoodsRepository">
<resultMap id="goodsMap" type="com.toolate.entity.Goods">
<id column="gid" property="id">id>
<result column="gname" property="name">result>
<collection property="customers" ofType="com.toolate.entity.Customer">
<id column="cid" property="id">id>
<result column="cname" property="name">result>
collection>
resultMap>
<select id="findById" parameterType="long" resultMap="goodsMap">
SELECT c.id cid,c.name cname,g.id gid,g.name gname from customer c, goods g,customer_goods cg where g.id = #{id} and cg.cid = c.id and cg.gid = g.id;
select>
mapper>
逆向工程
MyBatis 框架需要：实体类、⾃定义 Mapper 接⼝、Mapper.xml
传统的开发中上述的三个组件需要开发者⼿动创建，逆向⼯程可以帮助开发者来⾃动创建三个组件，减
轻开发者的⼯作量，提⾼⼯作效率。
如何使用
MyBatis Generator，简称 MBG，是⼀个专⻔为 MyBatis 框架开发者定制的代码⽣成器，可⾃动⽣成
MyBatis 框架所需的实体类、Mapper 接⼝、Mapper.xml，⽀持基本的 CRUD 操作，但是⼀些相对复
杂的 SQL 需要开发者⾃⼰来完成。
- 新建Maven工程，修改pom.xml
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.11version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.10version>
<scope>providedscope>
dependency>
<dependency>
<groupId>org.mybatis.generatorgroupId>
<artifactId>mybatis-generator-coreartifactId>
<version>1.3.7version>
dependency>
dependencies>
- 创建 MBG 配置⽂件 generatorConfig.xml
1、jdbcConnection 配置数据库连接信息。
2、javaModelGenerator 配置 JavaBean 的⽣成策略。
3、sqlMapGenerator 配置 SQL 映射⽂件⽣成策略。
4、javaClientGenerator 配置 Mapper 接⼝的⽣成策略。
5、table 配置⽬标数据表（tableName：表名，domainObjectName：JavaBean 类名）。
<generatorConfiguration>
<context id="testTables" targetRuntime="MyBatis3">
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=UTF-8" userId="root" password="123456">jdbcConnection>
<javaModelGenerator targetPackage="com.toolate.entity" targetProject="./src/main/java">javaModelGenerator>
<sqlMapGenerator targetPackage="com.toolate.repository" targetProject="./src/main/java">sqlMapGenerator>
<javaClientGenerator type="XMLMAPPER" targetPackage="com.toolate.repository" targetProject="./src/main/java">javaClientGenerator>
<table tableName="t_user" domainObjectName="User">table>
context>
generatorConfiguration>
- 创建Generator 执⾏类。
package com.toolate.test;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> warings = new ArrayList<String>();
boolean overwrite = true;
String genCig = "/generatorConfig.xml";
File configFile = new File(Main.class.getResource(genCig).getFile());
ConfigurationParser configurationParser = new
ConfigurationParser(warings);
Configuration configuration = null;
try {
configuration = configurationParser.parseConfiguration(configFile);
} catch (IOException e) {
e.printStackTrace();
} catch (XMLParserException e) {
e.printStackTrace();
}
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = null;
try {
myBatisGenerator = new
MyBatisGenerator(configuration,callback,warings);
} catch (InvalidConfigurationException e) {
e.printStackTrace();
}
try {
myBatisGenerator.generate(null);
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
- 执行Main
MyBatis延迟加载
- 什么是延迟加载？
延迟加载也叫懒加载、惰性加载，使⽤延迟加载可以提⾼程序的运⾏效率，针对于数据持久层的操作，
在某些特定的情况下去访问特定的数据库，在其他情况下可以不访问某些表，从⼀定程度上减少了 Java
应⽤与数据库的交互次数。
查询学⽣和班级的时，学⽣和班级是两张不同的表，如果当前需求只需要获取学⽣的信息，那么查询学
⽣单表即可，如果需要通过学⽣获取对应的班级信息，则必须查询两张表。
不同的业务需求，需要查询不同的表，根据具体的业务需求来动态减少数据表查询的⼯作就是延迟加
载。
- 在 config.xml 中开启延迟加载
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
<setting name="lazyLoadingEnabled" value="true"/>
settings>
- 将多表关联查询拆分成多个单表查询
StudentRepository
public Student findByIdLazy(long id);
StudentRepository.xml
<resultMap id="studentMapLazy" type="com.toolate.entity.Student">
<id column="id" property="id"></id>
<result column="name" property="name"></result>
<association property="classes" javaType="com.toolate.entity.Classes"
select="com.toolate.repository.ClassesRepository.findByIdLazy" column="cid">
</association>
</resultMap>
<select id="findByIdLazy" parameterType="long" resultMap="studentMapLazy">
select * from student where id = #{id}
</select>
ClassesRepository
public Classes findByIdLazy(long id);
ClassesRepository.xml
<select id="findByIdLazy" parameterType="long" resultType="com.toolate.entity.Classes">
SELECT * from classes where id = #{id}
select>
MyBatis缓存
- 什么是MyBatis缓存
使⽤缓存可以减少 Java 应⽤与数据库的交互次数，从⽽提升程序的运⾏效率。⽐如查询出 id = 1 的对
象，第⼀次查询出之后会⾃动将该对象保存到缓存中，当下⼀次查询时，直接从缓存中取出对象即可，
⽆需再次访问数据库。 - MyBatis 缓存分类
1、⼀级缓存：SqlSession 级别，默认开启，并且不能关闭。
操作数据库时需要创建 SqlSession 对象，在对象中有⼀个 HashMap ⽤于存储缓存数据，不同的
SqlSession 之间缓存数据区域是互不影响的。
⼀级缓存的作⽤域是 SqlSession 范围的，当在同⼀个 SqlSession 中执⾏两次相同的 SQL 语句事，第⼀
次执⾏完毕会将结果保存到缓存中，第⼆次查询时直接从缓存中获取。
需要注意的是，如果 SqlSession 执⾏了 DML 操作（insert、update、delete），MyBatis 必须将缓存
清空以保证数据的准确性。
2、⼆级缓存：Mapper 级别，默认关闭，可以开启。
使⽤⼆级缓存时，多个 SqlSession 使⽤同⼀个 Mapper 的 SQL 语句操作数据库，得到的数据会存在⼆
级缓存区，同样是使⽤ HashMap 进⾏数据存储，相⽐较于⼀级缓存，⼆级缓存的范围更⼤，多个
SqlSession 可以共⽤⼆级缓存，⼆级缓存是跨 SqlSession 的。
⼆级缓存是多个 SqlSession 共享的，其作⽤域是 Mapper 的同⼀个 namespace，不同的 SqlSession
两次执⾏相同的 namespace 下的 SQL 语句，参数也相等，则第⼀次执⾏成功之后会将数据保存到⼆级
缓存中，第⼆次可直接从⼆级缓存中取出数据。
代码
- 一级缓存
public class Test04 {
public static void main(String[] args) {
InputStream inputeStream = Test04.class.getClassLoader().getResourceAsStream("config.xml");
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputeStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
AccountRepository accountRepository = sqlSession.getMapper(AccountRepository.class);
Account account = accountRepository.findById(14L);
System.out.println(account);
sqlSession.close();
sqlSession =sqlSessionFactory.openSession();
AccountRepository accountRepository1 = sqlSession.getMapper(AccountRepository.class);
Account account1 = accountRepository1.findById(14L);
System.out.println(account1);
}
}
- 二级缓存
1、MyBatis ⾃带的⼆级缓存 - config.xml 配置开启⼆级缓存
<setting name="cacheEnabled" value="true"/>
- Mapper.xml中配置二级缓存
<cache>cache>
- 实体类实现序列化接⼝
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account implements Serializable {
private long id;
private String username;
private String password;
private int age;
}
2、ehcache ⼆级缓存
- pom.xml 添加相关依赖
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-ehcacheartifactId>
<version>1.0.0version>
dependency>
<dependency>
<groupId>net.sf.ehcachegroupId>
<artifactId>ehcache-coreartifactId>
<version>2.4.3version>
dependency>
- 添加 ehcache.xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<diskStore/>
<defaultCache
maxElementsInMemory="1000"
maxElementsOnDisk="10000000"
eternal="false"
overflowToDisk="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU">
defaultCache>
ehcache>
- config.xml 配置开启⼆级缓存
<setting name="cacheEnabled" value="true"/>
- Mapper.xml 中配置⼆级缓存
<cache type="org.mybatis.caches.ehcache.EhcacheCache">
<property name="timeToIdleSeconds" value="3600"/>
<property name="timeToLiveSeconds" value="3600"/>
<property name="memoryStoreEvictionPolicy" value="LRU"/>
cache>
- 实体类不需要实现序列化接⼝。
package com.toolate.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
private long id;
private String username;
private String password;
private int age;
}
MyBatis 动态 SQL
使⽤动态 SQL 可简化代码的开发，减少开发者的⼯作量，程序可以⾃动根据业务参数来决定 SQL 的组
成。
- if 标签
<select id="findByAccount" parameterType="com.southwind.entity.Account"
resultType="com.southwind.entity.Account">
select * from t_account where
<if test="id!=0">
id = #{id}
if>
<if test="username!=null">
and username = #{username}
if>
<if test="password!=null">
and password = #{password}
if>
<if test="age!=0">
and age = #{age}
if>
select>
- where标签
<select id="findByAccount" parameterType="com.toolate.entity.Account" resultType="com.toolate.entity.Account">
select * from t_account
<where>
<if test="id!=0">
id = #{id}
if>
<if test="username!=null">
and username = #{username}
if>
<if test="password!=null">
and password = #{password}
if>
<if test="age!=0">
and age = #{age}
if>
where>
select>
where 标签可以⾃动判断是否要删除语句块中的 and 关键字，如果检测到 where 直接跟 and 拼接，则
⾃动删除 and，通常情况下 if 和 where 结合起来使⽤。
- choose 、when 标签
<select id="findByAccount" parameterType="com.toolate.entity.Account" resultType="com.toolate.entity.Account">
select * from t_account
<where>
<choose>
<when test="id!=0">
id = #{id}
when>
<when test="username!=null">
username = #{username}
when>
<when test="password!=null">
password = #{password}
when>
<when test="age!=0">
age = #{age}
when>
choose>
where>
select>
- trim标签
trim 标签中的 prefix 和 suffix 属性会被⽤于⽣成实际的 SQL 语句，会和标签内部的语句进⾏拼接，如
果语句前后出现了 prefixOverrides 或者 suffixOverrides 属性中指定的值，MyBatis 框架会⾃动将其删
除。
<select id="findByAccount" parameterType="com.toolate.entity.Account" resultType="com.toolate.entity.Account">
select * from t_account
<trim prefix="where" prefixOverrides="and">
<if test="id!=0">
id = #{id}
if>
<if test="username!=null">
and username = #{username}
if>
<if test="password!=null">
and password = #{password}
if>
<if test="age!=0">
and age = #{age}
if>
trim>
select>
- set 标签
<update id="update" parameterType="com.toolate.entity.Account">
update t_account
<set>
<if test="username!=null">
username = #{username},
if>
<if test="password!=null">
password = #{password},
if>
<if test="age!=0">
age = #{age}
if>
set>
where id = #{id}
update>
- foreach标签
foreach 标签可以迭代⽣成⼀系列值，这个标签主要⽤于 SQL 的 in 语句。
<select id="findByIds" parameterType="com.toolate.entity.Account" resultType="com.toolate.entity.Account">
select * from t_account
<where>
<foreach collection="ids" open="id in (" close=")" item="id" separator=",">
#{id}
foreach>
where>
select>