java设计模式-代理模式

1:简介

在有些情况下,一个操作者不能或者不想直接访问另一个对象,这时需要找一个对象来完成任务,这个对象就是代理对象。

比如,购买火车票可以通过 12306 网站或者去火车票代售点买。虽然如此,但是他们最终的目的都是能拿到火车票,中间增加了一层代理的过程,但是不影响我们坐车

代理模式的定义:由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问对象不适合或者不能直接引用目标对象,代理对象作为访问对象和目标对象之间的中介。

代理模式的主要优点有:

  • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用;
  • 代理对象可以扩展目标对象的功能;
  • 代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度,增加了程序的可扩展性

其主要缺点是:

  • 代理模式会造成系统设计中类的数量增加
  • 在客户端和目标对象之间增加一个代理对象,会造成请求处理速度变慢;
  • 增加了系统的复杂度;

静态代理模式的实现

  1. 抽象主题(Proxy)类:通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  2. 真实主题(ShowImplProxy)类:实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。
  3. 代理(ProxyImplProxy)类:提供了与真实主题相同的接口,其内部含有对真实主题的引用,它可以访问、控制或扩展真实主题的功能。

代码如下

1:接口

public interface Proxy {

    void showMethod();
}

2:真实主题实现方法

//真实主题实现方法
public class ShowImplProxy implements Proxy{
    @Override
    public void showMethod() {
        System.out.println("=============ShowImplProxy执行方法===============");
    }
}

3:代理实现类

复制代码
//代理实现类
public class ProxyImplProxy implements Proxy{

    private ShowImplProxy showImplProxy;

    public ProxyImplProxy(ShowImplProxy showImplProxy) {
        this.showImplProxy = showImplProxy;
    }
    public ProxyImplProxy() {

    }

    @Override
    public void showMethod() {

        if(showImplProxy == null ){
            showImplProxy = new ShowImplProxy();
        }

        preMethod();
        showImplProxy.showMethod();
        postMethod();
    }



    public void preMethod(){
        System.out.println("方法执行之前处理");
    }


    public void postMethod(){
        System.out.println("方法执行之后处理");
    }
}
复制代码

4:方法调用

复制代码

package
com.test.proxy; public class MainApplication { public static void main(String[] args) { ProxyImplProxy proxy = new ProxyImplProxy(); proxy.showMethod(); } }
复制代码

打印结果:

1
2
3
方法执行之前处理
=============ShowImplProxy执行方法===============
方法执行之后处理

  

当然,上述方法虽然实现了,但是隐藏了诸多问题,那就是,不够灵活,因为类被限定,所以这个代理不够通用,那怎么办了,此时就需要使用到动态代理!

 

 

动态代理模式实现

  1. 抽象主题(MyProxy)类:通过接口或抽象类声明真实主题和代理对象实现的业务方法。
  2. 真实主题(ShowImplProxy)类:实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。
  3. 代理(JdkHandler)类:JDK动态代理。

1:首先还是需要接口

public interface MyProxy {

    void showMethod();
}

2:实现它的具体类

public class ShowImplProxy implements MyProxy {
    @Override
    public void showMethod() {
        System.out.println("=============ShowImplProxy执行方法===============");
    }
}

3:采用jdk动态代理实现方法,具体操作是,实现InvocationHandler,操作invoke方法

复制代码
package com.test.proxy.jdkproxy;


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

public class JdkHandler implements InvocationHandler {

    private Object obj;

    public JdkHandler(Object object) {
        this.obj = object;
    }

    public JdkHandler() {
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("---------invoke之前--------");
        method.invoke(obj,args);
        System.out.println("---------invoke之后--------");
        return null;
    }
}
复制代码

 

4:调用时,需要传递相关的参数就能实现动态代理了

复制代码
package com.test.proxy;

import com.test.proxy.jdkproxy.JdkHandler;

import java.lang.reflect.Proxy;

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


        MyProxy proxy = (MyProxy)Proxy.newProxyInstance(
                ShowImplProxy.class.getClassLoader(),
                ShowImplProxy.class.getInterfaces(),
                new JdkHandler(new ShowImplProxy())
        );

        proxy.showMethod();
    }
}
复制代码

打印结果:

---------invoke之前--------
=============ShowImplProxy执行方法===============
---------invoke之后--------

 

静态代理和动态代理的区别:

  • 静态代理只能通过手动完成代理操作,如果被代理类增加了新的方法,则代理类需要同步增加。
  • 动态代理采用在运行时动态生成代码的方式,取消了对被代理类的扩展限制。

 

posted @   鸭猪是的念来过倒  阅读(28)  评论(0编辑  收藏  举报
(评论功能已被禁用)
相关博文:
阅读排行:
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· DeepSeek “源神”启动!「GitHub 热点速览」
· 我与微信审核的“相爱相杀”看个人小程序副业
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
点击右上角即可分享
微信分享提示