最近在使用cxf时发现,
本文主要参考cxf使用手册
http://cxf.apache.org/docs/writing-a-service-with-spring.html
- Set up your build for CXF
- Writing a simple JAX-WS service
- Set up the HTTP transport
第一步:设置你的cxf的classpath
1、依赖库
commons-logging-1.1.1.jar
geronimo-activation_1.1_spec-1.0-M1.jar (or Sun's Activation jar)
geronimo-annotation_1.0_spec-1.1.jar (JSR 250)
geronimo-javamail_1.4_spec-1.7.1.jar (or Sun's JavaMail jar)
geronimo-servlet_3.0_spec-1.0.jar (or Sun's Servlet jar)
geronimo-ws-metadata_2.0_spec-1.1.1.jar (JSR 181)
jaxb-api-2.1.jar
jaxb-impl-2.1.13.jar
jaxws-api-2.1.jar
neethi-3.0.0.jar
saaj-api-1.3.jar
saaj-impl-1.3.jar
stax-api-1.0.1.jar
stax2-api-3.1.1.jar
wsdl4j-1.6.2.jar
woodstox-core-asl-4.0.8.jar
xmlschema-core-2.0.jar
xml-resolver-1.2.jar
2、The Spring jars:
aopalliance-1.0.jar
spring-core-3.0.5.RELEASE.jar
spring-beans-3.0.5.RELEASE.jar
spring-context-3.0.5.RELEASE.jar
spring-web-3.0.5.RELEASE.jar
3、And the CXF jar:
cxf-2.4.0.jar
第二步 编写你的service
1、代码编写
接口:
package demo.spring.service;
import javax.jws.WebService;
@WebService
public interface HelloWorld {
String sayHi(String text);
}
接口实现:
package demo.spring.service;
import javax.jws.WebService;
@WebService(endpointInterface = "demo.spring.service.HelloWorld")
public class HelloWorldImpl implements HelloWorld {
public String sayHi(String text) {
System.out.println("sayHi called");
return "Hello " + text;
}
}
2、spring文件配置
Lets create a "cxf-servlet.xml" file in our WEB-INF
directory which declares an endpoint bean。cxf-servlet.xml默认在WEB-INF directory但是可以在web.xml里面指定地址。
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<import resource="classpath:META-INF/cxf/cxf.xml" />
<import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
<jaxws:endpoint
id="helloWorld"
implementor="demo.spring.service.HelloWorldImpl"
address="/HelloWorld" />
</beans>
另外的配置方式
If you want to reference a spring managed-bean, you can write like this:
<bean id="hello" class="demo.spring.HelloWorldImpl" />
<jaxws:endpoint id="helloWorld" implementor="#hello" address="/HelloWorld" />
The bean
uses the following properties:
- id specifies the id of
the bean in the Spring context.
- implementor specifies
the implementation class.
- address specifies the
location the service will be hosted. This should just be a related path.
This is because CXF can't know the war name and the servlet container's
listening port, CXF will update the endpoint address with the request url
at the runtime.
To provide a
bean name instead of a classname as an implementor, simply supply the bean-name
prepended with "#", e.g. implementor="#myBean".
You
can also do more sophisticated things with
the <jaxws:endpoint> element like add nested tags to attach
JAX-WS Handlers or CXF Interceptors to the service. For more on this see JAX-WS
Configuration.
第三步设置cxf的servlet
Since
we're relying on the default "cxf-servlet.xml" file the default
web.xml referenced by many samples can be
used.
Alternatively,
for arbitrarily named configuration files such as beans.xml,
application-context.xml, etc. we can add the following elements:
- the
Spring ContextLoaderLister. This starts Spring and explicitly loads
the configuration file. We can specify where our file is via
a context-param element.
An example:
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:applicationContext.xml
</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>CXFServlet</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
It is
important to note that the address that you chose for your endpoint bean must
be one your servlet listens on. For instance, if my Servlet was register for
"/some-services/*" but my address was
"/more-services/HelloWorld", there is no way CXF could receive a
request.
Create a Client (Easy Way)
Just like
the <jaxws:endpoint> used on the server side, there is
a <jaxws:client> that can be used on the client side. You'll
give it a bean name, the service interface, and the service URL, and it will
create a bean with the specified name, implementing the service interface, and
invoking the remote SOAP service under the covers:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">
<jaxws:client id="helloClient"
serviceClass="demo.spring.HelloWorld"
address="http://localhost:9002/HelloWorld" />
</beans>
You can now
inject that "helloClient" bean into any other Spring bean, or look it
up from the Spring application context manually with code like this:
ApplicationContext context = ...; // your Spring ApplicationContext
HellWorld client = (HelloWorld) context.getBean("helloClient");
You
can also do more sophisticated things with
the <jaxws:client> element like add nested tags to attach
JAX-WS Handlers or CXF Interceptors to the client. For more on this see JAX-WS
Configuration.
Create a Client (More Manual Way)
CXF includes
a JaxWsProxyFactory bean which create a client for you from your service
interface. You simply need to tell it what your service class is (the
HelloWorld interface in this case) and the URL of your service. You can then
create a client bean via the JaxWsProxyFactory bean by calling it's create()
method.
Here's an
example:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws http://cxf.apache.org/schema/jaxws.xsd">
<bean id="client" class="demo.spring.service.HelloWorld"
factory-bean="clientFactory" factory-method="create"/>
<bean id="clientFactory" class="org.apache.cxf.jaxws.JaxWsProxyFactoryBean">
<property name="serviceClass" value="demo.spring.service.HelloWorld"/>
<property name="address" value="http://localhost:9002/services/HelloWorld"/>
</bean>
</beans>
If you were
going to access your client you could now simply pull it out of the Spring
context (or better yet, inject it into your application using Spring!):
ApplicationContext context = ...; // your Spring ApplicationContext
HelloWorld client = (HelloWorld) context.getBean("client");
client
code at http://svn.apache.org/repos/asf/cxf/trunk/distribution/src/main/release/samples/java_first_spring_support/src/main/java/demo/spring/client/Client.java
分享到:
相关推荐
CXF+spring+struts实现WebService
CXF2+Spring2.5开发WebService实例,需要导入jar包
CXF Restful + Spring3 + Mybatis 后台开发环境搭建
cxf+spring+client+springmvc
简单的webservice+Cxf+Spring数据对接实例以及jar.rar简单的webservice+Cxf+Spring数据对接实例以及jar.rar简单的webservice+Cxf+Spring数据对接实例以及jar.rar简单的webservice+Cxf+Spring数据对接实例以及jar.rar...
cxfserver+spring+mybatis
cxf3 + spring4,使用配置的方式发布webservice
web项目使用spring和cxf的一个开发实例,有简单的代码样例和jar。是一个完整的项目,最终发布完成时访问 http://ip:port/项目名称/webservices/ 就会发现你发布的webservice服务。
CXF2.6.4+Spring3.1.1+Jetty7.5.4三个开源框架整全发布webservice,方便快捷,再使用前请阅读项目包中log.log文件,方便你快速建立程序。
CXF2.6+SPRING3.0+STRUTS2.3整合的一个例子,含Jar包.
利用CXF3.0.2+Spring3.2.14发布WSSecurity!需要源代码可以下载!
cxf+spring实现webservice
利用CXF3.0.2+Spring3.2.14发布RESTFul,有源代码可以下载!
利用CXF3.0.2+Spring3.2.14传输文件,里面有笔者在练习过程中遇到的错误,还有源代码可以下载!
利用CXF3.0.2+Spring3.2.14发布RESTFul,传递json数据格式的!需要源代码可以下载!
利用CXF3.0+Spring3.2 HelloWorld实例,并且导入了小量的jar包以及在写例子的过程中遇见的一些错误!
Apache CXF2+Spring2.5轻松实现WebService
cxf+spring+tomat开发webservice所需jar包,该jar包只需解压后导入web工程即可,亲测有用
cxf+spring+tomcat 只是演示,一个helloWorld的例子