定义： 为其他对象提供一种代理，以控制对这个对象的访问
代理对象在客户端和目标对象之间起到中介的作用
类型： 结构性
适用场景
1、保护目标对象
2、增强目标对象
优点
代理模式能将代理对象与真实被调用的目标对象分离
一定程度上降低了系统的耦合度，扩展性好
保护目标对象
增强目标对象（如加before和after）
缺点：
代理模式会造成系统设计中类数目增加
在客户端和目标对象增加一个代理对象，会造成请求速度变慢
增加系统的复杂度
代理-扩展
静态代理
动态代理
CGLib代理
Spring 代理选择-扩展
当Bean有实现接口时，Spring就会用JDK的动态代理
当Bean没有实现接口时，Spring使用CGlib
可以强制使用Cglib
在spring配置中加入 <aop:aspectj-autoproxy proxy-target-class="true" />
静态代理实践（另外一个静态代理的例子Spring AOP原理）
1、创建实体Order
public class Order {
private Object orderInfo;
private Integer userId;
public Object getOrderInfo() {
return orderInfo;
}
public void setOrderInfo(Object orderInfo) {
this.orderInfo = orderInfo;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
}
2、创建Dao层
IOrderDao接口
public interface IOrderDao {
int insert(Order order);
}
IOrderDao接口实现
public class OrderDaoImpl implements IOrderDao {
@Override
public int insert(Order order) {
System.out.println("Dao层添加Order成功");
return 1;
}
}
3、创建服务层
创建IOrderService 接口
public interface IOrderService {
int saveOrder(Order order);
}
创建IOrderService 接口实现
public class OrderServiceImpl implements IOrderService{
private IOrderDao iOrderDao;
@Override
public int saveOrder(Order order) {
//Spring会自己注入，这里就直接注入了
iOrderDao = new OrderDaoImpl();
System.out.println("Service层调用Dao层添加Order");
return iOrderDao.insert(order);
}
}
4、模拟Spring中分库的使用介绍
创建DynamicDataSource
public class DynamicDataSource extends AbstractRoutingDataSource{
/**
* 返回值代表使用哪个Db
* @return
*/
@Override
protected Object determineCurrentLookupKey() {
return DataSourceContextHolder.getDBType();
}
}
创建DataSourceContextHolder
public class DataSourceContextHolder {
private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();
public static void setDBType(String dbType){
CONTEXT_HOLDER.set(dbType);
}
public static String getDBType(){
return (String) CONTEXT_HOLDER.get();
}
public static void clearDBType(){
CONTEXT_HOLDER.remove();
}
}
5、创建代理类
public class OrderServiceStaticProxy {
private IOrderService iOrderService;
public int saveOrder(Order order){
beforeMethod(order);
iOrderService = new OrderServiceImpl();
int result = iOrderService.saveOrder(order)
afterMethod();
return result;
}
private void beforeMethod(Order order){
System.out.println("静态代理 before code");
int userId = order.getUserId();
int dbRouter = userId % 2;
System.out.println("静态代理分配到【db" + dbRouter + "】处理数据");
// TODO: 2020/1/27 设置dataSource
DataSourceContextHolder.setDBType("db" + String.valueOf(dbRouter));
}
private void afterMethod(){
System.out.println("静态代理 after code");
}
}
6、测试
public class Test {
public static void main(String[] args) {
Order order = new Order();
order.setUserId(2);
OrderServiceStaticProxy orderServiceStaticProxy = new OrderServiceStaticProxy();
orderServiceStaticProxy.saveOrder(order);
}
}
7、UML图如下
8、输出结果如下
静态代理 before code 静态代理分配到【db0】处理数据 静态代理 after code Service层调用Dao层添加Order Dao层添加Order成功
动态代理实践（另外一个动态代理的例子Spring AOP原理）
1、创建动态代理类
public class OrderServiceDynamicProxy implements InvocationHandler{
private Object target;
public OrderServiceDynamicProxy(Object target){
this.target = target;
}
public Object build(){
Class cls = target.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces() ,this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object argObject =args[0];
beforeMethod(argObject);
Object object = method.invoke(target, args);
afterMethod();
return object;
}
private void beforeMethod(Object obj){
int userId = 0;
System.out.println("动态代理 before code");
if(obj instanceof Order){
Order order = (Order)obj;
userId = order.getUserId();
}
int dbRouter = userId % 2;
System.out.println("动态代理分配到【db" + dbRouter + "】处理数据");
// TODO: 2020/1/27 设置dataSource
DataSourceContextHolder.setDBType("db" + String.valueOf(dbRouter));
}
private void afterMethod(){
System.out.println("动代理 after code");
}
}
2、测试
public class Test {
public static void main(String[] args) {
Order order = new Order();
order.setUserId(2);
IOrderService orderServiceDynamicProxy = (IOrderService)new OrderServiceDynamicProxy(new OrderServiceImpl()).build();
orderServiceDynamicProxy.saveOrder(order);
}
}
3、输出
动态代理 before code 动态代理分配到【db0】处理数据 Service层调用Dao层添加Order Dao层添加Order成功 动代理 after code
代理模式在源码中的应用
1、JDK中的java .lang.reflet.Proxy类
2、Spring中的ProxyFactoryBean
核心的方法为getObject()
还有JdkDynamicAopProxy和CglibAopProxy
3、Mybatis中
MapperProxyFactory