简单使用Nutz

环境准备

Maven依赖

<!--Springboot整合Nutz-->
<dependency>
    <groupId>org.nutz</groupId>
    <artifactId>nutz-plugins-spring-boot-starter</artifactId>
    <version>1.r.66</version>
</dependency>
<!--阿里的数据连接池-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>
<!--数据库驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <scope>runtime</scope>
</dependency>

application

yml

spring:
  datasource:
    username: root
    password: root
    #加入时区报错，就增加一个时区的配置就ok了===serverTimezone=UTC
    url: jdbc:mysql://localhost:3306/nutzdemo?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
    #com.mysql.jdbc.Driver===5版本的数据库
    #com.mysql.cj.jdbc.Driver===8版本以上的数据库
    driver-class-name: com.mysql.cj.jdbc.Driver
    #指定druid德鲁伊数据源
    type: com.alibaba.druid.pool.DruidDataSource
nutz:
  json:
    auto-unicode: false
    quote-name: true
    ignore-null: true
    null-as-emtry: true
    enabled: true
    mode: compact
  dao:
    runtime:
      create: true #自动创建表
      migration: false #根据bena自动更新表结构
      basepackage: com.chuang.qywxweichuang.pojo  #扫描bean
    sqlmanager:
      paths:

Config

import org.nutz.dao.Dao;
import org.nutz.dao.impl.NutDao;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import javax.sql.DataSource;

@Configuration
public class DaoConfiguration {

    @Bean
    @Primary
    public Dao getDao(DataSource dataSource) {
        // 创建一个NutDao实例,在真实项目中, NutDao通常由ioc托管, 使用注入的方式获得.
        Dao dao = new NutDao(dataSource);
        return dao;
    }
}

实体类

import org.nutz.dao.entity.annotation.*;

@Table("t_person")   // 声明了Person对象的数据表
public class Person { // 不会强制要求继承某个类
    @Id       // 表示该字段为一个自增长的Id,注意,是数据库表中自增!!
    private int id; // @Id与属性名称id没有对应关系.

    @Name    // 表示该字段可以用来标识此对象，或者是字符型主键，或者是唯一性约束
    private String name;

    @Column      // 表示该对象属性可以映射到数据库里作为一个字段
    private int age;
    //省略get、set

测试类

import com.chuang.qywxweichuang.pojo.Person;
import org.junit.jupiter.api.Test;
import org.nutz.dao.Dao;
import org.nutz.dao.impl.NutDao;
import org.nutz.dao.impl.SimpleDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class QywxweichuangApplicationTests {
    // 创建一个NutDao实例,在真实项目中, NutDao通常由ioc托管, 使用注入的方式获得.
    @Autowired
    private Dao dao;
    @Test
    void contextLoads() {
        // 创建表
        dao.create(Person.class,false);// false的含义是,如果表已经存在,就不要删除重建了.
        Person person = new Person();
        person.setName("ABC");
        person.setAge(20);
        dao.insert(person);
        System.out.println(person.getId());
    }
}

表操作

创建表

// 创建表===第一个参数是Pojo类, 第二个参数是如果表存在,是不是先删再重新建,否则就是保持原样
// false的含义是,如果表已经存在,就不要删除重建了.
Person p = new Person();
dao.create(Person.class,false);
Person p = new Person();
person.setName("ABC");
person.setAge(20);
dao.insert(p);

删除表

//全部删掉哦,没条件的,慎用!!
dao.drop(Pet.class);

数据操作

插入 Insert

Person p = new Person();
p.setAge(22);
p.setName("老王"+i);
Person insert = dao.insert(p);
System.out.println("插入的数据======="+insert);

删除 Delete

直接删对象

dao.delete(pet); // Pet必须带@Id/@Name/@Pk中的一种或多种

根据名称删除

（如果你的实体声明了 @Name 字段）. 批量删除请用clear

dao.delete(Person.class,"Peter");

根据 ID 删除

（如果你的实体声明了 @Id 字段）

dao.delete(Person.class,2);

直接删列表

如果要按条件删,用dao.clear

dao.delete(list);

更新 Update

Person p = dao.fetch(Person.class,1);
p.setName("老李");
dao.update(p,"^name$");//仅更新name,参数是个正则表达式
// 注意, p至少带@Id/@Name/@Pk中的一种
dao.update(list, "^name$"); //更新一个集合也是可以的

更新多条

// 根据特定条件更新特定字段
dao.update(Person.class, Chain.make("dead",true), Cnd.where("age",">",150));
// 常用的+1更新
dao.update(Person.class, Chain.makeSpecial("age", "+1").add("location", "yvr"), Cnd.where("name","=", "wendal"));

插入和更新集合

无论是插入 (Insert) 还是更新 (Update)，你传入的对象都可以不仅仅是一个 POJO，你可以传入：

• 集合 ( Collection<?> )
• Map<?,?>
• 数组 ( T[] )

Nutz.Dao 会自动替你拆包，对集合成员依次执行相应操作。 对于 Map，它会迭代每一个值。

清除 Clear

清除所有记录

dao.clear(Person.class); //还是那句,慎用

按条件清除

dao.clear(Person.class,Cnd.where("id", ">", 35));

函数操作(func)

整数类型. 例如调用sum

//age总和
int func = dao.func(Person.class, "sum", "age");
System.out.println("sum==========="+func);
//sum===========2254

其他类型

Object func2 = dao.func2(Person.class, "min", "name");
System.out.println("min==========="+func2);

查询 Query

根据名称获取

//根据名称获取 （如果你的实体声明了 @Name 字段, 字符型主键,或者带唯一性索引的字段
Person p = dao.fetch(Person.class,"老王");
System.out.println("fetch========="+p);

根据 ID 获取

//根据 ID 获取 （如果你的实体声明了 @Id 字段, 数值型主键）
Person p = dao.fetch(Person.class,2);
System.out.println(p.getName());

@Id和@Name可以同时存在于一个Pojo类内,但不允许标注在同一个属性,毕竟不可以同时是数值型主键又是字符型主键

查询全部记录

List<Person> people = dao.query(Person.class, null);

按条件查询

List<Person> people = dao.query(Person.class, Cnd.where("name", "like", "P%"));

分页简单查询

//dao.createPager 第一个参数是第几页，第二参数是一页有多少条记录
List<Person> people = dao.query(Person.class, Cnd.where("age", ">", 18), dao.createPager(2, 4));

复杂的SQL条件

一个友好的工具类 – Cnd

它的设计初衷就是 “查询条件应该一行搞定”。

Cnd.where() 方法

Condition c = Cnd.where("age",">",30).and("name", "LIKE", "%K%").asc("name").desc("id");
//这个条件将生成 SQL
//WHERE age>30 AND name LIKE '%K%' ORDERBY name ASC, id DESC

你也可以嵌套表达式

SqlExpressionGroup e1 = Cnd.exps("name", "LIKE", "P%").and("age", ">", "20");
SqlExpressionGroup e2 = Cnd.exps("name", "LIKE", "S%").and("age", "<", "30");
Condition c = Cnd.where(e1).or(e2).asc("name");
//这个条件将生成 SQL
WHERE (name LIKE 'P%' AND age>'20') OR (name LIKE 'S%' AND age<'30') ORDER BY name ASC

拼装更加复杂的条件

一行确实搞不定，怎么办？

Nutz-1.b.38 以后，提供了 Criteria 接口，它继承自 Condition 接口

// 创建一个 Criteria 接口实例
Criteria cri = Cnd.cri();
// 组装条件
if(...){
    //andIn相当于SQL语句中的and+in
    cri.where().andIn("id", 3,4,5).andIn("name", "Peter", "Wendal", "Juqkai");
}else if(...){
    //andLT相当于SQL语句中的and+小于<
    cri.where().andLT("id", 9);
}else if(...){
    //andInBySql
    cri.where().andInBySql("关联字段","select id from 关联表 where name = '%s'",变量);
}else if(...){
    cri.where().andInBySql("关联字段","select id from 关联表 where name like '%%%s%%'",变量);
}

if(...){
    cri.where().andLike("name", "%A%");
}

cri.getOrderBy().asc("name").desc("id");

// 执行查询
List<MyObj> list = dao.query(MyObj.class, cri, null);

• LT : 小于 (LessThan)
• GTE : 大于等于 (GreatThanEqual)
• LTE : 小于等于 (LessThanEqual)