Java核心篇，二十三种设计模式（一），结构型——代理模式

一、代理模式

1.何为代理模式

一种java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等

代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务

简单的说就是，我们在访问实际对象时，是通过代理对象来访问的，代理模式就是在访问实际对象时引入一定程度的间接性，因为这种间接性，可以附加多种用途

2.代理模式的优点

• 优点一：可以隐藏真实目标类的实现；
• 优点二：可以实现客户与真实目标类间的解耦，在不修改真实目标类代码的情况下能够做一些额外的处理

二、静态代理

1.定义

由程序员创建或特定工具自动生成源代码，也就是在编译时就已经将接口，被代理类，代理类等确定下来。在程序运行之前，代理类的.class文件就已经生成

2.简单实现

①学生接口

public interface IStudent {
    public abstract void giveMoney();
}

②学生实现类

public class StudentImpl implements IStudent{

    private String name;

    public StudentImpl(String name){
        this.name = name;
    }


    @Override
    public void giveMoney() {
        System.out.println(name + "同学上交了学费");
    }
}

③学生代理类

public class StudentProxy implements IStudent {

    private IStudent student;

    public StudentProxy(IStudent student){
        this.student = student;
    }

    @Override
    public void giveMoney() {
        //交学费以前可以做的事
        before();
        student.giveMoney();
        //交学费以后可以做的其他事
        after();
    }

    public void before(){
        System.out.println("班长替班主任向全班同学收取学费");
    }

    public void after(){
        System.out.println("班长将全班同学的学费交给了班主任");
    }
}

④使用静态代理

public class Realize {

    private static IStudent student;
    private static IStudent studentProxy;

    public static void main(String[] args) {
        student = new StudentImpl("小明");
        studentProxy = new StudentProxy(student);
        studentProxy.giveMoney();
    }
}

三、动态代理

1.定义

在程序运行时，运用反射机制动态创建而成，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码

2.基于接口的动态代理

（1）如何创建代理对象

使用Proxy类中的newProxyInstance方法

（2）创建代理对象的要求：

被代理类最少实现一个接口，如果没有则不能使用

（3）newProxyInstance方法的参数：

ClassLoader: 类加载器

它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器

固定写法：

[对象].getClass().getClassLoader()
[类].class.getClassLoader()

Class[]: 字节码数组

它是用于让代理对象和被代理对象有相同方法

固定写法：

[对象].getClass().getInterfaces();
[类].class.getInterfaces();

InvocationHandler: 用于提供增强的代码

它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类（不是必须的），此接口的实现类都是谁用谁写

new InvocationHandler(){
            /**
             * 执行被代理对象的任何方法都会经过invoke方法
             * 方法参数的含义：
             * proxy ===> 代理对象的引用
             * method ===> 当前执行的方法
             * args ===> 当前执行方法所需的参数
             * return ===> 和被代理对象方法有相同的返回值
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                ......
            }
};

（4）代码实现（方法一：匿名内部类）

①学生接口

public interface IStudent {
    public abstract void giveMoney();
}

②接口实现类

public class StudentImpl implements IStudent{

    private String name;

    public StudentImpl(String name){
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name + "同学上交了学费");
    }
}

③实现动态代理并执行

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Realize {

    private static IStudent student;

    public static void before(){
        System.out.println("班长替班主任向全班同学收取学费");
    }

    public static void after(){
        System.out.println("班长将全班同学的学费交给了班主任");
    }

    public static void main(String[] args) {
        student = new StudentImpl("小明");
        IStudent iStudent = (IStudent) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), new InvocationHandler() {
            /**
             * 执行被代理对象的任何方法都会经过invoke方法
             * 方法参数的含义：
             * proxy ===> 代理对象的引用
             * method ===> 当前执行的方法
             * args ===> 当前执行方法所需的参数
             * return ===> 和被代理对象方法有相同的返回值
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                before();
                /**
                 * invoke方法的参数
                 * 第一个为被代理对象
                 * 第二个为方法参数-args
                 */
                Object obj = method.invoke(student, args);
                after();
                return obj;
            }
        });

        iStudent.giveMoney();
    }
}

（5）代码实现（方法二：自定义类，实现动态代理接口）

①学生接口

public interface IStudent {
    public abstract void giveMoney();
}

②接口实现类

public class StudentImpl implements IStudent{

    private String name;

    public StudentImpl(String name){
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name + "同学上交了学费");
    }
}

③动态代理接口的实现类

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StudentProxy<T> implements InvocationHandler {

    private T target;

    public StudentProxy(T target){
        this.target = target;
    }

    public void before(){
        System.out.println("班长替班主任向全班同学收取学费");
    }

    public void after(){
        System.out.println("班长将全班同学的学费交给了班主任");
    }

    /**
     * 执行被代理对象的任何方法都会经过invoke方法
     * 方法参数的含义：
     * proxy ===> 代理对象的引用
     * method ===> 当前执行的方法
     * args ===> 当前执行方法所需的参数
     * return ===> 和被代理对象方法有相同的返回值
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        /**
         * invoke方法的参数
         * 第一个为被代理对象
         * 第二个为方法参数-args
         */
        Object obj = method.invoke(target, args);
        after();
        return obj;
    }
}

④使用动态代理

import java.lang.reflect.Proxy;

public class Realize {

    private static IStudent student;
    private static StudentProxy studentProxy;

    public static void main(String[] args) {
        student = new StudentImpl("小明");
        studentProxy = new StudentProxy(student);

        /**
         * newProxyInstance方法的参数：
         * ClassLoader: 类加载器
         * 它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器
         * Class[]: 字节码数组
         * 它是用于让代理对象和被代理对象有相同方法
         * InvocationHandler: 用于提供增强的代码
         * 它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类（不是必须的），此接口的实现类都是谁用谁写
         */
        IStudent iStudent = (IStudent) Proxy.newProxyInstance(student.getClass().getClassLoader(), student.getClass().getInterfaces(), studentProxy);
        iStudent.giveMoney();
    }
}

3.基于子类的动态代理

1.确保项目是Maven工程

2.在pom.xml中设置打包方式

<packaging>jar</packaging>

3.在pom.xml中导入依赖坐标

<dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
</dependencies>

4.最终pom.xml为

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>demo19</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.1_3</version>
        </dependency>
    </dependencies>


</project>

5.依赖与使用

依赖类 ===> Enhancer

使用方法 ===> Enhancer.create()

6.要求

被代理类不能是最终类

7.参数

Class ===> 用于指定被代理对象的字节码

Callback ===> 用于提供增强的代码；我们一般写该接口的子接口实现类——>MethodInterceptor

8.代码实现（方法一：匿名内部类）

（1）学生接口

public interface IStudent {
    public abstract void giveMoney();
}

（2）学生接口实现类

public class StudentImpl implements IStudent{

    private String name;

    /**
     * 当实现CGLIB代理的时候，如果目标对象没有定义无参构造函数，当Enhancer对象create代理对象的时候，就会报错
     * 因为Spring通过CGLIB生成代理类对象时，并没有将目标对象的构造函数的参数及其类型进行设定，导致了CGLIB在生成代理类对象时，会使用默认的构造函数生成，结果目标对象类没有默认构造函数，CGLIB生成子类时，也没有加入默认构造函数，所以，异常的发生成为必然
     * 所以这里需要加入默认构造函数
     */
    public StudentImpl(){
        this.name = null;
    }

    public StudentImpl(String name){
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name + "同学上交了学费");
    }
}

（3）动态代理的实现

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

import java.lang.reflect.Method;

public class Realize {

    private static IStudent student;

    public static void before(){
        System.out.println("班长替班主任向全班同学收取学费");
    }

    public static void after(){
        System.out.println("班长将全班同学的学费交给了班主任");
    }

    public static void main(String[] args) {

        student = new StudentImpl("小明");

        /**
         * Class ===> 用于指定被代理对象的字节码
         * Callback ===> 用于提供增强的代码；我们一般写该接口的子接口实现类——>MethodInterceptor
         */
        IStudent iStudent = (IStudent) Enhancer.create(student.getClass(), new MethodInterceptor() {
             /**
              * 执行被代理对象的任何方法都会经过该方法
              * o ===> 代理对象的引用
              * method ===> 当前执行的方法
              * objects ===> 当前执行方法所需的参数
              * methodProxy ===> 当前执行方法的代理对象
              * return ===> 和被代理对象方法有相同的返回值
              */
             @Override
             public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                 before();
                 Object obj = method.invoke(student);
                 after();
                 return obj;
             }
        });

         iStudent.giveMoney();
    }
}

9.代码实现（方法二：自定义接口实现类）

（1）.学生接口

public interface IStudent {
    public abstract void giveMoney();
}

（2）学生接口实现类

public class StudentImpl implements IStudent{

    private String name;

    /**
     * 当实现CGLIB代理的时候，如果目标对象没有定义无参构造函数，当Enhancer对象create代理对象的时候，就会报错
     * 因为Spring通过CGLIB生成代理类对象时，并没有将目标对象的构造函数的参数及其类型进行设定，导致了CGLIB在生成代理类对象时，会使用默认的构造函数生成，结果目标对象类没有默认构造函数，CGLIB生成子类时，也没有加入默认构造函数，所以，异常的发生成为必然
     * 所以这里需要加入默认构造函数
     */
    public StudentImpl(){
        this.name = null;
    }

    public StudentImpl(String name){
        this.name = name;
    }

    @Override
    public void giveMoney() {
        System.out.println(name + "同学上交了学费");
    }
}

（3）学生代理类

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

public class StudentProxy<T> implements MethodInterceptor {

    private T target;

    public StudentProxy(T target){
        this.target = target;
    }

    public void before(){
        System.out.println("班长替班主任向全班同学收取学费");
    }

    public void after(){
        System.out.println("班长将全班同学的学费交给了班主任");
    }

    /**
     * 执行被代理对象的任何方法都会经过 intercept方法
     * 方法参数的含义：
     * o ===> 代理对象的引用
     * method ===> 当前执行的方法
     * objects ===> 当前执行方法所需的参数
     * return ===> 和被代理对象方法有相同的返回值
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        before();
        Object obj = method.invoke(target);
        after();
        return obj;
    }
}

（4）使用动态代理

import net.sf.cglib.proxy.Enhancer;

public class Realize {

    private static IStudent student;
    private static StudentProxy<IStudent> studentProxy;

    public static void main(String[] args) {

        student = new StudentImpl("小明");
        studentProxy = new StudentProxy<IStudent>(student);

        /**
         * Class ===> 用于指定被代理对象的字节码
         * Callback ===> 用于提供增强的代码；我们一般写该接口的子接口实现类——>MethodInterceptor
         */
        IStudent iStudent = (IStudent) Enhancer.create(student.getClass(), studentProxy);
        iStudent.giveMoney();
    }
}