现实生活中，存在着各种代理，比如海外代购，律师，游戏代练等等，映射到Java中，也存在着代理，汇总实际场景中的使用，将代理分为了静态代理和动态代理两种模式。
StaticProxy
静态代理拆开来，静态指的是在程序运行前就已经存在了代理类的字节码文件，也就是这个代理类是程序员手动编写的，代理类和被代理类的关系就已经确定了的，代理指的就是编写的代理类对被代理类的增强效果。
场景一：
张三看上了海外一家公司CompanyA制造的一款包，如果他自己想要买这款包，他就需要出国购买，出国前办理签证，坐飞机，买包，坐飞机，回家。但他并不像这么麻烦，于是他便找了一家代购店，于是张三所做的事情就是给钱，拿包完事，至于中间代购店如何出的国，如何坐的飞机，跟张三毫无关系，因为张三的目的就是要这个包，抽象如下：
业务接口BusinessA（制造包）
/**
* Description: 制造包的业务接口
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public interface BusinessA {
void createBag();
}
生产包的厂商CompanyA：
/**
* Description: 国外生产包的厂商A，但不限于A，可能还有B，C 。。。
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public class CompanyA implements BusinessA {
@Override
public void createBag() {
System.out.println("CompanyA公司生产的包。");
}
}
代理类ProxyStore：
/**
* Description: 代理商店，它对外宣称有卖包的业务
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public class ProxyStore implements BusinessA {
private CompanyA companyA;
@Override
public void createBag() {
// 1. 在购买前做的事
doBefore();
// 2. 从厂商购买
companyA.createBag();
// 3. 运回国内
doAfter();
}
private void doBefore() {
System.out.println("办理签证，坐飞机去国外。");
}
private void doAfter() {
System.out.println("从国外运回国内。");
}
public CompanyA getCompanyA() {
return companyA;
}
public void setCompanyA(CompanyA companyA) {
this.companyA = companyA;
}
}
测试：
/**
* Description:
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public class Test01 {
@Test
public void m1() {
// 创建代理类
ProxyStore proxyStore = new ProxyStore();
// 让代理有买包的权利
proxyStore.setCompanyA(new CompanyA());
// 由代理去购买
proxyStore.createBag();
}
}
静态代理的优缺点：
- 优点：业务类只需要关注业务本身，无需关心业务前后所做的增强处理，这些都交给代理来处理。
- 缺点：代理类代理的业务单一，假如业务接口扩展了，还需要改动代理类的代码，增加维护的成本。
DynamicProxy
动态代理拆开，动态指的是代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。
- Proxy类，它是所有动态代理的父类，其中利用静态方法newProxyInstance()来创建代理类。
- InvocationHandler接口，其中invoke方法的作用就是在代理类中调用目标方法，并返回结果。
- invoke方法的三个参数
- proxy：代理对象的实例
- method：通过它可以调用真实方法
- args：传过来的参数
还是上面静态代理的例子(以下为JDK动态代理，只能代理接口)：
业务接口BusinessA：
/**
* Description: 制造包的业务接口
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public interface BusinessA {
void createBag();
}
业务接口BusinessB：
/**
* Description: 制造手表的业务接口
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public interface BusinessB {
void createWatch();
}
生产包的厂商CompanyA：
/**
* Description: 国外生产包的厂商A，但不限于A，可能还有B，C 。。。
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public class CompanyA implements BusinessA {
@Override
public void createBag() {
System.out.println("CompanyA公司生产的包。");
}
}
生产手表的厂商CompanyB：
/**
* Description: 国外生产手表的厂商CompanyB
*
* @Author 70KG
* @Date 2019/3/12
* @Since v1.0
*/
public class CompanyB implements BusinessB {
@Override
public void createWatch() {
System.out.println("CompanyB公司生产的手表。");
}
}
代理类：
需要实现InvocationHandler接口，并且重写invoke方法，还需要一个获取代理对象的方法getProxyInstance。
/**
* description 实现InvocationHandler接口的动态代理类
*
* @author 70KG
* @date 2019/3/12
*/
public class ProxyClassBeans implements InvocationHandler {
/**
* 被代理的对象
**/
private Object tar;
/**
* 利用反射来调用目标方法
**/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 1. 调用目标方法之前
doBefore();
// 2. 调用目标方法
Object invoke = method.invoke(tar, args);
// 3. 调用目标方法之后
doAfter();
return invoke;
}
/** 绑定该类实现的所有接口，取得代理类 **/
public Object getProxyInstance() {
return Proxy.newProxyInstance(tar.getClass().getClassLoader(), tar.getClass().getInterfaces(), this);
}
// ===================动态代理类中的增强方法========================
public void doBefore() {
System.out.println("在国外寻找优质的货源。");
}
public void doAfter() {
System.out.println("精包装安全邮寄回国内。");
}
// ===========================get/set=============================
public Object getTar() {
return tar;
}
public void setTar(Object tar) {
this.tar = tar;
}
}
测试：
/**
* description
*
* @author 70KG
* @date 2019/3/12
*/
public class MainTest {
public static void main(String[] args) {
// 获取动态代理类
ProxyClassBeans proxyClassBeans = new ProxyClassBeans();
IBusinessA companyA = new CompanyA();
// 将目标类交给代理类
proxyClassBeans.setTar(companyA);
// 拿到代理对象
IBusinessA instance1 = (IBusinessA) proxyClassBeans.getProxyInstance();
instance1.createBag();
System.out.println("=================================");
IBusinessB companyB = new CompanyB();
proxyClassBeans.setTar(companyB);
IBusinessB instance2 = (IBusinessB) proxyClassBeans.getProxyInstance();
instance2.saleWatch();
}
}
运行结果：
在国外寻找优质的货源。
CompanyA公司生产的包。
精包装安全邮寄回国内。
=================================
在国外寻找优质的货源。
CompanyB公司生产的手表。
精包装安全邮寄回国内。
由运行结果可知，动态代理在增添业务的时候(增添了卖手表的业务)，只需要调用者传入不同的接口就好了，代理类不需要改动。
动态代理的优缺点：
- 优点：同样，我们只关注业务类的逻辑即可，并且如果新增业务类，代理类的代码根本不需要动，因为代理对象是根据传入的接口类型生成的，方便扩展。
- 缺点：JDK动态代理，在生成代理对象的时候必须传入业务类的接口类型，也就是只能够代理接口。能够代理类的动态代理是CGLIB动态代理。