Java tutorial
/* Copyright (c) 2012 GFT Appverse, S.L., Sociedad Unipersonal. This Source Code Form is subject to the terms of the Appverse Public License Version 2.0 (APL v2.0?). If a copy of the APL was not distributed with this file, You can obtain one at http://www.appverse.mobi/licenses/apl_v2.0.pdf. [^] Redistribution and use in source and binary forms, with or without modification, are permitted provided that the conditions of the AppVerse Public License v2.0 are met. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. EXCEPT IN CASE OF WILLFUL MISCONDUCT OR GROSS NEGLIGENCE, IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package org.appverse.web.framework.backend.api.converters.helpers; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.Collection; import java.util.List; import org.apache.commons.lang.ArrayUtils; import org.appverse.web.framework.backend.api.common.AbstractBean; import org.appverse.web.framework.backend.api.converters.IBeanConverter; /** * Copy properties between two objects of subclasses of abstract beans. The * subclasses of abstract bean must have the same amount of properties and name * and types must match except the type of properties that have type that * subclass AbstractBean. For properties of type that subclass AbstractBean and * for properties that are collection parametrized with types that subclass * AbstractBean this class creates deferred objects that with the * ConverterAspect implement lazyloading. * * @see org.appverse.web.framework.backend.api.converters.helpers.IndirectArrayList * @see org.appverse.web.framework.backend.aop.aspects.ConverterAspect * */ public class ConverterUtils extends org.springframework.beans.BeanUtils { /** * Creates target bean of targetClass type copying source properties to ones * with the same name at target. Beans and collections are copied as * detached objects to allow lazy initialization. * * @param source * Source Bean to copy * @param targetClass * Type of target bean to generate * @param converters * List of conveters of child bean properties * @return Target bean of targetClass type with source data converted * @throws Exception */ public static <TargetBean extends AbstractBean> TargetBean convert(AbstractBean source, Class<TargetBean> targetClass, IBeanConverter[] converters) throws Exception { // If source bean is null return null target bean if (source == null) { return null; } // Create target bean using target class default constructor Constructor<TargetBean> constructor = targetClass.getConstructor(new Class[] {}); TargetBean target = constructor.newInstance(new Object[] {}); // Obtain source fields (including inherited fields) Field[] sourceFields = getBeanFields(source); // Call class methods to copy simple properties, bean properties and // collection properties ConverterUtils.copyPlainFields(source, target, sourceFields); ConverterUtils.convertBeanFields(source, target, converters, sourceFields); ConverterUtils.convertBeanCollectionFields(source, target, converters, sourceFields); return target; } /** * Copy source bean collection properties of type bean to target bean as * detached bean collections * * @param sourceBean * Source Bean * @param targetBean * Target Bean * @param childrenBeanConverters * List of converters needed to convert source bean childs of * type bean collection to target bean childs of type bean * collection * @param sourceFields * Fields of source Bean * @throws Exception */ private static void convertBeanCollectionFields(AbstractBean sourceBean, AbstractBean targetBean, IBeanConverter[] childrenBeanConverters, Field[] sourceFields) throws Exception { // Arrays to hold bean collection field names, target collection types, // source collection parameter types and target collection parameter // types String[] beanCollectionFieldNames = new String[0]; Type[] targetFieldTypes = new Type[0]; Type[] sourceFieldParameterTypes = new Type[0]; Type[] targetFieldParameterTypes = new Type[0]; // For each source field... for (Field field : sourceFields) { // If source field is a collection... if (Collection.class.isAssignableFrom(field.getType())) { // Get Field (Remember is a collection) parameters Type[] sourceFieldParameters = ((ParameterizedType) field.getGenericType()) .getActualTypeArguments(); // If field is a collection of something extending // AbstractBean... if (sourceFieldParameters.length == 1 && AbstractBean.class.isAssignableFrom((Class<?>) sourceFieldParameters[0])) { // If target field is a collection if (Collection.class .isAssignableFrom(targetBean.getClass().getDeclaredField(field.getName()).getType())) { // Get target field parameter types Type[] targetFieldParameters = ((ParameterizedType) targetBean.getClass() .getDeclaredField(field.getName()).getGenericType()).getActualTypeArguments(); // If target field is a collection of something // extending // AbstractBean... if (targetFieldParameters.length == 1 && AbstractBean.class.isAssignableFrom((Class<?>) targetFieldParameters[0])) { // Fill Arrays with name, source field type, target // type and target // parameter type beanCollectionFieldNames = (String[]) ArrayUtils.add(beanCollectionFieldNames, field.getName()); targetFieldTypes = (Type[]) ArrayUtils.add(targetFieldTypes, targetBean.getClass().getDeclaredField(field.getName()).getType()); sourceFieldParameterTypes = (Type[]) ArrayUtils.add(sourceFieldParameterTypes, sourceFieldParameters[0]); targetFieldParameterTypes = (Type[]) ArrayUtils.add(targetFieldParameterTypes, targetFieldParameters[0]); } else { throw new Exception("Target collection parameter type mismatch"); } } else { throw new Exception("Target parameter type mismatch"); } } } } // For each field with collection of bean type... for (int i = 0; i < beanCollectionFieldNames.length; i++) { String beanCollectionFieldName = beanCollectionFieldNames[i]; Type targetFieldType = targetFieldTypes[i]; Type sourceFieldParameterType = sourceFieldParameterTypes[i]; Type targetFieldParameterType = targetFieldParameterTypes[i]; // Select the appropiate converter... IBeanConverter converter = getConverter(childrenBeanConverters, sourceFieldParameterType, targetFieldParameterType); // Create a target detached (LazyArrayList) collection using the // source collection, the target parameter type y the converter... @SuppressWarnings("unchecked") IndirectArrayList<AbstractBean, AbstractBean> lazyCollection = new IndirectArrayList<AbstractBean, AbstractBean>( (List<AbstractBean>) getGetterMethod(beanCollectionFieldName, sourceBean).invoke(sourceBean), (Class<AbstractBean>) targetFieldParameterType, converter); // Set the detached collection on target bean getSetterMethod(beanCollectionFieldName, targetFieldType, targetBean).invoke(targetBean, lazyCollection); } } /** * Copy source bean properties of type bean to target bean as detached beans * * @param sourceBean * Source Bean * @param targetBean * Target Bean * @param childrenBeanConverters * List of converters needed to convert source bean children of * type bean to target bean children of type bean * @param sourceFields * Fields of source Bean * @throws Exception */ private static void convertBeanFields(AbstractBean sourceBean, AbstractBean targetBean, IBeanConverter[] childrenBeanConverters, Field[] sourceFields) throws Exception { // Arrays to hold bean field names, source types and target types String[] beanFieldNames = new String[0]; Type[] sourceFieldTypes = new Type[0]; Type[] targetFieldTypes = new Type[0]; // For each source field... for (Field field : sourceFields) { // If source field is a bean... if (AbstractBean.class.isAssignableFrom(field.getType())) { // Fill Arrays with name, source field type and target type beanFieldNames = (String[]) ArrayUtils.add(beanFieldNames, field.getName()); sourceFieldTypes = (Type[]) ArrayUtils.add(sourceFieldTypes, field.getType()); targetFieldTypes = (Type[]) ArrayUtils.add(targetFieldTypes, targetBean.getClass().getDeclaredField(field.getName()).getType()); } } // For each field with bean type... for (int i = 0; i < beanFieldNames.length; i++) { String beanFieldName = beanFieldNames[i]; Type sourceFieldType = sourceFieldTypes[i]; Type targetFieldType = targetFieldTypes[i]; // Select the proper converter... IBeanConverter converter = getConverter(childrenBeanConverters, sourceFieldType, targetFieldType); // Get the target bean constructor @SuppressWarnings("unchecked") Constructor<AbstractBean> constructor = ((Class<AbstractBean>) targetFieldType) .getConstructor(new Class[] {}); // Create target child bean AbstractBean targetChildBean = constructor.newInstance(new Object[] {}); // Detach target child bean with source child bean and converter ((Detachable) targetChildBean).detach( (AbstractBean) getGetterMethod(beanFieldName, sourceBean).invoke(sourceBean), converter); // Set the detached target bean getSetterMethod(beanFieldName, targetFieldType, targetBean).invoke(targetBean, targetChildBean); } } /** * Copy source bean single properties to target bean * * @param source * Source Bean * @param target * Target Bean * @param sourceFields * Fields of source Bean * @throws Exception */ private static void copyPlainFields(AbstractBean source, AbstractBean target, Field[] sourceFields) throws Exception { String[] ignoreProperties = new String[0]; // For each source field... for (Field field : sourceFields) { // If source field is a bean... if (AbstractBean.class.isAssignableFrom(field.getType())) { // Put it in ignore properties ignoreProperties = (String[]) ArrayUtils.add(ignoreProperties, field.getName()); } } // Copy properties with Spring Framework copy properties org.springframework.beans.BeanUtils.copyProperties(source, target, ignoreProperties); } /** * Obtain a list of field declared by a bean class and superclasses * * @param bean * Bean to get the fields * @return Array of fields declared by bean class and superclasses * @throws Exception */ private static Field[] getBeanFields(AbstractBean bean) throws Exception { // Fields added to AbstractBean by ConverterAspect String[] ignoreFields = ((Detachable) bean).getDetachableFields(); Class<?> clazz = bean.getClass(); // Get the all fields declared by the class Field[] fields = clazz.getDeclaredFields(); // For all superclasses until arrive to AbstractBean (including // AbstractBean)... while (clazz.getSuperclass() != null && AbstractBean.class.isAssignableFrom(clazz.getSuperclass())) { clazz = clazz.getSuperclass(); // Add the clazz declared fields to field list fields = (Field[]) ArrayUtils.addAll(fields, clazz.getDeclaredFields()); } // Remove from the list fields added by the converters aspect to // Abstract // bean for (Field field : fields) { if (ArrayUtils.contains(ignoreFields, field.getName())) { fields = (Field[]) ArrayUtils.removeElement(fields, field); } } return fields; } /** * Select a converter from a array of them based on the match of converter * parameters with sourceType and targetType * * @param converters * List of converters * @param sourceType * First type to match * @param targetType * Second type to match * @return Proper converter based on sourceType and targetType * @throws Exception */ private static IBeanConverter getConverter(IBeanConverter[] converters, Type sourceType, Type targetType) throws Exception { // For each converter in converter list... for (IBeanConverter converter : converters) { // Obtain type parameters Type[] converterBeanTypes = ((ParameterizedType) converter.getClass().getGenericSuperclass()) .getActualTypeArguments(); // Check that converter has two parameters and this parameters are // differs if (converterBeanTypes.length != 2 || converterBeanTypes[0].equals(converterBeanTypes[1])) { throw new Exception("Wrong converter parameters"); } boolean wrongConverter = false; // For each converter type parameter... for (Type converterBeanType : converterBeanTypes) { // Check that the converter parameter type is either sourceType // or targetType if (!((Class<?>) converterBeanType).isAssignableFrom((Class<?>) sourceType) && !((Class<?>) converterBeanType).isAssignableFrom((Class<?>) targetType)) { wrongConverter = true; break; } } // If converter parameter types matches with sourceType and // targetType returns converter if (!wrongConverter) { return converter; } } // If no converter found throws exception throw new Exception("Appropiated Conversor not found"); } /** * Obtain a getter method object based on a bean and a field name. * * @param beanFieldName * Field name that gets the getter method * @param bean * Bean to obtain the getter method * @return Getter Method * @throws Exception */ private static Method getGetterMethod(String beanFieldName, AbstractBean bean) throws Exception { String beanGetterName = "get" + beanFieldName.substring(0, 1).toUpperCase() + beanFieldName.substring(1); Method beanGetter = bean.getClass().getDeclaredMethod(beanGetterName); return beanGetter; } /** * Obtain a setter method object based on a bean, a field name and a field * type. * * @param beanFieldName * Field name that sets the setter method * @param beanFieldType * Field type that sets the setter method * @param bean * Bean to obtain the setter method * @return Setter Method * @throws Exception */ private static Method getSetterMethod(String beanFieldName, Type beanFieldType, AbstractBean bean) throws Exception { String beanSetterName = "set" + beanFieldName.substring(0, 1).toUpperCase() + beanFieldName.substring(1); Method beanSetter = bean.getClass().getDeclaredMethod(beanSetterName, (Class<?>) beanFieldType); return beanSetter; } }