import org.hibernate.property.Setter; //导入依赖的package包/类
private void initialize(String[] aliases) {
	PropertyAccessor propertyAccessor = new ChainedPropertyAccessor(
			new PropertyAccessor[] {
					PropertyAccessorFactory.getPropertyAccessor( resultClass, null ),
					PropertyAccessorFactory.getPropertyAccessor( "field" )
			}
	);
	this.aliases = new String[ aliases.length ];
	setters = new Setter[ aliases.length ];
	for ( int i = 0; i < aliases.length; i++ ) {
		String alias = aliases[ i ];
		if ( alias != null ) {
			this.aliases[ i ] = alias;
			setters[ i ] = propertyAccessor.getSetter( resultClass, alias );
		}
	}
	isInitialized = true;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
@Override
   protected ProxyFactory buildProxyFactory(PersistentClass mappingInfo, Getter idGetter, Setter idSetter) {

	ProxyFactory pf = new MapProxyFactory();
	try {
		//TODO: design new lifecycle for ProxyFactory
		pf.postInstantiate(
				getEntityName(),
				null,
				null,
				null,
				null,
				null
		);
	}
	catch ( HibernateException he ) {
		LOG.unableToCreateProxyFactory( getEntityName(), he );
		pf = null;
	}
	return pf;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
protected AbstractComponentTuplizer(Component component) {
	propertySpan = component.getPropertySpan();
	getters = new Getter[propertySpan];
	setters = new Setter[propertySpan];

	Iterator iter = component.getPropertyIterator();
	boolean foundCustomAccessor=false;
	int i = 0;
	while ( iter.hasNext() ) {
		Property prop = ( Property ) iter.next();
		getters[i] = buildGetter( component, prop );
		setters[i] = buildSetter( component, prop );
		if ( !prop.isBasicPropertyAccessor() ) {
			foundCustomAccessor = true;
		}
		i++;
	}
	hasCustomAccessors = foundCustomAccessor;
	instantiator = buildInstantiator( component );
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
protected ProxyFactory buildProxyFactory(PersistentClass mappingInfo, Getter idGetter, Setter idSetter) {

		ProxyFactory pf = new MapProxyFactory();
		try {
			//TODO: design new lifecycle for ProxyFactory
			pf.postInstantiate(
					getEntityName(),
					null,
					null,
					null,
					null,
					null
			);
		}
		catch ( HibernateException he ) {
			log.warn( "could not create proxy factory for:" + getEntityName(), he );
			pf = null;
		}
		return pf;
	}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
protected ProxyFactory buildProxyFactory(PersistentClass mappingInfo, Getter idGetter, Setter idSetter) {
	HashSet proxyInterfaces = new HashSet();
	proxyInterfaces.add( HibernateProxy.class );
	proxyInterfaces.add( Element.class );

	ProxyFactory pf = new Dom4jProxyFactory();
	try {
		pf.postInstantiate(
				getEntityName(),
				Element.class,
				proxyInterfaces,
				null,
				null,
				mappingInfo.hasEmbeddedIdentifier() ?
		                (AbstractComponentType) mappingInfo.getIdentifier().getType() :
		                null
		);
	}
	catch ( HibernateException he ) {
		log.warn( "could not create proxy factory for:" + getEntityName(), he );
		pf = null;
	}
	return pf;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
public void testCompanyElementGeneration() throws Throwable {
	Setter idSetter = PropertyAccessorFactory.getPropertyAccessor( generateIdProperty(), EntityMode.DOM4J )
			.getSetter( null, null );
	Setter nameSetter = PropertyAccessorFactory.getPropertyAccessor( generateNameProperty(), EntityMode.DOM4J )
			.getSetter( null, null );
	Setter textSetter = PropertyAccessorFactory.getPropertyAccessor( generateTextProperty(), EntityMode.DOM4J )
			.getSetter( null, null );
	Setter accountIdSetter = PropertyAccessorFactory.getPropertyAccessor(
			generateAccountIdProperty(), EntityMode.DOM4J
	)
			.getSetter( null, null );

	Element root = generateRootTestElement();

	idSetter.set( root, new Long( 123 ), getSFI() );
	textSetter.set( root, "description...", getSFI() );
	nameSetter.set( root, "JBoss", getSFI() );
	accountIdSetter.set( root, new Long( 456 ), getSFI() );

	assertTrue( "DOMs not equal", new NodeComparator().compare( DOM, root ) == 0 );
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
public ValueGenerationPlan(
		String propertyName,
		IdentifierGenerator subGenerator,
		Setter injector) {
	this.propertyName = propertyName;
	this.subGenerator = subGenerator;
	this.injector = injector;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
@Override
protected ProxyFactory buildProxyFactory(PersistentClass thePersistentClass, Getter idGetter,
    Setter idSetter) {
  ProxyFactory pf = new MapProxyFactory();
  try {
    pf.postInstantiate(getEntityName(), null, null, null, null, null);
  } catch (final HibernateException he) {
    log.warn("could not create proxy factory for:" + getEntityName(), he);
    pf = null;
  }
  return pf;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
protected AbstractComponentTuplizer(Component component) {
	propertySpan = component.getPropertySpan();
	getters = new Getter[propertySpan];
	setters = new Setter[propertySpan];

	Iterator iter = component.getPropertyIterator();
	boolean foundCustomAccessor=false;
	int i = 0;
	while ( iter.hasNext() ) {
		Property prop = ( Property ) iter.next();
		getters[i] = buildGetter( component, prop );
		setters[i] = buildSetter( component, prop );
		if ( !prop.isBasicPropertyAccessor() ) {
			foundCustomAccessor = true;
		}
		i++;
	}
	hasCustomAccessors = foundCustomAccessor;

	String[] getterNames = new String[propertySpan];
	String[] setterNames = new String[propertySpan];
	Class[] propTypes = new Class[propertySpan];
	for ( int j = 0; j < propertySpan; j++ ) {
		getterNames[j] = getters[j].getMethodName();
		setterNames[j] = setters[j].getMethodName();
		propTypes[j] = getters[j].getReturnType();
	}
	instantiator = buildInstantiator( component );
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
protected ProxyFactory buildProxyFactory(PersistentClass persistentClass, Getter idGetter, Setter idSetter) {
	// allows defining a custom proxy factory, which is responsible for
	// generating lazy proxies for a given entity.
	//
	// Here we simply use the default...
	return super.buildProxyFactory( persistentClass, idGetter, idSetter );
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
@Override
protected ProxyFactory buildProxyFactory(PersistentClass pc, Getter arg1,Setter arg2) {
	CFCHibernateProxyFactory pf = new CFCHibernateProxyFactory();
	pf.postInstantiate(pc);
	
	return pf;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected ProxyFactory buildProxyFactory(PersistentClass persistentClass,
    Getter idGetter, Setter idSetter) {
  fixPropertyAccessors(persistentClass);
  return super.buildProxyFactory(persistentClass, idGetter, idSetter);
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
protected Setter buildPropertySetter(Property mappedProperty,
    PersistentClass mappedEntity) {
  return new EntityPropertyAccessor().getSetter(
      mappedEntity.getMappedClass(), mappedProperty.getName());
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
/**
 * Comunica que se ha cambiado de bean, para que los {@link NestedSetter},
 * creen una nueva instancia en vez de reutilizarla actual.
 */
private void resetNestedSetter() {

	NestedObjectHolder noh = new NestedObjectHolder();
	for (Setter s : setters) {
		if (s instanceof NestedSetter) {
			NestedSetter nSetter = (NestedSetter) s;
			nSetter.setHolder(noh);
		}
	}
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
/**
 * 
 * @param primary
 * @param duplicated
 * @param currentAlias
 */
private void handleDuplicate(Object primary, Object duplicated) {

	for (Setter s : setters) {
		if (s instanceof NestedSetter) {
			NestedSetter ns = (NestedSetter) s;
			ns.join(primary, duplicated);
		}
	}
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
private void initialize(String[] newAlias) {

		PropertyAccessor propertyAccessor = new ChainedPropertyAccessor(
				new PropertyAccessor[] {
						PropertyAccessorFactory.getPropertyAccessor(
								resultClass, null),
						PropertyAccessorFactory.getPropertyAccessor("field") });
		this.aliases = new String[newAlias.length];
		setters = new Setter[newAlias.length];
		for (int i = 0; i < newAlias.length; i++) {
			String alias = newAlias[i];
			if (alias != null) {
				this.aliases[i] = alias;
				// Diferencia con AliasToBeanResultTransformer

				if (alias.indexOf('.') > 0) {
					// found nested
					setters[i] = new NestedSetter(resultClass, alias);
				} else {

					// -------------------------------------------
					setters[i] = propertyAccessor.getSetter(resultClass, alias);
					// Diferencia con AliasToBeanResultTransformer
				}
				// -------------------------------------------
			}
		}
		isInitialized = true;
	}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
@Override
protected Setter buildPropertySetter(Property mappedProperty, PersistentClass mappedEntity) {
    if (!"property".equals(mappedProperty.getPropertyAccessorName())) {
        mappedProperty.setPropertyAccessorName(OptionAwareDirectPropertyAccessor.class.getName());
    }
    return super.buildPropertySetter(mappedProperty, mappedEntity);
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
@Override
public Setter getSetter(final Class theClass, final String propertyName) throws PropertyNotFoundException {
    final Field field = find(OptionAwareDirectPropertyAccessor_.fieldName.andThen(equalTo(propertyName)), fields(theClass)).get();
    final boolean isOption = Option.class.isAssignableFrom(field.getType());
    return new Setter() {
        @Override
        public void set(Object target, Object value, SessionFactoryImplementor factory) throws HibernateException {
            try {
                field.setAccessible(true);
                field.set(target, isOption ? Option.of(value) : value);
            }
            catch (Exception e) {
                throw new PropertyAccessException(e, "could not set a field value by reflection", true, theClass, propertyName);
            }
        }

        @Override
        public String getMethodName() {
            return null;
        }

        @Override
        public Method getMethod() {
            return null;
        }
    };
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
/**
 * @param theClass Target class in which the value is to be set
 * @param propertyName Target property name
 * @return returns Setter class instance
 */
private static Setter createSetter(Class theClass, String propertyName) {
    CollectionPropertySetter result  =  getSetterOrNull(theClass, propertyName);
    if (result == null) {
        throw new PropertyNotFoundException(
                "Could not find a setter for property "  
                + propertyName 
                + " in class " 
                + theClass.getName());
    }
    return result;
}
 

import org.hibernate.property.Setter; //导入依赖的package包/类
private Setter injector(Property property, Class attributeDeclarer) {
	return property.getPropertyAccessor( attributeDeclarer )
			.getSetter( attributeDeclarer, property.getName() );
}