关于代理模式:设计模式代理模式

代理模式：为一个对象提供一个替身，以管制对这个对象的拜访，即通过代理对象拜访指标对象。这样做的益处是：能够在指标对象实现的根底上，加强额定的性能操作，即扩大指标对象的性能。
被代理的对象能够是近程对象、创立开销大的对象或须要安全控制的对象。
代理模式有不同的模式，次要有三种动态代理、动静代理 (JDK 代理、接口代理)和 Cglib 代理 (能够在内存动静的创建对象，而不须要实现接口，他是属于动静代理的领域)。
代理模式示意图

动态代理在应用时，须要定义接口或者父类，被代理对象 (即指标对象) 与代理对象一起实现雷同的接口或者是继承雷同父类。

思路剖析图解(类图)

代码实现

创立 ITeachService 接口

public interface ITeachService {

    /**
     * 教学方法
     */
    public void teach();}

创立 TeachService 实现类

public class TeachService implements ITeachService{
    @Override
    public void teach() {System.out.println("开始上课...");
    }
}

创立 TeachServiceProxy 代理类

public class TeachServiceProxy implements ITeachService{

    private TeachService teachService;

    public TeachServiceProxy(TeachService teachService) {this.teachService = teachService;}

    @Override
    public void teach() {System.out.println("筹备上课...");
        teachService.teach();
        System.out.println("完结上课...");
    }
}

创立客户端调用

public class Client {public static void main(String[] args) {TeachServiceProxy teachServiceProxy = new TeachServiceProxy(new TeachService());
        teachServiceProxy.teach();

        // 输入
        // 筹备上课...
        // 开始上课...
        // 完结上课...

    }
}

长处：在不批改指标对象的性能前提下，能通过代理对象对指标性能扩大。
毛病：因为代理对象须要与指标对象实现一样的接口，所以会有很多代理类。
一旦接口减少办法，指标对象与代理对象都要保护。

代理对象，不须要实现接口，然而指标对象要实现接口，否则不能用动静代理。
代理对象的生成，是利用 JDK 的 API，动静的在内存中构建代理对象。
动静代理也叫做：JDK 代理、接口代理。

代理类所在包：java.lang.reflect.Proxy
JDK 实现代理只须要应用 newProxyInstance 办法, 然而该办法须要接管三个参数, 残缺的写法是: static Object newProxyInstance(ClassLoaderloader, Class<?>[]interfaces, InvocationHandlerh)

将后面的动态代理改良成动静代理模式

思路图解(类图)

代码实现

创立 ITeachService 接口

public interface ITeachService {public void teach();

    public void select(String name);

    public String answer(String answer);
}

创立 TeachService 实现类

public class TeachService implements ITeachService {
    @Override
    public void teach() {System.out.println("开始上课...");
    }

    @Override
    public void select(String name) {System.out.println("" + name +" 答复问题... ");
    }

    @Override
    public String answer(String answer) {System.out.println("答案是...");
        return answer;
    }
}

创立 TeachServiceProxy 代理类

public class TeachServiceProxy {

    // 要代理的对象
    private Object target;

    // 构造方法
    public TeachServiceProxy(Object target) {this.target = target;}

    // 获取代理对象
    public Object getProxyInstance() {
        /**
         *  public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
         *  1.ClassLoader loader: 指定以后指标对象应用的类加载器，获取加载器的办法固定
         *  2.Class<?>[] interfaces: 指标对象实现的接口，应用泛型办法确认类型
         *  3.InvocationHandler h: 事件处理，执行指标对象的办法时，会触发以后事件处理器办法，会把以后执行的指标对象的办法作为参数传入
         */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("开始应用 JDK 代理...");
                // 反射机制调用指标对象的办法
                Object invoke = method.invoke(target, args);
                System.out.println("完结应用 JDK 代理...");
                return invoke;
            }
        });
    }
}

创立客户端调用

public class Client {public static void main(String[] args) {

        // 创立指标对象
        TeachService teachService = new TeachService();
        // 创立代理类
        TeachServiceProxy teachServiceProxy = new TeachServiceProxy(teachService);
        // 获取代理对象
        ITeachService instance = (ITeachService) teachServiceProxy.getProxyInstance();
        // 调用办法
        instance.teach();
        instance.select("Tom");
        String answer = instance.answer("Java is best language");
        System.out.println("answer =" + answer);

        // 输入
        // 开始应用 JDK 代理...
        // 开始上课...
        // 完结应用 JDK 代理...
        // 开始应用 JDK 代理...
        // Tom 答复问题...
        // 完结应用 JDK 代理...
        // 开始应用 JDK 代理...
        // 答案是...
        // 完结应用 JDK 代理...
        // answer = Java is best language
    }
}

动态代理和 JDK 代理模式都要求指标对象实现一个接口，然而有时候指标对象只是一个独自的对象，并没有实现任何的接口，这个时候可应用指标对象子类来实现代理，这就是 Cglib 代理。
Cglib 代理也叫作 子类代理，它是在内存中构建一个子类对象从而实现对指标对象性能扩大，有些书也将 Cglib 代理归属到动静代理。
Cglib 是一个弱小的高性能的代码生成包，它能够在运行期扩大 Java 类与实现 Java 接口。它宽泛的被许多 AOP 的框架应用，例如 SpringAOP，实现办法拦挡。
在 AOP 编程中如何抉择代理模式：
- 指标对象须要实现接口，用 JDK 代理
- 指标对象不须要实现接口，用 Cglib 代理
Cglib 包的底层是通过应用字节码解决框架 ASM 来转换字节码并生成新的类。

须要引入 Cglib 的 Jar 包

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

<dependency>
    <groupId>asm</groupId>
    <artifactId>asm</artifactId>
    <version>3.2</version>
</dependency>

<dependency>
    <groupId>asm</groupId>
    <artifactId>asm-commons</artifactId>
    <version>3.2</version>
</dependency>

<dependency>
    <groupId>asm</groupId>
    <artifactId>asm-tree</artifactId>
    <version>3.2</version>
</dependency>

在内存中动静构建子类，留神代理的类不能为 final，否则报错 java.lang.IllegalArgumentException .
指标对象的办法如果为 final/static，那么就不会被拦挡，即不会执行指标对象额定的业务办法。

将后面的案例用 Cglib 代理模式实现

思路图解(类图)

代码实现

创立 TeachService 类

public class TeachService {public void teach() {System.out.println("开始上课...");
    }

    public void select(String name) {System.out.println("" + name +" 答复问题... ");
    }

    public String answer(String answer) {System.out.println("答案是...");
        return answer;
    }

}

创立 TeachServiceProxy 代理类

public class TeachServiceProxy implements MethodInterceptor {

    // 指标对象
    private Object target;

    // 结构器
    public TeachServiceProxy(Object target) {this.target = target;}

    // 创立一个 代理对象
    public Object getProxyInstance() {
        // 1. 创立工具类
        Enhancer enhancer = new Enhancer();
        // 2. 设置父类
        enhancer.setSuperclass(target.getClass());
        // 3. 设置回调函数
        enhancer.setCallback(this);
        // 4. 创立子类对象，即代理对象
        return enhancer.create();}

    // 重写 intercept 办法，会调用指标对象的办法
    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {System.out.println("开始 cglib 代理...");
        Object invoke = method.invoke(target, args);
        System.out.println("完结 cglib 代理...");
        return invoke;
    }
}

创立客户端调用

public class Client {public static void main(String[] args) {

        // 创立指标对象
        TeachService teachService = new TeachService();
        // 创立代理类
        TeachServiceProxy teachServiceProxy = new TeachServiceProxy(teachService);
        // 获取代理对象
        TeachService instance = (TeachService) teachServiceProxy.getProxyInstance();
        // 调用办法
        instance.teach();
        instance.select("Tom");
        String answer = instance.answer("Java is best language");
        System.out.println("answer =" + answer);

        // 输入
        // 开始 cglib 代理...
        // 开始上课...
        // 完结 cglib 代理...
        // 开始 cglib 代理...
        // Tom 答复问题...
        // 完结 cglib 代理...
        // 开始 cglib 代理...
        // 答案是...
        // 完结 cglib 代理...
        // answer = Java is best language

    }
}

防火墙代理
内网通过代理穿透防火墙，实现对公网的拜访。
缓存代理
比方：当申请图片文件等资源时，先到缓存代理取，如果取到资源则 ok, 如果取不到资源，再到公网或者数据库取，而后缓存。
近程代理
近程对象的本地代表，通过它能够把近程对象当本地对象来调用。近程代理通过网络和真正的近程对象沟通信息。
同步代理：次要应用在多线程编程中，实现多线程间同步工作。
同步代理：次要应用在多线程编程中，实现多线程间同步工作。

关于代理模式:设计模式代理模式

1.1 根本介绍

1.2 动态代理

1.2.1 根本介绍

1.2.2 利用实例

1.2.3 动态代理优缺点

1.3 动静代理

1.3.1 根本介绍

1.3.2 JDK 中生成代理对象的 API

1.3.3 动静代理利用实例

1.4 Cglib 代理

1.4.1 根本介绍

1.4.2 实现步骤

1.4.3 利用实例

1.5 常见的代理模式

Just My Socks（注册教程内含优惠码）

关于代理模式:设计模式代理模式

1.1 根本介绍

1.2 动态代理

1.2.1 根本介绍

1.2.2 利用实例

1.2.3 动态代理优缺点

1.3 动静代理

1.3.1 根本介绍

1.3.2 JDK 中生成代理对象的 API

1.3.3 动静代理利用实例

1.4 Cglib 代理

1.4.1 根本介绍

1.4.2 实现步骤

1.4.3 利用实例

1.5 常见的代理模式

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）