代理模式-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