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>

你可能感兴趣的:(SSM框架,mybatis,spring)