问道天下 http://earls.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 我的Ext下拉树型框的实现 earls 作者: earls  链接：http://earls.javaeye.com/blog/221032  发表时间: 2008年07月29日

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

cms.form.ComboTree = function(options) {
	cms.form.ComboTree.superclass.constructor.call(this, options);
};

Ext.extend(cms.form.ComboTree, Ext.form.TriggerField, {
	triggerClass : 'x-form-arrow-trigger',
	shadow : 'sides',
	lazyInit : true,
	initComponent : function() {
		cms.form.ComboTree.superclass.initComponent.call(this);
	},

	onRender : function(ct, position) {
		Ext.form.ComboBox.superclass.onRender.call(this, ct, position);
		var hiddenName = this.name;

		this.hiddenField = this.el.insertSibling({
			tag : 'input',
			type : 'hidden',
			name : hiddenName
		}, 'before', true);

		this.hiddenField.value = this.value !== undefined ? this.value : 0;

		this.el.dom.removeAttribute('name');
		this.id = this.name;

		if (!this.lazyInit) {
			this.initList();
		} else {
			this.on('focus', this.initList, this, {
				single : true
			});
		}
	},

	initList : function() {
		if (this.list) {
			return;
		}
		this.list = new Ext.Layer({
			shadow : this.shadow,
			cls : 'x-combo-list',
			constrain : false
		});

		this.root = new Ext.tree.AsyncTreeNode({expanded :true});
		this.list.setWidth(Math.max(this.wrap.getWidth(), 70));
		tree = new Ext.tree.TreePanel({
			autoScroll : true,
			height : 200,
			border : false,
			root : this.root,
			loader : this.loader
		});

		delete this.loader;

		tree.on('click', this.onClick, this);
		tree.render(this.list);

		this.el.dom.setAttribute('readOnly', true);
		this.el.addClass('x-combo-noedit');
	},
	
	expandNode : function(n, v){
		var cs = n.childNodes;
        for(var i = 0, len = cs.length; i < len; i++) {
        	if(cs[i].id == v){
        		return true;
        	}
        	if(expandNode(cs[i], v)){
				cs[i].expand();
				return true;
        	}
        }
        return false;
	},


	validateValue : function(value) {
		return true;
	},

	validateBlur : function() {
		return !this.list || !this.list.isVisible();
	},

	onDestroy : function() {
		if (this.wrap) {
			this.wrap.remove();
		}
		if (this.list) {
			this.list.destroy();
		}
		cms.form.ComboTree.superclass.onDestroy.call(this);
	},

	isExpanded : function() {
		return this.list && this.list.isVisible();
	},

	collapse : function() {
		if (this.isExpanded()) {
			this.list.hide();
		}
	},

	onClick : function(node) {
		this.setValue(node);
		this.collapse();
	},


	setValue : function(v) {
		var val = v;
		if(typeof v === 'object'){
			this.hiddenField.value = ((this.root && v.id == this.root.id) ? 0 : v.id);
			val = v.text;
		}
		cms.form.ComboTree.superclass.setValue.call(this, val);
	},

	initEvents : function() {
		cms.form.ComboTree.superclass.initEvents.call(this);
		this.el.on('mousedown', this.onTriggerClick, this);
	},

	onTriggerClick : function() {
		if (this.disabled) {
			return;
		}

		if (this.isExpanded()) {
			this.collapse();
			this.el.focus();
		} else {
			this.onFocus({});
			this.list.alignTo(this.wrap, 'tl-bl?');
			this.list.show();
		}
	}

});
Ext.reg('combotree', cms.form.ComboTree); 
做了些修改，重新发了代码，用法和普通field没有什么区别，功能也一样。目前没有遇到什么BUG。
 

 

 

 


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


JavaEye推荐



]]> Tue, 29 Jul 2008 13:17:23 +0800 http://earls.javaeye.com/blog/221032 http://earls.javaeye.com/blog/221032 Wicket中Tree的一些操作 earls 作者: earls  链接：http://earls.javaeye.com/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://earls.javaeye.com/blog/140987 http://earls.javaeye.com/blog/140987 Wicket在OSGi框架下的开发 earls 作者: earls  链接：http://earls.javaeye.com/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://earls.javaeye.com/blog/121966 http://earls.javaeye.com/blog/121966 Wicket如何通过OSGi框架注入Jetty earls 作者: earls  链接：http://earls.javaeye.com/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 String getUrlPattern() {  
  29.         return urlPattern;  
  30.     }  
  31.   
  32.     public void setUrlPattern(String urlPattern) {  
  33.         this.urlPattern = urlPattern;  
  34.     }  
  35.   
  36. }  
内容很简单，不多废话了。到目前为止，我们只是定义了Wicket相关的类文件，如何注入到Jetty中呢？接下来就是最主要的了：
java 代码
  1. package wanged.web;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.List;  
  5. import java.util.Map;  
  6.   
  7. import org.mortbay.jetty.Handler;  
  8. import org.mortbay.jetty.servlet.Context;  
  9. import org.mortbay.jetty.servlet.DefaultServlet;  
  10. import org.mortbay.jetty.servlet.FilterHolder;  
  11. import org.mortbay.jetty.servlet.SessionHandler;  
  12.   
  13. import wanged.web.wicket.FilterMapping;  
  14.   
  15. public class ContextFactory {  
  16.   
  17.     private HashMap<String, String> attributes;  
  18.   
  19.     private List<FilterMapping> filterMappings;  
  20.   
  21.     private Context ctx = new Context();;  
  22.   
  23.     public Context newInstance() {  
  24.         return ctx;  
  25.     }  
  26.   
  27.     public void init() {  
  28.         if (this.attributes != null) {  
  29.             for (Map.Entry<String, String> entry : this.attributes.entrySet()) {  
  30.                 ctx.setAttribute(entry.getKey(), entry.getValue());  
  31.             }  
  32.         }  
  33.         ctx.setSessionHandler(new SessionHandler());  
  34.         ctx.addServlet(DefaultServlet.class, "/");  
  35.   
  36.         for (FilterMapping fm : filterMappings) {  
  37.             ctx.addFilter(new FilterHolder(fm.getFilter()), fm.getUrlPattern(), Handler.REQUEST);  
  38.         }  
  39.     }  
  40.   
  41.     public void setFilterMappings(List<FilterMapping> filterMappings) {  
  42.         this.filterMappings = filterMappings;  
  43.     }  
  44.     public void setAttributes(HashMap<String, String> attributes) {  
  45.         this.attributes = attributes;  
  46.     }  
  47.   
  48.     public void setContextPath(String contextPath) {  
  49.         this.ctx.setContextPath(contextPath);  
  50.     }  
  51.   
  52. }  
这个类负责收集我们配置文件中的bean，然后打包成一个Context作为一个对外声明的Handler服务（注意org.mortbay.jetty.servlet.Context实现了org.mortbay.jetty.Handler接口）。
下面看配置文件web-bean.xml：
xml 代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
  4.   
  5.   <!-- 定义服务实现 -->  
  6.   <bean id="handler" factory-bean="contextFactory" factory-method="newInstance" />  
  7.   
  8.   <!-- Jetty的处理器工厂，用来向Jetty添加处理器 -->  
  9.   <bean id="contextFactory" class="wanged.web.ContextFactory" init-method="init">  
  10.     <property name="contextPath" value="/" />  
  11.     <property name="filterMappings">  
  12.       <!-- Filter执行顺序预定顺序相关 -->  
  13.       <list>  
  14.         <ref bean="gzipFilterMapping" />  
  15.         <ref bean="wicketFilterMapping" />  
  16.       </list>  
  17.     </property>  
  18.   </bean>  
  19.   
  20.   <bean id="gzipFilter" class="org.mortbay.servlet.GzipFilter" />  
  21.   
  22.   <bean id="wicketFilter" class="wanged.web.wicket.SpringWicketFilter">  
  23.     <property name="applicationFactory" ref="applicationFactory" />  
  24.   </bean>  
  25.   
  26.   <bean id="wicketFilterMapping" class="wanged.web.wicket.FilterMapping">  
  27.     <property name="filter" ref="wicketFilter" />  
  28.   </bean>  
  29.   
  30.   <bean id="gzipFilterMapping" class="wanged.web.wicket.FilterMapping">  
  31.     <property name="filter" ref="gzipFilter" />  
  32.   </bean>  
  33.   
  34.   <bean id="applicationFactory" class="wanged.web.wicket.SpringWebApplicationFactory" init-method="init" >  
  35.     <property name="diskStorePath" value="F:/TMP" />  
  36.   </bean>  
  37.   
  38. </beans>  
这里定义了我们所使用到的各种类，同时SpringWebApplicationFactory在此获得Spring上下文信息。
另一个声明服务的配置文件osgi-service.xml：
xml 代码
 
  1. <osgi:service interface="org.mortbay.jetty.Handler" ref="handler" />  
  2.   
  3. <osgi:reference id="roleService" interface="wanged.security.service.RoleService" />  
这里的roleService是引用了外部的一个服务，用来测试Sping注入的（可以用一个在web-bean.xml中定义的bean来代替测试）。
以上已经完成了wicket的web应用注入jetty的工作，最后就是写一个LoginPage.java完成整个Bundle：
java 代码
 
  1. package wanged.web.wicket.login;  
  2.   
  3. import org.apache.wicket.ajax.AjaxRequestTarget;  
  4. import org.apache.wicket.ajax.markup.html.form.AjaxButton;  
  5. import org.apache.wicket.markup.html.WebPage;  
  6. import org.apache.wicket.markup.html.form.Form;  
  7. import org.apache.wicket.markup.html.form.PasswordTextField;  
  8. import org.apache.wicket.markup.html.form.TextField;  
  9. import org.apache.wicket.model.CompoundPropertyModel;  
  10. import org.apache.wicket.model.IModel;  
  11.   
  12. import wanged.security.entity.Role;  
  13. import wanged.security.service.RoleService;  
  14. import org.apache.wicket.spring.injection.annot.SpringBean;  
  15. import org.mortbay.jetty.Handler;  
  16.   
  17. public class LoginPage extends WebPage {  
  18.   
  19.     private LoginUser user;  
  20.   
  21.     public LoginPage() {  
  22.         super();  
  23.         this.user = new LoginUser();  
  24.   
  25.         Form form = new AutoSaveForm("loginForm", new CompoundPropertyModel(user));  
  26.         add(form);  
  27.         form.add(new TextField("username"));  
  28.         form.add(new PasswordTextField("password"));  
  29.     }  
  30.   
  31. }  
  32.   
  33. class AutoSaveForm extends