CXF学习(进阶)

来源：互联网发布：java string replace 编辑：程序博客网时间：2024/06/03 19:05

一、自定义对象传递(简单JavaBean对象)。
第一步：创建传输的JavaBean对象(UserInfo)

[java] view plaincopy

package com.ws.model;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;
@XmlRootElement(name=“UserInfo”)
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(propOrder={“userName”,“userAge”})
public class UserInfo {
private String userName;
private Integer userAge;
public UserInfo(String name,Integer age){
this.userAge = age;
this.userName = name;
}
public UserInfo(){
}
// 添加geter/seter方法..
}

注解：@XmlRootElement-指定XML根元素名称（可选）
          @XmlAccessorType-控制属性或方法序列化，四种方案：
                      FIELD-对每个非静态，非瞬变属性JAXB工具自动绑定成XML，除非注明XmlTransient
                       NONE-不做任何处理
                      PROPERTY-对具有set/get方法的属性进行绑定，除非注明XmlTransient
                       PUBLIC_MEMBER -对有set/get方法的属性或具有共公访问权限的属性进行绑定，除非注明XmlTransient
            @XmlType-映射一个类或一个枚举类型成一个XML Schema类型

第二步：创建webservices服务端接口和实现类
1、创建服务端接口类

[java] view plaincopy

package com.ws.services;
import javax.jws.WebService;
import com.ws.model.UserInfo;
@WebService
public interface IUserServices {
public UserInfo getUserInfo(String userName, Integer userAge);
}

2、创建服务端接口实现类

[java] view plaincopy

package com.ws.services.impl;
import javax.jws.WebService;
import com.ws.model.UserInfo;
import com.ws.services.IUserServices;
@WebService
public class UserServicesImpl implements IUserServices {
public UserInfo getUserInfo(String userName, Integer userAge) {
return new UserInfo(userName,userAge);
}
}

3、创建服务端，并发布服务

[java] view plaincopy

package com.test;
import javax.xml.ws.Endpoint;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
import com.ws.services.impl.UserServicesImpl;
public class ServerTest {
public ServerTest(){
// 发布User服务接口
Endpoint.publish(”http://localhost:8090/userInfoServices”, new UserServicesImpl());
}
public static void main(String[] args) {
// 启动服务
new ServerTest();
System.out.println(”Server ready…”);
try {
Thread.sleep(1000*300);//休眠五分分钟，便于测试
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(”Server exit…”);
System.exit(0);
}
}

第三步：创建webservices客户端，并进行测试(这里只例举在客户端工程中的测试方法)
1、将服务端的JavaBean和Services接口类，copy到客户端工程中，且目录要一致
2、在客户端工程中，新建一个测试类测试

[java] view plaincopy

package com.ws.client;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import com.ws.model.UserInfo;
import com.ws.server.IUserServices;
public class UserTest {
public static void main(String[] args) {
//创建WebService客户端代理工厂
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
//注册WebService接口
factory.setServiceClass(IUserServices.class);
//设置WebService地址
factory.setAddress(”http://localhost:8090/userInfoServices”);
IUserServices userServices = (IUserServices)factory.create();
System.out.println(”invoke userinfo webservice…”);
// 测试返回JavaBean对象的
UserInfo user = userServices.getUserInfo(”vicky”, 23);
System.out.println(”UserName: ”+user.getUserName());
System.out.println(”UserAge : ”+user.getUserAge());
System.exit(0);
}
}

第四步：运行webServices服务，在IE中输入http://localhost:8090/userInfoServices?wsdl，验证服务是否成功发布
第四步：运行客户端，验证。

二、复杂对象传递(List,Map)

前面讲到了JavaBean对象的传递，这一节我们就CXF框架复杂对象(List，Map)的传递进行讲解。
第一步：创建存储复杂对象的类(因为WebServices的复杂对象的传递，一定要借助第三方对象(即自定义对象)来实现)

[java] view plaincopy

package com.ws.model;
import java.util.ArrayList;
import java.util.HashMap;
public class Users {
private ArrayList<UserInfo> userList; // 不要用List类型
private HashMap<Integer, UserInfo> userMap; // 不要用Map类型
private UserInfo[] userArray;
// geter/seter 方法
}

第二步：创建WebServices的服务端接口和实现类

[java] view plaincopy

package com.ws.services;
import javax.jws.WebService;
import com.ws.model.UserInfo;
import com.ws.model.Users;
@WebService
public interface IUserServices {
public Users getAllUsers();
public Users getUsersMap();
public Users getUsersArray();
}

[java] view plaincopy

package com.ws.services.impl;
import java.util.ArrayList;
import java.util.HashMap;
import javax.jws.WebService;
import com.ws.model.UserInfo;
import com.ws.model.Users;
import com.ws.services.IUserServices;
@WebService
public class UserServicesImpl implements IUserServices {
public Users getAllUsers() {
ArrayList<UserInfo> list = new ArrayList<UserInfo>();
list.add(new UserInfo(“vicky”,23));
list.add(new UserInfo(“ivy”,26));
list.add(new UserInfo(“simon”,26));
list.add(new UserInfo(“carol”,29));
Users users = new Users();
users.setUserList(list);
return users;
}
public Users getUsersMap() {
HashMap<Integer, UserInfo> map = new HashMap<Integer, UserInfo>();
map.put(23, new UserInfo(“vicky”,23));
map.put(22, new UserInfo(“caty”,22));
map.put(24, new UserInfo(“leah”,24));
map.put(25, new UserInfo(“kelly”,25));
map.put(27, new UserInfo(“ivy”,27));
map.put(26, new UserInfo(“simon”,26));
map.put(29, new UserInfo(“carol”,29));
Users users = new Users();
users.setUserMap(map);
return users;
}
public Users getUsersArray() {
UserInfo[] userInfo = new UserInfo[5];
for(int i=0;i<5;i++){
UserInfo info = new UserInfo();
info.setUserAge(23+i);
info.setUserName(”Array”+(i+1));
userInfo[i] = info;
}
Users users = new Users();
users.setUserArray(userInfo);
return users;
}
}

第三步：创建WebServices的服务端

[java] view plaincopy

package com.test;
import javax.xml.ws.Endpoint;
import org.apache.cxf.jaxws.JaxWsServerFactoryBean;
import com.ws.services.impl.UserServicesImpl;
public class ServerTest {
public ServerTest(){
// 发布User服务接口
Endpoint.publish(”http://localhost:8090/userInfoServices”, new UserServicesImpl());
}
public static void main(String[] args) {
// 启动服务
new ServerTest();
System.out.println(”Server ready…”);
try {
Thread.sleep(1000*300);//休眠五分分钟，便于测试
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(”Server exit…”);
System.exit(0);
}
}

第四步：创建WebServices的客户端，并测试
1、将服务端创建的复杂对象的类和接口copy到客户工程中，且路径要与服务端一致；
2、新建测试类进行测试

[java] view plaincopy

package com.ws.client;
import java.util.List;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import com.ws.model.UserInfo;
import com.ws.model.Users;
import com.ws.server.IUserServices;
public class UserTest {
public static void main(String[] args) {
//创建WebService客户端代理工厂
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
//注册WebService接口
factory.setServiceClass(IUserServices.class);
//设置WebService地址
factory.setAddress(”http://localhost:8090/userInfoServices”);
IUserServices userServices = (IUserServices)factory.create();
System.out.println(”invoke userinfo webservice…”);
// 测试Map
// testMap(userServices);
// 测试List
// testList(userServices);
// 测试Array
// testArray(userServices);
System.exit(0);
}
public static void testArray(IUserServices userServices){
Users users = userServices.getUsersArray();
if(users!=null){
UserInfo[] array = users.getUserArray();
for(UserInfo info:array){
System.out.println(”UserName: ”+info.getUserName());
System.out.println(”UserAge : ”+info.getUserAge());
}
}
}
public static void testList(IUserServices userServices){
Users users = userServices.getAllUsers();
if(users!=null){
List<UserInfo> list = users.getUserList();
for(UserInfo info:list){
System.out.println(”UserName: ”+info.getUserName());
System.out.println(”UserAge : ”+info.getUserAge());
}
}
}
public static void testMap(IUserServices userServices){
Users users = userServices.getUsersMap();
if(users!=null){
UserInfo info = users.getUserMap().get(23);
System.out.println(”UserName: ”+info.getUserName());
System.out.println(”UserAge : ”+info.getUserAge());
}
}
}

第五步：运行服务端，验证webservices服务是否发布成功
第六步：运行客户端，验证是否成功调用webservices服务

注：在做webServices复杂对象传递时，返回值的类型不要用接口类型。例如(List 应该换成ArrayList ,Map应该换成HashMap)

三、CXF整合Sring框架

通过前面两节的讲解，相信你对CXF框架开始有一些认识了。在当今项目开发中，Spring框架基上都用到过，那么它怎么与CXF结合呢，这就是我们这一间要讲的内容。好了，闲话少说。
    首先，在前面基础上再导入几个spring要用到的几个.jar包：
               1、spring-asm.jar
               2、spring-beans.jar
               3、spring-context.jar
               4、spring-core.jar
               5、spring-expression.jar
               6、spring-aop.jar
               7、spring-web.jar
第一步：新建一个服务端web project,导入要用到的cxf和spring的.jar包，修改web.xml。配置如下

[html] view plaincopy

<?xml version=“1.0” encoding=“UTF-8”?>
<web-app version=“2.4”
xmlns=“http://java.sun.com/xml/ns/j2ee”
xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd”>
<!– Spring 容器加载的配置文件设置 –>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
classpath:/applicationContext-server.xml
</param-value>
</context-param>
<!– Spring 配置 –>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
</listener>
<!– WebServices设置 –>
<servlet>
<servlet-name>CXFServices</servlet-name>
<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>CXFServices</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

第二步：新建一个接口类和接口实现类

[java] view plaincopy

package com.ms.services;
import java.util.List;
import javax.jws.WebService;
import com.ms.model.UserInfo;
@WebService
public interface IHelloServices {
public String sayHello(String name);
public String sayHelloToAll(List<UserInfo> users);
}

[java] view plaincopy

package com.ms.services.impl;
import java.util.List;
import javax.jws.WebService;
import com.ms.model.UserInfo;
import com.ms.services.IHelloServices;
@WebService(endpointInterface=“com.ms.services.IHelloServices”)
public class HelloServicesImpl implements IHelloServices {
public String sayHello(String name) {
return “Hello ”+name+“ .”;
}
public String sayHelloToAll(List<UserInfo> users) {
String hello = ”hello ”;
for(UserInfo user:users){
hello += user.getUserName()+” ,”;
}
hello += ” ,everybody.”;
return hello;
}
}

第三步：新建一个spring Bean的xml文件，配置CXF webservices的服务

[html] view plaincopy

<?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-3.0.xsd
http://cxf.apache.org/jaxws
http://cxf.apache.org/schemas/jaxws.xsd”>
<!– Import apache CXF bean definition 固定–>
<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” />
<!– services接口配置 –>
<bean id=“helloServicesBean” class=“com.ms.services.impl.HelloServicesImpl” />
<!– CXF 配置WebServices的服务名及访问地址 –>
<jaxws:server id=“helloServices” address=“/HelloServices”
serviceClass=“com.ms.services.IHelloServices”>
<jaxws:serviceBean>
<ref bean=“helloServicesBean”/>
</jaxws:serviceBean>
</jaxws:server>
</beans>

第四步：将工程部署到Tomcat中运行，在IE中输入”http://localhost:8090/CxfServer_Spring/services”,测试服务是否发布成功
第五步：新建一个客户端web project,导入要用到的cxf和spring的.jar包
第六步：将服务端的接口类及JavaBean对象类copy到客户端工程中，且路径要与服务端路径一致
第七步：新建一个spring Bean的xml配置文件，配置CXF webservices的客户端

[html] view plaincopy

<?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-3.0.xsd
http://cxf.apache.org/jaxws
http://cxf.apache.org/schemas/jaxws.xsd”>
<!– Import apache CXF bean definition –>
<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” />
<!– CXF webservices 客户端配置 –>
<jaxws:client id=“helloClient” serviceClass=“com.ms.services.IHelloServices”
address=“http://localhost:8090/CxfServer_Spring/services/HelloServices”>
</jaxws:client>
</beans>

第八步：新建一个测试类进行测试，代码如下

[java] view plaincopy

package com.test;
import java.util.ArrayList;
import java.util.List;
import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.ms.model.UserInfo;
import com.ms.services.IHelloServices;
public class Client {
public static void main(String[] args) {
invokeBySpring();
}
/**
* 通过Spring测试webservices
*/
public static void invokeBySpring(){
ApplicationContext context = new ClassPathXmlApplicationContext(“applicationContext-client.xml”);
IHelloServices helloServices = context.getBean(”helloClient”,IHelloServices.class);
List<UserInfo> users = new ArrayList<UserInfo>();
users.add(new UserInfo(“vicky”,23));
users.add(new UserInfo(“caty”,23));
users.add(new UserInfo(“ivy”,23));
users.add(new UserInfo(“kelly”,23));
String helloAll = helloServices.sayHelloToAll(users);
System.out.println(helloAll);
}
public static void invoke(){
//创建WebService客户端代理工厂
JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
//注册WebService接口
factory.setServiceClass(IHelloServices.class);
//设置WebService地址
factory.setAddress(”http://localhost:8090/CxfServer_Spring/services/HelloServices”);
IHelloServices helloServices = (IHelloServices)factory.create();
System.out.println(”invoke helloServices webservice…”);
String hello = helloServices.sayHello(”vicky”);
System.out.println(hello);
}
}

0 0