反射和代理(静态代理和动态代理)

原創 wyplj_sir 2020-05-23 12:47

文章目录

反射

Java的反射机制其实就是通过反射，可以在运行期间获取、检测和调用对象的属性和方法。
用一句话来概括反射就是加载一个运行时才知道的类以及它的完整内部结构。

反射的使用场景

1、编程工具 IDEA 或 Eclipse 等，在写代码时会有代码（属性或方法名）提示，就是因为使用了反射。

2、很多知名的框架，为了让程序更优雅更简洁，也会使用到反射。

例如，Spring 可以通过配置来加载不同的类，调用不同的方法，代码如下所示：

<bean id="person" class="com.spring.beans.Person" init-method="initPerson"></bean>

例如，MyBatis 在 Mapper 使用外部类的 Sql 构建查询时，代码如下所示：

@SelectProvider(type = PersonSql.class, method = "getListSql")
List<Person> getList();
class PersonSql {
    public String getListSql() {
        String sql = new SQL() {{
            SELECT("*");
            FROM("person");
        }}.toString();
        return sql;
    }
}

3、数据库连接池，也会使用反射调用不同类型的数据库驱动，代码如下所示：

String url = "jdbc:mysql://127.0.0.1:3306/mydb";
String username = "root";
String password = "root";
Class.forName("com.mysql.jdbc.Driver");
Connection connection = DriverManager.getConnection(url, username, password);

反射的使用

反射相关类：

类名 说明
Class 类的实体，在运行的Java应用程序中表示类和接口
Field 类的成员变量（类的属性）
Method 类的方法
Constructor 类的构造方法

获得类(3种)

  • getClass()
String str = "aa";
Class c1 = str.getClass();
  • Class.forName()
Class c1 = Class.forName ("java.lang.String");
  • .class
Class c1 = String.class

补充：

TYPE(基本数据类型包装类的 TYPE语法)，例如：

System.out.println(int.class);//int
System.out.println(Integer.TYPE);//int
System.out.println(Integer.class);//class java.lang.Integer

int.class表示基本数据类型int的Class对象
TYPE是Integer中的静态常量,api中已经写明它表示的是基本数据类型int的class实例
Integer.class表示引用数据类型Integer的class对象

获得属性

方法 说明
public Field getField(String name) 此 Class 对象所表示的类或接口的指定公共成员字段
public Field[] getFields() 此 Class 对象所表示的类或接口的所有可访问公共字段
public Field getDeclaredField(String name) 此 Class 对象所表示的类或接口的指定已声明字段(包括私有属性)
public Field[] getDeclaredFields() 此 Class 对象所表示的类或接口所声明的所有字段(包括私有)

获得方法

方法 说明
public Method getMethod(String name) 此 Class 对象所表示的类或接口的指定公共成员方法
public Method[] getMethods() 此 Class 对象所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的所有可访问公共方法
public Method getDeclaredMethod(String name) 此 Class 对象所表示的类或接口的指定已声明方法(包括私有)
public Method[] getDeclaredMethods() 此 Class 对象所表示的类或接口所声明的所有方法(包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法)

例子：

Class myClass = Class.forName("com.interview.chapter4.MyReflect");
//调用静态方法，无需创建实例对象
Method method = myClass.getMethod("staticMd");
method.invoke(myClass);
// 创建实例对象（相当于 new ）
Object object = myClass.newInstance();
//调用公共方法
Method method2 = myClass.getMethod("publicMd");
method2.invoke(object);
//调用私有方法
Method method3 = myClass.getDeclaredMethod("privateMd");
method3.setAccessible(true);
method3.invoke(object);

反射获取调用类可以通过 Class.forName()，反射获取类实例要通过 newInstance()，相当于 new 一个新对象，反射获取方法要通过 getMethod()，获取到类方法之后使用 invoke() 对类方法进行调用。如果是类方法为私有方法的话，则需要通过 setAccessible(true) 来修改方法的访问限制。

获得类的构造器

方法 说明
public Constructor getConstructor(Class<?>… ) 此 Class 对象所表示的类的指定公共构造方法
public Constructor<?>[] getConstructors() 此 Class 对象所表示的类的所有公共构造方法
public Constructor< T> getDeclaredConstructor(Class<?>…) 此 Class 对象所表示的类或接口的指定构造方法
public Constructor<?>[] getDeclaredConstructors() 此 Class 对象表示的类声明的所有构造方法。它们是公共、保护、默认（包）访问和私有构造方法

新建类的实例

  • 调用类的Class对象的newInstance方法
  • 调用默认Constructor对象的newInstance方法
  • 调用带参数Constructor对象的newInstance方法

代理

代理，就是你委托别人帮你办事，所以代理模式也有人称作委托模式的。比如领导要做什么事，可以委托他的秘书去帮忙做，这时就可以把秘书看做领导的代理。

代理模式又分为静态代理和动态代理。

静态代理

静态代理的使用

静态代理，代理类和被代理的类实现了同样的接口，代理类同时持有被代理类的引用。当我们需要调用被代理类的方法时，可以通过调用代理类的方法来做到。举例如下：

假设领导的工作是开会和给员工考评。

先定义一个接口Iwork：

public interface IWork {
    void meeting();
    int evaluate(String name);
}

定义领导类Leader（被代理的类，实现接口Iwork）：

import java.util.Random;

public class Leader implements IWork {

    @Override
    public void meeting() {
        System.out.println("领导早上要组织会议");
    }
    @Override
    public int evaluate(String name) {
        int score = new Random(System.currentTimeMillis()).nextInt(20) + 80;
        System.out.println(String.format("领导给%s的考评为%s分", name, score));
        return score;
    }
}

定义秘书类Secretary（代理类，实现接口Iwork）

public class Secretary implements IWork {
    private Leader mLeader;

    public Secretary(Leader mLeader) {
        this.mLeader = mLeader;
    }

    @Override
    public void meeting() {
        System.out.println("秘书先给老板准备材料");
        mLeader.metting();
    }
    @Override
    public int evaluate(String name) {
        return mLeader.evaluate(name);
    }
}

测试类：

public class TestApp {
    public static void main(String[] args) {
        Leader leader = new Leader();
        Secretary secretary = new Secretary(leader);
        secretary.meeting();
        secretary.evaluate("Joy");
    }
}

运行结果：
在这里插入图片描述

调用Secretary类的 meeting 方法时，我们调用了Leader类的 meeting 的方法，在此之前，我们还扩充了该方法。这时有的人可能有疑惑了，这看起来有点是装饰者模式了。这到底怎么回事？

和装饰者模式的区别

实际上，在装饰器模式和代理模式之间还是有很多差别的。装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。换句话说，用代理模式，代理类（proxy class）可以对它的客户隐藏一个对象的具体信息。因此，当使用代理模式的时候，我们常常在一个代理类中创建一个对象的实例。并且，当我们使用装饰器模式的时候，我们通常的做法是将原始对象作为一个参数传给装饰者的构造器。

一句话来总结这些差别：使用代理模式，代理和真实对象之间的的关系通常在编译时就已经确定了，而装饰者能够在运行时递归地被构造。

伪代码如下：

代理模式：

Interface Subject {
    void doAction()
}

public class RealSubject implements Subject{
    @Override
    public void doAction() {};
}

public class Proxy implements Subject{
       private RealSubject realSubject;

       public Proxy(RealSubject realSubject) {
             //关系在编译时确定
            this.realSubject = realSubject;
       }

       @Override
       public void doAction() {
             ….
             realSubject.doAction();
             ….
       }
}

装饰者模式：

Interface Component {
    void doAction()
}

public class ConcreteComponent implements Component {
    @Override
    public void doAction() {};
}

public class Decorator implements Component {
       private Component component;

       public Decorator(Component component) {
             //关系在编译时确定
            this.component = new component;
       }
       public void doAction() {
             ….
             component.doAction();
             ….
       }
}

其实代理模式和装饰者模式侧重点不一样，代理模式重点在于明确了被代理的类。如上例中，秘书很明确要代理的是的领导。而装饰者模式侧重于拓展类的方法，装饰类持有的实现Component接口的类的对象不是固定的，也就是说，装饰类可以根据在调用时传入的参数，装饰任意一个实现了 Component 接口的类。

优缺点

  • 优点：
    （1）代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对客户端隐藏了具体信息。
  • 缺点：
    （1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
    （2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。即静态代理类只能为特定的接口(Service)服务。如想要为多个接口服务则需要建立很多个代理类。

动态代理

正如前面说的，使用静态代理的话，每个代理类只能为一个接口服务，这样程序开发中必然会产生许多的代理类。所以我们就会想办法可以通过一个代理类完成全部的代理功能，那么我们就需要用动态代理。

对静态代理而言，一个代理只能代理一种类型，而且是在编译期就已经确定被代理的对象。而动态代理是在运行时，通过反射机制实现动态代理，并且能够代理各种类型的对象。

动态代理使用场景

动态代理被广为人知的使用场景是 Spring 中的面向切面编程（AOP）。例如，依赖注入 @Autowired 和事务注解 @Transactional 等，都是利用动态代理实现的。动态代理还可以封装一些 RPC 调用，也可以通过代理实现一个全局拦截器等。

和反射的关系

JDK 原生提供的动态代理就是通过反射实现的，但动态代理的实现方式还可以是 ASM（一个短小精悍的字节码操作框架）、cglib（基于 ASM）等，并不局限于反射。

实现一：JDK原生动态代理

实现代码如下：

interface Animal {
    void eat();
}
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("The dog is eating");
    }
}
class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("The cat is eating");
    }
}

// JDK 代理类
class AnimalProxy implements InvocationHandler {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        // 取得代理对象
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    @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;
    }
}

public static void main(String[] args) {
    // JDK 动态代理调用
    AnimalProxy proxy = new AnimalProxy();
    Animal dogProxy = (Animal) proxy.getInstance(new Dog());
    dogProxy.eat();
}

JDK Proxy 只能代理实现接口的类（即使是 extends 继承类也是不可以代理的）
为什么？
——这是由于 JDK 原生设计的原因，动态代理的实现方法 newProxyInstance() 的有一个参数为interfaces，代表接口代理类的接口实现列表。因此，要使用 JDK 原生的动态只能通过实现接口来完成。

实现二：cglib动态代理

要使用cglib动态代理，需引入cglib依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.12</version>
</dependency>

实现代码如下：

class Panda {
    public void eat() {
        System.out.println("The panda is eating");
    }
}
class CglibProxy implements MethodInterceptor {
    private Object target; // 代理对象
    public Object getInstance(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        // 设置父类为实例类
        enhancer.setSuperclass(this.target.getClass());
        // 回调方法
        enhancer.setCallback(this);
        // 创建代理对象
        return enhancer.create();
    }
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("调用前");
        Object result = methodProxy.invokeSuper(o, objects); // 执行方法调用
        System.out.println("调用后");
        return result;
    }
}
public static void main(String[] args) {
    // cglib 动态代理调用
    CglibProxy proxy = new CglibProxy();
    Panda panda = (Panda)proxy.getInstance(new Panda());
    panda.eat();
}

执行结果：

调用前
The panda is eating
调用后

由以上代码可以知道，cglib 的调用通过实现 MethodInterceptor 接口的 intercept 方法，调用 invokeSuper 进行动态代理的。它可以直接对普通类进行动态代理，并不需要像 JDK 代理那样，需要通过接口来完成。

cglib 底层是通过子类继承被代理对象的方式实现动态代理的，因此代理类不能是最终类（final），否则就会报错 java.lang.IllegalArgumentException: Cannot subclass final class xxx。

两种实现的区别

  1. JDK 原生动态代理是基于接口实现的，不需要添加任何依赖，可以平滑的支持 JDK 版本的升级
  2. cglib 不需要实现接口，可以直接代理普通类，需要添加依赖包，性能更高。

Spring中动态代理

Spring 动态代理的实现方式有两种：cglib 和 JDK 原生动态代理。Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。

Java反射机制剖析
Java-反射和动态代理
静态代理和动态代理
静态代理和动态代理的区别

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

图的遍历：深度优先遍历和广度优先遍历

圖的遍歷一般有兩種方式：深度優先和廣度優先。 深度優先（DFS） 深度優先遍歷也叫深度優先搜索(Depth First Search)。它的遍歷規則：不斷地沿着頂點的深度方向遍歷。頂點的深度方向是指它的鄰接點方向。 具體點，給定一

wyplj_sir 2020-06-29 06:59:05

Java内部类浅析

wyplj_sir 2020-05-10 19:42:35

抽象类和接口的区别（jdk8/jdk9）

wyplj_sir 2020-04-27 23:03:38

图的遍历：深度优先遍历和广度优先遍历

圖的遍歷一般有兩種方式：深度優先和廣度優先。 深度優先（DFS） 深度優先遍歷也叫深度優先搜索(Depth First Search)。它的遍歷規則：不斷地沿着頂點的深度方向遍歷。頂點的深度方向是指它的鄰接點方向。 具體點，給定一

wyplj_sir 2020-06-29 06:59:05

Java内部类浅析

wyplj_sir 2020-05-10 19:42:35

抽象类和接口的区别（jdk8/jdk9）

wyplj_sir 2020-04-27 23:03:38