# ormybatis

**Repository Path**: javahui/ormybatis

## Basic Information

- **Project Name**: ormybatis
- **Description**: ormybaits基于mybatis封装Dao层操作
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 13
- **Forks**: 2
- **Created**: 2016-03-31
- **Last Updated**: 2025-09-05

## Categories & Tags

**Categories**: database-dev

**Tags**: None

## README

##### 1. 加入jar
```xml
		<dependency>
			<groupId>pers.richard</groupId>
			<artifactId>ormybatis-spring-starter</artifactId>
			<version>${project.version}</version>
		</dependency>
```
##### 2. spring配置：

Springboot配置文件方式

```
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/d?useSSL=false&useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456
```

##### 3. 加入插件,生成基本代码
	<plugin>
		<groupId>pers.richard</groupId>
		<artifactId>ormybatis-maven-plugin</artifactId>
		<version>x.x.x-SNAPSHOT</version>
	</plugin>
##### 4. 在项目的 src/main/resources目录下增加ormybatis.properties文件用以生成代码
	jdbc.url=jdbc:mysql://localhost:3306/dbName?useSSL=true
	jdbc.username=root
	jdbc.password=123456
	
	table.name=user
	#生成src/main/resources路径下的文件夹名
	sqlFile.path=mapper
	
	# DAO类包路径
	dao.package.path=pers.richard.example.dao
	# po类包路径
	domain.package.path=pers.richard.example.po
	
	#Dao类名(可选)
	dao.class.name=
	#Domain bean类名(可选)
	domain.class.name=
##### 3. 运行mvn ormybatis:gen  生成dao类,po类,mapping xml文件


###### 3.1. @DaoConfig注解
    table(表名)
###### 3.2. 查询demo

```java
import java.util.Arrays;

@DaoConfig(table = "user")
public class UserDao extends OrmybatisBaseDao<User> {

    //主键id查询
    public void selectId() {
        //一个id查询
        User u1 = super.selectOne(1);
        User u2 = super.selectOne("1");

        //Where id in (1,2)   --多id查询
        List<User> userList2 = super.selectList(Arrays.asList(1, 2));

        //Where id in (1,2,10,20)   --多id查询
        List<String> list = new ArrayList();
        liset.add("1, 2");
        liset.add("10, 20");
        List<User> userList2 = super.selectList(list);
    }

    //一个条件查询
    public void selectOneFieldWhere() {
        //默认1:没有设置order by排序,则默认加上order By id desc
        //默认2:默认加上Limit 1,防止查出多条查询
        //WHERE age = 18 Limit 1 Order BY id desc
        User u1 = super.selectOne(Field.AGE, "18");//返回一个对象
        User u2 = super.selectOne(Field.AGE, "");//传入空,不执行查询,返回null

        //传入空,不执行查询,selectList返回空集合,不是null
        List<User> list = super.selectList(Field.NAME, "");
        log.info(list.toString());//不会报NullPointException 返回[]
    }

    
    public void page() {
        //分页列表查询
        Bean reqBean = new Bean()
                .setPageSize(20)
                .setPageNo(1)
                .setAge(18)//数字类型 使用等于查询
                .setName("wang");
        Select select = Select.create().list(reqBean)
                .eq(Field.NAME, reqBean.getName());//不加这行默认like查询,加上则用等于查询
        // WHERE age = 18 and wang = 'wang' ORDER BY id desc Limit 20
        List<User> userList = super.selectPage(select);
        
    }
    
    public void selectWhere() {
        //如果没设置order by排序,则默认加上order By id desc
        //select * from user ORDER BY id desc
        super.selectAll();

        //select * from user ORDER BY age DESC limit 10
        super.selectList(Select.create().orderDesc(Field.AGE).limit(10));

        Select sel = Select.create()
                .eq(Field.NAME, "")//忽略空的查询条件
                .eq(Field.STATUS, Arrays.asList(1, 2)); //自动为List<Integer>根据javaBean po中的类型
        User u = super.selectOne(sel); //WHERE status in (0,1) ORDER BY id Limit 1
        List<User> list = super.selectList(select1); //WHERE status in (0,1) ORDER BY id Limit 5000

        //查询条件说明
        Select s2 = Select.create()
                .eq(Field.AGE, "1234")// account_no = '1234'
                .like(Field.NAME, "wang")// name LIKE conat('wang', '%')
                .likeContains(Field.NAME, "wang") // account_no LIKE conat('%', 'wang', '%')
                .gt(Field.AGE, 100) // AGE > 100
                .gte(Field.AGE, 100) // AGE >= 100
                .lt(Field.AGE, 100) // AGE < 100
                .lte(Field.AGE, 100) // AGE <= 100
                .isNull(Field.AGE) // age is null
                .isNullString(Field.NAME); //name = ''

        Select.create()
                .likeMulti('abc', Field.NAME, Field.STATUS)// 多字段or模糊查( name LIKE conat('%','abc','%') or status LIKE conat('%','abc','%') )
                .eqMulti('abc', Field.NAME, Field.STATUS);// 多字段or等于( name='abc' or status ='abc')

        //时间范围的查询,如果Field字段是Date日期,同时使用 大于, 小于等范围查询,则自动转为(yyyy-MM-dd HH:mm:ss)格式
        //传入值的格式支持各种形式
        //WHERE create_time >= '2020-01-01 00:00:00' and create_time <= '2020-12-31 11:59:59'
        Select.create(Select.create().gte(Field.CREATE_TIME, '2020-01-01').lte(Field.CREATE_TIME, '2020-12-31'));
        Select.create(Select.create().betweenDate(Field.CREATE_TIME, '2020-01-01', '2020-12-31'));//效果一样

        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("age", 1234); // age='1234'(默认转为下划线命名法)
        paramMap.put("status", Arrays.asList(1,2)); // acc_status in (0, 1) 自动变成in多个值查询
        Select.create(paramMap);

        Bean bean = new Bean()
                .setPageNum(1)
                .setPageSize(20)
                .setName("jack")
                .setStartTime("2021/01/01")
                .setEndTime("2021/10/01");
        //where name like ('%'||'jack'||'%') and create_time>='2021-01-01 00:00:00' and create_time<='2021-10-01 00:00:00' limit 20 //自动范围查询和分页查询
        Select.create(bean);

        //Where name='jack' and createTime>='2021-01-01 00:00:00' and create_time<='2021-10-01 00:00:00' limit 20
        Select.create().list(bean);//多用于列表页面分页模糊查询 String类型使用like其它类型使用 =


        //Where create_time>='2000-01-01 00:00:00' AND create_time<='2020-12-31 23:59:59' 
        Map map = new HashMap();
        map.put("startTime", "2000年");//bean有startTime属性则表示查询开始起始时间
        map.put("endTime", "2020");//bean有endTime属性则表示查询开始结束时间
        Select.create(map);

        Select.create(Field.STATUS, 0).orderDesc(Field.ID).limit(5);//status=0按Id倒序前5
        Select.create(Field.STATUS, 0).orderDesc(Field.ID).limitPage(2, 20); //status=0按Id倒序取第2页20条

        Select.create().eval("age = 18"); //注入sql查询语句, where age = 18
        Select.create().eval("{} = {}", "id", 100); //占位符形式, where id = 100
    }

    //只查询指定的单条字段
    public void selectField() {
        //SELECT id FROM user WHERE status = 0 Order By id desc Limit 5000
        List<Integer> ids = super.selectListByField(Field.ID, Select.create(Field.STATUS, 0));

        //SELECT id FROM user WHERE status = 0 Order By id desc Limit 1
        Integer id = super.selectOneByField(Field.ID, Select.create(Field.STATUS, 0));
    }

    //统计语句
    public void count() {
        //select count(1) from table_name where status = 0 查status=0有多少条记录
        Integer count = super.count(Select.create(Field.STATUS, 0));
        super.sum(select);//合计
        super.avg(select);//平均值
    }

    //分组group by统计语句
    public List<JavaBean> group() {
        //select date_format(create_time,'%Y-%m' as month,STATUS as status, count(ID) as countNum FROM table_name
        //where name = 'jack' group by month,status 
        //order by month having countNum > 0
        SelectGroup selectGroup = SelectGroup.create()
                .whereEq(Field.NAME, "jack")
                .field("date_format(create_time,'%Y-%m')", "month").field(Field.STATUS)
                .count(Field.id, "countNum")
                .orderDesc("month")
                .having("countNum > 0");
        return super.selectListGroup(selectGroup, JavaBean.class);
    }

    //自定义SQL查询语句
    public void getAgeByName(String name) {
        //默认按当前dao的方法名去查找mapper select id
        Map resultMap = super.selectOneMapperStatementByMethodName(name);
        List<Map> result1 = super.selectListMapperStatementByMethodName(name);
        //指定select id,不需要加namespace
        Map map2 = super.selectOneStatement("getAgeByName", name);
        List<Map> result2 = super.selectListStatement("getBalanceByAccountNo", accountNo);
    }

    public void insert() {
        Date now = new Date();
        //setUpdateTime,setCreateTime可不写,自动为当前时间
        User u = new User()
                .setName("1234")
                .setStatus(0)
                .setAge(18)
                .setCreateUser(当前操作userId) //可省略,
                .setUpdateTime(new Date()).setCreateTime(new Date());//可省略,自动会加createTime,updateTime
        super.insert(account1);

        //按id主键查询有则update,无则insert
        super.insertOrUpdate(u);

        //查询name='jack' 的记录,有则忽略,无则insert操作
        int insertResult = super.insertIfAbsent(u, Select.create(Field.NAME, "jack"));

        //查找account_no = '1234' 的记录,有则用bean去update这条记录,无则insert操作
        int insertResult1 = super.insertOrUpdate(u, Select.create(Field.NAME, "jack"));

        //批量新增
        List<User> list = Arrays.asList(new User(), new User(), new User());
        super.insertBatch(list);
        //批量新增 ,每100条做commit;
        super.insertBatch(list, 100);

        //手写sql,指定xml的insert id
        suer.insert("insertId", parameterObject);
    }

    //修改操作
    public void update() {
        Date now = new Date();
        User user = super.selectOne(1);
        user.setStatus(0);
        user.setUpdateTime(now);//可省略,自动设置当前时间
        super.update(user);

        Update u1 = Update.create()
                .whereEq(Field.NAME, "1234") // where account_no = '1234'
                .updateEq(Field.STATUS, 0) //acc_status=0
                .updateIncr(Field.AGE, 10)//age = age + 10 自增10
			    .updateReduction(Field.AGE, 10);//age = age - 10 自减10
        updateNum = super.update(u1);

        //update status = 0 Where id = 1;
        Update u2 = Update.create().updateEq(Field.STATUS, 0).whereEq(Field.ID, 1);
        int updateNum = super.update(u2);

    }

    public void delete() {
        super.delete(Select.create(Field.ID, 1));//按查询条件删除,同update一样,必有一个查询条件,不支持全表删除
        super.delete(Arrays.asList(1,2));//删除id in (1,2)

    }
}
```

account.xml 生成一个只有基本字段名的xml,用来写自定义sql,方便写sql复制字段名

```xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="user">
	<sql id="columns">
		t.ID  "id",
		t.NAME  "name",
		t.STATUS  "status",
		t.AGE  "age",
		t.CREATE_TIME  "createTime",
		t.UPDATE_TIME  "updateTime"
	</sql>

</mapper>
```

java po 实体bean

```java
public class User extends AbstractDomain {
	private Integer id;	//主键ID
	private String name;	//名称
	private Integer status;	//状态
	private BigDecimal balance;	//年纪
	private Date createTime;	//创建时间
	private Integer createUser;	//创建时间
	private Date updateTime;
	
	public User(){}
	public enum Field implements IField {//生成此处枚举,方便构造查询条件,代码联想功能
		ID,
		NAME,
		STATUS,
		AGE,
		CREATE_TIME,
		UPDATE_TIME;
	}
	
	public Integer getId() {return id;}
	public Account setId(Integer id) {this.id = id;return this;}

	//......省略其它get set
}
```