`
裴小星
  • 浏览: 265323 次
  • 性别: Icon_minigender_1
  • 来自: 北京
博客专栏
8ccf5db2-0d60-335f-a337-3c30d2feabdb
Java NIO翻译
浏览量:27829
F3e939f0-dc16-3d6e-8c0b-3315c810fb91
PureJS开发过程详解
浏览量:74161
07a6d496-dc19-3c71-92cf-92edb5203cef
MongoDB Java ...
浏览量:62961
社区版块
存档分类
最新评论

OMToolkit介绍(3) :Web Framework 实现

阅读更多
OMToolkit介绍(3) :Web Framework 实现

  本文将介绍OMToolkit中的 Web Framework 的实现,包括控制器、视图渲染、事务管理、分页和权限控制等。与Web Framework有关的类主要位于com.omc.web包中。
  本文的project是建立在前一篇文章的project的基础上的,所以请先下载附件中的OMServer_Complete.rar,解压后导入到eclipse中。

1. Controller:控制器,解析Web请求并分发任务到Entity

(1) 创建Controller

  首先,新建初始的Controller类:
package com.omc.web;

import com.omc.server.*;

/**
 * Extracting task message from {@link Request} and employ an {@link Entity} to
 * handle the task.
 * 
 * @see Request
 * @see Entity
 */
public class Controller {
	private Request req;

	public Controller(Request request) {
		req = request;
	}

	public byte[] run() throws Exception {		
		String res = doRun();
		return response(res).getBytes();
	}

	public String doRun() throws Exception {
		return "Hello World!";
	}

	private String response(String response) {
		StringBuilder result = new StringBuilder();

		result.append("HTTP/1.1 200 OK\n");
		result.append(req.session() + "\n");

		result.append("\n" + response);

		return result.toString();
	}
}
  然后,修改Worker.Processing类,删除response(...)、oldCookie(...)、newCookie(...),修改doRun()方法,将以下代码:
toWrite(response(req).getBytes());
  修改为:
toWrite(new Controller(req).run());

  现在运行程序,在浏览器中输入http://localhost,仍然只能看到“Hello World!”,当然这只是开始。
  接下来,就要引入Entity了,先建一个空的Entity占个位子:
package com.omc.core;

public abstract class Entity {
}

  然后新建一个Entity的子类:
package com.omc.entity;

import com.omc.core.*;

public class User extends Entity {
	public String sayHello() throws Exception {
		return "Hello World!";
	}
}

  修改Controller的doRun()方法:
	public String doRun() throws Exception {
		Method method = User.class.getMethod("sayHello");		
		loadEntity();		
		try {
			Object res = method.invoke(entity);
			return (String) res;
		} catch (Exception e) {
			e.printStackTrace();
			return "";
		}
	}

	private void loadEntity() throws Exception {
		entity = (Entity) User.class.getConstructor().newInstance();	
	}

  运行程序,效果不变。当然这还谈不上任何的灵活性,至少Controller是不应该依赖于User类的;我们接下来将会根据URL中的信息,决定加载哪个Entity。

(2) 加载Entity

  考虑到将来可能还要从jar文件中加载Entity,我们先在Cfg中加入参数jar和pkg,分别表示Entity可能存在的jar文件和package的名称:
	private static String jar;
	private static String pkg;

	public static String jar() {
		return jar;
	}

	public static String pkg() {
		return pkg;
	}
  并在Cfg.cfg中增加参数:
jar=file:web.jar
pkg=com.omc.entity

  编写LoadUtil来根据名称加载Entity所属的类:
package com.omc.util;

import java.net.*;

/**
 * A wrap for a URL class loader. The loaded jar path and the package name can
 * be configured in the file "Cfg.cfg".
 */
public class LoadUtil {
	private static ClassLoader loader;

	public static void init() throws Exception {
		URL[] urls = new URL[] { new URL(Cfg.jar()) };
		loader = new URLClassLoader(urls);
	}

	public static Class<?> load(String name) throws ClassNotFoundException {
		return loader.loadClass(Cfg.pkg() + "." + name);
	}
}
  同时在Server类的init()中增加以下代码:
LoadUtil.init();

  在Request中加入提取Entity所属的类的方法:
	private Class<?> clz;

	public Class<?> clz() throws Exception {
		if (clz == null) {
			clz = LoadUtil.load(entity);
		}

		return clz;
	}

  最后修改Controller的loadEntity()方法,将以下代码:
entity = (Entity) User.class.getConstructor().newInstance();
  修改为:
entity = (Entity) req.clz().getConstructor().newInstance();
  并修改doRun()方法,将以下代码:
Method method = User.class.getMethod("sayHello");
  修改为
Method method = req.clz().getMethod("sayHello");

  运行程序,输入http://localhost/User/sayHello,效果没有变化。不过现在已经可以动态加载Entity了,你不妨也试着编写一个新的Entity类?
  当然,这还不够,我们希望所调用的方法也是动态的。

(3) 方法调用

  首先,需要在ReflectUtil中增加通过反射获取method的方法:
	public static Method getMethod(Class<?> clz, String name) {
		for (Method method : clz.getMethods()) {
			if (method.getParameterTypes().length == 0
					&& name.equals(method.getName())) {
				return method;
			}
		}

		return null;
	}

  然后,在Request中增加获取所调用的Method的方法:
	private Method method;

	public Method method() throws Exception {
		if (method == null) {
			method = getMethod(clz(), action());
			return method == null ? getMethod(clz(), "toView") : method;
		}

		return method;
	}
  这里需要注意的是,当找不到method时,会调用toView()方法,表示以当前的Entity为Model,渲染与方法名称相同的视图。我们在后面会将这个方法添加到Entity中,现在先不用理会。
  最后,需要修改Controller类的doRun()方法,将以下代码:
Method method = req.clz().getMethod("sayHello");
  修改为:
Method method = req.method();

  再次运行程序,输入http://localhost/User/sayHello进行测试。你也可以为User编写更多的方法,并修改URL进行测试。
  现在我们的Controller已经可以做到动态地加载Entity类,并调用相应的方法了。不过更进一步地,我们还希望根据URL(或body中的参数)对Entity的属性进行赋值。

(4) 属性赋值

  在ReflectUtil中加入一个新的setField(...)方法:
	public static void setField(final Object obj, String name,
			final Object value) throws Exception {
		FieldSetter setter = new FieldSetter() {
			public void set(Field field) throws Exception {
				field.set(obj, value);
			}
		};

		doSetField(obj.getClass(), name, setter);
	}

  在Controller的loadEntity()方法中加入以下代码:
	private void loadEntity() throws Exception {
		Map<String, String> params = req.params();

		entity = (Entity) req.clz().getConstructor().newInstance();

		loadFields(params);
	}

	private void loadFields(Map<String, String> params) throws Exception {
		for (Entry<String, String> param : params.entrySet()) {
			loadField(param);
		}
	}

	private void loadField(Entry<String, String> param) throws Exception {
		String name = param.getKey();
		String value = param.getValue();			

		for (Field field : req.clz().getDeclaredFields()) {
			field.setAccessible(true);
			if (field.getName().equals(name)) {
				Object obj = parseField(value, field);
				ReflectUtil.setField(entity, name, obj);
			}
		}
	}

	private Object parseField(String value, Field field) {
		return ReflectUtil.parseField(field.getType(), value);
	}

  接着修改User类,以便测试。在User类中加入属性name:
	private String name;
  并将sayHello()函数修改为如下形式:
	public String sayHello() throws Exception {
		return "Hello, " + name + "!";
	}

  运行程序,在浏览器中输入http://localhost/User/sayHello/name/Xiaoxing,可以得到如下输出:
Hello, Xiaoxing!

  最后,由于实际应用中还经常需要对session、cookie、request进行操作,我们还需要在Controller中加入一些相关的代码。

(5) Session,Cookie,Request

  在Entity中增加request属性:
	private Request request;

	public void setRequest(Request request) {
		this.request = request;
	}

	public Request getRequest() {
		return request;
	}

  在Controller类的loadEntity()方法中 加入以下代码:
		entity.setRequest(req);
		ReflectUtil.setField(entity, "session", req.session());
		ReflectUtil.setField(entity, "cookies", req.cookies());

  在Contrller类中增加getCookies(...)方法:
	@SuppressWarnings("unchecked")
	private List<Cookie> getCookies(Entity entity) throws Exception {
		return (List<Cookie>) ReflectUtil.getField(entity, "cookies");
	}
  其中用到的ReflectUtil.getField(...)的实现如下:
	public static Object getField(Object obj, String name) throws Exception {
		return doGetField(obj, obj.getClass(), name);
	}

	private static Object doGetField(Object obj, Class<?> clz, String name)
			throws Exception {
		for (Field field : clz.getDeclaredFields()) {
			if (field.getName().equals(name)) {
				field.setAccessible(true);
				return field.get(obj);
			}
		}

		Class<?> superClass = clz.getSuperclass();
		if (superClass.getSimpleName().equals("Object")) {
			return null;
		}

		return doGetField(obj, clz.getSuperclass(), name);
	}

  修改Controller类的Run()方法,增加获取entity的cookies的代码:
	public byte[] run() throws Exception {
		String res = doRun();
		List<Cookie> cookies = getCookies(entity);
		return response(res, cookies).getBytes();
	}

  修改Controller类的response方法,将改变后的cookies传回浏览器:
	private String response(String response, List<Cookie> cookies) {
		StringBuilder result = new StringBuilder();

		result.append("HTTP/1.1 200 OK\n");
		result.append(req.session() + "\n");
		if (cookies != null) {
			for (Cookie cookie : cookies) {
				result.append(cookie + "\n");
			}
		}

		result.append("\n" + response);

		return result.toString();
	}

  接下来,修改User类以进行测试:
package com.omc.entity;

import java.util.*;

import com.omc.core.*;
import com.omc.server.*;

public class User extends Entity {
	private String name;
	private Session session;
	private List<Cookie> cookies;

	public String init() throws Exception {
		session.set("role", "user");
		cookies.add(new Cookie("password", "pass"));

		return "Init Coomplete.";
	}

	public String sayHello() throws Exception {
		StringBuilder result = new StringBuilder();

		result.append("role:" + session.get("role") + "<br />");
		result.append("password:" + Cookie.get(cookies, "password") + "<br />");
		result.append("path: " + getRequest().path() + "<br />");

		result.append("Hello, " + name + "!");

		return result.toString();
	}
}

  现在可以运行程序进行测试了。在浏览器中输入http://localhost/User/init,将得到“Init Coomplete.”的提示信息;然后输入http://localhost/User/sayHello/name/Xiaoxing,将得到如下输出:
role:user
password:pass
path: User/sayHello/name/Xiaoxing
Hello, Xiaoxing!


  到此为止,Controller类的代码就基本完成了。现在的代码应该类似于附件中的OMWeb_Step1.rar。我们在Controller类中完成了以下工作:
  1. 根据Web请求,动态加载Entity;
  2. 根据Web请求,动态调用Entity的方法;
  3. 根据Web请求,对Entity的属性进行赋值;
  4. 设置Entity,使其能便捷地操作session、cookie和request对象。

  不过,现在的Controller类有点乱了,在下一篇文章中介绍数据存储部分时,我们会把loadFields(...)等操作交给DataUtil。

  接下来,我们将看看视图类“View”,了解视图渲染的细节。

2. View:视图渲染

(1) 准备工作

  在正式编写View类之前,还需要一些准备工作。首先是增加一个Reference类:
package com.omc.core.field;

import com.omc.core.*;

public class Reference<T extends Entity> {
	private T value;

	public T get() {
		return value;
	}

	public void set(T value) {
		this.value = value;
	}
}
  Reference表示对其他Entity的引用,后面我们还将在Reference中实现延迟加载。不过这属于数据存储的内容,这里暂不涉及。
  同时,需要增加TextField类:
package com.omc.core.field;

public class TextField {
	private String value;

	public String getText() {
		return value;
	}

	public void setText(String value) {
		this.value = value;
	}
}
  同样地,将来会在TextField中实现延迟加载。

  接着,在FileUtil中增加read方法:
	public static String read(String path) throws Exception {
		return new String(bytes(path));
	}
  这个方法用于读取文件内容并转为String。在视图渲染中经常需要读取html文件。

  然后,在StringUtil中增加以下代码:
	public static String upperFirst(String input) {
		return input.substring(0, 1).toUpperCase() + input.substring(1);
	}

	public static boolean isEmpty(Object s) {
		return s == null || s.equals("");
	}
  upperFirst(...)表示首字母大写,这在将一个属性名称转换为get方法的名称时将用到;isEMpty(...)表示判断一个字符串是否为空。

  在ReflectUtil中增加get(...)
	public static Object get(Object obj, String name) throws Exception {
		String methodName = "get" + StringUtil.upperFirst(name);
		Method m = getMethod(obj.getClass(), methodName);
		Object value = m == null ? getField(obj, name) : m.invoke(obj);
		return value == null ? "" : value;
	}
  这个方法结合运用getMethod(...)和getField(...),以获取对象的属性;即先查找get方法,没有get方法的话就查找属性本身,获取值并返回。

(2) 视图渲染框架

  首先,看看View类的基本框架:
package com.omc.web;

import static com.omc.util.FileUtil.*;

import java.util.*;
import java.util.regex.*;

import com.omc.core.field.*;
import com.omc.server.*;
import com.omc.util.*;

/**
 * Proving methods to render a HTML page form specific model and view name.
 */
public class View {
	public static final Pattern ABSTRACT = Pattern.compile("#abstract (.+?)\n");
	public static final Pattern PROPERTY = Pattern.compile("\\$\\{(.+?)\\}");

	private Object model;
	private String content;
	private Request req;

	private List<String> lines;
	private int index;
	private String s;
	private StringBuilder block;
	private StringBuilder result = new StringBuilder();

	public static String render(Object model, String view, Request request)
			throws Exception {
		String content = read("views/" + view + ".html").replace("\r", "");
		return new View(model, content, request).render();
	}

	private View(Object model, String content, Request request) {
		this.model = model;
		this.content = content;
		this.req = request;
	}

	public String render() throws Exception {
		if (content.startsWith("#extends")) {
			content = doExtends(content);
			return new View(model, content, req).render();
		}

		lines = StringUtil.split(content, '\n');
		while (index < lines.size()) {
			readLine();
			if (s.startsWith("#if")) {
				branch();
			} else if (s.startsWith("#loop")) {
				loop();
			} else {
				parseLine();
			}
		}

		return result.toString();
	}

	// codes...

	private void readLine() {
		s = lines.get(index++).trim();
	}
}
  可以看到,视图文件是逐行进行解析的,如果视图文件以“"#extends"”开头,则先进行继承相关的处理,然后逐行读取,根据关键字决定解析为分支、循环或者普通语句。

(3) 视图继承

  接下来,我们先看看doExtends(...)的实现:
	private String doExtends(String content) throws Exception {
		String[] parts = content.split("\n", 2);
		String view = parts[0].split(" ")[1];
		String parent = read("views/" + view + ".html").replace("\r", "");

		if (parent.startsWith("#extends")) {
			parent = doExtends(parent);
		}

		return updateParent(parent, overrides(parts[1]));
	}

	private Map<String, String> overrides(String body) {
		Map<String, String> overrides = new HashMap<String, String>();
		for (String override : body.split("#override ")) {
			if (!override.trim().isEmpty()) {
				String[] oParts = override.split("\n", 2);
				overrides.put(oParts[0].trim(), oParts[1] + '\n');
			}
		}

		return overrides;
	}

	private String updateParent(String parent, Map<String, String> overrides) {
		Matcher macher = ABSTRACT.matcher(parent);
		while (macher.find()) {
			String name = macher.group(1).trim();
			String o = overrides.get(name);
			if (o != null) {
				parent = parent.replace("#abstract " + name + '\n', o);
			}
		}

		return parent;
	}
  doExtends(...)方法:先提取第一行的第二个词,也就是被继承的视图的名称,获取被继承的视图文件的内容;如果该视图又继承了另一个视图,则递归调用doExtends();然后更新被继承视图的内容,即进行一些替换后返回。
  overrides(...)方法:将当前的页面按照“#overrides”关键字进行划分,取得要覆盖的部分的名称,以及用于覆盖的内容。
  updateParent(...)方法:根据overrides(...)方法得到的结果,对parent进行更新。找到parent视图中用关键字“#abstract”标注的部分,根据名称进行替换。
  总之,就是用子视图的“#overrids”的内容去覆盖父视图的“#abstract”部分。

(4) 分支与循环

  接着,是分支语句的实现:
	private void branch() throws Exception {
		String v = s.split(" ")[1];
		boolean record = v.startsWith("!") ? !bool(v.substring(1)) : bool(v);
		readBlock(record);

		if (record) {
			View view = new View(model, block.toString(), req);
			result.append(view.render());
		}
	}

	private boolean bool(String var) throws Exception {
		return parse(var).equals("true");
	}
  这里用的的parse(...)方法将在后面介绍解析变量名称的时候提到,而readBlock(...)将在后面介绍解析语法块时提到。
  分支语句的逻辑是:先提取第一行的第二个词,也就是判断条件;解析条件,如果结果为“true”,则判断成功,读取语法块并将语法块中的内容添加到渲染输出中,否则跳过语法块。
  循环语句的实现如下:
	private void loop() throws Exception {
		Iterable<?> iter = s.contains(" ") ? fromField() : fromModel();
		boolean record = iter.iterator().hasNext();
		readBlock(record);

		if (record) {
			for (Object item : iter) {
				Reference<?> r = (Reference<?>) item;
				View view = new View(r.get(), block.toString(), req);
				result.append(view.render());
			}
		}
	}

	private Iterable<?> fromField() throws Exception {
		String listName = s.split(" ")[1];
		return (Iterable<?>) parse(listName);
	}

	private Iterable<?> fromModel() {
		return (Iterable<?>) model;
	}
  首先,提取被循环的Iterable对象,如果“#loop”关键之后带有变量名称,则先解析变量名称作为被循环的Iterable对象;否则,以当前的model作为被循环的对象;对于Iterable对象包含的每个对象,都重新构造一个View对象,并将渲染结果添加到渲染输出,这实际上是一种间接递归。
  变量解析的实现如下:
	private Object parse(String var) throws Exception {
		if (var.contains(".")) {
			String[] parts = var.split("\\.", 2);
			return parse(reference(model, parts[0]), parts[1]);
		}

		return parseVar(model, var);
	}

	private Object parse(Object model, String var) throws Exception {
		if (model instanceof Reference<?> && !var.equals("id")) {
			Reference<?> reference = (Reference<?>) model;
			return parse(reference.get(), var);
		}

		if (var.contains(".")) {
			String[] parts = var.split(".", 2);
			model = ReflectUtil.get(model, var);
			return parse(model, parts[1]);
		}

		return fromField(model, var);
	}

	private Reference<?> reference(Object model, String var) throws Exception {
		Object field = ReflectUtil.get(model, var);
		return (Reference<?>) (field == null ? req.session().get(var) : field);
	}

	private Object parseVar(Object model, String var) throws Exception {
		Object value = fromField(model, var);
		if (!StringUtil.isEmpty(value)) {
			return value;
		}

		String param = req.params().get(var);
		if (param != null) {
			return param;
		}

		Object sessionObj = req.session().get(var);
		return sessionObj == null ? "" : sessionObj;
	}

	private Object fromField(Object model, String var) throws Exception {
		Object value = ReflectUtil.get(model, var);

		if (value instanceof TextField) {
			return ((TextField) value).getText();
		}

		return value;
	}
  parse(String var)方法:如果变量中带有“.”操作符,则获取所引用的model,并调用parse(Object model, String var)方法进行解析;否则调用parseVar(Object model, String var)方法进行解析。
  parse(Object model, String var)方法:如果model是一个对象引用,就先获取被引用的对象;如果变量中带有点操作符,就对自己进行递归调用;否则,从model的属性中获取值。
  reference(Object model, String var)方法:当前model的属性或session中获取所引用的model。
  parseVar(Object model, String var)方法:依次在model的属性、Web请求参数和session中查找变量,如果都没有找到,则返回空字符串。
  fromField(Object model, String var) 方法:从model的属性中获取值,并针对TextField进行特殊处理。

  解析语法块的实现如下:
	private void readBlock(boolean record) {
		if (record) {
			block = new StringBuilder();
		}

		int deep = 1;
		while (true) {
			readLine();

			if (s.startsWith("#if") || s.startsWith("#loop")) {
				++deep;
			} else if (s.startsWith("#end")) {
				--deep;
			}

			if (deep == 0) {
				break;
			}

			if (record) {
				block.append(s);
				block.append('\n');
			}
		}
	}
  先将表示层次深度的变量deep设置为1,再根据关键字“#if”“#loop”“#end”更新deep;当deep为0是退出,否则将改行内容添加到block中。
(5) 解析普通语句

  parseLine(...)的实现如下:
	private void parseLine() throws Exception {
		Matcher matcher = PROPERTY.matcher(s);

		while (matcher.find()) {
			String group = matcher.group(1);
			Object value = parse(group);
			s = s.replace("${" + group + "}", value.toString());
		}

		if (s.startsWith("#include")) {
			include();
		} else {
			result.append(s);
			result.append('\n');
		}
	}
  先对语句中形如“#{var}”的部分进行解析并替换,然后如果以关键字“#inclue”开头,则调用include()方法进行处理;否则,将内容添加到渲染输出。

  include方法实现如下:
	private void include() throws Exception {
		String path = s.split(" ")[1].substring(1);
		Request request = new Request(req.head(), path);
		result.append(new Controller(request).doRun());
	}
  即重新构造一个请求,调用Controller的doRun()方法进行处理,并将返回结果添加到渲染输出中。

  到此为止,View类的代码也基本完成了。View实现了以下功能:
  1. 基本的变量解析,包括“.”操作符,“${var}”标记等;
  2. 分支和循环语句;
  3. 静态继承与动态包含。


(6) 修改其他类

  在Entity中添加与view相关的属性和方法:
	private String view;

	public void setView(String view) {
		this.view = view;
	}

	public String toView() throws Exception {
		return toView(this);
	}

	public String toView(Object model) throws Exception {
		return toView(model, view);
	}

	public String toView(String view) throws Exception {
		return toView(this, view);
	}

	public String toView(Object model, String view) throws Exception {
		if (view.charAt(0) != '/') {
			view = this.getClass().getSimpleName() + '/' + view;
		}

		return View.render(model, view, request);
	}

	public String action(String action) throws Exception {
		if (action.startsWith("/")) {
			Request r = new Request(request.head(), action.substring(1));			
			return new Controller(r).doRun();
		} else {
			view = action;
			Method method = this.getClass().getMethod(action);
			return (String) method.invoke(this);
		}
	}
  toView()用于显示视图,而action(...)表示转向,可能会改变当前的view。

  在Controller类的loadEntity()方法中加入:
entity.setView(req.action());
  并将Controller类的parseField(...)方法修改为:
		if (field.getType().equals(TextField.class)) {
			TextField textField = new TextField();
			textField.setText(value);
			obj = textField;
		} else {
			obj = ReflectUtil.parseField(field.getType(), value);
		}

		return obj;


  修改Request类,引入默认页面。将init()方法中的以下代码:
entity = parts[0].isEmpty() ? "" : parts[0];
  修改为:
entity = parts[0].isEmpty() ? Cfg.defaultEntity() : parts[0];
  并将action()方法中的以下代码:
return parts.length >= 2 ? parts[1] : "";
  修改为:
return parts.length >= 2 ? parts[1] : Cfg.defaultAction();

  在Cfg中增加默认Entity和默认action的参数:
	private static String defaultEntity;
	private static String defaultAction;

	public static String defaultEntity() {
		return defaultEntity;
	}

	public static String defaultAction() {
		return defaultAction;
	}
  以及Cfg.cfg中的配置:
defaultEntity=User
defaultAction=index

(7) 测试

  在User类中加入以下属性和方法:
	private TextField description;

	public String list() throws Exception {
		Reference<User> r = new Reference<User>();
		r.set(this);
		
		List<Reference<User>> list = new ArrayList<Reference<User>>();
		list.add(r);
		list.add(r);
		list.add(r);
		
		return toView(list);
	}

  模板页面 views/User/master.html:
<html>
<head>
<meta http-equiv = "content-type" content = "text/html; charset=GBK" />
<title>
	#abstract title
</title>
<link rel="stylesheet" type="text/css" href="/resources/style.css" />
</head>
<body>
<div align="center">
	<img src="/resources/banner.jpg" />
</div>
<div align="center" id="box">
	#abstract content
</div>
</body>
<script defer type="text/javascript" src="/resources/script.js"></script>
</html>

  默认页面 views/User/index.html:
#extends /User/master

#override title
首页

#override content
测试表单
<form action="/User/test" method="post">
<table>
	<tr><td>用户名:</td></tr>
	<tr>
		<td><input name="name" id="用户名" maxlength="20" /><br /></td>
	</tr>
	<tr><td>描述:</td></tr>
	<tr>
	<td>
		<textarea name="description" id="描述"
			maxlength="500" rows="3" cols="50"></textarea>
	</td>
	</tr>
	<tr>
	<td>
		显示列表:<input type="checkbox" name="showList" value="true" />
	</td>
	</tr>
	<tr><td align="center"><input type="submit" value="提交"></td></tr>
</table>
</form>

  测试页面 views/User/test.html:
#extends /User/master

#override title
测试页面

#override content
#if !showList
	不显示列表!
#end

#if showList
	#include /User/list/name/${name}/description/${description}/showList/${showList}
#end

  列表页面 views/User/test.list:
#loop
	${name}<br />	
	${description}<br />
	<br />
#end

  运行程序,在浏览器中输入http://localhost,效果如图:






  试图渲染的说明到此为止,目前的代码应该类似于附件中的OMWeb_Step2.rar。考虑到篇幅的关系,剩下的部分将只做简单的介绍。

3. 其他:事务管理,分页和权限控制

(1) 事务管理

  事务管理的实现主要在Transaction中,Transaction包含了toSave和toDelete两个集合,分别表示需要重新保存的Entity和需要删除的Entity;此外还有一个Map类型的属性cache,用于缓存已经读取过的Entity。
  OMToolkit将自动管理事务,用户也可以通过Entity.getTransaction()获取事务管理对象。为了实现自动保存更新过的对象,需要在对基本类型进行封装,这就需要引入OMField,特别是需要在OMField中是set()方法中记录更新过的Enttiy,在处理过程结束时自动进行保存或删除。
  此外,还需要提到的是@UpdateOptions注解,如果Entity中处理Web请求的方法中没有这个注解,则所有的更新和删除等操作都不会反映在数据库中,这是Tranaction的作用就仅仅是cache已经读取过的Entity了。如果带有这个注解,则所有从数据库中获取的Entity都将申请更新锁,使得其他需要进行更新操作的线程无法同时获取数据,这是为了保证数据的一致性;但同时也是一个潜在的性能瓶颈,更理想的做法是不加锁,而对多个更新操作采用特定的策略进行合并。

(2) 分页处理

  分页处理的代码位于PageUtil类中,对于传入Reference列表,将按照Entity的id降序排列,即刚创建的Entity会排在前面;同时,读取request中的pageIndex和pageSize,进行分页处理后向request中写入empty、lastPage、nextPage等。
  当然,这种分页方式不够灵活。为了实现更自由的分页,用户需要通过References的values()方法获取Reference集合,再构造一个Comparator,连同pageIndex和pageSize,一起传入ArrayUtil.sort(...)方法中。这实际上是很繁琐的。所以OMToolkit的0.0.3版本的一个改进点就是优化这部分的API。

(3) 权限控制

  AccessChecker类将对Web请求进行权限检查。
  对于Entity中带有@Role注解的方法,将从session中获取key “role” 对应的字符串,如果session中的role不@Role注解中著名的允许的用户的列表中,则强制返回登录页面。
  对于Entity中带有@UpdateOptions注解的方法,将检查输入的参数中,将对类型为OMField的属性进行更新的部分进行检查,看是否包含于toUpdate列表中;同时,也将检查对于不包含于allowEmpty中的OMFiled类型的属性,是否在输入的参数中没有出现,或者被指定为空;对于试图更新不被允许的属性,或者试图将不允许为空的字段设置为空的Web请求,也将强制返回登录页面。
  应该说,这种处理也缺乏灵活性。这也是0.0.3版本中需要改进的一个地方。

4. 总结

  OMToolkit中的 Web Framework 的实现,包括了控制器、视图渲染、事务管理、分页和权限控制等。与Web Framework有关的类主要位于com.omc.web包中。

  控制器部分主要借助反射,实现了:
  1. 根据Web请求,动态加载Entity;
  2. 根据Web请求,动态调用Entity的方法;
  3. 根据Web请求,对Entity的属性进行赋值;
  4. 设置Entity,使其能便捷地操作session、cookie和request对象。

  视图部分,主要借助反射和对文本的解析,实现了:
  1. 基本的变量解析,包括“.”操作符,“${var}”标记等;
  2. 分支和循环语句;
  3. 静态继承与动态包含。

  事务管理的部分,主要借助OMField的set()方法中记录的动作,实现了:
  1. 自动保存更新过的Entity(需@UpdateOptions注解);
  2. 自动删除被移除的Entity(需@UpdateOptions注解);
  3. cache已经读取过的对象;
  4. 申请更新多(需@UpdateOptions注解)。

  分页部分借助对Request的操作,主要实现按照id降序排列,并截取需要显示的Refeence列表,并在Request中记录分页所需信息的功能;权限控制则借助注解实现角色的检查,和更新操作中Web请求参数的合法性,并将不合法的访问强制重定向至登录页面的功能。
8
4
分享到:
评论

相关推荐

    OMToolkit: Web Server,Web Framework 及 Object-Orinted Database 的简单实现

    OMToolkit 是一个集成 Web 服务器、Web 框架以及对象-关系数据库的工具包,旨在简化开发过程,提供一站式的解决方案。通过这个工具,开发者可以快速构建基于 Web 的应用程序,同时利用面向对象的数据库来存储和管理...

    webframework

    这个描述似乎重复了三次"webframework代码包",这可能意味着我们正在讨论的是一个名为"webframework"的特定Web框架的代码库或实现。这个代码包可能包含了实现Web应用功能的各种源代码文件、配置文件、文档和其他资源...

    vs2008视频教程5:.NET Framework 3.5 新功能介绍

    3. 面向对象的增强:.NET Framework 3.5对面向对象编程的支持进一步加强,包括匿名类型、自动属性、扩展方法等。匿名类型允许在不需要创建显式类的情况下定义临时对象,自动属性简化了属性的声明,而扩展方法则使得...

    自动化测试框架RobotFramework+Selenium2

    3. 支持变量: Robot Framework 支持变量,方便测试用例的维护和更新。 4. 支持数据驱动测试:Robot Framework 支持创建基于数据驱动的测试用例,提高测试的灵活性和可重用性。 5. 结果报告和日志:Robot Framework ...

    ExpressWeb Framework 1.6

    "ExpressWeb Framework 1.6" 是一个专为构建网络应用程序设计的开发框架,它集成了多种功能,便于开发者快速创建高效、响应式的Web应用。这个框架的核心目标是简化Web开发流程,提供易于使用的控件和源码,帮助...

    Robot Framework Webdemo

    Selenium 是一款流行的Web自动化工具,与Robot Framework结合,可以实现对浏览器的精细控制,如点击、输入、断言元素状态等。Webdemo很可能包含了用SeleniumLibrary编写的测试脚本,用于验证Web应用程序的功能和行为...

    spring-webmvc-5.0.8.RELEASE-API文档-中文版.zip

    标签:springframework、spring、webmvc、中文文档、jar包、java; 使用方法:解压翻译后的API文档,用浏览器打开“index.html”文件,即可纵览文档内容。 人性化翻译,文档中的代码和结构保持不变,注释和说明精准...

    Entity Framework 4.0 and Web Forms

    Entity Framework 4.0和*** Web Forms是微软公司推出的用于构建Web应用程序的技术,这本书主要讲述了如何使用Entity Framework 4.0在*** Web Forms应用程序中实现数据的显示和编辑。 Entity Framework是微软的.NET...

    net framework4.2_x64

    1. **.NET Framework概述**:.NET Framework是一个全面、统一的编程模型,由微软公司推出,旨在简化软件开发,提供跨语言互操作性,并支持多种应用程序类型,如Windows桌面应用、Web应用和服务。 2. **版本历史**:...

    .NET Framework4.5安装包

    .NET Framework 4.5是微软开发的一个全面的、统一的编程模型,用于构建和运行下一代的应用程序和Web服务。这个框架版本在.NET Framework 4的基础上进行了大量的改进和新功能的添加,旨在提升开发者的工作效率,增强...

    Web Framework

    web framework, 网页设计, 网站建设,网络架构

    RobotFramework自动化测试修炼宝典+源代码.zip

    Robot Framework是一个开源的、通用的自动化测试框架,特别适合于Web应用程序的测试。其核心特性包括易于理解和使用的表格语法,以及对验收测试和验收测试驱动开发(ATDD)的强大支持。 Robot Framework的架构设计...

    org.springframework.web.jar

    在Java的Web开发领域,Spring框架是不可或缺的重要工具,其中`org.springframework.web.jar`文件是Spring框架的核心组成部分,主要用于处理Web应用程序的相关功能。这个JAR(Java Archive)文件包含了Spring Web模块...

Global site tag (gtag.js) - Google Analytics