`
pangwu86
  • 浏览: 117782 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Nutz+ExtJS示例教程——后台Service实现

    博客分类:
  • nutz
阅读更多

 

 

后台的结构图如下:

 

 

这里是模仿了SSH的组织方式,因为毕竟大部分是学SSH过来的(ME也是其中之一),变化太大可能会有理解上的困难。

 

这里的Dao层被去掉了,因为Nutz本身提供的NutzDao就提供了基本的增删改查操作,因此这层可以去掉了,直接并入到Service层中。

 

接下来,先写model层,就是对于数据库表的JavaBean

详细步骤请参照Nutz 的文档Dao手册这部分:http://code.google.com/p/nutz/wiki/dao_hello

 

以User举例,其他模块类似

 

User类:

 

package org.nutz.demo.model;

import java.util.List;

import org.nutz.dao.entity.annotation.Column;
import org.nutz.dao.entity.annotation.Many;
import org.nutz.dao.entity.annotation.Table;

/**
 * 用户。
 * 
 * @author pangwu86@gmail.com
 * 
 */
@Table("t_user")
public class User extends Identity {

	@Column()
	private String userName;

	@Column()
	private String password;

	@Column()
	private String userType;

	@Many(target = ContactType.class, field = "userId")
	private List<ContactType> contactTypes;

	@Many(target = Contact.class, field = "userId")
	private List<Contact> contacts;

	@Many(target = Blog.class, field = "userId")
	private List<Blog> blogs;

	//  这里省略了get与set

}

 

要注意的是,不要忘了加Nutz的注释,同时如果字段与表中列名称有出入的话,要写入@Column("表列名")中,替换掉默认值。

 

下面开始写Service层共通的类,所有的Service都要继承这个基类,就可以实现增删改查的操作了。

 

这里对于增删改三项(查询操作的返回值就是查询的结果集,没有封装的必要)操作的返回值,做了一个简单的封装,其中包含了一部分业务信息,用一个枚举类型代替默认的返回值。

 

DbOperationResultEnum :

package org.nutz.demo.util.database;

/**
 * 封装了各种数据库操作结果。
 * 
 * @author pangwu86@gmail.com
 * 
 */
public enum DbOperationResultEnum {

	OPERATION_SUCCESS(true, "操作成功。"),

	OPERATION_FAILURE(false, "操作失败。"),

	INSERT_SUCCESS(true, "插入成功。"),

	INSERT_FAILURE(false, "插入失败。"),

	UPDATE_SUCCESS(true, "更新成功。"),

	UPDATE_FAILURE(false, "更新失败。"),

	DELETE_SUCCESS(true, "删除成功。"),

	DELETE_FAILURE(false, "删除失败,数据可能被引用,请先删引用关系。"),

	CLEAR_SUCCESS(true, "批量删除成功。"),

	CLEAR_FAILURE(false, "批量删除失败,数据可能被引用,请先删引用关系。");

	private boolean success;

	private String msg;

	private DbOperationResultEnum(boolean success, String msg) {
		this.success = success;
		this.msg = msg;
	}

	public boolean isSuccess() {
		return success;
	}

	public String getMsg() {
		return msg;
	}
}
 

BaseService:

package org.nutz.demo.service;

import java.util.List;

import org.nutz.dao.Chain;
import org.nutz.dao.Condition;
import org.nutz.dao.QueryResult;
import org.nutz.dao.sql.Sql;
import org.nutz.demo.util.database.DbOperationResultEnum;

/**
 * CRUD基本操作。<br>
 * 基于泛型类。
 * 
 * @author pangwu86@gmail.com
 * 
 * @param <T>
 *            实体类类型
 */
public interface BaseService<T> {

	/**
	 * 从配置SQL文件中取得SQL文。
	 * 
	 * @param key
	 * @return
	 */
	public Sql createSql(String key);

	/**
	 * 直接执行一组SQL语句。
	 * 
	 * @param sqls
	 * @return
	 */
	public boolean execute(Sql... sqls);

	/**
	 * 通用查询。(无分页)
	 * 
	 * @param cdn
	 * @return
	 */
	public List<T> query(Condition cdn);

	/**
	 * 通用查询。(带分页信息)
	 * 
	 * @param cdn
	 * @param pageNumber
	 * @param pageSize
	 * @return
	 */
	public QueryResult query(Condition cdn, int pageNumber, int pageSize);

	/**
	 * 通用获取,对象中引用的对象。(根据正则匹配)
	 * 
	 * @param obj
	 * @param regex
	 * @return
	 */
	public T fetchLinks(T obj, String regex);

	/**
	 * 通用获取。(根据条件)
	 * 
	 * @param cdn
	 * @return
	 */
	public T fetch(Condition cdn);

	/**
	 * 通用获取。(根据id)
	 * 
	 * @param id
	 * @return
	 */
	public T fetch(long id);

	/**
	 * 通用获取。(根据name)
	 * 
	 * @param name
	 * @return
	 */
	public T fetch(String name);

	/**
	 * 通用删除。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum delete(T entity);

	/**
	 * 通用插入。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum insert(T entity);

	/**
	 * 通用更新。(根据条件)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum update(Condition cnd, Chain chain);

	/**
	 * 通用更新。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum update(T entity);

	/**
	 * 通用批量删除。(删除全部)
	 * 
	 * @return
	 */
	public DbOperationResultEnum clear();

	/**
	 * 通用批量删除。(根据条件删除)
	 * 
	 * @param cdn
	 * @return
	 */
	public DbOperationResultEnum clear(Condition cdn);

	/**
	 * 返回该Service使用的实体类类型。
	 * 
	 * @return
	 */
	public Class<T> getEntryClz();

}

其中的方法可以根据你的需求再自行添加。

 

 

这里写到后来才发现,BaseService这个基类中的功能与Nutzorg.nutz.service 包下的几个类,EntityService,IdEntityServiceNameEntityService提供的功能相似

 

大家可以根据情况直接使用Nutz提供的,或作为参考,根据自身情况写出更符合自己使用习惯的共通类,来进行复用。

 

 

下面是BaseService的实现类:

package org.nutz.demo.service.impl;

import java.util.List;

import org.nutz.dao.Chain;
import org.nutz.dao.Condition;
import org.nutz.dao.Dao;
import org.nutz.dao.QueryResult;
import org.nutz.dao.impl.NutDao;
import org.nutz.dao.pager.Pager;
import org.nutz.dao.sql.Sql;
import org.nutz.demo.exception.BizException;
import org.nutz.demo.service.BaseService;
import org.nutz.demo.util.DaoUtil;
import org.nutz.demo.util.database.DSConfig;
import org.nutz.demo.util.database.DbOperationResultEnum;
import org.nutz.lang.Mirror;
import org.nutz.log.Log;
import org.nutz.log.Logs;

/**
 * 通用操作 实现。<br>
 * 
 * @author pangwu86@gmail.com
 * 
 */
public abstract class BaseServiceImpl<T> implements BaseService<T> {

	protected Log logger = Logs.getLog(getClass());

	private Mirror<T> mirror;

	@SuppressWarnings("unchecked")
	public BaseServiceImpl() {
		// 尝试获得泛型的类型
		try {
			Class<T> entryClass = (Class<T>) Mirror.getTypeParam(getClass(), 0);
			mirror = Mirror.me(entryClass);
			if (logger.isDebugEnabled())
				logger.debugf("获得泛型的实际类型: %s", entryClass.getName());
		} catch (Throwable e) {
			if (logger.isWarnEnabled())
				logger.warn("!!!无法获得泛型类型!", e);
			throw new RuntimeException(e);
		}
	}

	/**
	 * 方便的提供上层Dao。
	 * 
	 * @return
	 */
	public NutDao getDao() {
		return DaoUtil.getDao();
	}

	/**
	 * 方便的提供上层Dao。
	 * 
	 * @param dbConfig
	 * @return
	 */
	public NutDao getDao(DSConfig dbConfig) {
		return DaoUtil.getDao(dbConfig);
	}

	/**
	 * 获得当前泛型类型。
	 * 
	 * @return
	 */
	public Class<T> getEntryClz() {
		return mirror.getType();
	}

	/**
	 * 从配置SQL文件中取得SQL文。
	 * 
	 * @param key
	 * @return
	 */
	public Sql createSql(String key) {
		return DaoUtil.getSQLDao().sqls().create(key);
	}

	/**
	 * 直接执行一组SQL语句。
	 * 
	 * @param sqls
	 */
	public boolean execute(Sql... sqls) {
		try {
			DaoUtil.getDao().execute(sqls);
			return true;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("批量执行SQL语句报错。", e);
			}
			throw new RuntimeException(e);
		}
	}

	/**
	 * 通用查询。(无分页)
	 * 
	 * @param cdn
	 * @return
	 */
	public List<T> query(Condition cdn) {
		return DaoUtil.getDao().query(getEntryClz(), cdn, null);
	}

	/**
	 * 通用查询。(带分页信息)
	 * 
	 * @param cdn
	 * @param pageNumber
	 * @param pageSize
	 * @return
	 */
	public QueryResult query(Condition cdn, int pageNumber, int pageSize) {
		Dao dao = DaoUtil.getDao();
		Pager pager = dao.createPager(pageNumber, pageSize);
		List<T> list = dao.query(getEntryClz(), cdn, pager);
		if (null != pager) {
			pager.setRecordCount(dao.count(getEntryClz(), cdn));
		}
		return new QueryResult(list, pager);
	}

	/**
	 * 通用获取,对象中引用的对象。(根据正则匹配)
	 * 
	 * @param obj
	 * @param regex
	 * @return
	 */
	public T fetchLinks(T obj, String regex) {
		return DaoUtil.getDao().fetchLinks(obj, regex);
	}

	/**
	 * 通用获取。(根据条件)
	 * 
	 * @param cdn
	 * @return
	 */
	public T fetch(Condition cdn) {
		return DaoUtil.getDao().fetch(getEntryClz(), cdn);
	}

	/**
	 * 通用获取。(根据id)
	 * 
	 * @param id
	 * @return
	 */
	public T fetch(long id) {
		return DaoUtil.getDao().fetch(getEntryClz(), id);
	}

	/**
	 * 通用获取。(根据name)
	 * 
	 * @param name
	 * @return
	 */
	public T fetch(String name) {
		return DaoUtil.getDao().fetch(getEntryClz(), name);
	}

	/**
	 * 通用删除。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum delete(T entity) {
		try {
			return 1 == DaoUtil.getDao().delete(entity) ? DbOperationResultEnum.DELETE_SUCCESS
					: DbOperationResultEnum.DELETE_FAILURE;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("删除数据出错。", e);
			}
			throw new BizException(DbOperationResultEnum.DELETE_FAILURE, e);
		}
	}

	/**
	 * 通用插入。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum insert(T entity) {
		try {
			DaoUtil.getDao().insert(entity);
			return DbOperationResultEnum.INSERT_SUCCESS;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("插入数据出错。", e);
			}
			throw new BizException(DbOperationResultEnum.INSERT_FAILURE, e);
		}
	}

	/**
	 * 通用更新。(根据条件)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum update(Condition cnd, Chain chain) {
		try {
			return DaoUtil.getDao().update(getEntryClz(), chain, cnd) >= 0 ? DbOperationResultEnum.UPDATE_SUCCESS
					: DbOperationResultEnum.UPDATE_FAILURE;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("更新数据出错。", e);
			}
			throw new BizException(DbOperationResultEnum.UPDATE_FAILURE, e);
		}
	}

	/**
	 * 通用更新。(根据实体)
	 * 
	 * @param entity
	 * @return
	 */
	public DbOperationResultEnum update(T entity) {
		try {
			return 1 == DaoUtil.getDao().update(entity) ? DbOperationResultEnum.UPDATE_SUCCESS
					: DbOperationResultEnum.UPDATE_FAILURE;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("更新数据出错。", e);
			}
			throw new BizException(DbOperationResultEnum.UPDATE_FAILURE, e);
		}
	}

	/**
	 * 通用批量删除。(删除全部)
	 * 
	 * @return
	 */
	public DbOperationResultEnum clear() {
		return clear(null);
	}

	/**
	 * 通用批量删除。(根据条件删除)
	 * 
	 * @param cdn
	 * @return
	 */
	public DbOperationResultEnum clear(Condition cdn) {
		try {
			return DaoUtil.getDao().clear(getEntryClz(), cdn) >= 0 ? DbOperationResultEnum.CLEAR_SUCCESS
					: DbOperationResultEnum.CLEAR_FAILURE;
		} catch (Throwable e) {
			if (logger.isErrorEnabled()) {
				logger.error("批量删除数据出错。", e);
			}
			throw new BizException(DbOperationResultEnum.CLEAR_FAILURE, e);
		}
	}
}

其中导入的几个新类要简单介绍下:

 

DaoUtil类:

 

package org.nutz.demo.util;

import org.nutz.dao.impl.FileSqlManager;
import org.nutz.dao.impl.NutDao;
import org.nutz.demo.util.database.DSConfig;
import org.nutz.demo.util.database.DSContainer;
import org.nutz.demo.util.database.DSUtil;
import org.nutz.log.Log;
import org.nutz.log.Logs;

/**
 * DAO层切换类。
 * 
 * @author pangwu86@gmail.com
 * 
 */
public abstract class DaoUtil {

	protected static Log logger = Logs.getLog(DaoUtil.class);

	private static NutDao sqlDao = new NutDao();

	private static NutDao defaultDao = new NutDao(DSContainer.getDataSource(DSUtil
			.getDefaultDSConfig()));

	/**
	 * 加载配置SQL
	 */
	static {
		sqlDao.setSqlManager(new FileSqlManager("/config/sql"));
		if (logger.isDebugEnabled()) {
			logger.debugf("加载SQL配置文件成功,共%s条", sqlDao.sqls().count());
			for (String key : sqlDao.sqls().keys()) {
				String sql = sqlDao.sqls().get(key);
				logger.debugf("Key: %s Value: %s", key, sql);
			}
		}
	}

	public static NutDao getSQLDao() {
		return sqlDao;
	}

	/**
	 * 获得当前选中的Dao。
	 * 
	 * @return
	 */
	public static NutDao getDao() {
		return defaultDao;
	}

	/**
	 * 根据数据源配置信息,获得Dao。
	 * 
	 * @param dbConfig
	 * @return
	 */
	public static NutDao getDao(DSConfig dbConfig) {
		return new NutDao(DSContainer.getDataSource(dbConfig));
	}

}

这个类负责返回普通的NutzDao,跟一个用来获得自定义SQL语句的特殊的NutzDao

 

这里涉及到这个包下的几个类:

 

大家可能很奇怪为什么这里代码要这么多,这里其实从现有项目中搬过来的,是因为在做的项目中有这样一个需求——适应多数据源。

 

这个适应不只是在配置文件的时候要可以使用不同的数据源,在运行过程中,也要可以随时加入新的数据源,一个Service的每次执行都可以指定使用不同的数据源。

 

当然这里的系统不会有这么复杂的情况,代码的话大家可以选择性的看看,后面有时间了ME会把这部分精简掉。

 

BizException类:

package org.nutz.demo.exception;

import org.nutz.demo.util.database.constant.DbOperationResultEnum;

/**
 * 一个包含异常信息跟数据库操作结果信息的异常类。
 * 
 * @author pangwu86@gmail.com
 * 
 */
@SuppressWarnings("serial")
public class BizException extends RuntimeException {

	private DbOperationResultEnum dbOperationResultEnum = null;

	private Throwable cause = null;

	/**
	 * 业务异常。
	 * 
	 * @param dbOperationResultEnum
	 * @param cause
	 */
	public BizException(DbOperationResultEnum dbOperationResultEnum, Throwable cause) {
		super(cause);
		this.cause = cause;
		this.dbOperationResultEnum = dbOperationResultEnum;
	}

	public Throwable getCause() {
		return this.cause;
	}

	public DbOperationResultEnum getDBResult() {
		return this.dbOperationResultEnum;
	}
}

包含异常信息跟数据库操作结果信息的异常类,这里是为了保证在数据库出错的时候,仍然能正常的在页面上返回合理的结果,并将这个异常记录下来,这个类会跟后面的AOP配合使用,对其进行拦截,并将其异常写入日志,其结果返回页面。

 

好了,接下来开始实现四个模块的Service

 

这里以User为例子,展示Service接口与实现如何编写。


接口:

package org.nutz.demo.service;

import org.nutz.demo.model.User;

/**
 * 用户模块Service接口。
 * 
 * @author pangwu86@gmail.com
 * 
 */
public interface UserService extends BaseService<User> {

}
 

实现:

package org.nutz.demo.service.impl;

import org.nutz.demo.model.User;
import org.nutz.demo.service.UserService;

/**
 * 用户模块Service实现类。
 * 
 * @author pangwu86@gmail.com
 * 
 */
public class UserServiceImpl extends BaseServiceImpl<User> implements UserService {

}

是不是很简单,就这样,基本的增删改查功能就有了,那么接口与实现还存在的意义,就是在其中加入某个模块所具有的特殊的业务逻辑,而基本CRUD操作实现,你可以一行代码都不用写了,都在基类中实现好了。

 

最终代码如下:

 

下面把数据库配置文件加入,然后写几个测试类,看看刚才写的Service是否成功。

 

数据库配置文件ME这里采用了过去常用的properties文件,因为很多人还不是太熟悉用json格式(好吧,其实当时是ME忘了用json了)

 

 

放在这里,同时这里可以放一个log4j的配置文件,反正早晚都需要。

 

下面是测试类,还是以User为例,其他类似。

 

package org.nutz.demo.service;

import java.util.List;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.nutz.dao.Cnd;
import org.nutz.demo.model.User;
import org.nutz.demo.service.impl.UserServiceImpl;
import org.nutz.demo.util.database.constant.DbOperationResultEnum;

public class UserServiceTest {

	private static UserService userService;

	// 测试数据
	private final static String USERNAME1 = "testUser1";
	private final static String USERNAME2 = "testUser2";
	private final static String USERNAME3 = "testUser3";
	private final static String USERNAME4 = "testUser4";
	private final static String USERNAME4_2 = "testUser4_2";
	private final static String PASSWORD = "test123";

	private final static String ADMIN = "管理员";
	private final static String USER = "普通用户";

	@BeforeClass
	public static void beforeClass() {
		userService = new UserServiceImpl();
		// 准备测试数据
		User user1 = new User();
		user1.setUserName(USERNAME1);
		user1.setPassword(PASSWORD);
		user1.setUserType(ADMIN);

		User user2 = new User();
		user2.setUserName(USERNAME2);
		user2.setPassword(PASSWORD);
		user2.setUserType(USER);

		User user3 = new User();
		user3.setUserName(USERNAME3);
		user3.setPassword(PASSWORD);
		user3.setUserType(USER);

		// 清理当前数据
		userService.clear();
		// 插入测试数据
		userService.insert(user1);
		userService.insert(user2);
		userService.insert(user3);
	}

	@AfterClass
	public static void afterClass() {
		// 清理所有测试数据
		userService.clear();
	}

	@Before
	public void beforeMethod() {

	}

	@After
	public void afterMethod() {

	}

	@Test
	public void insert() throws Exception {
		User user = new User();
		user.setUserName(USERNAME4);
		user.setPassword(PASSWORD);
		user.setUserType(ADMIN);
		DbOperationResultEnum result = userService.insert(user);
		Assert.assertTrue(result.isSuccess());
	}

	@Test
	public void fetch() throws Exception {
		User user = userService.fetch(Cnd.where("userName", "=", USERNAME1));
		Assert.assertNotNull(user);
		Assert.assertTrue("管理员".equals(user.getUserType()));
	}

	@Test
	public void update() throws Exception {
		User user = userService.fetch(Cnd.where("userName", "=", USERNAME4));
		user.setUserName(USERNAME4_2);
		user.setUserType(USER);
		DbOperationResultEnum result = userService.update(user);
		Assert.assertTrue(result.isSuccess());
	}

	@Test
	public void query() throws Exception {
		List<User> users1 = userService.query(Cnd.where("userName", "=", USERNAME2).and("userType",
				"=", USER));
		List<User> users2 = userService.query(null);
		Assert.assertTrue(users1.size() == 1);
		Assert.assertTrue(users2.size() == 4);
	}

	@Test
	public void delete() throws Exception {
		User user = new User();
		user.setId(1000000);
		DbOperationResultEnum result = userService.delete(user);
		Assert.assertFalse(result.isSuccess());
	}

	@Test
	public void clear() throws Exception {
		DbOperationResultEnum result = userService.clear(Cnd.where("userName", "=", USERNAME4_2));
		Assert.assertTrue(result.isSuccess());
	}
}

 

确认无误后,说明后台的增删改查基本功能已经没有问题,可以开始进行下面的编码了。

 

下一集,将讲述MVC与IoC的使用。


PS:附件中为项目源码,无需解压直接导入Eclipse即可。
5
0
分享到:
评论
1 楼 hehebaiy 2012-08-17  
写的很好~~

相关推荐

    基于Nutz与ExtJs的快速开发

    4. **Nutz与ExtJs的整合**:讲解如何将Nutz作为后台服务,与ExtJs前端进行有效地通信,实现数据的动态加载和界面的实时更新。 5. **实战案例**:可能包含一些实际项目中的应用场景,如创建一个CRUD(创建、读取、...

    企业级应用项目,springmvc+nutz+redis+rabbitmq+quartz+shiro

    在本项目中,"企业级应用项目,springmvc+nutz+redis+rabbitmq+quartz+shiro",开发者采用了一系列高级技术构建了一个具备高可扩展性和低耦合度的系统,旨在提供一个适用于有一定Java基础的学习者进行实践和进阶的...

    国内技术强强联手之Nutz+KindEditor+LHGDialog+My97DatePicker

    标题中的“国内技术强强联手之Nutz+KindEditor+LHGDialog+My97DatePicker”揭示了四个关键的IT技术组件,它们在中国的技术社区中被广泛使用,并且经常一起集成到项目中以提供强大的功能。现在,我们将深入探讨这些...

    springboot+nutz+beetl整合工程

    在本项目中,`dao层`的实现将基于Nutz,通过其提供的注解和API来实现对数据库的操作,如增删改查等。 再来看Beetl,这是一款高性能的Java模板引擎,它的设计目标是提高开发效率,减少模板代码。Beetl语法简洁,支持...

    basecms(nutz+easyui)

    【basecms(nutz+easyui)】是一款基于Nutz框架和EasyUI前端库构建的CMS(内容管理系统)项目。此系统充分利用了EasyUI的组件化特性,为用户提供了一个直观、简洁且功能丰富的管理界面,而Nutz作为后端开发框架,确保...

    dbtoword.zip-springboot+POI+nutz+mysql导出word模板文件

    每次项目验收写文档是一个很凌乱的事情,作为一个程序员,应该是用技术...当然有很多工具也可以实现。比如PDman就可以导出word或者pdf文档。 这个案例主要是学习springboot项目开发。以及使用nutz poi第三方工具的使用

    nutz应用示例

    它不仅展示了如何设置和配置一个基于Nutz的Web应用,还通过具体的例子解释了Nutz与MySQL数据库的整合、数据访问、MVC架构的实现以及Ajax交互等多个关键知识点。开发者可以通过分析和运行这个项目,深入理解Nutz的...

    SpringMVC+Nutz框架介绍.docx

    SpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+Nutz框架介绍.docxSpringMVC+...

    SpringMVC+Nutz框架介绍.pdf

    SpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架介绍.pdfSpringMVC+Nutz框架...

    Java框架Nutz的基于jCasbin的权限管理插件.zip

    在Nutz+jCasbin的环境中,你可以根据业务需求定义各种条件,如用户属性、时间、地点等,来决定用户是否能执行特定操作,增强了权限控制的灵活性和适应性。 3. **策略定义**:jCasbin使用一种声明式的策略语言,称为...

    NutzWk是基于Nutz的Java开源企业级开发框架.rar

    开发计划: NutzWk 4.0.x 前后端分离版 (vue + nutz + dubbo) 开发中.. NutzWk 3.3.x CMS+微信+系统+权限+常用功能封装 (beetl / beetl+velocity) NutzWk 2.0.x 试验版(不建议使用) ...后台管理界面采用Pjax+Boo

    nutz框架使用手册.zip

    5. **实战示例**:手册可能包含多个实际开发案例,如CRUD操作、表单验证、文件上传下载、AJAX交互等,帮助读者通过实践更好地理解和掌握Nutz框架的使用。 6. **性能优化**:对于大型项目,性能优化至关重要。手册...

    数据表自动生成类代码

    可以自动生成数据库脚本,生成代码项目,数据库文档生成

    nutz代码生成器

    5. 示例:演示如何使用Nutz Codematic的示例项目。 使用Nutz Codematic可以显著提升开发效率,减少出错率,尤其在处理大量的数据库表时。通过自定义模板,还能保证生成的代码符合团队的编码规范,使得项目代码风格...

    在Nutz中使用Ioc-Annotation的入门教程

    `TestIocAnnotation`可能是这个教程中的示例代码,它演示了如何在实际项目中使用Nutz的Ioc-Annotation。这个文件可能包含了如何定义和使用注解的示例代码,通过阅读和运行这个例子,您可以更好地理解Nutz的Ioc机制。...

    nutz-1.r.58

    4. `nutz-1.r.58-manual.pdf` 和 `nutz-1.r.58-manual.rtf`:这是Nutz框架的手册,分别以PDF和RTF格式提供,包含了框架的使用指南、示例代码和最佳实践等内容。手册是开发者快速上手和掌握Nutz框架的重要教程资源。 ...

    nutz 文件上传例子

    在 Nutz 中,文件上传主要通过 `NutzHttp` 或 `Ioc` 容器中的 `nutz.plugin.multiupload` 插件来实现。首先,我们需要在项目中引入 Nutz 相关的依赖库,这通常通过 Maven 或 Gradle 等构建工具完成。接着,我们需要...

    nutz生成javabean工具.zip

    作为Nutz框架的一部分,Nutz Codematic可以无缝地与其他Nutz组件(如Nutz ORM)结合使用,实现更高效的开发流程。例如,生成的JavaBean可以直接用于Nutz ORM进行数据库操作,简化数据访问层的开发。 6. **学习与...

Global site tag (gtag.js) - Google Analytics