CXF 中自定义SOAPHeader

最新推荐文章于 2022-12-08 09:55:52 发布
最新推荐文章于 2022-12-08 09:55:52 发布
阅读量1.3k 收藏
点赞数
分类专栏： cxf 文章标签： cxf

出处：http://my.oschina.net/u/246522/blog/151422

目录[-]

拦截器(Interceptor)简单说明

      Interceptor是CXF架构中一个很有特色的模式。你可以在不对核心模块进行修改的情况下，动态添加很多功能。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的，CXF通过在Interceptor中对消息进行特殊处理，实现了很多重要功能模块，例如：日志记录，Soap消息处理，消息的压缩处。简单的说，可以在收到请求后，还未进行业务处理前，进行处理。或者在请求包发送前，进行报文的处理。

几个的API的介绍

Interceptor

定义两个方法，一个处理消息 handleMessage， 一个是处理错误 handleFault。

InterceptorChain

  单个的Interceptor功能有限，CXF要实现一个SOAP消息处理，需要将许许多多的Interceptor组合在一起使用。因此设计了 InterceptorChain，在我看了InterceptorChain就像是一个Interceptor的小队长。 小队长有调配安置Interceptor的权力（add，remove），也有控制消息处理的权力（doInterceptor，pause，resume，reset，abort），同时也有交付错误处理的权力（ {get|set}FaultObserver）。更有意思的是为灵活控制Interceptor的处理消息顺序（doInterceptStartingAt，doInterceptorStartingAfter），这也是InterceptorChain比较难理解的地方。
Fault
  定义了CXF中的错误消息。

InterceptorProvider

　　这里定义了Interceptor的后备保障部队。我们可以在InterceptorProvider中设置In，Out，InFault，OutFault 后备小分队，添加我们所希望添加的Interceptor。而InterceptorChain会根据这些后备小分队，组建自己的小分队实例，完成具体的作战功能任务。

AbstractAttributedInterceptorProvider

   InterceptorProvider实现的抽象类，由于这个类来继承了HashMap，我们可以像这个类中存储一些属性信息。

AbrstractBasicInterceptorProvider

   与AbstractAttributedInterceptorProvider不同，这个Interceptor只是简单实现了InterceptorProvider的功能，并不提供对其属性存储的扩展。

Message

   由于Interceptor是针对Message来进行处理的，当你打开Message这个类文件时，你会发现在Message中定义了很多常量，同时你还可以从Message中获取到很多与Message操作相关的信息。可以获取设置的对象有InterceptorChain Exchange Destination，还有获取设置Content的泛型接口，是不是感觉Message和Bus差不多，都成了大杂货铺，一切与消息处理相关的信息都可以放在Message中。

服务端拦截器

01package hs.cxf.soapHeader;
02 
03import javax.xml.soap.SOAPException;
04import javax.xml.soap.SOAPHeader;
05import javax.xml.soap.SOAPMessage;
06import org.apache.cxf.binding.soap.SoapMessage;
07import org.apache.cxf.binding.soap.saaj.SAAJInInterceptor;
08import org.apache.cxf.interceptor.Fault;
09import org.apache.cxf.phase.AbstractPhaseInterceptor;
10import org.apache.cxf.phase.Phase;
11import org.w3c.dom.NodeList;
12 
13/**
14 *
15 * @Title:获取soap头信息
16 *
17 * @Description:
18 *
19 * @Copyright:
20 *
21 * @author zz
22 * @version 1.00.000
23 *
24 */
25public class ReadSoapHeader extends AbstractPhaseInterceptor<SoapMessage> {
26 
27    private SAAJInInterceptor saa = new SAAJInInterceptor();
28 
29    public ReadSoapHeader() {
30        super(Phase.PRE_PROTOCOL);
31        getAfter().add(SAAJInInterceptor.class.getName());
32    }
33 
34    public void handleMessage(SoapMessage message) throws Fault {
35 
36        SOAPMessage mess = message.getContent(SOAPMessage.class);
37        if (mess == null) {
38            saa.handleMessage(message);
39            mess = message.getContent(SOAPMessage.class);
40        }
41        SOAPHeader head = null;
42        try {
43            head = mess.getSOAPHeader();
44        } catch (SOAPException e) {
45            e.printStackTrace();
46        }
47        if (head == null) {
48            return;
49        }
50        try {
51            //读取自定义的节点
52            NodeList nodes = head.getElementsByTagName("tns:spId");
53            NodeList nodepass = head.getElementsByTagName("tns:spPassword");
54            //获取节点值，简单认证
55            if (nodes.item(0).getTextContent().equals("wdw")) {
56                if (nodepass.item(0).getTextContent().equals("wdwsb")) {
57                    System.out.println("认证成功");
58                }
59            } else {
60                SOAPException soapExc = new SOAPException("认证错误");
61                throw new Fault(soapExc);
62            }
63 
64        } catch (Exception e) {
65            SOAPException soapExc = new SOAPException("认证错误");
66            throw new Fault(soapExc);
67        }
68    }
69 
70}

配置文件中新增拦截器配置

01<beans xmlns="http://www.springframework.org/schema/beans" 
02    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
03    xmlns:jaxws="http://cxf.apache.org/jaxws" 
04    xsi:schemaLocation="  
05http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd  
06http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">  
07   
08    <import resource="classpath:META-INF/cxf/cxf.xml" />  
09    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  
10    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  
11   
12    <bean id="jaxWsServiceFactoryBean" 
13        class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean">  
14        <property name="wrapped" value="true" />  
15        <property name="dataBinding" ref="aegisBean" />  
16    </bean>  
17   
18    <bean id="aegisBean" 
19        class="org.apache.cxf.aegis.databinding.AegisDatabinding" />  
20   
21    <jaxws:endpoint id="CollectiveServices" 
22        implementor="hs.cxf.server.WebServiceSampleImpl" address="/HelloWorld">  
23        <jaxws:inInterceptors>  
24          <!-- 日志拦截器 -->     
25          <bean class="org.apache.cxf.interceptor.LoggingOutInterceptor"/>  
26          <!-- 自定义拦截器 -->
27          <bean class="hs.cxf.soapHeader.ReadSoapHeader"/>  
28          </jaxws:inInterceptors>   
29        <jaxws:serviceFactory>  
30            <ref bean="jaxWsServiceFactoryBean"/>  
31        </jaxws:serviceFactory>  
32    </jaxws:endpoint>  
33</beans>
客户端拦截器：

01package hs.cxf.client.SoapHeader;
02 
03 
04import java.util.List;
05import javax.xml.namespace.QName;
06import org.apache.cxf.binding.soap.SoapHeader;
07import org.apache.cxf.binding.soap.SoapMessage;
08import org.apache.cxf.binding.soap.interceptor.AbstractSoapInterceptor;
09import org.apache.cxf.headers.Header;
10import org.apache.cxf.helpers.DOMUtils;
11import org.apache.cxf.interceptor.Fault;
12import org.apache.cxf.phase.Phase;
13import org.w3c.dom.Document;
14import org.w3c.dom.Element;
15/**
16 *
17 * @Title:在发送消息前，封装Soap Header 信息
18 *
19 * @Description:
20 *
21 * @Copyright:
22 *
23 * @author zz
24 * @version 1.00.000
25 *
26 */
27 
28public class AddSoapHeader extends AbstractSoapInterceptor {
29      private static String nameURI="http://127.0.0.1:8080/cxfTest/ws/HelloWorld";  
30       
31        public AddSoapHeader(){  
32            super(Phase.WRITE);  
33        }  
34         
35        public void handleMessage(SoapMessage message) throws Fault {  
36            String spPassword="wdwsb";  
37            String spName="wdw";  
38                
39            QName qname=new QName("RequestSOAPHeader");  
40            Document doc=DOMUtils.createDocument();  
41            //自定义节点
42            Element spId=doc.createElement("tns:spId");  
43            spId.setTextContent(spName);  
44            //自定义节点
45            Element spPass=doc.createElement("tns:spPassword");  
46            spPass.setTextContent(spPassword);  
47                
48            Element root=doc.createElementNS(nameURI, "tns:RequestSOAPHeader");  
49            root.appendChild(spId);  
50            root.appendChild(spPass);  
51                
52            SoapHeader head=new SoapHeader(qname,root);  
53            List<Header> headers=message.getHeaders();  
54            headers.add(head);  
55            System.out.println(">>>>>添加header<<<<<<<");
56        }  
57 
58}
客户端调用时：

001package hs.cxf.client;
002 
003import hs.cxf.client.SoapHeader.AddSoapHeader;
004import java.util.ArrayList;
005import javax.xml.bind.JAXBElement;
006import javax.xml.namespace.QName;
007import org.apache.cxf.endpoint.Client;
008import org.apache.cxf.frontend.ClientProxy;
009import org.apache.cxf.interceptor.Interceptor;
010import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
011import org.apache.cxf.transport.http.HTTPConduit;
012import org.apache.cxf.transports.http.configuration.HTTPClientPolicy;
013 
014/**
015 * @Title:
016 *
017 * @Description:
018 *
019 * @Copyright:
020 *
021 * @author zz
022 * @version 1.00.000
023 *
024 */
025public class TestClient {
026 
027    /**
028     * 测试1
029     */
030    @SuppressWarnings("unchecked")
031    public void testSend1() {
032        try {
033            JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
034 
035            ArrayList<Interceptor> list = new ArrayList<Interceptor>();
036            // 添加soap header
037            list.add(new AddSoapHeader());
038            // 添加soap消息日志打印
039            list.add(new org.apache.cxf.interceptor.LoggingOutInterceptor());
040            factory.setOutInterceptors(list);
041            factory.setServiceClass(WebServiceSample.class);
042            factory.setAddress("http://127.0.0.1:8080/cxfTest/ws/HelloWorld");
043 
044            Object obj = factory.create();
045            System.out.println(obj == null ? "NULL" : obj.getClass().getName());
046            if (obj != null) {
047                WebServiceSample ws = (WebServiceSample) obj;
048                String str = ws.say("test");
049                System.out.println(str);
050 
051                str = ws.say("1111");
052                System.out.println(str);
053 
054                User u = new User();
055                JAXBElement<String> je = new JAXBElement<String>(new QName(
056                        "http://bean.cxf.hs", "name"), String.class, "张三");
057                u.setName(je);
058                str = ws.sayUserName(u);
059                System.out.println(str);
060 
061                // 通过对象来交互
062                ReqBean req = new ReqBean();
063                req.setExp(new JAXBElement<String>(new QName(
064                        "http://bean.cxf.hs", "exp"), String.class,
065                        "<exp>111<exp>"));
066                req.setSeqId(new JAXBElement<String>(new QName(
067                        "http://bean.cxf.hs", "seqId"), String.class,
068                        "12345678"));
069                RespBean resp = ws.action(req);
070                System.out.println("resp_id:" + resp.getRespId().getValue());
071                System.out.println("resp_exp:" + resp.getExp().getValue());
072            }
073        } catch (Exception ex) {
074            ex.printStackTrace();
075        }
076    }
077 
078    /**
079     * 测试2
080     */
081    @SuppressWarnings("unchecked")
082    public void testSend2() {
083        String webServiceUrl = "http://127.0.0.1:8080/cxfTest/ws/HelloWorld";
084        String webServiceConTimeout = "60000";
085        String webServiceRevTimeout = "60000";
086        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
087 
088        ArrayList<Interceptor> list = new ArrayList<Interceptor>();
089        // 添加soap header 信息
090        list.add(new AddSoapHeader());
091        // 添加soap消息日志打印
092        list.add(new org.apache.cxf.interceptor.LoggingOutInterceptor());
093        factory.setOutInterceptors(list);
094        factory.setServiceClass(WebServiceSample.class);
095        factory.setAddress(webServiceUrl);
096        WebServiceSample service = (WebServiceSample) factory.create();
097 
098        //超时时间设置
099        Client clientP = ClientProxy.getClient(service);
100        HTTPConduit http = (HTTPConduit) clientP.getConduit();
101        HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
102        httpClientPolicy.setConnectionTimeout(Integer
103                .valueOf(webServiceConTimeout));
104        httpClientPolicy.setReceiveTimeout(Integer
105                .valueOf(webServiceRevTimeout));
106        httpClientPolicy.setAllowChunking(false);
107        http.setClient(httpClientPolicy);
108         
109     
110        // 通过对象来交互
111        ReqBean req = new ReqBean();
112        req.setExp(new JAXBElement<String>(new QName(
113                "http://bean.cxf.hs", "exp"), String.class,
114                "<exp>111<exp>"));
115        req.setSeqId(new JAXBElement<String>(new QName(
116                "http://bean.cxf.hs", "seqId"), String.class,
117                "12345678"));
118        System.out.println(">>>>>>发送消息<<<<<<<<<");
119        RespBean resp = service.action(req);
120        System.out.println("resp_id:" + resp.getRespId().getValue());
121        System.out.println("resp_exp:" + resp.getExp().getValue());
122 
123    }
124 
125    /**
126     * @param args
127     */
128    public static void main(String[] args) {
129        TestClient tc = new TestClient();
130        tc.testSend1();
131        System.out.println(">>>>>>>>>>>>2<<<<<<<<<<<<<");
132        tc.testSend2();
133        System.out.println(">>>>>>>>>>>>END<<<<<<<<<<<<<");
134    }
135 
136}

gaohe7091
关注
专栏目录
CXF 入门：创建一个基于SOAPHeader的安全验证(CXF拦截器使用)
weixin_33904756的博客
05-15 127
为什么80%的码农都做不了架构师？>>> ...
用CXF开发SOAP接口
大哲
02-01 286
请参照:apache-cxf-2.5.1、jdk1.6.0_10   1.如何基于CXF发布接口以及客户端调用请参照下面的网址：   http://www.cnblogs.com/hoojo/tag/WebService/     这里面说了关于CXF的拦截器、与spring的整合以及复杂数据类型的传递。   2.从官方下载的CXF包里面，有个samples文件夹，这里面有各种应用的...
使用CXF实现带header的soap服务
08-03
NULL 博文链接：https://abingpow.iteye.com/blog/2002196
CXF 中自定义SOAPHeader
weixin_34185364的博客
08-08 355
2019独角兽企业重金招聘Python工程师标准>>> ...
CXF 添加soap 头部信息
勇往直前，学无止尽
10-21 8449
CXF版本为3.1.3，访问.net接口，需要在头部添加用户名和密码。 1:首先使用wsdl2java.bat生成相应的代码 2:新增拦截器。 import java.util.List; import javax.xml.namespace.QName; import org.apache.cxf.binding.soap.SoapHeader; import org.apach
CXF 服务端校验soapHeader，客户端添加soapHeader 记录
wangml010的博客
07-10 4333
整体需求是这样的，作为服务端，我的接口需要有一个安全验证，因此做了一个拦截器来验证soapHeader。作为客户端，需要往soapHeader中添加双方规定的参数。搞了一天多，在网上看了很多方法，最终还是搞定了。不得不说，现在网上的抄袭现象太严重了，有的博客甚至把别人分享的东西搬过来，连一个字都不带改的…… 服务端拦截器验证soapHeader 服务端主要是spring，接口是通过C...
CXF客户端添加soapHeader代码 + jar包 + apache-cxf-3.1.15
07-10
以上步骤展示了如何在CXF客户端中添加SOAP Header，这个过程涉及到CXF客户端的配置、自定义Header处理以及服务调用。通过这样的方式，我们可以灵活地控制SOAP请求中的Header信息，满足各种服务交互的需求。记得根据...
CXF-08：自定义CXF拦截器来进行权限控制
乘风晓栈的博客
10-24 4395
自定义拦截器： 需要实现Interceptor接口，实际上，我们一般会继承AbstractPhaseInterceptor； 做一个权限控制，有用户名和密码的时候才允许调用 Web Service： * 1 . 在服务器端将系统提供的In拦截器改为自定义拦截器 在运行起来的CXF服务端不需要做任何的改动，只需要修改In拦截器：
在soapheader中添加自定义信息
热门推荐
cyf_cyf的专栏
01-11 1万+
有时候我们的webservice在服务端需要做一个调用方的验证，以保证我们的服务只有指定的客户才能使用。虽然可以使用wss4j的方法来做安全验证，但是考虑到我们的项目会与被.net平台下的项目调用，为了避免跨平台间出现的问题，我们还是决定采用自定义soapheader的形式来添加验证信息。            先来看一下客户端发起请求的soap内容
CXF 添加soap 头部信息.zip_CXF增加soap头验证_bluex8z_cxf_meltedkw7_soap信息头
09-24
CXF的Interceptor接口允许我们在消息传递过程中插入自定义逻辑。创建一个实现了`org.apache.cxf.interceptor.Fault`和`org.apache.cxf.phase.Phase`接口的类，如`SoapHeaderInterceptor`，并在`handleMessage`方法...
CXF实战之自定义拦截器(五)
达拉斯母牛
07-30 8913
CXF已经内置了一些拦截器，这些拦截器大部分默认添加到拦截器链中，有些拦截器也可以手动添加，如手动添加CXF提供的日志拦截器。也可以自定义拦截器，CXF中实现自定义拦截器很简单，只要继承AbstractPhaseInterceptor或者AbstractPhaseInterceptor的子类（如AbstractSoapInterceptor）即可。
java cxf soapheader_CXF 中自定义SOAPHeader
weixin_35455175的博客
02-26 1181
Interceptor是CXF架构中一个很有特色的模式。你可以在不对核心模块进行修改的情况下，动态添加很多功能。这对于CXF这个以处理消息为中心的服务框架来说是非常有用的，CXF通过在Interceptor中对消息进行特殊处理，实现了很多重要功能模块，例如：日志记录，Soap消息处理，消息的压缩处。简单的说，可以在收到请求后，还未进行业务处理前，进行处理。或者在请求包发送前，进行报文的处理。Int...
CXF-使用interceptor处理Soap Headers
Dijkstra的专栏
04-29 752
最近需要对外提供 web service 服务，初步调研后决定采用 CXF 进行开发，CXF 是 apache 提供的开源框架，对 JAX-WS 标准的实现较为完整，并提供了与 spring 框架的集成，功能较为丰富。由于设计到在 SOAP 头中传输身份验证信息，本文主要讲解如何通过 CXF 提供的 interceptor 来处理 SOAP 头中的数据。实际上， JAX-WS 所定义的 Handl
CXF 2.0 学习笔记-3 SOAP Header （转）
huiseyiyu的专栏
09-21 239
CXF 2.0 学习笔记-3 SOAP Header 基于CXF2.0前2个学习笔记，对原先服务端与客户端进行修改，实现在SOAP Header里面添加自定义的数据进行认证在做之前，先要理解如下的信息拦截器(Interceptor)简单说明      Interceptor是CXF架构中一个很有特色的模式。你可以在不对核心模块进行修改的情况下，动态添加很多功能。这对于CXF这个以处理消息为中...
apache-cxf测试webservice添加header信息
weixin_34037173的博客
09-28 1631
2019独角兽企业重金招聘Python工程师标准>>> ...
Apache CXF: 如何为 Web 请求增加定制的 HTTP header?
Nicholas的专栏 QQ1295794532
04-23 3005
转自：http://simpleframework.net/blog/v/57763.html HTTP协议中，HTTP 头部字段是请求和响应消息头的组成部分。它们定义HTTP事务的操作参数，携带有客户端浏览器、请求压面、服务器以及其他更多的信息。 下面是使用CXF（v2.4.0）为Web服务增加HTTP headers的示例： /** * @author Singaram
使用CXF调用Webservice接口添加SoapHeader
weixin_42551921的博客
12-08 1303
WebService是一种跨编程语言和跨操作系统平台的远程调用技术。 服务端程序采用java编写，客户端程序则可以采用其他编程语言编写，反之亦然！指服务端程序和客户端程序可以在不同的操作系统上运行。XML+XSD,SOAP和WSDL就是构成WebService平台的三大技术。SOAP协议定义了SOAP消息的格式，SOAP协议是基于HTTP协议的，SOAP也是基于XML和XSD的，XML是SOAP的数据编码方式。WSDL文件保存在Web服务器上，通过一个url地址就可以访问到它。客户端要调用一个WebServ
cxf faultcode自定义错误
最新发布
05-20
在CXF中，可以通过自定义异常类来生成自定义的faultcode。以下是一个示例： 首先，我们创建一个自定义异常类，例如MyException： ```java public class MyException extends Exception { private static final ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值