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

静态代理——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);
	}
}

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