Java设计模式之代理模式

时间 2019-12-01

标签 java 设计模式代理栏目 Java 繁體版

原文原文链接

设计模式之代理模式

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

简介

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

java中的代理分为三类：静态代理、动态代理和Cglib代理。下面依次讲解着三种代理。编程

1. 静态代理

静态代理在使用时，须要定义接口或者父类，被代理的对象和代理对象须要一块儿实现同一个接口或者继承同一个父类。设计模式

代码示例缓存

接口：框架

package com.wangjun.designPattern.proxy;

/*
 * 咱们有一我的类的接口，有不少种职业，好比教师，学生
 */
public interface Person {
    //获取本职业的职责
    public String getDuty();
}

目标对象1：ide

package com.wangjun.designPattern.proxy;

public class Student implements Person {

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

}

目标对象2：函数

package com.wangjun.designPattern.proxy;

public class Teacher implements Person {

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

}

代理对象：工具

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;
    }
}

测试类：性能

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());
    }

}

静态代理总结：

优势：能够作到在不修改目标对象的功能前提下,对目标功能扩展；
缺点：由于代理对象须要与目标对象实现同样的接口，因此会有不少代理类，同时，一旦接口增长方法，目标对象与代理对象都要维护。

2. 动态代理

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

动态代理有如下特色：

代理对象不须要实现接口；
代理对象的生成是利用JDK中的API动态的在内存中构建代理对象（须要咱们指定建立代理对象/目标对象实现的接口的类型）；

代理类所在的包是：java.lang.reflect.Proxy

JDK实现动态代理只须要使用newProxyInstance方法，该方法须要传入三个变量：

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

ClassLoader loader：指定当前目标对象使用类加载器，获取加载器的方法是固定的
Class<?>[] interfaces：目标对象实现的接口的类型，使用泛型方式确认类型
InvocationHandler h：事件处理，执行目标对象的方法时，会触发事件处理器的方法，会把当前执行目标对象的方法做为参数传入。

代码示例

接口类Person.class和实现类Teacher.class、Sutdent.class不变，在这个基础上，增长一个代理工厂类ProxyFactory.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;
                    }
                });
    }

}

测试类：

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子类实现代理的方法

须要引入cglib和asm的jar包文件，Spring的核心包里面已经包含了此包；
引入jar包后，就能够在内存中动态构建子类；
代理的类不能为final，不然报错；
目标对象的方法若是为final/static，那么就不会被拦截，即不会执行目标对象额外的方法。

代码示例

目标对象类：

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

Cglib代理工厂类：

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;
    }

}

测试类：

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代理

参考：http://www.javashuo.com/article/p-nzewgjjh-gt.html