设计模式知识点整理-代理模式(静态代理,jdk动态代理,cglib动态代理)

什么是代理模式

代理模式是一种结构型设计模式,简单解释就是使用代理对象调用目标对象,并且在不改变源码的情况下,实现对目标对象的功能扩展。

代理类中的两个角色

目标类

代理类

举个例子,有个艺术表演者,他的核心任务是表演才艺

public class Performer{

    public void perform(){

        System.out.println("表演才艺");

    } 

}

他在表演才艺之前,先跟观众打招呼,表演完才艺之后,向观众致谢

public void perform(){ 

        System.out.println("各位观众朋友们大家好");

        System.out.println("表演才艺");

        System.out.println("感谢大家的观看");

}

核心任务是表演才艺,非核心任务是打招呼跟致谢,我们想把这两项分开。表演者类设计为目标类,只保留表演才艺的核心任务。再设计一个代理类,实现对目标类的调用与扩展,代理类中实现打招呼跟致谢的功能,这就是我们用到的代理模式。

分类

代理模式分为静态代理跟动态代理,动态代理又分为jdk动态代理跟cglib动态代理

静态代理

使用静态代理重构之前的例子

表演接口

public interface IPerform {

    public void perform();

}

表演者目标类

public class Performer implements IPerform {

    @Override

    public void perform() {

        System.out.println("表演才艺");

    }

}

表演者代理类

public class PerformProxy implements IPerform {

    //接收目标对象

    private  IPerform target;

    public PerformProxy(IPerform perform) {

        this.target = perform;

    }

    @Override

    public void perform() {

        //表演前先向观众们问好

        System.out.println("各位观众朋友们大家好");

        //调用目标方法

        target.perform();

        //表演完成向观众致谢

        System.out.println("感谢大家的观看");

    }

}

测试

public class Test {

    public static void main(String[] args) {

        //目标对象

        IPerform perform = new Performer();

        //代理对象,将目标对象注入

        IPerform performProxy = new PerformProxy(perform);

        performProxy.perform();

    }

}

测试结果

各位观众朋友们大家好

表演才艺

感谢大家的观看

静态代理总结

静态代理中,将目标类注入到代理类中,实现在代理类中调用目标类的方法,并扩展目标类的功能。但是代理对象需要与目标对象实现一样的接口,代理对象必须提前写出,如果接口层发生了变化,代理对象的代码也要进行维护。如果能在运行时动态地写出代理对象,不但减少了一大批代理类的代码,也少了不断维护的烦恼。这种方式就是接下来的动态代理

jdk动态代理

jdk动态代理代理类所在的包为:java.lang.reflect.Proxy,调用Proxy类的静态方法newProxyInstance,该方法会返回代理类对象。

newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h )接收的三个参数依次为:

ClassLoader loader:指定当前目标对象使用类加载器,写法固定

Class[] interfaces:目标对象实现的接口的类型,写法固定

InvocationHandler h:事件处理接口,需传入一个实现类,一般直接使用匿名内部类

java底层封装了实现细节

使用jdk动态代理重构之前的例子

表演接口

public interface IPerform {

    public void perform();

}

表演者目标类

public class Performer implements IPerform {

    @Override

    public void perform() {

        System.out.println("表演才艺");

    }

}

表演者代理类

public class PerformProxy {

    //接收目标对象

    private  IPerform target;

    public PerformProxy(IPerform perform) {

        this.target = perform;

    }

    //使用jdk动态代理,为目标对象生成代理对象

    public Object getProxyInstance(){

        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("各位观众朋友们大家好");

                        //调用目标方法

                        Object returnValue = method.invoke(target, args);

                        //表演完成向观众致谢

                        System.out.println("感谢大家的观看");

                        return returnValue;

                    }

                });

    }

}

测试

public class Test {

    public static void main(String[] args) {

        //目标对象

        IPerform perform = new Performer();

        //代理对象,将目标对象注入

        PerformProxy performProxy = new PerformProxy(perform);

        IPerform proxy = (IPerform)performProxy.getProxyInstance();

        //通过代理对象调用目标对象方法

        proxy.perform();

    }

}

jdk动态代理总结

jdk动态代理中的目标对象必须实现接口,否则无法使用该代理方式。如果目标对象没有实现接口,我们可以使用cglib动态代理。

cglig动态代理

前提条件:

需要引入cglib的jar文件与asm的jar文件,cglib依赖于asm。由于Spring的核心包中已经包括了Cglib功能,所以也可以直接引入spring-core-3.2.5.jar

目标类不能为final

目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法

使用jdk动态代理重构之前的例子

表演者目标类

public class Performer {

    public void perform() {

        System.out.println("表演才艺");

    }

}

表演者代理类

public class PerformProxy implements MethodInterceptor {

    //接收目标对象

    private  Object  target;

    public PerformProxy(Object  perform) {

        this.target = perform;

    }

    //获取目标对象的代理对象

    public Object getProxyInstance(){

        //工具类

        Enhancer en = new Enhancer();

        //设置父类对象

        en.setSuperclass(this.target.getClass());

        //设置回调函数

        en.setCallback(this);

        //创建子类,也就是代理对象

        return en.create();

    }

    @Override

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        //表演前先向观众们问好

        System.out.println("各位观众朋友们大家好");

        //执行目标对象的方法

        Object returnValue = method.invoke(target, objects);

        //表演完成向观众致谢

        System.out.println("感谢大家的观看");

        return returnValue;

    }

}

测试

public class Test {

    public static void main(String[] args) {

        //目标对象

        Performer perform = new Performer();

        PerformProxy performProxy = new PerformProxy(perform);

        //生成代理对象

        Performer proxy = (Performer)performProxy.getProxyInstance();

        proxy.perform();

    }

}

在Spring的AOP编程中: 如果加入容器的目标对象有实现接口,用JDK代理 如果目标对象没有实现接口,用Cglib代理

你可能感兴趣的:(设计模式知识点整理-代理模式(静态代理,jdk动态代理,cglib动态代理))