代理模式-go/java实现

目的:在代理类中实现对操作目标类的控制,间接访问

优点:中介隔离了一层,调用对象类的时候,不需要直接操作,而是由第三方的代理类操作,这样更有利于解耦,有高扩展性

缺点:代码量增加,静态代理的每一个实体类的业务逻辑都需要有个对应代理类来完成。

设计场景如下:

我们现在要通过中介买房,我们需要做的是看房,中介会完成帮我们跟业主沟通,挑选房子,带我们去看,拿钥匙开门,谈价格等等一系列工作,而我们需要做的就是看房子和付款。

静态代理——golang实现:

package proxypattern_static

import "fmt"

/*接口*/
type ISeller interface {
    /*定义接口实现方法*/
    deal(int)
}
/*代理类*/
type ProxySeller struct {
    seller Seller
}
/*实体类*/
type Seller struct {

}

/*代理类构造方法*/
func newProxySeller(seller Seller) *ProxySeller {
    return &ProxySeller{
        seller:seller,
    }
}
/*代理类实现接口及业务逻辑
    中介代替买家完成工作
*/
func (proxySeller ProxySeller) deal(money int) {
    if proxySeller.seller.deal(money) {
        proxySeller.seller.connectMoney(money)
        proxySeller.seller.transfer()
        fmt.Println("交易成功")
    } else {
        fmt.Println("交易失败")
    }
    fmt.Println("交易结束")
}

/*实体类实现接口
    卖家交易函数
 */
func (Seller) deal(money int) bool{
    if money > 100 {
        return true
    } else {
        return false
    }
}
/*实体类
    卖家收钱函数
*/
func (Seller) connectMoney(money int) {
    fmt.Println("卖家收到钱")
}

/*实体类
    卖家过户函数
*/
func (Seller) transfer(){
    fmt.Println("卖家过户")
}

func Excute(){
    proxySeller := newProxySeller(*new(Seller))
    proxySeller.deal(50)
    proxySeller.deal(200)
}

动态代理——java实现(后面学会go怎么实现再补充)

代理类实现InvocationHandler接口

public class ProxyHandler implements InvocationHandler {

    private Object object;

    public Object newProxyHandler(Object object) {
        this.object = object;
        return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        ISeller seller = (ISeller) this.object;
        if((boolean) method.invoke(this.object, args)) {
            System.out.println("交易成功");
            return true;
        } else {
            System.out.println("交易失败");
            return false;
        }
    }
}

接口

public interface Seller {
    public boolean deal(int price);
}

实现接口的实体类

public class ISeller implements Seller {

    @Override
    public boolean deal(int price) {
        // TODO Auto-generated method stub
        return price > 100 ? true : false;
    }
}

测试

public class Main {

    public static void main(String args[]) {
        ProxyHandler proxyHandler = new ProxyHandler();
        Seller seller = (Seller) proxyHandler.newProxyHandler(new ISeller());
        seller.deal(200);
        seller.deal(50);
    }
}

动态代理多用来实现面向切面编程,也就是所谓的AOP

原文 

https://studygolang.com/articles/17254

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 代理模式-go/java实现

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址