# 代理模式

今天学到Spring的动态代理实现AOP，对代理这个概念很模糊，看了一篇文章发现这使用了设计模式中的代理模式，于是学习记录一下。

## 简介

代理模式是一种对象结构型的模式，主要为其他对象提供一种代理以控制对这个对象的访问。简单点说就是你访问一个对象并不是直接的访问它，而是通过一个代理间接访问，那么这个代理就可以在访问对象之前或之后做一些定制化的操作，比如校验入参，打印日志什么的。Spring AOP就是一个代理模式的典型应用。

java中的代理大致可以分为三类：静态代理、JDK动态代理和Cglib动态代理。下面依次讲解着三种代理。

## 1. 静态代理

静态代理在使用时，需要定义接口或者父类，被代理的对象和代理对象需要一起实现同一个接口或者继承同一个父类。

**代码示例**

接口：

```java
package com.wangjun.designPattern.proxy;

/*
 * 我们有一个人类的接口，有很多种职业，比如教师，学生
 */
public interface Person {
    //获取本职业的职责
    public String getDuty();
}
```

目标对象1：

```java
package com.wangjun.designPattern.proxy;

public class Student implements Person {

    @Override
    public String getDuty() {
        return "学习知识";
    }

}
```

目标对象2：

```java
package com.wangjun.designPattern.proxy;

public class Teacher implements Person {

    @Override
    public String getDuty() {
        return "教书育人";
    }

}
```

代理对象：

```java
package com.wangjun.designPattern.proxy;

import java.util.HashMap;
import java.util.Map;

/*
 * 通过代理，加入缓存功能
 */
public class CachedPersonProxy implements Person{

    private Person person;
    private Map<Person,String> map = new HashMap<>();;

    public CachedPersonProxy(Person person) {
        this.person = person;
    }

    @Override
    public String getDuty() {
        String duty = map.get(person);
        if(null == duty) {
            duty = person.getDuty();
            map.put(person, duty);
        }
        return duty;
    }
}
```

测试类：

```java
package com.wangjun.designPattern.proxy;

public class Main {

    public static void main(String[] args) {
        Teacher teacher = new Teacher();

        CachedPersonProxy proxy = new CachedPersonProxy(teacher);

        System.out.println(proxy.getDuty());
    }

}
```

**静态代理总结：**

1. 优点：可以做到在不修改目标对象的功能前提下，对目标功能扩展；
2. 缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，同时，一旦接口增加方法，目标对象与代理对象都要维护。

## 2. JDK动态代理

JDK动态代理也叫接口代理。

动态代理有以下特点：

* 代理对象不需要实现接口（但是被代理对象仍然需要实现接口）；
* 代理对象的生成是利用JDK中的API动态的在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口的类型）；

JDK获取代理对象只需要使用newProxyInstance方法，该方法需要传入三个变量：

```java
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler hander) throws IllegalArgumentException
```

* loader：指定被代理对象使用的类加载器(使用`Object.getClass().getClassLoader()`获取)
* interfaces：被代理对象实现的接口的类型(使用`Object.getClass().getInterfaces()`获取)
* hander：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把被代理对象的方法作为参数传入。

**代码示例**

接口类Person.class和实现类Teacher.class、Sutdent.class不变，在这个基础上，增加一个代理工厂类ProxyFactory.java，然后在测试类中先建立目标对象和代理对象的联系，接着再用代理对象中的同名方法。

代理工厂类：

```java
package com.wangjun.designPattern.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;

public class ProxyFactory {

    private Person person;
    private Map<Person, String> map = new HashMap<>();

    public ProxyFactory(Person person) {
        this.person = person;
    }

    //获取代理对象
    public Object getProxyInstance() {
        return Proxy.newProxyInstance(
                person.getClass().getClassLoader(), 
                person.getClass().getInterfaces(),
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String duty = map.get(person);
                        if(null == duty) {
                            //执行对象方法
                            System.out.println("没有缓存");
                            duty = (String) method.invoke(person, args);
                            map.put(person, duty);
                        }
                        return duty;
                    }
                });
    }

}
```

测试类：

```java
package com.wangjun.designPattern.proxy;

public class Main {

    public static void main(String[] args) {
        Person teacher = new Teacher();
        System.out.println(teacher.getClass());
        //使用动态代理
        ProxyFactory proxyFactory = new ProxyFactory(teacher);
        Person teacherProxy = (Person) proxyFactory.getProxyInstance();
        System.out.println(teacherProxy.getClass());
        System.out.println(teacherProxy.getDuty());
        System.out.println(teacherProxy.getDuty());
    }
}
```

**总结**

代理对象不需要实现接口，但是目标对象一定要实现接口，否则不能用动态代理。

## 3. Cglib动态代理

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

* Cglib是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和synaop，为他们提供方法的interception(拦截)。
* Cglib代理，也叫作子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能的扩展。
* Cglib包的底层是通过使用一个小而快的字节码处理框架ASM来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

**Cglib子类实现代理的方法**

1. 需要引入cglib和asm的jar包文件，Spring的核心包里面已经包含了这两个包；
2. 引入jar包后，就可以在内存中动态构建子类；
3. 代理的类不能为final，否则报错；
4. 目标对象的方法如果为final/static，那么就不会被拦截，即不会执行目标对象额外的方法。

**代码示例**

目标对象类：

```java
package com.wangjun.designPattern.proxy;
/*
 * 目标对象，没有实现任何接口
 */
public class Doctor {
    public String getDuty() {
        return "救死扶伤";
    }
}
```

Cglib代理工厂类：

```java
package com.wangjun.designPattern.proxy;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

/*
 * cglib代理工厂
 * 对Doctor在内存中动态构建一个子类对象
 */
public class CglibProxyFactory implements MethodInterceptor {

    private Object person;
    private Map<Object, String> map = new HashMap<>();

    public CglibProxyFactory(Object person) {
        this.person = person;
    }

    // 给目标对象创建一个代理对象
    public Object getProxyInstance() {
        // 1.工具类
        Enhancer en = new Enhancer();
        // 2.设置父类  
        en.setSuperclass(person.getClass());
        // 3.设置回调函数
        en.setCallback(this);
        // 4.创建子类(代理对象)
        return en.create();
    }

    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        String duty = map.get(person);
        if(null == duty) {
            //执行目标对象的方法
            System.out.println("cglib实现，有缓存");
            duty = (String) arg1.invoke(person, arg2);
            map.put(person, duty);
        }
        return duty;
    }

}
```

测试类：

```java
package com.wangjun.designPattern.proxy;

public class Main {

    public static void main(String[] args) {
        // 使用cglib
        // 目标对象
        Doctor target = new Doctor();
        System.out.println(target.getClass());
        // 代理对象
        Doctor proxyCglib = (Doctor) new CglibProxyFactory(target).getProxyInstance();
        // 执行代理对象的方法
        System.out.println(proxyCglib.getClass());
        System.out.println(proxyCglib.getDuty());
        System.out.println(proxyCglib.getDuty());
    }
}
```

**在Spring的AOP编程中:**

* 如果加入容器的目标对象有实现接口，用JDK代理
* 如果目标对象没有实现接口，用Cglib代理

> 参考：<https://www.cnblogs.com/cenyu/p/6289209.html>


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://jun-wang.gitbook.io/learnjava/ji-shu-xue-xi/java-she-ji-mo-shi/dai-li-mo-shi.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.