public static final Define makeMethod(String proxyPackage, final Class clazz, final String methodName, Class... parameters) {
        parameters = parameters == null ? new Class[0] : parameters;
        final Method method = Utilities.getMethod(clazz, methodName, parameters);
        if (method == null) {
            throw new RuntimeException("Method[" + methodName + "] was not exist!");
        }
        if (proxyPackage == null || proxyPackage.trim().length() == 0) {
            proxyPackage = Utilities.getProxyPackage();
        }
        final int modifier = method.getModifiers();
        // 拒绝非public方法
        if (!Modifier.isPublic(modifier)) {
            throw new RuntimeException("Method[" + methodName + "] was not a public method!");
        }
        // 被代理类名
        final String className = clazz.getName().replace('.', '/');
        // 代理类名
        final String proxyClassName = Utilities.toProxyClassName(proxyPackage, className);
        // 创建ClassWriter
        final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        // 创建类
        cw.visit(Utilities.VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER,
                proxyClassName, null, Utilities.SUPER, null);
        // 创建默认构造方法
        Utilities.doDefaultConstructor(cw);
        // 创建方法
        final MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_VARARGS,
                "invoke", "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;", null,
                new String[]{"java/lang/Exception"}
        );
        // 非静态方法使用1号位参数作为实例；静态方法使用类名，不占用参数位
        if (!Modifier.isStatic(modifier)) {
            // 调出第一个参数（第一个临时变量），实例
            mv.visitVarInsn(Opcodes.ALOAD, 1);
            Utilities.doClassCast(mv, Type.getType(clazz));
        }
        // 生成参数列表, 实例方法参数列表因1号位被实例占用需增加偏移量1
        final Class[] parameterTypes = method.getParameterTypes();
        final StringBuffer buffer = new StringBuffer(128);
        // 循环构建参数列表，调出第一个临时变量遍历并强制转换
        buffer.append('(');
        for (int i = 0, n = parameterTypes.length; i < n; i++) {
            // 调出第二个参数（第二个临时变量）
            mv.visitVarInsn(Opcodes.ALOAD, 2);
            // 序号压栈
            mv.visitIntInsn(Opcodes.BIPUSH, i);
            // 组合取值
            mv.visitInsn(Opcodes.AALOAD);
            Type paramType = Type.getType(parameterTypes[i]);
            Utilities.doClassCast(mv, paramType);
            // 加入参数描述
            buffer.append(paramType.getDescriptor());
        }
        buffer.append(')');
        // 加入返回值描述
        buffer.append(Type.getDescriptor(method.getReturnType()));

        if (Modifier.isStatic(modifier)) {
            // 调用类方法，使用类调用
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, className, methodName, buffer.toString());
            Utilities.doPackPrimitive(method.getReturnType(), mv);
        } else {
            // 调用实例方法
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, className, methodName, buffer.toString());
            Utilities.doPackPrimitive(method.getReturnType(), mv);
        }
        // 返回结果
        mv.visitInsn(Opcodes.ARETURN);
        mv.visitMaxs(0, 0);
        mv.visitEnd();
        cw.visitEnd();
        final Define define = new Define();
        define.setClassName(className);
        define.setProxyClassName(proxyClassName);
        define.setTargetName(methodName);
        define.setMethod(true);
        define.setRedirect(null);
        define.setReturnType(method.getReturnType());
        define.setBytes(cw.toByteArray());
        return define;
    }