`
schy_hqh
  • 浏览: 555824 次
  • 性别: 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-获取工厂对象
评论
发表评论

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

相关推荐

    web service cxf 2.7.5 与spring 3.0 集成

    在本篇中，我们将深入探讨如何将Apache CXF 2.7.5版本与Spring 3.0框架集成，以便在Java应用程序中创建和消费Web服务。 **一、CXF简介** Apache CXF是一个全面的Web服务框架，它支持多种协议，如SOAP、RESTful HTTP...

    maven(jersey+redis+mongodb+spring)集成

    "maven(jersey+redis+mongodb+spring)集成"指的是使用Maven作为项目构建工具，将Jersey用于RESTful API开发，Redis作为缓存系统，MongoDB作为NoSQL数据库，以及Spring框架作为应用核心，进行无缝集成的开发模式。...

    webService（CXF）与spring集成

    它提供了丰富的功能，包括SOAP、RESTful API支持，并且能够与Spring框架无缝集成。这篇博客文章将深入探讨如何将CXF与Spring结合使用，以实现高效、可扩展的Web服务解决方案。 首先，让我们理解CXF的核心功能。CXF...

    spring集成cxf（webservice）

    - **工具支持**：CXF提供了一系列工具，支持JavaBean、Web服务与WSDL之间的转换，并且与Maven、Ant和Spring等工具无缝集成。 - **RESTful服务支持**：除了传统的SOAP服务外，CXF还支持RESTful服务，并且内置了JAX-RS...

    Spring2.0和XFire1.2.6整合案例

    XFire支持多种协议，如HTTP、JMS，并且可以无缝地与Spring框架集成，利用Spring的依赖注入特性，使Web服务的实现更加简单。 Spring与XFire的整合主要涉及以下几个关键步骤： 1. **添加依赖**：首先，你需要在项目...

    CXF开发webService所需jar包(和spring集成)

    5. **Spring Integration**：CXF可以无缝集成Spring框架，通过Spring配置文件来定义服务、端点和数据绑定。这样可以利用Spring的依赖注入（DI）和管理功能。 在提供的"cxf所需jar包"压缩文件中，我们可以找到以下...

    resteasy-jaxrs-2.3.6.Final-all

    2. **与Spring集成**：Resteasy可以无缝集成到Spring框架中，这使得开发者可以利用Spring的依赖注入和管理功能，进一步简化服务的构建。通过这种方式，可以轻松地在REST服务中使用其他Spring组件和服务。 3. **...

    jersey+spring

    本文将深入探讨jersey与spring的集成，以及如何在实际项目中应用这些技术。 一、jersey简介 jersey是基于JAX-RS标准的RESTful服务实现，它提供了一套全面的工具集来创建和部署RESTful服务。通过jersey，开发者可以...

    cxf+spring所需的jar包

    同时，Spring的事务管理可以与CXF服务无缝集成，确保服务操作的事务一致性。 4. jar包解析： 压缩包中的jar文件可能包括了CXF的核心库、Spring框架的核心库、以及它们之间的适配器和依赖。例如： - CXF的相关jar...

    webservice + spring

    3. Spring Boot与Apache CXF：Apache CXF是另一个流行的WebService实现，它可以与Spring Boot无缝集成。通过Spring Boot的自动配置功能，我们可以快速搭建一个基于CXF的WebService服务器，并且可以方便地使用Spring...

    Spring_WebService源码

    其契约优先的开发模式，使得服务的定义和实现更加清晰，同时与Spring框架的无缝集成，让整个开发过程更加高效。通过学习和掌握Spring WebService，开发者可以轻松地在分布式系统中构建可靠且可扩展的Web服务。

    Spring+cxf配置接口+mybatis配置

    综上所述，"Spring+cxf配置接口+mybatis配置"这个项目可能是在构建一个集成了后端服务、Web服务接口和数据库操作的企业级应用。开发者需要理解这三个框架的基本原理和配置方式，才能有效地整合它们，实现高效、稳定...

    CXF整合spring实现SOAP接口开发

    Spring框架还能与其他组件如MyBatis、Hibernate等无缝集成，构建出可扩展且易于维护的应用。 3. **CXF与Spring整合的优势**： - 简化配置：Spring的XML配置可以用来管理CXF的bean，减少手动配置工作。 - 容器管理...

    cxf整合springjar包下载

    CXF的一个重要特性是其能够无缝地将Web服务功能与企业级Java应用（如EJB）结合，同时也支持多种编程模型，包括JAX-WS和JAX-RS。 Spring框架是Java开发的基石，尤其在企业级应用中广泛应用。它提供了依赖注入（DI）...

    spring+webservice

    CXF可以与Spring无缝集成，允许开发者利用Spring的配置和依赖注入特性来管理Web服务。通过Spring，你可以方便地在Spring应用上下文中声明CXF的服务和客户端，使得服务的部署和测试更加简单。 在"day02_ws_cxf_...

    webservice-cxf-spring-jar.zip

    Spring可以和CXF无缝集成，帮助开发者管理Web服务的生命周期，如bean的创建、配置和服务的发布。 3. **CXF与Spring的集成**：在Spring环境中，CXF可以通过Spring的Bean定义来配置，这简化了服务端点的创建和管理。...

    基于springmvc、spring、mybatis的web框架

    Spring还包含了其他模块，如Spring JDBC、Spring ORM（与MyBatis集成），用于数据库操作，以及Spring Security和Spring Session，分别处理权限控制和会话管理。 **MyBatis** 是一个轻量级的持久层框架，它允许...

    WebService整合spring

    Apache CXF是目前最常用的，它不仅支持SOAP协议，还支持RESTful风格的服务，同时与Spring无缝集成，使得配置和服务的创建变得更加简单。 **2. Apache CXF简介** Apache CXF是一个开源的Web服务框架，它允许开发者...

    springCloud

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

    cxf_spring 相关jar包(2)

    同时，Spring的事务管理功能也可以无缝集成到CXF服务中，提供统一的事务策略。 博客链接 "https://huangjiateng.iteye.com/blog/2195588" 可能提供了更详细的使用示例和配置指南，对于理解如何在实际项目中集成和...

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