JAVA webservice之CXF

时间  2019-12-04
标签 java webservice cxf 栏目 Java 繁體版
原文   原文链接

昨天咱们一块儿学习了一下xfire，今天咱们来看一下CXF，为何学完那个接着学这个呢。由于CXF是在xfire的基础上实现html

的，因此咱们学习它会比较简单点，毕竟咱们昨天刚看过了xfire的实现方法。废话少说，直接来例子。java

1）首先呢，仍是包的问题，在http://cxf.apache.org/download.html这里能够下到最新版的CXF，固然，我用的是最新版的。接下来仍是那句废话，建WEB项目，放入JAR包。而JAR包咱们就不选择了，一堆所有放入。web

咱们会看到它包含了spring的JAR包，后面当咱们须要把CXF做为WEB项目部署时，就须要用到spring的配置文件，这个后面再讲。spring

仍是接口类和实现类：apache

Java代码 复制代码 收藏代码编程

  1. @WebService   浏览器

  2. public interface IReaderService {  tomcat

  3.     public Reader getReader(@WebParam(name="name") String name,@WebParam(name="password") String password);  服务器

  4.     public List<Reader> getReaders();  app

  5. }  

@WebService
public interface IReaderService {
	public Reader getReader(@WebParam(name="name") String name,@WebParam(name="password") String password);
	public List<Reader> getReaders();
}

Java代码 复制代码 收藏代码

  1. @WebService (endpointInterface="com.cxf.servlet.IReaderService",serviceName="readerService")  

  2. public class ReaderService implements IReaderService{  

  3.     public Reader getReader(@WebParam(name="name") String name,@WebParam(name="password") String password) {  

  4.         return new Reader(name,password);  

  5.     }  

  6.       

  7.     public List<Reader> getReaders(){  

  8.         List<Reader> readerList = new ArrayList<Reader>();  

  9.         readerList.add(new Reader("shun1","123"));  

  10.         readerList.add(new Reader("shun2","123"));  

  11.         return readerList;  

  12.     }  

  13. }  

@WebService(endpointInterface="com.cxf.servlet.IReaderService",serviceName="readerService")
public class ReaderService implements IReaderService{
	public Reader getReader(@WebParam(name="name") String name,@WebParam(name="password") String password) {
		return new Reader(name,password);
	}
	
	public List<Reader> getReaders(){
		List<Reader> readerList = new ArrayList<Reader>();
		readerList.add(new Reader("shun1","123"));
		readerList.add(new Reader("shun2","123"));
		return readerList;
	}
}

 这两个类除了加入注解外，其余均和昨天讲的webservice的同样。这里就很少讲了，对注解的解释，你们能够看看JAVAEE的文档。不过按意思应该很容易理解的。

接下来就是JAVABEAN，仍是那个Reader类：

Java代码 复制代码 收藏代码

  1. public class Reader{  

  2.     private static final long serialVersionUID = 1L;  

  3.     private String name;  

  4.     private String password;  

  5.       

  6.     public Reader(){}  

  7.     public Reader(String name,String password) {  

  8.         this.name = name;  

  9.         this.password = password;  

  10.     }  

  11.     //Get/Set方法省略  

  12.     public String toString(){  

  13.         return "Name:"+name+",Password:"+password;  

  14.     }  

  15.       

  16. }  

public class Reader{
	private static final long serialVersionUID = 1L;
	private String name;
	private String password;
	
	public Reader(){}
	public Reader(String name,String password) {
		this.name = name;
		this.password = password;
	}
	//Get/Set方法省略
	public String toString(){
		return "Name:"+name+",Password:"+password;
	}
	
}

 上面的已经写完了。

2）咱们要用作WEB项目吗？不急，先不用，CXF自带了一个轻量的容器服务，至关于spring本身提供了IOC容器同样。咱们能够先用它来测试一下咱们部署成功没。

直接来一个测试类：

Java代码 复制代码 收藏代码

  1. public static void main(String[] args) {  

  2.         System.out.println("Server is starting...");  

  3.         ReaderService readerService = new ReaderService();  

  4.         Endpoint.publish("http://localhost:8080/readerService",readerService);  

  5.         System.out.println("Server is started...");  

  6.     }  

public static void main(String[] args) {
		System.out.println("Server is starting...");
		ReaderService readerService = new ReaderService();
		Endpoint.publish("http://localhost:8080/readerService",readerService);
		System.out.println("Server is started...");
	}

 简单得不得了吧。直接publish地址，而后指定接口或类就OK了。我这里用的是类，但尽可能用接口，毕竟面向接口编程才是真正的面对对象思想。

咱们启动看看结果：

 咱们看到启动已经完成，接着启动浏览器看看是否成功了。

直接在浏览器输入http://localhost:8080/readerService?wsdl，咱们能够看到：

 它生成了咱们所须要的wsdl文件，说明咱们部署成功了。

3）部署成功后，咱们就是要调用啦，它的调用也至关简单，跟xfire相似，取得接口，而后就能够跟本地类同样调用方法了。

Java代码 复制代码 收藏代码

  1. public static void main(String[] args) {  

  2.         JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();  

  3.         factoryBean.setServiceClass(IReaderService.class);  

  4.         factoryBean.setAddress("http://localhost:8080/readerService");  

  5.           

  6.         IReaderService readerService = (IReaderService)factoryBean.create();  

  7.         Reader reader = readerService.getReader("shun","123");  

  8.         System.out.println("Reader:"+reader);  

  9.     }  

public static void main(String[] args) {
		JaxWsProxyFactoryBean factoryBean = new JaxWsProxyFactoryBean();
		factoryBean.setServiceClass(IReaderService.class);
		factoryBean.setAddress("http://localhost:8080/readerService");
		
		IReaderService readerService = (IReaderService)factoryBean.create();
		Reader reader = readerService.getReader("shun","123");
		System.out.println("Reader:"+reader);
	}

 这里很简单，也是取得一个工厂类，而后直接设接口和地址再create就能够得取相应的接口了，这里跟xfire同样，也是须要调用端先定义好接口原型，不然这些调用将无从提及。

咱们运行获得结果：

 没问题，跟咱们预想的结果一致。

 

4）但不少状况下，咱们并不但愿咱们的webservice和咱们的应用分开两个服务器，而但愿他们在同一个容器，tomcat或JBOSS或其余的，这样咱们就必须经过WEB来部署咱们前面完成的webservice。

注意，咱们这里须要用到spring定义文件。

首先看看web.xml:

Java代码 复制代码 收藏代码

  1. <?xml version="1.0" encoding="UTF-8"?>  

  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

  3.     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"  

  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"  

  5.     id="WebApp_ID" version="3.0">  

  6.       

  7.     <context-param>  

  8.         <param-name>contextConfigLocation</param-name>  

  9.         <param-value>WEB-INF/beans.xml</param-value>  

  10.     </context-param>  

  11.       

  12.     <listener>  

  13.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  

  14.     </listener>  

  15.       

  16.     <servlet>  

  17.         <servlet-name>CXFServlet</servlet-name>  

  18.         <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>  

  19.     </servlet>  

  20.     <servlet-mapping>  

  21.         <servlet-name>CXFServlet</servlet-name>  

  22.         <url-pattern>/webservice/*</url-pattern>  

  23.     </servlet-mapping>  

  24. </web-app>  

<?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_3_0.xsd"
	id="WebApp_ID" version="3.0">
	
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>WEB-INF/beans.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>
	</servlet>
	<servlet-mapping>
		<servlet-name>CXFServlet</servlet-name>
		<url-pattern>/webservice/*</url-pattern>
	</servlet-mapping>
</web-app>

 这里很简单，只是指定了spring的监听器和相应的配置文件路径，而且指定了CXF的拦截方式。

接下来看看beans.xml:

Java代码 复制代码 收藏代码

  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"  

  4.     xmlns:jaxws="http://cxf.apache.org/jaxws"  

  5.     xsi:schemaLocation="  

  6.         http://www.springframework.org/schema/beans  

  7.         http://www.springframework.org/schema/beans/spring-beans.xsd  

  8.         http://cxf.apache.org/jaxws  

  9.         http://cxf.apache.org/schemas/jaxws.xsd">  

  10.     <import resource="classpath:META-INF/cxf/cxf.xml" />  

  11.     <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  

  12.     <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  

  13.       

  14.     <jaxws:endpoint id="readerServicce2"  

  15.         implementor="com.cxf.servlet.ReaderService" address="/readerService2" />  

  16. </beans>  

<?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: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-extension-soap.xml" />
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />
    
    <jaxws:endpoint id="readerServicce2"
        implementor="com.cxf.servlet.ReaderService" address="/readerService2" />
</beans>

 这里很简单，只是经过jaxws:endpoint定义了一个webservice，implementor是webservice的处理类，而address是它的访问路径，跟咱们前面写的readerService相似。

这时咱们能够把它部署到tomcat中，经过http://localhost:8080/CXFWebservice/webservice/readerService2?wsdl能够直接访问。

 

有些朋友会问，为何此次访问的URL跟前面的不同呢。其实前面的访问地址是咱们本身定义的，而这里的webservice地址是咱们在配置文件中配置好的，而且是经过web项目来部署的，这里就须要用项目名称，并且咱们在CXFServlet那里配置了url-pattern是webservice，因此最后的URL就跟上面一致了。

咱们能够看到效果：

 这证实咱们部署成功了。

 

能够再次用前面的测试类测试一下，注意，须要把address修改为咱们发布后的URL。

CXF相比xfire又更简洁了一些，虽然它增长了一些注解，但这些无伤大雅，它只是把之前的services.xml中的信息集中到类中，反而更方便维护，但这仍是见仁见智的，有些人就喜欢配置文件，而有些人就不喜欢。另外CXF的调用方式更加简洁，比起xfire它的代码量更小了，是一个较大的进步。

 

有些朋友在搭建的过程当中出现了一些问题，免去一个个回复了，这里放出代码，有须要的朋友能够下载看看。

lib目录下的全部包均没有放入，把cxf的全部包放入便可。

注：所用IDE为idea，文件结构跟eclipse不通用，若是须要在eclipse下使用的，能够直接复制代码和文件到eclipse新建的项目便可。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程