快速入门

模块	所属层级	描述
wu-database-lazy-lambda	lambda	针对不同数据源
wu-database-lazy-orm-core	orm 核心	orm核心处理
wu-database-lazy-sql	sql核心处理成	处理sql解析、sql执行、sql映射
wu-elasticsearch-starter	ES	ES
wu-hbase-starter	hbase	hbase
wu-database-lazy-datasource-starter	数据源处理	数据源处理

简介

特性

强大的CRUD操作：内置通过注入 LazyLambdaStream 对象即可实现表单的大部分CRUD操作
支持Lambda形式的调用：通过Lambda表达式，方便的编写各类查询条件
内置分页查询：通过构造分页对象查询数据统计分页总数
支持多种数据库：支持MySQL

支持数据库

任何能使用 LazyLambdaStream进行CRUD，并且支持标准SQL的数据库，具体支持情况如下

MySQL

框架架构

![log.png](./Lazy ORM log.png)

代码托管

Gitee ｜Github

参与贡献

欢迎各位同学一起参与完善wu-framework-lazy-orm-spring-starter

贡献代码：代码地址wu-framework-lazy-orm-spring-starter，欢迎提交Issue或者Pull Requests

教程、案例、使用者名单

暂无

版本功能

Lazy-ORM 是一款针对懒人快速开发的ORM框架
支持实体类反射数据进行数据库CRUD操作
新增灵性数据插入更新(自动过滤空值)
新增配置导出数据忽略指定字段
spring.datasource.ignore-exported-fields: - id
新增配置声明导出数据中的特殊字符
spring.datasource.special-fields: - ASC
新增@LazyScan自动扫描实体创建表
新增自动填充表数据
新增创建表方法
新增更新表字段方法
修复数据插入布尔类型、数字类型字段字符串更改为->原始数据类型
新增逆向工程功能生成对应的Java class 支持mybatis 适配
使用Spring 进行事物管理
修复数据为null 时执行sql 数据为 "null" 问题
新增自动过滤null字段的upsert接口
新增字段自动关联转译
- 注解方法入参数通过数据库转译@LazyTableArgsTranslation
- 注解方法出参数转译@LazyTableTranslation
- 通过一个字段管理其他表的一条数据@LazyTableTranslationOneField
- 通过一个字段管理其他表的数据@LazyTableTranslationOneToManyField

快速开始

我们将通过一个简单的 Demo 来阐述 wu-framework-lazy-orm-spring-starter 的强大功能，在此之前，我们假设您已经：

拥有 Java 开发环境以及相应 IDE
熟悉 Spring Boot
熟悉 Maven

现有一张 User 表，其表结构如下：

id	name	annual_salary	email
1	吴小二	18	test1@lazy.com
2	吴三	20	test2@lazy.com
3	吴小四	28	test3@lazy.com
4	吴小五	21	test4@lazy.com
5	吴小六	24	test5@lazy.com

其对应的数据库 Schema 脚本如下：

DROP TABLE IF EXISTS user;

CREATE TABLE user
(
    id            BIGINT(20) NOT NULL COMMENT '主键ID',
    name          VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
    annual_salary INT(11) NULL DEFAULT NULL COMMENT '年薪',
    email         VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
    PRIMARY KEY (id)
);

其对应的数据库 Data 脚本如下：

DELETE
FROM user;

INSERT INTO user (id, name, annual_salary, email)
VALUES (1, '吴小二', 18, 'test1@lazy.com'),
       (2, '吴三', 20, 'test2@lazy.com'),
       (3, '吴小四', 28, 'test3@lazy.com'),
       (4, '吴小五', 21, 'test4@lazy.com'),
       (5, '吴小六', 24, 'test5@lazy.com');

初始化工程

创建一个空的 Spring Boot 工程（工程将以 MySQL 作为默认数据库进行演示）

添加依赖

引入 Spring Boot Starter 父工程：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.6.7</version>
    <relativePath/>
</parent>

引入 spring-boot-starter、spring-boot-starter-test、wu-framework-lazy-orm-spring-starter、mysql 依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
     <!--懒人依赖-->
    <dependency>
        <groupId>top.wu2020</groupId>
        <artifactId>wu-framework-lazy-orm-spring-starter</artifactId>
        <version>1.2.6-JDK17-SNAPSHOT</version>
    </dependency>
     <!--mysql-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

配置

在 application.yml 配置文件中添加 mysql 数据库的相关配置：

# DataSource Config
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver

Spring Boot 启动类：


@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

}

编码

编写实体类 User.java（此处使用了 Lombok 简化代码）


@Data
public class User {
    private Long id;
    private String name;
    private Integer annualSalary;
    private String email;
}

开始使用

添加测试类，进行功能测试：


@SpringBootTest
public class SampleTest {

    @Autowired
    LazyLambdaStream lazyLambdaStream;

    @Test
    public void testSelect() {
        System.out.println(("----- selectAll method test ------"));
        // 等同于执行sql select * from sys_user
        Collection<User> userList = lazyLambdaStream.select(LazyWrappers.<User>lambdaWrapper()).collection();
        AssertFactory.assertEquals(5, userList.size());
        userList.forEach(System.out::println);
    }

}

小结

通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

安装

全新的 wu-framework-lazy-orm-spring-starter 1.2.6-JDK17-SNAPSHOT 版本基于 JDK17，提供了 lambda 形式的调用，所以安装集成 MP3.0 要求如下：

JDK 8+
Maven or Gradle

Spring Boot

Maven：

    <dependency>
        <groupId>top.wu2020</groupId>
        <artifactId>wu-framework-lazy-orm-spring-starter</artifactId>
        <version>1.2.6-JDK17-SNAPSHOT</version>
    </dependency>

配置

wu-framework-lazy-orm-spring-starter 的配置异常的简单，我们仅需要一些简单的配置即可使用 wu-framework-lazy-orm-spring-starter 的强大功能！

Spring Boot 工程

配置yaml

# DataSource Config
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver

注解

::: tip 本文将介绍 wu-framework-lazy-orm-spring-starter 注解包相关类详解（更多详细描述可点击查看源码注释） :::

描述
使用位置对象

@LazyTable


@LazyTable(tableName = "sys_user")
public class User {
    private Long id;
    private String name;
    private Integer annualSalary;
    private String email;
}

属性	类型	必须指定	默认值	描述
tableName	String	否	""	表名
schema	String	否	""	schema
comment	String	否	""	表注释
perfectTable	boolean	否	"false"	完善表
smartFillField	boolean	否	false	智能填充bean属性针对数据源如mysql查询结果、http请求结果中包含的数据字段不再当前对象中

@LazyTableFieldId


@LazyTable(tableName = "sys_user")
public class User {

    @LazyTableFieldId
    private Long id;
    private String name;
    private Integer annualSalary;
    private String email;
}

属性	类型	必须指定	默认值	描述
value	String	否	""	字段名
name	String	否	""	字段名
comment	String	否	""	字段注释
type	String	否	""	字段了类型（varchar、int等）
indexType	LayerField.LayerFieldType	否	LayerField.LayerFieldType.ID	索引类型
idType	IdType	否	AUTOMATIC_ID	主键自增类型

LayerFieldType

值	描述
FIELD_TYPE	字段类型
ID	数据库 ID
UNIQUE	唯一性索引
AUTOMATIC	自动的

IdType

值	描述
AUTOMATIC_ID	主键ID 默认自增
INPUT_ID	输入主键

@LazyTableField


@LazyTable(tableName = "sys_user")
public class User {

    private Long id;
    private String name;
    @LazyTableField("salary")
    private Integer annualSalary;
    private String email;
}

属性	类型	必须指定	默认值	描述
value	String	否	""	字段名
name	String	否	""	字段名
comment	String	否	""	字段注释
columnType	String	否	""	字段了类型（varchar、int等）
exist	boolean	否	true	是否存在
indexType	LayerField.LayerFieldType	否	LayerField.LayerFieldType.ID	索引类型
idType	IdType	否	AUTOMATIC_ID	主键自增类型

快速测试

自动导入 wu-framework-lazy-orm-spring-starter 测试所需相关配置。

示例工程

源码：👉 wu-framework-lazy-orm-spring-starter-simple(opens new window)

使用教程

添加测试依赖

Maven:

<dependency>
    <groupId>top.wu2020</groupId>
    <artifactId>wu-framework-lazy-orm-spring-starter</artifactId>
    <version>1.2.6-JDK17-SNAPSHOT</version>
</dependency>

Gradle：

compile group: 'top.wu2020', name: 'wu-framework-lazy-orm-spring-starter', version: '1.2.6-JDK17-SNAPSHOT'

编写测试用例


@Autowired
private LazyOperation lazySqlOperation;

/**
 * 用户信息简单插入
 */
@ApiOperation("用户信息简单插入")
@PostMapping("/lazy/upsert")
public void lazyUpsert() {
    SysUser sysUser = new SysUser();
    sysUser.setUsername("小来");
    sysUser.setPassword("1234");
    sysUser.setId(1L);
    // 同执行sql insert into sys_user (user_name,password,id) values("小来","1234","1") ON DUPLICATE KEY UPDATE user_name=values (user_name),password=values (password),id=values (id)
    lazySqlOperation.upsert(sysUser);
}

核心功能

代码生成器

快速开始

安装

<dependency>
    <groupId>top.wu2020</groupId>
    <artifactId>wu-framework-lazy-orm-spring-starter</artifactId>
    <version>1.2.6-JDK17-SNAPSHOT</version>
</dependency>

::: tip 直接使用maven引入项目，通过配置文件加载生成代码 :::

配置文件

spring:
  lazy:
    enable-reverse-engineering: true  # 允许逆向工程
    reverse-engineering:
      enable-lazy: false   # 不允许lazy系列注解
      enable-lombok-accessors: false # 不允许 lombok.accessors
      enable-lombok-data: false  # 不允许 lombok.data
      package-name: org.wu.lazy  # 包名
      enable-swagger: false  # 不允许 swagger

使用

启动Spring-boot的启动类即可

成品

Lazy ORM Log 2 .png

CRUD 接口

upsert

    /**
 * 批量更新或插入
 *
 * @param objects
 * @param <T>
 */
<T> void upsert(Object... objects);

参数说明

类型	参数名	描述
Object...	objects	任意实体对象

upsert 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    DataBaseUser dataBaseUser = new DataBaseUser();
    dataBaseUser.setUsername("username");
    dataBaseUser.setAddress("地址");
    dataBaseUser.setAge(18);
    // 同执行SQL: insert into user (id,username,birthday,sex,age,age_type,address_id) VALUES (null,'username',null,null,18,null,null)  ON DUPLICATE KEY UPDATE 
    //id=values (id),username=values (username),birthday=values (birthday),sex=values (sex),age=values (age),age_type=values (age_type),address_id=values (address_id)
    lazyLambdaStream.upsert(dataBaseUser);

}

insert

    /**
 * 插入 单个/list
 *
 * @param t
 * @param <T>
 */
<T> void insert(T t);

参数说明

类型	参数名	描述
T	t	实体对象

insert 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    DataBaseUser dataBaseUser = new DataBaseUser();
    dataBaseUser.setUsername("username");
    dataBaseUser.setAddress("地址");
    dataBaseUser.setAge(18);
    // 同执行SQL: INSERT INTO user(username,birthday,sex,age,age_type,address_id)values(null,'username',null,null,'18',null,null)
    lazyLambdaStream.insert(dataBaseUser);

}

upsertRemoveNull

  /**
 * 更新或者插入单个执行 去除空值
 * 多个数据性能会慢，不经常使用
 */
Object upsertRemoveNull(Object... t);

参数说明

类型	参数名	描述
Object...	t	任意实体对象

upsertRemoveNull 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    Address address = new Address();
    address.setId(1L);
    address.setLongitude(1.2d);
    //  执行SQL: insert into address (id,latitude,longitude) VALUES (1,'0.0','1.2')  ON DUPLICATE KEY UPDATE 
    // id=values (id),latitude=values (latitude),longitude=values (longitude)
    lazyLambdaStream.upsertRemoveNull(address);

    List<Address> addresses = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        Address addressa = new Address();
        address.setId(1L);
        address.setLongitude(1.2d);
        addresses.add(addressa);
    }
    // 执行SQL: insert into address (id,name,latitude,longitude) VALUES (null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0'),(null,null,'0.0','0.0')  ON DUPLICATE KEY UPDATE
    // id=values (id),name=values (name),latitude=values (latitude),longitude=values (longitude)
    lazyLambdaStream.upsert(addresses);

}

lazyPage

    /**
 * 分页查询
 *
 * @param <T>
 * @return
 */
<T> Page<T> lazyPage(@NonNull Page lazyPage, @NonNull Class returnType, String sql, Object... params);

参数说明

类型	参数名	描述
Page	lazyPage	分页对象
Class	returnType	返回数据类型
String	sql	执行的sql语句
Object...	params	sql执行参数

lazyPage 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );

    //  执行SQL: select user.* from user where  user.age  >  18  and  user.sex  =  '男'
    Page<DataBaseUser> dataBaseUserLazyPage = lazyLambdaStream
            .selectPage(LazyWrappers.<DataBaseUser>lambdaWrapper()
                            .gt(DataBaseUser::getAge, 18)
                            .eq(DataBaseUser::getSex, "男"),
                    new Page<>(1, 10)
            );
    System.out.println(dataBaseUserLazyPage);
}

executeSQL


/**
 * @param sql
 * @param t
 * @param params
 * @param <T>
 * @return
 */
<T> List<T> executeSQL(String sql, Class t, Object... params);

参数说明

类型	参数名	描述
Class	t	返回数据类型
String	sql	执行的sql语句
Object...	params	sql执行参数

executeSQL 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );

    //  执行SQL: select user.* from user where  user.age  >  18  and  user.sex  =  '男'
    List<DataBaseUser> dataBaseUsers = lazyLambdaStream.executeSQL("select user.* from user where  user.age  >  %s  and  user.sex  =  '%s'", DataBaseUser.class, 18, "男");
    System.out.println(dataBaseUsers);
}

executeSQLForBean

      /**
 * description 执行SQL 返回指定类型
 *
 * @param
 * @return
 * @exception/throws
 * @author Jiawei Wu
 * @date 2020/12/29 下午1:44
 */
<T> T executeSQLForBean(String sql, Class<?> t, Object... params);

参数说明

类型	参数名	描述
Class	t	返回数据类型
String	sql	执行的sql语句
Object...	params	sql执行参数

executeSQLForBean 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );

    //  执行SQL: select user.* from user where  user.age  >  18  and  user.sex  =  '男' limit 1
    DataBaseUser dataBaseUser = lazyLambdaStream
            .executeSQLForBean("select user.* from user where  user.age  >  %s  and  user.sex  =  '%s' limit 1",
                    DataBaseUser.class,
                    18,
                    "男"
            );
    System.out.println(dataBaseUser);
}

perfect

 /**
 * describe 完善表
 *
 * @param entityClasses class 对象数组
 * @return
 * @author Jia wei Wu
 * @date 2022/1/2 5:05 下午
 **/
<T> T perfect(@NonNull Class... entityClasses);

参数说明

类型	参数名	描述
Class...	entityClasses	实体对象

perfect 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    LazyDatabaseJsonMessage.lazyDataSourceType = DataSourceType.MySQL;
    // 完善表结构
    lazyLambdaStream.perfect(Address.class);

}

createTable

    /**
 * describe 创建表
 *
 * @param
 * @return
 * @author Jia wei Wu
 * @date 2022/1/2 7:48 下午
 **/
<T> T createTable(@NonNull Class<?>... entityClasses);

参数说明

类型	参数名	描述
Class...	entityClasses	实体对象

createTable 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    LazyDatabaseJsonMessage.lazyDataSourceType = DataSourceType.MySQL;
    // 创建表
    lazyLambdaStream.createTable(Address.class);

}

updateTable

    /**
 * describe 更新表
 *
 * @param
 * @return
 * @author Jia wei Wu
 * @date 2022/1/2 7:48 下午
 **/
<T> T updateTable(@NonNull Class<?>... entityClasses);

参数说明

类型	参数名	描述
Class...	entityClasses	实体对象

updateTable 案例

    public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );
    LazyDatabaseJsonMessage.lazyDataSourceType = DataSourceType.MySQL;
    // 更新表
    lazyLambdaStream.updateTable(Address.class);

}

execute

    /**
 * 执行操作
 *
 * @param persistenceRepository
 * @return
 */
List<Object> execute(PersistenceRepository persistenceRepository);

参数说明

类型	参数名	描述
PersistenceRepository	persistenceRepository	预执行SQL需要的属性

execute 案例

// 使用相当灵活、想咋玩就咋玩

executeOne

    /**
 * 执行操作
 *
 * @param persistenceRepository
 * @return
 */
Object executeOne(PersistenceRepository persistenceRepository);

参数说明

类型	参数名	描述
PersistenceRepository	persistenceRepository	预执行SQL需要的属性

executeOne 案例

        public static void main(String[] args) {
    LazyLambdaStream lazyLambdaStream = LazyLambdaStreamFactory.createLazyLambdaStream(
            "127.0.0.1",
            3306,
            "acw",
            "root",
            "wujiawei"
    );

    PersistenceRepository persistenceRepository = PersistenceRepositoryFactory.create();
    persistenceRepository.setQueryString("select user.* from user where  user.age  >  18  and  user.sex  =  '男' limit 1");
    persistenceRepository.setExecutionType(LambdaTableType.SELECT);
    persistenceRepository.setResultClass(DataBaseUser.class);
    //  执行SQL: select user.* from user where  user.age  >  18  and  user.sex  =  '男' limit 1
    DataBaseUser dataBaseUser = (DataBaseUser) lazyLambdaStream.executeOne(persistenceRepository);
    System.out.println(dataBaseUser);
}

聪明懒人的操作接口

saveSqlFile

    /**
 * @param nameDatabase 数据库名 默认当前连接数据
 *                     System.getProperty("user.dir") 数据文件地址
 * @return 保存数据到本地数据
 * description 数据库数据存储到sql文件(删除表后、创建表 数据使用upsert)
 * @author Jiawei Wu
 * @date 2021/1/31 6:40 下午
 **/
void saveSqlFile(String nameDatabase);

参数说明

类型	参数名	描述
String	nameDatabase	数据库名默认当前连接数据

saveSoftSqlFile

    /**
 * @param nameDatabase 数据库名 默认当前连接数据
 *                     System.getProperty("user.dir") 数据文件地址
 * @return 保存数据到本地数据
 * description 柔和形 数据库数据存储到sql文件(表存在不删除 数据使用upsert)
 * @author Jiawei Wu
 * @date 2021/1/31 6:40 下午
 **/
void saveSoftSqlFile(String nameDatabase);

参数说明

类型	参数名	描述
String	nameDatabase	数据库名默认当前连接数据

saveUpsertSqlFile

    /**
 * describe  导出增量式更新数据
 *
 * @param nameDatabase 数据库名 默认当前连接数据
 *                     System.getProperty("user.dir") 数据文件地址
 * @return 保存数据到本地数据
 * @author Jia wei Wu
 * @date 2022/4/9 22:57
 **/
void saveUpsertSqlFile(String nameDatabase);

参数说明

类型	参数名	描述
String	nameDatabase	数据库名默认当前连接数据

stuffed

    /**
 * 自动填充数据
 * SELECT
 * *
 * FROM
 * information_schema.COLUMNS
 * WHERE
 * TABLE_SCHEMA = 'lazy'
 * AND TABLE_NAME = 'sys_user';
 *
 * @param schema 数据库
 * @param table  表
 * @param num    数量
 */
void stuffed(String schema, String table, Long num);

/**
 * 自动填充数据
 * SELECT
 * *
 * FROM
 * information_schema.COLUMNS
 * WHERE
 * TABLE_SCHEMA = 'lazy'
 * AND TABLE_NAME = 'sys_user';
 *
 * @param table class 对应数据库结构的class
 * @param num   数量
 */
void stuffed(Class table, Long num);

参数说明

类型	参数名	描述
String	schema	数据库名
String	table	表名
Long	num	数量

stuffedAll

    /**
 * 塞入所有数据
 *
 * @param num
 */
void stuffedAll(Long num);

参数说明

类型	参数名	描述
Long	num	存储数据数量

stuffedJava

    /**
 * describe 根据表明创建出Java文件
 *
 * @param schema    数据库
 * @param tableName 表名
 * @return
 * @author Jia wei Wu
 * @date 2022/1/23 12:23 上午
 **/
void stuffedJava(String schema, String tableName);

参数说明

类型	参数名	描述
String	schema	数据库
String	tableName	表名

wujiawei / wu-framework-parent .gitee-modal { width: 500px !important; }

快速入门

简介

特性

支持数据库

框架架构

代码托管

参与贡献

教程、案例、使用者名单

版本功能

快速开始

初始化工程

添加依赖

配置

编码

开始使用

小结

安装

Spring Boot

配置

Spring Boot 工程

注解

@LazyTable

@LazyTableFieldId

LayerFieldType

IdType

@LazyTableField

快速测试

示例工程

使用教程

添加测试依赖

编写测试用例

核心功能

代码生成器

快速开始

安装

配置文件

使用

成品

CRUD 接口

upsert

参数说明

upsert 案例

insert

参数说明

insert 案例

upsertRemoveNull

参数说明

upsertRemoveNull 案例

lazyPage

参数说明

lazyPage 案例

executeSQL

参数说明

executeSQL 案例

executeSQLForBean

参数说明

executeSQLForBean 案例

perfect

参数说明

perfect 案例

createTable

参数说明

createTable 案例

updateTable

参数说明

updateTable 案例

execute

参数说明

execute 案例

executeOne

参数说明

executeOne 案例

聪明懒人的操作接口

saveSqlFile

参数说明

saveSoftSqlFile

参数说明

saveUpsertSqlFile

参数说明

wujiawei / wu-framework-parent