package asm;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.Type;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.LocalVariableNode;
import org.objectweb.asm.tree.MethodNode;

import com.me.WorkServiceImpl;


/**
 * 获取方法参数名字
 */
public class MethodParamNamesScanner {

	/**
	 * 获取方法参数名列表
	 * 
	 * @param clazz
	 * @param m
	 * @return
	 * @throws IOException
	 */
	public static List<String> getMethodParamNames(Class<?> clazz, Method method) throws IOException {
		try (InputStream in = clazz.getResourceAsStream("/" + clazz.getName().replace('.', '/') + ".class")) {
			return getMethodParamNames(in, method);
		}
	}

	public static List<String> getMethodParamNames(InputStream in, Method method) throws IOException {
		try (InputStream ins = in) {
			return getParamNames(ins, new EnclosingMetadata(method.getName(), Type.getMethodDescriptor(method),
					method.getParameterTypes().length));
		}
	}

	/**
	 * 获取构造器参数名列表
	 * 
	 * @param clazz
	 * @param constructor
	 * @return
	 */
	public static List<String> getConstructorParamNames(Class<?> clazz, Constructor<?> constructor) {
		try (InputStream in = clazz.getResourceAsStream("/" + clazz.getName().replace('.', '/') + ".class")) {
			return getConstructorParamNames(in, constructor);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return new ArrayList<String>();
	}

	public static List<String> getConstructorParamNames(InputStream ins, Constructor<?> constructor) {
		try (InputStream in = ins) {
			return getParamNames(
					in,
					new EnclosingMetadata(constructor.getName(), Type.getConstructorDescriptor(constructor), constructor
							.getParameterTypes().length));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		return new ArrayList<String>();
	}

	/**
	 * 获取参数名列表辅助方法
	 * 
	 * @param in
	 * @param m
	 * @return
	 * @throws IOException
	 */
	private static List<String> getParamNames(InputStream in, EnclosingMetadata enclosingMetadata) throws IOException {
		ClassReader classReader = new ClassReader(in);
		ClassNode classNode = new ClassNode();
		classReader.accept(classNode, ClassReader.EXPAND_FRAMES);// 建议EXPAND_FRAMES
		// ASM树接口形式访问
		List<MethodNode> methods = classNode.methods;
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < methods.size(); ++i) {
			List<LocalVariable> varNames = new ArrayList<LocalVariable>();
			MethodNode methodNode = methods.get(i);
			// 验证方法签名
			if (methodNode.desc.equals(enclosingMetadata.desc) && methodNode.name.equals(enclosingMetadata.name)) {
				List<LocalVariableNode> local_variables = methodNode.localVariables;
				for (int k = 0; k < local_variables.size(); k++) {
					String varName = local_variables.get(k).name;
					// index-记录了正确的方法本地变量索引。(方法本地变量顺序可能会被打乱。而index记录了原始的顺序)
					int index = local_variables.get(k).index;
					// 非静态方法,第一个参数是this
					if (!"this".equals(varName)) {
						varNames.add(new LocalVariable(index, varName));
					}
				}
				LocalVariable[] tmpArr = varNames.toArray(new LocalVariable[varNames.size()]);
				// 根据index来重排序，以确保正确的顺序
				Arrays.sort(tmpArr);
				for (int j = 0; j < enclosingMetadata.size; j++) {
					list.add(tmpArr[j].name);
				}
				break;
			}
		}
		return list;
	}

	/**
	 * 方法本地变量索引和参数名封装
	 * 
	 * @author xby Administrator
	 */
	static class LocalVariable implements Comparable<LocalVariable> {
		public int index;
		public String name;

		public LocalVariable(int index, String name) {
			this.index = index;
			this.name = name;
		}

		public int compareTo(LocalVariable o) {
			return this.index - o.index;
		}
	}

	/**
	 * 封装方法描述和参数个数
	 * 
	 * @author xby Administrator
	 */
	static class EnclosingMetadata {
		// method name
		public String name;
		// method description
		public String desc;
		// params size
		public int size;

		public EnclosingMetadata(String name, String desc, int size) {
			this.name = name;
			this.desc = desc;
			this.size = size;
		}
	}

	public static void main(String[] args) throws IOException {
		for (Method m : WorkServiceImpl.class.getDeclaredMethods()) {
			List<String> list = getMethodParamNames(WorkServiceImpl.class, m);
			System.out.println(m.getName() + ":");
			for (String str : list) {
				System.out.println(str);
			}
			System.out.println("------------------------");
		}
	}
}

package asm;
 
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
 
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
 
/**
 * 
 * <p>根据class A生成一个class B extends A</p>
 * <li>重写A及A父类的所有方法，eg. public void xx() {super.xx();}
 * <li>copy A类定义的所有属性
 * 
    1、生成被代理类的子类，并重写所有方法（除java.lang.Object类定义的方法），增加before和after拦截。
	2、重新定义被代理类的所有属性（不包括属性的赋值）。	
	3、把生成的class文件保存到硬盘中。
	4、从内存中加载新生成的class。
 * 
 */
public class ClassAdapter extends ClassVisitor implements Opcodes{
    public static final String INIT = "<init>";
    private ClassWriter classWriter;
    //原始类名字
    private String originalClassName;
    //增强类名字
    private String enhancedClassName;
    //原始类
    private Class<?> originalClass;
 
    
    /**
     * 
    * <p>Title: </p> 
    * <p>Description: </p> 
    * @param enhancedClassName  增强类
    * @param targetClass  目标类
    * @param writer   class写入
     */
	public ClassAdapter(String enhancedClassName, Class<?> targetClass, ClassWriter writer) {
		super(Opcodes.ASM4, writer);
		this.classWriter = writer;
		this.originalClassName = targetClass.getName();
		this.enhancedClassName = enhancedClassName;
		this.originalClass = targetClass;
	}

	@Override
	public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
		cv.visit(version, Opcodes.ACC_PUBLIC, toAsmCls(enhancedClassName), signature, name, interfaces);
	}

	/**
	 * 访问属性
	 */
	@Override
	public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
		// 拷贝所有属性 可使用java反射给属性赋值（生成class后newInstance在赋值）
		return super.visitField(access, name, desc, signature, value);
	}

	@Override
	public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
		// 删除所有方法
		return null;
	}

	/**
	 * 把类名中的.替换为/
	 * 
	 * @param className
	 * @return
	 */
	private static String toAsmCls(String className) {
		return className.replace('.', '/');
	}

	/**
	 * 
	 * <p>
	 * 前置方法
	 * </p>
	 *
	 * @see TxHandler
	 * @param mWriter
	 */
	private static void doBefore(MethodVisitor mWriter, String methodInfo) {
		mWriter.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
		mWriter.visitLdcInsn("before method : " + methodInfo);
		mWriter.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
		// 或者直接调用静态方法
		// mWriter.visitLdcInsn(methodInfo);
		// mWriter.visitMethodInsn(INVOKESTATIC,toAsmCls(TxHandler.class.getName()),"before","(Ljava/lang/String;)V");
	}

	/**
	 * 
	 * <p>
	 * 后置方法
	 * </p>
	 * 
	 * @see TxHandler
	 * @param mWriter
	 */
	private static void doAfter(MethodVisitor mWriter, String methodInfo) {
		mWriter.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
		mWriter.visitLdcInsn("after method : " + methodInfo);
		mWriter.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
	}

	/**
	 * 判断方法是否可以重新覆写
	 * <p>
	 * object类本身的方法不做重写
	 * </p>
	 * <p>
	 * "main" 方法不做重写
	 * </p>
	 * 
	 * @param m
	 * @return
	 */
	public static boolean needOverride(Method method) {
		// object类本身的方法不做重写
		if (method.getDeclaringClass().getName().equals(Object.class.getName())) {
			return false;
		}
		// "main" 方法不做重写
		if (Modifier.isPublic(method.getModifiers()) && Modifier.isStatic(method.getModifiers()) && method.getReturnType().getName().equals("void")
				&& method.getName().equals("main")) {
			return false;
		}
		return true;
	}

	@Override
	public void visitEnd() {
		// 如果originalClass定义了私有成员变量，那么直接在visitMethod中复制originalClass的<init>会报错。
		// ALOAD 0
		// INVOKESPECIAL cc/RoleService.<init>()V
		// RETURN
		// // 调用originalClassName的<init>方法，否则class不能实例化
		MethodVisitor mvInit = classWriter.visitMethod(ACC_PUBLIC, INIT, "()V", null, null);
		mvInit.visitVarInsn(ALOAD, 0);
		mvInit.visitMethodInsn(INVOKESPECIAL, toAsmCls(originalClassName), INIT, "()V");
		mvInit.visitInsn(RETURN);
		mvInit.visitMaxs(0, 0);
		mvInit.visitEnd();

		// 获取所有方法，并重写(main方法 和 Object的方法除外)
		Method[] methods = originalClass.getMethods();
		for (Method m : methods) {
			//不覆写main方法
			if (!needOverride(m)) {
				continue;
			}
			//类型
			Type mt = Type.getType(m);
			StringBuilder methodInfo = new StringBuilder(originalClassName);
			methodInfo.append(".").append(m.getName());
			methodInfo.append("|");

			Class<?>[] paramTypes = m.getParameterTypes();
			//类型名字
			for (Class<?> t : paramTypes) {
				methodInfo.append(t.getName()).append(",");
			}
			if (paramTypes.length > 0) {
				//删除最后一个“,”
				methodInfo.deleteCharAt(methodInfo.length() - 1);
			}
			
			// 方法是被哪个类定义的
			String declaringCls = toAsmCls(m.getDeclaringClass().getName());
			// 方法 description
			MethodVisitor mWriter = classWriter.visitMethod(ACC_PUBLIC, m.getName(), mt.toString(), null, null);
			// insert code here (before)
			doBefore(mWriter, methodInfo.toString());
			int i = 0;
			// 如果不是静态方法 load this对象
			if (!Modifier.isStatic(m.getModifiers())) {
				mWriter.visitVarInsn(ALOAD, i++);
			}
			StringBuilder sb = new StringBuilder(m.getName());
			// load 出方法的所有参数
			for (Class<?> tCls : m.getParameterTypes()) {
				Type t = Type.getType(tCls);
				sb.append(loadCode(t)).append(",");
				mWriter.visitVarInsn(loadCode(t), i++);
				if (t.getSort() == Type.LONG || t.getSort() == Type.DOUBLE) {
					i++;
				}
			}
			// super.xxx();
			mWriter.visitMethodInsn(INVOKESPECIAL, declaringCls, m.getName(), mt.toString());
			// 处理返回值类型
			Type rt = Type.getReturnType(m);
			// 没有返回值
			if (rt.toString().equals("V")) {
				doAfter(mWriter, methodInfo.toString());
				mWriter.visitInsn(RETURN);
			}
			// 把return xxx() 转变成 ： Object o = xxx(); return o;
			else {
				int storeCode = storeCode(rt);
				int loadCode = loadCode(rt);
				int returnCode = rtCode(rt);
				mWriter.visitVarInsn(storeCode, i);
				doAfter(mWriter, methodInfo.toString());
				mWriter.visitVarInsn(loadCode, i);
				mWriter.visitInsn(returnCode);
			}
			// 已设置了自动计算，但还是要调用一下，不然会报错
			mWriter.visitMaxs(i, ++i);
			mWriter.visitEnd();
		}
		cv.visitEnd();
	}

	/**
	 * 
	 * <p>
	 * get StoreCode(Opcodes#xStore)
	 * </p>
	 *
	 *
	 * @param type
	 * @return
	 */
	public static int storeCode(Type type) {
		//排序
		int sort = type.getSort();
		switch (sort) {
		case Type.ARRAY:
			sort = ASTORE;
			break;
		case Type.BOOLEAN:
			sort = ISTORE;
			break;
		case Type.BYTE:
			sort = ISTORE;
			break;
		case Type.CHAR:
			sort = ISTORE;
			break;
		case Type.DOUBLE:
			sort = DSTORE;
			break;
		case Type.FLOAT:
			sort = FSTORE;
			break;
		case Type.INT:
			sort = ISTORE;
			break;
		case Type.LONG:
			sort = LSTORE;
			break;
		case Type.OBJECT:
			sort = ASTORE;
			break;
		case Type.SHORT:
			sort = ISTORE;
			break;
		default:
			break;
		}
		return sort;
	}

	/**
	 * 
	 * <p>
	 * get StoreCode(Opcodes#xLOAD)
	 * </p>
	 *
	 * @param type
	 * @return
	 */
	public static int loadCode(Type type) {
		int sort = type.getSort();
		switch (sort) {
		case Type.ARRAY:
			sort = ALOAD;
			break;
		case Type.BOOLEAN:
			sort = ILOAD;
			break;
		case Type.BYTE:
			sort = ILOAD;
			break;
		case Type.CHAR:
			sort = ILOAD;
			break;
		case Type.DOUBLE:
			sort = DLOAD;
			break;
		case Type.FLOAT:
			sort = FLOAD;
			break;
		case Type.INT:
			sort = ILOAD;
			break;
		case Type.LONG:
			sort = LLOAD;
			break;
		case Type.OBJECT:
			sort = ALOAD;
			break;
		case Type.SHORT:
			sort = ILOAD;
			break;
		default:
			break;
		}
		return sort;
	}

	/**
	 * 
	 * <p>
	 * get StoreCode(Opcodes#xRETURN)
	 * </p>
	 *
	 * @param type
	 * @return
	 */
	public static int rtCode(Type type) {
		int sort = type.getSort();
		switch (sort) {
		case Type.ARRAY:
			sort = ARETURN;
			break;
		case Type.BOOLEAN:
			sort = IRETURN;
			break;
		case Type.BYTE:
			sort = IRETURN;
			break;
		case Type.CHAR:
			sort = IRETURN;
			break;
		case Type.DOUBLE:
			sort = DRETURN;
			break;
		case Type.FLOAT:
			sort = FRETURN;
			break;
		case Type.INT:
			sort = IRETURN;
			break;
		case Type.LONG:
			sort = LRETURN;
			break;
		case Type.OBJECT:
			sort = ARETURN;
			break;
		case Type.SHORT:
			sort = IRETURN;
			break;
		default:
			break;
		}
		return sort;
	}
}

package asm;


/**
 * <p></p>
 */
public class RoleService extends Service{
	private String field1 = "";
	
	public String executeOuter(Integer name) {
		System.out.println("executeOuter call super.query()");
		return query();
	}

	@Override
	public String query() {
		System.out.println("execute (RoleService): query");
		return "query result (RoleService)";
	}

	public String getField1() {
		return field1;
	}

	public void setField1(String field1) {
		this.field1 = field1;
	} 
	
}

/**
 * Service.java 11:59:38 AM Apr 27, 2012
 *
 * Copyright(c) 2000-2012 HC360.COM, All Rights Reserved.
 */
package asm;


/**
 * <p></p>
 * 
 */
public class Service extends Dao{

	@Override
	public void insert(Object o) {
 		super.insert(o);
	}
	
}

/**
 * Dao.java 11:58:24 AM Apr 27, 2012
 *
 * Copyright(c) 2000-2012 HC360.COM, All Rights Reserved.
 */
package asm;
/**
 * <p></p>
 * 
 */
public class Dao {
	public void insert(Object o) {
		System.out.println("insert : " + o);
	}
	
	public String query() {
		System.out.println("execute (Dao): query");
		return "query result (Dao)";
	}
	public String query2() {
		System.out.println("execute (Dao): query2");
		return "query2 result (Dao)";
	}
	
	public int test() {
		System.out.println("execute (Dao) : test");
		return 0;
	}
	
	protected void testProtected() {
		System.out.println("execute (Dao) : testProtected");
		testPrivate();
	}
	
	private void testPrivate() {
		System.out.println("execute (Dao) : testPrivate");
	}
	
	public Dao[] testArray(String[] s,Object o) {
		System.out.println("execute (Dao) : testArray");
		return null;
	}
}

package asm;

import java.io.PrintStream;

public class RoleService$EnhancedByCc extends RoleService
{
  private String field1;

  public String executeOuter(Integer paramInteger)
  {
    System.out.println("before method : asm.RoleService.executeOuter|java.lang.Integer");
    String str = super.executeOuter(paramInteger);
    System.out.println("after method : asm.RoleService.executeOuter|java.lang.Integer");
    return str;
  }

  public String query()
  {
    System.out.println("before method : asm.RoleService.query|");
    String str = super.query();
    System.out.println("after method : asm.RoleService.query|");
    return str;
  }

  public void setField1(String paramString)
  {
    System.out.println("before method : asm.RoleService.setField1|java.lang.String");
    super.setField1(paramString);
    System.out.println("after method : asm.RoleService.setField1|java.lang.String");
  }

  public String getField1()
  {
    System.out.println("before method : asm.RoleService.getField1|");
    String str = super.getField1();
    System.out.println("after method : asm.RoleService.getField1|");
    return str;
  }

  public void insert(Object paramObject)
  {
    System.out.println("before method : asm.RoleService.insert|java.lang.Object");
    super.insert(paramObject);
    System.out.println("after method : asm.RoleService.insert|java.lang.Object");
  }

  public String query2()
  {
    System.out.println("before method : asm.RoleService.query2|");
    String str = super.query2();
    System.out.println("after method : asm.RoleService.query2|");
    return str;
  }

  public int test()
  {
    System.out.println("before method : asm.RoleService.test|");
    int i = super.test();
    System.out.println("after method : asm.RoleService.test|");
    return i;
  }

  public Dao[] testArray(String[] paramArrayOfString, Object paramObject)
  {
    System.out.println("before method : asm.RoleService.testArray|[Ljava.lang.String;,java.lang.Object");
    Dao[] arrayOfDao = super.testArray(paramArrayOfString, paramObject);
    System.out.println("after method : asm.RoleService.testArray|[Ljava.lang.String;,java.lang.Object");
    return arrayOfDao;
  }
}

public class SpringAction1 {
	// 注入对象springDao
	private SpringDao springDao;

	// 一定要写被注入对象的set方法
	public void setSpringDao(SpringDao springDao) {
		this.springDao = springDao;
	}

	public void ok() {
		springDao.ok();
	}
}

package test.spring1;

public class SpringDao {
	public void ok() {
		System.out.println("Spring dao");
	}
}

SpringAction1 springAction1 = (SpringAction1) ContextUtil.getBean("springAction", SpringAction1.class);
springAction1.ok();