目录
1.代理模式的应用场景
代理模式（Proxy Pattern）的定义非常简单，是指为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端与目标对象之间起到中介作用，代理模式属于 结构性设计模式。主要有两个目的：一是保护目标对象，二是增强目标对象。生活中的房产中介、售票黄牛、快递等都是代理模式的体现。
上图是代理模式的类结构图，其中Subject是顶层接口，RealSubject是真实对象（被代理对象），Proxy是代理对象，代理对象持有被代理对象的引用，客户端调用代理对象的方法，同时也调用被代理对象的方法，但是会在代理对象前后增加一些处理代码，这种一般被理解为代码增强。代理模式分为静态代理、动态代理
2.静态代理
以订单为例，静态代理的代码实现。
package nju.java.pattern.proxy_pattern;
//订单类
public class Order {
private Object orderInfo;
private long createTime;
private String id;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public long getCreateTime() {
return createTime;
}
public void setCreateTime(long createTime) {
this.createTime = createTime;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}
持久层：
package nju.java.pattern.proxy_pattern;
//持久层操作类
public class OrderDao {
public int insert(Order order){
System.out.println("OrderDao 创建Order成功");
return 1;
}
}
package nju.java.pattern.proxy_pattern;
public interface IOrderService {
int createOrder(Order order);
}
package nju.java.pattern.proxy_pattern;
import java.text.SimpleDateFormat;
import java.util.Date;
public class OrderService implements IOrderService {
private OrderDao orderDao;
public OrderService(){
//如果使用Spring 应该是自动注入
//为了使用方便，直接在构造函数中初始化
orderDao=new OrderDao();
}
@Override
public int createOrder(Order order) {
System.out.println("OrderService调用orderDao创建订单");
return orderDao.insert(order);
}
}
接下来使用静态代理，主要功能是：根据订单创建时间自动按年进行分库。
下面是动态切换数据源
package nju.java.pattern.proxy_pattern;
public class DynamicDataSourceEntry {
//默认数据源
public final static String DEFAULT_SOURCE = null;
private final static ThreadLocal<String> local=new ThreadLocal<String>();
private DynamicDataSourceEntry(){}
//清空数据源
public static void clear(){
local.remove();
}
//获取当前正在使用的数据源名字
public static String get(){
return local.get();
}
//还原当前切换的数据源
public static void restore(){
local.set(DEFAULT_SOURCE);
}
//设置已知名字的数据源
public static void set(String source){
local.set(source);
}
//根据年份动态设置数据源
public static void set(int year){
local.set("DB_"+year);
}
}
切换数据源的代理类：
package nju.java.pattern.proxy_pattern;
import java.text.SimpleDateFormat;
import java.util.Date;
public class OrderServiceStaticProxy implements IOrderService {
private SimpleDateFormat yearFormat=new SimpleDateFormat("yyyy");
private IOrderService orderService;
public OrderServiceStaticProxy(IOrderService orderService){
this.orderService=orderService;
}
//这里的就相当于方法增强，before、after都能为createOrder做很多事情
public int createOrder(Order order){
before();
Long time=order.getCreateTime();
Integer dbRouter=Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("静态代理类自动分配到【DB_"+dbRouter+"】数据源处理数据");
DynamicDataSourceEntry.set(dbRouter);
orderService.createOrder(order);
after();
return 0;
}
private void before() {
System.out.println("Proxy before method.");
}
private void after(){
System.out.println("Proxy after method.");
}
}
测试代码：
package nju.java.pattern.proxy_pattern;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestProxyPattern {
public static void main(String[] args) {
try{
//静态代理的测试
Order order=new Order();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd");
Date date=sdf.parse("2017/02/01");
order.setCreateTime(date.getTime());
IOrderService orderService=new OrderServiceStaticProxy(new OrderService());
orderService.createOrder(order);
} catch (Exception e) {
e.printStackTrace();
}
}
}
3.动态代理
动态代理和静态代理的基本思路一致，但是功能更加强大，适应性更轻。以找对象这项业务为例子，如果发展成了产业，出现了媒婆、婚介所等，那么用静态代理成本太高了，需要一个更加通用的解决方案：
3.1 JDK实现方式
创建媒婆（婚介所）类JDKMeipo:
package nju.java.pattern.proxy_pattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JDKMeipo implements InvocationHandler {
//被代理的对象，把引用保存下来
private Object target;
public Object getInstance(Object target)throws Exception{
this.target=target;
Class<?> clazz=target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
before();
Object obj=method.invoke(this.target,args);
after();
return obj;
}
private void after() {
System.out.println("如果合适的话，就准备办事");
}
private void before(){
System.out.println("我是媒婆:我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
}
单身客户类Customer：
package nju.java.pattern.proxy_pattern;
public class Customer implements Person{
@Override
public void findLove() {
System.out.println("有钱有颜");
System.out.println("脾性好");
System.out.println("讨人喜欢");
}
}
测试代码如下：
package nju.java.pattern.proxy_pattern;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestProxyPattern {
public static void main(String[] args) {
try{
//动态代理的测试
Person obj=(Person) new JDKMeipo().getInstance(new Customer());
obj.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
如果是数据源动态路由业务,看一下怎么实现动态代理：
package nju.java.pattern.proxy_pattern;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.text.SimpleDateFormat;
import java.util.Date;
public class OrderServiceDynamicProxy implements InvocationHandler {
private SimpleDateFormat yearFormat=new SimpleDateFormat("yyyy");
private Object target;
public Object getInstance(Object target){
this.target=target;
Class<?> clazz=target.getClass();
return Proxy.newProxyInstance(clazz.getClassLoader(),clazz.getInterfaces(),this);
}
public Object invoke(Object proxy, Method method,Object[] args)throws Throwable{
before(args[0]);
Object object=method.invoke(target,args);
after();
return object;
}
private void after() {
System.out.println("Proxy after method.");
}
private void before(Object arg) {
try {
System.out.println("Proxy before method");
//需要在OrderService里面实现getCreateTime()方法
Long time=(Long) target.getClass().getMethod("getCreateTime").invoke(target);
Integer dbRouter=Integer.valueOf(yearFormat.format(new Date(time)));
System.out.println("动态代理类自动分配到【DB_"+dbRouter+"】数据源处理数据");
DynamicDataSourceEntry.set(dbRouter);
}catch (Exception e){
e.printStackTrace();
}
}
}
测试代码：
package nju.java.pattern.proxy_pattern;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestProxyPattern {
public static void main(String[] args) {
try{
//动态代理的测试
Person obj=(Person) new JDKMeipo().getInstance(new Customer());
obj.findLove();
Order order1=new Order();
Date date1=sdf.parse("2018/02/01");
order.setCreateTime(date1.getTime());
IOrderService orderService1=(IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderService());
orderService1.createOrder(order1);
} catch (Exception e) {
e.printStackTrace();
}
}
}3.2 JDK动态代理
JDK动态代理功能非常强大，它生成对象的步骤如下：
（1）获取被代理对象的引用，并获取它所有的接口，反射获取。
（2）JDK动态代理类重新生成一个新的类，同时新的类要实现被代理类实现的所有接口。
（3）动态生成Java代码，新加的业务逻辑方法由一定的逻辑代码调用（在代码中体现）。
（4）编译新生成的Java代码.class文件。
（5）重新加载到JVM中运行
以上过程就叫字节码重组。JDK中有一个规范，在ClassPath下只要是$开头的.class文件，一般都是自动生成的。
手写实现可以查看后面提到的参考书籍
3.3 CGLib代理调用API及原理分析
还是以媒婆为例：
package nju.java.pattern.proxy_pattern;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibMeipo implements MethodInterceptor {
public Object getInstance(Class<?> clazz) throws Exception{
Enhancer enhancer=new Enhancer();
//设置即将生成的新类的父类
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
return enhancer.create();
}
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy)throws Throwable{
//业务的增强
before();
Object obj=methodProxy.invokeSuper(o,objects);
after();
return obj;
}
private void after() {
System.out.println("如果合适的话，就准备办事吧");
}
private void before() {
System.out.println("我是媒婆，我要给你找对象，现在已经确认你的需求");
System.out.println("开始物色");
}
}
package nju.java.pattern.proxy_pattern;
import net.sf.cglib.core.DebuggingClassWriter;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestProxyPattern {
public static void main(String[] args) {
try{
//测试CGLib
//利用CGlib的代理类可以将内存中的.class文件写入本地磁盘
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY
,"E://cglib_proxy_class/");
Customer obj1=(Customer)new CglibMeipo().getInstance(Customer.class);
obj1.findLove();
} catch (Exception e) {
e.printStackTrace();
}
}
}
上面就是CGlib的实现，它的执行代理方法的效率比JDK高，因为CGlib采用了FastClass机制，它的原理简单来说就是：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index(int 类型)；这个index当作一个入参，FastClass就可以直接定位要调用的方法并直接进行调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高。
3.4 CGLib和JDK动态代理对比
（1）JDK动态代理实现了被代理对象的接口，CGLib代理继承了被代理对象
（2）JDK动态代理和CGLib代理都在运行期生成字节码，JDK动态代理直接写Class字节码，CGLib代理使用ASM框架写Class字节码，CGLib代理实现更复杂，生成代理类比JDK动态代理效率低。
（3）JDK动态代理调用代理方法是通过反射机制调用的，CGLib代理是通过FastClass机制直接调用方法的，CGLib代理的执行效率更高。
4.代理模式与Spring
4.1 代理模式在Spring源码中的应用
ProxyFactoryBean核心方法getObject()，源码如下：
public Object getObject() throws BeansException {
initializeAdviso Chain();
if ( isSingleton ()) {
return getSingletoninstance ();
}
else {
if (this.targetName == null) {
logger .warn (” Using non-singleton proxies with singleton targets is often undesi able. ”＋"Enable prototype Poxies by setting the 'targetName' property. ”);
}
return newPrototypeInstance();
}
}在 getObjectO方法中，主要调用 getSingletouInstance()和 newPrototypeInstance() 在 Spring 的配置中如果不做任何设置，那么Spring代理生成的Bean都是单例对象。如果修改scope,则每次创建一个新的原型对象。newPrototypelnstance()。里面的逻辑比较复杂，我们后面再做深入研究，这里先做简单了解。Spring利用动态代理实现AOP时有两个非常重要类:JdkDynamicAopProxy类和CglibAopProxy类，来看一下类图，如下图所示。
4.2 Spring中的代理选择原则
（1）当Bean有实现接口时，Spring就会用JDK动态代理。
（2）当Bean没有实现接口时，Spring会选择CGLib代理。
（3）Spring可以通过配置强制使用CGLib代理，只需在Spring的配置文件中加入如下代码：
<aop:aSpectj-aUtoproxy proxy-target-clasS="true"/>
5.静态代理和动态代理的本质区别
（1） 静态代理只能通过手动完成代理操作，如果被代理类增加了新的方法，代理类需要同步增加，违背开闭原则。
（2） 动态代理釆用在运行时动态生成代码的方式，取消了对被代理类的扩展限制，遵循开闭原则。
（3） 若动态代理要对目标类的增强逻辑进行扩展，结合策略模式，只需要新增策略类便可完成，无须修改代理类的代码。
6.代理模式的优缺点
代理模式具有以下优点：
(1) 代理模式能将代理对象与真实被调用目标对象分离。
(2) 在一定程度上降低了系统的耦合性，扩展性好。
(3) 可以起到保护目标对象的作用。
(4) 可以增强目标对象的功能。
当然，代理模式也有缺点：
(1) 代理模式会造成系统设计中类的数量增加。
(2) 在客户端和目标对象中增加一个代理对象，会导致请求处理速度变慢。
(3) 增加了系统的复杂度。
代码位置：https://github.com/YellowDii/MySpring.git
参考书籍：《Spring5核心原理与30个类手写实现》
225
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
