import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public Object coerce(String property, String source) throws Exception {
    Object[] parameters = new Object[]{source};

    FastConstructor ctor = propertyConstructors.get(property);
    Object value;
    if (ctor != null) {
        value = ctor.newInstance(parameters);
    } else {
        value = Long.parseLong(source);
    }

    return value;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
private Map<String, FastConstructor> createPropertyConstructors(Map<String, Object> propertyTypes) {
    Map<String, FastConstructor> constructors = new HashMap<String, FastConstructor>();

    Class[] parameterTypes = new Class[]{String.class};
    for (String property : propertyTypes.keySet()) {
        log.debug(".createPropertyConstructors property==" + property + ", type==" + propertyTypes.get(property));
        Class clazz = JavaClassHelper.getBoxedType((Class) propertyTypes.get(property));
        FastClass fastClass = FastClass.create(FastClassClassLoaderProviderDefault.INSTANCE.classloader(clazz), clazz);
        FastConstructor constructor = fastClass.getConstructor(parameterTypes);
        constructors.put(property, constructor);
    }
    return constructors;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
private static SelectExprProcessorForge initializeCtorInjection(BeanEventType beanEventType, ExprForge[] forges, Object[] expressionReturnTypes, EngineImportService engineImportService, EventAdapterService eventAdapterService, String statementName)
        throws ExprValidationException {

    Pair<FastConstructor, ExprForge[]> pair = InstanceManufacturerUtil.getManufacturer(beanEventType.getUnderlyingType(), engineImportService, forges, expressionReturnTypes);
    EventBeanManufacturerCtor eventManufacturer = new EventBeanManufacturerCtor(pair.getFirst(), beanEventType, eventAdapterService);
    ExprEvaluator[] evaluators = ExprNodeUtilityRich.getEvaluatorsMayCompile(pair.getSecond(), engineImportService, SelectExprInsertEventBeanFactory.class, false, statementName);
    return new SelectExprInsertNativeNoWiden(beanEventType, eventManufacturer, pair.getSecond(), evaluators);
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public static Object makeUnderlyingFromFastCtor(Object[] properties, FastConstructor ctor, Class target) {
    try {
        return ctor.newInstance(properties);
    } catch (InvocationTargetException e) {
        throw getTargetExceptionAsEPException(target.getName(), e.getTargetException());
    }
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public static InstanceManufacturerFactory getManufacturer(Class targetClass, EngineImportService engineImportService, ExprNode[] childNodes)
        throws ExprValidationException {
    ExprForge[] forgesUnmodified = ExprNodeUtilityCore.getForges(childNodes);
    Object[] returnTypes = new Object[forgesUnmodified.length];
    for (int i = 0; i < forgesUnmodified.length; i++) {
        returnTypes[i] = forgesUnmodified[i].getEvaluationType();
    }

    Pair<FastConstructor, ExprForge[]> ctor = InstanceManufacturerUtil.getManufacturer(targetClass, engineImportService, forgesUnmodified, returnTypes);
    return new InstanceManufacturerFactoryFastCtor(targetClass, ctor.getFirst(), ctor.getSecond());
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public EventBeanManufacturerCtor(FastConstructor fastConstructor, BeanEventType beanEventType, EventAdapterService eventAdapterService) {
    this.fastConstructor = fastConstructor;
    this.beanEventType = beanEventType;
    this.eventAdapterService = eventAdapterService;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public InstanceManufacturerFactoryFastCtor(Class targetClass, FastConstructor ctor, ExprForge[] forges) {
    this.targetClass = targetClass;
    this.ctor = ctor;
    this.forges = forges;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public FastConstructor getCtor() {
    return ctor;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public FastConstructor getFastConstructor()
{
    return fastConstructor;
}
 

import net.sf.cglib.reflect.FastConstructor; //导入依赖的package包/类
public void setFastConstructor(FastConstructor fastConstructor)
{
    this.fastConstructor = fastConstructor;
}