Utilice Dozer para convertir con elegancia DO en VO
En el desarrollo web, entraremos en contacto con muchos conceptos del modelo de dominio, la mayoría de los cuales están relacionados con entidades con abreviaturas, generalmente terminadas en O (Objeto). Los más comunes son DO, DTO, VO, DAO, etc. También solemos tener operaciones para convertir un objeto de entidad en otro objeto de entidad. Este artículo presenta principalmente un método de conversión que el autor considera más elegante en la práctica. Bienvenido a hacer ladrillos.
Qué es DO, DTO y VO
Se han introducido varios conceptos de modelo en Java en los conceptos de VO, PO, DO, DTO, BO, QO, DAO y POJO en Java. Aquí hay un breve resumen:
En el desarrollo diario de un proyecto, VO corresponde a los datos (formulario) que deben mostrarse en la página, DO corresponde a los datos almacenados en la base de datos (tabla de datos) y DTO corresponde a los datos que deben transferirse excepto los dos.
Es posible que muchas personas no estén tan familiarizadas con VO y DTO. Por el contrario, están más familiarizadas con DO. Esto se debe a que solo usamos DO en muchos proyectos por varias razones. Las razones pueden ser las siguientes:
1. El proyecto es demasiado pequeño Para una entidad empresarial, encapsularlo en una DO es suficiente.
2. No estoy familiarizado con DTO y VO, y mucho menos con la diferencia entre ellos.
3. Comprenda la diferencia entre DO \ DTO \ VO, pero no se moleste en usarlo.
Entonces, aquí, el blogger hablará sobre por qué se introducen tantos conceptos y por qué sugiero que use estos objetos de entidad en sus proyectos.
¿Por qué no usar un DO
Veamos un ejemplo así. Supongamos que hay una entidad como Usuario en nuestro proyecto. Generalmente incluimos los siguientes atributos al crear la tabla de usuarios:
Para esta entidad, normalmente necesitamos crear una clase DO para encapsular la entidad Usuario.
public class UserDO {
private Integer id; //唯一主键
private Date createdTime; //创建时间
private Date updatedTime; //最后更新时间
private String name; //姓名
private Integer age; //年龄
private String gender; //性别
private String address; //住址
private String password; //密码
private String nickName; //昵称
private Date birthday; //生日
private String politicalStatus; //政治面貌,1表示群众,2表示团员,3表示党员,4表示其他,100表示未知
private Integer companyId; //公司的ID
private Integer status; //数据状态,1表示可用,0表示不可用
//setter and getter
}Luego, en el código, desde DAO hasta la pantalla frontal, todos usamos este objeto de clase UserDO para la transmisión de datos. Cual es el problema con esto?
- Los campos innecesarios también se pasan a la página de inicio.
Es posible que no necesitemos mostrar los campos como contraseña, createdTime, updatedTime y estado en la interfaz, pero estos campos también pueden pasarse a la interfaz (a menos que no hayamos consultado los campos correspondientes al consultar SQL). Esto no solo aumenta la cantidad de transmisión de datos, sino que también puede tener problemas de seguridad.
- Es necesario convertir algunos campos, pero no se admiten.
Para el campo de rostro político en el ejemplo anterior, almacenamos números en la base de datos, pero lo que quiero mostrar en la página de inicio es la descripción en chino. Esta situación solo se puede mostrar en el front-end a través de if / else.
-
Algunos campos deben mostrarse, pero no quieren aparecer en la base de datos.
- En la tabla User, solo almacenamos el companyId de este usuario, y necesitamos consultar la tabla de la empresa para obtener información más detallada sobre la empresa. Para el objeto Usuario, ¿qué pasa si queremos mostrar la empresa a la que pertenece al mismo tiempo en la interfaz y esperamos encontrarlas todas a través de una sola consulta? Hay varias soluciones sencillas, la primera es incluir una propiedad de la clase Company en UserDO y pasarla por esta propiedad. La otra es escribir los atributos de empresa que queremos pasar al front-end a UserDO. Sin embargo, si se hace esto, ¿puede UserDO seguir llamándose DO?
- Todavía hay muchas preguntas, por lo que no las presentaré en detalle aquí.
Puede verse que usar un DO de principio a fin (desde la base de datos hasta la página de inicio) no es un buen diseño.
Cómo utilizar DO, DTO, VO correctamente
Para el ejemplo anterior, podemos diseñarlo en las siguientes clases. Dado que el modelo no es complicado, solo es necesario introducir VO aquí.
UserDO tiene una correspondencia uno a uno con los campos de la base de datos, por lo que no es necesario modificarlo aquí.
public class UserDO {
private Integer id; //唯一主键
private Date createdTime; //创建时间
private Date updatedTime; //最后更新时间
private String name; //姓名
private Integer age; //年龄
private String gender; //性别
private String address; //住址
private String password; //密码
private String nickName; //昵称
private Date birthday; //生日
private String education; //学历
private String politicalStatus; //政治面貌,1表示群众,2表示团员,3表示党员,4表示其他,100表示未知
private Integer companyId; //公司的ID
private Integer status; //数据状态,1表示可用,0表示不可用
//setter and getter
}Introduzca UserVO para encapsular los campos que deben mostrarse cuando se pasan a la interfaz.
public class UserVO {
private Integer id; //唯一主键
private String name; //姓名
private Integer age; //年龄
private String gender; //性别
private String address; //住址
private String nickName; //昵称
private Date birthday; //生日
private String education; //学历
private String politicalStatus; //政治面貌，群众、团员、党员等
private Company company; //公司
//setter and getter
}UserVO solo contiene los campos requeridos para la visualización, y los campos que no necesitan mostrarse no necesitan incluirse aquí.
Después de introducir esta clase, podemos usar UserDO al consultar la base de datos y luego convertir DO en VO cuando necesitemos pasarlo al front-end.
para resumir
Al ver esto, es posible que haya descubierto que UserDO y UserVO contienen muchos de los mismos campos. ¿Es realmente necesario diseñar un VO por separado? Lo que puedo decirle claramente es que cuando su sistema se hace más grande y hay más y más campos en la tabla, definitivamente es beneficioso usar conceptos como DO \ DTO \ VO para el procesamiento jerárquico. En cuanto a cómo convertir de manera efectiva entre diferentes clases de entidad, lo presentaré a continuación.
Convierta con gracia DO a VO
Dozer es una herramienta de conversión de objetos.
Dozer puede copiar datos de forma recursiva de JavaBean a JavaBean, y estos JavaBeans pueden ser de diferentes tipos complejos. Para todas las asignaciones, Dozer copiará directamente los campos con el mismo nombre. Si los nombres de los campos son diferentes o hay requisitos especiales correspondientes, se pueden definir en xml.
El DO \ DTO \ VO que presentamos anteriormente no es JavaBean. Da la casualidad de que puede utilizar Dozer para la conversión. Además de usar Dozer, por supuesto, tiene otras opciones:
La solución típica es la copia manual. Las desventajas son obvias. El código está inundado de una gran cantidad de métodos Set y Get, y el negocio real está enterrado en el valor y la copia del valor.
Otra solución es usar BeanUtil, pero BeanUtil no es lo suficientemente flexible y, a veces, debe copiarse manualmente. Dozer puede transformar objetos de manera flexible y es fácil de usar.
Tipos de conversión admitidos por Dozer
El tipo de datos básico primitivo, seguido de Wrapper es una clase de empaquetado El tipo complejo es un tipo complejo
• Primitive to Primitive Wrapper
• Primitive to Custom Wrapper
• Primitive Wrapper to Primitive Wrapper
• Primitive to Primitive
• Complex Type to Complex Type
• String to Primitive
• String to Primitive Wrapper
• String to Complex Type if the Complex Type contains a String constructor
• String 到复杂类型 , 如果复杂类型包含一个 String 类型的构造器
• String to Map
• Collection to Collection
• Collection to Array
• Map to Complex Type
• Map to Custom Map Type
• Enum to Enum
• Each of these can be mapped to one another: java.util.Date, java.sql.Date, java.sql.Time, java.sql.Timestamp, java.util.Calendar, java.util.GregorianCalendar
• String to any of the supported Date/Calendar Objects.
• Objects containing a toString() method that produces a long representing time in (ms) to any supported Date/Calendar object.Utilice Dozer en proyectos normales de Java
Agregar dependencia en pom.xml
<dependency>
<groupId>net.sf.dozer</groupId>
<artifactId>dozer</artifactId>
<version>5.5.1</version>
</dependency>Utilice Dozer para la conversión de clases
public class Main {
public static void main(String[] args) {
DozerBeanMapper mapper = new DozerBeanMapper();
UserDO userDO = new UserDO();
userDO.setName("hollis");
userDO.setAddress("hz");
userDO.setAge(25);
userDO.setCompanyId(1);
userDO.setBirthday(new Date());
userDO.setGender("male");
userDO.setEducation("1");
userDO.setNickName("hollis");
userDO.setPoliticalStatus("3");
UserVO userVO = (UserVO) mapper.map(userDO, UserVO.class);
System.out.println(userVO);
}
}Conversión de campos especiales Antes de utilizar el asignador para la conversión, configure uno o más archivos de asignación
List myMappingFiles = new ArrayList();
myMappingFiles.add("dozer-mapping.xml");
mapper.setMappingFiles(myMappingFiles);
配置dozer-mapping.xml文件Si los tipos de datos son inconsistentes, los nombres son diferentes o existe una relación en cascada, puede usar el archivo dozer-mapping.xml para realizar una conversión de bean personalizada.
<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://dozer.sourceforge.net
http://dozer.sourceforge.net/schema/beanmapping.xsd">
<mapping>
<class-a>com.hollis.lab.UserDO</class-a>
<class-b>com.hollis.lab.UserVO</class-b>
</mapping>
</mappings>Usar Dozer en proyectos JavaWeb
Agregar dependencia en pom.xml
<dependency>
<groupId>net.sf.dozer</groupId>
<artifactId>dozer</artifactId>
<version>5.5.1</version>
</dependency>Utilice Spring para integrar la topadora
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="baseMapper" class="org.dozer.spring.DozerBeanMapperFactoryBean">
<property name="mappingFiles">
<list>
<value>classpath:mapping/dozer-mapping.xml</value>
</list>
</property>
</bean>
</beans> Utilice baseMapper para la conversión de Bean
@Autowired
private Mapper baseMapper;
private UserVO doToVo(UserDO userDO){
if(userDO == null) return null;
UserVO vo = baseMapper.map(userDO, UserVO.getClass());
if(userDO.getCompanyId != null) getCompany(vo);
return vo;
}A través del código y la configuración anteriores, hemos realizado parte de la operación de DO a VO. La razón por la que es parte de la operación es porque no hicimos una configuración adicional en dozer-mapping.xml, solo use dozer para neutralizar DO Los atributos compartidos en VO se han convertido. Para otras conversiones con diferentes tipos o nombres, puede consultar el ejemplo del sitio web oficial configurando el archivo dozer-mapping.xml.
Hay otro getCompany () no implementado arriba. Este método consiste en consultar la entidad de la empresa a través de companyId y asignarla al atributo de la empresa en UserVO.
Después de usar dozer, podemos asignar algunas propiedades en UserDO a UserVO. De hecho, el proceso de conversión se implementa llamando al método getter en UserDO y al método setter en UserVO. Los lectores pueden hacer un experimento. Para algunas propiedades en UserVO sin escribir el método Setter para ver si el valor de la propiedad se puede convertir, el blogger lo ha probado, no es posible.