示例类图

静态代理.png

示例代码

被代理部分

• Order
• IOrderDao
• IOrderService
• OrderDaoImp
• OrderServiceImpl

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;
    }

}

public interface IOrderDao {
    int insert(Order order);
}

public interface IOrderService {
    int saveOrder(Order order);
}

public class OrderDaoImpl implements IOrderDao {
    @Override
    public int insert(Order order) {
        System.out.println("Dao层添加Order成功");
        return 1;
    }
}

public class OrderServiceImpl implements IOrderService {

    private IOrderDao iOrderDao;

    @Override
    public int saveOrder(Order order) {
        //Spring会自己注入，我们课程中就直接new了
        iOrderDao = new OrderDaoImpl();
        System.out.println("Service层调用Dao层添加Order");
        return iOrderDao.insert(order);
    }

}

代理部分

• 代理类 OrderServiceStaticProxy 组合进了一个 IOrderService 作为被代理的对象；
• 在代理类中，增强了 IOrderService.saveOrder(order) 方法，具体模拟的是多数据源的分配；

import designpattern.structural.proxy.IOrderService;
import designpattern.structural.proxy.Order;
import designpattern.structural.proxy.OrderServiceImpl;
import designpattern.structural.proxy.db.DataSourceContextHolder;

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){
        int userId = order.getUserId();
        int dbRouter = userId % 2;
        System.out.println("静态代理分配到【db" + dbRouter + "】处理数据");

        //todo 设置dataSource;
        DataSourceContextHolder.setDBType("db" + String.valueOf(dbRouter));
        System.out.println("静态代理 before code");
    }

    private void afterMethod(){
        System.out.println("静态代理 after code");
    }

}

public class DataSourceContextHolder {

    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<String>();

    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();
    }

}

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDBType();
    }

//    <bean id="db0" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
//      ...
//    </bean>

//    <bean id="db1" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
//      ...
//    </bean>

//  <bean id="dataSource" class="com.geely.design.pattern.structural.proxy.db.DynamicDataSource">
//      <property name="targetDataSources">
//          <map key-type="java.lang.String">
//              <entry value-ref="db0" key="db0"></entry>
//              <entry value-ref="db1" key="db1"></entry>
//          </map>
//      </property>
//      <property name="defaultTargetDataSource" ref="db0"></property>
//  </bean>

//  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
//      <property name="dataSource" ref="dataSource" />
//  </bean>

}

测试类

public class Test {
    public static void main(String[] args) {
        Order order = new Order();
        order.setUserId(2);

        OrderServiceStaticProxy orderServiceStaticProxy = new OrderServiceStaticProxy();
        orderServiceStaticProxy.saveOrder(order);
    }
}

输出：

静态代理分配到【db0】处理数据
静态代理 before code
Service层调用Dao层添加Order
Dao层添加Order成功
静态代理 after code