VO与PO的相互转换

GWT中的RPC机制可以让我们在前台页面直接调用后台的servlet，而且还能在前台就封装成一个对象，调用后台的方法，免去了中间的拆装。

但是一般前台展示用的是VO，而后台程序用的是PO，2者之间的转换还是有些麻烦，要写很多get set方法，很不利与整个程序的模块化与扩展性。

以下是我的一个方案，暂时感觉还不错。

写一个注解，通过这个注解来绑定VO与PO

package com.single.annotation;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import com.single.onlineoffice.main.server.convert.Convert;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface BindConvert {

	@SuppressWarnings("unchecked")
	Class<? extends Convert> convert();
	
}

写一个转换接口Convert

package com.single.convert;

import java.util.Collection;

public interface Convert<DOMAIN,CLIENT> {

	public CLIENT convertToClient(DOMAIN domain,Object... params);
	
	public DOMAIN convertToDomain(CLIENT client,Object... params);
	
	public Collection<CLIENT> convertCollectionToClient(Collection<DOMAIN> domains,Object... params);
	
	public Collection<DOMAIN> convertCollectionToDomain(Collection<CLIENT> clients,Object... params);
}

下面是Employee这个PO

package com.single.domain;

import com.single.annotation.BindConvert;
import com.single.onlineoffice.main.server.convert.EmployeeConvert;


@BindConvert(convert=EmployeeConvert.class)
public class Employee {

	private Long id;

	private String name;

	private Account account;
}

下面是ClientEmployee这个VO，与PO的差别是有一个username，他只是account中的一个属性

package com.single.domain;

import java.io.Serializable;

import com.single.annotation.BindConvert;
import com.single.onlineoffice.main.server.convert.EmployeeConvert;

@BindConvert(convert=EmployeeConvert.class)
public class ClientEmployee implements Serializable{

	private Long id;
	private String name;
	private String username;
}

下面是Employee与ClientEmployee之间的转换器

package com.single.onlineoffice.main.server.convert;

import java.util.Collection;
import com.single.onlineoffice.main.client.domain.ClientEmployee;
import com.single.onlineoffice.main.server.domain.Employee;

public class EmployeeConvert implements Convert<Employee, ClientEmployee> {
	@Override
	public ClientEmployee convertToClient(Employee domain,Object... params) {
		ClientEmployee clientEmployee=new ClientEmployee();
		clientEmployee.setId(domain.getId());
		clientEmployee.setName(domain.getName());
		clientEmployee.setUsername(domain.getAccount().getUsername());
		return clientEmployee;
	}

	@Override
	public Employee convertToDomain(ClientEmployee client,Object... params) {
		Employee employee=new Employee();
		employee.setId(client.getId());
		employee.setName(client.getName());
		return employee;
	}

	@SuppressWarnings("unchecked")
	@Override
	public Collection<ClientEmployee> convertCollectionToClient(
			Collection<Employee> domains, Object... params) {
		Collection<ClientEmployee> collection=null;
		try {
			collection=domains.getClass().newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("创建集合对象出错");
		}
		for(Employee employee:domains){
			collection.add(convertToClient(employee, params));
		}
		
		return collection;
	}

	@SuppressWarnings("unchecked")
	@Override
	public Collection<Employee> convertCollectionToDomain(
			Collection<ClientEmployee> clients, Object... params) {
		Collection<Employee> collection=null;
		try {
			collection=clients.getClass().newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("创建集合对象出错");
		}
		for(ClientEmployee clientEmployee:clients){
			collection.add(convertToDomain(clientEmployee, params));
		}
		return collection;
	}

}

再写一个辅助类就可以轻松的进行转换了

package com.single.onlineoffice.main.server.util;

import com.single.annotation.BindConvert;
import com.single.onlineoffice.main.server.convert.Convert;

public class DomainClientConvertUtils {

	@SuppressWarnings("unchecked")
	public static <X>X convertToClient(Object object,Object... params) {
		BindConvert anno=object.getClass().getAnnotation(BindConvert.class);
		Convert<Object, Object> convert=null;
		try {
			convert=anno.convert().newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("Domain转换Client异常");
		}
		return (X)convert.convertToClient(object,params);
	}
	
	@SuppressWarnings("unchecked")
	public static <X>X convertToDomain(Object object,Object... params) {
		BindConvert anno=object.getClass().getAnnotation(BindConvert.class);
		Convert<Object, Object> convert=null;
		try {
			convert=anno.convert().newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException("Client转换Domain异常");
		}
		return (X)convert.convertToDomain(object,params);
	}
}

如果需要转换，使用以下语句就可以了

		Employee employee=null;
		ClientEmployee ce=DomainClientConvertUtils.convertToClient(employee);
		
		ClientEmployee clientEmployee=null;
		Employee e=DomainClientConvertUtils.convertToDomain(clientEmployee);