Java tutorial
/* * Hibernate, Relational Persistence for Idiomatic Java * * License: GNU Lesser General Public License (LGPL), version 2.1 or later. * See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>. */ package org.hibernate.mapping; import java.io.Serializable; import java.util.Iterator; import java.util.StringTokenizer; import org.hibernate.EntityMode; import org.hibernate.HibernateException; import org.hibernate.MappingException; import org.hibernate.PropertyNotFoundException; import org.hibernate.bytecode.enhance.spi.interceptor.EnhancementHelper; import org.hibernate.engine.spi.CascadeStyle; import org.hibernate.engine.spi.CascadeStyles; import org.hibernate.engine.spi.Mapping; import org.hibernate.internal.util.collections.ArrayHelper; import org.hibernate.property.access.spi.Getter; import org.hibernate.property.access.spi.PropertyAccessStrategy; import org.hibernate.property.access.spi.PropertyAccessStrategyResolver; import org.hibernate.property.access.spi.Setter; import org.hibernate.service.ServiceRegistry; import org.hibernate.tuple.ValueGeneration; import org.hibernate.type.CompositeType; import org.hibernate.type.Type; /** * Represents a property as part of an entity or a component. * * @author Gavin King */ public class Property implements Serializable, MetaAttributable { private String name; private Value value; private String cascade; private boolean updateable = true; private boolean insertable = true; private boolean selectable = true; private boolean optimisticLocked = true; private ValueGeneration valueGenerationStrategy; private String propertyAccessorName; private boolean lazy; private String lazyGroup; private boolean optional; private java.util.Map metaAttributes; private PersistentClass persistentClass; private boolean naturalIdentifier; private boolean lob; public boolean isBackRef() { return false; } /** * Does this property represent a synthetic property? A synthetic property is one we create during * metamodel binding to represent a collection of columns but which does not represent a property * physically available on the entity. * * @return True if synthetic; false otherwise. */ public boolean isSynthetic() { return false; } public Type getType() throws MappingException { return value.getType(); } public int getColumnSpan() { return value.getColumnSpan(); } public Iterator getColumnIterator() { return value.getColumnIterator(); } public String getName() { return name; } public boolean isComposite() { return value instanceof Component; } public Value getValue() { return value; } public boolean isPrimitive(Class clazz) { return getGetter(clazz).getReturnType().isPrimitive(); } public CascadeStyle getCascadeStyle() throws MappingException { Type type = value.getType(); if (type.isComponentType()) { return getCompositeCascadeStyle((CompositeType) type, cascade); } else if (type.isCollectionType()) { return getCollectionCascadeStyle(((Collection) value).getElement().getType(), cascade); } else { return getCascadeStyle(cascade); } } private static CascadeStyle getCompositeCascadeStyle(CompositeType compositeType, String cascade) { if (compositeType.isAnyType()) { return getCascadeStyle(cascade); } int length = compositeType.getSubtypes().length; for (int i = 0; i < length; i++) { if (compositeType.getCascadeStyle(i) != CascadeStyles.NONE) { return CascadeStyles.ALL; } } return getCascadeStyle(cascade); } private static CascadeStyle getCollectionCascadeStyle(Type elementType, String cascade) { if (elementType.isComponentType()) { return getCompositeCascadeStyle((CompositeType) elementType, cascade); } else { return getCascadeStyle(cascade); } } private static CascadeStyle getCascadeStyle(String cascade) { if (cascade == null || cascade.equals("none")) { return CascadeStyles.NONE; } else { StringTokenizer tokens = new StringTokenizer(cascade, ", "); CascadeStyle[] styles = new CascadeStyle[tokens.countTokens()]; int i = 0; while (tokens.hasMoreTokens()) { styles[i++] = CascadeStyles.getCascadeStyle(tokens.nextToken()); } return new CascadeStyles.MultipleCascadeStyle(styles); } } public String getCascade() { return cascade; } public void setCascade(String cascade) { this.cascade = cascade; } public void setName(String name) { this.name = name == null ? null : name.intern(); } public void setValue(Value value) { this.value = value; } public boolean isUpdateable() { // if the property mapping consists of all formulas, // make it non-updateable return updateable && !ArrayHelper.isAllFalse(value.getColumnUpdateability()); } public boolean isInsertable() { // if the property mapping consists of all formulas, // make it non-insertable final boolean[] columnInsertability = value.getColumnInsertability(); return insertable && (columnInsertability.length == 0 || !ArrayHelper.isAllFalse(columnInsertability)); } public ValueGeneration getValueGenerationStrategy() { return valueGenerationStrategy; } public void setValueGenerationStrategy(ValueGeneration valueGenerationStrategy) { this.valueGenerationStrategy = valueGenerationStrategy; } public void setUpdateable(boolean mutable) { this.updateable = mutable; } public void setInsertable(boolean insertable) { this.insertable = insertable; } public String getPropertyAccessorName() { return propertyAccessorName; } public void setPropertyAccessorName(String string) { propertyAccessorName = string; } /** * Approximate! */ boolean isNullable() { return value == null || value.isNullable(); } public boolean isBasicPropertyAccessor() { return propertyAccessorName == null || "property".equals(propertyAccessorName); } public java.util.Map getMetaAttributes() { return metaAttributes; } public MetaAttribute getMetaAttribute(String attributeName) { return metaAttributes == null ? null : (MetaAttribute) metaAttributes.get(attributeName); } public void setMetaAttributes(java.util.Map metas) { this.metaAttributes = metas; } public boolean isValid(Mapping mapping) throws MappingException { return getValue().isValid(mapping); } public String toString() { return getClass().getName() + '(' + name + ')'; } public void setLazy(boolean lazy) { this.lazy = lazy; } /** * Is this property lazy in the "bytecode" sense? * * Lazy here means whether we should push *something* to the entity * instance for this field in its "base fetch group". Mainly it affects * whether we should list this property's columns in the SQL select * for the owning entity when we load its "base fetch group". * * The "something" we push varies based on the nature (basic, etc) of * the property. * * @apiNote This form reports whether the property is considered part of the * base fetch group based solely on the mapping information. However, * {@link EnhancementHelper#includeInBaseFetchGroup} is used internally to make that * decision to account for {@link org.hibernate.cfg.AvailableSettings#ALLOW_ENHANCEMENT_AS_PROXY} */ public boolean isLazy() { if (value instanceof ToOne) { // For a many-to-one, this is always false. Whether the // association is EAGER, PROXY or NO-PROXY we want the fk // selected return false; } return lazy; } public String getLazyGroup() { return lazyGroup; } public void setLazyGroup(String lazyGroup) { this.lazyGroup = lazyGroup; } public boolean isOptimisticLocked() { return optimisticLocked; } public void setOptimisticLocked(boolean optimisticLocked) { this.optimisticLocked = optimisticLocked; } public boolean isOptional() { return optional || isNullable(); } public void setOptional(boolean optional) { this.optional = optional; } public PersistentClass getPersistentClass() { return persistentClass; } public void setPersistentClass(PersistentClass persistentClass) { this.persistentClass = persistentClass; } public boolean isSelectable() { return selectable; } public void setSelectable(boolean selectable) { this.selectable = selectable; } public String getAccessorPropertyName(EntityMode mode) { return getName(); } // todo : remove public Getter getGetter(Class clazz) throws PropertyNotFoundException, MappingException { return getPropertyAccessStrategy(clazz).buildPropertyAccess(clazz, name).getGetter(); } // todo : remove public Setter getSetter(Class clazz) throws PropertyNotFoundException, MappingException { return getPropertyAccessStrategy(clazz).buildPropertyAccess(clazz, name).getSetter(); } // todo : remove public PropertyAccessStrategy getPropertyAccessStrategy(Class clazz) throws MappingException { String accessName = getPropertyAccessorName(); if (accessName == null) { if (clazz == null || java.util.Map.class.equals(clazz)) { accessName = "map"; } else { accessName = "property"; } } final EntityMode entityMode = clazz == null || java.util.Map.class.equals(clazz) ? EntityMode.MAP : EntityMode.POJO; return resolveServiceRegistry().getService(PropertyAccessStrategyResolver.class) .resolvePropertyAccessStrategy(clazz, accessName, entityMode); } protected ServiceRegistry resolveServiceRegistry() { if (getPersistentClass() != null) { return getPersistentClass().getServiceRegistry(); } if (getValue() != null) { return getValue().getServiceRegistry(); } throw new HibernateException("Could not resolve ServiceRegistry"); } public boolean isNaturalIdentifier() { return naturalIdentifier; } public void setNaturalIdentifier(boolean naturalIdentifier) { this.naturalIdentifier = naturalIdentifier; } public boolean isLob() { return lob; } public void setLob(boolean lob) { this.lob = lob; } }