代理模式

静态代理:

代理类实现接口,构造方法传入实现类实例,代理类重写接口方法,加入逻辑。


public class ProxyDemo {
    public static void main(String args[]){
        IRequest subject = new RealSubject();
        Proxy p = new Proxy(subject);
        p.request();
    }
}

interface IRequest{
    void request();
}

class RealSubject implements IRequest{
    public void request(){
        System.out.println("request");
    }
}

class Proxy implements IRequest{
    private IRequest subject;
    public Proxy(IRequest subject){
        this.subject = subject;
    }
    public void request(){
        System.out.println("proxy before");
        subject.request();
        System.out.println("proxy after");
    }
}

代理类是在编译时就实现好的。也就是说 Java 编译完成后代理类是一个实际的 class 文件。


动态代理:

动态代理:代理类是在运行时生成的。也就是说 Java 编译完之后并没有实际的 class 文件,而是在运行时动态生成的类字节码,并加载到JVM中。动态代理类使用字节码动态生成加载技术,在运行时生成加载类。生成动态代理类的方法很多,如,JDK 自带的动态处理、CGLIB、Javassist 或者 ASM 库。JDK 的动态代理使用简单,它内置在 JDK 中,因此不需要引入第三方 Jar 包,但相对功能比较弱。

构造类实现InvocationHandler接口,重写Invoke方法,构造方法传入实现类。 相对优点:不用重写所有接口方法。但是只能对接口实现。

动态代理常被应用到以下几种情况中:

  1. 数据库连接以及事务管理
  2. 单元测试中的动态 Mock 对象
  3. 自定义工厂与依赖注入(DI)容器之间的适配器
  4. 类似 AOP 的方法拦截器
public class DynamicProxyDemo01 {
    public static void main(String[] args) {
        Subject realSubject = new RealSubject();    //1.创建委托对象
        ProxyHandler handler = new ProxyHandler(realSubject);   //2.创建调用处理器对象
        Subject proxySubject = (Subject) Proxy.newProxyInstance(RealSubject.class.getClassLoader(),
                RealSubject.class.getInterfaces(), handler);    //3.动态生成代理对象
        proxySubject.request(); //4.通过代理对象调用方法
    }
}

/**
 * 接口
 */
interface Subject{
    void request();
}

/**
 * 委托类
 */
class RealSubject implements Subject{
    public void request(){
        System.out.println("====RealSubject Request====");
    }
}
/**
 * 代理类的调用处理器
 */
class ProxyHandler implements InvocationHandler {
    private Subject subject;
    public ProxyHandler(Subject subject){
        this.subject = subject;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("====before====");
        Object result = method.invoke(subject, args);
        System.out.println("====after====");
        return result;
    }
}

public interface IDBQuery {
        String request();
    }

public class DBQuery implements IDBQuery {
        public DBQuery() {
            try {
                Thread.sleep(1000);//假设数据库连接等耗时操作
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }

        @Override
        public String request() {
            return "request string";
        }
    }
public class DBQueryHandler implements InvocationHandler {
    IDBQuery realQuery = null;//定义主题接口

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //如果第一次调用,生成真实主题
        if(realQuery == null){
            realQuery = new DBQuery();
        }
        //返回真实主题完成实际的操作
        return realQuery.request();
    }

    public static IDBQuery createProxy(){
        IDBQuery proxy = (IDBQuery) Proxy.newProxyInstance(
                ClassLoader.getSystemClassLoader(), new Class[]{IDBQuery.class}, new DBQueryHandler()
        );
        return proxy;
    }

    @Test
    public void test(){
        IDBQuery idbQuery=createProxy();
        System.out.println(idbQuery.request());
    }
}

当使用者调用了代理对象所代理的接口中的方法的时候,这个调用的信息会被传递给InvocationHandler的invoke方法。在 invoke方法的参数中可以获取到代理对象、方法对应的Method对象和调用的实际参数。invoke方法的返回值被返回给使用者。这种做法实际上相 当于对方法调用进行了拦截。
代码一:

    private static HelloService getHelloServiceProxy() {
        HelloService helloService = new HelloServiceImpl();
        InvocationHandler handler = new JavaDynamicProxy(helloService);

        return (HelloService) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                helloService.getClass().getInterfaces(), handler);
    }

代码二:

    public List getList(final List list) {
        return (List) Proxy.newProxyInstance(DummyProxy.class.getClassLoader(), new Class[] { List.class },
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if ("add".equals(method.getName())) {
                            throw new UnsupportedOperationException();
                        }
                        else {
                            return method.invoke(list, args);
                        }
                    }
                });
    }

cglib:

既可以对接口,也可以对类实现。
http://blog.csdn.net/danchu/article/details/70238002

参考文章:
https://www.jianshu.com/p/6f6bb2f0ece9

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成,浏览时请结合常识与多方信息审慎甄别。
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

相关阅读更多精彩内容

  • 代理模式是常用的结构型设计模式之一,当无法直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问,...
    SnDragon阅读 1,460评论 2赞 4
  • 一> 代理模式 概述 代理(Proxy)是一种设计模式, 提供了对目标对象另外的访问方式;即通过代理访问目标对象。...
    奋斗的老王阅读 1,250评论 0赞 50
  • 原文连接 简介 Java编程的目标是实现现实不能完成的,优化现实能够完成的,是一种虚拟技术。生活中的方方面面都可以...
    zjk_00阅读 433评论 0赞 0
  • 2017年4月10日 1.感恩爸妈帮助照顾孩子。 2.感恩儿子让我成长,现在小脾气见长。 3.感恩先生的关心,为家...
    冯梓源阅读 167评论 0赞 0
  • 站在十字路口 向左还是向右 没有人能告诉你正确的方向是哪一边 不管是内向还是外向 都无法感到快乐的时候 是自己本身...
    臻悉阅读 314评论 1赞 2

友情链接更多精彩内容