目的：在代理类中实现对操作目标类的控制，间接访问
优点：中介隔离了一层，调用对象类的时候，不需要直接操作，而是由第三方的代理类操作，这样更有利于解耦，有高扩展性
缺点：代码量增加，静态代理的每一个实体类的业务逻辑都需要有个对应代理类来完成。
设计场景如下：
我们现在要通过中介买房，我们需要做的是看房，中介会完成帮我们跟业主沟通，挑选房子，带我们去看，拿钥匙开门，谈价格等等一系列工作，而我们需要做的就是看房子和付款。
静态代理——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
