CXF-05：使用CXF处理返回值的类型为Map、非JavaBean式的复合类

忘是亡心i 2022-07-16 10:37 149阅读 0赞

\* 当形参、返回值的类型是String、基本数据类型时，CXF可以处理；

**\*** 当形参、返回值的类型是JavaBean式的复合类、List集合、数组等时，CXF可以处理；  
         \* **还有一些像 Map、非JavaBean式的复合类，CXF不可以处理；**

**         ****处理思路：提供一个转换器，该转换器负责把CXF不能处理的类型，转换为CXF可以处理的类型**

**         Web Service未加转换器目录图：**

![20161015105413198][]

\* 从头写起，代码不受前面文章的影响（ jar 包地址 http://pan.baidu.com/s/1jHJ56BW    （Apache官网上也可以下载））

**（一）编写一个返回 Map 的程序，暴露 CXF服务端 时报错**

**\* 1 . 编写要暴露的功能 HelloWorld.java 接口代码，没有相应的实体类编写 User.java 与 Food.java 代码，编写该接口的实现类代码 HelloWorldWs.java**

import java.util.List;
    import java.util.Map;
    import javax.jws.WebService;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.model.User;
    @WebService//J2EE文档里查看WebService
    public interface HelloWorld {
    	//还有一些像 Map、非JavaBean式的复合类，CXF不可以处理；
    	Map<String, Food> getAllFoods();
    }

public class Food {
    	private Integer id;
    	private String name;
    	private String describe;
    	public Food() {
    		super();
    	}
    	public Food(Integer id, String name, String describe) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.describe = describe;
    	}
    	public Integer getId() {
    		return id;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getDescribe() {
    		return describe;
    	}
    	public void setDescribe(String describe) {
    		this.describe = describe;
    	}
    }

public class User {
    	private Integer id;
    	private String name;
    	private String tel;
    	private String describe;
    	public Integer getId() {
    		return id;
    	}
    	public User() {
    		super();
    	}
    	public User(Integer id, String name, String tel, String describe) {
    		super();
    		this.id = id;
    		this.name = name;
    		this.tel = tel;
    		this.describe = describe;
    	}
    	public void setId(Integer id) {
    		this.id = id;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getTel() {
    		return tel;
    	}
    	public void setTel(String tel) {
    		this.tel = tel;
    	}
    	public String getDescribe() {
    		return describe;
    	}
    	public void setDescribe(String describe) {
    		this.describe = describe;
    	}
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((describe == null) ? 0 : describe.hashCode());
    		result = prime * result + ((name == null) ? 0 : name.hashCode());
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		User other = (User) obj;
    		if (describe == null) {
    			if (other.describe != null)
    				return false;
    		} else if (!describe.equals(other.describe))
    			return false;
    		if (name == null) {
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		return true;
    	}
    }

import java.util.Date;
    import java.util.List;
    import java.util.Map;
    import javax.jws.WebService;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.model.User;
    import org.fjava.cxf.ws.HelloWorld;
    import org.fjava.cxf.service.UserService;
    import org.fjava.cxf.service.UserServiceImpl;
    @WebService(endpointInterface="org.fjava.cxf.ws.HelloWorld", serviceName="HelloWorldWs")  
    //endpointInterface=""表示实现的接口  serviceName是wsdl2java或其他语言后的文件名，可以不和HelloWorldWs相同
    public class HelloWorldWs implements HelloWorld {
    	@Override
    	public Map<String, Food> getAllFoods() {
    		UserService userService = new UserServiceImpl();
    		return userService.getAllFoods();
    	}
    }

** \* 2 . 编写功能实现逻辑代码 UserService.java UserServiceImp.java**

import java.util.List;
    import java.util.Map;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.model.User;
    public interface UserService {
    	List<Food> getFoodsByUser(User user);
    	Map<String, Food> getAllFoods();
    }

import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.model.User;
    public class UserServiceImpl implements UserService {
    	//为简单，不写Dao层，用一个HashMap来模拟内存中的数据库
    	static Map<User, List<Food>> foodDb = new HashMap<>();
    	static{
    		List<Food> catList1 = new ArrayList<Food>();
    		catList1.add(new Food(1 , "一个汉堡" , "是三层的，有夹层哦！"));
    		catList1.add(new Food(2 , "火腿肠" , "这是章鱼哥从岸上偷运来的，据说很美味！"));
    		foodDb.put(new User(1 , "海绵宝宝" , "123123123" , "开心的海绵宝宝！") , catList1);
    		List<Food> catList2 = new ArrayList<Food>();
    		catList2.add(new Food(3 , "蟹王汉堡" , "橙色，亮金色，我的宝贝，我的爱！"));
    		catList2.add(new Food(4 , "海绵金币" , "吃着金币样的甜甜饼，想着海绵宝宝赚的钱被扣了，哈哈哈，爽气！"));
    		foodDb.put(new User(2 , "蟹老板" , "321321321" , "哇！好有钱的蟹老板") , catList2);
    	}
    	@Override
    	public List<Food> getFoodsByUser(User user) {
    		return foodDb.get(user);
    	}
    	@Override
    	public Map<String, Food> getAllFoods() {
    		Map<String, Food> map = new HashMap<String, Food>();
    		for (List<Food> foods : foodDb.values()) {
    			for (Food food : foods) {
    				map.put(food.getName(), food);
    			}
    		}
    		return map;
    	}
    }

**\* 3 . 编写 Main方法 ServiceMainTest.java 与 CXF服务端暴露Main方法 ServiceMain.java**

import java.util.Map;
    import javax.xml.ws.Endpoint;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.ws.HelloWorld;
    import org.fjava.cxf.ws.impl.HelloWorldWs;
    //测试写的程序没有问题
    public class ServiceMainTest {
    	public static void main(String[] args){
    		HelloWorld helloWorld = new HelloWorldWs();
    		Map<String, Food> allFoods = helloWorld.getAllFoods();
    		System.out.println(allFoods);
    	}
    }

**         运行结果：编写的程序运行成功**

**\{蟹王汉堡=org.fjava.cxf.model.Food@356f5b17, 海绵金币=org.fjava.cxf.model.Food@21c55e69, 一个汉堡=org.fjava.cxf.model.Food@24b950d1, 火腿肠=org.fjava.cxf.model.Food@268dc2d\}**

import javax.xml.ws.Endpoint;
    import org.fjava.cxf.ws.HelloWorld;
    import org.fjava.cxf.ws.impl.HelloWorldWs;
    //发布Web Service
    public class ServiceMain {
    	public static void main(String[] args){
    		HelloWorld hw = new HelloWorldWs();
    		//调用Endpoint的publish("本机地址","服务的提供者：一个Web Service对象")方法发布Web Service
    		//如何设置cxf的服务端端口号：这是公司规定或个人设置，不可重复
    		Endpoint.publish("http://192.168.0.159:6786/sayHello", hw);
    		System.out.println("Web Service暴露成功！");
    		//暴露成功后可以被任何平台的任何语言调用
    		//检查调用地址http://192.168.*.*/sayHello?wsdl
    	}
    }

**         运行结果：暴露该接口 - 编写的程序运行失败，证明当返回值的类型是Map集合时，CXF不可以处理**

**（二）在CXF开发中，如果遇到系统无法自动处理的类型，就需要程序员自行处理。**

**处理思路：提供一个转换器，该转换器负责把CXF不能处理的类型，转换为CXF可以处理的类型**

**         Web Service加转换器后目录图：**

**         ![20161015180239304][]**

**         \* 1 . 使用 @XmlJavaTypeAdapter 修饰CXF无法处理的类型**

**使用该Annotation时，通过value属性指定一个转换器，这个转换器是XMLAdapter的子类（XmlJavaTypeAdapter在 Java EE 帮助文档里查看）**

**         \* 操作为 HelloWorld.java 接口中加标签**

import java.util.List;
    import java.util.Map;
    import javax.jws.WebService;
    import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.model.User;
    import org.fjava.cxf.ws.util.HelloXmlAdepter;
    @WebService//J2EE文档里查看WebService
    public interface HelloWorld {
    	//还有一些像 Map、非JavaBean式的复合类，CXF不可以处理；
    	//CXF不能处理Map<String, Food>类型，我们采用HelloXmlAdepter进行处理
    	@XmlJavaTypeAdapter(value = HelloXmlAdepter.class) Map<String, Food> getAllFoods();
    }

**         \* 2 . 实现自己的转换器  
实现转换器时，需要开发一个CXF能处理的类型，操作为新建转换器 HelloXmlAdepter.java 类，新建CXF能处理的 StringFood.java 类**

import java.util.HashMap;
    import java.util.Map;
    import javax.xml.bind.annotation.adapters.XmlAdapter;
    import org.fjava.cxf.model.Food;
    import org.fjava.cxf.ws.util.StringFood.Entry;
    //该转换器负责完成StringFood与Map<String, Food>的相互转换
    public class HelloXmlAdepter extends XmlAdapter<StringFood, Map<String, Food>> {
    	@Override
    	public Map<String, Food> unmarshal(StringFood v) throws Exception {
    		Map<String, Food> resMap = new HashMap<>();
    		for (Entry entry : v.getEntries()) {
    			resMap.put(entry.getKey(), entry.getValue());
    		}
    		return resMap;
    	}
    	@Override
    	public StringFood marshal(Map<String, Food> v) throws Exception {
    		StringFood sf = new StringFood();
    		for (String key : v.keySet()) {
    			sf.getEntries().add(new Entry(key, v.get(key)));
    		}
    		return sf;
    	}
    }

import java.util.ArrayList;
    import java.util.List;
    import org.fjava.cxf.model.Food;
    public class StringFood {
    	public static class Entry{
    		private String key;
    		private Food value;
    		public Entry() {
    			super();
    		}
    		public Entry(String key, Food value) {
    			super();
    			this.key = key;
    			this.value = value;
    		}
    		public String getKey() {
    			return key;
    		}
    		public void setKey(String key) {
    			this.key = key;
    		}
    		public Food getValue() {
    			return value;
    		}
    		public void setValue(Food value) {
    			this.value = value;
    		}
    	}
    	private List<Entry> entries = new ArrayList<>();
    	public List<Entry> getEntries() {
    		return entries;
    	}
    	public void setEntries(List<Entry> entries) {
    		this.entries = entries;
    	}
    }

**         \* 3 . 发布Web Service，写完后运行以下代码，若打印出 "Web Service暴露成功！" 则暴露成功；**  
**         \* 4 . 调用CXF提供的wsdl2java工具，根据WSDL文档生成相应的[Java][]代码\_\_CXF-02：使用CXF开发Web Service客户端 http://blog.csdn.net/cheng\_feng\_xiao\_zhan/article/details/52683987**  
**         \* 5 . 编写客户端**

**客户端编写逻辑输出代码：**

public static void main(String[] args) {
    	//这是命令生成的类，该类的实例可当成工厂来使用
    	HelloWorldWs factory = new HelloWorldWs();
    	//无参的方法，返回的是远程Web Service服务端的代理，服务端不能关闭。
    	HelloWorld helloWorld = factory.getHelloWorldWsPort();
    	StringFood allFoods = helloWorld.getAllFoods();
    	List<Entry> entries = allFoods.getEntries();
    	for (Entry entry : entries) {
    		System.out.println(entry.getKey() + " " + entry.getValue().getDescribe());
    	}
    }

**客户端运行结果：**

蟹王汉堡 橙色，亮金色，我的宝贝，我的爱！
    海绵金币 吃着金币样的甜甜饼，想着海绵宝宝赚的钱被扣了，哈哈哈，爽气！
    一个汉堡 是三层的，有夹层哦！
    火腿肠 这是章鱼哥从岸上偷运来的，据说很美味！

运行成功，解决 '像 Map、非JavaBean式的复合类，CXF不可以处理' 的问题！

**希望对你有帮助，祝你有一个好心情，加油！**

**若有错误、不全、可优化的点，欢迎纠正与补充；转载请注明出处！**

[20161015105413198]: /images/20220716/2b5bd09e232d49338d9d675f222ccaba.png
[20161015180239304]: /images/20220716/d29b43b3ed0342b8ab048651c02934b5.png
[Java]: http://lib.csdn.net/base/javaee