代理模式是在二十三种设计模式中比较接近现实生活和容易理解的一种设计模式，简单的来说就是A通过B的代理，与C进行通信，如图：
当然这样看来并没有增加A与C通信的效率，反而多了一层代理，但是，当A多了以后呢？
显然，这样可以只让B与C进行通信，类似于多加了一层的代理层，专门用来处理请求，再来一个现实点的例子：
如果一个人有事想找你你可以直接与他对话，而如果一群人想找你你一定不能同时与他们进行对话，就需要一个一个的回复，比如我们平常的移动联系方式微信，此时他就可以代理你进行消息的接收和回复，如图 ：
因此，我们总结下代理模式的概念和优点：
定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
优点：（1）职责清晰 （2）高扩展性（3）智能化
2 代理模式(静态代理)静态代理简单的说就是接口代理实现类，当一个或多个类实现一个接口后，需要将接口的方法进行实现，当类进行实例化时使用接口进行代理方法的实现，直接调用接口的方法而不是实现类的方法。
/**
* 代理模式（静态代理）
*
* @author 17122
*/
public class StaticProxy {
public static void main(String[] args) {
People people = new Programmer();
people.sayHello();
}
}
interface People {
/**
* sayHello方法
*/
void sayHello();
}
class Student implements People {
@Override
public void sayHello() {
System.out.println("Hello I am a Student");
}
public void study() {
System.out.println("Study");
}
}
class Programmer implements People {
@Override
public void sayHello() {
System.out.println("Hello I am a Programmer");
}
public void playCode() {
System.out.println("Play code");
}
}
动态代理的实现较为复杂，因为要实现动态代理就需要依托Java的反射机制，就是JDK官方原生的代理，继承InvocationHandler接口，实现invoke方法，就可以自定义代理工具类，根据不同的类进行动态的代理。
/**
* 动态代理
*
* @author 17122
*/
public class DynamicProxy {
public static void main(String[] args) {
Boos boos = new Boos();
Worker worker = new Worker();
getDynamicProxy(worker, Worker.class);
getDynamicProxy(boos, Boos.class);
}
/**
* 动态代理实现方法
*
* @param obj
* @param clazz
*/
public static void getDynamicProxy(Object obj, Class clazz) {
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(obj);
Courier instance = (Courier) Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), myInvocationHandler);
instance.takeSomething();
}
}
/**
* 快递员
*/
interface Courier {
/**
* 取东西
*/
void takeSomething();
}
class Worker implements Courier {
@Override
public void takeSomething() {
System.out.println("Worker take Something");
}
}
class Boos implements Courier {
@Override
public void takeSomething() {
System.out.println("Boos take Something");
}
}
class MyInvocationHandler implements InvocationHandler {
/**
* 被代理的目标类
*/
private Object target;
/**
* 构造方法 放入目标类
*
* @param target
*/
public MyInvocationHandler(Object target) {
this.target = target;
}
/**
* Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler.
* 返回指定接口的代理类实例，该接口将方法调用分派给指定的调用处理程序。
*
* @param proxy the class loader to define the proxy class 定义代理类的类装入器
* @param method the list of interfaces for the proxy class to implement 代理类要实现的接口列表
* @param args the invocation handler to dispatch method invocations to 将方法调用分派到的调用处理程序
* @return
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = method.invoke(target, args);
return result;
}
}
（1）最主要的不同就是动态代理依靠反射机制，可以在程序运行的过程中进行被代理对象的确定，而静态代理在程序编译时期就已经确定。
（2）静态代理需要自己写代码进行完成，而动态代理就是通过Proxy.newInstance()生成。
,
