反射与代理模式

水深无声 2021-09-21 04:06 282阅读 0赞

### 一、反射 ###

**（一）概述**

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这**个类的所有属性和方法**；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。

实际上，我们创建的**每一个类也都是对象**，即**类本身是 java.lang.Class 类的实例对象**。这个实例对象称之为类对象，也就是 Class 对象。

**反射就是把 java 类中的各种成分映射成一个个的 Java 对象**

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。如图是类的正常加载过程：反射的原理在于 class 对象。  
熟悉一下加载的时候：Class 对象的由来是将 class 文件读入内存，并为之创建一个 Class 对象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]

*  **Class 类的实例**表示正在运行的 Java 应用程序中的**类和接口**。也就是 jvm 中有 N 多的实例每个类都有该 Class 对象。（**包括基本数据类型**）
 *  Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。也就是这不需要我们自己去处理创建，JVM 已经帮我们创建好了。

**（二）获取对象的三种方式**

*  通过**object类的 getClass() 函数**，由于object是根类，**每一个类都有这个函数**
 *  每一个类（包括基本数据类型，注意这里基本数据类型不用转成包装类）都有一个**class属性**，静态属性，通过类名直接访问
 *  通过**Class类的静态方法** forName(String className)

package test.reflect;
    
    /** * @author 谢世杰 */
    public class GetClass { 
        public static void main(String[] args) { 
            Student student = new Student();
    
            // 第一种方式
            Class stuClass1 = student.getClass();
            System.out.println(stuClass1.getName());
    
            // 第二种方式
            Class stuClass2 = Student.class;
            System.out.println(int.class.getName());
            System.out.println(stuClass1 == stuClass2);
    
            // 第三种方式
            try { 
                Class stuClass3 = Class.forName("test.reflect.Student");
                System.out.println(stuClass1 == stuClass3);
            } catch (ClassNotFoundException e) { 
                e.printStackTrace();
            }
            
        }
    }
    
    //所有获得到的class对象都是同一个。

**（三）类对象的常见方法**

**1.获取构造函数**

*  getConstructor 根据参数获得公有构造函数
 *  getDeclaredConstructor 根据参数获得任意构造函数
 *  newInstance 执行构造函数，私有构造函数需要开放权限

**2.获得成员变量**

*  getDeclaredFields() 获得所有字段
 *  getFields() 所有公有字段

**3.getMethods()**

*  getMethods() 获取所有公有方法(包括继承的父类的方法)
 *  getDeclaredMethods() 获取本类所有方法

**（四）通过反射运行配置文件**

我们利用**反射和配置文件**，可以使应用程序更新时，对**源码无需进行任何修改**，我们只需要**将新类发送给客户端，并修改配置文件即可**

**【实体类】**

// 原实体类
    public class Student { 
    	public void show(){ 
    		System.out.println("is show()");
    	}
    }
    
    // 新类
    public class Student2 { 
       public void show2(){ 
       	System.out.println("is show2()");
       }
    }

**【配置文件】**

// 原配置文件
    className = cn.fanshe.Student
    methodName = show
    
    // 新配置文件
    className = cn.fanshe.Student2
    methodName = show2

**【业务类】**

import java.io.FileNotFoundException;
    import java.io.FileReader;
    import java.io.IOException;
    import java.lang.reflect.Method;
    import java.util.Properties;
     
    /* * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改 * 我们只需要将新类发送给客户端，并修改配置文件即可 */
    public class Demo { 
    	public static void main(String[] args) throws Exception { 
    		//通过反射获取Class对象
    		Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
    		//2获取show()方法
    		Method m = stuClass.getMethod(getValue("methodName"));//show
    		//3.调用show()方法
    		m.invoke(stuClass.getConstructor().newInstance());
    		
    	}
    	
    	//此方法接收一个key，在配置文件中获取相应的value
    	public static String getValue(String key) throws IOException{ 
    		Properties pro = new Properties();//获取配置文件的对象
    		FileReader in = new FileReader("pro.txt");//获取输入流
    		pro.load(in);//将流加载到配置文件对象中
    		in.close();
    		return pro.getProperty(key);//返回根据key获取的value值
    	}
    }

原理：配置文件中存储的是调用类的路径和调用方法的路径，业务类中调用方法的方式是c**lass类的forname方法**，只需要传进类路径名和方法名即可，只要修改了**配置的类路径名和方法名**，并传入新类，实现了**对修改封闭，对扩展开放**。

**（五）通过反射越过泛型检查**

泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的，运行也不会有问题。

import java.lang.reflect.Method;
    import java.util.ArrayList;
     
    /* * 通过反射越过泛型检查 * * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？ */
    public class Demo { 
    	public static void main(String[] args) throws Exception{ 
    		ArrayList<String> strList = new ArrayList<>();
    		strList.add("aaa");
    		strList.add("bbb");
    		
    		//获取ArrayList的Class对象，反向的调用add()方法，添加数据
    		Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
    		//获取add()方法
    		Method m = listClass.getMethod("add", Object.class);
    		//调用add()方法
    		m.invoke(strList, 100);
    		
    		//遍历集合
    		for(Object obj : strList){ 
    			System.out.println(obj);
    		}
    	}
    }

--------------------

### 二、代理模式 ###

**（一）定义**

**1.什么是代理模式**

*  代理（Proxy）模式是结构型的设计模式之一，它可以为其他对象**提供一种代理（Proxy）以控制对这个对象**的访问。
 *  所谓代理，是指具有**与被代理的对象具有相同的接口的类**，客户端必须通过代理与被代理的目标类交互，而代理一般在交互的过程中（交互前后），进行某些特别的处理。
 *  通俗的来讲代理模式就是我们生活中常见的**中介或者代理人**，比如我们想要买房子或者买车，自己弄太麻烦，就可以找一个中介，帮我全部打理好；或者父母是孩子的代理人，有些事情是需要父母出面代理孩子完成。

**2.为什么要用代理模式**

*  **中介隔离作用**：在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是**代理类和委托类实现相同的接口**。
 *  **开闭原则，增加功能**：代理类除了是客户类和委托类的中介之外，我们还可以通过**给代理类增加额外的功能来扩展委托类的功能**，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。

**3.参与角色**

*  **抽象主题（Subject）**：真实主题与代理主题的**共同接口**。
 *  **真实主题（RealSubject）**：实现抽象主题，定义真实主题**所要实现的业务逻辑**，供代理主题调用。
 *  **代理主题（Proxy）**：实现抽象主题，是真实主题的代理。通过**真实主题的业务逻辑方法来实现抽象方法**，并可以附加自己的操作。

**4.应用场景**

*  需要控制对目标对象的访问。
 *  需要对目标对象进行方法增强。如：添加日志记录，计算耗时等。
 *  需要延迟加载目标对象。

**（二）静态代理**

以孩子交学费为例

【抽象主题】

package designpatterns.proxy;
    
    public interface IChild { 
        void money();
        void school();
    }

【真实主题】

package designpatterns.proxy;
    
    public class Child implements IChild { 
        @Override
        public void money() { 
            System.out.println("娃娃去交钱");
        }
    
        @Override
        public void school() { 
            System.out.println("娃娃去上学");
        }
    }

**【代理主题】**

package designpatterns.proxy;
    
    public class Parent implements IChild { 
    
        private IChild child;
    
        public Parent(IChild child) { 
            this.child = child;
        }
    
        @Override
        public void money() { 
            System.out.println("父母去交钱");
        }
    
        @Override
        public void school() { 
            child.school();
        }
    }

【测试环境】

package designpatterns.proxy;
    
    public class Demo { 
        public static void main(String[] args) { 
            IChild child = new Child();
            IChild proxy = new Parent(child);
            proxy.money();
            proxy.school();
        }
    }
    
    // 运行结果
    父母去交钱
    娃娃去上学

注意：在代理主题中引入的对象是抽象主题类而不是真实主题类。

**（三）动态代理**

动态代理的实现手段：**JDK 自带的 Proxy 类、CGlib、Javaassist 等**。

1.Proxy类实现动态代理

抽象主题和真实主题不变

【代理处理类】

package designpatterns.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class ChildHandle implements InvocationHandler { 
    
        private IChild child;
    
        public ChildHandle(IChild child) { 
            this.child = child;
        }
    
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { 
            Object obj = null;
    
            /** * method.getName()是获得抽象主题的方法，通过多态定位到具体实现类 * 当在生产环境进行调用的时候，根据不同的方法名执行不同的方法 * */
            if ("school".equals(method.getName())) { 
                obj = method.invoke(child,args);
            }
    
            if ("money".equals(method.getName())) { 
                System.out.println("父母交学费");
            }
    
            return obj;
        }
    }

**【测试环境】**

package designpatterns.proxy;
    
    import java.lang.reflect.Proxy;
    
    public class Dynamic { 
        public static void main(String[] args) { 
            IChild child = new Child();
            ChildHandle handler = new ChildHandle(child);
    
            // 代理模式
            IChild proxy = (IChild) Proxy.newProxyInstance(
                    child.getClass().getClassLoader(),
                    child.getClass().getInterfaces(),
                    handler);
    		// 这里的方法调用，对用的就是ChildHandle类中invoke方法中method.getName()所得到得内容
            proxy.money();
            proxy.school();
        }
    }
    
    // 运行结果
    父母交学费
    娃娃去上学

**2.分析**

Proxy.newProxyInstance() 方 法接受三个参数：

*  ClassLoader loader: 指定**当前目标对象使用的类加载器**，获取加载器的方法是固定的
 *  Class<?>\[\] interfaces: 指定**目标对象实现的接口的类型**，使用泛型方式确认类型
 *  InvocationHandler:**指定动态处理器**，执行目标对象的方法时，会触发事件处理器的方法

关于proxy动态代理的个人理解：proxy动态代理的**InvocationHandler 接口就类似多线程的runnable接口**，而invoke方法就相当于run方法，多线程的逻辑写在run方法中，而代理模式中需要实现的逻辑是写在invoke方法中，而通过java反射，又可以在运行的时候获取抽象主题和真实主题的方法，然后重新实现代理逻辑。实现的方式跟多线程的start方式略有不同，代理是通过传参实现的。

总结：虽然相对于静态代理，proxy动态代理大大**减少了我们的开发任务**，同时**减少了对业务接口的依赖**，降低了耦合度。但是还是有一点点小小的遗憾之处，那就是**Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理，仅支持 interface 代理**。

**3.CGlib动态代理**

**静态代理和proxy动态代理**模式都是要求目标对象是**实现一个接口的目标对象**，但是有时候目标对象只是一个单独的对象，并没有实现任何的接口，这个时候就可以使用以**目标对象子类的方式类**实现代理，这种方法就叫做：Cglib 代理

**Cglib 代理，也叫作子类代理**，它是在**内存中构建一个子类对象从而实现对目标对象功能的扩展**。CGLib 采用了非常底层的字节码技术，其原理是**通过字节码技术为一个类创建子类**，并在**子类中采用方法拦截的技术拦截所有父类方法的调用，顺势织入横切逻辑**。但因为采用的是继承，所以不能对 final 修饰的类进行代理。J**DK 动态代理与 CGLib 动态代理均是实现 Spring AOP 的基础**。

这里的拦截是指，**子类代理会拦截所有父类方法的调用**，并把调用更改成在拦截方法内的逻辑

Cglib 子类代理实现方法:

*  需要引入 cglib 的 jar 文件。
 *  引入功能包后，就可以在内存中动态构建子类
 *  代理的类不能为 final, 否则报错
 *  目标对象的方法如果为 final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法.

4.总结一下JDK动态代理和Gglib动态代理的区别：

*  JDK动态代理是实现了**被代理对象的接口**，Cglib是**继承了被代理对象**。
 *  JDK和Cglib都是在运行期生成字节码，JDK是直接写Class字节码，Cglib使用ASM框架写Class字节码，Cglib代理实现更复杂，生成代理类比JDK效率低。
 *  JDK**调用代理方法，是通过反射机制调用**，Cglib是通过**FastClass机制直接调用方法**，Cglib执行效率更高。

FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个Class，这个Class会为代理类或被代理类的方法分配一个index(int类型)。  
**这个index当做一个入参，FastClass就可以直接定位要调用的方法直接进行调用，这样省去了反射调用**，所以调用效率比JDK动态代理通过反射调用高。

--------------------

**【Java 面试那点事】**

**这里致力于分享 Java 面试路上的各种知识，无论是技术还是经验，你需要的这里都有！**

**这里可以让你【快速了解 Java 相关知识】，并且【短时间在面试方面有跨越式提升】**

**面试路上，你不孤单！**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70]: /images/20210920/23eebabd644f47cb985271e208d3b7b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzOTQ1MjQ2_size_16_color_FFFFFF_t_70 1]: /images/20210920/aec9415b87534a4f8591b5b28648b86f.png