设计模式——代理模式-个人IP:shigen

时间:2024-03-05 12:11:09

最近在学习的时候,突然看到了代理模式。一看就很熟悉,因为在spring中大量用到了代理模式。那接下来将结合查询到的资料和代码,分享一下代理模式的分类和实现,以及golang版本的。

先来看下代理模式的类图,拒绝乱七八糟的文字

代理模式

很简单,就是在一个接口的实现类方法处理逻辑中执行其他的逻辑。一分析,重点来了!如何获得接口实现类方法

静态代理

很简单的一种方式就是我再写一个类,直接把原有的方法调用一遍,不同的是我现在混杂了新逻辑,三方使用的话,也是调用我的新代码逻辑。

相信接下来的代码大家一看就明白,我就直接贴上代码了:

java实现

java版本代理模式

同样我们改造一下,就是go的实现:

go版本
import "fmt"

// Subject 接口定义了需要被代理的对象的方法
type Subject interface {
	Request() string
}

// RealSubject 是需要被代理的对象
type RealSubject struct{}

func (r *RealSubject) Request() string {
	return "RealSubject: 处理请求"
}

// Proxy 是代理对象,它包含了一个指向 RealSubject 的引用
type Proxy struct {
	realSubject *RealSubject
}

func (p *Proxy) Request() string {
	// 在这里可以进行一些额外的操作,例如鉴权、日志等
	result := "Proxy: 转发请求到 RealSubject\n"
	if p.realSubject == nil {
		p.realSubject = &RealSubject{}
	}
	result += " " + p.realSubject.Request()
	return result
}

// 使用代理模式来使用 RealSubject 对象
func main() {
	// proxy := &Proxy{}
	// fmt.Println(proxy.Request())

	realSubject := &RealSubject{}
	fmt.Println(realSubject.Request())
}

注:代码和文章参考:

  • 详解设计模式:代理模式
  • golang代理模式

动态代理

官方一点的话术是这样的:由于静态代理只能够对一种类型(接口)进行代理,如果想要对多种类型进行代理的话就需要创建多个代理类,为了弥补了静态代理的不足,从而出现了动态代理,使用反射技术实现。

我直接表示看不懂,直呼看不懂。

来点简单的,我直接放代码吧:

简单的代码结构

关键点在于我的Proxyfactory:

public class ProxyFactory {

    public <T> SmsService getProxyObject(T target) {
        /**
         * ClassLoader loader, 类加载器,加载代理类
         * Class<?>[] interfaces, 真实对象实现接口
         * InvocationHandler h 代理对象处理的函数
         */
        if (target instanceof SmsService) {
            return (SmsService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
                @Override
                public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                    System.out.println("开始代理");
                    Object result = method.invoke(target, objects);
                    System.out.println("代理结束");
                    return result;
                }
            });
        } else {
            throw new IllegalArgumentException("Target object must implement the specified interface");
        }
    }

}

函数的参数target就是需要代理的对象。这里可以封装成一个统一的工具类,先不做展示了。

代码的调用方面:

public class MainMethod {

    public static void main(String[] args) {
        // 生成新对象
        PhoneSmsService phoneSmsService = new PhoneSmsService();
        PcSmsService pcSmsService = new PcSmsService();

        ProxyFactory proxyFactory = new ProxyFactory();
        SmsService PhoneProxyObject = proxyFactory.getProxyObject(phoneSmsService);
        SmsService pcProxyObject = proxyFactory.getProxyObject(pcSmsService);

        PhoneProxyObject.send();
        pcProxyObject.send();
    }

}

运行结果:

运行结果

所以对比之下,动态代理的优点就很明显了:

  1. 简化开发:相比静态代理,动态代理可以减少重复代码;
  2. 更灵活:动态代理可以在运行时动态地创建代理对象,可以应用于更广泛的场景。

在此,设计模式的学习+1。