Java中反射的理解

关于反射

这是中间的东西，我之前没学多少，随着我学习框架的深入，想要深入了解源码，其中一个重要的知识就是反射。

什么是反射？

在程序的运行状态下，我们可以获取这个类的所有变量和方法，包括私有变量，并赋值。在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字节码对象，获取所有对象，然后循环遍历每个构造函数，通过.()方法，获取构造函数中的所有参数并输出。

	@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.通过反射得到对应的构造方法，构造这个类的新实例可以带参数也可以不带参数。

通过Class对象的()方法，得到对应的方法。方法的参数是构造函数参数的.class。

比如我的User构造函数有一个User(name,int age,sex){…}，那么函数的参数就是(.class,int.class,.class)。得到对应的构造函数对象后，调用其方法并写入对应的参数java field对象set方法，得到一个新的实例。

		@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的方法，可以获取所有属性的值，包括私有属性的值。通过Field类的数组接收。

然后通过for循环，遍历数组中的每个元素，输出属性名。

关于如何设置私有变量的值，通过字节码对象的方法，参数是一个属性的名称，得到对应的属性Field对象。如果属性是私有的，设置为true，最后调用字段的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[] 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类和一个自己定义的类来实现接口。

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

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...");
    }
}

实现接口和覆盖方法的自定义类。

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类的静态方法，需要传入三个参数，第一个是代理对象的类加载器，第二个是代理实现的接口对象，第三个One是接口的实现类。

	@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.使用反射，还可以对泛型进行一些操作java field对象set方法，比如将类型变量存入类型变量中。

原理：集合中的泛型类型只在编译器中有效，在运行时，泛型类型会失效。

	@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.借助反射，也可以化简数

刚开始学习，只能处理一个get请求和一个post请求。使用反射，我们可以一次处理任意数量的 post 或 get 请求，即将来自客户端的不同请求交给不同的请求，这正是该方法所做的。所以我们可以自己定义一个继承，重写它的方法，让别人继承我们的。

继承自is，把post或者get方法的名字改成你要映射的方法名，把返回值改成，也就是请求后要返回的地址，函数的参数是和doGet一样，方法也一样。

这是我在看传志博客视频时学到的。以前是知道怎么用的，现在明白了反射原理就明白了。附上代码。

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);
		}
	}
}

欢迎批评指正！