Java tutorial
/** * This file Copyright (c) 2003-2012 Magnolia International * Ltd. (http://www.magnolia-cms.com). All rights reserved. * * * This file is dual-licensed under both the Magnolia * Network Agreement and the GNU General Public License. * You may elect to use one or the other of these licenses. * * This file is distributed in the hope that it will be * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT. * Redistribution, except as permitted by whichever of the GPL * or MNA you select, is prohibited. * * 1. For the GPL license (GPL), you can redistribute and/or * modify this file under the terms of the GNU General * Public License, Version 3, as published by the Free Software * Foundation. You should have received a copy of the GNU * General Public License, Version 3 along with this program; * if not, write to the Free Software Foundation, Inc., 51 * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * 2. For the Magnolia Network Agreement (MNA), this file * and the accompanying materials are made available under the * terms of the MNA which accompanies this distribution, and * is available at http://www.magnolia-cms.com/mna.html * * Any modifications to this file must keep this entire header * intact. * */ package info.magnolia.content2bean.impl; import info.magnolia.cms.core.SystemProperty; import info.magnolia.content2bean.Content2BeanTransformer; import info.magnolia.content2bean.PropertyTypeDescriptor; import info.magnolia.content2bean.TypeDescriptor; import info.magnolia.content2bean.TypeMapping; import info.magnolia.objectfactory.ClassFactory; import info.magnolia.objectfactory.Classes; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.util.Collection; import java.util.HashMap; import java.util.Map; import javax.inject.Singleton; import org.apache.commons.beanutils.PropertyUtils; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Basic type mapping implementation. * @author philipp * @version $Id$ * */ @Singleton public class TypeMappingImpl implements TypeMapping { private static Logger log = LoggerFactory.getLogger(TypeMappingImpl.class); /** * Property types already resolved. */ private final Map<String, PropertyTypeDescriptor> propertyTypes = new HashMap<String, PropertyTypeDescriptor>(); /** * Descriptors for types. **/ private final Map<Class<?>, TypeDescriptor> types = new HashMap<Class<?>, TypeDescriptor>(); /** * Get a adder method. Transforms name to singular. */ public Method getAddMethod(Class<?> type, String name, int numberOfParameters) { name = StringUtils.capitalize(name); Method method = getExactMethod(type, "add" + name, numberOfParameters); if (method == null) { method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "s"), numberOfParameters); } if (method == null) { method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "es"), numberOfParameters); } if (method == null) { method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "ren"), numberOfParameters); } if (method == null) { method = getExactMethod(type, "add" + StringUtils.removeEnd(name, "ies") + "y", numberOfParameters); } return method; } /** * Cache the already resolved types. * */ @Override public PropertyTypeDescriptor getPropertyTypeDescriptor(Class<?> beanClass, String propName) { PropertyTypeDescriptor dscr; String key = beanClass.getName() + "." + propName; dscr = propertyTypes.get(key); if (dscr != null) { return dscr; } //TypeMapping defaultMapping = TypeMapping.Factory.getDefaultMapping(); // TODO - is this used - or is the comparison correct ? // if (this != defaultMapping) { // dscr = defaultMapping.getPropertyTypeDescriptor(beanClass, propName); // if (dscr.getType() != null) { // return dscr; // } // } dscr = new PropertyTypeDescriptor(); dscr.setName(propName); PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(beanClass); for (int i = 0; i < descriptors.length; i++) { PropertyDescriptor descriptor = descriptors[i]; if (descriptor.getName().equals(propName)) { Class<?> propertytype = descriptor.getPropertyType(); // may be null for indexed properties if (propertytype != null) { dscr.setType(getTypeDescriptor(propertytype)); } break; } } if (dscr.getType() != null) { if (dscr.isMap() || dscr.isCollection()) { int numberOfParameters = dscr.isMap() ? 2 : 1; Method method = getAddMethod(beanClass, propName, numberOfParameters); if (method != null) { dscr.setAddMethod(method); if (dscr.isMap()) { dscr.setCollectionKeyType(getTypeDescriptor(method.getParameterTypes()[0])); dscr.setCollectionEntryType(getTypeDescriptor(method.getParameterTypes()[1])); } else { dscr.setCollectionEntryType(getTypeDescriptor(method.getParameterTypes()[0])); } } } } // remember me propertyTypes.put(key, dscr); return dscr; } @Override public void addPropertyTypeDescriptor(Class<?> beanClass, String propName, PropertyTypeDescriptor dscr) { propertyTypes.put(beanClass.getName() + "." + propName, dscr); } @Override public void addTypeDescriptor(Class<?> beanClass, TypeDescriptor dscr) { types.put(beanClass, dscr); } @Override public TypeDescriptor getTypeDescriptor(Class<?> beanClass) { TypeDescriptor dscr = types.get(beanClass); // eh, we know about this type, don't bother resolving any further. if (dscr != null) { return dscr; } dscr = new TypeDescriptor(); dscr.setType(beanClass); dscr.setMap(Map.class.isAssignableFrom(beanClass)); dscr.setCollection(beanClass.isArray() || Collection.class.isAssignableFrom(beanClass)); types.put(beanClass, dscr); if (!beanClass.isArray() && !beanClass.isPrimitive()) { // don't bother looking for a transformer if the property is an array or a primitive type Content2BeanTransformer transformer = null; // TODO ? transformerProvider.getTransformerFor(beanClass); try { if (transformer == null) { transformer = findTransformerByNamingConvention(beanClass); } if (transformer == null) { transformer = findTransformerViaProperty(beanClass); } } catch (Exception e) { // this is fine because having a transformer class is optional log.debug("No custom transformer class {}Transformer class found", beanClass.getName()); } dscr.setTransformer(transformer); } return dscr; } /** * @deprecated since 4.5, transformers should be explicitly registered via the module descriptor. */ protected Content2BeanTransformer findTransformerByNamingConvention(Class<?> beanClass) { final String transformerClassName = beanClass.getName() + "Transformer"; try { return instantiateTransformer(beanClass, transformerClassName); } catch (ClassNotFoundException e) { log.debug("No transformer found by naming convention for {} (attempted to load {})", beanClass, transformerClassName); return null; } } /** * This was originally implemented by {@link info.magnolia.content2bean.impl.PropertiesBasedTypeMapping}. * @deprecated since 4.5, transformers should be explicitly registered via the module descriptor. */ protected Content2BeanTransformer findTransformerViaProperty(Class<?> beanClass) throws ClassNotFoundException { final String property = SystemProperty.getProperty(beanClass.getName() + ".transformer"); if (property != null) { return instantiateTransformer(beanClass, property); } return null; } protected Content2BeanTransformer instantiateTransformer(Class<?> beanClass, String transformerClassName) throws ClassNotFoundException { final ClassFactory classFactory = Classes.getClassFactory(); final Class<Content2BeanTransformer> transformerClass = classFactory.forName(transformerClassName); if (Content2BeanTransformer.class.isAssignableFrom(transformerClass)) { try { log.debug("Found a custom transformer [{" + transformerClass + "}] for [{" + beanClass + "}]"); // TODO use components ? return classFactory.newInstance(transformerClass); } catch (Exception e) { log.error("Can't instantiate custom transformer [{" + transformerClass + "}] for [{" + beanClass + "}]", e); } } return null; } /** * Find a method. * * @param numberOfParameters */ protected Method getExactMethod(Class<?> type, String name, int numberOfParameters) { Method[] methods = type.getMethods(); for (int i = 0; i < methods.length; i++) { Method method = methods[i]; if (method.getName().equals(name)) { // TODO - CAUTION: in case there's several methods with the same name and the same numberOfParameters // this method might pick the "wrong" one. We should think about adding a check and throw an exceptions // if there's more than one match! if (method.getParameterTypes().length == numberOfParameters) { return method; } } } return null; } }