wicket 研究和学习Wicket技术 http://mywicket.group.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 Wicket中Tree的一些操作 earls 作者: earls  链接：http://mywicket.group.javaeye.com/group/blog/140987  发表时间: 2007年11月15日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

      首次接触Wicket中的Tree，没有比较好的文档可以参考，只好慢慢琢磨。这里只是作为使用经验的记录：

1、隐藏根节点：
       有时显示根节点有点鸡肋的感觉，可以调用tree.setRootLess(true)将其隐藏

2、初始显示时全部折叠：
       默认情况下会全部展开，有点没必要。可以调用tree.getTreeState().collapseAll()来实现
3、树节点的刷新：
      当通过后台程序更改树的modle数据后，需要重置TreeState的状态，否则树的显示有问题，并且调用onNodeLinkClicked()方法也会抛出异常，所以可以简单调用tree.getTreeState().collapseAll()来重新初始TreeState的状态
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 15 Nov 2007 18:42:07 +0800 http://mywicket.group.javaeye.com/group/blog/140987 http://mywicket.group.javaeye.com/group/blog/140987 Wicket在OSGi框架下的开发 earls 作者: earls  链接：http://mywicket.group.javaeye.com/group/blog/121966  发表时间: 2007年09月08日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

       之前写的文章 Wicket如何通过OSGi框架注入Jetty 中关于wicket如何在OSGi下工作比较繁琐，经过不断摸索，发现一种简化的方式，而且可以在wicket的程序类修改时不重新启动整个OSGi框架，只通过update就可以更新wicket程序，很方便。
        首先看一下jetty如何整合到OSGi中，建一个Bundle（wanged_core_jetty）写一个Jetty的类：
java 代码
 
  1. package wanged.core.jetty;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.mortbay.jetty.Handler;  
  6. import org.mortbay.jetty.Server;  
  7. import org.mortbay.jetty.handler.HandlerCollection;  
  8.   
  9. public class Jetty {  
  10.   
  11.     private Server server = new Server(8080);  
  12.   
  13.     private HandlerCollection handlerCollection;  
  14.   
  15.     private List<Handler> handlers;  
  16.   
  17.     public void start() {  
  18.   
  19.         if (handlers != null && handlers.size() > 0) {  
  20.             this.handlerCollection.setHandlers(handlers.toArray(new Handler[handlers.size()]));  
  21.         }  
  22.   
  23.         this.server.setHandler(handlerCollection);  
  24.         try {  
  25.             this.server.start();  
  26.         } catch (Exception e) {  
  27.             e.printStackTrace();  
  28.         }  
  29.     }  
  30.   
  31.     public void stop() {  
  32.         try {  
  33.             this.server.stop();  
  34.         } catch (Exception e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.   
  39.     public void setHandlerCollection(HandlerCollection handlerCollection) {  
  40.         this.handlerCollection = handlerCollection;  
  41.     }  
  42.   
  43.     /** 
  44.      * 设置要添加到HandlerCollection中的Handler 
  45.      *  
  46.      * @param handlers 
  47.      */  
  48.     public void setHandlers(List<Handler> handlers) {  
  49.         this.handlers = handlers;  
  50.     }  
  51.   
  52. }  
这个Bundle中就一个类，下面看配置文件：
xml 代码
 
  1. <osgi:service interface="org.mortbay.jetty.HandlerContainer" ref="handlerCollection" />  
  2.   
  3. <!-- Jetty访问日志 -->  
  4. <bean name="requestLog" class="org.mortbay.jetty.NCSARequestLog">  
  5.   <property name="filename" value="F:/TMP/yyyy_mm_dd.request.log" />  
  6.   <property name="filenameDateFormat" value="yyyy_MM_dd" />  
  7.   <property name="logDateFormat" value="yyyy-MM-dd HH:mm:ss" />  
  8.   <property name="logLatency" value="true" />  
  9.   <property name="extended" value="false" />  
  10. </bean>  
  11.   
  12. <!-- Jetty访问日志处理器 -->  
  13. <bean name="requestLogHandler" class="org.mortbay.jetty.handler.RequestLogHandler">  
  14.   <property name="requestLog" ref="requestLog" />  
  15. </bean>  
  16.   
  17. <!-- 处理器集合 -->  
  18. <bean name="handlerCollection" class="org.mortbay.jetty.handler.HandlerCollection" />  
  19.   
  20. <!-- Jetty服务器 -->  
  21. <bean name="jettyServer" class="wanged.core.jetty.Jetty" init-method="start" destroy-method="stop">  
  22.   <property name="handlerCollection" ref="handlerCollection" />  
  23.   <property name="handlers">  
  24.     <list>  
  25.       <ref bean="requestLogHandler" />  
  26.     </list>  
  27.   </property>  
  28. </bean>  
好了，这个已经搞定，目前Jetty可以单独启动了。
       下面来看wicket的bundle，中间涉及到4个主要类：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import org.mortbay.jetty.HandlerContainer;  
  4. import org.mortbay.jetty.webapp.WebAppContext;  
  5. import org.springframework.beans.BeansException;  
  6. import org.springframework.context.ApplicationContext;  
  7. import org.springframework.context.ApplicationContextAware;  
  8.   
  9. public class WicketApplication implements ApplicationContextAware {  
  10.   
  11.     private WebAppContext ctx;  
  12.   
  13.     public WicketApplication(String webApp, String contextPath) {  
  14.         ctx = new WebAppContext(webApp, contextPath);  
  15.     }  
  16.   
  17.     public void start() throws Exception {  
  18.         ctx.start();  
  19.     }  
  20.   
  21.     public void stop() throws Exception {  
  22.         ctx.stop();  
  23.     }  
  24.   
  25.     /** 
  26.      * Jetty的HandlerContainer，用于注册web上下文 
  27.      *  
  28.      * @param handlerContainer 
  29.      */  
  30.     public void setHandlerContainer(HandlerContainer handlerContainer) {  
  31.         handlerContainer.addHandler(ctx);  
  32.     }  
  33.   
  34.     public void setApplicationContext(ApplicationContext context) throws BeansException {  
  35.         // 设置Spring的应用上下文参数  
  36.         ctx.setAttribute(ApplicationContext.class.getName(), context);  
  37.     }  
  38. }  
这个用来启动wicket的web应用，具体配置请看后面的配置文件。
        Wicket本身和Spring的整合很简单，这里借鉴了官方实现写了两个简单的类来处理：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import java.lang.annotation.ElementType;  
  4. import java.lang.annotation.Retention;  
  5. import java.lang.annotation.RetentionPolicy;  
  6. import java.lang.annotation.Target;  
  7.   
  8. @Retention(RetentionPolicy.RUNTIME)  
  9. @Target( { ElementType.FIELD })  
  10. public @interface SpringBean {  
  11.   
  12.     /** 
  13.      * 被引用Bean的名称;如果没有指定 
  14.      *  
  15.      * @return name String 被引用Bean的名称 
  16.      */  
  17.     String name() default "";  
  18. }  
这个声明了一个原数据，你的Wicket组件中使用方法如下：
java 代码
 
  1. private static final class LoginForm extends Form {  
  2.         @SpringBean  
  3.         private transient RoleService roleService;  
  4.         ......  
  5. }  
这样就可以通过下面这个类，自动将Bean注入。
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import java.lang.reflect.Field;  
  4. import java.util.Collections;  
  5. import java.util.HashMap;  
  6. import java.util.Map;  
  7.   
  8. import org.apache.wicket.Component;  
  9. import org.apache.wicket.application.IComponentInstantiationListener;  
  10. import org.springframework.context.ApplicationContext;  
  11.   
  12. public class SpringComponentInjector implements IComponentInstantiationListener {  
  13.   
  14.     public final static String WICKET_PACKAGE = "org.apache.wicket";  
  15.   
  16.     private HashMap<Class<Component>, Map<Field, SpringBean>> AnnotationCacheMap = new HashMap<Class<Component>, Map<Field, SpringBean>>();  
  17.   
  18.     private ApplicationContext context;  
  19.   
  20.     /** 
  21.      * 添加Spring上下文环境，以便从配置文件中装配所需的bean 
  22.      *  
  23.      * @param context ApplicationContext Spring上下文环境 
  24.      */  
  25.     public SpringComponentInjector(ApplicationContext context) {  
  26.         this.context = context;  
  27.     }  
  28.   
  29.     @SuppressWarnings("unchecked")  
  30.     @Override  
  31.     public void onInstantiation(Component component) {  
  32.         Map<Field, SpringBean> fieldMap = getFieldMap((Class<Component>) component.getClass());  
  33.         if (fieldMap != null) {  
  34.             // 将Bean注入到对应的Field中  
  35.             for (Map.Entry<Field, SpringBean> entry : fieldMap.entrySet()) {  
  36.                 this.inject(entry.getKey(), component, entry.getValue());  
  37.             }  
  38.         }  
  39.     }  
  40.   
  41.     /** 
  42.      *  
  43.      * @param clazz 
  44.      * @return null 当clazz是wicket自身的类或者没有包含需要依赖注入的域时返回null 
  45.      */  
  46.     private final Map<Field, SpringBean> getFieldMap(Class<Component> clazz) {  
  47.   
  48.         // 判断clazz是否是wicket项目的类，即其类全称以org.apache.wicket开头  
  49.         if (clazz.getName().startsWith(WICKET_PACKAGE)) {  
  50.             return null;  
  51.         }  
  52.   
  53.         // 从缓存中获得  
  54.         synchronized (AnnotationCacheMap) {  
  55.             Map<Field, SpringBean> map = AnnotationCacheMap.get(clazz);  
  56.   
  57.             if (map == null) {  
  58.                 map = createFieldMap(clazz);  
  59.                 AnnotationCacheMap.put(clazz, map);  
  60.             }  
  61.             return map;  
  62.         }  
  63.   
  64.     }  
  65.   
  66.     private Map<Field, SpringBean> createFieldMap(Class<Component> clazz) {  
  67.         Map<Field, SpringBean> map = new HashMap<Field, SpringBean>();  
  68.   
  69.         for (Field field : clazz.getDeclaredFields()) {  
  70.             SpringBean beanAnon = field.getAnnotation(SpringBean.class);  
  71.             if (beanAnon != null) {  
  72.                 map.put(field, beanAnon);  
  73.             }  
  74.         }  
  75.   
  76.         // 该类中没有需要注入的域  
  77.         if (map.size() == 0) {  
  78.             return null;  
  79.         }  
  80.   
  81.         // 只读限制  
  82.         return Collections.unmodifiableMap(map);  
  83.     }  
  84.   
  85.     private final void inject(Field field, Object instance, SpringBean beanAnon) {  
  86.         Object o = this.getBean(field, beanAnon);  
  87.         if (o != null) {  
  88.             try {  
  89.                 if (field.isAccessible()) {  
  90.                     field.set(instance, o);  
  91.                 } else {  
  92.                     field.setAccessible(true);  
  93.                     field.set(instance, o);  
  94.                     field.setAccessible(false);  
  95.                 }  
  96.             } catch (IllegalArgumentException e) {  
  97.                 e.printStackTrace();  
  98.             } catch (IllegalAccessException e) {  
  99.                 e.printStackTrace();  
  100.             }  
  101.         }  
  102.     }  
  103.   
  104.     private final Object getBean(Field field, SpringBean beanAnon) {  
  105.         String beanName = beanAnon.name();  
  106.   
  107.         if ("".equals(beanName)) {  
  108.             beanName = field.getName();  
  109.         }  
  110.         return this.context.getBean(beanName);  
  111.     }  
  112.   
  113. }  
主要的类都已经有了，现在就缺每个wicket都需要的WebApplication类的子类了：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import java.io.File;  
  4.   
  5. import org.apache.wicket.protocol.http.WebApplication;  
  6. import org.apache.wicket.session.ISessionStore;  
  7. import org.apache.wicket.util.lang.PackageName;  
  8. import org.springframework.context.ApplicationContext;  
  9.   
  10. import wanged.web.wicket.page.help.ErrorPage;  
  11. import wanged.web.wicket.page.login.Login;  
  12.   
  13. public class DefaultApplication extends WebApplication {  
  14.   
  15.     public static final String DISK_STORE_PATH = "DISK_STORE_PATH";  
  16.   
  17.     @SuppressWarnings("unchecked")  
  18.     @Override  
  19.     public Class getHomePage() {  
  20.         return Login.class;  
  21.     }  
  22.   
  23.     @Override  
  24.     protected void init() {  
  25.         ApplicationContext ac = (ApplicationContext) getServletContext().getAttribute(ApplicationContext.class.getName());  
  26.         this.addComponentInstantiationListener(new SpringComponentInjector(ac));  
  27.         this.mount("/login", PackageName.forClass(Login.class));  
  28.         this.mount("/help", PackageName.forClass(ErrorPage.class));  
  29.     }  
  30.   
  31.     @Override  
  32.     protected ISessionStore newSessionStore() {  
  33.         getServletContext().setAttribute("javax.servlet.context.tempdir", new File(getInitParameter("pageStorePath")));  
  34.         return super.newSessionStore();  
  35.     }  
  36.   
  37. }  
有了这些类，还需要配置文件将他们组合起来才能使用：
xml 代码
 
  1. <osgi:reference interface="org.mortbay.jetty.HandlerContainer" id="handlerContainer" />  
  2.   
  3. <bean id="wicketApp" class="wanged.web.wicket.WicketApplication" init-method="start" destroy-method="stop">  
  4.   <constructor-arg value="d:/Workspace/wanged_wicket_app/webapp" />  
  5.   <constructor-arg value="/" />  
  6.   <property name="handlerContainer" ref="handlerContainer" />  
  7. </bean>  
有了上面的配置还需要一点，就是我们的web应用的根目录d:/Workspace/wanged_wicket_app/webapp，在这里我们放置静态文件和web.xml：
xml 代码
 
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"  
  3.   xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
  4.   xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  
  5.   version="2.5">  
  6.   
  7.   <filter>  
  8.     <filter-name>gzipFilter</filter-name>  
  9.     <filter-class>org.mortbay.servlet.GzipFilter</filter-class>  
  10.   </filter>  
  11.   
  12.   <filter>  
  13.     <filter-name>wicketFilter</filter-name>  
  14.     <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>  
  15.     <init-param>  
  16.       <param-name>applicationClassName</param-name>  
  17.       <param-value>wanged.web.wicket.DefaultApplication</param-value>  
  18.     </init-param>  
  19.     <init-param>  
  20.       <param-name>pageStorePath</param-name>  
  21.       <param-value>F:/TMP</param-value>  
  22.     </init-param>  
  23.     <init-param>  
  24.       <param-name>configuration</param-name>  
  25.       <param-value>development</param-value>  
  26.     </init-param>  
  27.   </filter>  
  28.   
  29.   <filter-mapping>  
  30.     <filter-name>gzipFilter</filter-name>  
  31.     <url-pattern>/*</url-pattern>  
  32.   </filter-mapping>  
  33.   
  34.   <filter-mapping>  
  35.     <filter-name>wicketFilter</filter-name>  
  36.     <url-pattern>/wkt/*</url-pattern>  
  37.   </filter-mapping>  
  38.   
  39. </web-app>  

好了，现在就自己写一个Wicket页面尝试一下吧^_^
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 08 Sep 2007 14:16:09 +0800 http://mywicket.group.javaeye.com/group/blog/121966 http://mywicket.group.javaeye.com/group/blog/121966 Rose4J 新的WEB开发引擎 lthu 作者: lthu  链接：http://mywicket.group.javaeye.com/group/blog/118095  发表时间: 2007年08月29日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最新内容请参考www.rose4j.cn

根据我的经验，一个典型的Web应用中的代码比例如下：
页面逻辑约占 50%，商业逻辑约占30%, O/R 约占20%。

但事实上，页面却是最不受重视的部分，从来都被认为是脏活，累活，杂活。典型的开发过程通常是这样：
页面设计人员迅速的用Dreamweaver等生成一堆文本杂乱无章的页面，然后交给JSP程序员加入更加杂乱无章的Java代码和Taglib。
当页面布局风格需要改变的时候，页面设计人员用Dreamweaver等生成一堆新的页面。JSP程序员再重新加入更加杂乱无章的Java代码Taglib。
至于页面中的脚本逻辑调试，更是一门精深的工夫了。

根据社会规则，通常来说，工作内容越轻松，收入越高；工作内容越脏月累，收入越低；Web开发也是如此：做着最脏最累的活的页面程序员，工资一般比不上后台业务逻辑程序员。

开发框架通常会带来这样的结果：让简单的东西，变得更简单；让复杂的东西，变得更复杂。

于是就有了研发RoseForJ的想法，希望有前台页面与后台java程序能完全分开，当程序员拿到页面嵌入java代码后，在Dreamweaver中不会影响页面排版效果，当页面需要修改时，页面设计人员用Dreamweaver进行修改时不影响现有的页面。

wicket、xmlc 、Tapestry 等已有此项功能，wicket在服务器端的编程过于复杂，Freemarker, Velocity在view层和html混合在一起，嵌入代码后的页面在Dreamweaver中一般会乱掉。

RoseForJ的思路是 Velocity在XML DOM领域的扩展。

如果说，Fastm = JDynamiTe + Wicket；DOMPlus = XMLC + Wicket，那么RoseForJ=xmlc+wicket+velocity

下面我们来看看RoseForJ的模板

 

  1. >  
  2. <html xmlns:j="http://www.mobi99.cn">  
  3. <head>  
  4. <title>${title}title>  
  5.   
  6. head>  
  7.   
  8. <body>  
  9. <ul>  
  10.  <li j:foreach="${dataSet}" j:item="${data}">  
  11.   <span j:tid='${data.getName()}' id="showname">这里显示NAMEspan>  
  12.         <j:tempnode j:tid='${data.getName()}'>这里显示NAMEj:tempnode>  
  13.    <img src="http://localhost/roseforj/listImg.do?id=${data.getId()}" width="200" />  
  14.    xxx.id=${xxx.getId()}   
  15.  li>  
  16. ul>  
  17. <j:include path='/xml/include.html'/>  
  18. body>  
  19. html>  

 


从上面模板可以看出RoseForJ只有两个TAG（tempnode、include）和3个属性（foreach、item，tid），它也是一个标记语言，写法如下 ${变量表达式} 。

          其中3个属性可用于html任何标签（如用于tr ，td等），foreach、item配合使用，表示一个循环，foreach="${dataSet}"   ,此时dataSet是一个集合对象或数组，item="${data}" ，data表示集合对象或数组对象中每一个成员。

         ${变量表达式} 的用法非常灵活，可在任何位置，如上面的用法：

1、这里作为TAG 的text的值，运行结束后将替换掉 "这里显示NAME" 这段文本

  1. <span j:tid='${data.getName()}' id="showname">这里显示NAMEspan>  

2、此处用法是作为HTML TAG img的属性src的参数值。

  1. <img src="http://localhost/roseforj/listImg.do?id=${data.getId()}" width="200" />  


3、xxx.id=${data.getId()} 可以直接输出。

         两个TAG（tempnode、include）中include不用说一看就知道是引入外面的一个模板文件，tempnode的作用是在解析完成后，会将此tempnode节点删除，如在此处的应用

xml 代码
  1. <div class="dtree">      
  2. <a href="javascript: d.openAll();">展开a> | <a href="javascript: d.closeAll();">关闭>      
  3. <script type="text/javascript">      
  4.  d = new dTree('d');       
  5.         
  6.  d.add(0,-1,'系统菜单','#',"showMenu",null);        
  7.  <j:tempnode j:foreach="${MenuSet}" j:item="${data}">      
  8.   d.add('${data.get("id")}','${data.get("i_parentid")}','${data.get("c_title")}','${data.get("c_target")}');       
  9. j:tempnode>        
  10.  document.write(d);       
  11. script>
  12.   


我们都知道在script TAG中是不允许出现其它tag的，所以此处的运行结果为：

xml 代码
  1. <script type="text/javascript">  
  2.     d = new dTree('d');   
  3.        
  4.     d.add(0,-1,'系统菜单','#',"showMenu",null);    
  5.        
  6.         d.add('1','0','频道管理','../channel/listChannel.do','mainFrame');   
  7.        
  8.         d.add('2','0','内容管理','../content/listContent.do','mainFrame');   
  9.        
  10.         d.add('3','1','新增频道','../channel/editChannel.do','mainFrame');   
  11.        
  12.         d.add('4','2','新增内容','../content/editContent.do','mainFrame');   
  13.        
  14.         d.add('5','0','角色管理','../role/listRole.do','mainFrame');   
  15.        
  16.         d.add('6','0','用户管理','../user/listUser.do','mainFrame');   
  17.        
  18.         d.add('7','5','新增角色','../role/editRole.do','mainFrame');   
  19.        
  20.         d.add('8','6','新增用户','../user/editUser.do','mainFrame');   
  21.        
  22.         d.add('9','0','菜单管理','../menu/listMenu.do','mainFrame');   
  23.        
  24.         d.add('10','9','新增菜单','../menu/editMenu.do','mainFrame');   
  25.        
  26.     document.write(d);   
  27. script>  


从上面的代码可以看出tempnode 节点被删除了

在服务器端的编程则更加简单，几乎没有任何约束，你可以用hibernate，ibaits，javabean或者自己组织的任何对象，同时还可以嵌套使用，如：

java 代码
  1. package juan.framework;   
  2.   
  3. import java.util.ArrayList;   
  4. import java.util.List;   
  5.   
  6. public class ValueObject {   
  7.    private int id=0;   
  8.    private String name="tom";   
  9.       
  10.    private List aList=new ArrayList();   
  11.       
  12.    public List getList() {   
  13.       return aList;   
  14.    }   
  15.   
  16.    public void setList(List list) {   
  17.       aList = list;   
  18.    }   
  19.   
  20.    public int getId() {   
  21.       return id;   
  22.    }   
  23.   
  24.    public void setId(int id) {   
  25.       this.id = id;   
  26.    }   
  27.   
  28.    public String getName() {   
  29.       return name;   
  30.    }   
  31.   
  32.    public void setName(String name) {   
  33.       this.name = name;   
  34.    }   
  35. }   
  36.   
  37.   
  38. package juan.framework;   
  39.   
  40. import java.util.ArrayList;   
  41. import java.util.List;   
  42. import java.util.Vector;   
  43.   
  44. import juan.framework.context.IContext;   
  45. import juan.framework.context.impl.InnerContextImpl;   
  46. import juan.framework.runtime.RuntimeSingleton;   
  47.   
  48. public class Test {   
  49.   
  50.    /**  
  51.     * @param args  
  52.     */  
  53.    public static void main(String[] args) throws Exception{   
  54.       String filename = "/xml/hell.html"; //要访问的模板path   
  55.       Vector paths = new Vector();   
  56.       paths.add("E:\\workspace\\Test\\juan");  //模板存放的path，可以有多个   
  57.       RuntimeSingleton.init(paths);   
  58.   
  59.   
  60.       IContext context=new InnerContextImpl();   
  61.       context.put("title", "www.mobi99.cn");   
  62.          
  63.       ValueObject vo1=new ValueObject();   
  64.       vo1.setId(9999);   
  65.       vo1.setName("vovovovovov");   
  66.          
  67.       context.put("data", vo1);    
  68.          
  69.          
  70.       List aList=new ArrayList();    
  71.       ValueObject[] xxSet=new ValueObject[2];   
  72.          
  73.       ValueObject vo=new ValueObject();   
  74.       vo.setId(100);   
  75.       vo.setName("tony");   
  76.          
  77.          
  78.       aList.add(vo);   
  79.       xxSet[0]=vo;   
  80.          
  81.       vo=new ValueObject();   
  82.       vo.setId(200);   
  83.       vo.setName("tom");   
  84.       aList.add(vo);   
  85.       xxSet[1]=vo;   
  86.          
  87.       context.put("dataSet", aList);   
  88.       context.put("xxSet", xxSet);   
  89.   
  90.       RuntimeSingleton.getTemplate(filename, "GBK").merge(context,null); //此处null为writer，demo中省掉了   
  91.    }   
  92. }   
  93.   

从上面的编码中可以看出RoseForJ对数据的要求几乎是没有任何要求的，可以是pojo 如可以这样用${data.getName()}，也可以是个集合类，则可以这样取值${data.get("c_author")} ，还可以嵌套调用如：${ChannelFactory.get(data.get("c_channelid"))} ，data.get("c_channelid")运行的结果作为ChannelFactory.get(...)的参数，另外RoseForJ还提供了格式化输出等工具，如日期输出${DateTool.format("yyyy-MM-dd",data.get("t_starttime"))} ，数学运算

a href="listContent.do?pages=${MathTool.sub(iPageCurrent,1)}">上一页
a href="listContent.do?pages=${MathTool.add(iPageCurrent,1)}">下一页

 太晚了，明天再接着写

 

 

 


本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 29 Aug 2007 23:24:56 +0800 http://mywicket.group.javaeye.com/group/blog/118095 http://mywicket.group.javaeye.com/group/blog/118095 Wicket如何通过OSGi框架注入Jetty earls 作者: earls  链接：http://mywicket.group.javaeye.com/group/blog/116150  发表时间: 2007年08月24日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

       Wicket框架的优点就不多说了，总之第一次看到她就让人耳目一新。我的框架就是采用OSGi、Spring、Hibernate、Wicket、Jetty等开源技术搭建的，所以这篇文章就是我在将Wicket通过OSGi框架注入Jetty中的一点心得体会。目前wicket刚刚推出1.3Beta3版，由于1.3版和2.0版比较接近，所以采用1.3版来测试。
       首先介绍一下我的整体思路，将Jetty和wicket分别作为OSGi的Bundle，对外提供服务；自己的基于wicket的web应用也作为一个Bundle。另外因为web应用中要用到其它Bundle提供的服务，当然采用IOC方式最方便，所以需要wicket和spring整合一下。
       先说Jetty和Wicket这两个Bundle，其实Jetty6.1.5已经兼容OSGi，它的jar包已经可以直接作为Bundle使用，我们目前涉及到的就是其安装目录下的lib/jetty-6.1.5.jar，lib/jetty-util-6.1.5.jar和lib/servlet-api-2.5.6.1.5.jar这三个jar包。前两个是jetty作为嵌入式服务器所必需的，最后一个是jetty的servlet实现。
       因为我们采用编程式处理web应用，所以需要将web应用的信息注入到Jetty中。那么为什么不使用配置文件如web.xml呢？因为如果使用配置文件就要解决两个问题：
       第一是绝对路径问题，OSGi的Bundle并没有自己固定部署的位置，所以部署时绝对路径可以任选，这样如果采用配置文件声明web应用，那么配置文件就要随着Bundle位置变更而变更，一般Bundle都是jar包的形式保存，势必导致修改的困难。
       第二是类加载问题，因为我们要使用IOC和其他Bundle声明的服务，如果采用配置文件方式，类的初始化都由ClassLoader直接处理，因此上面所说的很难办到。   
       采用编程式处理web应用，就需要建一个Bundle（wanged_core_jetty），用来处理其他Bundle提供的Handler（这个jetty中的主要部件，可以参看Jetty 6.1.5的配置一文）。先看配置文件bean.xml：
xml 代码
 
  1. <bean id="jettyHandlerManager" class="wanged.core.jetty.JettyHandlerManager">  
  2.   <property name="handlers" ref="handlers" />  
  3. </bean>  
  4.   
  5. <bean name="jettyServer" class="wanged.core.jetty.JettyServer" init-method="start" destroy-method="stop" />  
以及osgi-service.xml：
xml 代码
 
  1. <!-- 服务 和 引用 -->  
  2. <osgi:reference id="handlers" interface="org.mortbay.jetty.Handler" cardinality="1..n">  
  3.   <osgi:listener ref="jettyServer" />  
  4. </osgi:reference>  
这里引用了其他Bundle提供的接口为org.mortbay.jetty.Handler的服务，并注册一个监听器jettyServer来处理Handler的动态绑定与删除问题，以便可以动态添加/删除web应用。下面看看具体代码：
java 代码
 
  1. package wanged.core.jetty;  
  2.   
  3. import java.util.Dictionary;  
  4.   
  5. import org.mortbay.jetty.Handler;  
  6. import org.mortbay.jetty.Server;  
  7. import org.mortbay.jetty.handler.HandlerCollection;  
  8. import org.springframework.osgi.service.TargetSourceLifecycleListener;  
  9.   
  10. /** 
  11.  * 启动Jetty服务器，监听Handler的添加与删除，并动态更新服务器的Handler 
  12.  * @author wanged 
  13.  * 
  14.  */  
  15.   
  16. @SuppressWarnings("unchecked")  
  17. public class JettyServer implements TargetSourceLifecycleListener{  
  18.       
  19.     private Server server = new Server(8080);  
  20.       
  21.     private HandlerCollection handlers = new HandlerCollection();  
  22.       
  23.     public void start(){  
  24.         this.server.setHandler(this.handlers);  
  25.         try {  
  26.             this.server.start();  
  27.         } catch (Exception e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.     }  
  31.       
  32.     /** 
  33.      * 绑定新的Handler，并启动之 
  34.      */  
  35.     public void bind(Object obj, Dictionary dict) throws Exception {  
  36.         Handler h = (Handler)obj;  
  37.         this.handlers.addHandler(h);  
  38.         h.start();  
  39.     }  
  40.       
  41.     /** 
  42.      * 删除Handler，并停止之 
  43.      */  
  44.     public void unbind(Object obj, Dictionary dict) throws Exception {  
  45.         Handler h = (Handler)obj;  
  46.         this.handlers.removeHandler(h);  
  47.         h.stop();  
  48.     }  
  49.       
  50.     public void stop(){  
  51.         try {  
  52.             this.server.stop();  
  53.         } catch (Exception e) {  
  54.             e.printStackTrace();  
  55.         }  
  56.     }  
  57.   
  58. }  
实现接口TargetSourceLifecycleListener，监听服务的绑定与删除。另一个类如下：
java 代码
  1. package wanged.core.jetty;  
  2.   
  3. import java.util.Collection;  
  4.   
  5. import org.mortbay.jetty.Handler;  
  6.   
  7. /** 
  8.  * Jetty服务器Handler的管理器，用来动态管理作为服务注册的Handler 
  9.  * @author wanged 
  10.  * 
  11.  */  
  12. public class JettyHandlerManager {  
  13.     private Collection<Handler> handlers;  
  14.   
  15.     public void setHandlers(Collection<Handler> handlers) {  
  16.         this.handlers = handlers;  
  17.     }  
  18.   
  19. }  
这个类只是简单声明了一个setHandlers方法，功能可以扩展。到此为止Jetty的相关工作已经处理完了。
       下面该说说web应用了，我的web应用放在一个叫wanged_wicket_app的Bundle中。涉及到的类比较多，所以现将类列出再一一解说。首先看SpringWicketFilter：
java 代码
  1. package wanged.web.wicket;  
  2.   
  3. import org.apache.wicket.protocol.http.IWebApplicationFactory;  
  4. import org.apache.wicket.protocol.http.WicketFilter;  
  5.   
  6. public class SpringWicketFilter extends WicketFilter{  
  7.     private IWebApplicationFactory factory ;  
  8.       
  9.     public IWebApplicationFactory getApplicationFactory(){  
  10.         return factory;  
  11.     }  
  12.           
  13.     public void setApplicationFactory(IWebApplicationFactory factory){  
  14.         this.factory = factory;  
  15.     }  
  16.       
  17. }  
为什么不直接用WicketFilter呢，因为WicketFilter需要有一个applicationClass的参数需要定义在init-param中，需要解析web.xml才能得到，而且生成的WebApplication不能使用IOC功能。熟悉Wicket的朋友会问，Wicket不是已经和Spring整合了么？是的，确实整合了，但这种整合无法用在OSGi环境下，所以我们需要自定义一个WicketFilter的子类来声明一个注入了Spring上下文的IWebApplicationFactory的实现SpringWebApplicationFactory：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import org.apache.wicket.protocol.http.IWebApplicationFactory;  
  4. import org.apache.wicket.protocol.http.WebApplication;  
  5. import org.apache.wicket.protocol.http.WicketFilter;  
  6. import org.springframework.beans.BeansException;  
  7. import org.springframework.context.ApplicationContext;  
  8. import org.springframework.context.ApplicationContextAware;  
  9.   
  10. public class SpringWebApplicationFactory implements IWebApplicationFactory, ApplicationContextAware {  
  11.     private WebApplication webApplication;  
  12.   
  13.     private ApplicationContext context;  
  14.   
  15.     private String diskStorePath;  
  16.   
  17.     public void init() {  
  18.         DefaultApplication app = new DefaultApplication();  
  19.         app.setApplicationContext(context);  
  20.         app.setDiskStorePath(this.diskStorePath);  
  21.         this.webApplication = app;  
  22.     }  
  23.   
  24.     public WebApplication createApplication(WicketFilter filter) {  
  25.         return webApplication;  
  26.     }  
  27.   
  28.     public void setApplicationContext(ApplicationContext context) throws BeansException {  
  29.         this.context = context;  
  30.     }  
  31.       
  32.     public void setDiskStorePath(String path){  
  33.         this.diskStorePath = path;  
  34.     }  
  35. }  
这里引用了一个DefaultApplication，这是WebApplication的子类，在Wicket应用中有至关重要的作用，每一个wicket的web应用都需要自定义一个：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import java.io.File;  
  4.   
  5. import org.apache.wicket.protocol.http.SecondLevelCacheSessionStore;  
  6. import org.apache.wicket.protocol.http.WebApplication;  
  7. import org.apache.wicket.protocol.http.pagestore.DiskPageStore;  
  8. import org.apache.wicket.session.ISessionStore;  
  9. import org.apache.wicket.spring.injection.annot.SpringComponentInjector;  
  10. import org.apache.wicket.util.lang.Bytes;  
  11. import org.springframework.beans.BeansException;  
  12. import org.springframework.context.ApplicationContext;  
  13. import org.springframework.context.ApplicationContextAware;  
  14.   
  15. import wanged.web.wicket.login.LoginPage;  
  16.   
  17. public class DefaultApplication extends WebApplication implements ApplicationContextAware {  
  18.     private ApplicationContext context;  
  19.     private String diskStorePath;  
  20.   
  21.       
  22.     @SuppressWarnings("unchecked")  
  23.     @Override  
  24.     public Class getHomePage() {  
  25.         return LoginPage.class;  
  26.     }  
  27.   
  28.     @Override  
  29.     public void init() {  
  30.         super.init();  
  31.         addComponentInstantiationListener(new SpringComponentInjector(this, this.context));  
  32.     }  
  33.   
  34.     public void setApplicationContext(ApplicationContext context) throws BeansException {  
  35.         this.context = context;  
  36.     }  
  37.   
  38.     protected ISessionStore newSessionStore() {  
  39.         return new SecondLevelCacheSessionStore(this, new DiskPageStore(new File(this.diskStorePath), (int) Bytes.megabytes(10).bytes(), (int) Bytes.megabytes(  
  40.                         100).bytes(), 25));  
  41.     }  
  42.       
  43.     public void setDiskStorePath(String path){  
  44.         this.diskStorePath = path;  
  45.     }  
  46. }  
由于Wicket1.3开始采用Filter处理Request，不再使用Servlet，所以我们的环境中只需要配置Filter的相关信息即可。为了能采用IOC方式配置Filter及其映射，引入一个新类FilterMapping：
java 代码
 
  1. package wanged.web.wicket;  
  2.   
  3. import javax.servlet.Filter;  
  4.   
  5. public class FilterMapping {  
  6.     private Class<Filter> filterClass;  
  7.   
  8.     private Filter filter;  
  9.   
  10.     private String urlPattern = "/*";  
  11.   
  12.     public Class<Filter> getFilterClass() {  
  13.         return filterClass;  
  14.     }  
  15.   
  16.     public void setFilterClass(Class<Filter> filterClass) {  
  17.         this.filterClass = filterClass;  
  18.     }  
  19.   
  20.     public Filter getFilter() {  
  21.         return filter;  
  22.     }  
  23.   
  24.     public void setFilter(Filter filter) {  
  25.         this.filter = filter;  
  26.     }  
  27.   
  28.     public