首页 > 软件编程 > java > 用Mybatis3 Dynamic SQL实现多表连接查询

如何用Mybatis3 Dynamic SQL实现多表连接查询？官方示例代码解析

2026-07-14 08:41:57 作者：yj_5979

本文详细介绍了SpringBoot整合Mybatis3 Dynamic SQL的方法,包括依赖引入、配置文件编写和代码生成,通过Lambda表达式简化了条件查询、子查询和连接查询的写法,并提供了批量新增、删除和更新的实战示例,帮助开发者高效上手动态SQL,提升数据库操作效率

SpringBoot整合Mybatis3 Dynamic Sql（IDEA）

Mybatis Dynamic Sql与以前TargetRuntime相比较：

移除了XXXExamle类和xml文件，代价是不兼容其他的TargetRuntime
java版本限制，生成器将需要运行Java 8，低版本可能会出现错误
代码逻辑相对以前，使用了 lambda表达式，是的较容易理解
移除了iBatis2代码生成的支持

引入依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.1.RELEASE</version>
    <relativePath/>
</parent>
<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <!--web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.38</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis.dynamic-sql</groupId>
        <artifactId>mybatis-dynamic-sql</artifactId>
        <version>1.1.4</version>
    </dependency>
    <!-- MyBatis 生成器 -->
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.4.0</version>
        <optional>true</optional>
    </dependency>
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>1.3.2</version>
    </dependency>
    <!--druid -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.6</version>
    </dependency>
</dependencies>
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

创建generatorConfig.xml配置文件

在resources/mybatis下创建generatorConfig.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--Mybatis Generator目前有5种运行模式，分别为：MyBatis3DynamicSql、MyBatis3Kotlin、MyBatis3、MyBatis3Simple、MyBatis3DynamicSqlV1。-->
    <context id="springboot-base" targetRuntime="MyBatis3DynamicSql">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <jdbcConnection
                        connectionURL="jdbc:mysql://127.0.0.1:3306/student?tinyInt1isBit=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true"
                        driverClass="com.mysql.jdbc.Driver"
                        userId="root"
                        password="91597489"/>
        <javaTypeResolver>
            <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer， 为 true时把JDBC DECIMAL
            和 NUMERIC 类型解析为java.math.BigDecimal -->
            <property name="forceBigDecimals" value="false" />
            <!--是否试用jdk8时间类-->
            <property name="useJSR310Types" value="true"/>
        </javaTypeResolver>
        <!-- targetProject:生成PO类的位置 -->
        <javaModelGenerator
                            targetPackage="com.my.entity"
                            targetProject="src/main/java">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置 -->
        <sqlMapGenerator targetPackage="mybatis.mapping"
                         targetProject="src/main/resources">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置 -->
        <javaClientGenerator
                             targetPackage="com.my.mapper"
                             targetProject="src/main/java" type="XMLMAPPER">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
        </javaClientGenerator>
        <!--生成全部表tableName设为%-->
        <table tableName="%"/>
        <!-- 指定数据库表 
  schema:数据库的schema,可以使用SQL通配符匹配。如果设置了该值，生成SQL的表名会变成如schema.tableName的形式。
  domainObjectName:生成对象的基本名称。如果没有指定，MBG会自动根据表名来生成名称。
  -->
        <!--<table schema="" tableName="" domainObjectName=""/>-->
    </context>
</generatorConfiguration>

在java下新建util包和MybatisGenerator.java文件

package com.my.util;

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.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class MybatisGenerator {
    public static void main(String[] args) throws IOException, XMLParserException, InvalidConfigurationException, SQLException, InterruptedException {
        //MBG 执行过程中的警告信息
        List<String> warnings = new ArrayList<>();
        //读取我们的 MBG 配置文件
        InputStream is = MybatisGenerator.class.getResourceAsStream("/mybatis/generatorConfig.xml");
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(is);
        is.close();
        //当生成的代码重复时，不要覆盖原代码
        DefaultShellCallback callback = new DefaultShellCallback(false);
        //创建 MBG
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
        //执行生成代码
        myBatisGenerator.generate(null);
        //输出警告信息
        for (String warning : warnings) {
            System.out.println(warning);
        }
    }
}

直接运行此程序，就会生成对应的entity，mapper文件，例如：

package com.my.entity;

import java.time.LocalDate;
import javax.annotation.Generated;

public class Student {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Integer id;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Integer studentId;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private String name;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private Integer age;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private String sex;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    private LocalDate birthday;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Integer getId() {
        return id;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setId(Integer id) {
        this.id = id;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Integer getStudentId() {
        return studentId;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setStudentId(Integer studentId) {
        this.studentId = studentId;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public String getName() {
        return name;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public Integer getAge() {
        return age;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setAge(Integer age) {
        this.age = age;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public String getSex() {
        return sex;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setSex(String sex) {
        this.sex = sex == null ? null : sex.trim();
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public LocalDate getBirthday() {
        return birthday;
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public void setBirthday(LocalDate birthday) {
        this.birthday = birthday;
    }
}

package com.my.mapper;

import static com.my.mapper.StudentDynamicSqlSupport.*;
import static org.mybatis.dynamic.sql.SqlBuilder.*;

import com.my.entity.Student;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import javax.annotation.Generated;
import org.apache.ibatis.annotations.DeleteProvider;
import org.apache.ibatis.annotations.InsertProvider;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.ResultMap;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.SelectProvider;
import org.apache.ibatis.annotations.UpdateProvider;
import org.apache.ibatis.type.JdbcType;
import org.mybatis.dynamic.sql.BasicColumn;
import org.mybatis.dynamic.sql.delete.DeleteDSLCompleter;
import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
import org.mybatis.dynamic.sql.select.CountDSLCompleter;
import org.mybatis.dynamic.sql.select.SelectDSLCompleter;
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.UpdateDSLCompleter;
import org.mybatis.dynamic.sql.update.UpdateModel;
import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;

@Mapper
public interface StudentMapper {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    BasicColumn[] selectList = BasicColumn.columnList(id, studentId, name, age, sex, birthday);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    long count(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @DeleteProvider(type=SqlProviderAdapter.class, method="delete")
    int delete(DeleteStatementProvider deleteStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @InsertProvider(type=SqlProviderAdapter.class, method="insert")
    int insert(InsertStatementProvider<Student> insertStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @InsertProvider(type=SqlProviderAdapter.class, method="insertMultiple")
    int insertMultiple(MultiRowInsertStatementProvider<Student> multipleInsertStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @ResultMap("StudentResult")
    Optional<Student> selectOne(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @SelectProvider(type=SqlProviderAdapter.class, method="select")
    @Results(id="StudentResult", value = {
        @Result(column="id", property="id", jdbcType=JdbcType.INTEGER, id=true),
        @Result(column="student_id", property="studentId", jdbcType=JdbcType.INTEGER),
        @Result(column="name", property="name", jdbcType=JdbcType.VARCHAR),
        @Result(column="age", property="age", jdbcType=JdbcType.INTEGER),
        @Result(column="sex", property="sex", jdbcType=JdbcType.VARCHAR),
        @Result(column="birthday", property="birthday", jdbcType=JdbcType.DATE)
    })
    List<Student> selectMany(SelectStatementProvider selectStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    @UpdateProvider(type=SqlProviderAdapter.class, method="update")
    int update(UpdateStatementProvider updateStatement);

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default long count(CountDSLCompleter completer) {
        return MyBatis3Utils.countFrom(this::count, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int delete(DeleteDSLCompleter completer) {
        return MyBatis3Utils.deleteFrom(this::delete, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int deleteByPrimaryKey(Integer id_) {
        return delete(c -> 
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insert(Student record) {
        return MyBatis3Utils.insert(this::insert, record, student, c ->
            c.map(id).toProperty("id")
            .map(studentId).toProperty("studentId")
            .map(name).toProperty("name")
            .map(age).toProperty("age")
            .map(sex).toProperty("sex")
            .map(birthday).toProperty("birthday")
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insertMultiple(Collection<Student> records) {
        return MyBatis3Utils.insertMultiple(this::insertMultiple, records, student, c ->
            c.map(id).toProperty("id")
            .map(studentId).toProperty("studentId")
            .map(name).toProperty("name")
            .map(age).toProperty("age")
            .map(sex).toProperty("sex")
            .map(birthday).toProperty("birthday")
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int insertSelective(Student record) {
        return MyBatis3Utils.insert(this::insert, record, student, c ->
            c.map(id).toPropertyWhenPresent("id", record::getId)
            .map(studentId).toPropertyWhenPresent("studentId", record::getStudentId)
            .map(name).toPropertyWhenPresent("name", record::getName)
            .map(age).toPropertyWhenPresent("age", record::getAge)
            .map(sex).toPropertyWhenPresent("sex", record::getSex)
            .map(birthday).toPropertyWhenPresent("birthday", record::getBirthday)
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<Student> selectOne(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectOne(this::selectOne, selectList, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<Student> select(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectList(this::selectMany, selectList, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default List<Student> selectDistinct(SelectDSLCompleter completer) {
        return MyBatis3Utils.selectDistinct(this::selectMany, selectList, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default Optional<Student> selectByPrimaryKey(Integer id_) {
        return selectOne(c ->
            c.where(id, isEqualTo(id_))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int update(UpdateDSLCompleter completer) {
        return MyBatis3Utils.update(this::update, student, completer);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateAllColumns(Student record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(id).equalTo(record::getId)
                .set(studentId).equalTo(record::getStudentId)
                .set(name).equalTo(record::getName)
                .set(age).equalTo(record::getAge)
                .set(sex).equalTo(record::getSex)
                .set(birthday).equalTo(record::getBirthday);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    static UpdateDSL<UpdateModel> updateSelectiveColumns(Student record, UpdateDSL<UpdateModel> dsl) {
        return dsl.set(id).equalToWhenPresent(record::getId)
                .set(studentId).equalToWhenPresent(record::getStudentId)
                .set(name).equalToWhenPresent(record::getName)
                .set(age).equalToWhenPresent(record::getAge)
                .set(sex).equalToWhenPresent(record::getSex)
                .set(birthday).equalToWhenPresent(record::getBirthday);
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKey(Student record) {
        return update(c ->
            c.set(studentId).equalTo(record::getStudentId)
            .set(name).equalTo(record::getName)
            .set(age).equalTo(record::getAge)
            .set(sex).equalTo(record::getSex)
            .set(birthday).equalTo(record::getBirthday)
            .where(id, isEqualTo(record::getId))
        );
    }

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    default int updateByPrimaryKeySelective(Student record) {
        return update(c ->
            c.set(studentId).equalToWhenPresent(record::getStudentId)
            .set(name).equalToWhenPresent(record::getName)
            .set(age).equalToWhenPresent(record::getAge)
            .set(sex).equalToWhenPresent(record::getSex)
            .set(birthday).equalToWhenPresent(record::getBirthday)
            .where(id, isEqualTo(record::getId))
        );
    }
}

package com.my.mapper;

import java.sql.JDBCType;
import java.time.LocalDate;
import javax.annotation.Generated;
import org.mybatis.dynamic.sql.SqlColumn;
import org.mybatis.dynamic.sql.SqlTable;

public final class StudentDynamicSqlSupport {
    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final Student student = new Student();

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Integer> id = student.id;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Integer> studentId = student.studentId;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<String> name = student.name;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<Integer> age = student.age;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<String> sex = student.sex;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final SqlColumn<LocalDate> birthday = student.birthday;

    @Generated("org.mybatis.generator.api.MyBatisGenerator")
    public static final class Student extends SqlTable {
        public final SqlColumn<Integer> id = column("id", JDBCType.INTEGER);

        public final SqlColumn<Integer> studentId = column("student_id", JDBCType.INTEGER);

        public final SqlColumn<String> name = column("name", JDBCType.VARCHAR);

        public final SqlColumn<Integer> age = column("age", JDBCType.INTEGER);

        public final SqlColumn<String> sex = column("sex", JDBCType.VARCHAR);

        public final SqlColumn<LocalDate> birthday = column("birthday", JDBCType.DATE);

        public Student() {
            super("student");
        }
    }
}

实践

需要在impl文件前面引入包，静态引入

import static org.mybatis.dynamic.sql.SqlBuilder.*;
import static com.my.mapper.StudentDynamicSqlSupport.*;

查询

查询指定列

public List<Student> list1() {
    SelectStatementProvider select = SqlBuilder.select(name, age, sex)
        .from(student)
        .build()
        .render(RenderingStrategies.MYBATIS3);
    return studentMapper.selectMany(select);
}

查询所有列

public List<Student> list2() {
    SelectStatementProvider select = SqlBuilder.select(StudentMapper.selectList)
        .from(student)
        .build()
        .render(RenderingStrategies.MYBATIS3);
    return studentMapper.selectMany(select);
}

条件查询

public List<Student> list3(Student stu) {
    SelectStatementProvider select = SqlBuilder.select(StudentMapper.selectList)
        .from(student)
        .where(name, isLike("%" + stu.getName() + "%"))
        .and(sex, isIn("男", "女"))
        //.and(sex, isEqualTo("男"))
        //.or(sex, isEqualTo("女"))
        .orderBy(age)
        .build()
        .render(RenderingStrategies.MYBATIS3);
    return studentMapper.selectMany(select);
}

排序：

升序：默认MySQL可以不加ASC即为升序排序，DynamicSql也是如此，指定列即可；
降序：调用descending()即可，以上方例子为例，原orderBy(age)改为orderBy(age.descending())即可。

where条件查询对照表

Condition	Example	Result
Between	where(foo, isBetween(x).and(y))	where foo between ? and ?
Equals	where(foo, isEqualTo(x))	where foo = ?
Greater Than	where(foo, isGreaterThan(x))	where foo > ?
Greater Than or Equals	where(foo, isGreaterThanOrEqualTo(x))	where foo >= ?
In	where(foo, isIn(x, y))	where foo in (?,?)
In (case insensitive)	where(foo, isInCaseInsensitive(x, y))	where upper(foo) in (?,?)（框架会将x和y的值转换为大写）
Less Than	where(foo, isLessThan(x))	where foo < ?
Less Than or Equals	where(foo, isLessThanOrEqualTo(x))	where foo <= ?
Like	where(foo, isLike(x))	where foo like ?（框架不会将SQL通配符添加到值中-您需要自己进行操作）
Like (case insensitive)	where(foo, isLikeCaseInsensitive(x))	where upper(foo) like ?（框架不会在值中添加SQL通配符-您需要自己执行，框架会将x的值转换为大写）
Not Between	where(foo, isNotBetween(x).and(y))	where foo not between ? and ?
Not Equals	where(foo, isNotEqualTo(x))	where foo <> ?
Not In	where(foo, isNotIn(x, y))	where foo not in (?,?)
Not In (case insensitive)	where(foo, isNotInCaseInsensitive(x, y))	where upper(foo) not in (?,?)（框架会将x和y的值转换为大写）
Not Like	where(foo, isLike(x))	where foo not like ?（框架不会将SQL通配符添加到值中-您需要自己进行操作）
Not Like (case insensitive)	where(foo, isNotLikeCaseInsensitive(x))	where upper(foo) not like ?（框架不会在值中添加SQL通配符-您需要自己执行，框架会将x的值转换为大写）
Not Null	where(foo, isNotNull())	where foo is not null
Null	where(foo, isNull())	where foo is null

子查询

public List<Student> list4(int agevo) {
    SelectStatementProvider select = SqlBuilder.select(StudentMapper.selectList)
        .from(student)
        .where(id, isIn(select(id)
                        .from(student)
                        .where(age, isGreaterThanOrEqualTo(agevo))))
        .build()
        .render(RenderingStrategies.MYBATIS3);
    return studentMapper.selectMany(select);
}

子查询对照表

Condition	Example	Result
Equals	where(foo, isEqualTo(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo = (select bar from table2 where bar = ?)
Greater Than	where(foo, isGreaterThan(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo > (select bar from table2 where bar = ?)
Greater Than or Equals	where(foo, isGreaterThanOrEqualTo(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo >= (select bar from table2 where bar = ?)
In	where(foo, isIn(select(bar).from(table2).where(bar, isLessThan(x)))	where foo in (select bar from table2 where bar < ?)
Less Than	where(foo, isLessThan(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo < (select bar from table2 where bar = ?)
Less Than or Equals	where(foo, isLessThanOrEqualTo(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo <= (select bar from table2 where bar = ?)
Not Equals	where(foo, isNotEqualTo(select(bar).from(table2).where(bar, isEqualTo(x)))	where foo <> (select bar from table2 where bar = ?)
Not In	where(foo, isNotIn(select(bar).from(table2).where(bar, isLessThan(x)))	where foo not in (select bar from table2 where bar < ?)

根据业务添加条件

public List<Student> list5(String name) {
    QueryExpressionDSL<org.mybatis.dynamic.sql.select.SelectModel>.QueryExpressionWhereBuilder builder = select(StudentMapper.selectList)
        .from(student)
        .where();
    if (name != null && !"".equals(name)) {
        builder.where(StudentDynamicSqlSupport.name, isLike("%" + name + "%"));
    } else {
        builder.where(age, isLessThan(25));
    }
    SelectStatementProvider select = builder.build().render(RenderingStrategies.MYBATIS3);
    return studentMapper.selectMany(select);
}

连接查询

有前面的基础，连接查询其实异曲同工，我这里直接贴上官方示例代码：

SelectStatementProvider selectStatement = select(orderMaster.orderId, orderDate, orderDetail.lineNumber, orderDetail.description, orderDetail.quantity)
    .from(orderMaster, "om")
    .join(orderDetail, "od").on(orderMaster.orderId, equalTo(orderDetail.orderId))
    .build()
    .render(RenderingStrategies.MYBATIS3);

目前支持四种连接类型：

.join(...) 内连接
.leftJoin(...) 左外连接
.rightJoin(...) 右外连接
.fullJoin(...) 全连接

添加

单个添加

stu = new Student();
stu.setStudentId(45);
stu.setName("杨间");
stu.setAge(20);
stu.setSex("男");
return studentMapper.insert(stu);

批量添加

要使用注释掉的这段代码需要引用一下包

import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
import org.mybatis.dynamic.sql.insert.*;

List<Student> stus = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    Student stu = new Student();
    stu.setStudentId(45);
    stu.setName("杨间");
    stu.setAge(20);
    stu.setSex("男");
    stus.add(stu);
}
return studentMapper.insertMultiple(stus);
/*MultiRowInsertStatementProvider<Student> render = insertMultiple(stus)
    .into(student)
    .map(id).toProperty("id")
    .map(studentId).toProperty("studentId")
    .map(name).toProperty("name")
    .map(age).toProperty("age")
    .map(sex).toProperty("sex")
    .map(birthday).toProperty("birthday")
    .build()
    .render(RenderingStrategies.MYBATIS3);
return studentMapper.insertMultiple(render);*/

批量新增这里需要注意的是map的添加，也可以不加，但我在使用过程中出现过不加map导致批量新增出现某些必填字段明明赋值了数据库却报没有不能为空，猜测应该是转换成sql语句时into与value没有一一对应，加上map就没问题了。

删除

主键删除

return studentMapper.deleteByPrimaryKey(stu.getId());

条件删除

DeleteStatementProvider del = deleteFrom(student)
    .where(name, isEqualTo("杨间"))
    .build()
    .render(RenderingStrategies.MYBATIS3);
return studentMapper.delete(del);

跟新

主键更新

对所有属性进行更新

stu.setId(6);
stu.setStudentId(99);
stu.setName("陆辛");
stu.setAge(20);
stu.setSex("男");
return studentMapper.updateByPrimaryKey(stu);

对不为null的属性进行更新

stu.setId(7);
stu.setName("顾楠");
stu.setSex("女");
return studentMapper.updateByPrimaryKeySelective(stu);

复杂的更新

UpdateStatementProvider updat = SqlBuilder.update(student)
    .set(name).equalTo("白小纯")
    .set(sex).equalTo("男")
    .where(id, isEqualTo(5))
    .build()
    .render(RenderingStrategies.MYBATIS3);
return studentMapper.update(updat);

注意set方法，常用的方法有以下：

set(column).equalToNull() 将对应列更新为null；
set(column).equalTo(T value)将对应列更新为value；
set(column).equalToWhenPresent(T value)如果value不能null的话更新列；
set(column).equalTo(BasicColumn rightColumn)将一列的值设置为另一列的值，还可以对其加，减等操作。

总结

以上为个人经验，希望能给大家一个参考，也希望大家多多支持脚本之家。

如何用Mybatis3 Dynamic SQL实现多表连接查询？官方示例代码解析

SpringBoot整合Mybatis3 Dynamic Sql（IDEA）

引入依赖

创建generatorConfig.xml配置文件

在java下新建util包和MybatisGenerator.java文件

实践

查询

添加

删除

跟新

总结

您可能感兴趣的文章: