Java tutorial
/* * Copyright (C) 2014-2015 University of Dundee & Open Microscopy Environment. * All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ package ome.services.graphs; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Queue; import java.util.Set; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.commons.beanutils.NestedNullException; import org.apache.commons.beanutils.PropertyUtils; import org.hibernate.engine.SessionFactoryImplementor; import org.hibernate.metadata.ClassMetadata; import org.hibernate.type.AssociationType; import org.hibernate.type.CollectionType; import org.hibernate.type.ComponentType; import org.hibernate.type.Type; import org.springframework.beans.BeanUtils; import org.springframework.context.ApplicationContext; import org.springframework.context.event.ContextRefreshedEvent; import com.google.common.base.Joiner; import com.google.common.collect.HashMultimap; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.google.common.collect.SetMultimap; import ome.model.IObject; import ome.tools.spring.OnContextRefreshedEventListener; /** * The graph path bean holds the Hiberate object mapping and assists navigation thereof. * @author m.t.b.carroll@dundee.ac.uk * @since 5.1.0 */ public class GraphPathBean extends OnContextRefreshedEventListener { private static final Logger log = LoggerFactory.getLogger(GraphPathBean.class); /** * How entities may be <q>unlinked</q> from the value of a property. * @author m.t.b.carroll@dundee.ac.uk * @since 5.1.0 */ static enum PropertyKind { OPTIONAL, REQUIRED, COLLECTION }; /** * A tuple used in initialization to note mapping object properties for processing. * @author m.t.b.carroll@dundee.ac.uk * @since 5.1.0 */ /* private GraphPathReport */ static class PropertyDetails { final String holder; final List<String> path; final Type type; final boolean isNullable; /** * Construct a new property details tuple instance. * @param className the name of the class holding the property * @param path the HQL path by which the property is referenced * @param type the Hibernate type of the property * @param isNullable if the property is nullable */ PropertyDetails(String className, List<String> path, Type type, boolean isNullable) { this.holder = className; this.path = path; this.type = type; this.isNullable = isNullable; } } /* classes indexed by their simple name */ private final Map<String, Class<? extends IObject>> classesBySimpleName = new HashMap<String, Class<? extends IObject>>(); /* direct and indirect superclasses of mapped entities */ private final SetMultimap<String, String> allSuperclasses = HashMultimap.create(); /* direct and indirect subclasses of mapped entities */ private final SetMultimap<String, String> allSubclasses = HashMultimap.create(); /* X -> Y, Z: class X links to class Y with X's property Z */ private final SetMultimap<String, Entry<String, String>> linkedTo = HashMultimap.create(); /* X -> Y, Z: class X is linked to by class Y with Y's property Z */ private final SetMultimap<String, Entry<String, String>> linkedBy = HashMultimap.create(); /* how nullable properties are */ private final HashMap<Entry<String, String>, PropertyKind> propertyKinds = new HashMap<Entry<String, String>, PropertyKind>(); /* which properties are accessible */ private final Set<Entry<String, String>> accessibleProperties = new HashSet<Entry<String, String>>(); /* the identifier properties of classes */ private final Map<String, String> classIdProperties = new HashMap<String, String>(); /* the properties of classes that have simple values */ private final SetMultimap<String, String> simpleProperties = HashMultimap.create(); /** * The application context after refresh should contain a usable Hibernate session factory. * If not already done, process the Hibernate domain object model from that bean. * @param event the context refreshed event bearing the new application context */ @Override public void handleContextRefreshedEvent(ContextRefreshedEvent event) { if (propertyKinds.isEmpty()) { final ApplicationContext context = event.getApplicationContext(); final SessionFactoryImplementor sessionFactory = context.getBean("sessionFactory", SessionFactoryImplementor.class); initialize(sessionFactory); } } /** * If the given property of the given class is actually declared by an interface that it implements, * find the name of the interface that first declares the property. * @param className the name of an {@link IObject} class * @param propertyName the name of a property of the class * @return the interface declaring the property, or {@code null} if none */ private Class<? extends IObject> getInterfaceForProperty(String className, String propertyName) { Class<? extends IObject> interfaceForProperty = null; Set<Class<? extends IObject>> interfacesFrom, interfacesTo; try { interfacesFrom = ImmutableSet .<Class<? extends IObject>>of(Class.forName(className).asSubclass(IObject.class)); } catch (ClassNotFoundException e) { log.error("could not load " + IObject.class.getName() + " subclass " + className); return null; } while (!interfacesFrom.isEmpty()) { interfacesTo = new HashSet<Class<? extends IObject>>(); for (final Class<? extends IObject> interfaceFrom : interfacesFrom) { if (interfaceFrom.isInterface() && BeanUtils.getPropertyDescriptor(interfaceFrom, propertyName) != null) { interfaceForProperty = interfaceFrom; } for (final Class<?> newInterface : interfaceFrom.getInterfaces()) { if (newInterface != IObject.class && IObject.class.isAssignableFrom(newInterface)) { interfacesTo.add(newInterface.asSubclass(IObject.class)); classesBySimpleName.put(newInterface.getSimpleName(), newInterface.asSubclass(IObject.class)); } } } interfacesFrom = interfacesTo; } return interfaceForProperty == null ? null : interfaceForProperty; } /** * @param name the name of an object property * @return if the property should be ignored */ private static boolean ignoreProperty(String name) { return "perm1".equals(name) || name.startsWith("_") || name.endsWith("CountPerOwner"); } /** * Process the Hibernate domain object model to initialize this class' instance fields. * No other method should write to them. * @param sessionFactory the Hibernate session factory */ private void initialize(SessionFactoryImplementor sessionFactory) { /* note all the direct superclasses */ final Map<String, String> superclasses = new HashMap<String, String>(); final Map<String, ClassMetadata> classesMetadata = sessionFactory.getAllClassMetadata(); for (final String className : classesMetadata.keySet()) { try { final Class<?> actualClass = Class.forName(className); if (IObject.class.isAssignableFrom(actualClass)) { classesBySimpleName.put(actualClass.getSimpleName(), actualClass.asSubclass(IObject.class)); final Set<String> subclassNames = sessionFactory.getEntityPersister(className) .getEntityMetamodel().getSubclassEntityNames(); for (final String subclassName : subclassNames) { if (!subclassName.equals(className)) { final Class<?> actualSubclass = Class.forName(subclassName); if (actualSubclass.getSuperclass() == actualClass) { superclasses.put(subclassName, className); } } } } else { log.warn("mapped class " + className + " is not a " + IObject.class.getName()); } } catch (ClassNotFoundException e) { log.error("could not instantiate class", e); } } /* note the indirect superclasses and subclasses */ for (final Entry<String, String> superclassRelationship : superclasses.entrySet()) { final String startClass = superclassRelationship.getKey(); String superclass = superclassRelationship.getValue(); while (superclass != null) { allSuperclasses.put(startClass, superclass); allSubclasses.put(superclass, startClass); superclass = superclasses.get(superclass); } } /* queue for processing all the properties of all the mapped entities: name, type, nullability */ final Queue<PropertyDetails> propertyQueue = new LinkedList<PropertyDetails>(); final Map<String, Set<String>> allPropertyNames = new HashMap<String, Set<String>>(); for (final Entry<String, ClassMetadata> classMetadata : classesMetadata.entrySet()) { final String className = classMetadata.getKey(); final ClassMetadata metadata = classMetadata.getValue(); /* note name of identifier property */ classIdProperties.put(metadata.getEntityName(), metadata.getIdentifierPropertyName()); /* queue other properties */ final String[] propertyNames = metadata.getPropertyNames(); final Type[] propertyTypes = metadata.getPropertyTypes(); final boolean[] propertyNullabilities = metadata.getPropertyNullability(); for (int i = 0; i < propertyNames.length; i++) { final List<String> propertyPath = Collections.singletonList(propertyNames[i]); propertyQueue.add( new PropertyDetails(className, propertyPath, propertyTypes[i], propertyNullabilities[i])); } final Set<String> propertyNamesSet = new HashSet<String>(propertyNames.length); propertyNamesSet.addAll(Arrays.asList(propertyNames)); allPropertyNames.put(className, propertyNamesSet); } /* process each property to note entity linkages */ while (!propertyQueue.isEmpty()) { final PropertyDetails property = propertyQueue.remove(); if (ignoreProperty(property.path.get(property.path.size() - 1))) { continue; } /* if the property has a component type, queue the parts for processing */ if (property.type instanceof ComponentType) { final ComponentType componentType = (ComponentType) property.type; final String[] componentPropertyNames = componentType.getPropertyNames(); final Type[] componentPropertyTypes = componentType.getSubtypes(); final boolean[] componentPropertyNullabilities = componentType.getPropertyNullability(); for (int i = 0; i < componentPropertyNames.length; i++) { final List<String> componentPropertyPath = new ArrayList<String>(property.path.size() + 1); componentPropertyPath.addAll(property.path); componentPropertyPath.add(componentPropertyNames[i]); propertyQueue.add(new PropertyDetails(property.holder, componentPropertyPath, componentPropertyTypes[i], componentPropertyNullabilities[i])); } } else { /* determine if another mapped entity class is linked by this property */ final boolean isAssociatedEntity; if (property.type instanceof CollectionType) { final CollectionType ct = (CollectionType) property.type; isAssociatedEntity = sessionFactory.getCollectionPersister(ct.getRole()).getElementType() .isEntityType(); } else { isAssociatedEntity = property.type instanceof AssociationType; } /* the property can link to entities, so process it further */ String propertyPath = Joiner.on('.').join(property.path); /* find if the property is accessible (e.g., not protected) */ boolean propertyIsAccessible = false; String classToInstantiateName = property.holder; Class<?> classToInstantiate = null; try { classToInstantiate = Class.forName(classToInstantiateName); while (Modifier.isAbstract(classToInstantiate.getModifiers())) { classToInstantiateName = allSubclasses.get(classToInstantiateName).iterator().next(); classToInstantiate = Class.forName(classToInstantiateName); } try { PropertyUtils.getNestedProperty(classToInstantiate.newInstance(), propertyPath); propertyIsAccessible = true; } catch (NoSuchMethodException e) { /* expected for collection properties */ } catch (NestedNullException e) { log.warn("guessing " + propertyPath + " of " + property.holder + " to be accessible"); propertyIsAccessible = true; } } catch (ReflectiveOperationException e) { log.error("could not probe property " + propertyPath + " of " + property.holder, e); continue; } /* build property report line for log */ final char arrowShaft = property.isNullable ? '-' : '='; final StringBuffer sb = new StringBuffer(); sb.append(property.holder); sb.append(' '); for (final String propertyName : property.path) { sb.append(arrowShaft); sb.append(arrowShaft); sb.append(propertyName); } sb.append(arrowShaft); sb.append(arrowShaft); sb.append("> "); final String valueClassName; if (isAssociatedEntity) { valueClassName = ((AssociationType) property.type).getAssociatedEntityName(sessionFactory); sb.append(valueClassName); } else { valueClassName = null; sb.append("value"); } if (property.type.isCollectionType()) { sb.append("[]"); } if (!propertyIsAccessible) { sb.append(" (inaccessible)"); } /* determine from which class the property is inherited, if at all */ String superclassWithProperty = null; String currentClass = property.holder; while (true) { currentClass = superclasses.get(currentClass); if (currentClass == null) { break; } else if (allPropertyNames.get(currentClass).contains(property.path.get(0))) { superclassWithProperty = currentClass; } } /* check if the property actually comes from an interface */ final String declaringClassName = superclassWithProperty == null ? property.holder : superclassWithProperty; final Class<? extends IObject> interfaceForProperty = getInterfaceForProperty(declaringClassName, property.path.get(0)); /* report where the property is declared */ if (superclassWithProperty != null) { sb.append(" from "); sb.append(superclassWithProperty); } else { if (interfaceForProperty != null) { sb.append(" see "); sb.append(interfaceForProperty.getName()); /* It would be nice to set PropertyDetails to have the interface as the holder, * but then properties would not be unique by declarer class and instance ID. */ } /* entity linkages by non-inherited properties are recorded */ if (valueClassName == null && property.path.size() > 1) { /* assume that the top-level property suffices for describing simple properties */ log.debug("recording " + propertyPath + " as " + property.path.get(0)); propertyPath = property.path.get(0); } final Entry<String, String> classPropertyName = Maps.immutableEntry(property.holder, propertyPath); if (valueClassName == null) { simpleProperties.put(property.holder, propertyPath); } else { linkedTo.put(property.holder, Maps.immutableEntry(valueClassName, propertyPath)); linkedBy.put(valueClassName, classPropertyName); } final PropertyKind propertyKind; if (property.type.isCollectionType()) { propertyKind = PropertyKind.COLLECTION; } else if (property.isNullable) { propertyKind = PropertyKind.OPTIONAL; } else { propertyKind = PropertyKind.REQUIRED; } propertyKinds.put(classPropertyName, propertyKind); if (propertyIsAccessible) { accessibleProperties.add(classPropertyName); } } if (log.isDebugEnabled()) { log.debug(sb.toString()); } } } log.info("initialized graph path bean with " + propertyKinds.size() + " properties"); } /** * @param simpleName the simple name of a mapped IObject class * @return the class with that simple name, or {@code null} if one is not known */ public Class<? extends IObject> getClassForSimpleName(String simpleName) { Class<? extends IObject> namedClass = classesBySimpleName.get(simpleName); if (namedClass != null) { return namedClass; } /* may have named a subclass, try guessing */ Class<?> subclass; try { subclass = Class.forName("omero.model." + simpleName); } catch (ClassNotFoundException e) { return null; } while (namedClass == null && subclass != Object.class) { subclass = subclass.getSuperclass(); namedClass = classesBySimpleName.get(subclass.getSimpleName()); } return namedClass; } /** * Get the superclasses of the given class, if any. * @param className the name of a class * @return the class' superclasses, never {@code null} */ public Set<String> getSuperclassesOf(String className) { return allSuperclasses.get(className); } /** * Get the name of this class and of its mapped superclasses. * @param className the name of a class * @return the class and its superclasses, never {@code null} */ public Collection<String> getSuperclassesOfReflexive(String className) { final Collection<String> superclasses = getSuperclassesOf(className); final Collection<String> superclassesReflexive = new ArrayList<String>(superclasses.size() + 1); superclassesReflexive.add(className); superclassesReflexive.addAll(superclasses); return superclassesReflexive; } /** * Get the subclasses of the given class, if any. * @param className the name of a class * @return the class' subclasses, never {@code null} */ public Set<String> getSubclassesOf(String className) { return allSubclasses.get(className); } /** * Get the name of this class and of its mapped subclasses. * @param className the name of a class * @return the class and its subclasses, never {@code null} */ public Collection<String> getSubclassesOfReflexive(String className) { final Collection<String> subclasses = getSubclassesOf(className); final Collection<String> subclassesReflexive = new ArrayList<String>(subclasses.size() + 1); subclassesReflexive.add(className); subclassesReflexive.addAll(subclasses); return subclassesReflexive; } /** * Get the classes and properties to which the given class links. * @param className the name of a class * @return the classes to which the given class links, and by which properties; never {@code null} */ public Set<Entry<String, String>> getLinkedTo(String className) { return linkedTo.get(className); } /** * Get the classes and properties that link to the given class. * @param className the name of a class * @return the classes that link to the given class, and by which properties; never {@code null} */ public Set<Entry<String, String>> getLinkedBy(String className) { return linkedBy.get(className); } /** * Get what kind of property a specific class property is. * @param className the name of a class * @param propertyName the name of a property declared, not just inherited, by that class * @return the kind of property it is */ public PropertyKind getPropertyKind(String className, String propertyName) { return propertyKinds.get(Maps.immutableEntry(className, propertyName)); } /** * Find if the given property can be accessed. * @param className the name of a class * @param propertyName the name of a property declared, not just inherited, by that class * @return if the property can be accessed */ public boolean isPropertyAccessible(String className, String propertyName) { return accessibleProperties.contains(Maps.immutableEntry(className, propertyName)); } /** * Get the identifier property for the given class. * @param className the name of a class * @return the identifier property, or {@code null} if one is not known */ public String getIdentifierProperty(String className) { return classIdProperties.get(className); } /** * Get the <q>simple</q> properties for the given class, not linking to other mapped classes. * @param className the name of a class * @return the <q>simple</q> properties of the given class; never {@code null} */ public Set<String> getSimpleProperties(String className) { return simpleProperties.get(className); } }