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.Content; import info.magnolia.cms.util.ContentUtil; import info.magnolia.cms.util.SystemContentWrapper; import info.magnolia.content2bean.Content2BeanException; import info.magnolia.content2bean.Content2BeanTransformer; import info.magnolia.content2bean.PropertyTypeDescriptor; import info.magnolia.content2bean.TransformationState; import info.magnolia.content2bean.TypeDescriptor; import info.magnolia.content2bean.TypeMapping; import info.magnolia.objectfactory.Classes; import info.magnolia.objectfactory.ComponentProvider; import java.lang.reflect.Method; import java.util.Collection; import java.util.Iterator; import java.util.LinkedHashMap; import java.util.Locale; import java.util.Map; import javax.inject.Inject; import javax.inject.Singleton; import javax.jcr.RepositoryException; import org.apache.commons.beanutils.BeanUtilsBean; import org.apache.commons.beanutils.MethodUtils; import org.apache.commons.beanutils.PropertyUtils; import org.apache.commons.beanutils.PropertyUtilsBean; import org.apache.commons.lang.LocaleUtils; import org.apache.commons.lang.StringUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * Concrete implementation using reflection and adder methods. * * @author philipp * @version $Id$ */ @Singleton public class Content2BeanTransformerImpl implements Content2BeanTransformer, Content.ContentFilter { private static final Logger log = LoggerFactory.getLogger(Content2BeanTransformerImpl.class); private final BeanUtilsBean beanUtilsBean; /** * @deprecated should not be needed since we pass it around now... or will we ? ... TODO MAGNOLIA-3525 */ @Inject private TypeMapping typeMapping; public Content2BeanTransformerImpl() { super(); // We use non-static BeanUtils conversion, so we can // * use our custom ConvertUtilsBean // * control converters (convertUtilsBean.register()) - we can register them here, locally, as opposed to a // global ConvertUtils.register() final EnumAwareConvertUtilsBean convertUtilsBean = new EnumAwareConvertUtilsBean(); // de-register the converter for Class, we do our own conversion in convertPropertyValue() convertUtilsBean.deregister(Class.class); this.beanUtilsBean = new BeanUtilsBean(convertUtilsBean, new PropertyUtilsBean()); } @Override @Deprecated public TypeDescriptor resolveType(TransformationState state) throws ClassNotFoundException { throw new UnsupportedOperationException(); } /** * Resolves the <code>TypeDescriptor</code> from current transformation state. Resolving happens in the following * order: * <ul> * <li>checks the class property of the current node * <li>calls onResolve subclasses should override * <li>reflection on the parent bean * <li>in case of a collection/map type call getClassForCollectionProperty * <li>otherwise use a Map * </ul> */ @Override public TypeDescriptor resolveType(TypeMapping typeMapping, TransformationState state, ComponentProvider componentProvider) throws ClassNotFoundException { TypeDescriptor typeDscr = null; Content node = state.getCurrentContent(); try { if (node.hasNodeData("class")) { String className = node.getNodeData("class").getString(); if (StringUtils.isBlank(className)) { throw new ClassNotFoundException("(no value for class property)"); } Class<?> clazz = Classes.getClassFactory().forName(className); typeDscr = typeMapping.getTypeDescriptor(clazz); } } catch (RepositoryException e) { // ignore log.warn("can't read class property", e); } if (typeDscr == null && state.getLevel() > 1) { TypeDescriptor parentTypeDscr = state.getCurrentType(); PropertyTypeDescriptor propDscr; if (parentTypeDscr.isMap() || parentTypeDscr.isCollection()) { if (state.getLevel() > 2) { // this is not necessarily the parent node of the current String mapProperyName = state.peekContent(1).getName(); propDscr = state.peekType(1).getPropertyTypeDescriptor(mapProperyName, typeMapping); if (propDscr != null) { typeDscr = propDscr.getCollectionEntryType(); } } } else { propDscr = state.getCurrentType().getPropertyTypeDescriptor(node.getName(), typeMapping); if (propDscr != null) { typeDscr = propDscr.getType(); } } } typeDscr = onResolveType(typeMapping, state, typeDscr, componentProvider); if (typeDscr != null) { // might be that the factory util defines a default implementation for interfaces final Class<?> type = typeDscr.getType(); typeDscr = typeMapping.getTypeDescriptor(componentProvider.getImplementation(type)); // now that we know the property type we should delegate to the custom transformer if any defined Content2BeanTransformer customTransformer = typeDscr.getTransformer(); if (customTransformer != null && customTransformer != this) { TypeDescriptor typeFoundByCustomTransformer = customTransformer.resolveType(typeMapping, state, componentProvider); // if no specific type has been provided by the // TODO - is this comparison working ? if (typeFoundByCustomTransformer != TypeMapping.MAP_TYPE) { // might be that the factory util defines a default implementation for interfaces Class<?> implementation = componentProvider .getImplementation(typeFoundByCustomTransformer.getType()); typeDscr = typeMapping.getTypeDescriptor(implementation); } } } if (typeDscr == null || typeDscr.needsDefaultMapping()) { if (typeDscr == null) { log.debug("was not able to resolve type for node [{}] will use a map", node); } typeDscr = TypeMapping.MAP_TYPE; } log.debug("{} --> {}", node.getHandle(), typeDscr.getType()); return typeDscr; } /** * Called once the type should have been resolved. The resolvedType might be null if no type has been resolved. * After the call the FactoryUtil and custom transformers are used to get the final type. TODO - check javadoc */ protected TypeDescriptor onResolveType(TypeMapping typeMapping, TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) { return resolvedType; } /** * @deprecated since 4.5, use {@link #onResolveType(info.magnolia.content2bean.TypeMapping, info.magnolia.content2bean.TransformationState, info.magnolia.content2bean.TypeDescriptor, info.magnolia.objectfactory.ComponentProvider)} */ protected TypeDescriptor onResolveType(TransformationState state, TypeDescriptor resolvedType, ComponentProvider componentProvider) { return onResolveType(getTypeMapping(), state, resolvedType, componentProvider); } @Override public Collection<Content> getChildren(Content node) { return node.getChildren(this); } /** * Process all nodes except MetaData and nodes with names prefixed by "jcr:". */ @Override public boolean accept(Content content) { return ContentUtil.EXCLUDE_META_DATA_CONTENT_FILTER.accept(content); } @Override public void setProperty(TransformationState state, PropertyTypeDescriptor descriptor, Map<String, Object> values) { throw new UnsupportedOperationException(); } /** * Do not set class property. In case of a map/collection try to use adder method. */ @Override public void setProperty(TypeMapping mapping, TransformationState state, PropertyTypeDescriptor descriptor, Map<String, Object> values) { String propertyName = descriptor.getName(); if (propertyName.equals("class")) { return; } Object value = values.get(propertyName); Object bean = state.getCurrentBean(); if (propertyName.equals("content") && value == null) { value = new SystemContentWrapper(state.getCurrentContent()); } else if (propertyName.equals("name") && value == null) { value = state.getCurrentContent().getName(); } else if (propertyName.equals("className") && value == null) { value = values.get("class"); } // do no try to set a bean-property that has no corresponding node-property // else if (!values.containsKey(propertyName)) { if (value == null) { return; } log.debug("try to set {}.{} with value {}", new Object[] { bean, propertyName, value }); // if the parent bean is a map, we can't guess the types. if (!(bean instanceof Map)) { try { PropertyTypeDescriptor dscr = mapping.getPropertyTypeDescriptor(bean.getClass(), propertyName); if (dscr.getType() != null) { // try to use an adder method for a Collection property of the bean if (dscr.isCollection() || dscr.isMap()) { log.debug("{} is of type collection, map or /array", propertyName); Method method = dscr.getAddMethod(); if (method != null) { log.debug("clearing the current content of the collection/map"); try { Object col = PropertyUtils.getProperty(bean, propertyName); if (col != null) { MethodUtils.invokeExactMethod(col, "clear", new Object[] {}); } } catch (Exception e) { log.debug("no clear method found on collection {}", propertyName); } Class<?> entryClass = dscr.getCollectionEntryType().getType(); log.debug("will add values by using adder method {}", method.getName()); for (Iterator<Object> iter = ((Map<Object, Object>) value).keySet().iterator(); iter .hasNext();) { Object key = iter.next(); Object entryValue = ((Map<Object, Object>) value).get(key); entryValue = convertPropertyValue(entryClass, entryValue); if (entryClass.isAssignableFrom(entryValue.getClass())) { if (dscr.isCollection()) { log.debug("will add value {}", entryValue); method.invoke(bean, new Object[] { entryValue }); } // is a map else { log.debug("will add key {} with value {}", key, entryValue); method.invoke(bean, new Object[] { key, entryValue }); } } } return; } log.debug("no add method found for property {}", propertyName); if (dscr.isCollection()) { log.debug("transform the values to a collection", propertyName); value = ((Map<Object, Object>) value).values(); } } else { value = convertPropertyValue(dscr.getType().getType(), value); } } } catch (Exception e) { // do it better log.error("Can't set property [{}] to value [{}] in bean [{}] for node {} due to {}", new Object[] { propertyName, value, bean.getClass().getName(), state.getCurrentContent().getHandle(), e.toString() }); log.debug("stacktrace", e); } } try { // This uses the converters registered in beanUtilsBean.convertUtilsBean (see constructor of this class) // If a converter is registered, beanutils will convert value.toString(), not the value object as-is. // If no converter is registered, then the value Object is set as-is. // If convertPropertyValue() already converted this value, you'll probably want to unregister the beanutils // converter. // some conversions like string to class. Performance of PropertyUtils.setProperty() would be better beanUtilsBean.setProperty(bean, propertyName, value); // TODO this also does things we probably don't want/need, i.e nested and indexed properties } catch (Exception e) { // do it better log.error("Can't set property [{}] to value [{}] in bean [{}] for node {} due to {}", new Object[] { propertyName, value, bean.getClass().getName(), state.getCurrentContent().getHandle(), e.toString() }); log.debug("stacktrace", e); } } /** * Most of the conversion is done by the BeanUtils. TODO don't use bean utils conversion since it can't be used for * the adder methods */ @Override public Object convertPropertyValue(Class<?> propertyType, Object value) throws Content2BeanException { if (Class.class.equals(propertyType)) { try { return Classes.getClassFactory().forName(value.toString()); } catch (ClassNotFoundException e) { log.error(e.getMessage()); throw new Content2BeanException(e); } } if (Locale.class.equals(propertyType)) { if (value instanceof String) { String localeStr = (String) value; if (StringUtils.isNotEmpty(localeStr)) { return LocaleUtils.toLocale(localeStr); } } } if (Collection.class.equals(propertyType) && value instanceof Map) { // TODO never used ? return ((Map) value).values(); } // this is mainly the case when we are flattening node hierarchies if (String.class.equals(propertyType) && value instanceof Map && ((Map) value).size() == 1) { return ((Map) value).values().iterator().next(); } return value; } /** * Use the factory util to instantiate. This is useful to get default implementation of interfaces */ @Override public Object newBeanInstance(TransformationState state, Map properties, ComponentProvider componentProvider) throws Content2BeanException { // we try first to use conversion (Map --> primitive type) // this is the case when we flattening the hierarchy? final Object bean = convertPropertyValue(state.getCurrentType().getType(), properties); // were the properties transformed? if (bean == properties) { try { // TODO MAGNOLIA-2569 MAGNOLIA-3525 what is going on here ? (added the following if to avoid permanently // requesting LinkedHashMaps to ComponentFactory) final Class<?> type = state.getCurrentType().getType(); if (LinkedHashMap.class.equals(type)) { // TODO - as far as I can tell, "bean" and "properties" are already the same instance of a // LinkedHashMap, so what are we doing in here ? return new LinkedHashMap(); } else if (Map.class.isAssignableFrom(type)) { // TODO ? log.warn("someone wants another type of map ? " + type); } return componentProvider.newInstance(type); } catch (Throwable e) { throw new Content2BeanException(e); } } return bean; } /** * Initializes bean by calling its init method if present. */ @Override public void initBean(TransformationState state, Map properties) throws Content2BeanException { Object bean = state.getCurrentBean(); Method init; try { init = bean.getClass().getMethod("init", new Class[] {}); try { init.invoke(bean); // no parameters } catch (Exception e) { throw new Content2BeanException("can't call init method", e); } } catch (SecurityException e) { return; } catch (NoSuchMethodException e) { return; } log.debug("{} is initialized", bean); } @Override public TransformationState newState() { return new TransformationStateImpl(); // TODO - do we really need different impls for TransformationState ? // if so, this was defined in mgnl-beans.properties // Components.getComponentProvider().newInstance(TransformationState.class); } /** * Returns the default mapping. * * @deprecated since 4.5, do not use. */ @Override public TypeMapping getTypeMapping() { return typeMapping;// TypeMapping.Factory.getDefaultMapping(); } }