项目中使用的Web Service框架是Rop,在本次开发中,遇到了A对象的成员属性包含B对象,调用服务端时报B对象类型与传递的对象不匹配的问题。本人对Rop框架理解并不深,只是简单会用,好在网上关于Rop的资料不多,逐一筛下来,《rop入门(二)》这篇文章里,关于处理复合对象的内容对解决这个问题是很有针对性的,我在尝试该解决方案的过程中,做了一些调整,形成了一种变式方案,现摘取原方案并附我的调整,整理出来:
(注:我的解决方案在分割线后)
《rop入门(二)》文中,提到了两种解决方案:
1.手动将复合对象(UserInfo)转换成Json或xml格式
原文示例是手动拼接的....个人觉得还是使用一些现有的工具类,将实体转换成xml或json报文比较好。个人没有用这种方式。
2.配置自定义类型转换器
首先贴一个Rop示例中的TelephoneConverter,如下:
package com.rop.sample.request;
import com.rop.request.RopConverter;
import org.springframework.core.convert.converter.Converter;
import org.springframework.util.StringUtils;
public class TelephoneConverter implements RopConverter<String, Telephone> {
@Override
public Telephone convert(String source) {
if (StringUtils.hasText(source)) {
String zoneCode = source.substring(0, source.indexOf("-"));
String telephoneCode = source.substring(source.indexOf("-") + 1);
Telephone telephone = new Telephone();
telephone.setZoneCode(zoneCode);
telephone.setTelephoneCode(telephoneCode);
return telephone;
} else {
return null;
}
}
@Override
public String unconvert(Telephone target) {
StringBuilder sb = new StringBuilder();
sb.append(target.getZoneCode());
sb.append("-");
sb.append(target.getTelephoneCode());
return null;
}
@Override
public Class<String> getSourceClass() {
return String.class;
}
@Override
public Class<Telephone> getTargetClass() {
return Telephone.class;
}
}
转换器TelephoneConverter的逻辑很清晰,convert方法将指定格式的String解析为Telephone对象,unconvert反之。
转换器TelephoneConverter的配置如下:
<rop:annotation-driven formatting-conversion-service="conversionService"/>
<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
<property name="converters">
<set>
<!-- 将 xxxx-yyy 格式化串转换为 Telephone 对象 -->
<bean class="com.rop.sample.request.TelephoneConverter"/>
</set>
</property>
</bean>
搜索rop的配置文件,找到 conversionService 的位置,TelephoneConverter是作为示例配置在此处的,新写自定义转换器时,添加该转换器的bean标签即可。
以上介绍了原文中转换器的写法和配置,下面简要介绍使用,我将简述rop请求的大致流程以便理解,以get方式请求为例:
DefaultRopClient ropClient;
//略去ropClient的初始化过程
//添加自定义转换器
ropClient.addRopConvertor(new TelephoneConverter());
//略去入参封装
//调用get方法进行rop调用
ropClient.buildClientRequest().get(ropRequest,ropResponseClass,methodName,version);
跟踪源码,只摘录与get请求流程有关的方法,顺次排列如下:
public <T> CompositeResponse get(RopRequest ropRequest, Class<T> ropResponseClass, String methodName, String version) {
Map<String, String> requestParams = getRequestForm(ropRequest, methodName, version);
return get(ropResponseClass, requestParams);
}
private Map<String, String> getRequestForm(RopRequest ropRequest, String methodName, String version) {
Map<String, String> form = new LinkedHashMap<String, String>(16);
//系统级参数
form.put(SystemParameterNames.getAppKey(), appKey);
form.put(SystemParameterNames.getMethod(), methodName);
form.put(SystemParameterNames.getVersion(), version);
form.put(SystemParameterNames.getFormat(), messageFormat.name());
form.put(SystemParameterNames.getLocale(), locale.toString());
if (sessionId != null) {
form.put(SystemParameterNames.getSessionId(), sessionId);
}
//业务级参数
form.putAll(getParamFields(ropRequest, messageFormat));
//对请求进行签名
String signValue = sign(ropRequest.getClass(), appSecret, form);
form.put("sign", signValue);
return form;
}
/**
* 获取ropRequest对应的参数名列表
*
* @param ropRequest
* @param mf
* @return
*/
private Map<String, String> getParamFields(RopRequest ropRequest, MessageFormat mf) {
if (!requestAllFields.containsKey(ropRequest.getClass())) {
parseRopRequestClass(ropRequest);
}
return toParamValueMap(ropRequest, mf);
}
/**
* 获取ropRequest对象的对应的参数列表
*
* @param ropRequest
* @param mf
* @return
*/
private Map<String, String> toParamValueMap(RopRequest ropRequest, MessageFormat mf) {
List<Field> fields = requestAllFields.get(ropRequest.getClass());
Map<String, String> params = new HashMap<String, String>();
for (Field field : fields) {
RopConverter convertor = getConvertor(field.getType());
Object fieldValue = ReflectionUtils.getField(field, ropRequest);
if (fieldValue != null) {
if (convertor != null) {//有对应转换器
String strParamValue = (String) convertor.unconvert(fieldValue);
params.put(field.getName(), strParamValue);
} else if (field.getType().isAnnotationPresent(XmlRootElement.class) ||
field.getType().isAnnotationPresent(XmlType.class)) {
String message = MessageMarshallerUtils.getMessage(fieldValue, mf);
params.put(field.getName(), message);
} else {
params.put(field.getName(), fieldValue.toString());
}
}
}
return params;
}
toParamValueMap是一个关键方法。整体思想是将传入的实体转换成Map。如Convertor类完成了正确配置,并在ropClient调用rop请求前添加了转换器(ropClient.addRopConvertor(new TelephoneConverter());),那么在转换复合对象时,将调用该转换器的unconvert方法,将实体转换成自定义格式的字符串,之后put入map中,完成参数封装。
之后,开始正式执行get请求,此处就不再是rop的部分了,用了SpringFramework的RestTemplate类对象,调用getForObject(...)方法发起get请求:
private <T> CompositeResponse get(Class<T> ropResponseClass, Map<String, String> requestParams) {
String responseContent = restTemplate.getForObject(buildGetUrl(requestParams), String.class, requestParams);
if (logger.isDebugEnabled()) {
logger.debug("response:\n" + responseContent);
}
return toCompositeResponse(responseContent, ropResponseClass);
}
在这个过程中,调用了TelephoneConverter的convert方法,将指定格式的字符串还原成Telephone对象。
之后,执行服务器端方法逻辑,完成后返回。返回时,不再调用TelephoneConverter,具体逻辑是:
根据rop配置文件中设置的数据格式(Json/xml),responseContent 为该格式的字符串。
String responseContent = restTemplate.getForObject(buildGetUrl(requestParams), String.class, requestParams);
将该字符串解析为真实实体类型并完成返回。
return toCompositeResponse(responseContent, ropResponseClass);
private <T> CompositeResponse toCompositeResponse(String content, Class<T> ropResponseClass) {
if(logger.isDebugEnabled()){
logger.debug(content);
}
boolean successful = isSuccessful(content);
DefaultCompositeResponse<T> compositeResponse = new DefaultCompositeResponse<T>(successful);
if (MessageFormat.json == messageFormat) {
if (successful) {
T ropResponse = jsonUnmarshaller.unmarshaller(content, ropResponseClass);
compositeResponse.setSuccessRopResponse(ropResponse);
} else {
ErrorResponse errorResponse = jsonUnmarshaller.unmarshaller(content, ErrorResponse.class);
compositeResponse.setErrorResponse(errorResponse);
}
} else {
if (successful) {
T ropResponse = xmlUnmarshaller.unmarshaller(content, ropResponseClass);
compositeResponse.setSuccessRopResponse(ropResponse);
} else {
ErrorResponse errorResponse = xmlUnmarshaller.unmarshaller(content, ErrorResponse.class);
compositeResponse.setErrorResponse(errorResponse);
}
}
return compositeResponse;
}
以上就是原例的完整请求响应流程。
---------------------------------------------------------------------------------------------------------------------------
在我的实践中,由于不熟悉,并没有添加自定义转换器
//添加自定义转换器
ropClient.addRopConvertor(new TelephoneConverter());
由于这个疏忽,再加上一个习惯性小动作,反倒实现了我自己的解决方案,下面以User和UserInfo为例,阐述我的方案:
public class User extends AbstractRopRequest {
private String userName;
private UserInfo UserInfo;
//省略getter、setter
//省略toString()
}
public class UserInfo {
private String birthday;
private String telephone;
private String address;
@Override
public String toString() {
return "UserInfo [" + (birthday != null ? "birthday=" + birthday + ", " : "")
+ (telephone != null ? "telephone=" + telephone + ", " : "")
+ (address != null ? "address=" + address : "") + "]";
}
//省略getter、setter
}
如不对UserInfo类的对象做处理,在使用Rop传递User对象时,会报UserInfo类型和UserInfo对象不匹配。
我首先编写了UserInfoConvertor的编写及配置,但由于我没有 调用addRopConvertor()方法,所以在
/**
* 获取ropRequest对象的对应的参数列表
*
* @param ropRequest
* @param mf
* @return
*/
private Map<String, String> toParamValueMap(RopRequest ropRequest, MessageFormat mf) {
List<Field> fields = requestAllFields.get(ropRequest.getClass());
Map<String, String> params = new HashMap<String, String>();
for (Field field : fields) {
RopConverter convertor = getConvertor(field.getType());
Object fieldValue = ReflectionUtils.getField(field, ropRequest);
if (fieldValue != null) {
if (convertor != null) {//有对应转换器
String strParamValue = (String) convertor.unconvert(fieldValue);
params.put(field.getName(), strParamValue);
} else if (field.getType().isAnnotationPresent(XmlRootElement.class) ||
field.getType().isAnnotationPresent(XmlType.class)) {
String message = MessageMarshallerUtils.getMessage(fieldValue, mf);
params.put(field.getName(), message);
} else {
params.put(field.getName(), fieldValue.toString());
}
}
}
return params;
}
toParamValueMap()方法执行时,没有获得到相应的 UserInfoConvertor ,封装时,由于UserInfo类中顺手为之的toString()方法,UserInfo对象在形式上,如同 userName这个普通String成员一样,以字符串形式被封装进params这个map中。
这样下来,可以将toString()方法视为UserInfoConvertor中的unconvert()方法,完成了从实体到字符串的转换。
某种程度上,自动生成的toString()方法简化了Convertor的编写,即不用再将对象属性一一获取出来,按照一定规则完成封装,这种简化随着对象属性数量的增长而愈发明显。
至此,客户端将对象转换为字符串的动作完成。
之后,客户端发送get请求:
String responseContent = restTemplate.getForObject(buildGetUrl(requestParams), String.class, requestParams);
服务端接收到get请求后,获取到请求参数,调用UserInfoConvertor的convert()方法开始将字符串解析成UserInfo对象。
与TelephoneConverter不同,此处 convert() 解析的为 toString() 生成的模板化字符串,如:
UserInfo [birthday=生日, telephone=电话, address=地址]
那么,掐头去尾,将中间的“属性名=属性值”的形式转存为map,再封装为UserInfo即可。我使用了自写工具类完成map到Object的封装。该工具类在 Farewell To Getter/Setter----参数封装工具类 一文中。
@Override
public UserInfo convert(String rowInfo) {
if (StringUtils.hasText(rowInfo)) {
//传入的字符串样例 UserInfo [birthday=生日, telephone=电话, address=地址]
String infoString = rowInfo.substring(rowInfo.indexOf("[")+1, rowInfo.indexOf("]")); //掐头去尾
String[] infoArray = infoString.split(",");
HashMap<String, String> infoMap = new HashMap<String,String>();
for (String info : infoArray) {
String[] property = info.split("=");
infoMap.put(property[0].trim(), property[1].trim());
}
UserInfo info = new UserInfo();
try { //调用自写工具类完成map到Object的自动化封装
SetPropertiesTool.map2Object(infoMap,SetPropertiesTool.LOWER_FIRST,info);
} catch (Exception e) {
e.printStackTrace();
}
return info;
} else {
return null;
}
}
一眼看去,似乎比原例中的方法复杂:
@Override
public Telephone convert(String source) {
if (StringUtils.hasText(source)) {
String zoneCode = source.substring(0, source.indexOf("-"));
String telephoneCode = source.substring(source.indexOf("-") + 1);
Telephone telephone = new Telephone();
telephone.setZoneCode(zoneCode);
telephone.setTelephoneCode(telephoneCode);
return telephone;
} else {
return null;
}
}
但实际上,我的写法除了创建该类对象一句需要随新类更改:
UserInfo info = new UserInfo();
其上下两部分均无需更改。
-------------------------------------------------------------------------------------------------------------------------------
综上,我的实现方式为:
1.新建复合对象(UserInfo)的Converter,并配置在rop.xml中
2.为复合对象自动生成toString()方法
3.Converter中unconvert()方法为空实现,只根据toString()方法的格式,编写convert()方法解析为实体。
完整UserInfoConverter示例如下:
public class UserInfoConverter implements RopConverter<String,UserInfo>{
@Override
public String unconvert(UserInfo info){
return null;
}
@Override
public UserInfo convert(String rowInfo) {
if (StringUtils.hasText(rowInfo)) {
//传入的字符串样例 UserInfo [birthday=生日, telephone=电话, address=地址]
String infoString = rowInfo.substring(rowInfo.indexOf("[")+1, rowInfo.indexOf("]")); //掐头去尾
String[] infoArray = infoString.split(",");
HashMap<String, String> infoMap = new HashMap<String,String>();
for (String info : infoArray) {
String[] property = info.split("=");
infoMap.put(property[0].trim(), property[1].trim());
}
UserInfo info = new UserInfo();
try { //调用自写工具类完成map到Object的自动化封装
SetPropertiesTool.map2Object(infoMap,SetPropertiesTool.LOWER_FIRST,info);
} catch (Exception e) {
e.printStackTrace();
}
return info;
} else {
return null;
}
}
@Override
public Class<String> getSourceClass(){
return String.class;
}
@Override
public Class<UserInfo> getTargetClass(){
return UserInfo.class;
}
}
以上。