NUTZ入门

作者: 李中凯_f395 | 来源:发表于2019-04-08 17:00 被阅读0次

NUTZ入门
Nutz
kams quartz jdbc store定时任务
nutz实现文件上传
在nutz框架中使用javax.mail进行邮件的发送
[开源APP推荐] NutzCommunity – Nutz社区
SQL Server '@P0'附近有语法错误
org.nutz.dao.DaoException: org.n
web网页中主题切换的实现思路
入门级知识

一、ioc

相当于spirng中的ioc，spring中提供了xml与注解的方式加载bean，nutz中提供了json和注解的方式加载bean

1. 配置并获取bean

1.1 在resource目录下创建ioc目录，创建dao.js并配置

这里的date相当于spring中的bean的id,type相当于bean的class

var ioc = {
   date: {
    type: "java.util.Date"
  }
}

1.2 获取通过NutIoc获取bean

JsonLoader loader = new JsonLoader("ioc/");
NutIoc ioc = new NutIoc(loader);
Date date = ioc.get(Date.class);
System.out.println(date);
ioc.depose();//关闭ioc容器

2.使用工厂方法实例化

使用静态工厂方法

calendar: {
       type: "java.util.Calendar",
       factory: "java.util.Calendar#getInstance"
   }

使用实例工厂方法

calendar: {
       type: "java.util.Calendar",
       factory: "java.util.Calendar#getInstance"
   },
   date2: {
       factory: "$calendar#getTime"
   }

3.向构造方法中注入值

args值类型为一个数组，数组中可以传字符串或者bean，如果为bean，写法为[{refer: 'beanId'}]

agrs: ['arg']

4.属性中注入值

fields: {
  name: 'zhangsan'
}

5.事件监听

初始化、调用、销毁

events : {
        create : ... , // 创建完成后,各种属性已经设置好
        fetch  : ... , // 每次从ioc取出
        depose : ...   // ioc容器销毁前,一般用于清理各种资源
}

6.是否单例

singleton : false//默认是单例，如果指定为原型，则容器不会调用depose方法

7.使用注解的方式

7.1配置注解加载器

AnnotationIocLoader loader = new AnnotationIocLoader("com.zbrx.nutz");
NutIoc ioc = new NutIoc(loader);
User user = ioc.get(User.class);
System.out.println(user);

7.2配置bean

可以通过@IocBean(name="user")的方式指定bean的id，默认为首字母小写

package com.zbrx.nutz.bean;
import org.nutz.ioc.loader.annotation.IocBean;
@IocBean
public class User {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

7.3注解中配置其他信息

 @IocBean(name="user", singleton=true, create="init", depose="distory" ,
    args={"a string", "refer:anotherObject", true, 234} ...)

7.4为属性注入值

@Inject先按照名字找，再按照类型找，也可以手动指定名字
例:@Inject("user")或@Inject("refer:user")

@Inject
private User user;

8.复合加载器

如何参数是以号开头，则是加载器类型，后面的参数为这个加载器的构造函数参数，直到遇到下一个号开头的参数
也可以用简写的形式来定义,如*js, *anno

ComboIocLoader loader = new ComboIocLoader(new String[]{
  "*org.nutz.ioc.loader.json.JsonLoader", "ioc/",
  "*org.nutz.ioc.loader.annotation.AnnotationIocLoader", "com.zbrx.nutz"
});

二、mvc

配置web.xml

<filter>
  <filter-name>nutz</filter-name>
  <filter-class>org.nutz.mvc.NutFilter</filter-class>
  <init-param>
    <param-name>modules</param-name>
    <param-value>net.wendal.nutzbook.MainModule</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>nutz</filter-name>
  <url-pattern>/*</url-pattern>
</filter-mapping>

配置主模块(相当于spring中配置xml的位置，nutz是用java编码的方式)

package net.wendal.nutzbook.;

import org.apache.commons.dbcp.BasicDataSource;
import org.nutz.mvc.annotation.*;
import org.nutz.mvc.ioc.provider.ComboIocProvider;

//开启注解扫描
@Modules(scanPackage = true)
@Ok("json")//方法正常返回格式
@Fail("json")//方法错误返回格式
@IocBy(type= ComboIocProvider.class, args = {
  "*org.nutz.ioc.loader.json.JsonLoader", "ioc/",
  "*org.nutz.ioc.loader.annotation.AnnotationIocLoader", "com.zbrx.nutz"
})//设置ioc容器
public class MainModule {

}

添加入口函数

只要添加了@At注解方法是非静态public的即为入口函数。
在入口函数上可以使用的注解有：
@Ok//成功视图
@Fail//失败视图
@At//入口函数对应的url,相当于spring中的RequestMapping

接收请求参数

入口参数使用@Param("name")String name，
如果是对象，可以使用@Param("..")Pet pet
如果请求参数名与方法参数名一致，可以省略@Param

接收属性参数

入口参数使用@Attr("user")User user，获取request、session中的属性值，相当于request.getAttribute("user");

返回视图

@Ok(">>:/user/login")//重定向，等同于@Ok("redirect:/user/login")
@Ok("->:/user/index")//转发，等同于@Ok("forward:/user/index")
@Ok("jsp:/user/index.jsp")同上
@Ok("json")//返回json字符串
@Ok("raw:png")//返回文件
@Ok("re")//根据返回值来确定
if (...)
return ">>:/user/login.html";
else
return "jsp:jsp.user.home";
如果需要传值，在方法参数列表中加入ViewModel即可

由ioc容器管理mvc

在MainModule上指定
@IocBy(args={
"js", "ioc/",
"anno", "..."//这里需要注解扫描的类路劲
})

三、Dao

创建java实体

@Table("tb_person")//这里对应数据库表名
public class Person{
  @Id//表示该字段为一个自增长的Id,注意,是数据库表中自增!!
  private int id;
  @Name//表示该字段可以用来标识此对象，或者是字符型主键，或者是唯一性约束
  private String name;
   @Column// 表示该对象属性可以映射到数据库里作为一个字段
  private int age;
  ...//省略get/set方法
}

Dao常用操作

数据库表操作

1.建表

dao.create(Person.class, false);//这里的false表示如果该表存在，不删除

//扫描@Table注解并自动建表
//第二个参数为包名，第三个参数表示，如果存在，是否删除
Daos.createTablesInPackage(dao, "net.nutz", false);

2.删除表

dao.drop(Person.class);//连同数据一块删除

记录操作

1.插入一条记录

//插入一条数据并返回id值
Person person = new Person();
person.setName("张三");
person.setAge(23);
dao.insert(person);
System.out.println(person.getId());

//插入数据不返回id
dao.fastInsert(person);

2.取出一条数据

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

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

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

3.更新一条或多条数据

Person p = dao.fetch(Person.class, 1);
p.setAge(18);
dao.update(p);

dao.update(list);//更新一个集合

4.删除数据

//删除一条数据
dao.delete(person);//按照对象删除
dao.delete(Person.class, 1);//按照id删除
dao.delete(Person.class, "张三");//按照名字删除
dao.delete(list);//删除集合

//删除表中所有数据
dao.clear(Person.class);

//按照条件删除数据
dao.clear(Person.class, Cnd.where("age", ">", "18"));

5.查询数据

//查询全部
dao.query(Person.class, null);

//按照条件查询
dao.query(Person.class, Cnd.where("age", ">", "18"));

//分页查询
Pager page = dao.createPager(2, 10);
dao.query(Person.class, Cnd.where("age", ">", "18"), page);

6.聚合函数的操作

dao.func(Person.class, "min", "age");

7.字段过滤

/** 只操作某些字段，如下即只插入name字段，其他操作同样 */
FieldFilter ff = FieldFilter.create(User.class, "^name$");
  ff.run(new Atom() {
    @Override
    public void run() {
      //只插入name字段
      User u = new User();
      u.setPassword("123456");
      u.setName("lisi");
      dao.insert(u);
    }
});

//或者
User u = new User();
u.setPassword("123456");
u.setName("lisi");
dao = Daos.ext(dao, FieldFilter.create(User.class, "^name$"));
dao.insert(u);

8.一对一关系映射

我们习惯在userInfo表中定义userId，这里正好相反

/* user.id=userInfo.userId */


@Table("tb_user")
public class User {
  @Id
  private int id;
  @Column
  private String name;
  @Column
  private String password;
  private int userInfoId;
  @One(field="userInfoId")
  private UserInfo userInfo;
  ...//省略get set
}

@Table("tb_user_info")
public class UserInfo {
  @Id
  private int id;
  @Column
  private String phone;
  ...//省略getset
}

//插入操作
User u = new User();
u.setName("zhangsan");
u.setPassword("123456");
UserInfo userInfo = new UserInfo();
userInfo.setPhone("18511558240");
u.setUserInfo(userInfo);
dao.insertWith(u, "userInfo");

//获取操作
User user = dao.fetch(User.class, 1);
user = dao.fetchLinks(user, "userInfo");
System.out.println(user.getUserInfo().getPhone());

//更新操作
dao.updateWith(user, "userInfo");

//删除操作
dao.deleteWith(user, "userInfo");
//删除userInfo
dao.deleteLinks(user, "userInfo");//调用dao.delete挨个删除
dao.clearLinks(user, "userInfo");//一条sql语句删除

9.一对多关系映射

@Table("tb_student")
public class Student {
  @Id
  private int id;
  @Column
  private String name;
  @Column
  private int age;
  @Column
  private int teacherId;
}

@Table("tb_thecher")
public class Teacher {
  @Id
  private int id;
  @Column
  private String name;
  @Column
  private int age;
  @Many(field = "teacherId")
  private List<Student> student;
}

//插入操作
Teacher t = new Teacher();
t.setName("teacher1");
t.setAge(24);
List<Student> list = new ArrayList<>();
for(int i=0; i<10; i++) {
  Student s = new Student();
  s.setName("stu"+i);
  s.setAge(18);
  list.add(s);
}
t.setStudent(list);
dao.insertWith(t, "student");

//查询操作，其他操作同一对一使用方法相同
Teacher t1 = dao.fetch(Teacher.class, 1);
dao.fetchLinks(t1, "student");
System.out.println(t1.getStudent().get(0).getName());

10.多对多关系映射

@Table("tb_student")
public class Student {
  @Id
  private int id;
  @Column
  private String name;
  @Column
  private int age;
  @Column
  private int teacherId;
}

@Table("tb_course")
public class Course {
  @Id
  private int id;
  @Column
  private String name;
  @ManyMany(relation = "tb_student_course", from = "courseId", to = "studentId")
  private List<Student> students;
}

@Table("tb_student_Course")
public class StudentCourse {
  @Id
  private int id;
  @Column
  private int studentId;
}

//插入操作
Course c = new Course();
c.setName("语文");
List<Student> list = new ArrayList<>();
for(int i=0; i<10; i++) {
  Student s = new Student();
  s.setName("课程"+i);
·s.setAge(18);
·list.add(s);
}
c.setStudents(list);
dao.insertWith(c, "students");
//其他操作同上

11.自定义sql

使用外部文件sql

//加载sql文件
((NutDao)dao).setSqlManager(new FileSqlManager("sql/"));
Sql sql = dao.sqls().create("select.findAll");
//这里需要注意的是，如果返回一个指定entity的list集合，请使用entities()方法。
//或者可以直接写sql
//Sql sql = Sqls.create("select * from tb_user");

//使用回调函数并指定返回类型
sql.setCallback(Sqls.callback.entities());
//设置返回类型实体
sql.setEntity(dao.getEntity(User.class));
//执行sql
dao.execute(sql);
List<User> list = sql.getList(User.class);
System.out.println(list);

user.sqls

/* select.findAll */
select * from tb_user

如果要加参数，在sql文件中用"$名称"和"@名称"的方式来赋值

DELETE FROM $table WHERE name=@name

变量(var)占位符 - 形式为 $名称，是将值直接替换，
赋值方式：sql.vars().set("table","t_abc");
参数(param)占位符 - 形式为 @名称，使用"?"来替换，用来创建 PreparedStatement
赋值方式：sql.params().set("name","Peter");

使用条件占位符

Sql sql = Sqls.create("SELECT name FROM tb_user $condition");
sql.setCondition(Cnd.where("id", ">", 35));

分页

Sql sql = Sqls.queryEntity("SELECT * FROM t_pet");
sql.setPager(dao.createPager(2,20));
sql.setEntity(dao.getEntity(Pet.class));
dao.execute(sql);
sql.getList(Pet.class);

12.如何开启事务

final User user1 = dao.fetch(User.class, 1);
final User user2 = dao.fetch(User.class, 2);
user1.setName("zhangsan");
user2.setName("lisi");
//开启事务
Trans.exec(new Atom(){
  public void run() {
    dao.update(user1);
    dao.update(user2);
  }
});
//关闭事务

可以接受多个Atom作为参数
public static void exec(Atom... atoms);

四、过滤器

内置过滤器，可以加在主模块、子模块、入口函数上

nutz提供了一个内置过滤器CheckSession ，它的构造函数需要两个参数
1.检查session什么属性
2.如果不存在，重定向到哪里

@Filters(@By(type=CheckSession.class, args={"user", "/login.jsp"}))

自定义过滤器

实现ActionFilter接口即可
1.ActionFilter : 返回null即为通过，返回view对象，则表示拦截
如果同时实现AbstractProcessor 接口，通过doNext(ac)继续执行，具有环绕功能

五、应用启动或者关闭时额外处理

1.实现接口Setup
2.主模块类上添加@SetupBy(MainSetup.class)

使用Setup实现自动创建表

public class MainSetup implements Setup {
  @Override
  public void init(NutConfig config) {
    //获取ioc容器,从容器中获取dao
    Dao dao = config.getIoc().get(Dao.class);
    // 拿到Dao,自然就可以自动建表了
    Daos.createTableInPackage(dao, "net.wendal.nutzbook.bean", false);
    // 表结构变化了? migration一下
    Daos.migration(dao, "net.wendal.nutzbook.bean", true, false);
  }
  @Override
  public void destroy(NutConfig nutConfig) {
  }
}

六、异步执行
@Async
方法上加入该注解表明该方法时异步的。
七、AOP

声明aop类

@IocBean
public class TestAop implements MethodInterceptor {
    @Override
    public void filter(InterceptorChain chain) throws Throwable {
        System.out.println("执行前");
        chain.doChain();
        System.out.println("执行后");
    }
}

使用aop

@At("/ping")
@Aop("testAop")
public String ping(String name) {
  System.out.println("执行ping方法");
  return "success";
}

json方式声明aop

var ioc = {
    txNONE: {
        type: "org.nutz.aop.interceptor.TransactionInterceptor",
        args: [0]
    },
    txREAD_UNCOMMITTED: {
        type: "org.nutz.aop.interceptor.TransactionInterceptor",
        args: [1]
    },
    txREAD_COMMITTED: {
        type: "org.nutz.aop.interceptor.TransactionInterceptor",
        args: [2]
    },
    txREPEATABLE_READ: {
        type: "org.nutz.aop.interceptor.TransactionInterceptor",
        args: [4]
    },
    txSERIALIZABLE: {
        type: "org.nutz.aop.interceptor.TransactionInterceptor",
        args: [8]
    },
    log: {
        type: "org.nutz.aop.interceptor.LoggingMethodInterceptor"
    },
    $aop : {
        type : 'org.nutz.ioc.aop.config.impl.ComboAopConfigration',
        fields: {
            aopConfigrations: [
                {
                    type: "org.nutz.ioc.aop.config.impl.JsonAopConfigration",
                    fields : {
                        itemList : [
                            ['com\\.zbrx\\.nutz\\..+','.+','ioc:log'],
                            ['com\\.zbrx\\.nutz\\..+','.+','ioc:txSERIALIZABLE']
                        ]
                    }
                },
                {
                    type: "org.nutz.ioc.aop.config.impl.AnnotationAopConfigration"
                }
            ]
        }
    }
};

NUTZ入门
一、ioc 相当于spirng中的ioc，spring中提供了xml与注解的方式加载bean，nutz中提供了js...
Nutz
自定义Sql + 拼接查询条件 + 分页
kams quartz jdbc store定时任务
1.引入nutz-integration-quartz插件 2.在resources目录下加入quartz.pro...
nutz实现文件上传
目前需要实现一个文件上传的功能，由于后台使用了nutz这个框架，所有实现的文件上传跟spring mvc有所不同，...
在nutz框架中使用javax.mail进行邮件的发送
使用nutz+javax.mail来进行简单的邮件发送操作，没有包含附件的操作，测试的邮箱是公司的邮箱，建议使用网...
[开源APP推荐] NutzCommunity – Nutz社区
Nutz社区iOS客户端, 方便Nutzer 在社区交流. 1. 支持横屏查看话题 2. 支持代码块字体缩放 3....
SQL Server '@P0'附近有语法错误
最近在用Nutz开发项目，在一次执行自定义分页的SQL时出现错误，截取部分报错信息如下：执行的SQL如下：后来...
org.nutz.dao.DaoException: org.n
Model.java bean controller 执行结果由于controller中catch异常，我直接打...
web网页中主题切换的实现思路
网页中切换主题，实际上就是在对网页中的元素设置不同的样式所呈现出来的整体显示效果的切换比如上图中nutz官网可以...
入门级知识
入门知识_1 入门知识_2 入门知识_3 入门知识4