JAX-WS使用Handler实现简单的WebService权限验证

最新推荐文章于 2019-07-24 03:49:35 发布
最新推荐文章于 2019-07-24 03:49:35 发布
阅读量3.1k 收藏 3
点赞数
分类专栏： web service

WebService如果涉及到安全保密或者使用权限的时候，WS-Security通常是最优选择。WS-Security (Web服务安全) 包含了关于如何在WebService消息上保证完整性和机密性的规约，如何将签名和加密头加入SOAP消息。不过WS-Security也有一些性能上的损耗，在信息保密要求不是很高的情况下，可以通过在SOAPHeader中添加简单的校验信息实现。

具体思路是客户端调用需要认证的服务时，在SOAPHeader中添加授权信息（如用户名、密码或者序列号等）。服务端收到请求，在SOAPHeader中校验授权信息，校验通过则执行请求，校验不通过则返回错误提示。



实例代码 http://download.csdn.net/detail/accountwcx/8922191


客户端发起请求在SOAPHeader中添加的授权数据格式如下

[html]  view plain  copy
  1. <auth xmlns="http://www.tmp.com/auth">  
  2.     <name>admin</name>  
  3.     <password>admin</password>  
  4. </auth>  


服务端


服务端授权校验Handler

[java]  view plain  copy
  1. import java.util.Iterator;  
  2. import java.util.Set;  
  3.   
  4. import javax.xml.namespace.QName;  
  5. import javax.xml.soap.SOAPBody;  
  6. import javax.xml.soap.SOAPElement;  
  7. import javax.xml.soap.SOAPEnvelope;  
  8. import javax.xml.soap.SOAPException;  
  9. import javax.xml.soap.SOAPFault;  
  10. import javax.xml.soap.SOAPHeader;  
  11. import javax.xml.soap.SOAPMessage;  
  12. import javax.xml.ws.handler.MessageContext;  
  13. import javax.xml.ws.handler.soap.SOAPHandler;  
  14. import javax.xml.ws.handler.soap.SOAPMessageContext;  
  15.   
  16. /** 
  17.  * 服务端请求校验Handler  
  18.  * @author accountwcx@qq.com 
  19.  * 
  20.  */  
  21. public class ValidateAuthHandler implements SOAPHandler<SOAPMessageContext> {  
  22.   
  23.     @Override  
  24.     public void close(MessageContext context) {  
  25.     }  
  26.   
  27.     @Override  
  28.     public boolean handleFault(SOAPMessageContext context) {  
  29.         return true;  
  30.     }  
  31.   
  32.     @Override  
  33.     public boolean handleMessage(SOAPMessageContext context) {  
  34.         // 判断消息是请求还是响应  
  35.         Boolean output = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);         
  36.           
  37.         boolean result = false;  
  38.           
  39.         SOAPMessage message = context.getMessage();  
  40.           
  41.         //如果是请求，则执行校验  
  42.         if(!output){  
  43.             result = validate(message);  
  44.               
  45.             if(!result){  
  46.                 validateFail(message);  
  47.             }  
  48.         }  
  49.           
  50.         System.out.println(output ? "服务端响应：" : "服务端接收：");  
  51.         try {  
  52.             message.writeTo(System.out);              
  53.         } catch (Exception e) {  
  54.             e.printStackTrace();  
  55.         }  
  56.           
  57.         System.out.println("\r\n");  
  58.   
  59.         return result;  
  60.     }  
  61.       
  62.     /** 
  63.      * 授权校验失败，在SOAPBody中添加SOAPFault 
  64.      * @param message 
  65.      */  
  66.     private void validateFail(SOAPMessage message) {  
  67.         try {  
  68.             SOAPEnvelope envelop = message.getSOAPPart().getEnvelope();  
  69.   
  70.             envelop.getHeader().detachNode();  
  71.             envelop.addHeader();  
  72.   
  73.             envelop.getBody().detachNode();  
  74.             SOAPBody body = envelop.addBody();  
  75.   
  76.             SOAPFault fault = body.getFault();  
  77.   
  78.             if (fault == null) {  
  79.                 fault = body.addFault();  
  80.             }  
  81.   
  82.             fault.setFaultString("授权校验失败！");  
  83.   
  84.             message.saveChanges();  
  85.         } catch (SOAPException e) {  
  86.             e.printStackTrace();  
  87.         }  
  88.     }  
  89.       
  90.     /** 
  91.      * 授权校验 
  92.      * @param message 
  93.      * @return 校验成功返回true，校验失败返回false 
  94.      */  
  95.     private boolean validate(SOAPMessage message){  
  96.         boolean result = false;  
  97.           
  98.         try {  
  99.             SOAPEnvelope envelop = message.getSOAPPart().getEnvelope();  
  100.             SOAPHeader header = envelop.getHeader();  
  101.               
  102.             if(header != null){  
  103.                 Iterator iterator = header.getChildElements(new QName("http://www.tmp.com/auth", "auth"));  
  104.                 SOAPElement auth = null;  
  105.                   
  106.                 if(iterator.hasNext()){  
  107.                     //获取auth  
  108.                     auth = (SOAPElement)iterator.next();  
  109.                       
  110.                     //获取name  
  111.                     Iterator it = auth.getChildElements(new QName("http://www.tmp.com/auth", "name"));  
  112.                     SOAPElement name = null;  
  113.                     if(it.hasNext()){  
  114.                         name = (SOAPElement)it.next();  
  115.                     }  
  116.                       
  117.                     //获取password  
  118.                     it = auth.getChildElements(new QName("http://www.tmp.com/auth", "password"));  
  119.                     SOAPElement password = null;  
  120.                     if(it.hasNext()){  
  121.                         password = (SOAPElement)it.next();  
  122.                     }  
  123.                       
  124.                     //判断name和password是否符合要求  
  125.                     if(name != null && password != null && "admin".equals(name.getValue()) && "admin".equals(password.getValue())){  
  126.                         result = true;  
  127.                     }  
  128.                 }  
  129.             }  
  130.               
  131.         } catch (SOAPException e) {  
  132.             e.printStackTrace();  
  133.         }  
  134.           
  135.         return result;  
  136.     }  
  137.   
  138.     @Override  
  139.     public Set<QName> getHeaders() {  
  140.         return null;  
  141.     }  
  142.   
  143. }  


客户端


客户端添加授权Handler

[html]  view plain  copy
  1. import java.util.Set;  
  2.   
  3. import javax.xml.namespace.QName;  
  4. import javax.xml.soap.SOAPElement;  
  5. import javax.xml.soap.SOAPException;  
  6. import javax.xml.soap.SOAPHeader;  
  7. import javax.xml.soap.SOAPMessage;  
  8. import javax.xml.ws.handler.MessageContext;  
  9. import javax.xml.ws.handler.soap.SOAPHandler;  
  10. import javax.xml.ws.handler.soap.SOAPMessageContext;  
  11.   
  12. /**  
  13.  * 客户端添加请求授权  
  14.  * @author accountwcx@qq.com  
  15.  *  
  16.  */  
  17. public class AddAuthHandler implements SOAPHandler<SOAPMessageContext> {  
  18.   
  19.     @Override  
  20.     public boolean handleMessage(SOAPMessageContext context) {  
  21.         // 判断消息是请求还是响应  
  22.         Boolean output = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);  
  23.   
  24.         SOAPMessage message = context.getMessage();  
  25.   
  26.         if (output) {  
  27.             try {  
  28.                 SOAPHeader header = message.getSOAPHeader();  
  29.                 if (header == null) {  
  30.                     header = message.getSOAPPart().getEnvelope().addHeader();  
  31.                 }  
  32.   
  33.                 SOAPElement auth = header.addChildElement(new QName("http://www.tmp.com/auth", "auth"));  
  34.                   
  35.                 SOAPElement name = auth.addChildElement("name");  
  36.                 name.addTextNode("admin");  
  37.   
  38.                 SOAPElement password = auth.addChildElement("password");  
  39.                 password.addTextNode("admin");  
  40.                   
  41.                 message.saveChanges();  
  42.   
  43.             } catch (SOAPException e) {  
  44.                 e.printStackTrace();  
  45.             }  
  46.         }  
  47.           
  48.         System.out.println(output ? "客户端请求：" : "客户端接收：");  
  49.         try {  
  50.             message.writeTo(System.out);  
  51.         } catch (Exception e) {  
  52.             e.printStackTrace();  
  53.         }  
  54.           
  55.         System.out.println("\r\n");  
  56.   
  57.         return true;  
  58.     }  
  59.   
  60.     @Override  
  61.     public boolean handleFault(SOAPMessageContext context) {  
  62.         return true;  
  63.     }  
  64.   
  65.     @Override  
  66.     public void close(MessageContext context) {  
  67.     }  
  68.   
  69.     @Override  
  70.     public Set<QName> getHeaders() {  
  71.         return null;  
  72.     }  
  73. }  

客户端Handler配置文件handler-chain.xml

[html]  view plain  copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <javaee:handler-chains xmlns:javaee="http://java.sun.com/xml/ns/javaee"  
  3.     xmlns:xsd="http://www.w3.org/2001/XMLSchema">  
  4.     <javaee:handler-chain>  
  5.         <javaee:handler>  
  6.             <javaee:handler-class>com.rvho.client.handler.AddAuthHandler</javaee:handler-class>  
  7.         </javaee:handler>  
  8.     </javaee:handler-chain>  
  9. </javaee:handler-chains>  

客户端的Service中添加Handler配置文件

[java]  view plain  copy
  1. /** 
  2.  * This class was generated by the JAX-WS RI. 
  3.  * JAX-WS RI 2.2.9-b130926.1035 
  4.  * Generated source version: 2.2 
  5.  *  
  6.  */  
  7. @WebServiceClient(name = "HelloWSService", targetNamespace = "http://www.tmp.com/ws/hello", wsdlLocation = "http://localhost:8014/jaxwsserver/services/hello?wsdl")  
  8. @HandlerChain(file="handler-chain.xml")  
  9. public class HelloWSService  
  10.     extends Service  
  11. {  
  12.   
  13.     private final static URL HELLOWSSERVICE_WSDL_LOCATION;  
  14.     private final static WebServiceException HELLOWSSERVICE_EXCEPTION;  
  15.     private final static QName HELLOWSSERVICE_QNAME = new QName("http://www.tmp.com/ws/hello", "HelloWSService");  
  16.   
  17.     static {  
  18.         URL url = null;  
  19.         WebServiceException e = null;  
  20.         try {  
  21.             url = new URL("http://localhost:8014/jaxwsserver/services/hello?wsdl");  
  22.         } catch (MalformedURLException ex) {  
  23.             e = new WebServiceException(ex);  
  24.         }  
  25.         HELLOWSSERVICE_WSDL_LOCATION = url;  
  26.         HELLOWSSERVICE_EXCEPTION = e;  
  27.     }  
  28.   
  29.     public HelloWSService() {  
  30.         super(__getWsdlLocation(), HELLOWSSERVICE_QNAME);  
  31.     }  
  32.   
  33.     public HelloWSService(WebServiceFeature... features) {  
  34.         super(__getWsdlLocation(), HELLOWSSERVICE_QNAME, features);  
  35.     }  
  36.   
  37.     public HelloWSService(URL wsdlLocation) {  
  38.         super(wsdlLocation, HELLOWSSERVICE_QNAME);  
  39.     }  
  40.   
  41.     public HelloWSService(URL wsdlLocation, WebServiceFeature... features) {  
  42.         super(wsdlLocation, HELLOWSSERVICE_QNAME, features);  
  43.     }  
  44.   
  45.     public HelloWSService(URL wsdlLocation, QName serviceName) {  
  46.         super(wsdlLocation, serviceName);  
  47.     }  
  48.   
  49.     public HelloWSService(URL wsdlLocation, QName serviceName, WebServiceFeature... features) {  
  50.         super(wsdlLocation, serviceName, features);  
  51.     }  
  52.   
  53.     /** 
  54.      *  
  55.      * @return 
  56.      *     returns HelloWS 
  57.      */  
  58.     @WebEndpoint(name = "HelloWSPort")  
  59.     public HelloWS getHelloWSPort() {  
  60.         return super.getPort(new QName("http://www.tmp.com/ws/hello", "HelloWSPort"), HelloWS.class);  
  61.     }  
  62.   
  63.     /** 
  64.      *  
  65.      * @param features 
  66.      *     A list of {@link javax.xml.ws.WebServiceFeature} to configure on the proxy.  Supported features not in the <code>features</code> parameter will have their default values. 
  67.      * @return 
  68.      *     returns HelloWS 
  69.      */  
  70.     @WebEndpoint(name = "HelloWSPort")  
  71.     public HelloWS getHelloWSPort(WebServiceFeature... features) {  
  72.         return super.getPort(new QName("http://www.tmp.com/ws/hello", "HelloWSPort"), HelloWS.class, features);  
  73.     }  
  74.   
  75.     private static URL __getWsdlLocation() {  
  76.         if (HELLOWSSERVICE_EXCEPTION!= null) {  
  77.             throw HELLOWSSERVICE_EXCEPTION;  
  78.         }  
  79.         return HELLOWSSERVICE_WSDL_LOCATION;  
  80.     }  
  81.   
  82. }  


客户端发起index请求

[java]  view plain  copy
  1. URL wsdlUrl = new URL("http://localhost:7180/jaxwsserver/services/hello?wsdl");  
  2. HelloWSService helloWSS = new HelloWSService(wsdlUrl);  
  3. HelloWS helloWS = helloWSS.getHelloWSPort();  
  4. String index = helloWS.index();  

客户端发起正确授权的请求以及服务器的响应

[html]  view plain  copy
  1. <!-- 客户端请求 -->  
  2. <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"  
  3.             xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">  
  4.     <SOAP-ENV:Header>  
  5.         <auth xmlns="http://www.tmp.com/auth">  
  6.             <name>admin</name>  
  7.             <password>admin</password>  
  8.         </auth>  
  9.     </SOAP-ENV:Header>  
  10.     <S:Body>  
  11.         <ns2:index xmlns:ns2="http://www.tmp.com/ws/hello" />  
  12.     </S:Body>  
  13. </S:Envelope>  
  14.   
  15. <!-- 服务端响应 -->  
  16. <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"  
  17.             xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">  
  18.     <SOAP-ENV:Header/>  
  19.     <S:Body>  
  20.         <ns2:indexResponse xmlns:ns2="http://www.tmp.com/ws/hello">  
  21.             <return>hello</return>  
  22.         </ns2:indexResponse>  
  23.     </S:Body>  
  24. </S:Envelope>  

客户端发起错误授权的请求以及服务器的响应

[html]  view plain  copy
  1. <!-- 客户端请求 -->  
  2. <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"  
  3.             xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">  
  4.     <SOAP-ENV:Header>  
  5.         <auth xmlns="http://www.tmp.com/auth">  
  6.             <name></name>  
  7.             <password></password>  
  8.         </auth>  
  9.     </SOAP-ENV:Header>  
  10.     <S:Body>  
  11.         <ns2:index xmlns:ns2="http://www.tmp.com/ws/hello" />  
  12.     </S:Body>  
  13. </S:Envelope>  
  14.   
  15. <!-- 服务器响应 -->  
  16. <S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/"   
  17.             xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/">  
  18.     <S:Header/>  
  19.     <S:Body>  
  20.         <S:Fault>  
  21.             <faultcode>S:Server</faultcode>  
  22.             <faultstring>授权校验失败！</faultstring>  
  23.         </S:Fault>  
  24.     </S:Body>  
  25. </S:Envelope>  


HandlerReolver代替Handler配置文件


handler-chain配置文件对所有的请求都添加授权验证信息，有些时候不是所有的请求都需要添加授权验证，HandlerResolver提供了在编程时添加Handler的方法，可以用HandlerResolver给需要授权的接口添加Handler。

[java]  view plain  copy
  1. URL wsdlUrl = new URL("http://localhost:7180/jaxwsserver/services/hello?wsdl");  
  2. HelloWSService helloWSS = new HelloWSService(wsdlUrl);  
  3.   
  4. //通过HandlerResolver添加Handler  
  5. helloWSS.setHandlerResolver(new HandlerResolver(){  
  6.   
  7.     @Override  
  8.     @SuppressWarnings("rawtypes")             
  9.     public List<Handler> getHandlerChain(PortInfo portInfo) {  
  10.         List<Handler> handlerChain = new ArrayList<Handler>();  
  11.         handlerChain.add(new AddAuthHandler());  
  12.         return handlerChain;  
  13.     }  
  14.       
  15. });  
  16.   
  17. HelloWS helloWS = helloWSS.getHelloWSPort();  
  18.   
  19. //调用index服务  
  20. String index = helloWS.index();  


lipc_
关注
专栏目录
JDK1.6自带的Jax-Ws详解（含权限检查完整解决方案）
thegodofwar的专栏
11-01 4333
       最近参与开发一个防火墙项目，主要负责Web Services，因为实际情况选用了JDK1.6自带的Jax-Ws，它比当前比较主流的CXF(已经替代了以前的XFIRE)轻量,不依赖任何容器，一个简单的Java Application就可以发布Web Services,这是一件多么令人兴奋的事，但是权限检查却非常费力，查看了很多解决方案，他们大多数是针对容器上部署的Web Services的权限检查......最后终于在官网文档（https://xwss.dev.java.net/Securing
WebService权限
03-23
NULL 博文链接：https://q-wong.iteye.com/blog/1069653
Web Service学习-CXF开发Web Service的权限控制（二）
weixin_34249678的博客
07-05 105
Web Service怎样进行权限控制？ 解决思路：server端要求input消息总是携带实username。password信息，假设没实username和password信息。直接拒绝调用 解决方式：拦截器 为了让程序猿能訪问，并改动CXF框架所生成的SOAP消息，CXF提供了拦截器 CXF（Celtix +XFire）说明： 假设不用CXF等框架，SOAP消息的生成。解析都是由程序猿负...
webservice 权限控制
weixin_34199335的博客
11-10 245
webservice 如何限制访问，权限控制？1.服务器端总是要input消息必须携带用户名、密码信息 如果不用cxf框架，SOAP消息（xml片段）的生成、解析都是有程序员负责 2.拦截器 为了让程序员能访问，并修改cxf框架所生成的soap消息，cxf提供拦截器 服务器添加拦截器 1.获取Endpoint的publish方法返回值 2.调用该方法的返回值getInInterceptor...
webservice权限控制
weixin_30855761的博客
10-18 978
webservice权限控制设计及说明 已有2.0版本，自动实现接口，取消了eclipse生成实现类的过程，详情见git上2.0文档 代码地址（1.0） https://coding.net/u/mich/p/easytry/git/tree/master/WebService 代码地址（2.0） https://coding.net/u/mich/p/easytry/git/tre...
webService权限问题
weixin_30468137的博客
07-24 384
1.在本地发布的 webservice 当我们运行时是可以看见输入框的 当换成别的IP时看不见 这是webservice出于安全考虑的 只需要在 web 加入 <system.web> <webServices> <protocols> <add name="HttpGet" /> <add name="HttpPo...
jax-ws handler 的详解及简单实例
08-29
JAX-WS Handler 是 Java API for XML Web Services (JAX-WS) 中的一个关键组件，它提供了一种在服务端和客户端处理消息的机制，类似于面向切面编程（AOP）的概念。Handler 可以在 Web Service 请求和响应之间插入...
jax-ws的handler做调用权限校验例子
10-01
在这个例子中，我们将关注如何使用`JAX-WS`的`Handler`机制进行调用权限校验。 `Handler`是`JAX-WS`中的一个重要组件，它允许我们在Web服务调用的生命周期中插入自定义逻辑。这包括在消息发送前、接收到消息后、...
webService - 使用Handler来增强WebService的功能
Laurence
09-26 4193
阅读本文前您需要以下的知识和工具： Apache axis1.1，并且会初步使用；Tomcat 4.0以上, 并且会初步使用；SOAP消息（SOAP Message）编程知识；JAX-RPC编程基础知识；Java安全编程基础知识。Handler的基本概念J2EE Web 服务中的Handler技术特点非常像Servlet技术中的Filter。我们知道，在Servlet中，当一个HTTP到达服务端时，往往要经过多个Filter对请求进行过滤，然后才到达提供服务的Servlet，这些Filter的功能往往是对请
自己写的一个基于WebService的权限管理系统
06-05
这是自己写的一个基于WebService的权限管理系统，内附完整的解决方案，数据库文件，使用说明等。具有较高的的参考价值。如有什么好的建议可以给我留言。
JAX-WS实做webservice验证
pdw2009的专栏
03-26 798
jdk ws例子
WebService：权限控制、拦截器
熊诗言的博客
12-15 960
[03]基于webservice的权限系统
qzp1991的专栏
09-30 1140
基于webservice的权限系统
[01]基于webservice的权限系统
qzp1991的专栏
09-26 1889
基于webservice的权限系统
[02]基于webservice的权限系统
qzp1991的专栏
09-28 1142
基于webservice的权限系统 数据库设计
JAX-WS - Handler详解
袭冷
06-24 2059
一、Handler说明     Handler用于处理Soap消息，如控制Header（如隐式的添加用户信息等）     Handler分成LogicalHandler和SOAPHandler，常用为SOAPHandler；客户端先处理LogicalHeader再处理SOAPHandler，服务器反之 二、开始前的准备     1、服务端         （1）接口：
webservice使用拦截器进行权限验证
u011079727的专栏
11-12 1527
我们知道webservice是实现两个系统之间的交互
webservice添加用户密码验证
mxia520的博客
11-15 7388
一、增加maven 依赖 &lt;dependency&gt; &lt;groupId&gt;org.apache.cxf&lt;/groupId&gt; &lt;artifactId&gt;cxf-rt-ws-security&lt;/artifactId&gt; &lt;version&gt;3.1.8&lt;/version&gt;
使用JAX-WS开发与部署WebService教程
本文档主要讲解了如何使用JAX-WS技术来开发和部署Web服务，包括基于WSDL文件创建WebService客户端的详细步骤，并提供了一个简单的WSDL文件示例。 在Java环境中，JAX-WS（Java API for XML Web Services）是一种标准...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值