- 浏览: 265024 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
DragonKiiiiiiiing:
支持楼主,中国互联网太缺这种无私奉献的人了。您的这本书我已拜读 ...
JAVA NIO 全书 译稿 -
sp42:
非常感谢!热部署帮助很大!
Pure JS (2): 热部署 (利用 JDK 7 NIO 监控文件变化) -
sp42:
其实在我的架构中,我更倾向于 JSP 作为前端模板系统~还是写 ...
Pure JS (5.3):pure.render 的实现(构造window对象,实现服务器端 JQuery Template) -
sp42:
非常不错,楼主做的正是鄙人想做的做的,而且比鄙人的来的成熟、健 ...
OMToolkit介绍(5): 总结 -
cfanllm:
楼主辛苦了,,,谢谢分享啊
JAVA NIO 全书 译稿
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请求参数的合法性,并将不合法的访问强制重定向至登录页面的功能。
- OMWeb_Step1.rar (68.6 KB)
- 下载次数: 2
- OMWeb_Step2.rar (80.3 KB)
- 下载次数: 2
- OMToolkit.rar (106.2 KB)
- 下载次数: 2
- OMSimpleBlog.rar (119.6 KB)
- 下载次数: 3
发表评论
-
OMToolkit介绍(5): 总结
2011-03-22 19:13 1733OMToolkit介绍(5): 总结 ( ... -
OMToolkit介绍(4) :Object-Oriented Database 实现
2011-03-22 07:26 1174OMToolkit介绍(4) :Object-Oriented ... -
OMToolkit介绍(2) :Web Server 实现
2011-03-19 04:18 1623OMToolkit介绍(2) :Web Server 实现 ... -
OMTookit介绍(1) 简单示例:OMSimpleBlog
2011-03-17 07:50 1271OMTookit介绍(1) 简单示 ... -
OMToolkit: Web Server,Web Framework 及 Object-Orinted Database 的简单实现
2011-03-15 02:01 1600概述 最近在看一些NIO和concurrent的资 ...
相关推荐
OMToolkit 是一个集成 Web 服务器、Web 框架以及对象-关系数据库的工具包,旨在简化开发过程,提供一站式的解决方案。通过这个工具,开发者可以快速构建基于 Web 的应用程序,同时利用面向对象的数据库来存储和管理...
这个描述似乎重复了三次"webframework代码包",这可能意味着我们正在讨论的是一个名为"webframework"的特定Web框架的代码库或实现。这个代码包可能包含了实现Web应用功能的各种源代码文件、配置文件、文档和其他资源...
3. 面向对象的增强:.NET Framework 3.5对面向对象编程的支持进一步加强,包括匿名类型、自动属性、扩展方法等。匿名类型允许在不需要创建显式类的情况下定义临时对象,自动属性简化了属性的声明,而扩展方法则使得...
3. 支持变量: Robot Framework 支持变量,方便测试用例的维护和更新。 4. 支持数据驱动测试:Robot Framework 支持创建基于数据驱动的测试用例,提高测试的灵活性和可重用性。 5. 结果报告和日志:Robot Framework ...
"ExpressWeb Framework 1.6" 是一个专为构建网络应用程序设计的开发框架,它集成了多种功能,便于开发者快速创建高效、响应式的Web应用。这个框架的核心目标是简化Web开发流程,提供易于使用的控件和源码,帮助...
Selenium 是一款流行的Web自动化工具,与Robot Framework结合,可以实现对浏览器的精细控制,如点击、输入、断言元素状态等。Webdemo很可能包含了用SeleniumLibrary编写的测试脚本,用于验证Web应用程序的功能和行为...
标签:springframework、spring、webmvc、中文文档、jar包、java; 使用方法:解压翻译后的API文档,用浏览器打开“index.html”文件,即可纵览文档内容。 人性化翻译,文档中的代码和结构保持不变,注释和说明精准...
Entity Framework 4.0和*** Web Forms是微软公司推出的用于构建Web应用程序的技术,这本书主要讲述了如何使用Entity Framework 4.0在*** Web Forms应用程序中实现数据的显示和编辑。 Entity Framework是微软的.NET...
1. **.NET Framework概述**:.NET Framework是一个全面、统一的编程模型,由微软公司推出,旨在简化软件开发,提供跨语言互操作性,并支持多种应用程序类型,如Windows桌面应用、Web应用和服务。 2. **版本历史**:...
.NET Framework 4.5是微软开发的一个全面的、统一的编程模型,用于构建和运行下一代的应用程序和Web服务。这个框架版本在.NET Framework 4的基础上进行了大量的改进和新功能的添加,旨在提升开发者的工作效率,增强...
web framework, 网页设计, 网站建设,网络架构
Robot Framework是一个开源的、通用的自动化测试框架,特别适合于Web应用程序的测试。其核心特性包括易于理解和使用的表格语法,以及对验收测试和验收测试驱动开发(ATDD)的强大支持。 Robot Framework的架构设计...