MyBatis-Flex

https://mybatis-flex.com/zh/
Admin
MyBatis-Flex is a lightweight MyBatis enhancement framework that provides high performance and...
Tokens:98,316
Snippets:1,078
Trust Score:6.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Basic Code Generation Setup

Source: https://mybatis-flex.com/zh/others/codegen.html

This example demonstrates the basic setup for the code generator, including data source configuration and creating a generator instance.

```java
public class Codegen {

    public static void main(String[] args) {
        //配置数据源
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/your-database?characterEncoding=utf-8");
        dataSource.setUsername("root");
        dataSource.setPassword("******");

        //创建配置内容，两种风格都可以。
        GlobalConfig globalConfig = createGlobalConfigUseStyle1();
        //GlobalConfig globalConfig = createGlobalConfigUseStyle2();

        //通过 datasource 和 globalConfig 创建代码生成器
        Generator generator = new Generator(dataSource, globalConfig);

        //生成代码
        generator.generate();
    }

    public static GlobalConfig createGlobalConfigUseStyle1() {
        //创建配置内容
        GlobalConfig globalConfig = new GlobalConfig();

        //设置根包
        globalConfig.setBasePackage("com.test");

        //设置表前缀和只生成哪些表
        globalConfig.setTablePrefix("tb_");
        globalConfig.setGenerateTable("tb_account", "tb_account_session");

        //设置生成 entity 并启用 Lombok
        globalConfig.setEntityGenerateEnable(true);
        globalConfig.setEntityWithLombok(true);
        //设置项目的JDK版本，项目的JDK为14及以上时建议设置该项，小于14则可以不设置
        globalConfig.setEntityJdkVersion(17);

        //设置生成 mapper
        globalConfig.setMapperGenerateEnable(true);

        //可以单独配置某个列
        ColumnConfig columnConfig = new ColumnConfig();
        columnConfig.setColumnName("tenant_id");
        columnConfig.setLarge(true);
        columnConfig.setVersion(true);
        globalConfig.setColumnConfig("tb_account", columnConfig);

        return globalConfig;
    }

    public static GlobalConfig createGlobalConfigUseStyle2() {
        //创建配置内容
        GlobalConfig globalConfig = new GlobalConfig();

        //设置根包
        globalConfig.getPackageConfig()
                .setBasePackage("com.test");

        //设置表前缀和只生成哪些表，setGenerateTable 未配置时，生成所有表
        globalConfig.getStrategyConfig()
                .setTablePrefix("tb_")
                .setGenerateTable("tb_account", "tb_account_session");

        //设置生成 entity 并启用 Lombok
        globalConfig.enableEntity()
                .setWithLombok(true)
                .setJdkVersion(17);

        //设置生成 mapper
        globalConfig.enableMapper();

        //可以单独配置某个列
        ColumnConfig columnConfig = new ColumnConfig();
        columnConfig.setColumnName("tenant_id");
        columnConfig.setLarge(true);
        columnConfig.setVersion(true);
        globalConfig.getStrategyConfig()
                .setColumnConfig("tb_account", columnConfig);

        return globalConfig;
    }
}
```

--------------------------------

### Quickly Configure and Start MybatisFlexBootstrap

Source: https://mybatis-flex.com/zh/intro/use-in-kotlin.html

Use DSL and overloaded operators to quickly configure and start a MybatisFlexBootstrap instance. This method is not required in a SpringBoot environment; refer to mybatis-flex-spring-boot for configuration.

```kotlin
runFlex {
    // Configure data source, equivalent to setDataSource(dataSource)
    +dataSource
    // Configure Mapper, equivalent to addMapper(AccountMapper::class.java)
    +AccountMapper::class
    // Configure log output, equivalent to setLogImpl(StdOutImpl::class.java)
    logImpl = StdOutImpl::class
}
```

--------------------------------

### Example Query Result Output

Source: https://mybatis-flex.com/zh/base/relations-query.html

Example of the final mapped `UserVO` objects after the join query execution.

```txt
UserVO{userId='1', userName='admin', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}]}
UserVO{userId='2', userName='ry', roleList=[Role{roleId=2, roleKey='common', roleName='普通角色'}]}
UserVO{userId='3', userName='test', roleList=[Role{roleId=1, roleKey='admin', roleName='超级管理员'}, Role{roleId=2, roleKey='common', roleName='普通角色'}]}
```

--------------------------------

### Complete Cacheable Methods Example

Source: https://mybatis-flex.com/zh/core/data-cache.html

Comprehensive example of AccountServiceImpl demonstrating various cacheable and cache-evicting methods.

```java
@Service
@CacheConfig(cacheNames = "account")
public class AccountServiceImpl extends CacheableServiceImpl<MyAccountMapper, Account> {

    @Override
    @CacheEvict(allEntries = true)
    public boolean remove(QueryWrapper query) {
        return super.remove(query);
    }

    @Override
    @CacheEvict(key = "#id")
    public boolean removeById(Serializable id) {
        return super.removeById(id);
    }

    @Override
    @CacheEvict(allEntries = true)
    public boolean removeByIds(Collection<? extends Serializable> ids) {
        return super.removeByIds(ids);
    }

    // 根据查询条件更新时，实体类主键可能为 null。
    @Override
    @CacheEvict(allEntries = true)
    public boolean update(Account entity, QueryWrapper query) {
        return super.update(entity, query);
    }

    @Override
    @CacheEvict(key = "#entity.id")
    public boolean updateById(Account entity, boolean ignoreNulls) {
        return super.updateById(entity, ignoreNulls);
    }

    @Override
    @CacheEvict(allEntries = true)
    public boolean updateBatch(Collection<Account> entities, int batchSize) {
        return super.updateBatch(entities, batchSize);
    }

    @Override
    @Cacheable(key = "#id")
    public Account getById(Serializable id) {
        return super.getById(id);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public Account getOne(QueryWrapper query) {
        return super.getOne(query);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public <R> R getOneAs(QueryWrapper query, Class<R> asType) {
        return super.getOneAs(query, asType);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public List<Account> list(QueryWrapper query) {
        return super.list(query);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public <R> List<R> listAs(QueryWrapper query, Class<R> asType) {
        return super.listAs(query, asType);
    }

    // 无法通过注解进行缓存操作
    @Override
    @Deprecated
    public List<Account> listByIds(Collection<? extends Serializable> ids) {
        return super.listByIds(ids);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public long count(QueryWrapper query) {
        return super.count(query);
    }

    @Override
    @Cacheable(key = "#root.methodName + ':' + #page.getPageSize() + ':' + #page.getPageNumber() + ':' + #query.toSQL()")
    public <R> Page<R> pageAs(Page<R> page, QueryWrapper query, Class<R> asType) {
        return super.pageAs(page, query, asType);
    }

}
```

--------------------------------

### Example Configuration for Package Expressions

Source: https://mybatis-flex.com/zh/others/apt.html

Demonstrates the usage of package expressions like `${entityPackage}`, `${entityPackage.parent}`, and `${entityPackage.parent.parent}` for configuring APT generation paths.

```properties
processor.allInTables.package=${entityPackage}.table
processor.mapper.package=${entityPackage.parent}.mapper
processor.tableDef.package=${entityPackage.parent.parent}.table
```

--------------------------------

### Query Top-Level Menus

Source: https://mybatis-flex.com/zh/base/relations-query.html

Example of querying top-level menus using QueryWrapper and relation mapping.

```java
QueryWrapper qw = QueryWrapper.create();
qw.where(MENU.PARENT_ID.eq(0));

List<Menu> menus = menuMapper.selectListWithRelationsByQuery(qw);
System.out.println(JSON.toJSONString(menus));
```

--------------------------------

### Configure Package Directory and Base Package

Source: https://mybatis-flex.com/zh/others/codegen.html

Example of configuring the source directory and base package for generated code using the `getPackageConfig()` method.

```java
globalConfig.getPackageConfig()
        .setSourceDir("D://files/java")
        .setBasePackage("com.your.domain");
```

--------------------------------

### Add MyBatis-Flex Spring Boot Starter (Kotlin)

Source: https://mybatis-flex.com/zh/intro/gradle.html

Use this starter dependency for seamless integration with Spring Boot applications. It simplifies configuration and setup.

```kotlin
dependencies {
    implementation("com.mybatis-flex:mybatis-flex-spring-boot-starter:1.11.8")
}
```

--------------------------------

### MyBatis-Flex Startup Banner

Source: https://mybatis-flex.com/zh/faq.html

This is the expected Banner information printed to the console when MyBatis-Flex starts successfully. If this is not visible, it indicates that MyBatis-Flex was not loaded correctly.

```txt
  __  __       _           _   _       _____ _
 |  \/  |_   _| |__   __ _| |_(_)___  |  ___| | _____  __
 | |\/| | | | | '_ \ / _` | __| / __| | |_  | |/ _ \ \/ /
 | |  | | |_| | |_) | (_| | |_| \__ \ |  _| | |  __/>  <
 |_|  |_|\__, |_.__/ \__,_|\__|_|___/ |_|   |_|\___/_/\_\
         |___/ v1.5.4 https://mybatis-flex.com
```

--------------------------------

### Console Output of Account Query

Source: https://mybatis-flex.com/zh/intro/getting-started.html

Example console output after executing the query for an account with age 18.

```text
Account(id=1, userName=张三, age=18, birthday=Sat Jan 11 00:00:00 CST 2020)
```

--------------------------------

### MyBatis-Flex Spring Boot v3.x Starter Dependency

Source: https://mybatis-flex.com/zh/intro/maven.html

This dependency setup is for projects using Spring Boot version 3.x.

```xml
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-spring-boot3-starter</artifactId>
    <version>1.11.8</version>
</dependency>
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-processor</artifactId>
    <version>1.11.8</version>
    <scope>provided</scope>
</dependency>
```

--------------------------------

### MyBatis-Flex Compatible API Example

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates using QueryWrapper with MyBatis-Plus compatible APIs. This is useful for users migrating from MyBatis-Plus to MyBatis-Flex.

```java
QueryWrapper queryWrapper = new QueryWrapper();
queryWrapper.from("tb_account")
    .eq("column1", "value1")
    .ge(Account::getAge, 18)
    .or(wrapper -> {
        wrapper.eq("column2", "value2")
            .ge(Account::getSex, 0);
    });

System.out.println(queryWrapper.toSQL());
```

```sql
SELECT * FROM `tb_account`
WHERE column1 = 'value1' AND `age` >= 18
OR (column2 = 'value2' AND `sex` >= 0)
```

--------------------------------

### Add MyBatis-Flex Spring Boot Starter (Groovy)

Source: https://mybatis-flex.com/zh/intro/gradle.html

Use this starter dependency for seamless integration with Spring Boot applications. It simplifies configuration and setup.

```groovy
dependencies {
    implementation 'com.mybatis-flex:mybatis-flex-spring-boot-starter:1.11.8'
}
```

--------------------------------

### Create Database Table and Insert Data

Source: https://mybatis-flex.com/zh/intro/getting-started.html

Defines the 'tb_account' table and inserts initial records. This SQL script is used to set up the database for the Hello World example.

```sql
CREATE TABLE IF NOT EXISTS `tb_account`
(
    `id`        INTEGER PRIMARY KEY auto_increment,
    `user_name` VARCHAR(100),
    `age`       INTEGER,
    `birthday`  DATETIME
);

INSERT INTO tb_account(id, user_name, age, birthday)
VALUES (1, '张三', 18, '2020-01-11'),
       (2, '李四', 19, '2021-03-21');
```

--------------------------------

### MyBatis-Flex Admin Configuration Example

Source: https://mybatis-flex.com/zh/base/configuration.html

Enables and configures MyBatis-Flex-Admin for SQL auditing. Ensure the secret-key matches the one configured in the MyBatis-Flex-Admin project.

```yaml
mybatis-flex:
  admin-config:
    enable: true
    endpoint: http://admin-host:8080/message/collect
    secret-key: secretKey
```

--------------------------------

### Query Wrapper Example

Source: https://mybatis-flex.com/zh/intro/getting-started.html

Construct a query to select records where the age is 18 using QueryWrapper and the generated ACCOUNT table definition.

```java
QueryWrapper queryWrapper = QueryWrapper.create()
        .select()
        .where(ACCOUNT.AGE.eq(18));
```

--------------------------------

### Basic Account Entity Mapping

Source: https://mybatis-flex.com/zh/base/auto-mapping.html

An example of an Account entity class with basic field-to-column mapping for the 'tb_account' table.

```java
@Table(value = "tb_account")
public class Account {

    @Id(keyType = KeyType.Auto)
    private Long id;
    private String userName;
    private int age;

    //getter setter
}
```

--------------------------------

### Simplified Dependency Declaration with Dependency Management

Source: https://mybatis-flex.com/zh/intro/maven.html

Example showing how to declare MyBatis-Flex dependencies without specifying the version when `mybatis-flex-dependencies` is imported in `<dependencyManagement>`.

```xml
<dependencies>
    <dependency>
        <groupId>com.mybatis-flex</groupId>
        <artifactId>mybatis-flex-spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>com.mybatis-flex</groupId>
        <artifactId>mybatis-flex-codegen</artifactId>
    </dependency>
</dependencies>
```

--------------------------------

### Basic MyBatis-Flex Configuration

Source: https://mybatis-flex.com/zh/base/configuration.html

Example of basic MyBatis-Flex configuration in application.yml for Spring Boot or app.yml for Solon. This snippet shows the top-level structure for various configuration sections.

```yaml
mybatis-flex:
  #......
  datasource:
    #......
  configuration:
    #......
  global-config:
    #......
  admin-config:
    #......
  seata-config:
    #......
```

--------------------------------

### Implement Custom Template Engine

Source: https://mybatis-flex.com/zh/others/codegen.html

Example of implementing a custom template engine using EnjoyTemplate. This class handles file generation by rendering templates with provided parameters.

```java
public class EnjoyTemplate implements ITemplate {

    private Engine engine;

    public EnjoyTemplate() {
        Engine engine = Engine.use(engineName);
        if (engine == null) {
            engine = Engine.create(engineName, e -> {
                e.addSharedStaticMethod(StringUtil.class);
                e.setSourceFactory(new FileAndClassPathSourceFactory());
            });
        }
        this.engine = engine;

        // 以下配置将支持 user.girl 表达式去调用 user 对象的 boolean isGirl() 方法
        Engine.addFieldGetterToFirst(new FieldGetters.IsMethodFieldGetter());
    }

    @Override
    public void generate(Map<String, Object> params, String templateFilePath, File generateFile) {
        if (!generateFile.getParentFile().exists() && !generateFile.getParentFile().mkdirs()) {
            throw new IllegalStateException("Can not mkdirs by dir: " + generateFile.getParentFile());
        }
        // 开始生成文件
        try (FileOutputStream fileOutputStream = new FileOutputStream(generateFile)) {
            engine.getTemplate(templateFilePath).render(params, fileOutputStream);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
```

--------------------------------

### Maven Dependency for seata-spring-boot-starter

Source: https://mybatis-flex.com/zh/core/tx.html

Example Maven dependency for integrating seata-spring-boot-starter into a Spring Boot project.

```xml
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.7.0</version>
</dependency>
```

--------------------------------

### Result Output for One-to-One Relation

Source: https://mybatis-flex.com/zh/base/relations-query.html

Example output demonstrating how the Account and IDCard data is structured after a successful associated query using the Relations annotation.

```txt
 [
 Account{id=1, userName='孙悟空', age=18, idCard=IDCard{accountId=1, cardNo='0001', content='内容1'}},
 Account{id=2, userName='猪八戒', age=19, idCard=IDCard{accountId=2, cardNo='0002', content='内容2'}},
 Account{id=3, userName='沙和尚', age=19, idCard=IDCard{accountId=3, cardNo='0003', content='内容3'}},
 Account{id=4, userName='六耳猕猴', age=19, idCard=IDCard{accountId=4, cardNo='0004', content='内容4'}},
 Account{id=5, userName='王麻子叔叔', age=19, idCard=IDCard{accountId=5, cardNo='0005', content='内容5'}}
 ]
```

--------------------------------

### Configure ServiceImpl Generation

Source: https://mybatis-flex.com/zh/others/codegen.html

Configure the class prefix, suffix, superclass, and overwrite behavior for generated ServiceImpl classes. Caching examples can also be enabled or disabled.

```java
globalConfig.getServiceImplConfig()
        .setClassPrefix("My")
        .setClassSuffix("ServiceImpl")
        .setSuperClass(ServiceImpl.class);
```

--------------------------------

### User Entity Example with TypeHandler

Source: https://mybatis-flex.com/zh/base/query.html

When using select...As to map query results to a different DTO or VO, ensure that any custom type handlers configured on the entity's properties are also configured on the corresponding properties of the target DTO/VO.

```java
public class User {

    @Column(typeHandler=xxxHandler.class)
    private String attr1;

    //getter setter
}
```

--------------------------------

### Inserting Article with Tenant ID

Source: https://mybatis-flex.com/zh/core/multi-tenancy.html

Example of inserting an Article. The tenantId set manually will be overridden by the TenantFactory's return value if it provides one. If the TenantFactory returns null or an empty array, the manually set tenantId is retained.

```java
Article article = new Article();
article.setTenantId(100);

articleMapper.insert(article);
```

--------------------------------

### Seata Global Transactional Annotation

Source: https://mybatis-flex.com/zh/core/tx.html

Example of starting a Seata distributed transaction using the @GlobalTransactional annotation.

```java
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import com.seata.core.context.RootContext;
import com.seata.spring.annotation.GlobalTransactional;

public class PurchaseService {

    private static final Log LOGGER = LogFactory.getLog(PurchaseService.class);

    private StockClient stockClient;
    private OrderClient orderClient;

    @GlobalTransactional
    public void purchase(String userId, String commodityCode, int orderCount) {
        LOGGER.info("purchase begin ... xid: " + RootContext.getXID());
        stockClient.deduct(commodityCode, orderCount);
        orderClient.create(userId, commodityCode, orderCount);
    }
}
```

--------------------------------

### Query with Custom String Column Names

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates how to use custom string column names for querying. This example filters accounts where the column 'a1' is greater than or equal to 100 and not equal to 200.

```java
// 静态导入 QueryMethods.column 方法
QueryColumn a1 = column("a1");

QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .where(a1.ge(100))
    .and(a1.ne(200))
```

```sql
SELECT * FROM tb_account
WHERE a1 >=  100
AND a1 != 200
```

--------------------------------

### Advanced Partial Field Update with UpdateWrapper (Field Arithmetic)

Source: https://mybatis-flex.com/zh/base/add-delete-update.html

This example demonstrates updating a field using arithmetic operations directly within the `UpdateWrapper`. The `set` method with field references allows for expressions like `ACCOUNT.AGE.add(1)`.

```java
Account account = UpdateEntity.of(Account.class, 100);

account.setUserName("Michael");

// 通过 UpdateWrapper 操作 account 数据
UpdateWrapper wrapper = UpdateWrapper.of(account);
wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1));

accountMapper.update(account);
```

--------------------------------

### Querying Accounts with Basic Mapping

Source: https://mybatis-flex.com/zh/base/auto-mapping.html

Demonstrates querying a list of Account objects using QueryWrapper and QueryChain with basic mapping.

```java
QueryWrapper qw = new QueryWrapper();
qw.select(ACCOUNT.ALL_COLUMNS)
    .where(ACCOUNT.ID.ge(100));

List<Account> accounts = accountMapper.selectListByQuery(qw);
```

```java
QueryChain.of(accountMapper)
    .select(ACCOUNT.ALL_COLUMNS)
    .where(ACCOUNT.ID.ge(100))
    .list();
```

--------------------------------

### Db.tx() Code Example

Source: https://mybatis-flex.com/zh/core/tx.html

This example demonstrates the basic usage of the Db.tx() method. The provided Supplier contains the transactional operations. If the Supplier returns true, the transaction is committed; otherwise (if it returns null, false, or throws an exception), the transaction is rolled back.

```java
Db.tx(() -> {

    //进行事务操作

    return true;
});
```

--------------------------------

### Nested Transaction Example

Source: https://mybatis-flex.com/zh/core/tx.html

This example illustrates how to implement nested transactions using Db.tx(). The outer Db.tx() call wraps an inner Db.tx() call. By default, nested transactions behave like the REQUIRED propagation, meaning they join an existing transaction if one is present, or create a new one if not.

```java
Db.tx(() -> {

    //进行事务操作

    boolean success = Db.tx(() -> {
        //另一个事务的操作
        return true;
    });


    return true;
});
```

--------------------------------

### Cursor Query Example

Source: https://mybatis-flex.com/zh/base/query.html

For processing large datasets, use cursor queries to prevent memory leaks. This example demonstrates fetching accounts using a cursor within a transaction. Cursor queries fetch data one record at a time during iteration, and must be executed within a transaction to maintain the database connection.

```java
Cursor<T> selectCursorByQuery(QueryWrapper queryWrapper);
```

```java
Db.tx(() -> {
    Cursor<Account> accounts = accountMapper.selectCursorByQuery(query);
    for (Account account : accounts) {
        System.out.println(account);
    }
    return true;
});
```

--------------------------------

### Pagination with Limit and Offset

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates how to implement pagination using LIMIT and OFFSET clauses, with database-specific SQL generation.

```java
QueryWrapper queryWrapper = QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .orderBy(ACCOUNT.ID.desc())
    .limit(10)
    .offset(20);
```

--------------------------------

### MyBatis-Plus Data Update

Source: https://mybatis-flex.com/zh/intro/benchmark.html

Example of updating data using MyBatis-Plus.

```java
PlusAccount plusAccount = new PlusAccount();
plusAccount.setUserName("testInsert" + i);
plusAccount.setNickname("testInsert" + i);
plusAccount.addOption("key1", "value1");
plusAccount.addOption("key2", "value2");
plusAccount.addOption("key3", "value3");
plusAccount.addOption("key4", "value4");
plusAccount.addOption("key5", "value5");

LambdaUpdateWrapper<PlusAccount> updateWrapper = new LambdaUpdateWrapper<>();
updateWrapper.ge(PlusAccount::getId, 9000);
updateWrapper.le(PlusAccount::getId, 9100);
updateWrapper.like(PlusAccount::getUserName, "admin");
updateWrapper.like(PlusAccount::getNickname, "admin");

mapper.update(plusAccount, lambdaUpdateWrapper);
```

--------------------------------

### MyBatis-Flex Data Update

Source: https://mybatis-flex.com/zh/intro/benchmark.html

Example of updating data using MyBatis-Flex.

```java
FlexAccount flexAccount = new FlexAccount();
flexAccount.setUserName("testInsert" + i);
flexAccount.setNickname("testInsert" + i);
flexAccount.addOption("key1", "value1");
flexAccount.addOption("key2", "value2");
flexAccount.addOption("key3", "value3");
flexAccount.addOption("key4", "value4");
flexAccount.addOption("key5", "value5");

QueryWrapper queryWrapper = QueryWrapper.create()
    .where(FLEX_ACCOUNT.ID.ge(9200))
    .and(FLEX_ACCOUNT.ID.le(9300))
    .and(FLEX_ACCOUNT.USER_NAME.like("admin"))
    .and(FLEX_ACCOUNT.NICKNAME.like("admin"));

mapper.updateByQuery(flexAccount, queryWrapper);
```

--------------------------------

### Using SQL Functions with QueryWrapper

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates how to use SQL aggregate functions like MAX and AVG, and how to construct constants for numbers, strings, and custom columns.

```java
QueryWrapper query = new QueryWrapper()
        .select(
            ACCOUNT.ID,
            ACCOUNT.USER_NAME,
            max(ACCOUNT.BIRTHDAY),
            avg(ACCOUNT.SEX).as("sex_avg")
        ).from(ACCOUNT);
```

```txt
select(number(1)) --> SELECT 1
select(string("str")) --> SELECT 'str'
select(column("abc")) --> SELECT abc
```

--------------------------------

### Multi-Datasource Transaction Example

Source: https://mybatis-flex.com/zh/core/tx.html

This example shows how multiple data sources can be managed within a single @Transactional annotation. Even though operations are performed on different data sources (ds1 and ds2), they are part of the same transaction. If an exception occurs (like division by zero), all operations within that transaction will be rolled back.

```java
@Transactional
public void doSomething(){

    try{
        DataSourceKey.use("ds1");
        Db.updateBySql("update .... ");
    }finally{
        DataSourceKey.clear()
    }

    try{
        DataSourceKey.use("ds2");
        Db.updateBySql("update ...");
    }finally{
        DataSourceKey.clear();
    }

    //抛出异常
    int x = 1/0;
}
```

--------------------------------

### Basic Joins with QueryWrapper

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates how to perform left and inner joins on tables using QueryWrapper.

```java
QueryWrapper queryWrapper=QueryWrapper.create()
    .select()
    .from(ACCOUNT)
    .leftJoin(ARTICLE).on(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID))
    .innerJoin(ARTICLE).on(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID))
    .where(ACCOUNT.AGE.ge(10));
```

--------------------------------

### Multi-Table Query 1 (Fluent-MyBatis)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of a join query using Fluent-MyBatis.

```java
StudentQuery leftQuery = new StudentQuery("a1").selectAll()
    .where.age().eq(34)
    .end();
HomeAddressQuery rightQuery = new HomeAddressQuery("a2")
    .where.address().like("address")
    .end();

IQuery query = leftQuery
    .join(rightQuery)
    .on(l -> l.where.homeAddressId(), r -> r.where.id()).endJoin()
    .build();

List<StudentEntity> entities = this.mapper.listEntity(query);
```

--------------------------------

### MyBatis-Plus Pagination Query

Source: https://mybatis-flex.com/zh/intro/benchmark.html

Example of how to perform a paginated query using MyBatis-Plus.

```java
LambdaQueryWrapper<PlusAccount> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.ge(PlusAccount::getId, 100);
    queryWrapper.eq(PlusAccount::getEmail, "michael@gmail.com");
    Page<PlusAccount> p = Page.of(page, pageSize, 20000, false);
    mapper.selectPage(p, queryWrapper);
```

--------------------------------

### MyBatis-Flex Pagination Query

Source: https://mybatis-flex.com/zh/intro/benchmark.html

Example of how to perform a paginated query using MyBatis-Flex.

```java
QueryWrapper queryWrapper = new QueryWrapper()
    .where(FLEX_ACCOUNT.ID.ge(100));
mapper.paginate(page, pageSize, 20000, queryWrapper);
```

--------------------------------

### Simplified Query Construction with Infix Notation

Source: https://mybatis-flex.com/zh/intro/use-in-kotlin.html

Demonstrates how to build query conditions more concisely using infix notation and extension methods, contrasting with the native MyBatis-Flex approach. This method avoids the need for registering Mappers and APT/KSP.

```kotlin
// Extended query using infix notation
val accountList: List<Account> = query {
    select(Account::id, Account::userName)
    whereWith {
        Account::age.isNotNull and (Account::age ge 17)
    }
    orderBy(-Account::id)
}
```

--------------------------------

### Configure Annotation Processor Paths

Source: https://mybatis-flex.com/zh/intro/maven.html

Recommended configuration for `mybatis-flex-processor` using `maven-compiler-plugin` to enable APT services. This avoids needing to declare `mybatis-flex-processor` in the main dependencies.

```xml
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>3.8.1</version>
    <configuration>
        <annotationProcessorPaths>
            <path>
                <groupId>com.mybatis-flex</groupId>
                <artifactId>mybatis-flex-processor</artifactId>
                <version>1.11.8</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>
```

--------------------------------

### Selecting Columns with Aliases using QueryWrapper

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Demonstrates how to select specific columns and assign aliases to them using the `as()` method, and also how to alias the table itself.

```java
QueryWrapper query = new QueryWrapper()
    .select(
          ACCOUNT.ID.as("accountId")
        , ACCOUNT.USER_NAME)
    .from(ACCOUNT.as("a"));
```

--------------------------------

### Partial Field Update (Fluent-MyBatis)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of updating specific fields using Fluent-MyBatis.

```java
AccountUpdate update = new AccountUpdate()
.update.userName().is("michael")
.age().is(18)
.birthday().is(null)
.end()
.where.id().eq(100)
.end();
accountMapper.updateBy(update);
```

--------------------------------

### Multi-Table Query 2 (MyBatis-Flex)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of a multi-table query with aliases using MyBatis-Flex.

```java
QueryWrapper query = new QueryWrapper()
.select(
      ACCOUNT.ID
    , ACCOUNT.USER_NAME
    , ARTICLE.ID.as("articleId")
    , ARTICLE.TITLE)
.from(ACCOUNT.as("a"), ARTICLE.as("b"))
.where(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID));
```

--------------------------------

### Multi-Table Query 1 (MyBatis-Flex)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of a left join query using MyBatis-Flex.

```java
QueryWrapper query = QueryWrapper.create()
    .select().from(ACCOUNT)
    .leftJoin(ARTICLE).on(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID))
    .where(ACCOUNT.AGE.ge(10));

List<Account> accounts = mapper.selectListByQuery(query);
```

--------------------------------

### 使用 prepareAuth 实现数据权限

Source: https://mybatis-flex.com/zh/core/data-permission.html

通过重写 prepareAuth 方法处理 QueryWrapper 或 SQL 语句以添加权限条件。

```java
public class AuthDialectImpl extends CommonsDialectImpl {

    @Override
    public void prepareAuth(QueryWrapper queryWrapper, OperateType operateType) {
        List<QueryTable> queryTables = CPI.getQueryTables(queryWrapper);
        if (queryTables == null || queryTables.isEmpty()) {
            return;
        }
        for (QueryTable queryTable : queryTables) {
            if (PROJECT.getTableName().equals(queryTable.getName())) {
                queryWrapper.and(PROJECT.INSERT_USER_ID.eq(1));
            }
        }
        super.prepareAuth(queryWrapper, operateType);
    }

    @Override
    public void prepareAuth(String schema, String tableName, StringBuilder sql, OperateType operateType) {
        if (PROJECT.getTableName().equals(tableName)) {
            sql.append(AND).append(wrap("insert_user_id")).append(EQUALS).append(1);
        }
        super.prepareAuth(schema, tableName, sql, operateType);
    }

    @Override
    public void prepareAuth(TableInfo tableInfo, StringBuilder sql, OperateType operateType) {
        if (PROJECT.getTableName().equals(tableInfo.getTableName())) {
            sql.append(AND).append(wrap("insert_user_id")).append(EQUALS).append(1);
        }
        super.prepareAuth(tableInfo, sql, operateType);
    }
}
```

--------------------------------

### QueryWrapper JDK Serial Deserialization

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Example of deserializing a QueryWrapper object that was previously serialized using JDK Serial.

```java
byte[] bytes = ....
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
QueryWrapper queryWrapper = (QueryWrapper) ois.readObject();
```

--------------------------------

### UpdateChain: setRaw() for Special SQL Functions

Source: https://mybatis-flex.com/zh/base/add-delete-update.html

Shows an example of using `setRaw()` with a special SQL function, `utl_raw.cast_to_raw`.

```java
UpdateChain.of(Account.class)
    .setRaw(Account::getUserName, "utl_raw.cast_to_raw('some magic here')")
    .where(Account::getId).eq(1)
    .update();
```

```sql
UPDATE tb_account SET  user_name = utl_raw.cast_to_raw('some magic here')
WHERE id = 1
```

--------------------------------

### Implement MyBatisFlexCustomizer for Initialization

Source: https://mybatis-flex.com/zh/base/mybatis-flex-customizer.html

Implement the MyBatisFlexCustomizer interface in a @Configuration class to perform initialization configurations for MyBatis-Flex. This is useful for setting up global configurations, custom primary key generators, multi-tenancy, dynamic table names, and more.

```java
import org.springframework.context.annotation.Configuration;
import com.mybatisflex.core.config.FlexGlobalConfig;
import com.mybatisflex.core.mybatis.MyBatisFlexCustomizer;

@Configuration
public class MyBatisFlexConfiguration implements MyBatisFlexCustomizer {

    @Override
    public void customize(FlexGlobalConfig globalConfig) {
        // We can perform a series of initialization configurations here
    }

}
```

--------------------------------

### Custom InsertListener Implementation

Source: https://mybatis-flex.com/zh/core/table.html

Provides an example implementation of the InsertListener interface to perform custom actions before an entity is inserted.

```java
public class MyInsertListener implements InsertListener {

    @Override
    public void onInsert(Object entity) {
        Account account = (Account)entity;

        //设置 account 被新增时的一些默认数据
        account.setInsertTime(new Date());
        account.setInsertUserId("...");

        //多租户的场景下，设置当前 租户 ID ..
        account.setTenantId("....");
    }
}
```

--------------------------------

### Configure Source Directory and Base Package

Source: https://mybatis-flex.com/zh/others/codegen.html

Sets the output directory for generated files and the root package name for the project.

```java
globalConfig.getPackageConfig()
        .setSourceDir("D:\\files\\java")
        .setBasePackage("com.your.domain");
```

--------------------------------

### Partial Field Update (MyBatis-Flex)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of updating specific fields in an entity using MyBatis-Flex.

```java
Account account = UpdateEntity.of(Account.class);
account.setId(100); //设置主键
account.setUserName("michael");
account.setAge(18);
account.setBirthday(null);

accountMapper.update(account);
```

--------------------------------

### Core QueryWrapper Construction and Execution

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Shows the essential steps of creating a QueryWrapper with a condition and then using it to query a list of accounts.

```java
//构造 QueryWrapper
QueryWrapper query = new QueryWrapper();
query.where(ACCOUNT.ID.ge(100));

//通过 query 查询数据列表
accountMapper.selectListByQuery(query);
```

--------------------------------

### Custom TenantFactory Implementation

Source: https://mybatis-flex.com/zh/core/multi-tenancy.html

Implement TenantFactory to dynamically retrieve tenant IDs, for example, from request attributes in a Spring application.

```java
public class MyTenantFactory implements TenantFactory {

    public Object[] getTenantIds(){
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        Long tenantId =  attributes.getAttribute("tenantId", RequestAttributes.SCOPE_REQUEST);

        return new Object[]{tenantId};
    }
}
```

--------------------------------

### Spring Boot 配置注册方言

Source: https://mybatis-flex.com/zh/core/data-permission.html

在 Spring Boot 项目中通过 MyBatisFlexCustomizer 注册方言。

```java
@Configuration
public class MybatisFlexConfig implements MyBatisFlexCustomizer {

    @Override
    public void customize(FlexGlobalConfig flexGlobalConfig) {
        

        // 注册查询权限监听方言
        DialectFactory.registerDialect(DbType.MYSQL, new AuthDialectImpl());
    }
}
```

--------------------------------

### Partial Field Update (MyBatis-Plus)

Source: https://mybatis-flex.com/zh/intro/comparison.html

Example of updating specific fields using MyBatis-Plus's UpdateWrapper.

```java
UpdateWrapper<Account> updateWrapper = new UpdateWrapper<>();
updateWrapper.eq("id", 100);
updateWrapper.set("user_name", "michael");
updateWrapper.set("age", 18);
updateWrapper.set("birthday", null);

accountMapper.update(null, updateWrapper);
```

--------------------------------

### Default Data Source Usage

Source: https://mybatis-flex.com/zh/core/multi-datasource.html

Example of using the default data source to select all rows from 'tb_account'.

```java
List<Row> rows = Db.selectAll("tb_account");
System.out.println(rows);
```

--------------------------------

### Configure Table Definition Files for Entities in Different Packages

Source: https://mybatis-flex.com/zh/others/apt.html

When entity classes are in multiple packages, setting `processor.allInTables.enable=true` consolidates all `Tables` definitions into a single package. Specify the desired package for these consolidated files.

```properties
processor.allInTables.enable=true
processor.allInTables.package=com.example.entity.table
```

--------------------------------

### Querying with Relations and valueField

Source: https://mybatis-flex.com/zh/base/relations-query.html

Example of executing a query using `selectListWithRelationsByQueryAs` to retrieve data with specified relations and selective fields.

```java
List<UserVO5> userVO5List = userMapper.selectListWithRelationsByQueryAs(QueryWrapper.create(), UserVO5.class);
System.out.println(JSON.toJSONString(userVO5List));
```

--------------------------------

### Configure TenantFactory

Source: https://mybatis-flex.com/zh/core/multi-tenancy.html

Set up a TenantFactory to provide the current tenant IDs for data operations. This is crucial for data isolation.

```java
TenantManager.setTenantFactory(new TenantFactory() {
    @Override
    public Object[] getTenantIds() {
        //通过这里返回当前租户 ID
        return new Object[]{100};
    }
});
```

--------------------------------

### Selecting Specific Columns with QueryWrapper

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Illustrates how to use the `select` method to specify which columns to retrieve from a table. `select()` without arguments defaults to selecting all columns.

```java
QueryWrapper query1 = new QueryWrapper();
query1.select(ACCOUNT.ID, ACCOUNT.USER_NAME)
    .from(ACCOUNT);

QueryWrapper query2 = new QueryWrapper();
query2.select().from(ACCOUNT);
```

--------------------------------

### QueryWrapper JDK Serial Serialization

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Example of serializing a QueryWrapper object using Java's built-in JDK Serial mechanism.

```java
QueryWrapper queryWrapper = ...
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(queryWrapper);
```

--------------------------------

### Chained Configuration for Entity Generation

Source: https://mybatis-flex.com/zh/others/codegen.html

Demonstrates using chained method calls for configuring entity generation, including enabling Lombok and setting a superclass.

```java
// 设置生成 Entity 并启用 Lombok、设置父类
globalConfig.enableEntity()
        .setWithLombok(true)
        .setSuperClass(BaseEntity.class);
```

--------------------------------

### AccountServiceImpl with Cache Annotations

Source: https://mybatis-flex.com/zh/core/data-cache.html

Example of AccountServiceImpl using Spring Cache annotations for caching data in Redis.

```java
// 设置统一的缓存名称
@Service
@CacheConfig(cacheNames = "account")
public class AccountServiceImpl extends CacheableServiceImpl<AccountMapper, Account> implements AccountService {

    // 根据主键缓存数据
    @Override
    @Cacheable(key = "#id")
    public Account getById(Serializable id) {
        return super.getById(id);
    }

    // 根据方法名加查询 SQL 语句缓存结果数据
    // 加上方法名是为了避免不同的方法使用一样的 QueryWrapper
    @Override
    @Cacheable(key = "#root.methodName + ':' + #query.toSQL()")
    public List<Account> list(QueryWrapper query) {
        return super.list(query);
    }

}
```

--------------------------------

### 配置数据源解密器

Source: https://mybatis-flex.com/zh/core/datasource-encryption.html

通过 DataSourceManager 设置解密逻辑，必须在 MybatisFlexBootstrap 初始化之前调用。

```java
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl("jdbc:mysql://localhost:3306/flex_test");
dataSource.setUsername("root123"); // 真实的账号应该是 root
dataSource.setPassword("123456---0000"); // 真实的密码应该是 123456
        
//配置数据源解密器：DataSourceDecipher
DataSourceManager.setDecipher(new DataSourceDecipher() {
    @Override
    public String decrypt(DataSourceProperty property, String value) {
        //解密用户名，通过编码支持任意加密方式的解密
        if (property == DataSourceProperty.USERNAME) {
            return value.substring(0, 4);
        } 
        //解密密码
        else if (property == DataSourceProperty.PASSWORD) {
            return value.substring(0, 6);
        }
        return value;
    }
});
        
MybatisFlexBootstrap.getInstance()
        .setDataSource(dataSource)
        .addMapper(TenantAccountMapper.class)
        .start();

List<Row> rowList = Db.selectAll("tb_account");
RowUtil.printPretty(rowList);
```

--------------------------------

### Configure Package for All Tables Class

Source: https://mybatis-flex.com/zh/others/apt.html

Define the package for the `Tables` class when `processor.allInTables.enable` is true, using `processor.allInTables.package`. `${entityPackage}` refers to the Entity class's package.

```properties
processor.allInTables.package=${entityPackage}.table
```

--------------------------------

### Constructing Multi-Property IN Clause

Source: https://mybatis-flex.com/zh/intro/use-in-kotlin.html

Example of building a multi-property IN clause, supporting up to three properties. This allows for complex filtering based on combinations of fields.

```kotlin
filter<Account> {
    (Account::id to Account::userName to Account::age).inTriple(
        1 to "张三" to 18,
        2 to "李四" to 19,
    )
}
```

--------------------------------

### Selecting from Multiple Tables with QueryWrapper

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Shows how to select columns from multiple tables, alias them, and define the join condition in the `where` clause.

```java
QueryWrapper query = new QueryWrapper()
    .select(
          ACCOUNT.ID
        , ACCOUNT.USER_NAME
        , ARTICLE.ID.as("articleId")
        , ARTICLE.TITLE)
    .from(ACCOUNT.as("a"), ARTICLE.as("b"))
    .where(ACCOUNT.ID.eq(ARTICLE.ACCOUNT_ID));
```

--------------------------------

### Saving a New Account Record

Source: https://mybatis-flex.com/zh/base/active-record.html

Demonstrates creating and saving a new Account record using the Active Record pattern. The `create()` static method and setters are used for data population.

```java
Account.create()
    .setUserName("张三")
    .setAge(18)
    .setBirthday(new Date())
    .save();
```

--------------------------------

### Basic @Table Annotation Usage

Source: https://mybatis-flex.com/zh/core/table.html

Example of using the @Table annotation to map an Account entity to the 'tb_account' table and specify an update listener.

```java
@Table(value = "tb_account", onUpdate = MyUpdateListener.class)
public class Account {

}
```

--------------------------------

### MyBatis-Flex Spring Boot v4.x Starter Dependency

Source: https://mybatis-flex.com/zh/intro/maven.html

For Spring Boot v4.x projects, this starter is used. Note that 'spring-boot-starter-jdbc' may need to be added separately.

```xml
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-spring-boot4-starter</artifactId>
    <version>1.11.8</version>
</dependency>
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-processor</artifactId>
    <version>1.11.8</version>
    <scope>provided</scope>
</dependency>
```

--------------------------------

### MyBatis-Flex Spring Boot v2.x Starter Dependency

Source: https://mybatis-flex.com/zh/intro/maven.html

Use this configuration for projects utilizing Spring Boot version 2.x.

```xml
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-spring-boot-starter</artifactId>
    <version>1.11.8</version>
</dependency>
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-processor</artifactId>
    <version>1.11.8</version>
    <scope>provided</scope>
</dependency>
```

--------------------------------

### Query Map Collection Example

Source: https://mybatis-flex.com/zh/base/query.html

This method retrieves query results as a list of Row objects, which can be useful for querying data into Map-like structures.

```java
List<Row> selectRowsByQuery(QueryWrapper queryWrapper);
```

--------------------------------

### Union and Union All Operations

Source: https://mybatis-flex.com/zh/base/querywrapper.html

Illustrates how to combine results from multiple queries using UNION and UNION ALL.

```java
QueryWrapper query = new QueryWrapper()
    .select(ACCOUNT.ID)
    .from(ACCOUNT)
    .orderBy(ACCOUNT.ID.desc())
    .union(select(ARTICLE.ID).from(ARTICLE))
    .unionAll(select(ARTICLE.ID).from(ARTICLE));
```

--------------------------------

### Using #{ } and ${ } for SQL Parameter Passing

Source: https://mybatis-flex.com/zh/base/db-row.html

Demonstrates how to pass parameters to raw SQL queries using MyBatis's #{ } and ${ } syntax with a Map. This is useful for dynamic query construction.

```java
Map<String, Integer> map = Collections.singletonMap("age", 18);
List<Row> rowList = Db.selectListBySql("select * from tb_account where age > #{age}", map);
RowUtil.printPretty(rowList);
```
Tokens:
Raw