`
schy_hqh
  • 浏览: 543176 次
  • 性别: Icon_minigender_1
社区版块
存档分类
最新评论

JAX与spring的无缝集成（一）

 
阅读更多

JAX-WS与spring集成有几种方式：

第一种：

通过jaxws-rt来实现对webservice的启动。

确定：需要额外编写一个配置文件sun-jaxws.xml，而且无法使用spring的自动注入功能，只能收到从BeanFactory中获取bean！

依赖

<!-- 通过servlet集成jax -->
<dependency>
	<groupId>com.sun.xml.ws</groupId>
	<artifactId>jaxws-rt</artifactId>
</dependency>

 

需要在web.xml中配置一个Servlet

<listener>
	<listener-class>com.sun.xml.ws.transport.http.servlet.WSServletContextListener</listener-class>
</listener>
<servlet>
	<servlet-name>StudentWsService</servlet-name>
	<servlet-class>com.sun.xml.ws.transport.http.servlet.WSServlet</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>StudentWsService</servlet-name>
	<url-pattern>/ws</url-pattern>
</servlet-mapping>

 

需要额外增加一个配置文件：sun-jaxws.xml

<?xml version="1.0" encoding="UTF-8"?>
<endpoints xmlns="http://java.sun.com/xml/ns/jax-ws/ri/runtime" version="2.0">
	
	<!-- name配置服务的名称   implementation配置对应的实现类  url-pattern配置浏览器中访问本服务的地址-->
	<endpoint name="StudentWsService" 
		implementation="com.hqh.student.ws.StudentWSServiceImpl" 
		url-pattern="/ws"/>

</endpoints>

 

第二种（推荐）：

通过spring提供的jar包完成与JAX-WS的无缝集成

优点：webservice对象由spring管理，spring可以完成注入！

1、依赖包（需要排除其默认依赖的spring2.0，否则与项目使用的spring3.0冲突）

pom.xml

<!-- 通过spring提供的servlet集成jax -->
<dependency>
  <groupId>org.jvnet.jax-ws-commons.spring</groupId>
  <artifactId>jaxws-spring</artifactId>
  <!-- 排除其对spring2.0的依赖 -->
  <exclusions>
  	<exclusion>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring</artifactId>
  	</exclusion>
  </exclusions>
</dependency>

 

2、配置WSSpringServlet

<!-- 使用spring提供的对jax的支持 -->
<servlet>
	<servlet-name>StudentWsService-WSSpringServlet</servlet-name>
	<servlet-class>com.sun.xml.ws.transport.http.servlet.WSSpringServlet</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>StudentWsService-WSSpringServlet</servlet-name>
	<url-pattern>/jaxws-spring</url-pattern>
</servlet-mapping>

 

 

3、将jaxws与spring的整合放到另一个配置文件中 applicationContext-jaxws.xml

引入命名空间，在eclipse中引入schema文件（XML Catalog：Add ...）

（xsd文件可以从Maven Dependencies的jaxws-spring-1.8.jar中获得）

xmlns:ws和xmlns:wss为新加入的命名空间

 

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:ws="http://jax-ws.dev.java.net/spring/core"
        xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd  
           http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core.xsd
           http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet.xsd">
	
	<context:annotation-config/>
	
	<context:component-scan base-package="com.hqh.student"/>
	
	<!-- url must same with the url pattern of StudentWsService-WSSpringServlet in web.xml -->
	<wss:binding url="/jaxws-spring">
		<wss:service>
<!-- bean的值需要加前缀 "#",studentWsService是实现类在bean容器中的名称 --> 
			<ws:service bean="#studentWsService">
				<ws:metadata>
					<value>/WEB-INF/wsdl/student.xsd</value>
				</ws:metadata>
			</ws:service>
		</wss:service>
	</wss:binding>
	
	<!-- 手动注入（注：jaxws已经与spring集成起来，那么可以使用注解来注入了，不需要再手动注入！） -->
	<!-- Web service methods 
	<bean id="studentWsService" class="com.hqh.student.ws.StudentWSServiceImpl">
		<property name="studentService" ref="StudentService"></property>
	</bean>
	
	<bean id="StudentService" class="com.hqh.student.service.StudentServiceImpl"/>
	-->	
</beans>

 

 

4、在web.xml中加入基础配置

<!-- spring配置文件地址 -->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:applicationContext.xml,classpath:applicationContext-jaxws.xml</param-value>
</context-param>

 

5、webservice实现类中使用注解完成注入

package com.hqh.student.ws;

import java.util.List;

import javax.annotation.Resource;
import javax.jws.WebService;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryUtils;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.util.WebUtils;

import com.hqh.student.context.BeanFactoryUtil;
import com.hqh.student.context.WebUtil;
import com.hqh.student.model.Reward;
import com.hqh.student.model.Student;
import com.hqh.student.service.StudentService;


@WebService(endpointInterface="com.hqh.student.ws.IStudentWSService",
			serviceName="StudentWSService",
			portName="studentServicePort",
			targetNamespace="http://ws.student.hqh.com",
			wsdlLocation="/WEB-INF/wsdl/student.wsdl")
//该对象交由spring管理，studentWsService即为该实现类在bean容器中的name
@Component("studentWsService")
public class StudentWSServiceImpl implements IStudentWSService{
	
//	private static final BeanFactory factory = new ClassPathXmlApplicationContext("beans.xml");
//	public StudentWSServiceImpl() {
//		if(studentService==null) {
//			studentService = factory.getBean(StudentService.class);
//		}
//	}
	
	//自动注入
	@Resource
	private StudentService studentService;
	
	
	@Override
	public Student getStudent(String number) {
//		studentService = (StudentService) WebUtil.getBean(StudentService.class);
//		studentService = (StudentService) BeanFactoryUtil.getBean(StudentService.class);
		return studentService.getStudent(number);
	}

	@Override
	public List<Student> list() {
//		studentService = (StudentService) WebUtil.getBean(StudentService.class);
//		studentService = (StudentService) BeanFactoryUtil.getBean(StudentService.class);
		return studentService.list();
	}

	@Override
	public List<Reward> listReward(String number, String year) {
//		studentService = (StudentService) WebUtil.getBean(StudentService.class);
//		studentService = (StudentService) BeanFactoryUtil.getBean(StudentService.class);
		return studentService.listReward(number, year);
	}

}

 

启动jetty服务器，访问如下地址：

http://localhost:8080/student-web/jaxws-spring?wsdl

完成！

 

 客户端的编写

由于客户端与服务端是不同的两个应用，本例中服务端将采用Tomcat作为容器，客户端使用jetty作为容器

1、修改服务端的插件，使用tomcat

 

<!-- cargo插件 配置tomcat -->
<!-- 第一种方式：独立发布 -->
<plugin>
	<groupId>org.codehaus.cargo</groupId>
	<artifactId>cargo-maven2-plugin</artifactId>
	<configuration>
		<container>
			<containerId>tomcat6x</containerId>
			<home>E:\technology-hqh\soft\server\apache-tomcat-6.0.29</home>
		</container>
		<configuration>
			<!-- 独立部署 -->
			<type>standalone</type>
			<home>${project.build.directory}/tomcat6x</home>
			<properties>
				<!-- 设置新的端口 -->
				<cargo.servlet.port>9999</cargo.servlet.port>
			</properties>
		</configuration>
		<deployables>
	    <deployable>
	      <type>war</type>
	      <properties>
	      	<!-- 重新指定应用的上下文 -->
	        <context>/server</context>
	      </properties>
	    </deployable>
	  </deployables>
	</configuration>
</plugin>

 2、开始编写客户端

基本步骤：

使用jaxws-maven-plugin将wsdl转为本地java文件

使用springMVC实现呈现层的功能

使用jaxws-spring将JAX-WS与spring进行集成，主要是在客户端注入endpoint服务对象

使用maven-jetty-plugin插件，用jetty作为客户端的服务器

 

pom.xml

 

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>com.hqh.student</groupId>
	<artifactId>student-cient-remote</artifactId>
	<packaging>war</packaging>
	<version>0.0.1-SNAPSHOT</version>

	<name>student-cient-remote Maven Webapp</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>3.0.5.RELEASE</spring.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>
		<!-- SPRING -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- servlet+jstl+jsp -->
		<dependency>
			<groupId>servletapi</groupId>
			<artifactId>servletapi</artifactId>
			<version>2.4</version>
			<scope>provided</scope>
		</dependency>
		
	<!-- 主要是为了解决异常才引入jaxws-rt的：
		java.lang.ClassNotFoundException: com.sun.istack.XMLStreamReaderToContentHandler -->
		<dependency>
			<groupId>com.sun.xml.ws</groupId>
			<artifactId>jaxws-rt</artifactId>
			<version>2.1.3</version> 
			<!-- 排除 activation，解决包冲突异常java.lang.LinkageError: loader constraint violation-->
			<exclusions>
				<exclusion>
				<groupId>javax.activation</groupId>
					<artifactId>activation</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<!-- jax与 spring 集成 -->
		<dependency>
			<groupId>org.jvnet.jax-ws-commons.spring</groupId>
			<artifactId>jaxws-spring</artifactId>
			<version>1.8</version>
			<exclusions>
				<exclusion>
					<groupId>org.springframework</groupId>
					<artifactId>spring</artifactId>
				</exclusion>
				<!-- 排除 activation-->
				<exclusion>
				<groupId>javax.activation</groupId>
					<artifactId>activation</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>

	<build>
		<finalName>student-cient-remote</finalName>
		<!-- 客户端使用jetty容器 -->
		<plugins>
			<!-- jetty插件 -->
			<plugin>
				<groupId>org.mortbay.jetty</groupId>
				<artifactId>maven-jetty-plugin</artifactId>
				<version>6.1.10</version>
				<configuration>
					<scanIntervalSeconds>1000</scanIntervalSeconds>
				</configuration>
			</plugin>
			<!-- 编码 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<configuration>
					<encoding>UTF-8</encoding>
				</configuration>
			</plugin>
			
			<!--jaxws插件-->
			<plugin>
				  <groupId>org.codehaus.mojo</groupId>
				  <artifactId>jaxws-maven-plugin</artifactId>
				  <version>1.9</version>
				  <configuration>
				  	<wsdlUrls>
						<wsdlUrl>http://localhost:9999/server/jaxws-spring?wsdl</wsdlUrl>
					</wsdlUrls>
				  </configuration>
				  <executions>
				  	<execution>
				  		<phase>compile</phase>
				  		<goals>
				  			<goal>wsimport</goal>
				  		</goals>
				  	</execution>
				  </executions>
			</plugin>
		</plugins>
	</build>
</project>

 

web.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	id="WebApp_ID" version="2.5">
	
	<!-- spring配置文件地址 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:applicationContext.xml</param-value>
	</context-param>
	
	<!-- 初始化beanFactory -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	
	<!-- springMVC -->
	<servlet>
		<servlet-name>srpingMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>srpingMVC</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
	
	
	<!-- 使用spring提供的对jax的支持 -->
	<servlet>
		<servlet-name>StudentWsService-WSSpringServlet</servlet-name>
		<servlet-class>com.sun.xml.ws.transport.http.servlet.WSSpringServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>StudentWsService-WSSpringServlet</servlet-name>
		<url-pattern>/jaxws-spring</url-pattern>
	</servlet-mapping>
	
	
</web-app>

 

srpingMVC-servlet.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    
    <mvc:annotation-driven/>

    <!-- 配置需要被扫描的包 -->
    <context:component-scan base-package="com.hqh"/>

	<!-- 配置对静态资源文件的访问不被过滤 -->
	<mvc:resources location="/resources/" mapping="/resources/**"/>
    
    <!-- 配置返回的数据如何呈现：前缀+逻辑视图+后缀 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    	<property name="prefix" value="/WEB-INF/jsp/"/>
    	<property name="suffix" value=".jsp"/>
    </bean>
    
</beans>

 

applicationContext.xml

 

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	    xmlns:aop="http://www.springframework.org/schema/aop"
	    xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:ws="http://jax-ws.dev.java.net/spring/core"
        xmlns:wss="http://jax-ws.dev.java.net/spring/servlet"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-3.0.xsd  
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
           http://jax-ws.dev.java.net/spring/core http://jax-ws.dev.java.net/spring/core/spring-jax-ws-core.xsd
           http://jax-ws.dev.java.net/spring/servlet http://jax-ws.dev.java.net/spring/servlet/spring-jax-ws-servlet.xsd">
	<context:annotation-config/>
	<context:component-scan base-package="com.hqh.client"/>
	
	<!-- 利用spring完成webservice服务的注入！ -->
	<!-- Accessing web services using JAX-WS -->
	<bean id="wsService" class="org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean">
	    <property name="serviceInterface" value="com.hqh.student.ws.IStudentWSService"/>
	    <property name="wsdlDocumentUrl" value="http://localhost:9999/server/jaxws-spring?wsdl"/>
	    <property name="namespaceUri" value="http://ws.student.hqh.com"/>
	    <property name="serviceName" value="StudentWSService"/>
	    <property name="portName" value="studentServicePort"/>
    </bean>
    
    <!-- 依赖注入 -->
	<bean id="client" class="com.hqh.client.ws.controller.ClientController">
		<property name="studentWsService" ref="wsService"></property>
	</bean>   
    
</beans>

 

Controller

 

package com.hqh.client.ws.controller;


import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

import com.hqh.student.ws.IStudentWSService;
import com.hqh.student.ws.Student;

@Controller
public class ClientController {

	/**
	 * 容器初始化第一次，会调用setters进行注入，但是第2次开始，ClientController变为一个新的对象
	 * 导致studentWsService为NULL，所以，这里使用static来保存第一次初始化好webservice接口的代理对象
	 * 这里是使用配置文件的方式利用spring提供的配置示例进行注入的
	 * 用注解注入又该怎样做呢？
	 */
	private static IStudentWSService studentWsService;
	
	//通过setters方法进行注入！
	public void setStudentWsService(IStudentWSService wsService) {
		studentWsService = wsService;
	}

	@RequestMapping(value="/getStudent",method=RequestMethod.GET)
	public String getStudent() {
		return "index";
	}
	
	@RequestMapping(value="/getStudent",method=RequestMethod.POST)
	public String getStudent(String number,Model model) {
		Student stu = studentWsService.getStudent(number);
		System.out.println(stu);
		if(stu==null) {
			model.addAttribute("error", "不存在！");
		} else {
			model.addAttribute(stu);
		}
		return "index";
	}
	
}

 

 期间遇到2个异常，很是费了点劲儿才解决了！

异常一

java.lang.NoClassDefFoundError: com/sun/istack/XMLStreamReaderToContentHandler
	at com.sun.xml.ws.encoding.StreamSOAPCodec.decode(StreamSOAPCodec.java:227)
	at com.sun.xml.ws.encoding.StreamSOAPCodec.decode(StreamSOAPCodec.java:296)
	at com.sun.xml.ws.encoding.StreamSOAPCodec.decode(StreamSOAPCodec.java:128)
	at com.sun.xml.ws.encoding.SOAPBindingCodec.decode(SOAPBindingCodec.java:287)
	at com.sun.xml.ws.transport.http.client.HttpTransportPipe.process(HttpTransportPipe.java:171)
	at com.sun.xml.ws.transport.http.client.HttpTransportPipe.processRequest(HttpTransportPipe.java:86)
	at com.sun.xml.ws.api.pipe.Fiber.__doRun(Fiber.java:595)
	at com.sun.xml.ws.api.pipe.Fiber._doRun(Fiber.java:554)
	at com.sun.xml.ws.api.pipe.Fiber.doRun(Fiber.java:539)
	at com.sun.xml.ws.api.pipe.Fiber.runSync(Fiber.java:436)
	at com.sun.xml.ws.client.Stub.process(Stub.java:248)

 解决办法：

增加依赖jaxws-rt，这个问题便解决了！

 

异常二

 

java.lang.LinkageError: loader constraint violation: when resolving overridden method "com.sun.xml.ws.message.jaxb.AttachmentMarshallerImpl.addMtomAttachment(Ljavax/activation/DataHandler;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;" the class loader (instance of org/mortbay/jetty/webapp/WebAppClassLoader) of the current class, com/sun/xml/ws/message/jaxb/AttachmentMarshallerImpl, and its superclass loader (instance of <bootloader>), have different Class objects for the type javax/activation/DataHandler used in the signature
	at com.sun.xml.ws.message.jaxb.JAXBMessage.writePayloadTo(JAXBMessage.java:311)
	at com.sun.xml.ws.message.AbstractMessageImpl.writeTo(AbstractMessageImpl.java:142)
	at com.sun.xml.ws.encoding.StreamSOAPCodec.encode(StreamSOAPCodec.java:108)
	at com.sun.xml.ws.encoding.SOAPBindingCodec.encode(SOAPBindingCodec.java:258)
	at com.sun.xml.ws.transport.http.client.HttpTransportPipe.process(HttpTransportPipe.java:142)
	at com.sun.xml.ws.transport.http.client.HttpTransportPipe.processRequest(HttpTransportPipe.java:86)
	at com.sun.xml.ws.api.pipe.Fiber.__doRun(Fiber.java:595)
	at com.sun.xml.ws.api.pipe.Fiber._doRun(Fiber.java:554)
	at com.sun.xml.ws.api.pipe.Fiber.doRun(Fiber.java:539)
	at com.sun.xml.ws.api.pipe.Fiber.runSync(Fiber.java:436)
	at com.sun.xml.ws.client.Stub.process(Stub.java:248)
	at com.sun.xml.ws.client.sei.SEIStub.doProcess(SEIStub.java:135)
	at com.sun.xml.ws.client.sei.SyncMethodHandler.invoke(SyncMethodHandler.java:109)
	at com.sun.xml.ws.client.sei.SyncMethodHandler.invoke(SyncMethodHandler.java:89)
	at com.sun.xml.ws.client.sei.SEIStub.invoke(SEIStub.java:118)

 解决办法：

排除冲突，依赖包与容器中的jar包冲突了，在jaxws-rt和jaxws-spring的依赖中排除掉activation1.1.jar

 

 

 

分享到：
| spring-获取工厂对象
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springCloud

    二：服务介绍： 1） 服务的注册与发现 Spring Cloud是一个基于Spring Boot实现的云应用开发工具，它为基于JVM的云应用开发中涉及的配置管理、服务发现、断路器、智能路由、微代理、控制总线、全局锁、决策竞选、...

    wsdl2java源码-CXFDemo:一个关于CXF实现jax-ws规范的webservice

    是一个开源的一个webservice，可以与spring无缝集成。支持soap1.1、1.2、RESTtful或者CORBA。 ##使用CXF实现jax-ws规范的webservice 服务端： 1、创建java工程，把cxf的jar包导入工程中 2、编写SEI，在SEI上添加@...

    WebSer之CXF框架例子.docx

    Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。...Spring 进行无缝集成。 本资源以项目工程实例为例子，讲解如何使用CXF开发WebService服务。

    CXF WEBSERVICE入门，非常详细实用

    Apache CXF = Celtix + XFire，Apache CXF 的前身叫 Apache CeltiXfire，现在已经正式更名为 Apache CXF 了，以下简称为 CXF。CXF 继承了 Celtix 和 XFire 两大开源项目的精华，提供了对 JAX-...Spring 进行无缝集成。

    apache-cxf-2.2.9-src.zip

    CXF和Spring无缝集成；CXF支持多种传输协议（HTTP， JMS， Corba等）， 支持多种Binding数据格式（SOAP，XML，JSON等）， 支持多种DataBinding数据类型（JAXB， Aegis) 。CXF基于Interceptor的架构，使得整个框架...

    WebService with Apache CXF

    Apache CXF = Celtix + XFire，Apache CXF 的前身叫 Apache CeltiXfire，现在已经正式更名为 Apache CXF 了，以下简称为 CXF。...Spring 进行无缝集成。 想了解新技术的就下下来看看把，应该对你有所帮助。

    cxf-2.7.15源码

    CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者 CORBA ...Spring 进行无缝集成。

    cxf2.5源码

    CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者 CORBA ...Spring 进行无缝集成。

    apache-cxf-3.0.0

    Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者...Spring 进行无缝集成。

    apache-cxf-2.7.11-src.zip

    Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者...Spring 进行无缝集成。

    apache-cxf-2.7.18.tar.gz

    Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者...Spring 进行无缝集成。

    apache-cxf-2.3.0-src

    Apache CXF 是一个开源的 Services 框架，CXF 帮助您利用 Frontend 编程 API 来构建和开发 Services ，像 JAX-WS 。这些 Services 可以支持多种协议，比如：SOAP、XML/HTTP、RESTful HTTP 或者...Spring 进行无缝集成。

Magicbox
Global site tag (gtag.js) - Google Analytics