import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public PojoInstantiator(Component component, ReflectionOptimizer.InstantiationOptimizer optimizer) {
	this.mappedClass = component.getComponentClass();
	this.isAbstract = ReflectHelper.isAbstractClass( mappedClass );
	this.optimizer = optimizer;

	this.proxyInterface = null;
	this.embeddedIdentifier = false;

	try {
		constructor = ReflectHelper.getDefaultConstructor(mappedClass);
	}
	catch ( PropertyNotFoundException pnfe ) {
		LOG.noDefaultConstructor(mappedClass.getName());
		constructor = null;
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public Query setProperties(Object bean) throws HibernateException {
	Class clazz = bean.getClass();
	String[] params = getNamedParameters();
	for (int i = 0; i < params.length; i++) {
		String namedParam = params[i];
		try {
			Getter getter = ReflectHelper.getGetter( clazz, namedParam );
			Class retType = getter.getReturnType();
			final Object object = getter.get( bean );
			if ( Collection.class.isAssignableFrom( retType ) ) {
				setParameterList( namedParam, ( Collection ) object );
			}
			else if ( retType.isArray() ) {
			 	setParameterList( namedParam, ( Object[] ) object );
			}
			else {
				setParameter( namedParam, object, determineType( namedParam, retType ) );
			}
		}
		catch (PropertyNotFoundException pnfe) {
			// ignore
		}
	}
	return this;
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
/**
 * Retrieve the default (no arg) constructor from the given class.
 *
 * @param clazz The class for which to retrieve the default ctor.
 * @return The default constructor.
 * @throws PropertyNotFoundException Indicates there was not publicly accessible, no-arg constructor (todo : why PropertyNotFoundException???)
 */
public static <T> Constructor<T> getDefaultConstructor(Class<T> clazz) throws PropertyNotFoundException {
	if ( isAbstractClass( clazz ) ) {
		return null;
	}

	try {
		Constructor<T> constructor = clazz.getDeclaredConstructor( NO_PARAM_SIGNATURE );
		constructor.setAccessible( true );
		return constructor;
	}
	catch ( NoSuchMethodException nme ) {
		throw new PropertyNotFoundException(
				"Object class [" + clazz.getName() + "] must declare a default (no-argument) constructor"
		);
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
/**
 * Retrieve a constructor for the given class, with arguments matching the specified Hibernate mapping
 * {@link Type types}.
 *
 * @param clazz The class needing instantiation
 * @param types The types representing the required ctor param signature
 * @return The matching constructor.
 * @throws PropertyNotFoundException Indicates we could not locate an appropriate constructor (todo : again with PropertyNotFoundException???)
 */
public static Constructor getConstructor(Class clazz, Type[] types) throws PropertyNotFoundException {
	final Constructor[] candidates = clazz.getConstructors();
	for ( int i = 0; i < candidates.length; i++ ) {
		final Constructor constructor = candidates[i];
		final Class[] params = constructor.getParameterTypes();
		if ( params.length == types.length ) {
			boolean found = true;
			for ( int j = 0; j < params.length; j++ ) {
				final boolean ok = params[j].isAssignableFrom( types[j].getReturnedClass() ) || (
						types[j] instanceof PrimitiveType &&
								params[j] == ( ( PrimitiveType ) types[j] ).getPrimitiveClass()
				);
				if ( !ok ) {
					found = false;
					break;
				}
			}
			if ( found ) {
				constructor.setAccessible( true );
				return constructor;
			}
		}
	}
	throw new PropertyNotFoundException( "no appropriate constructor in class: " + clazz.getName() );
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public String extractPrimaryKeyValue(){
	//Get pk column and value
	String pkValue = null;
	try{
		pkValue = pc.getIdentifierProperty().getGetter(entity.getClass()).get(entity).toString();
	} catch(PropertyNotFoundException pnfe) {
		logger.info("PropertyNotFoundException " + pnfe.getMessage());
	} catch(MappingException me) {
		logger.info("MappingException " + me.getMessage());
	} catch(HibernateException he) {
		logger.info("HibernateException " + he.getMessage());
	} catch(NullPointerException npe) {
		logger.info("NullPointerException " + npe.getMessage());
	}
	return pkValue;
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
/**
 * Create a "getter" for the named attribute
 */
public Getter getGetter(Class theClass, String propertyName) 
throws PropertyNotFoundException {
	if (nodeName==null) {
		throw new MappingException("no node name for property: " + propertyName);
	}
	if ( ".".equals(nodeName) ) {
		return new TextGetter(propertyType, factory);
	}
	else if ( nodeName.indexOf('/')>-1 ) {
		return new ElementAttributeGetter(nodeName, propertyType, factory);
	}
	else if ( nodeName.indexOf('@')>-1 ) {
		return new AttributeGetter(nodeName, propertyType, factory);
	}
	else {
		return new ElementGetter(nodeName, propertyType, factory);
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
/**
 * Create a "setter" for the named attribute
 */
public Setter getSetter(Class theClass, String propertyName) 
throws PropertyNotFoundException {
	if (nodeName==null) {
		throw new MappingException("no node name for property: " + propertyName);
	}
	if ( ".".equals(nodeName) ) {
		return new TextSetter(propertyType);
	}
	else if ( nodeName.indexOf('/')>-1 ) {
		return new ElementAttributeSetter(nodeName, propertyType);
	}
	else if ( nodeName.indexOf('@')>-1 ) {
		return new AttributeSetter(nodeName, propertyType);
	}
	else {
		return new ElementSetter(nodeName, propertyType);
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public PojoInstantiator(Component component, ReflectionOptimizer.InstantiationOptimizer optimizer) {
	this.mappedClass = component.getComponentClass();
	this.optimizer = optimizer;

	this.proxyInterface = null;
	this.embeddedIdentifier = false;

	try {
		constructor = ReflectHelper.getDefaultConstructor(mappedClass);
	}
	catch ( PropertyNotFoundException pnfe ) {
		log.info(
		        "no default (no-argument) constructor for class: " +
				mappedClass.getName() +
				" (class must be instantiated by Interceptor)"
		);
		constructor = null;
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public static Constructor getDefaultConstructor(Class clazz) throws PropertyNotFoundException {

		if ( isAbstractClass(clazz) ) return null;

		try {
			Constructor constructor = clazz.getDeclaredConstructor(NO_CLASSES);
			if ( !isPublic(clazz, constructor) ) {
				constructor.setAccessible(true);
			}
			return constructor;
		}
		catch (NoSuchMethodException nme) {
			throw new PropertyNotFoundException(
				"Object class " + clazz.getName() +
				" must declare a default (no-argument) constructor"
			);
		}

	}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public static Constructor getConstructor(Class clazz, Type[] types) throws PropertyNotFoundException {
	final Constructor[] candidates = clazz.getConstructors();
	for ( int i=0; i<candidates.length; i++ ) {
		final Constructor constructor = candidates[i];
		final Class[] params = constructor.getParameterTypes();
		if ( params.length==types.length ) {
			boolean found = true;
			for ( int j=0; j<params.length; j++ ) {
				final boolean ok = params[j].isAssignableFrom( types[j].getReturnedClass() ) || (
					types[j] instanceof PrimitiveType &&
					params[j] == ( (PrimitiveType) types[j] ).getPrimitiveClass()
				);
				if (!ok) {
					found = false;
					break;
				}
			}
			if (found) {
				if ( !isPublic(clazz, constructor) ) constructor.setAccessible(true);
				return constructor;
			}
		}
	}
	throw new PropertyNotFoundException( "no appropriate constructor in class: " + clazz.getName() );
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
/**
 * Retrieve the default (no arg) constructor from the given class.
 *
 * @param clazz The class for which to retrieve the default ctor.
 * @return The default constructor.
 * @throws PropertyNotFoundException Indicates there was not publicly accessible, no-arg constructor (todo : why PropertyNotFoundException???)
 */
public static Constructor getDefaultConstructor(Class clazz) throws PropertyNotFoundException {
	if ( isAbstractClass( clazz ) ) {
		return null;
	}

	try {
		Constructor constructor = clazz.getDeclaredConstructor( NO_PARAM_SIGNATURE );
		if ( !isPublic( clazz, constructor ) ) {
			constructor.setAccessible( true );
		}
		return constructor;
	}
	catch ( NoSuchMethodException nme ) {
		throw new PropertyNotFoundException(
				"Object class [" + clazz.getName() + "] must declare a default (no-argument) constructor"
		);
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
@ExceptionHandler(value = 
		{
		Exception.class, 
		NullPointerException.class,
	    NoSuchRequestHandlingMethodException.class, 
	    RuntimeException.class,
	    ResourceAccessException.class,
	    AccessDeniedException.class,
	    PropertyNotFoundException.class,
	    ConstraintViolationException.class,
	    NestedServletException.class}
		)

// Don't pass model object here. Seriously was creating issues here.
   public ModelAndView globalErrorHandler(HttpServletRequest request, Exception e) {
           System.out.println("comes in exception controller");
           ModelAndView mdlViewObj = new ModelAndView("/common/Exception");
           logger.error(e.getStackTrace());
           return mdlViewObj;
           //return new ModelAndView("common/Exception"); // Error java.lang.IllegalStateException: No suitable resolver for argument [0] [type=org.springframework.ui.ModelMap]
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
private static Setter createSetter(Class theClass, String propertyName) throws PropertyNotFoundException {
	BasicSetter 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.PropertyNotFoundException; //导入依赖的package包/类
public static Getter createGetter(Class theClass, String propertyName) throws PropertyNotFoundException {
	BasicGetter result = getGetterOrNull(theClass, propertyName);
	if (result==null) {
		throw new PropertyNotFoundException(
				"Could not find a getter for " +
				propertyName +
				" in class " +
				theClass.getName()
		);
	}
	return result;
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
private static Field getField(Class clazz, String name) throws PropertyNotFoundException {
	if ( clazz==null || clazz==Object.class ) {
		throw new PropertyNotFoundException("field not found: " + name); 
	}
	Field field;
	try {
		field = clazz.getDeclaredField(name);
	}
	catch (NoSuchFieldException nsfe) {
		field = getField( clazz, clazz.getSuperclass(), name );
	}
	field.setAccessible(true);
	return field;
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public Getter getGetter(Class theClass, String propertyName)
		throws PropertyNotFoundException {
	Getter result = null;
	for (int i = 0; i < chain.length; i++) {
		PropertyAccessor candidate = chain[i];
		try {
			result = candidate.getGetter(theClass, propertyName);
			return result;
		} catch (PropertyNotFoundException pnfe) {
			// ignore
		}
	}
	throw new PropertyNotFoundException("Could not find getter for " + propertyName + " on " + theClass);
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public Setter getSetter(Class theClass, String propertyName)
		throws PropertyNotFoundException {
	Setter result = null;
	for (int i = 0; i < chain.length; i++) {
		PropertyAccessor candidate = chain[i];
		try {
			result = candidate.getSetter(theClass, propertyName);
			return result;
		} catch (PropertyNotFoundException pnfe) {
			//
		}
	}
	throw new PropertyNotFoundException("Could not find setter for " + propertyName + " on " + theClass);
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
private static Getter getter(Class clazz, String name) throws MappingException {
	try {
		return BASIC_PROPERTY_ACCESSOR.getGetter( clazz, name );
	}
	catch ( PropertyNotFoundException pnfe ) {
		return DIRECT_PROPERTY_ACCESSOR.getGetter( clazz, name );
	}
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
public int getPropertyIndex(String name) {
	String[] names = getPropertyNames();
	for ( int i = 0, max = names.length; i < max; i++ ) {
		if ( names[i].equals( name ) ) {
			return i;
		}
	}
	throw new PropertyNotFoundException(
			"Unable to locate property named " + name + " on " + getReturnedClass().getName()
	);
}
 

import org.hibernate.PropertyNotFoundException; //导入依赖的package包/类
private static Setter createSetter(Class theClass, String propertyName) 
throws PropertyNotFoundException {
	BasicSetter result = getSetterOrNull(theClass, propertyName);
	if (result==null) {
		throw new PropertyNotFoundException( 
				"Could not find a setter for property " + 
				propertyName + 
				" in class " + 
				theClass.getName() 
			);
	}
	return result;
}