Java中反射的理解

关于反射

这是JavaSE中的东西，之前学的不多，随着自己学习的框架的深入，想要理解深入的源码，其中一个重要的知识就是反射。

什么是反射呢

在程序的运行状态下，我们可以获得这个类的所有变量和方法，包括私有变量，并可以对他们进行赋值。在Java中这种动态的获取和设定类的属性和动态调用动态对象的方法的行为成为Java中的反射。

如何使用反射

要想使用反射，必须要做的就是获取Java中的编译的字节码（.class）对象。一般有一下三种获取方式：

//第一种
Class clazz = User.class;
//第二种
Class clazz = user.getClass();
//第三种
Class clazz = Class.forName(beans.User);

通过反射我们能做些什么东西呢？

首先先把实体类对象定义好，以上面的User类为例。

package beans;

/**
 * @Auther: MGL
 * @Date: 2019/5/12 22:04
 * @Description:一个实体类
 */
public class User {

    private String name;
    private int age;
    private String sex;

    public User(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;

        System.out.println("具有参数name，age，sex三个参数的构造器调用了");
    }

    public User(String name){
        this.name = name;
        System.out.println("具有参数name属性的构造器调用了");
    }

    public User(){

    }

    public void sayHello(String content){
        System.out.println(content);
    }

    @Override
    public String toString() {
        return "User:[name = " + name + ",age = " + age + ", sex = " + sex + "]";
    }
}

因为每个测试方法都要用到这个Class对象，为了方便，我把这个Class对象定义为一个静态变量。

 private static  Class<?> userClazz;

    static {
        try {
            userClazz = Class.forName("beans.User");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

1.获取类的构造方法

通过Java字节码对象，获取所有的Constructor对象，然后循环每个构造方法Constructor，通过constructor.getParameterTypes()方法，获取构造方法中的所有参数并输出。

	@Test
    public void test1() {

        Constructor[] constructors = userClazz.getConstructors();

        for (Constructor constructor : constructors
             ) {
            System.out.println("------------------");
            System.out.println("构造器名称：" + constructor.getName());
            Class[] parameterTypes = constructor.getParameterTypes();
            for(int i = 0;i<parameterTypes.length;i++){
                System.out.println(parameterTypes[i].getName() + "   ");
            }
        }
    }

2.通过反射得到相应的构造方法，new出这个类的实例，有参构造和无参构造都可以。

通过Class对象的getConstructor()方法，得到对应的Constructor，方法的参数为构造函数参数的.class。
例如，我的User构造函数有一个为public User(String name,int age,String sex){…},那么getConstructor函数的参数为getConstructor(String.class,int.class,String.class)。得到相应的构造方法Constructor对象后，调用他的newInstance方法，把对应参数写进去，就可以得到一个新的实例。

		@Test
		public void test2() throws  NoSuchMethodException, IllegalAccessException
		, InvocationTargetException, InstantiationException {

	        Constructor constructor = userClazz.getConstructor(String.class,int.class,String.class);
	
	        User user = (User) constructor.newInstance("mgl", 21, "male");
	
	        System.out.println(user);
    }

3.通过反射，获取类的所有属性的值，可以设置相应属性的值

通过字节码对象Class的getDeclaredFields方法，可以得到所有属性的值，包括私有属性的值。通过一个Field类的数组接收。
然后通过for循环，遍历数组中的每一个元素，输出属性的名称。

关于如何设置某个私有变量的值，通过字节码对象的getDeclaredField方法，参数为某个属性的名称，得到对应的属性Field对象。如果是属性为私有的，把它的setAccessible设为true，最后调用field的set方法，方法有两个参数，一个是要设置的属性的对象，一个是那个属性的值。比如我要设置我的User对象的name属性，代码如下：

 	@Test
    public void test3() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
    
        Field[] fields = userClazz.getDeclaredFields();
        for(Field field :fields){
            System.out.println("属性名称为：" + field.getName());
        }

        User user = (User) userClazz.newInstance();
        Field field = userClazz.getDeclaredField("name");
        field.setAccessible(true);
        field.set(user,"mgl");
        System.out.println(user);
    }

4.获取类中所有的Method方法，也可以动态调用对象方法

同getDeclaredFields方法类似，获取字节码对象的方法为getDeclaredMethods，同样打印输出方法的名称，参数类型。

如果要动态调用对象的方法，同样先通过class实例一个对象，通过方法的名称获取对应的方法，最后调用方法的invoke方法。

        Method[] methods = userClazz.getDeclaredMethods();

        for(Method method :methods){
            method.setAccessible(true);
            System.out.println("---------------------");
            System.out.println("方法名称：" + method.getName());

            Class[] parameterClazz = method.getParameterTypes();
            for(int i = 0;i<parameterClazz.length;i++){
                System.out.println("第" + (i+1) + "参数类型为：" + parameterClazz[i].getName());
            }
        }

        /**
         * 获取类中对应的方法，并调用
         */
        System.out.println("--------------------------");
        User user= (User) userClazz.newInstance();

        Method method = userClazz.getMethod("sayHello",String.class);

        method.invoke(user,"哈哈哈");
    }

5.实现简单的动态代理

动态代理，简单来说就是，一个对象本来可以完成这项工作，但是他自己不想去完成，通过一个代理对象来完成这项工作，这就是动态代理。
JDK提供了动态代理的实现，但是JDK只能对接口做代理，可以用cglib来对类做代理。
具体的实现方法：我们需要一个Proxy类和自己定义一个类来实现InvocationHandler接口。

首先给出接口和实现类的代码：

public interface Student {
    void login();
    void submit();
}

class StudentImpl implements Student {
    @Override
    public void login() {
        System.out.println("login...");
    }

    @Override
    public void submit() {
        System.out.println("submit...");
    }
}

自定义MyInvocationHandler类来实现InvocationHandler接口，重写invoke方法。

public class MyInvocationHandler implements InvocationHandler {
    private Object target;

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("调用前");
        method.invoke(target,args);
        System.out.println("调用后");

        return null;
    }
}

在实例化代理对象时，需要调用Proxy类的静态方法newProxyInstance，需要传入三个参数，第一个是被代理对象的类加载器，第二个是被代理对象实现的接口，第三个是InvocationHandler接口的实现类。

	@Test
    public void test5(){
        Student student = new StudentImpl();
        MyInvocationHandler handler = new MyInvocationHandler(student);

        Student proxyStu = (Student) Proxy.newProxyInstance(student.getClass().getClassLoader(),student.getClass().getInterfaces(),handler);
        proxyStu.login();
        proxyStu.submit();;
    }

6.使用反射，还可以对泛型进行一些操作，如将Integer类型的ArrayList中存入String类型的变量。

原理：集合中的泛型只在编译器有效，而到了运行期，泛型则会失效。

	@Test
    public void test6() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(6);

        Class clazz = list.getClass();
        Method method = clazz.getMethod("add",Object.class);
        method.invoke(list,"abc");
        System.out.println(list);
    }

7.借助反射，还可以简化servlet的个数

最开始学习Javaweb的时候，一个servlet只能处理一个get请求和一个post请求。利用反射，我们可以将在一个servlet中处理任意多个post或get请求，即把客户端的不同的请求交给对应不同的Method，而这也正是servlet的service方法在做的事情。所以我们可以自己定义一个BaseServlet继承HttpServlet，重写它的service方法，让别的servlet来继承我们的BaseServlet。
继承自BaseServlet的servlet的写法是，把post或get方法的名称改为你想映射的方法名，返回值改为String，这也是请求servlet之后要返回的地址，函数的参数和doGet，doPost方法一致。
这个是我在看传智博客视频的时候学习的，以前只是会用，现在了解反射后，才明白这个BaseServlet的原理。附上代码。

public class BaseServlet extends HttpServlet {
	@Override
	public void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		response.setContentType("text/html;charset=UTF-8");//处理响应编码
		
		/**
		 * 1. 获取method参数，它是用户想调用的方法 2. 把方法名称变成Method类的实例对象 3. 通过invoke()来调用这个方法
		 */
		String methodName = request.getParameter("method");
		Method method = null;
		/**
		 * 2. 通过方法名称获取Method对象
		 */
		try {
			method = this.getClass().getMethod(methodName,
					HttpServletRequest.class, HttpServletResponse.class);
		} catch (Exception e) {
			throw new RuntimeException("您要调用的方法：" + methodName + "它不存在！", e);
		}
		
		/**
		 * 3. 通过method对象来调用它
		 */
		try {
			String result = (String)method.invoke(this, request, response);
			if(result != null && !result.trim().isEmpty()) {//如果请求处理方法返回不为空
				int index = result.indexOf(":");//获取第一个冒号的位置
				if(index == -1) {//如果没有冒号，使用转发
					request.getRequestDispatcher(result).forward(request, response);
				} else {//如果存在冒号
					String start = result.substring(0, index);//分割出前缀
					String path = result.substring(index + 1);//分割出路径
					if(start.equals("f")) {//前缀为f表示转发
						request.getRequestDispatcher(path).forward(request, response);
					} else if(start.equals("r")) {//前缀为r表示重定向
						response.sendRedirect(request.getContextPath() + path);
					}
				}
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

欢迎大家批评指正！