在项目中使用了Apache xml-rpc，遇到了一个麻烦的问题。spring没有提供对xml-rpc的支持，在处理webservice请求的时候，没有办法使用spring容器中管理的各种各样的bean对象。显然，这是不能接受的。

　　使用Apache xml-rpc，一般只需要在web.xml中定义一个servlet (XmlRpcServlet), 再实现用于处理webservice请求的组件类就可以了。

　　比如定义一个Servlet:

1. <servlet>  
2.     <servlet-name>XmlRpcServletservlet-name>  
3.     <servlet-class>org.apache.xmlrpc.webserver.XmlRpcServletservlet-class>  
4.     <init-param>  
5.         <param-name>enabledForExtensionsparam-name>  
6.         <param-value>trueparam-value>  
7.     init-param>  
8. servlet>  

实现处理webservice请求的组件：

1. public class Calculator   
2. {   
3.     public int add(int i1, int i2)   
4.     {   
5.         return i1 + i2;   
6.     }   
7. }  

　　除此之外，还需要定义一个property文件，告诉xml-rpc,在请求来了以后，用哪个组件去处理。这个property文件必须命名为XmlRpcServlet.properties，并且必须放到org.apache.xmlrpc.webserver包下面。

Properties代码

Calculator=com.oyl.Calculator  

　　这样，当webservice收到请求后，就会初始化一个新的组件对象去处理请求。这样，新的问题也来了，一般的web应用程序都使用spring来管理各个业务组件，通过上面的例子不难发现，www.linuxidc.com 我们没有办法使用spring管理的bean去处理webservice的请求，每次都初始化一个新的对象去处理请求，也会造成资源的浪费。

　　那么，怎么才能在xml-rpc中使用spring管理的bean去处理webservice的请求呢？

　　首先，要实现一个接口org.apache.xmlrpc.server.RequestProcessorFactoryFactory，这个接口类定义了如何创建对象去处理webservice请求：

1. public class CustomRequestProcessorFactoryFactory implements  
2.         RequestProcessorFactoryFactory   
3. {   
4.     private final RequestProcessorFactory factory = new CustomRequestProcessorFactory();   
5.     private final CustomWebServiceHandler service;   
6.   
7.   
8.     public CustomRequestProcessorFactoryFactory(CustomWebServiceHandler service)   
9.     {   
10.         this.service = service;   
11.     }   
12.   
13.   
14.     @Override  
15.     public RequestProcessorFactory getRequestProcessorFactory(Class arg0)   
16.             throws XmlRpcException   
17.     {   
18.         return factory;   
19.     }   
20.   
21.     private class CustomRequestProcessorFactory implements  
22.             RequestProcessorFactory   
23.     {   
24.   
25.         @Override  
26.         public Object getRequestProcessor(XmlRpcRequest arg0)   
27.                 throws XmlRpcException   
28.         {   
29.             return service;   
30.         }   
31.   
32.     }   
33. }  

　　仔细看代码会发现，接口org.apache.xmlrpc.server.RequestProcessorFactoryFactory实际上就是一个工厂的工厂，它是一个用于创建处理webservice请求对象的工厂的工厂类。在上面的例子中，创建webservice请求对象的工厂类是一个实现了RequestProcessorFactory接口的内部类，它主要是返回我们真正需要用来处理请求的CustomWebServiceHandler对象。

　　有了上面这个工厂的工厂类，我们还需要扩展一下默认的XmlRpcServlet。主要是实现newXmlRpcHandlerMapping方法，在newXmlRpcHandlerMapping方法中，把需要用到的spring bean对象取出来，www.linuxidc.com再作为参数创建一个RequestProcessorFactoryFactory对象，就可以达到目的了。

1. public class CustomXmlRpcServlet extends XmlRpcServlet   
2. {   
3.     private static final long serialVersionUID = 8615627610262194L;   
4.     protected static ApplicationContext ctx = null;   
5.   
6.     public CustomXmlRpcServlet()   
7.     {   
8.         super();   
9.     }   
10.   
11.   
12.     public void init()   
13.     {   
14.         if (ctx == null)   
15.         {   
16.             ctx = WebApplicationContextUtils   
17.                     .getRequiredWebApplicationContext(this.getServletContext());   
18.         }   
19.     }   
20.   
21.   
22.     protected XmlRpcHandlerMapping newXmlRpcHandlerMapping()   
23.             throws XmlRpcException   
24.     {   
25.         PropertyHandlerMapping mapping = new PropertyHandlerMapping();   
26.            
27.         CustomWebServiceHandler service = (CustomWebServiceHandler) ctx.getBean("customWebServiceHandler");   
28.            
29.         mapping.setRequestProcessorFactoryFactory(new CustomRequestProcessorFactoryFactory(service));   
30.         mapping.addHandler("CustomWebServiceHandler", CustomWebServiceHandler.class);   
31.   
32.         return mapping;   
33.     }   
34. }  

这样扩展以后，之前提到的XmlRpcServlet.properties文件也不再需要了。