CXF 入门：创建一个基于WS-Security标准的安全验证(CXF回调函数使用)

注意：以下客户端调用代码中获取服务端ws实例，都是通过CXF 入门: 远程接口调用方式实现

以下是服务端配置

========================================================

一，web.xml配置,具体不在详述

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE web-app
  3. PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  4. "http://java.sun.com/dtd/web-app_2_3.dtd">
  5. <web-app>
  6. <context-param>
  7. <param-name>contextConfigLocation</param-name>
  8. <!--ws-context.xml(必须）是cxf配置文件, wssec.xml可选，作用可以打印出加密信息类容 -->
  9. <param-value>WEB-INF/ws-context.xml,WEB-INF/wssec.xml</param-value>
  10. </context-param>
  11. <listener>
  12. <listener-class>
  13. org.springframework.web.context.ContextLoaderListener
  14. </listener-class>
  15. </listener>
  16. <servlet>
  17. <servlet-name>CXFServlet</servlet-name>
  18. <display-name>CXF Servlet</display-name>
  19. <servlet-class>
  20. org.apache.cxf.transport.servlet.CXFServlet
  21. </servlet-class>
  22. <load-on-startup>0</load-on-startup>
  23. </servlet>
  24. <servlet-mapping>
  25. <servlet-name>CXFServlet</servlet-name>
  26. <url-pattern>/services/*</url-pattern>
  27. </servlet-mapping>
  28. </web-app>

二，ws具体代码
简单的接口

  1. import javax.jws.WebService;
  2. @WebService()
  3. public interface WebServiceSample {
  4. String say(String name);
  5. }

接口具体实现类

  1. public class WebServiceSampleImpl implements WebServiceSample {
  2. public String say(String name) {
  3. return "你好," + name;
  4. }
  5. }

三,ws回调函数,必须实现javax.security.auth.callback.CallbackHandler

从cxf2.4.x后校验又cxf内部实现校验，所以不必自己校验password是否相同，但客户端必须设置，详情请参考：http://cxf.apache.org/docs/24-migration-guide.html的Runtime  Changes片段

回调函数WsAuthHandler代码，校验客户端请求是否合法 ，合法就放行，否则拒绝执行任何操作

  1. import java.io.IOException;
  2. import javax.security.auth.callback.Callback;
  3. import javax.security.auth.callback.CallbackHandler;
  4. import javax.security.auth.callback.UnsupportedCallbackException;
  5. import org.apache.cxf.interceptor.Fault;
  6. import org.apache.ws.security.WSPasswordCallback;
  7. import org.apache.xmlbeans.impl.soap.SOAPException;
  8. public class WsAuthHandler implements CallbackHandler {
  9. public void handle(Callback[] callbacks) throws IOException,
  10. UnsupportedCallbackException {
  11. for (int i = 0; i < callbacks.length; i++) {
  12. WSPasswordCallback pc = (WSPasswordCallback) callbacks[i];
  13. String identifier = pc.getIdentifier();
  14. int usage = pc.getUsage();
  15. if (usage == WSPasswordCallback.USERNAME_TOKEN) {// 密钥方式USERNAME_TOKEN
  16. // username token pwd...
  17. // ▲这里的值必须和客户端设的值相同,从cxf2.4.x后校验方式改为cxf内部实现校验，不必自己比较password是否相同
  18. // 请参考：http://cxf.apache.org/docs/24-migration-guide.html的Runtime
  19. // Changes片段
  20. pc.setPassword("testPassword");// ▲【这里非常重要】▲
  21. // ▲PS 如果和客户端不同将抛出org.apache.ws.security.WSSecurityException:
  22. // The
  23. // security token could not be authenticated or
  24. // authorized异常，服务端会认为客户端为非法调用
  25. } else if (usage == WSPasswordCallback.SIGNATURE) {// 密钥方式SIGNATURE
  26. // set the password for client‘s keystore.keyPassword
  27. // ▲这里的值必须和客户端设的值相同,从cxf2.4.x后校验方式改为cxf内部实现校验，不必自己比较password是否相同;
  28. // 请参考：http://cxf.apache.org/docs/24-migration-guide.html的Runtime
  29. // Changes片段
  30. pc.setPassword("testPassword");// //▲【这里非常重要】▲
  31. // ▲PS:如果和客户端不同将抛出org.apache.ws.security.WSSecurityException:The
  32. // security token could not be authenticated or
  33. // authorized异常，服务端会认为客户端为非法调用
  34. }
  35. //不用做其他操作
  36. }
  37. }
  38. }

四，CXF配置ws-context.xml：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
  4. xsi:schemaLocation="
  5. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  6. http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
  7. <import resource="classpath:META-INF/cxf/cxf.xml" />
  8. <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />
  9. <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
  10. <!-- 以上未基本配置，必须，位置在cxf jar中 -->
  11. <jaxws:endpoint id="webServiceSample" address="/WebServiceSample"
  12. implementor="com.service.impl.WebServiceSampleImpl">
  13. <!--inInterceptors表示被外部调用时，调用此拦截器 -->
  14. <jaxws:inInterceptors>
  15. <bean class="org.apache.cxf.binding.soap.saaj.SAAJInInterceptor" />
  16. <bean class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
  17. <constructor-arg>
  18. <map>
  19. <!-- 设置加密类型 -->
  20. <entry key="action" value="UsernameToken" />
  21. <!-- 设置密码类型为明文 -->
  22. <entry key="passwordType" value="PasswordText" />
  23. <!--<entry key="action" value="UsernameToken Timestamp" /> 设置密码类型为加密<entry
  24. key="passwordType" value="PasswordDigest" /> -->
  25. <entry key="passwordCallbackClass" value="com.service.handler.WsAuthHandler" />
  26. </map>
  27. </constructor-arg>
  28. </bean>
  29. </jaxws:inInterceptors>
  30. </jaxws:endpoint>
  31. </beans>

CXF配置wssec.xml(可选)，用于配置输出校验的具体信息

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:cxf="http://cxf.apache.org/core"
  4. xmlns:wsa="http://cxf.apache.org/ws/addressing" xmlns:http="http://cxf.apache.org/transports/http/configuration"
  5. xmlns:wsrm-policy="http://schemas.xmlsoap.org/ws/2005/02/rm/policy"
  6. xmlns:wsrm-mgr="http://cxf.apache.org/ws/rm/manager"
  7. xsi:schemaLocation="
  8. http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
  9. http://cxf.apache.org/transports/http/configuration http://cxf.apache.org/schemas/configuration/http-conf.xsd
  10. http://schemas.xmlsoap.org/ws/2005/02/rm/policy http://schemas.xmlsoap.org/ws/2005/02/rm/wsrm-policy.xsd
  11. http://cxf.apache.org/ws/rm/manager http://cxf.apache.org/schemas/configuration/wsrm-manager.xsd
  12. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  13. <cxf:bus>
  14. <cxf:features>
  15. <cxf:logging />
  16. <wsa:addressing />
  17. </cxf:features>
  18. </cxf:bus>
  19. </beans>

服务端代码及配置到此结束！！！

=========================================================

=========================================================

以下是客户端配置，主要是回调函数，在客户端调用服务端前被调用，负责安全信息的设置

----------------------------------------------------------------------------------------

一，先实现回调函数WsClinetAuthHandler，同样必须实现javax.security.auth.callback.CallbackHandler

  1. import java.io.IOException;
  2. import javax.security.auth.callback.Callback;
  3. import javax.security.auth.callback.CallbackHandler;
  4. import javax.security.auth.callback.UnsupportedCallbackException;
  5. import org.apache.ws.security.WSPasswordCallback;
  6. public class WsClinetAuthHandler implements CallbackHandler {
  7. public void handle(Callback[] callbacks) throws IOException,
  8. UnsupportedCallbackException {
  9. for (int i = 0; i < callbacks.length; i++) {
  10. WSPasswordCallback pc = (WSPasswordCallback) callbacks[i];
  11. System.out.println("identifier: " + pc.getIdentifier());
  12. // 这里必须设置密码，否则会抛出：java.lang.IllegalArgumentException: pwd == null
  13. // but a password is needed
  14. pc.setPassword("testPassword");// ▲【这里必须设置密码】▲
  15. }
  16. }
  17. }

二，客户端调用代码：

  1. import java.util.ArrayList;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. import org.apache.cxf.binding.soap.saaj.SAAJOutInterceptor;
  5. import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
  6. import org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor;
  7. import org.apache.ws.security.WSConstants;
  8. import org.apache.ws.security.handler.WSHandlerConstants;
  9. import test.saa.client.WebServiceSample;
  10. import test.saa.handler.WsClinetAuthHandler;
  11. public class TestClient {
  12. public static void main(String[] args) {
  13. // 以下和服务端配置类似，不对，应该说服务端和这里的安全验证配置一致
  14. Map<String, Object> outProps = new HashMap<String, Object>();
  15. outProps.put(WSHandlerConstants.ACTION,
  16. WSHandlerConstants.USERNAME_TOKEN);
  17. outProps.put(WSHandlerConstants.USER, "admin");
  18. outProps.put(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_TEXT);
  19. // 指定在调用远程ws之前触发的回调函数WsClinetAuthHandler，其实类似于一个拦截器
  20. outProps.put(WSHandlerConstants.PW_CALLBACK_CLASS,
  21. WsClinetAuthHandler.class.getName());
  22. ArrayList list = new ArrayList();
  23. // 添加cxf安全验证拦截器，必须
  24. list.add(new SAAJOutInterceptor());
  25. list.add(new WSS4JOutInterceptor(outProps));
  26. JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
  27. // WebServiceSample服务端接口实现类，这里并不是直接把服务端的类copy过来，具体请参考http://learning.iteye.com/blog/1333223
  28. factory.setServiceClass(WebServiceSample.class);
  29. // 设置ws访问地址
  30. factory.setAddress("http://localhost:8080/cxf-wssec/services/WebServiceSample");
  31. //注入拦截器，用于加密安全验证信息
  32. factory.getOutInterceptors().addAll(list);
  33. WebServiceSample service = (WebServiceSample) factory.create();
  34. String response = service.say("2012");
  35. System.out.println(response);
  36. }
  37. }

客户端到此结束！！！！

========================================================================

#######################################################################

PS:客户端的另一种调用方式，主要通过配置文件,不过需要spring bean的配置文件（第一种就不用牵扯到spring的配置，比较通用吧！）

一，回调函数WsClinetAuthHandler不变，和上面一样
二，client-beans.xml安全验证配置文件，具体信息看注释，如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
  4. xsi:schemaLocation="
  5. http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
  6. http://cxf.apache.org/jaxws http://cxf.apache.org/schema/jaxws.xsd">
  7. <!--这里无非是通过配置来替代JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean()创建代理并实例化一个ws-->
  8. <bean id="client" class="test.saa.client.WebServiceSample"
  9. factory-bean="clientFactory" factory-method="create" />
  10. <!-- 通过代理创建ws实例 -->
  11. <bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
  12. <property name="serviceClass" value="test.saa.client.WebServiceSample" />
  13. <!-- ws地址，也可以是完整的wsdl地址 -->
  14. <property name="address"
  15. value="http://localhost:8080/cxf-wssec/services/WebServiceSample" />
  16. <!--outInterceptors表示调用外部指定ws时，调用此拦截器 -->
  17. <property name="outInterceptors">
  18. <list>
  19. <bean class="org.apache.cxf.binding.soap.saaj.SAAJOutInterceptor" />
  20. <ref bean="wss4jOutConfiguration" />
  21. </list>
  22. </property>
  23. </bean>
  24. <bean id="wss4jOutConfiguration" class="org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor">
  25. <property name="properties">
  26. <map>
  27. <!-- 设置加密类型 ,服务端需要和这里的设置保持一致-->
  28. <entry key="action" value="UsernameToken" />
  29. <entry key="user" value="admin" />
  30. <!-- 设置密码为明文 ,服务端需要和这里的设置保持一致-->
  31. <entry key="passwordType" value="PasswordText" />
  32. <!-- <entry key="action" value="UsernameToken Timestamp" /> <entry key="user"
  33. value="adminTest" /> 设置密码类型为加密方式,服务端需要和这里的设置保持一致<entry key="passwordType" value="PasswordDigest"
  34. /> -->
  35. <entry key="passwordCallbackRef">
  36. <ref bean="passwordCallback" />
  37. </entry>
  38. </map>
  39. </property>
  40. </bean>
  41. <bean id="passwordCallback" class="test.saa.handler.WsClinetAuthHandler" />
  42. </beans>

三，具体调用服务端代码：

    1. import org.springframework.context.ApplicationContext;
    2. import org.springframework.context.support.ClassPathXmlApplicationContext;
    3. import test.saa.client.WebServiceSample;
    4. public final class Client {
    5. public static void main(String args[]) throws Exception {
    6. //加载配置
    7. ApplicationContext context = new ClassPathXmlApplicationContext(
    8. new String[] { "test/saa/client-beans.xml" });
    9. //获取ws实例
    10. WebServiceSample client = (WebServiceSample) context.getBean("client");
    11. String response = client.say("2012");
    12. System.out.println("Response: " + response);
    13. }
    14. }
时间： 2024-12-19 07:04:12

CXF 入门：创建一个基于WS-Security标准的安全验证(CXF回调函数使用)的相关文章

使用CXF+spring创建一个web的接口项目

一.web project整合spring 1.1.打开Myeclipse,建立web project(eclipse为dynamic web project),使用J2EE5.0. 1.2.添加Srping的基本jar包(无需事务等) org.springframework.beans-3.1.1.RELEASE.jar commons-logging.jar org.springframework.aop-3.1.1.RELEASE.jar org.springframework.asm-3

Kivy A to Z -- 如何从Python创建一个基于Binder的Service及如何从Java访问Python创建的Service

<Kivy A to Z -- 如何从python代码中直接访问Android的Service> 一文中讲到了如何从python访问java的service,这一篇再来讲下如何创建一个基于Binder的Python Service以及如何从Java代码中访问这个Python创建的Service. 先来看代码,再作下解释: 接<Kivy A to Z -- 如何从python代码中直接访问Android的Service>一文,我们在相关的文件中增加代码: binder_wrap.cp

如何创建一个基于Maven的SmartGWT项目

如何创建一个基于Maven的SmartGWT项目 使用环境 Eclipse的版本为:Luna Service Release 2 (4.4.2)(这个其实不是很重要,你完全可以使用最新版本的Eclipse或者MyEclipse) Maven的版本为:3.1.0 SmartGWT的版本为:6.0p GWT的SDK版本为:2.7 前提准备 你需要安装Maven.如何安装Maven不是文本的内容,你可以参考我的关于Maven的博客. 把SmartGWT的jar包上传到私服服务器. 操作过程 创建GWT

CXF 入门：创建一个基于SOAPHeader的安全验证(CXF拦截器使用)

下面具体的webservice实现类直接用的是上面的,这里不再说明 CXF拦截器使用,创建一个使用SOAPHeader的安全验证   xml格式: <soap:Header> <auth:authentication xmlns:auth="http://gd.chinamobile.com//authentication"> <auth:systemID>1</auth:systemID> <auth:userID>test

[STM32F10x] 从零开始创建一个基于标准库的工程

硬件:STM32F103C8T6 平台:MDK-AMR V4.70 1.创建一个Keil uVision 的工程 要点:相同类型的源文件放在一起以便于管理       2.添加标准库源文件 3.添加几个必要的源文件 包括: core_cm3.c stm32f10x_it.c system_stm32f10x_it.c stm32f10x_conf.h 4.指定头文件路径 5.添加必要的预处理标志 本例为 USE_STDPERIPH_DRIVER, STM32F10X_MD 6.添加一个main函

【webGL】threejs入门 ---创建一个简单立方体

开发环境 Three.js是一个JavaScript库,所以,你可以使用平时开发JavaScript应用的环境开发Three.js应用.如果你没什么偏好的话,我会推荐Komodo IDE. 调试建议使用Chrome或者Firefox浏览器.如果你使用的是Firefox,那么Firebug会是你必不可少的插件:如果你使用的是Chrome,那么直接使用控制台调试即可.这些和JavaScript的调试是相同的,因此本书不作进一步展开. 下载 首先,我们需要在Github下载Three.js的代码. 在

Qt使用教程之创建一个基于Qt部件的应用程序（一）

<Qt Enterprise最新版下载> 本教程主要介绍了如何使用Qt Creator来创建一个文字搜索的小的Qt应用程序,它是Qt UI Tools Text Finder Example的简化版本.该应用程序的用户界面是由Qt部件使用Qt Designer构建的:在代码编辑器中使用C ++编写该应用程序的逻辑. 创建文本搜索项目 1. 选择File > New File or Project > Application > Qt Widgets Application &

如何利用Facebook的create-react-app脚手架创建一个基于ant design mobile的项目

引言: create-react-app是Facebook发布的一款全局的命令行工具用来创建一个新的项目. 通常我们开始做一个react web或者 app 项目的时候,都会自己利用 npm 或者 yarn 安装项目所需要的一些依赖,再写 webpack.config.js ,一系列复杂的配置,搭建好开发环境后写src源代码. 现在,如果你想要搭建一个完整的 react 项目环境,已经不需要自己动手布置许许多多的东西,利用 create-react-app 工具,就能轻松帮你配置好一个 reac

使用IDEA结合MAVEN创建一个基于SpringMVC为前端JdbcTemplate为数据库组件的Java Web项目

前言 如今的Java项目,如果还使用传统的把jar包复制到目录下这种原始的方式,对于依赖管理来说实在是灾难.对某个功能需要引入某种技术包,但是你不确定是否已存在,如果分类好的话还好找,若是杂在一堆不仅头大,还身心俱疲.Maven旨在解决依赖问题,让项目结构变得精简,而Spring解决了项目中Bean的管理以及各种配置文件配置的功能轻松读入等问题,对于Java项目来说确实是福音.对于一个Web项目来说,必然需要数据库的读写,JdbcTemplate是一个Spring实现的Jdbc Support.