Java Bytecode.addInvokevirtual方法代码示例

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private void addUnwrapper(Bytecode code, Class type) {
	final int index = FactoryHelper.typeIndex( type );
	final String wrapperType = FactoryHelper.wrapperTypes[index];
	// checkcast
	code.addCheckcast( wrapperType );
	// invokevirtual
	code.addInvokevirtual( wrapperType, FactoryHelper.unwarpMethods[index], FactoryHelper.unwrapDesc[index] );
}
 

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private void addGetter(ClassFile classfile, final Method[] getters) throws CannotCompileException {
	ConstPool cp = classfile.getConstPool();
	int target_type_index = cp.addClassInfo( this.targetBean.getName() );
	String desc = GET_SETTER_DESC;
	MethodInfo mi = new MethodInfo( cp, GENERATED_GETTER_NAME, desc );

	Bytecode code = new Bytecode( cp, 6, 4 );
	/* | this | bean | args | raw bean | */
	if ( getters.length >= 0 ) {
		// aload_1 // load bean
		code.addAload( 1 );
		// checkcast // cast bean
		code.addCheckcast( this.targetBean.getName() );
		// astore_3 // store bean
		code.addAstore( 3 );
		for ( int i = 0; i < getters.length; ++i ) {
			if ( getters[i] != null ) {
				Method getter = getters[i];
				// aload_2 // args
				code.addAload( 2 );
				// iconst_i // continue to aastore
				code.addIconst( i ); // growing stack is 1
				Class returnType = getter.getReturnType();
				int typeIndex = -1;
				if ( returnType.isPrimitive() ) {
					typeIndex = FactoryHelper.typeIndex( returnType );
					// new
					code.addNew( FactoryHelper.wrapperTypes[typeIndex] );
					// dup
					code.addOpcode( Opcode.DUP );
				}

				// aload_3 // load the raw bean
				code.addAload( 3 );
				String getter_desc = RuntimeSupport.makeDescriptor( getter );
				String getterName = getter.getName();
				if ( this.targetBean.isInterface() ) {
					// invokeinterface
					code.addInvokeinterface( target_type_index, getterName, getter_desc, 1 );
				}
				else {
					// invokevirtual
					code.addInvokevirtual( target_type_index, getterName, getter_desc );
				}

				if ( typeIndex >= 0 ) {       // is a primitive type
					// invokespecial
					code.addInvokespecial(
							FactoryHelper.wrapperTypes[typeIndex],
					        MethodInfo.nameInit,
					        FactoryHelper.wrapperDesc[typeIndex]
					);
				}

				// aastore // args
				code.add( Opcode.AASTORE );
				code.growStack( -3 );
			}
		}
	}
	// return
	code.addOpcode( Opcode.RETURN );

	mi.setCodeAttribute( code.toCodeAttribute() );
	mi.setAccessFlags( AccessFlag.PUBLIC );
	classfile.addMethod( mi );
}
 

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private void addUnwrapper(
		ClassFile classfile,
        Bytecode code,
        Class type) {
	int index = FactoryHelper.typeIndex( type );
	String wrapperType = FactoryHelper.wrapperTypes[index];
	// checkcast
	code.addCheckcast( wrapperType );
	// invokevirtual
	code.addInvokevirtual( wrapperType, FactoryHelper.unwarpMethods[index], FactoryHelper.unwrapDesc[index] );
}
 

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
/**
 * Replaces retrieval of the array field with the retrieval of its
 * corresponding <em>KoratArray</em> field.
 * 
 * @param cit -
 *            CodeIterator
 * @param idx -
 *            current position in the <code>cit</code>
 * @param cpIdx -
 *            index for the array field in the <code>cPool</code>
 * @throws NotFoundException
 */
private void delegateArrayGetfield(int cpIdx, CodeIterator cit, int idx) {
    try {

        if (!checkArrayType(cpIdx))
            return;

        String fieldName = constPool.getFieldrefName(cpIdx);
        int classIdx = constPool.getFieldrefClass(cpIdx);
        String targetClassName = constPool.getClassInfo(classIdx);

        CtClass targetClz = classPool.get(targetClassName);
        String koratArrayFieldName = InstrumentationManager.getKoratArrayFieldName(fieldName);
        CtClass koratArrayClass = targetClz.getDeclaredField(
                koratArrayFieldName).getType();

        String methodDesc = Descriptor.ofMethod(koratArrayClass,
                new CtClass[0]);

        Bytecode codes = new Bytecode(constPool);
        codes.addInvokevirtual(targetClz,
                InstrumentationManager.getGetterName(koratArrayFieldName),
                methodDesc);

        cit.write(codes.get(), idx);

    } catch (NotFoundException e) {
        throw new RuntimeException(e);
    }
}
 

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
public static CtMethod delegateMethod(CtClass implClass, CtMethod method, CtMethod delegateGetter) throws NotFoundException, CannotCompileException {
    checkArgument(!Modifier.isStatic(method.getModifiers()),
                  "Cannot delegate static method " + method.getLongName());
    checkArgument(!Modifier.isStatic(delegateGetter.getModifiers()),
                  "Delegate getter method " + delegateGetter.getLongName() + " must not be static");
    checkArgument(isSubtype(delegateGetter.getDeclaringClass(), implClass),
                  "Implementation class " + implClass + " does not contain delegate getter method " + delegateGetter.getLongName());
    checkArgument(delegateGetter.getParameterTypes().length == 0,
                  "Delegate getter method " + delegateGetter.getLongName() + " must not take any parameters");
    checkArgument(!delegateGetter.getReturnType().isPrimitive(),
                  "Delegate getter method " + delegateGetter.getLongName() + " must return an object");

    try {
        final CtMethod conflict = implClass.getDeclaredMethod(method.getName(), method.getParameterTypes());
        throw new IllegalArgumentException("Class " + implClass.getName() +
                                           " already contains a method " + conflict.getLongName() +
                                           " that conflicts with the delegated method " + method.getLongName());
    } catch(NotFoundException ignored) {}

    final String name = method.getName();
    final CtClass[] paramTypes = method.getParameterTypes();
    final CtClass returnType = method.getReturnType();
    final MethodInfo info = method.getMethodInfo2(); // Must be read-only
    final String descriptor = info.getDescriptor();
    final CtClass decl = method.getDeclaringClass();

    final Bytecode bc = new Bytecode(implClass.getClassFile().getConstPool());
    int maxStack = 1;
    bc.addAload(0); // push this
    bc.addInvokeinterface(delegateGetter.getDeclaringClass(), delegateGetter.getName(), delegateGetter.getReturnType(), null, 1); // get delegate
    bc.addCheckcast(decl); // make the verifier happy
    maxStack += bc.addLoadParameters(paramTypes, 1); // push all params
    if(decl.isInterface()) { // call the method on delegate
        bc.addInvokeinterface(decl, name, descriptor, 1 + paramTypes.length);
    } else {
        bc.addInvokevirtual(decl, name, descriptor);
    }
    bc.addReturn(returnType); // forward the return value

    bc.setMaxLocals(false, paramTypes, 0);
    bc.setMaxStack(Math.max(2, maxStack)); // return value might be up to 2 stack ops

    final CtMethod delegator = CtNewMethod.copy(method, implClass, null);
    setAccessModifiers(delegator, method.getModifiers());
    setModifier(delegator, Modifier.ABSTRACT, false);
    setModifier(delegator, Modifier.NATIVE, false);
    delegator.getMethodInfo().setCodeAttribute(bc.toCodeAttribute());
    implClass.addMethod(delegator);
    return delegator;
}
 

import javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private void addGetter(ClassFile classfile, final Method[] getters) throws CannotCompileException {
	final ConstPool constPool = classfile.getConstPool();
	final int targetBeanConstPoolIndex = constPool.addClassInfo( this.targetBean.getName() );
	final String desc = GET_SETTER_DESC;
	final MethodInfo getterMethodInfo = new MethodInfo( constPool, GENERATED_GETTER_NAME, desc );

	final Bytecode code = new Bytecode( constPool, 6, 4 );
	/* | this | bean | args | raw bean | */
	if ( getters.length >= 0 ) {
		// aload_1 // load bean
		code.addAload( 1 );
		// checkcast // cast bean
		code.addCheckcast( this.targetBean.getName() );
		// astore_3 // store bean
		code.addAstore( 3 );
		for ( int i = 0; i < getters.length; ++i ) {
			if ( getters[i] != null ) {
				final Method getter = getters[i];
				// aload_2 // args
				code.addAload( 2 );
				// iconst_i // continue to aastore
				// growing stack is 1
				code.addIconst( i );
				final Class returnType = getter.getReturnType();
				int typeIndex = -1;
				if ( returnType.isPrimitive() ) {
					typeIndex = FactoryHelper.typeIndex( returnType );
					// new
					code.addNew( FactoryHelper.wrapperTypes[typeIndex] );
					// dup
					code.addOpcode( Opcode.DUP );
				}

				// aload_3 // load the raw bean
				code.addAload( 3 );
				final String getterSignature = RuntimeSupport.makeDescriptor( getter );
				final String getterName = getter.getName();
				if ( this.targetBean.isInterface() ) {
					// invokeinterface
					code.addInvokeinterface( targetBeanConstPoolIndex, getterName, getterSignature, 1 );
				}
				else {
					// invokevirtual
					code.addInvokevirtual( targetBeanConstPoolIndex, getterName, getterSignature );
				}

				if ( typeIndex >= 0 ) {
					// is a primitive type
					// invokespecial
					code.addInvokespecial(
							FactoryHelper.wrapperTypes[typeIndex],
							MethodInfo.nameInit,
							FactoryHelper.wrapperDesc[typeIndex]
					);
				}

				// aastore // args
				code.add( Opcode.AASTORE );
				code.growStack( -3 );
			}
		}
	}
	// return
	code.addOpcode( Opcode.RETURN );

	getterMethodInfo.setCodeAttribute( code.toCodeAttribute() );
	getterMethodInfo.setAccessFlags( AccessFlag.PUBLIC );
	classfile.addMethod( getterMethodInfo );
}