Wicket如何通过OSGi框架注入Jetty

       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：
以及osgi-service.xml：
这里引用了其他Bundle提供的接口为org.mortbay.jetty.Handler的服务，并注册一个监听器jettyServer来处理Handler的动态绑定与删除问题，以便可以动态添加/删除web应用。下面看看具体代码：
实现接口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应用都需要自定义一个：
由于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 Form {  
34.   
35.     /* 这里就是使用IOC的地方， 
36.         试想一下如果没有IOC，我们如何让自定义的类来获得其他Bean呢 
37.     */  
38.     @SpringBean  
39.     RoleService roleService;  
40.       
41.     AutoSaveForm(String id, IModel m) {  
42.         super(id, m);  
43.         AjaxButton button = new AjaxButton("button", this) {  
44.             @Override  
45.             protected void onSubmit(AjaxRequestTarget target, Form form) {  
46.                 LoginUser user = (LoginUser)form.getModelObject();  
47.                 System.out.println("un: " + user.getUsername());  
48.                 System.out.println("pd: " + user.getPassword());  
49.             }  
50.         };  
51.         this.add(button);  
52.     }  
53. }  

        运行一下一切OK。感觉好繁琐呀！确实如此，OSGi带给我们的是基于组件的面向服务的开发，用来做小项目确实有点大炮打蚊子的感觉，但如果是做大型项目，就能充分体现出组件和SOA的优势。

能否提供个目录结构？

无法贴图，只好这样了
wanged_wicket_app
       classes
       META-INF
             spring
                   osgi-service.xml
                   web-bean.xml
             MANIFEST.MF
       src
             wanged
                   web
                         wicket
                               login
                                     LoginPage.java
                                     LoginPage.html
                               DefaultApplication.java
                               FilterMapping.java
                               SpringWebApplicationFactory.java
                               SpringWicketFilter.java
                         ContextFactory.java

图见附件

谢谢，感觉刚入手好烦。

至少要比它看起来要烦得多。