java反射复习（二）

用反射机制调用对象的方法

	Class<?> classType = A.class;
		try {
			// Object aa = classType.newInstance();
	
      Object a = classType.getConstructor(new
         Class[]{}).newInstance(new Object[]{});
        //获取InvokeTester类的add()方法
        Method addMethod = classType.getMethod("add", new Class[]{int.class});
        //调用invokeTester对象上的add()方法
        Object result;
			result = addMethod.invoke(a, new Object[]{new Integer(100)});
		
        System.out.println((Integer) result);
        //获取InvokeTester类的echo()方法
        Method echoMethod = classType.getMethod("echo", new Class[]{String.class});
        //调用invokeTester对象的echo()方法
        result = echoMethod.invoke(a, new Object[]{"Hello"});
        System.out.println((String) result);

动态创建和访问数组

  

 	Class<?> classType = Class.forName("java.lang.String");
        // 创建一个长度为10的字符串数组
        Object array = Array.newInstance(classType, 10);
        // 把索引位置为5的元素设为"hello"
        Array.set(array, 5, "hello");
        Array.set(array, 6, "world");
        // 获得索引位置为5的元素的值
        String s = (String) Array.get(array, 5);
        System.out.println(s);

   	int[] dims = new int[]{5, 10, 15};
	        //创建一个具有指定的组件类型和维度的新数组。
	  Object array = Array.newInstance(Integer.TYPE, dims);   
	  Object arrayObj = Array.get(array, 3);
	  Class<?> cls = arrayObj.getClass().getComponentType();
	  System.out.println(cls);
	  arrayObj = Array.get(arrayObj, 5);
	  Array.setInt(arrayObj, 10, 37);
	  int arrayCast[][][] = (int[][][]) array;
	  System.out.println(arrayCast[3][5][10]);

自动去代理执行被代理对象

 

class B implements InvocationHandler {
	/**
	 * 
	 * 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
	 */
	private Object delegate;

	/** */
	/**
	 * 动态生成方法被处理过后的对象 (写法固定)
	 * 
	 * @param delegate
	 * @param proxy
	 * @return
	 */
	public Object bind(Object delegate) {
		this.delegate = delegate;
		return Proxy.newProxyInstance(
				this.delegate.getClass().getClassLoader(), this.delegate
						.getClass().getInterfaces(), this);
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object result = null;
		try {
			// 执行原来的方法之前记录日志
			logging(method.getName() + " Method end .");
			// JVM通过这条语句执行原来的方法(反射机制)
			result = method.invoke(this.delegate, args);
			// 执行原来的方法之后记录日志
			logging( method.getName() + " Method Start!");
		} catch (Exception e) {
			e.printStackTrace();
		}
		// 返回方法返回值给调用者
		return result;
	}
	
	public void logging(String msg){
		System.out.println(msg);
	}

}

代理调用代码

	    A a = new A(); 
	     B b =new B();
	     b.bind(a);
		try {
			Method addMethod = A.class.getMethod("add", new Class[]{int.class});
	        b.invoke(null, addMethod, new Object[]{new Integer(10)});
		
		} catch (Throwable e) {
			e.printStackTrace();
		}

  Java语言反射提供一种动态链接程序组件的多功能方法。它允许程序创建和控制任何类的对象(根据安全性限制)，无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如，反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。
反射有两个缺点。第一个是性能问题。当用于字段和方法接入时反射要远慢于直接代码。性能问题的程度取决于程序中是如何使用反射的。如果它作为程序运行中相对很少涉及的部分，缓慢的性能将不会是一个问题。即使测试中最坏情况下的计时图显示的反射操作只耗用几微秒。仅反射在性能关键的应用的核心逻辑中使用时性能问题才变得至关重要。
许多应用更严重的一个缺点是使用反射会模糊程序内部实际要发生的事情。程序人员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来维护问题。反射代码比相应的直接代码更复杂，正如性能比较的代码实例中看到的一样。解决这些问题的最佳方案是保守地使用反射-- 仅在它可以真正增加灵活性的地方。