深入探讨WSDL到WSDL转换的技术细节实用工具最佳实践指南以及如何通过有效转换提升企业服务集成的效率与兼容性

引言

在当今企业服务架构中，Web服务扮演着至关重要的角色，而Web服务描述语言（WSDL）作为描述Web服务的标准格式，其转换和兼容性处理直接影响着服务集成的效率与质量。本文将深入探讨WSDL到WSDL转换的技术细节，介绍实用工具，分享最佳实践，并阐述如何通过有效转换提升企业服务集成的效率与兼容性。

WSDL基础知识

WSDL概述

WSDL（Web Services Description Language）是一种基于XML的描述语言，用于描述Web服务的功能和访问方式。它定义了服务的位置、服务提供的操作以及消息的数据格式。一个标准的WSDL文档通常包含以下主要元素：

Types：定义Web服务使用的数据类型
Message：定义通信中使用的消息数据结构
PortType：定义Web服务的操作和消息
Binding：定义PortType的具体通信协议和数据格式
Port：定义服务的访问端点
Service：定义相关端点的集合

WSDL的重要性

WSDL在企业服务集成中具有不可替代的重要性：

服务接口标准化：提供统一的服务描述标准
自动化工具支持：支持自动生成客户端和服务端代码
服务发现与集成：便于服务注册中心的管理和发现
跨平台兼容性：支持不同技术平台间的服务调用

WSDL到WSDL转换的技术细节

转换的必要性

WSDL到WSDL转换看似冗余，但在实际应用中却有着重要的意义：

版本兼容性：处理不同版本的WSDL规范（1.1和2.0）
命名空间调整：修改或统一命名空间以适应企业标准
协议转换：将基于一种协议的WSDL转换为另一种协议
服务聚合：合并多个WSDL文档为一个统一的服务接口
安全增强：添加或修改安全相关的策略和绑定

转换的核心技术

1. XSLT转换

XSLT（Extensible Stylesheet Language Transformations）是WSDL转换最常用的技术之一。通过定义XSLT样式表，可以对WSDL文档进行精确的转换。

下面是一个简单的XSLT示例，用于修改WSDL文档中的命名空间：

<?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://example.com/newnamespace"> <!-- 修改目标命名空间 --> <xsl:template match="wsdl:definitions"> <wsdl:definitions> <xsl:copy-of select="@*[name() != 'targetNamespace']"/> <xsl:attribute name="targetNamespace">http://example.com/newnamespace</xsl:attribute> <xsl:apply-templates select="node()"/> </wsdl:definitions> </xsl:template> <!-- 修改所有引用到旧命名空间的地方 --> <xsl:template match="@*[contains(., 'http://example.com/oldnamespace')]"> <xsl:attribute name="{name()}"> <xsl:value-of select="replace(., 'http://example.com/oldnamespace', 'http://example.com/newnamespace')"/> </xsl:attribute> </xsl:template> <!-- 默认复制所有其他节点 --> <xsl:template match="@*|node()"> <xsl:copy> <xsl:apply-templates select="@*|node()"/> </xsl:copy> </xsl:template> </xsl:stylesheet>

2. DOM/SAX解析与重构

使用编程语言中的DOM或SAX解析器，可以更灵活地处理WSDL文档。以下是一个使用Java DOM API进行WSDL转换的示例：

import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.transform.Transformer; import javax.xml.transform.TransformerFactory; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult; import org.w3c.dom.Document; import org.w3c.dom.Element; import org.w3c.dom.NodeList; import java.io.File; public class WsdlConverter { public static void convertWsdl(String inputPath, String outputPath) throws Exception { // 加载WSDL文档 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(new File(inputPath)); // 修改命名空间 Element definitions = doc.getDocumentElement(); definitions.setAttribute("targetNamespace", "http://example.com/newnamespace"); // 修改所有引用到旧命名空间的地方 NodeList allNodes = doc.getElementsByTagName("*"); for (int i = 0; i < allNodes.getLength(); i++) { Element element = (Element) allNodes.item(i); if (element.hasAttribute("namespace")) { String namespace = element.getAttribute("namespace"); if (namespace.contains("http://example.com/oldnamespace")) { element.setAttribute("namespace", namespace.replace("http://example.com/oldnamespace", "http://example.com/newnamespace")); } } } // 保存修改后的WSDL TransformerFactory transformerFactory = TransformerFactory.newInstance(); Transformer transformer = transformerFactory.newTransformer(); DOMSource source = new DOMSource(doc); StreamResult result = new StreamResult(new File(outputPath)); transformer.transform(source, result); } public static void main(String[] args) { try { convertWsdl("input.wsdl", "output.wsdl"); System.out.println("WSDL转换完成"); } catch (Exception e) { e.printStackTrace(); } } }

3. WSDL4J库

WSDL4J是一个专门用于处理WSDL文档的Java库，提供了更高级的API来操作WSDL：

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import java.io.File; public class Wsdl4jConverter { public static void convertWsdl(String inputPath, String outputPath) throws Exception { // 创建WSDL工厂 WSDLFactory factory = WSDLFactory.newInstance(); // 创建WSDL读取器 WSDLReader reader = factory.newWSDLReader(); // 读取WSDL文档 Definition definition = reader.readWSDL(new File(inputPath).toURI().toString()); // 修改目标命名空间 definition.setTargetNamespace("http://example.com/newnamespace"); // 修改服务端口 Service service = definition.getService(new QName("http://example.com/oldnamespace", "MyService")); if (service != null) { definition.removeService(service.getQName()); service.setQName(new QName("http://example.com/newnamespace", "MyService")); definition.addService(service); } // 创建WSDL写入器 WSDLWriter writer = factory.newWSDLWriter(); // 写入修改后的WSDL writer.writeWSDL(definition, new File(outputPath)); } public static void main(String[] args) { try { convertWsdl("input.wsdl", "output.wsdl"); System.out.println("WSDL转换完成"); } catch (Exception e) { e.printStackTrace(); } } }

实用WSDL转换工具

1. Apache CXF

Apache CXF是一个开源的服务框架，提供了丰富的WSDL处理功能，包括WSDL到WSDL的转换。以下是一个使用CXF进行WSDL转换的示例：

import org.apache.cxf.tools.wsdlto.WSDLToJava; import org.apache.cxf.tools.common.ToolContext; public class CxfWsdlConverter { public static void convertWsdl(String inputPath, String outputPath) { // 创建工具上下文 ToolContext context = new ToolContext(); // 设置输出目录 context.put(ToolContext.CFG_OUTPUTDIR, outputPath); // 创建WSDL到Java转换器 WSDLToJava converter = new WSDLToJava(inputPath); // 执行转换 converter.run(context); } public static void main(String[] args) { convertWsdl("input.wsdl", "output"); System.out.println("WSDL转换完成"); } }

2. SOAP UI

SOAP UI是一个流行的Web服务测试工具，也提供了WSDL转换功能：

打开SOAP UI，导入原始WSDL
右键点击项目，选择”Show Interface Viewer”
在Interface Viewer中，可以查看和修改WSDL内容
使用”Export”功能导出修改后的WSDL

3. Eclipse WSDL Editor

Eclipse IDE提供了一个强大的WSDL编辑器，支持可视化和源码编辑：

在Eclipse中导入WSDL文件
使用WSDL编辑器打开文件
在图形界面中直接修改服务接口、绑定和端口
保存修改后的WSDL

4. Oxygen XML Editor

Oxygen XML Editor是一个专业的XML编辑工具，提供了强大的WSDL编辑和转换功能：

打开WSDL文件
使用”Refactoring”菜单中的选项进行重构
使用XSLT转换功能进行批量修改
验证和保存修改后的WSDL

WSDL转换的最佳实践

1. 版本控制

在WSDL转换过程中，版本控制是至关重要的：

使用Git等版本控制系统管理WSDL文件的所有变更
为每个转换创建分支，便于追踪和回滚
记录每次转换的目的和变更内容

# Git工作流程示例 git init wsdl-repo cd wsdl-repo git checkout -b feature/namespace-conversion # 执行WSDL转换 git add . git commit -m "Converted namespace from old to new" git checkout main git merge feature/namespace-conversion

2. 自动化测试

确保转换后的WSDL保持原有功能：

创建自动化测试套件验证转换前后的WSDL功能一致性
使用单元测试框架如JUnit进行测试

import org.junit.Test; import static org.junit.Assert.*; import javax.wsdl.*; public class WsdlConversionTest { @Test public void testNamespaceConversion() throws Exception { // 加载原始WSDL Definition originalWsdl = loadWsdl("original.wsdl"); // 执行转换 convertWsdl("original.wsdl", "converted.wsdl"); // 加载转换后的WSDL Definition convertedWsdl = loadWsdl("converted.wsdl"); // 验证命名空间已更改 assertEquals("http://example.com/newnamespace", convertedWsdl.getTargetNamespace()); // 验证服务操作数量保持不变 assertEquals(originalWsdl.getServices().size(), convertedWsdl.getServices().size()); // 验证端口类型数量保持不变 assertEquals(originalWsdl.getPortTypes().size(), convertedWsdl.getPortTypes().size()); } private Definition loadWsdl(String path) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); return reader.readWSDL(new File(path).toURI().toString()); } }

3. 文档记录

详细记录转换过程和决策：

为每个转换项目创建文档
记录转换的原因、方法和影响
提供转换前后的对比示例

# WSDL转换文档 ## 转换目标 将服务命名空间从`http://example.com/oldnamespace`更改为`http://example.com/newnamespace` ## 转换方法 使用XSLT转换，样式表文件为`namespace-converter.xsl` ## 转换影响 - 所有引用到旧命名空间的地方都已更新 - 服务端点保持不变 - 客户端代码需要重新生成 ## 转换前后对比 ### 原始WSDL片段 ```xml <wsdl:definitions targetNamespace="http://example.com/oldnamespace"> <wsdl:service name="MyService"> <wsdl:port name="MyPort" binding="tns:MyBinding"> <soap:address location="http://example.com/service"/> </wsdl:port> </wsdl:service> </wsdl:definitions>

转换后WSDL片段

<wsdl:definitions targetNamespace="http://example.com/newnamespace"> <wsdl:service name="MyService"> <wsdl:port name="MyPort" binding="tns:MyBinding"> <soap:address location="http://example.com/service"/> </wsdl:port> </wsdl:service> </wsdl:definitions>

 ### 4. 性能优化 优化WSDL转换过程以提高效率： - 使用流式处理（如SAX）处理大型WSDL文件 - 缓存常用转换模板 - 并行处理多个WSDL文件 ```java import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; import java.io.BufferedWriter; import java.io.FileWriter; public class SaxWsdlConverter { public static void convertLargeWsdl(String inputPath, String outputPath) throws Exception { SAXParserFactory factory = SAXParserFactory.newInstance(); factory.setNamespaceAware(true); SAXParser saxParser = factory.newSAXParser(); BufferedWriter writer = new BufferedWriter(new FileWriter(outputPath)); DefaultHandler handler = new DefaultHandler() { private boolean inTargetNamespace = false; @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { try { writer.write("<" + qName); for (int i = 0; i < attributes.getLength(); i++) { String attrName = attributes.getQName(i); String attrValue = attributes.getValue(i); if ("targetNamespace".equals(attrName)) { attrValue = "http://example.com/newnamespace"; inTargetNamespace = true; } else if (attrValue.contains("http://example.com/oldnamespace")) { attrValue = attrValue.replace("http://example.com/oldnamespace", "http://example.com/newnamespace"); } writer.write(" " + attrName + "="" + attrValue + """); } writer.write(">"); } catch (Exception e) { throw new SAXException(e); } } @Override public void endElement(String uri, String localName, String qName) throws SAXException { try { writer.write("</" + qName + ">"); if ("definitions".equals(localName)) { inTargetNamespace = false; } } catch (Exception e) { throw new SAXException(e); } } @Override public void characters(char[] ch, int start, int length) throws SAXException { try { writer.write(new String(ch, start, length)); } catch (Exception e) { throw new SAXException(e); } } }; saxParser.parse(inputPath, handler); writer.close(); } public static void main(String[] args) { try { convertLargeWsdl("large-input.wsdl", "large-output.wsdl"); System.out.println("大型WSDL转换完成"); } catch (Exception e) { e.printStackTrace(); } } }

通过有效WSDL转换提升企业服务集成的效率与兼容性

1. 统一服务接口

通过WSDL转换，企业可以统一不同部门或系统的服务接口标准：

统一命名空间约定
标准化错误处理机制
统一安全策略和绑定

<!-- 转换前：不同部门使用不同的命名空间约定 --> <wsdl:definitions targetNamespace="http://hr.example.com/services"> <!-- HR部门的服务定义 --> </wsdl:definitions> <wsdl:definitions targetNamespace="http://finance.example.com/wsdl"> <!-- 财务部门的服务定义 --> </wsdl:definitions> <!-- 转换后：统一的命名空间约定 --> <wsdl:definitions targetNamespace="http://example.com/services/hr"> <!-- HR部门的服务定义 --> </wsdl:definitions> <wsdl:definitions targetNamespace="http://example.com/services/finance"> <!-- 财务部门的服务定义 --> </wsdl:definitions>

2. 协议适配

通过WSDL转换，可以使服务支持多种通信协议：

将SOAP/HTTP转换为SOAP/JMS
添加REST绑定支持
支持不同版本的SOAP协议

<!-- 转换前：仅支持SOAP/HTTP --> <wsdl:binding name="MyServiceBinding" type="tns:MyServicePortType"> <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/> <!-- 操作定义 --> </wsdl:binding> <wsdl:service name="MyService"> <wsdl:port name="MyServicePort" binding="tns:MyServiceBinding"> <soap:address location="http://example.com/MyService"/> </wsdl:port> </wsdl:service> <!-- 转换后：同时支持SOAP/HTTP和SOAP/JMS --> <wsdl:binding name="MyServiceHttpBinding" type="tns:MyServicePortType"> <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/> <!-- 操作定义 --> </wsdl:binding> <wsdl:binding name="MyServiceJmsBinding" type="tns:MyServicePortType"> <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/jms"/> <!-- 操作定义 --> </wsdl:binding> <wsdl:service name="MyService"> <wsdl:port name="MyServiceHttpPort" binding="tns:MyServiceHttpBinding"> <soap:address location="http://example.com/MyService"/> </wsdl:port> <wsdl:port name="MyServiceJmsPort" binding="tns:MyServiceJmsBinding"> <soap:address location="jms://queue/MyServiceQueue"/> </wsdl:port> </wsdl:service>

3. 服务聚合

通过WSDL转换，可以将多个相关服务聚合为一个统一的服务接口：

合并多个WSDL文档
创建服务门面模式
简化客户端调用复杂度

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import java.util.*; public class WsdlAggregator { public static void aggregateServices(List<String> inputPaths, String outputPath) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); // 创建聚合后的WSDL定义 Definition aggregatedDefinition = null; // 合并所有输入WSDL for (String path : inputPaths) { Definition currentDefinition = reader.readWSDL(new File(path).toURI().toString()); if (aggregatedDefinition == null) { // 使用第一个WSDL作为基础 aggregatedDefinition = currentDefinition; } else { // 合并服务 Map services = currentDefinition.getServices(); for (Object key : services.keySet()) { aggregatedDefinition.addService((Service) services.get(key)); } // 合并端口类型 Map portTypes = currentDefinition.getPortTypes(); for (Object key : portTypes.keySet()) { aggregatedDefinition.addPortType((PortType) portTypes.get(key)); } // 合并绑定 Map bindings = currentDefinition.getBindings(); for (Object key : bindings.keySet()) { aggregatedDefinition.addBinding((Binding) bindings.get(key)); } } } // 写入聚合后的WSDL WSDLWriter writer = factory.newWSDLWriter(); writer.writeWSDL(aggregatedDefinition, new File(outputPath)); } public static void main(String[] args) { try { List<String> inputPaths = Arrays.asList("service1.wsdl", "service2.wsdl", "service3.wsdl"); aggregateServices(inputPaths, "aggregated-service.wsdl"); System.out.println("WSDL聚合完成"); } catch (Exception e) { e.printStackTrace(); } } }

4. 兼容性处理

通过WSDL转换，可以处理不同版本和标准之间的兼容性问题：

WSDL 1.1与WSDL 2.0之间的转换
处理不同SOAP标准的差异
适配不同厂商的扩展

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import javax.wsdl.extensions.soap.*; import org.w3c.dom.Element; public class WsdlCompatibilityConverter { public static void convertToWsdl2(String inputPath, String outputPath) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); // 读取WSDL 1.1文档 Definition definition11 = reader.readWSDL(new File(inputPath).toURI().toString()); // 创建WSDL 2.0定义 Definition definition20 = factory.newDefinition(); // 设置目标命名空间 definition20.setTargetNamespace(definition11.getTargetNamespace()); // 转换端口类型为接口 Map portTypes = definition11.getPortTypes(); for (Object key : portTypes.keySet()) { PortType portType = (PortType) portTypes.get(key); // 创建WSDL 2.0接口 InterfaceType interfaceType = createInterfaceFromPortType(portType); definition20.addInterface(interfaceType); } // 转换绑定 Map bindings = definition11.getBindings(); for (Object key : bindings.keySet()) { Binding binding = (Binding) bindings.get(key); // 创建WSDL 2.0绑定 BindingType bindingType = createBindingFromBinding(binding); definition20.addBinding(bindingType); } // 转换服务 Map services = definition11.getServices(); for (Object key : services.keySet()) { Service service = (Service) services.get(key); // 创建WSDL 2.0服务 ServiceType serviceType = createServiceFromService(service); definition20.addService(serviceType); } // 写入WSDL 2.0文档 WSDLWriter writer = factory.newWSDLWriter(); writer.writeWSDL(definition20, new File(outputPath)); } private static InterfaceType createInterfaceFromPortType(PortType portType) { // 实现从PortType到InterfaceType的转换逻辑 // ... return null; } private static BindingType createBindingFromBinding(Binding binding) { // 实现从Binding到BindingType的转换逻辑 // ... return null; } private static ServiceType createServiceFromService(Service service) { // 实现从Service到ServiceType的转换逻辑 // ... return null; } public static void main(String[] args) { try { convertToWsdl2("service-wsdl11.wsdl", "service-wsdl20.wsdl"); System.out.println("WSDL 1.1到2.0转换完成"); } catch (Exception e) { e.printStackTrace(); } } }

5. 安全增强

通过WSDL转换，可以增强服务的安全性：

添加WS-Security策略
实现传输层安全
集成身份验证和授权机制

<!-- 转换前：基本WSDL，无安全策略 --> <wsdl:definitions targetNamespace="http://example.com/myservice"> <wsdl:binding name="MyServiceBinding" type="tns:MyServicePortType"> <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/> <!-- 操作定义 --> </wsdl:binding> <wsdl:service name="MyService"> <wsdl:port name="MyServicePort" binding="tns:MyServiceBinding"> <soap:address location="http://example.com/MyService"/> </wsdl:port> </wsdl:service> </wsdl:definitions> <!-- 转换后：添加WS-Security策略 --> <wsdl:definitions targetNamespace="http://example.com/myservice" xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" xmlns:sp="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702"> <!-- 定义安全策略 --> <wsp:Policy wsu:Id="UsernameToken"> <wsp:ExactlyOne> <wsp:All> <sp:SupportingTokens> <wsp:Policy> <sp:UsernameToken sp:IncludeToken="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient"> <wsp:Policy> <sp:WssUsernameToken10/> </wsp:Policy> </sp:UsernameToken> </wsp:Policy> </sp:SupportingTokens> </wsp:All> </wsp:ExactlyOne> </wsp:Policy> <wsdl:binding name="MyServiceBinding" type="tns:MyServicePortType"> <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/> <!-- 应用安全策略 --> <wsp:PolicyReference URI="#UsernameToken"/> <!-- 操作定义 --> </wsdl:binding> <wsdl:service name="MyService"> <wsdl:port name="MyServicePort" binding="tns:MyServiceBinding"> <soap:address location="https://example.com/MyService"/> </wsdl:port> </wsdl:service> </wsdl:definitions>

案例研究：企业WSDL转换项目

项目背景

某大型跨国企业拥有多个业务部门，每个部门都开发了自己的Web服务。这些服务使用不同的命名空间约定、安全策略和通信协议，导致系统集成困难和维护成本高昂。

项目目标

统一所有服务的命名空间约定
标准化安全策略
支持多协议绑定
创建服务聚合层简化客户端调用

实施方案

1. 命名空间标准化

开发了一个XSLT转换工具，将所有服务的命名空间转换为统一格式：

<?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> <!-- 部门到命名空间的映射 --> <xsl:variable name="dept-ns-map"> <mapping dept="hr" ns="human-resources"/> <mapping dept="finance" ns="financial-services"/> <mapping dept="sales" ns="sales-and-marketing"/> <mapping dept="it" ns="information-technology"/> </xsl:variable> <!-- 提取部门名称 --> <xsl:template name="get-department"> <xsl:param name="namespace"/> <xsl:choose> <xsl:when test="contains($namespace, 'hr.')">hr</xsl:when> <xsl:when test="contains($namespace, 'finance.')">finance</xsl:when> <xsl:when test="contains($namespace, 'sales.')">sales</xsl:when> <xsl:when test="contains($namespace, 'it.')">it</xsl:when> <xsl:otherwise>other</xsl:otherwise> </xsl:choose> </xsl:template> <!-- 获取新的命名空间 --> <xsl:template name="get-new-namespace"> <xsl:param name="old-namespace"/> <xsl:variable name="dept"> <xsl:call-template name="get-department"> <xsl:with-param name="namespace" select="$old-namespace"/> </xsl:call-template> </xsl:variable> <xsl:variable name="ns" select="document('')//xsl:variable[@name='dept-ns-map']/mapping[@dept=$dept]/@ns"/> <xsl:value-of select="concat('http://company.example.com/services/', $ns)"/> </xsl:template> <!-- 修改目标命名空间 --> <xsl:template match="wsdl:definitions"> <wsdl:definitions> <xsl:copy-of select="@*[name() != 'targetNamespace']"/> <xsl:attribute name="targetNamespace"> <xsl:call-template name="get-new-namespace"> <xsl:with-param name="old-namespace" select="@targetNamespace"/> </xsl:call-template> </xsl:attribute> <xsl:apply-templates select="node()"/> </wsdl:definitions> </xsl:template> <!-- 修改所有引用到旧命名空间的地方 --> <xsl:template match="@*[contains(., 'http://')]"> <xsl:attribute name="{name()}"> <xsl:choose> <xsl:when test="contains(., 'http://') and contains(., '.example.com/')"> <xsl:call-template name="get-new-namespace"> <xsl:with-param name="old-namespace" select="."/> </xsl:call-template> </xsl:when> <xsl:otherwise> <xsl:value-of select="."/> </xsl:otherwise> </xsl:choose> </xsl:attribute> </xsl:template> <!-- 默认复制所有其他节点 --> <xsl:template match="@*|node()"> <xsl:copy> <xsl:apply-templates select="@*|node()"/> </xsl:copy> </xsl:template> </xsl:stylesheet>

2. 安全策略标准化

开发了一个Java工具，为所有WSDL添加统一的安全策略：

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import org.w3c.dom.Element; public class SecurityPolicyEnhancer { private static final String SECURITY_POLICY = "<wsp:Policy wsu:Id="SecurityPolicy" " + "xmlns:wsp="http://schemas.xmlsoap.org/ws/2004/09/policy" " + "xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" " + "xmlns:sp="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702">" + "<wsp:ExactlyOne>" + "<wsp:All>" + "<sp:TransportBinding>" + "<wsp:Policy>" + "<sp:TransportToken>" + "<wsp:Policy>" + "<sp:HttpsToken RequireClientCertificate="false"/>" + "</wsp:Policy>" + "</sp:TransportToken>" + "</wsp:Policy>" + "</sp:TransportBinding>" + "<sp:SupportingTokens>" + "<wsp:Policy>" + "<sp:UsernameToken sp:IncludeToken="http://docs.oasis-open.org/ws-sx/ws-securitypolicy/200702/IncludeToken/AlwaysToRecipient">" + "<wsp:Policy>" + "<sp:WssUsernameToken10/>" + "</wsp:Policy>" + "</sp:UsernameToken>" + "</wsp:Policy>" + "</sp:SupportingTokens>" + "</wsp:All>" + "</wsp:ExactlyOne>" + "</wsp:Policy>"; public static void addSecurityPolicy(String inputPath, String outputPath) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); // 读取原始WSDL Definition definition = reader.readWSDL(new File(inputPath).toURI().toString()); // 创建安全策略元素 Element policyElement = createElementFromString(SECURITY_POLICY); // 将安全策略添加到WSDL定义中 definition.addExtensibilityElement(policyElement); // 为每个绑定添加安全策略引用 Map bindings = definition.getBindings(); for (Object key : bindings.keySet()) { Binding binding = (Binding) bindings.get(key); Element policyReference = createPolicyReferenceElement("#SecurityPolicy"); binding.addExtensibilityElement(policyReference); } // 将HTTP端点更改为HTTPS Map services = definition.getServices(); for (Object serviceKey : services.keySet()) { Service service = (Service) services.get(serviceKey); Map ports = service.getPorts(); for (Object portKey : ports.keySet()) { Port port = (Port) ports.get(portKey); List extensibilityElements = port.getExtensibilityElements(); for (Object element : extensibilityElements) { if (element instanceof SOAPAddress) { SOAPAddress soapAddress = (SOAPAddress) element; String locationURI = soapAddress.getLocationURI(); if (locationURI.startsWith("http://")) { soapAddress.setLocationURI(locationURI.replace("http://", "https://")); } } } } } // 写入修改后的WSDL WSDLWriter writer = factory.newWSDLWriter(); writer.writeWSDL(definition, new File(outputPath)); } private static Element createElementFromString(String xml) { // 实现将XML字符串转换为DOM元素的逻辑 // ... return null; } private static Element createPolicyReferenceElement(String uri) { // 实现创建策略引用元素的逻辑 // ... return null; } public static void main(String[] args) { try { addSecurityPolicy("input.wsdl", "secure-output.wsdl"); System.out.println("安全策略添加完成"); } catch (Exception e) { e.printStackTrace(); } } }

3. 多协议支持

为所有服务添加JMS绑定，实现HTTP和JMS双协议支持：

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import javax.wsdl.extensions.soap.*; public class MultiProtocolSupport { public static void addJmsBinding(String inputPath, String outputPath) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); // 读取原始WSDL Definition definition = reader.readWSDL(new File(inputPath).toURI().toString()); // 为每个绑定创建对应的JMS绑定 Map bindings = definition.getBindings(); Map newBindings = new HashMap(); for (Object key : bindings.keySet()) { Binding httpBinding = (Binding) bindings.get(key); String bindingName = httpBinding.getQName().getLocalPart(); // 创建JMS绑定 Binding jmsBinding = definition.createBinding(); jmsBinding.setQName(new QName(definition.getTargetNamespace(), bindingName + "JmsBinding")); jmsBinding.setPortType(httpBinding.getPortType()); // 添加SOAP绑定扩展 SOAPBinding soapBinding = (SOAPBinding) definition.getExtensionRegistry().createExtension( Binding.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "binding")); soapBinding.setTransportURI("http://schemas.xmlsoap.org/soap/jms"); soapBinding.setStyle("document"); jmsBinding.addExtensibilityElement(soapBinding); // 复制所有操作绑定 List httpBindingOperations = httpBinding.getBindingOperations(); for (Object opObj : httpBindingOperations) { BindingOperation httpBindingOp = (BindingOperation) opObj; BindingOperation jmsBindingOp = definition.createBindingOperation(); jmsBindingOp.setName(httpBindingOp.getName()); // 复制输入绑定 if (httpBindingOp.getBindingInput() != null) { BindingInput jmsBindingInput = definition.createBindingInput(); jmsBindingInput.setName(httpBindingOp.getBindingInput().getName()); // 添加SOAP body SOAPBody soapBody = (SOAPBody) definition.getExtensionRegistry().createExtension( BindingInput.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "body")); soapBody.setUse("literal"); jmsBindingInput.addExtensibilityElement(soapBody); jmsBindingOp.setBindingInput(jmsBindingInput); } // 复制输出绑定 if (httpBindingOp.getBindingOutput() != null) { BindingOutput jmsBindingOutput = definition.createBindingOutput(); jmsBindingOutput.setName(httpBindingOp.getBindingOutput().getName()); // 添加SOAP body SOAPBody soapBody = (SOAPBody) definition.getExtensionRegistry().createExtension( BindingOutput.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "body")); soapBody.setUse("literal"); jmsBindingOutput.addExtensibilityElement(soapBody); jmsBindingOp.setBindingOutput(jmsBindingOutput); } jmsBinding.addBindingOperation(jmsBindingOp); } newBindings.put(jmsBinding.getQName(), jmsBinding); } // 添加所有新绑定到定义中 for (Object key : newBindings.keySet()) { definition.addBinding((Binding) newBindings.get(key)); } // 为每个服务添加JMS端口 Map services = definition.getServices(); for (Object serviceKey : services.keySet()) { Service service = (Service) services.get(serviceKey); Map ports = service.getPorts(); for (Object portKey : ports.keySet()) { Port httpPort = (Port) ports.get(portKey); String portName = httpPort.getName(); Binding httpBinding = httpPort.getBinding(); String bindingName = httpBinding.getQName().getLocalPart(); // 查找对应的JMS绑定 Binding jmsBinding = (Binding) newBindings.get( new QName(definition.getTargetNamespace(), bindingName + "JmsBinding")); if (jmsBinding != null) { // 创建JMS端口 Port jmsPort = definition.createPort(); jmsPort.setName(portName + "JmsPort"); jmsPort.setBinding(jmsBinding); // 添加SOAP地址 SOAPAddress soapAddress = (SOAPAddress) definition.getExtensionRegistry().createExtension( Port.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "address")); soapAddress.setLocationURI("jms://queue/" + portName + "Queue"); jmsPort.addExtensibilityElement(soapAddress); // 添加JMS地址 JMSAddress jmsAddress = (JMSAddress) definition.getExtensionRegistry().createExtension( Port.class, new QName("http://schemas.xmlsoap.org/wsdl/jms/", "address")); jmsAddress.setDestinationURI("queue/" + portName + "Queue"); jmsPort.addExtensibilityElement(jmsAddress); // 添加端口到服务 service.addPort(jmsPort); } } } // 写入修改后的WSDL WSDLWriter writer = factory.newWSDLWriter(); writer.writeWSDL(definition, new File(outputPath)); } public static void main(String[] args) { try { addJmsBinding("input.wsdl", "multiprotocol-output.wsdl"); System.out.println("多协议支持添加完成"); } catch (Exception e) { e.printStackTrace(); } } }

4. 服务聚合

开发了一个服务聚合工具，将相关服务组合为一个统一的服务接口：

import javax.wsdl.*; import javax.wsdl.factory.WSDLFactory; import javax.wsdl.xml.WSDLReader; import javax.wsdl.xml.WSDLWriter; import javax.wsdl.extensions.soap.*; import java.util.*; public class ServiceAggregator { public static void aggregateServices(List<String> inputPaths, String outputPath, String serviceName) throws Exception { WSDLFactory factory = WSDLFactory.newInstance(); WSDLReader reader = factory.newWSDLReader(); // 创建聚合后的WSDL定义 Definition aggregatedDefinition = factory.newDefinition(); aggregatedDefinition.setTargetNamespace("http://company.example.com/services/aggregated"); // 创建聚合端口类型 PortType aggregatedPortType = aggregatedDefinition.createPortType(); aggregatedPortType.setQName(new QName(aggregatedDefinition.getTargetNamespace(), serviceName + "PortType")); // 创建聚合绑定 Binding aggregatedBinding = aggregatedDefinition.createBinding(); aggregatedBinding.setQName(new QName(aggregatedDefinition.getTargetNamespace(), serviceName + "Binding")); aggregatedBinding.setPortType(aggregatedPortType); // 添加SOAP绑定扩展 SOAPBinding soapBinding = (SOAPBinding) factory.newExtensionRegistry().createExtension( Binding.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "binding")); soapBinding.setTransportURI("http://schemas.xmlsoap.org/soap/http"); soapBinding.setStyle("document"); aggregatedBinding.addExtensibilityElement(soapBinding); // 创建聚合服务 Service aggregatedService = aggregatedDefinition.createService(); aggregatedService.setQName(new QName(aggregatedDefinition.getTargetNamespace(), serviceName)); // 创建聚合端口 Port aggregatedPort = aggregatedDefinition.createPort(); aggregatedPort.setName(serviceName + "Port"); aggregatedPort.setBinding(aggregatedBinding); // 添加SOAP地址 SOAPAddress soapAddress = (SOAPAddress) factory.newExtensionRegistry().createExtension( Port.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "address")); soapAddress.setLocationURI("http://company.example.com/services/" + serviceName); aggregatedPort.addExtensibilityElement(soapAddress); aggregatedService.addPort(aggregatedPort); // 聚合所有输入WSDL的操作 Map<String, Definition> operationToServiceMap = new HashMap<>(); for (String path : inputPaths) { Definition currentDefinition = reader.readWSDL(new File(path).toURI().toString()); // 获取所有端口类型 Map portTypes = currentDefinition.getPortTypes(); for (Object key : portTypes.keySet()) { PortType portType = (PortType) portTypes.get(key); // 获取所有操作 List operations = portType.getOperations(); for (Object opObj : operations) { Operation operation = (Operation) opObj; // 添加到聚合端口类型 aggregatedPortType.addOperation(operation); // 记录操作来源服务 operationToServiceMap.put(operation.getName(), currentDefinition); } } } // 为聚合绑定创建操作绑定 for (Object key : operationToServiceMap.keySet()) { String operationName = (String) key; Definition sourceDefinition = operationToServiceMap.get(operationName); // 查找源操作 Operation sourceOperation = findOperation(sourceDefinition, operationName); // 创建绑定操作 BindingOperation bindingOperation = aggregatedDefinition.createBindingOperation(); bindingOperation.setName(operationName); // 处理输入 if (sourceOperation.getInput() != null) { BindingInput bindingInput = aggregatedDefinition.createBindingInput(); bindingInput.setName(sourceOperation.getInput().getName()); // 添加SOAP body SOAPBody soapBody = (SOAPBody) factory.newExtensionRegistry().createExtension( BindingInput.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "body")); soapBody.setUse("literal"); bindingInput.addExtensibilityElement(soapBody); bindingOperation.setBindingInput(bindingInput); } // 处理输出 if (sourceOperation.getOutput() != null) { BindingOutput bindingOutput = aggregatedDefinition.createBindingOutput(); bindingOutput.setName(sourceOperation.getOutput().getName()); // 添加SOAP body SOAPBody soapBody = (SOAPBody) factory.newExtensionRegistry().createExtension( BindingOutput.class, new QName("http://schemas.xmlsoap.org/wsdl/soap/", "body")); soapBody.setUse("literal"); bindingOutput.addExtensibilityElement(soapBody); bindingOperation.setBindingOutput(bindingOutput); } aggregatedBinding.addBindingOperation(bindingOperation); } // 添加所有元素到聚合定义 aggregatedDefinition.addPortType(aggregatedPortType); aggregatedDefinition.addBinding(aggregatedBinding); aggregatedDefinition.addService(aggregatedService); // 写入聚合后的WSDL WSDLWriter writer = factory.newWSDLWriter(); writer.writeWSDL(aggregatedDefinition, new File(outputPath)); } private static Operation findOperation(Definition definition, String operationName) { Map portTypes = definition.getPortTypes(); for (Object key : portTypes.keySet()) { PortType portType = (PortType) portTypes.get(key); List operations = portType.getOperations(); for (Object opObj : operations) { Operation operation = (Operation) opObj; if (operationName.equals(operation.getName())) { return operation; } } } return null; } public static void main(String[] args) { try { List<String> inputPaths = Arrays.asList( "hr-service.wsdl", "finance-service.wsdl", "sales-service.wsdl" ); aggregateServices(inputPaths, "enterprise-service.wsdl", "EnterpriseService"); System.out.println("服务聚合完成"); } catch (Exception e) { e.printStackTrace(); } } }