tessl/maven-com-mybatis-flex--mybatis-flex-core

MyBatis-Flex is an elegant enhancement framework for MyBatis providing type-safe query building, active record patterns, and comprehensive ORM capabilities

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

MyBatis-Flex Core

Name: tessl/maven-com-mybatis-flex--mybatis-flex-core
Author: tessl

MyBatis-Flex is an elegant enhancement framework for MyBatis that provides type-safe query building, active record patterns, and comprehensive ORM capabilities. It supports 40+ database types and offers multiple programming paradigms including Repository pattern, Active Record, and Service Layer abstractions.

Package Information

Package Name: mybatis-flex-core
Package Type: maven
Language: Java
Group ID: com.mybatis-flex
Artifact ID: mybatis-flex-core
Installation:
```
<dependency>
    <groupId>com.mybatis-flex</groupId>
    <artifactId>mybatis-flex-core</artifactId>
    <version>1.10.8</version>
</dependency>
```

Core Imports

import com.mybatisflex.core.MybatisFlexBootstrap;
import com.mybatisflex.core.BaseMapper;
import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.core.activerecord.Model;
import com.mybatisflex.core.service.IService;
import com.mybatisflex.core.row.Db;
import com.mybatisflex.core.FlexGlobalConfig;

Basic Usage

// 1. Bootstrap MyBatis-Flex
MybatisFlexBootstrap bootstrap = MybatisFlexBootstrap.getInstance()
    .setDataSource(dataSource)
    .addMapper(UserMapper.class)
    .start();

// 2. Get mapper instance
UserMapper userMapper = bootstrap.getMapper(UserMapper.class);

// 3. Basic CRUD operations
User user = new User("Alice", 25);
userMapper.insert(user);

// 4. Query building
List<User> adults = userMapper.selectListByQuery(
    QueryWrapper.create()
        .select()
        .from(User.class)
        .where(USER.AGE.ge(18))
);

// 5. Active Record pattern
User activeUser = new User();
activeUser.setName("Bob");
activeUser.setAge(30);
activeUser.save();

// 6. Row-based operations (no entities)
Db.insert("users", Row.ofMap(Map.of("name", "Charlie", "age", 28)));

Architecture

MyBatis-Flex is built around several key components:

Bootstrap System: MybatisFlexBootstrap for framework initialization and configuration
Repository Pattern: BaseMapper<T> interface providing universal CRUD operations
Query Builder: QueryWrapper for type-safe, fluent SQL generation
Active Record: Model<T> base class for entity-centric operations
Service Layer: IService<T> interface for business logic abstraction
Row Operations: Db utility class for entity-free database operations
Multi-Database Support: Dialect system supporting 40+ database types
Type Safety: Comprehensive generic type system with lambda expression support

Capabilities

Bootstrap and Configuration

Framework initialization, global configuration, and multi-datasource setup. Essential for getting MyBatis-Flex running in any Java application.

public class MybatisFlexBootstrap {
    public static MybatisFlexBootstrap getInstance();
    public MybatisFlexBootstrap setDataSource(DataSource dataSource);
    public MybatisFlexBootstrap addDataSource(String key, DataSource dataSource);
    public MybatisFlexBootstrap addMapper(Class<?> mapperClass);
    public MybatisFlexBootstrap start();
    public <T> T getMapper(Class<T> mapperClass);
}

public class FlexGlobalConfig {
    public static FlexGlobalConfig getDefaultConfig();
    public static void setConfig(String configId, FlexGlobalConfig config, boolean isDefault);
}

Bootstrap and Configuration

Universal CRUD Operations

Comprehensive CRUD interface that eliminates the need for custom mapper methods. Supports batch operations, relationship loading, and advanced querying.

public interface BaseMapper<T> {
    // Insert operations
    int insert(T entity);
    int insertSelective(T entity);
    int insertBatch(Collection<T> entities);
    int insertOrUpdate(T entity);
    
    // Select operations
    T selectOneById(Serializable id);
    List<T> selectListByQuery(QueryWrapper queryWrapper);
    long selectCountByQuery(QueryWrapper queryWrapper);
    Page<T> paginate(Page<T> page, QueryWrapper queryWrapper);
    
    // Update operations
    int update(T entity);
    int updateByQuery(T entity, QueryWrapper queryWrapper);
    
    // Delete operations
    int deleteById(Serializable id);
    int deleteBatchByIds(Collection<? extends Serializable> ids);
    int deleteByQuery(QueryWrapper queryWrapper);
}

Universal CRUD Operations

Query Builder System

Type-safe, fluent query building with comprehensive SQL support. Includes support for complex joins, subqueries, CTEs, and all major SQL operations.

public class QueryWrapper {
    public static QueryWrapper create();
    public QueryWrapper select(QueryColumn... queryColumns);
    public QueryWrapper from(Class<?>... entityClasses);
    public QueryWrapper where(QueryCondition queryCondition);
    public QueryWrapper leftJoin(Class<?> entityClass);
    public QueryWrapper orderBy(QueryColumn... queryColumns);
    public QueryWrapper groupBy(QueryColumn... queryColumns);
    public QueryWrapper limit(Number rows);
}

public class QueryColumn {
    public static QueryColumn create(String columnName);
    public QueryCondition eq(Object value);
    public QueryCondition ge(Object value);
    public QueryCondition in(Object... values);
}

Query Builder System

Active Record Pattern

Entity-centric operations where domain objects handle their own persistence. Provides a clean, object-oriented approach to database operations.

public abstract class Model<T extends Model<T>> {
    public boolean save();
    public boolean update();
    public boolean update(boolean ignoreNulls);
    public boolean remove();
    public Optional<Boolean> saveOpt();
    public Optional<Boolean> updateOpt();
    public Optional<Boolean> removeOpt();
}

Active Record Pattern

Fluent Update Operations

Type-safe, chainable update operations that provide a clean alternative to traditional entity updates. Supports conditional field setting, complex WHERE conditions, and direct SQL execution.

public class UpdateChain<T> {
    public static <T> UpdateChain<T> of(Class<T> entityClass);
    public static <T> UpdateChain<T> of(BaseMapper<T> mapper);
    public UpdateChain<T> set(String column, Object value);
    public UpdateChain<T> set(QueryColumn column, Object value);
    public <R> UpdateChain<T> set(LambdaGetter<R> getter, Object value);
    public UpdateChain<T> where(QueryCondition condition);
    public UpdateChain<T> and(QueryCondition condition);
    public UpdateChain<T> or(QueryCondition condition);
    public boolean update();
}

Fluent Update Operations

Service Layer Interface

Business logic abstraction with enhanced CRUD operations, batch processing, and query chaining. Perfect for service-oriented architectures.

public interface IService<T> {
    boolean save(T entity);
    boolean saveBatch(Collection<T> entities);
    boolean saveOrUpdate(T entity);
    boolean removeById(Serializable id);
    boolean update(T entity);
    T getById(Serializable id);
    List<T> list(QueryWrapper queryWrapper);
    Page<T> page(Page<T> page, QueryWrapper queryWrapper);
    long count(QueryWrapper queryWrapper);
}

Service Layer Interface

Row-Based Database Operations

Direct database operations without entity classes. Ideal for dynamic queries, reporting, and working with unknown table structures.

public class Db {
    public static int insert(String tableName, Row row);
    public static int insertBySql(String sql, Object... args);
    public static List<Row> selectBySql(String sql, Object... args);
    public static int updateBySql(String sql, Object... args);
    public static int deleteBySql(String sql, Object... args);
}

public class Row {
    public static Row ofMap(Map<String, Object> map);
    public Row set(String column, Object value);
    public Object get(String column);
}

Row-Based Operations

Multi-Database Support

Comprehensive database dialect system supporting 40+ database types including MySQL, PostgreSQL, Oracle, SQL Server, and specialized databases.

public enum DbType {
    MYSQL, POSTGRESQL, ORACLE, SQL_SERVER, DB2,
    CLICKHOUSE, H2, SQLITE, DERBY, FIREBIRD,
    DM, KINGBASE, GBASE, OSCAR, HANA, REDSHIFT;
}

public interface IDialect {
    String forSelectByQuery(QueryWrapper queryWrapper);
    String forPaginateQuery(QueryWrapper queryWrapper, long offset, long rows);
    String wrap(String keyword);
}

Multi-Database Support

Pagination Support

Comprehensive pagination with performance optimizations, count query optimization, and type conversion support.

public class Page<T> {
    public Page(int pageNumber, int pageSize);
    public Page(int pageNumber, int pageSize, boolean optimizeCountQuery);
    
    public List<T> getRecords();
    public long getTotalRow();
    public int getTotalPage();
    public int getPageNumber();
    public int getPageSize();
    public <R> Page<R> convert(Function<T, R> mapper);
}

Pagination Support

Types

// Core query types
public class QueryCondition {
    public QueryCondition and(QueryCondition condition);
    public QueryCondition or(QueryCondition condition);
    public QueryCondition not();
}

public class QueryColumn {
    public static QueryColumn create(String columnName);
    public QueryColumn as(String alias);
    public QueryCondition eq(Object value);
    public QueryCondition ge(Object value);
    public QueryCondition in(Object... values);
    public QueryCondition like(String pattern);
    public QueryCondition isNull();
    public QueryCondition between(Object start, Object end);
}

public class QueryTable {
    public static QueryTable create(String tableName);
    public static QueryTable create(Class<?> entityClass);
    public QueryTable as(String alias);
}

// Update operations
public class UpdateChain<T> {
    public static <T> UpdateChain<T> of(Class<T> entityClass);
    public static <T> UpdateChain<T> of(BaseMapper<T> mapper);
    public UpdateChain<T> set(String column, Object value);
    public UpdateChain<T> where(QueryCondition condition);
    public boolean update();
}

// Pagination types
public class Page<T> {
    public Page(int pageNumber, int pageSize);
    public Page(int pageNumber, int pageSize, boolean optimizeCountQuery);
    public List<T> getRecords();
    public long getTotalRow();
    public int getTotalPage();
    public int getPageNumber();
    public int getPageSize();
    public <R> Page<R> convert(Function<T, R> mapper);
}

// Row operations
public class Row extends LinkedHashMap<String, Object> {
    public static Row ofMap(Map<String, Object> map);
    public Row set(String column, Object value);
    public <T> T get(String column);
    public Object get(String column);
}

public class RowKey {
    public static RowKey of(String... columns);
    public static RowKey of(QueryColumn... columns);
}

// Functional interfaces
@FunctionalInterface
public interface LambdaGetter<T> extends Serializable, Function<T, Object> {
}

// Cursor for streaming results
public interface Cursor<T> extends Closeable, Iterable<T> {
    boolean isOpen();
    boolean isConsumed();
    int getCurrentIndex();
}

// Field query builder for relationship loading
public interface FieldQueryBuilder {
    FieldQueryBuilder with(String fieldName);
    FieldQueryBuilder with(LambdaGetter<?>... fieldGetters);
}

// Configuration types
public class FlexGlobalConfig {
    public DbType getDbType();
    public void setDbType(DbType dbType);
    public KeyConfig getKeyConfig();
    public void setKeyConfig(KeyConfig keyConfig);
    public boolean isLogicDeleteColumn(String column);
    public void setLogicDeleteColumn(String column);
}

public class KeyConfig {
    public KeyType getKeyType();
    public void setKeyType(KeyType keyType);
    public String getValue();
    public void setValue(String value);
}

// Enums
public enum DbType {
    MYSQL, POSTGRESQL, ORACLE, SQL_SERVER, DB2,
    CLICKHOUSE, H2, SQLITE, DERBY, FIREBIRD,
    DM, KINGBASE, GBASE, OSCAR, HANA, REDSHIFT;
}

public enum KeyType {
    None, Auto, Generator, Sequence;
}

// Transaction support
public enum Propagation {
    REQUIRED,
    REQUIRES_NEW,
    NESTED,
    NOT_SUPPORTED,
    NEVER,
    SUPPORTS,
    MANDATORY;
}

// Batch processing
@FunctionalInterface
public interface BatchArgsSetter<T> {
    void setArgs(PreparedStatement ps, T item, int index) throws SQLException;
}