反射

一、概述

反射，就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法。

要想这样使用，首先你必须得到class文件对象，其实也就是得到Class类的对象。

Class类：

成员变量 Field

构造方法 Constructor

成员方法 Method

获取class文件对象的方式：

1）Object类的getClass()方法

2）数据类型的静态属性class

3）Class类中的静态方法

public static Class forName(String className)

开发时一般使用Class类中的静态方法获取class文件，因为可以通过把字符串配置到配置文件中灵活的创建不同的类。

二、详解

1.通过反射获取构造方法并使用

获取构造方法的对象

public Constructor[] getConstructors():所有公共构造方法

public Constructor[] getDeclaredConstructors():所有构造方法

public Constructor<T> getConstructor(Class<?>... parameterTypes)：获取单个构造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：获取单个构造方法（含私有）

参数表示的是：要获取的构造方法的构造参数个数及数据类型的class字节码文件对象

获取构造方法对象后，通过方法：T newInstance(Object... initargs)  创建对象。

注意：

在访问私有构造方法时不能直接访问，要设置一下访问权限

方法：void setAccessible(boolean flag) true表示可以直接访问

简单案例

public class ReflectDemo3 {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.Person");


		// 获取私有构造方法对象
		// NoSuchMethodException：每个这个方法异常
		// 原因是一开始我们使用的方法只能获取公共的，下面这种方式就可以了。
		Constructor con = c.getDeclaredConstructor(String.class);


		// 用该私有构造方法创建对象
		// IllegalAccessException:非法的访问异常。
		// 暴力访问
		con.setAccessible(true);// 值为true则指示反射的对象在使用时应该取消Java语言访问检查。
		Object obj = con.newInstance("abc");


		System.out.println(obj);
	}
}

2.通过反射获取成员变量并使用

获取成员变量的对象

Field[] fields = c.getFields();获取所有的公共成员变量

Field[] fields = c.getDeclaredFields();获取所有的成员变量

Field field = c.getField(String name);获取单个成员变量

Field field = c.getDeclaredField(String name);获取单个成员变量(可以为私有)

获取成员变量对象后， 通过方法： void set(Object obj, Object value) 直接对 对象里的成员变量的值进行修改。

注意：

在访问私有构造方法时不能直接访问，要设置一下访问权限

方法：void setAccessible(boolean flag) true表示可以直接访问

简单案例

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/*
 * 通过反射获取成员变量并使用
 */
public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.Person");

		// 获取所有的成员变量
		// Field[] fields = c.getFields();
		// Field[] fields = c.getDeclaredFields();
		// for (Field field : fields) {
		// System.out.println(field);
		// }

		/*
		 * Person p = new Person(); p.address = "北京"; System.out.println(p);
		 */

		// 通过无参构造方法创建对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		System.out.println(obj);

		// 获取单个的成员变量
		// 获取address并对其赋值
		Field addressField = c.getField("address");
		// public void set(Object obj,Object value)
		// 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
		addressField.set(obj, "北京"); // 给obj对象的addressField字段设置值为"北京"
		System.out.println(obj);

		// 获取name并对其赋值
		// NoSuchFieldException
		Field nameField = c.getDeclaredField("name");
		// IllegalAccessException
		nameField.setAccessible(true);
		nameField.set(obj, "林青霞");
		System.out.println(obj);

		// 获取age并对其赋值
		Field ageField = c.getDeclaredField("age");
		ageField.setAccessible(true);
		ageField.set(obj, 27);
		System.out.println(obj);
	}
}

3.通过反射获取成员方法并使用

获取成员方法的对象

Method[] methods = c.getMethods(); 获取自己的包括父亲的公共方法

Method[] methods = c.getDeclaredMethods(); 获取自己的所有的方法

public Method getMethod(String name,Class<?>... parameterTypes); 获取 单个 方法

public Method getDeclaredMethod(String name,Class<?>... parameterTypes);获取单个方法(可以为私有)

获取成员方法对象后，调用方法：public Object invoke(Object obj,Object... args) 

返回值是Object接收,第一个参数表示对象是谁，第二参数表示调用该方法的实际参数

实现方法的执行

注意：

在访问私有构造方法时不能直接访问，要设置一下访问权限

方法：void setAccessible(boolean flag) true表示可以直接访问

简单案例

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class ReflectDemo {
	public static void main(String[] args) throws Exception {
		// 获取字节码文件对象
		Class c = Class.forName("cn.itcast_01.Person");

		// 获取所有的方法
		// Method[] methods = c.getMethods(); // 获取自己的包括父亲的公共方法
		// Method[] methods = c.getDeclaredMethods(); // 获取自己的所有的方法
		// for (Method method : methods) {
		// System.out.println(method);
		// }

		Constructor con = c.getConstructor();
		Object obj = con.newInstance();

		/*
		 * Person p = new Person(); p.show();
		 */

		// 获取单个方法并使用
		// public void show()
		// public Method getMethod(String name,Class<?>... parameterTypes)
		// 第一个参数表示的方法名，第二个参数表示的是方法的参数的class类型
		Method m1 = c.getMethod("show");
		// obj.m1(); // 错误
		// public Object invoke(Object obj,Object... args)
		// 
		m1.invoke(obj); // 调用obj对象的m1方法

		System.out.println("----------");
		// public void method(String s)
		Method m2 = c.getMethod("method", String.class);
		m2.invoke(obj, "hello");
		System.out.println("----------");

		// public String getString(String s, int i)
		Method m3 = c.getMethod("getString", String.class, int.class);
		Object objString = m3.invoke(obj, "hello", 100);
		System.out.println(objString);
		// String s = (String)m3.invoke(obj, "hello",100);
		// System.out.println(s);
		System.out.println("----------");

		// private void function()
		Method m4 = c.getDeclaredMethod("function");
		m4.setAccessible(true);
		m4.invoke(obj);
	}
}

4.动态代理

1）代理概述

代理模式是常用的java设计模式，他的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。 

动态代理：在程序运行时，运用反射机制动态创建而成。

2）动态代理的实现：Proxy与InvocationHandler

A：新建Proxy对象

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)

B：新建对象需要获取ClassLoader,interfaces,InvocationHandler

通过class.getClassLoader()获得ClassLoader

通过class.getInterfaces()获得getInterfaces

InvocationHandler需要自己建立：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
	private Object target; // 目标对象

	public MyInvocationHandler(Object target) {
		this.target = target;
	}

	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("权限校验");
		Object result = method.invoke(target, args);
		System.out.println("日志记录");
		return result; // 返回的是代理对象
	}
}

C：对象新建完成后运行被代理的方法即可

3）案例

public class StudentDaoImpl implements StudentDao {

	@Override
	public void login() {
		System.out.println("登录功能");
	}

	@Override
	public void regist() {
		System.out.println("注册功能");
	}

}

public class UserDaoImpl implements UserDao {

	@Override
	public void add() {
		System.out.println("添加功能");
	}

	@Override
	public void delete() {
		System.out.println("删除功能");
	}

	@Override
	public void update() {
		System.out.println("修改功能");
	}

	@Override
	public void find() {
		System.out.println("查找功能");
	}

}

import java.lang.reflect.Proxy;

public class Test {
	public static void main(String[] args) {
		UserDao ud = new UserDaoImpl();
		ud.add();
		ud.delete();
		ud.update();
		ud.find();
		System.out.println("-----------");
		// 我们要创建一个动态代理对象
		// Proxy类中有一个方法可以创建动态代理对象
		// public static Object newProxyInstance(ClassLoader loader,Class<?>[]
		// interfaces,InvocationHandler h)
		// 我准备对ud对象做一个代理对象
		MyInvocationHandler handler = new MyInvocationHandler(ud);
		UserDao proxy = (UserDao) Proxy.newProxyInstance(ud.getClass()
				.getClassLoader(), ud.getClass().getInterfaces(), handler);
		proxy.add();
		proxy.delete();
		proxy.update();
		proxy.find();
		System.out.println("-----------");

		StudentDao sd = new StudentDaoImpl();
		MyInvocationHandler handler2 = new MyInvocationHandler(sd);
		StudentDao proxy2 = (StudentDao) Proxy.newProxyInstance(sd.getClass()
				.getClassLoader(), sd.getClass().getInterfaces(), handler2);
		proxy2.login();
		proxy2.regist();
	}
}

5.案例

给定ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 * 给定ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据
 */
public class ArrayListDemo {
	public static void main(String[] args) throws NoSuchMethodException,
			SecurityException, IllegalAccessException,
			IllegalArgumentException, InvocationTargetException {
		// 创建集合对象
		ArrayList<Integer> array = new ArrayList<Integer>();

		// array.add("hello");
		// array.add(10);

		Class c = array.getClass(); // 集合ArrayList的class文件对象
		Method m = c.getMethod("add", Object.class);

		m.invoke(array, "hello"); // 调用array的add方法，传入的值是hello
		m.invoke(array, "world");
		m.invoke(array, "java");

		System.out.println(array);
	}
}