关于分库分表的实现

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/csujiangyu/article/details/61197621

当数据大的时候,都会考虑分库分表的实现。分库分表可以在不同的层做。一般来说有以下几种:

  • jdbc层:实现复杂,属于轻量级,对应用基本没有侵入性;缺点是不能复用数据库连接,在应用部署多的时候资源耗费大,不适于大规模部署。类似当当网的sharding-jdbc.
  • ORM层:比如蘑菇街TSharding框架封装mybatis,实现简单。缺点是必须依赖ORM层,侵入性比较大。
  • DBProxy层:如cobar和mycat,可以做到连接复用,性能不错,完全没侵入性。缺点是实现复杂,框架比较重,维护工作量大。
  • DAO层:实现简单,缺点是分表比较麻烦。美团的框架似乎就是这样做到。

无论怎么做分库分表,其基本思路都是一样的。需要有分库路由,分库规则,分库关键字等。

下面简单用Spring在DAO层做一个分库的实现。假如有2个数据源,通过在RouteKey选择不同的数据源。

设计路由关键字

public enum RouteKey {
    CURRENT,

    HISTORY;

    private static Map<String, RouteKey> map = new HashMap<>(values().length);

    static {
        for (RouteKey routeKey : values()) {
            map.put(routeKey.name(), routeKey);
        }
    }

    public static RouteKey convertRoutekey(String key) {
        return map.get(key);
    }

}

设计路由注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface DataSourceConfig {

    String key();

}

路由规则实现,利用了Spring的AOP思想,对DAO方法做个拦截,进来做到对应用的无侵入性。根据传入的参数,绑定不同的路由key到当前线程,为了后续获取connection时候需要。

@Component
@Aspect
//@Order(0)
public class DataSourceAspect {

    private static final LocalVariableTableParameterNameDiscoverer parameterNameDiscoverer =
            new LocalVariableTableParameterNameDiscoverer();

    private static final ConcurrentHashMap<Method, String[]> paramNameMap = new ConcurrentHashMap<>();

    @Around(value = "@annotation(dataSourceConfig)", argNames = "joinPoint, dataSourceConfig")
//    @Around(value = "@annotation(dataSourceConfig) && args(dataSourceConfig)")
    public Object dataSourceAspect(ProceedingJoinPoint joinPoint, DataSourceConfig dataSourceConfig) throws Throwable {
        String keyName = dataSourceConfig.key();

        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();


        String[] paramNames = paramNameMap.get(method);
        if (paramNames == null) {
            synchronized (this) {
                String[] names = paramNameMap.get(method);
                if (names == null){
                    names = parameterNameDiscoverer.getParameterNames(method);
                }

                paramNames = names;

            }
        }

        Object[] args = joinPoint.getArgs();
        RouteKey routeKey;

        int i = 0;
        for (String name : paramNames) {
            if (name.equals(keyName)) {
                routeKey = (RouteKey) args[i];
                DataSourceKeyHolder.setRouteKey(routeKey);
                break;
            }

            i++;
        }

        try {
            return joinPoint.proceed();

        } finally {

            DataSourceKeyHolder.clear();
        }
    }
}

扩展AbstractRoutingDataSource类,重载determineCurrentLookupKey方法,路由到不同的库

public class CustomDataSource extends AbstractRoutingDataSource {


    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceKeyHolder.getRouteKey().name();
    }
}

DataSourceKeyHolder是个ThreadLocal,将路由key绑定到当前线程。Spring很多涉及事务操作的都会用到ThreadLocal。

public class DataSourceKeyHolder {

    private static final ThreadLocal<RouteKey> holder = new ThreadLocal<RouteKey>(){
        protected RouteKey initialValue() {
            return RouteKey.CURRENT;
        }
    };

    public static RouteKey getRouteKey(){
        return holder.get();
    }


    public static void setRouteKey(RouteKey key){
        holder.set(key);
    }


    public static void clear(){
        holder.remove();
    }

}

数据源配置。Spring事务会在方法前获取数据连接connection,但是这时还没有到DAO层进行路由选择,因此需要延迟加载数据源,需要用到LazyConnectionDataSourceProxy。

 <bean id="dataSource1" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/example"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <bean id="dataSource2" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/example2"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

        <bean id="dataSource" class="com.ydoing.spring.core.transaction.CustomDataSource">
      <property name="targetDataSources">
          <map>
              <entry key="CURRENT" value-ref="dataSource1"/>
              <entry key="HISTORY" value-ref="dataSource2"/>
          </map>
      </property>
    </bean>

    <bean id="lazyDataSource" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">
        <property name="targetDataSource" ref="dataSource"/>
    </bean>


    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="lazyDataSource"/>
    </bean>


    <tx:annotation-driven transaction-manager="txManager" />

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="lazyDataSource"/>
    </bean>

怎么使用?

    @Transactional
    @DataSourceConfig(key = "key")
    public void update(RouteKey key) {

        String sql2 = "insert into customer(name, age, address,  code) values ('Jack', 12, 'BJ', '002')";
        int effectNum = jdbcTemplate.update(sql2);

        System.out.println(effectNum);
    }
展开阅读全文

没有更多推荐了,返回首页