import org.springframework.asm.Type; //导入依赖的package包/类
public LazyEntityGenerator(Class<?> entityType) {
	this.writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
	this.emitter = new ClassEmitter(writer);
	this.entityType = entityType;
	this.proxyClassName = entityType.getName() + "$$Hibatis$Lazy";
	this.metadata = EntityMetadata.get(entityType);
	// 开始声明类
	this.beginClass();
	// 加入属性
	addField(Opcodes.ACC_PRIVATE, "$target", Type.getType(Object.class).getDescriptor() , null);
	addField(Opcodes.ACC_PRIVATE, "$source", Type.getType(HibatisEntity.class).getDescriptor() , null);
	addField(Opcodes.ACC_PRIVATE, "$association", Type.getType(AssociationProperty.class).getDescriptor() , null);
	// 重写属性
	this.overrideProperties();
	// 结束声明类
	this.emitter.visitEnd();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void generateGet(Class type, final Map getters) {
    final CodeEmitter e = begin_method(Constants.ACC_PUBLIC, BEAN_MAP_GET, null);
    e.load_arg(0);
    e.checkcast(Type.getType(type));
    e.load_arg(1);
    e.checkcast(Constants.TYPE_STRING);
    EmitUtils.string_switch(e, getNames(getters), Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {
        public void processCase(Object key, Label end) {
            PropertyDescriptor pd = (PropertyDescriptor)getters.get(key);
            MethodInfo method = ReflectUtils.getMethodInfo(pd.getReadMethod());
            e.invoke(method);
            e.box(method.getSignature().getReturnType());
            e.return_value();
        }
        public void processDefault() {
            e.aconst_null();
            e.return_value();
        }
    });
    e.end_method();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void generateGetPropertyType(final Map allProps, String[] allNames) {
    final CodeEmitter e = begin_method(Constants.ACC_PUBLIC, GET_PROPERTY_TYPE, null);
    e.load_arg(0);
    EmitUtils.string_switch(e, allNames, Constants.SWITCH_STYLE_HASH, new ObjectSwitchCallback() {
        public void processCase(Object key, Label end) {
            PropertyDescriptor pd = (PropertyDescriptor)allProps.get(key);
            EmitUtils.load_class(e, Type.getType(pd.getPropertyType()));
            e.return_value();
        }
        public void processDefault() {
            e.aconst_null();
            e.return_value();
        }
    });
    e.end_method();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
public void generateClass(ClassVisitor v) throws Exception {
    int size = props.size();
    String[] names = (String[])props.keySet().toArray(new String[size]);
    Type[] types = new Type[size];
    for (int i = 0; i < size; i++) {
        types[i] = (Type)props.get(names[i]);
    }
    ClassEmitter ce = new ClassEmitter(v);
    ce.begin_class(Constants.V1_6,
                   Constants.ACC_PUBLIC | Constants.ACC_SUPER,
                   getClassName(),
                   superclass != null ? Type.getType(superclass) : Constants.TYPE_OBJECT,
                   null,
                   null);
    EmitUtils.null_constructor(ce);
    EmitUtils.add_properties(ce, names, types);
    ce.end_class();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void generateGet(final Class target, final Method[] getters) {
    CodeEmitter e = begin_method(Constants.ACC_PUBLIC, GET_PROPERTY_VALUES, null);
    if (getters.length >= 0) {
        e.load_arg(0);
        e.checkcast(Type.getType(target));
        Local bean = e.make_local();
        e.store_local(bean);
        for (int i = 0; i < getters.length; i++) {
            if (getters[i] != null) {
                MethodInfo getter = ReflectUtils.getMethodInfo(getters[i]);
                e.load_arg(1);
                e.push(i);
                e.load_local(bean);
                e.invoke(getter);
                e.box(getter.getSignature().getReturnType());
                e.aastore();
            }
        }
    }
    e.return_value();
    e.end_method();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
public void generateClass(ClassVisitor v) throws Exception {
    ClassEmitter ce = new ClassEmitter(v);
    ce.begin_class(Constants.V1_6,
                   Constants.ACC_PUBLIC | Constants.ACC_SUPER | Constants.ACC_INTERFACE,
                   getClassName(),
                   null,
                   null,
                   Constants.SOURCE_FILE);
    for (Iterator it = signatures.keySet().iterator(); it.hasNext();) {
        Signature sig = (Signature)it.next();
        Type[] exceptions = (Type[])signatures.get(sig);
        ce.begin_method(Constants.ACC_PUBLIC | Constants.ACC_ABSTRACT,
                        sig,
                        exceptions).end_method();
    }
    ce.end_class();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void generateConstructor(Object[] arrays) {
    CodeEmitter e = begin_method(Constants.ACC_PUBLIC, CSTRUCT_OBJECT_ARRAY, null);
    e.load_this();
    e.super_invoke_constructor();
    e.load_this();
    e.load_arg(0);
    e.super_putfield("a", Constants.TYPE_OBJECT_ARRAY);
    for (int i = 0; i < arrays.length; i++) {
        Type type = Type.getType(arrays[i].getClass());
        declare_field(Constants.ACC_PRIVATE, getFieldName(i), type, null);
        e.load_this();
        e.load_arg(0);
        e.push(i);
        e.aaload();
        e.checkcast(type);
        e.putfield(getFieldName(i));
    }
    e.return_value();
    e.end_method();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
public void generateClass(ClassVisitor classVisitor) throws Exception {

    ClassEmitter classEmitter = new ClassEmitter(classVisitor);
    classEmitter.begin_class(Constants.V1_5,
            Constants.ACC_PUBLIC,
            makeProxyClassName(),
            Constants.TYPE_OBJECT,
            new Type[] { Type.getType(EventSubscriberProxy.class) },
            null);

    createDelegateField(classEmitter);
    createConstructor(classEmitter);
    createGetEventTypeMethod(classEmitter);
    createIsAsyncMethod(classEmitter);
    createHandleMessageMethod(classEmitter);

    classEmitter.end_class();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void createHandleMessageMethod(ClassEmitter classEmitter) {
    Signature signature = new Signature(
            "handleMessage", Type.VOID_TYPE, new Type[] { MESSAGE_TYPE });
    Signature subscriberMethodSignature = new Signature(
            subscriberInfo.getSubscriberMethodName(),
            Type.VOID_TYPE,
            new Type[] { Type.getType(subscriberInfo.getEventType()) });

    CodeEmitter emitter = classEmitter.begin_method(Constants.ACC_PUBLIC, signature, null);

    emitter.load_this();
    emitter.getfield("delegate");

    emitter.load_arg(0);
    emitter.invoke_interface(MESSAGE_TYPE, GETPAYLOAD_SIGNATURE);
    emitter.checkcast(Type.getType(subscriberInfo.getEventType()));
    emitter.invoke_virtual(Type.getType(subscriberInfo.getBeanClass()), subscriberMethodSignature);
    emitter.return_value();
    emitter.end_method();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
protected ClassGenerator transform(ClassGenerator cg) throws Exception {
	ClassEmitterTransformer transformer = new ClassEmitterTransformer() {
		@Override
		public void end_class() {
			declare_field(Constants.ACC_PUBLIC, BEAN_FACTORY_FIELD, Type.getType(BeanFactory.class), null);
			super.end_class();
		}
	};
	return new TransformingClassGenerator(cg, transformer);
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
public ProxyClassGenerator(Class<?> entityType , boolean overrideProperties) {
	this.writer = new ClassWriter(ClassWriter.COMPUTE_MAXS);
	this.emitter = new ClassEmitter(writer);

	this.entityType = entityType;
	this.proxyClassName = entityType.getName() + "$$Hibatis";
	this.proxyClassPath = proxyClassName.replace(".", "/");
	this.entityClassPath = entityType.getName().replace(".", "/");
	this.metadata = EntityMetadata.get(entityType);
	// 开始声明类
	this.beginClass();
	// 声明字段
	Long serialVersionUID = new Long(proxyClassName.hashCode());
	int access = Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL;
	this.addField(access, "serialVersionUID", "J", serialVersionUID);
	// 加入字段
	this.addField(Opcodes.ACC_PRIVATE, "$propertyChanges", Type.getDescriptor(List.class), null);
	// 加入属性
	this.addProperty("$version", Type.getType(String.class), false, false); // 版本
	this.addProperty("$state", Type.getType(EntityState.class), false, false); // 状态
	this.addProperty("$type", Type.getType(Class.class), false, false); // 类型
	// 重写所有的属性
	if(overrideProperties){
		this.overrideProperties();
	}
	// 结束声明类
	this.emitter.visitEnd();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void beginClass() {
	Type supperType = Type.getType(entityType);
	Type[] interfaceTypes = new Type[] { Type.getType(Serializable.class), Type.getType(HibatisEntity.class) };
	this.emitter.begin_class(Opcodes.V1_5, Opcodes.ACC_PUBLIC, proxyClassName, supperType, interfaceTypes,
			null);
	addConstructor();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private void putNewField(CodeEmitter e, String name, Class<?> realType, Class<?> interfaceType) {
	String realTypePath = realType.getName().replace(".", "/");
	e.visitVarInsn(Opcodes.ALOAD, 0);
	e.visitTypeInsn(Opcodes.NEW, realTypePath);
	e.visitInsn(Opcodes.DUP);
	e.visitMethodInsn(Opcodes.INVOKESPECIAL, realTypePath, "<init>", "()V", false);
	e.visitFieldInsn(Opcodes.PUTFIELD, proxyClassPath, name, Type.getDescriptor(interfaceType));
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
public static String getKey(Method method, Class targetClass) {
    StringBuilder sb = new StringBuilder();
    sb.append(method.getDeclaringClass().getName());
    sb.append('.');
    sb.append(method.getName());
    sb.append(Type.getMethodDescriptor(method));
    if (targetClass != null) {
        sb.append('_');
        sb.append(targetClass.getName());
    }
    return sb.toString();
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
public LocalVariableTableVisitor(Class<?> clazz, Map<Member, String[]> map, String name, String desc, boolean isStatic) {
	super(SpringAsmInfo.ASM_VERSION);
	this.clazz = clazz;
	this.memberMap = map;
	this.name = name;
	this.args = Type.getArgumentTypes(desc);
	this.parameterNames = new String[this.args.length];
	this.isStatic = isStatic;
	this.lvtSlotIndex = computeLvtSlotIndices(isStatic, this.args);
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
private static int[] computeLvtSlotIndices(boolean isStatic, Type[] paramTypes) {
	int[] lvtIndex = new int[paramTypes.length];
	int nextIndex = (isStatic ? 0 : 1);
	for (int i = 0; i < paramTypes.length; i++) {
		lvtIndex[i] = nextIndex;
		if (isWideType(paramTypes[i])) {
			nextIndex += 2;
		}
		else {
			nextIndex++;
		}
	}
	return lvtIndex;
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
	// Skip bridge methods - we're only interested in original annotation-defining user methods.
	// On JDK 8, we'd otherwise run into double detection of the same annotated method...
	if ((access & Opcodes.ACC_BRIDGE) != 0) {
		return super.visitMethod(access, name, desc, signature, exceptions);
	}
	return new MethodMetadataReadingVisitor(name, access, getClassName(),
			Type.getReturnType(desc).getClassName(), this.classLoader, this.methodMetadataSet);
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
public AnnotationVisitor visitAnnotation(final String desc, boolean visible) {
	String className = Type.getType(desc).getClassName();
	this.annotationSet.add(className);
	return new AnnotationAttributesReadingVisitor(
			className, this.attributesMap, this.metaAnnotationMap, this.classLoader);
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
public AnnotationVisitor visitAnnotation(String attributeName, String asmTypeDescriptor) {
	String annotationType = Type.getType(asmTypeDescriptor).getClassName();
	AnnotationAttributes nestedAttributes = new AnnotationAttributes();
	this.attributes.put(attributeName, nestedAttributes);
	return new RecursiveAnnotationAttributesVisitor(annotationType, nestedAttributes, this.classLoader);
}
 

import org.springframework.asm.Type; //导入依赖的package包/类
@Override
public AnnotationVisitor visitAnnotation(String attributeName, String asmTypeDescriptor) {
	String annotationType = Type.getType(asmTypeDescriptor).getClassName();
	AnnotationAttributes nestedAttributes = new AnnotationAttributes();
	this.allNestedAttributes.add(nestedAttributes);
	return new RecursiveAnnotationAttributesVisitor(annotationType, nestedAttributes, this.classLoader);
}