如何用Mule创建动态的HTTP代理服务

 
目的
引入动态http代理的主要目的是在加入新的http代理而不需要重启Mule代理服务。注意，要真正的动态代理，需要注入实现了路径与服务器地址映射的检索服务的Spring的Bean，在enricher位置通过groovy获得Bean的实例进行调用。
 
实例程序的限制：
这个例子程序缺乏生产环境中使用处理：
错误处理
从数据库检索路径的映射配置信息
            这个例子将HTTP相对路径和目标服务器之间的映射写在XML配置文件里。这当然不能允许动态修改代理配置。
支持更多的HTTP方法
             只支持HTTP get和post方法
处理的HTTP参数。
             实例程序没考虑HTTP参数但这些都被认为是在HTTP相对路径的一部分。
支持HTTPS。
 
为了能够有一个服务代理，一个简单的SOAP问候服务使用一个Mule配置文件和一个Java类实现。
Mule配置包含以下配置：
<?xml version="1.0" encoding="UTF-8"?>
<mule
xmlns:cxf="http://www.mulesoft.org/schema/mule/cxf"
xmlns="http://www.mulesoft.org/schema/mule/core"
xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
xmlns:spring="http://www.springframework.org/schema/beans"
xmlns:test="http://www.mulesoft.org/schema/mule/test"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.mulesoft.org/schema/mule/cxf http://www.mulesoft.org/schema/mule/cxf/current/mule-cxf.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/test http://www.mulesoft.org/schema/mule/test/current/mule-test.xsd"
 
<spring:beans>
<spring:bean id="helloService" class="com.ivan.mule.dynamichttpproxy.HelloService"/>
</spring:beans>
 
<flow name="GreetingFlow">
<inbound-endpoint address="http://localhost:8182/services/GreetingService"
exchange-pattern="request-response"/>
 
<cxf:jaxws-service serviceClass="com.ivan.mule.dynamichttpproxy.HelloService"/>
<component>
<spring-object bean="helloService"/>
</component>
</flow>
</mule>
 
服务类：
package com.ivan.mule.dynamichttpproxy;
 
import java.util.Date;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
 
/**
* SOAP web service endpoint implementation class that implements
* a service that extends greetings.
*
* @author Ivan Krizsan
*/
@WebService
public class HelloService {
/**
* Greets the person with the supplied name.
*
* @param inName Name of person to greet.
* @return Greeting.
*/
@WebResult(name = "greeting")
public String greet(@WebParam(name = "inName") final String inName) {
return "Hello " + inName + ", the time is now " + new Date();
}
}
 
 
服务器信息Bean，用于存储原始HTTP请求路径与对应目标服务器ip端口的映射信息：
package com.ivan.mule.dynamichttpproxy;
 
/**
* Holds information about a server which to forward requests to.
*
* @author Ivan Krizsan
*/
public class ServerInformationBean {
private String serverAddress;
private String serverPort;
private String serverName;
 
/**
* Creates an instance holding information about a server with supplied
* address, port and name.
*
* @param inServerAddress
* @param inServerPort
* @param inServerName
*/
public ServerInformationBean(final String inServerAddress,
final String inServerPort, final String inServerName) {
serverAddress = inServerAddress;
serverPort = inServerPort;
serverName = inServerName;
}
 
public String getServerAddress() {
return serverAddress;
}
 
public String getServerPort() {
return serverPort;
}
 
public String getServerName() {
return serverName;
}
}
 
动态HTTP 代理Mule配置：
<?xml version="1.0" encoding="UTF-8"?>
<!--
The dynamic HTTP proxy Mule configuration file.
 
Author: Ivan Krizsan
-->
<mule xmlns:scripting="http://www.mulesoft.org/schema/mule/scripting"
xmlns:http="http://www.mulesoft.org/schema/mule/http"
xmlns="http://www.mulesoft.org/schema/mule/core"
xmlns:doc="http://www.mulesoft.org/schema/mule/documentation"
xmlns:spring="http://www.springframework.org/schema/beans"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:test="http://www.mulesoft.org/schema/mule/test"
version="CE-3.4.0"
xsi:schemaLocation="
http://www.mulesoft.org/schema/mule/cxf http://www.mulesoft.org/schema/mule/cxf/current/mule-cxf.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-current.xsd
http://www.mulesoft.org/schema/mule/core http://www.mulesoft.org/schema/mule/core/current/mule.xsd
http://www.mulesoft.org/schema/mule/test http://www.mulesoft.org/schema/mule/test/current/mule-test.xsd"
 
 
<spring:beans>
<!--
Mappings from path to server represented by a hash map.
A map has been choosen to limit the scope of this example.
Storing data about mappings between path to server in a database
will enable runtime modifications to the mapping data without
having to stop and restart the general proxy Mule application.
-->
<util:map id="pathToServerAndPortMapping" map-class="java.util.HashMap">
<!-- Entry for MyServer. -->
<spring:entry key="services/GreetingService">
<spring:bean class="com.ivan.mule.dynamichttpproxy.ServerInformationBean">
<spring:constructor-arg value="localhost"/>
<spring:constructor-arg value="8182"/>
<spring:constructor-arg value="MyServer"/>
</spring:bean>
</spring:entry>
<!-- Entry for SomeOtherServer. -->
<spring:entry key="services/GreetingService?wsdl">
<spring:bean class="com.ivan.mule.dynamichttpproxy.ServerInformationBean">
<spring:constructor-arg value="127.0.0.1"/>
<spring:constructor-arg value="8182"/>
<spring:constructor-arg value="SomeOtherServer"/>
</spring:bean>
</spring:entry>
</util:map>
</spring:beans>
 
<flow name="HTTPGeneralProxyFlow">
<!--
Note that if you increase the length of the path to, for instance
generalProxy/additionalPath, then the expression determining
the outgoing path need to be modified accordingly.
Changing the path, without changing its length, require no
modification to outgoing path.
-->
<http:inbound-endpoint
exchange-pattern="request-response"
host="localhost"
port="8981"
path="dynamicHttpProxy" doc:name="HTTP Receiver"/>
 
<!-- Extract outgoing path from received HTTP request. -->
<set-property
value="#[org.mule.util.StringUtils.substringAfter(org.mule.util.StringUtils.substringAfter(message.inboundProperties['http.request'], '/'), '/')]"
propertyName="outboundPath"
doc:name="Extract Outbound Path From Request" />
 
<logger message="#[string:Outbound path = #[message.outboundProperties['outboundPath']]]"level="DEBUG"/>
 
<!--
Using the HTTP request path, select which server to forward the request to.
Note that there should be some kind of error handling in case there is no server for the current path.
Error handling has been omitted in this example.
-->
<enricher target="#[variable:outboundServer]">
<scripting:component doc:name="Groovy">
<!--
If storing mapping data in a database, this Groovy script
should be replaced with a database query.
-->
<scripting:script engine="Groovy">
<![CDATA[
def theMap = muleContext.getRegistry().lookupObject("pathToServerAndPortMapping")
def String theOutboundPath = message.getOutboundProperty("outboundPath")
def theServerBean = theMap[theOutboundPath]
theServerBean
]]>
</scripting:script>
</scripting:component>
</enricher>
 
<logger
message="#[string:Server address = #[groovy:message.getInvocationProperty('outboundServer').serverAddress]]"
level="DEBUG"/>
<logger
message="#[string:Server port = #[groovy:message.getInvocationProperty('outboundServer').serverPort]]"
level="DEBUG"/>
<logger
message="#[string:Server name = #[groovy:message.getInvocationProperty('outboundServer').serverName]]"
level="DEBUG"/>
 
<!-- Log the request and its metadata for development purposes, -->
<test:component logMessageDetails="true"/>
 
<!--
Cannot use a MEL expression in the value of the method attribute
on the HTTP outbound endpoints so have to revert to this way of
selecting HTTP method in the outgoing request.
In this example, only support for GET and POST has been implemented.
This can of course easily be extended to support additional HTTP
verbs as desired.
-->
<choice doc:name="Choice">
<!-- Forward HTTP GET requests. -->
<when expression="#[message.inboundProperties['http.method']=='GET']">
<http:outbound-endpoint
exchange-pattern="request-response"
host="#[groovy:message.getInvocationProperty('outboundServer').serverAddress]"
port="#[groovy:message.getInvocationProperty('outboundServer').serverPort]"
method="GET"
path="#[message.outboundProperties['outboundPath']]"
doc:name="Send HTTP GET"/>
</when>
<!-- Forward HTTP POST requests. -->
<when expression="#[message.inboundProperties['http.method']=='POST']">
<http:outbound-endpoint
exchange-pattern="request-response"
host="#[groovy:message.getInvocationProperty('outboundServer').serverAddress]"
port="#[groovy:message.getInvocationProperty('outboundServer').serverPort]"
method="POST"
path="#[message.outboundProperties['outboundPath']]"
doc:name="Send HTTP POST"/>
</when>
<!-- If HTTP method not recognized, use GET. -->
<otherwise>
<http:outbound-endpoint
exchange-pattern="request-response"
host="#[groovy:message.getInvocationProperty('outboundServer').serverAddress]"
port="#[groovy:message.getInvocationProperty('outboundServer').serverPort]"
method="GET"
path="#[message.outboundProperties['outboundPath']]"
doc:name="Default: Send HTTP GET"/>
</otherwise>
</choice>
</flow>
</mule>
 
 
注意：
一个名称为“pathToServerAndPortMapping”用Spring XML配置了路径与服务器地址的映射
<set-property>元素设置了outboundPath属性的值，outboundPath即服务的相对路径，用于检索目标服务器，并对目标服务器发起http:outbound-endpoint.
<enricher>元素部分是使用outboundpath检索对应的ServerInformationBean实例
<choice>元素包含了多个outbound HTTP endpoints。
 
启动Mule工程服务后，现在访问真正的目标服务
http://localhost:8182/services/GreetingService?wsdl
应该能看到WSDL文件内容了。通过soapUI访问，应该能收到包含日期和时间的问候了。
 
接下来，通过soapUI访问代理服务
http://localhost:8981/dynamicHttpProxy/services/GreetingService
 
控制台上会打印如下内容：
... Outbound path = services/GreetingService
... Server address = localhost
... Server port = 8182
... Server name = MyServer
 
转载请注明原创首发地址：如何用Mule创建动态HTTP代理服务
 
标签 : appserver, architecture, esb

  
    
    
      发表评论
      
    
    
  
IT瘾于2015年1月28日 下午06时19分42秒发布
      #
发表评论发送引用通报
Re: 如何用Mule创建动态的HTTP代理服务 Anonymous于2024年12月22日下午04时16分46秒评论 #
标题
正文	HTML : b, strong, i, em, blockquote, br, p, pre, a href="", ul, ol, li, sub, sup
OpenID Login	(Not me?)
姓名
电子邮件
网站
记住我	是否
电邮地址不会公开在网页上，您留下的电子邮件仅用于本文有新评论时通知您（以后可以随时拿掉）。
如何用Mule创建动态的HTTP代理服务

Re: 如何用Mule创建动态的HTTP代理服务
