java nutz_NUTZ入门

最新推荐文章于 2024-04-06 09:36:40 发布

Darwin Lee

最新推荐文章于 2024-04-06 09:36:40 发布

阅读量478

点赞数

文章标签： java nutz

本文链接：https://blog.csdn.net/weixin_33270404/article/details/114120677

版权

一、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

nutz

org.nutz.mvc.NutFilter

modules

net.wendal.nutzbook.MainModule

nutz

配置主模块(相当于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;

}

//插入操作

Teacher t = new Teacher();

t.setName("teacher1");

t.setAge(24);

List 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 students;

}

@Table("tb_student_Course")

public class StudentCourse {

@Id

private int id;

@Column

private int studentId;

}

//插入操作

Course c = new Course();

c.setName("语文");

List 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 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: {