如何写一个读写分离中间件

MiniMax H3 + ComfyUI 影视级视频生成工作流搭建指南 AI视频生成正在从单帧图像生成向影视级叙事创作演进,核心挑战在于如何保持角色一致性、动作连贯性与镜头稳定性。文生视频模型虽能产出高质感片段,却难以满足短剧、动画等项目中多分镜、可复用、批量生产的工业化需求。ComfyUI 作为节点式工作流引擎,将模型加载、提示词编码、参考图控制、采样解码等步骤拆解为可视化节点,通过数据流串联起完整的生成管线,真正实现从分镜设计到素材归档的流程化管理。结合 MiniMax H3 的视频生成能力与 ref2va 参考模式,创作者可在同一张画布中集成角色参考、场景控制与批量队列, 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 10:33 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:jianshu.com/p/549d88222528

2b0f1a3b2fdcb2274dc3359d9b583f44.jpeg


公司 DBA 一直埋怨 Atlas 的难用,希望从客户端层出一个读写分离的方案。开源市场上在客户端做读写分离的开源软件基本上没有。业务方利用 Spring 自带的路由数据源能实现部分读写分离的功能,但是功能不够完善。部分参考 Sharing-JDBC 源码思想,利用部分业余时间,写了这个 Robustdb,总共只使用了十多个类,两千多行代码左右。

一、背景

随着业务量的增长,所有公司都不是直接选择分库分表设计方案的。很长一段时间内,会采用 库垂直拆分和分区表 来解决库表数据量比较大的问题,采用读写分离来解决访问压力比较大的问题。我们公司也是一样。目前绝大部分业务还是使用读写分离的方案。我相信很多公司和我们公司的架构一样,采用中间代理层做读写分离。结构如下:

dd2a098f9fd0090fa0640043b54cba24.jpeg

第一层是 VIP 曾。通过 VIP 做中间映射层,避免了应用绑定数据库的真实 IP,这样在数据库故障时,可以通过 VIP 飘移来将流量打到另一个库。但是 VIP 无法跨机房,为未来的异地多活设计埋下绕不过去的坎。

VIP 下面一层是读写分离代理,我们公司使用的是 360 的 Atlas。Atlas 通过将 SQL 解析为 DML(Data Modify Language)和 DQL(Data Query Language),DML 的请求全部发到主库,DQL 根据配置比例分发到读库(读库包括主库和从库)。

使用 Atlas 有以下不足:

  • Altas 不再维护更新,现存一些 bug,bug 网上很多描述;

  • Altas 中没有具体应用请求 IP 与具体数据库 IP 之间的映射数据,所以无法准确查到访问DB的请求是来自哪个应用;

  • Altas 控制的粒度是 SQL 语句,只能指定某条查询 SQL 语句走主库,不能根据场景指定;

  • DB 在自动关闭某个与 Altas 之间的连接时,Altas 不会刷新,它仍有可能把这个失效的连接给下次请求的应用使用;

  • 使用 Altas,对后期增加其他功能模会比较麻烦。

基于 Atlas 以上问题,以及我们需要将数据库账号和连接配置集中管控。我们设计了下面这套方案:

b7eb31fd7917dc517bad2ef22514ae48.jpeg

通过在客户端做读写分离可以解决 Atlas 上面存在的不足。整个流程如下图所示:

7b2cfa73f4a2133b6fba86adefcc1bd5.jpeg

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://gitee.com/zhijiantianya/ruoyi-vue-pro

  • 视频教程:https://doc.iocoder.cn/video/

二、Robustdb 原理

1、读写分离设计核心点——路由

支持每条 SQL 按照 DML、DQL 类型的默认路由。

需求描述

目前公司采用读写分离的方案来增强数据库的性能,所有的 DML(insert、updata、delete)操作在主库,通过 MySQL 的 binlog 同步,将数据同步到多个读库。所有的 DQL(select) 操作主库或从库,从而增强数据的读能力。

支持方法级别的指定路由

需求描述

在 Service 中指定方法中所有 DB 操作方法操作同一个数据库(主要是主库),保证方法中的 DB 读写都操作主库,避免数据同步延迟导致读从库数据异常。从而保证整个方法的事务属性。

解决思路

我们将获取真实数据库(主库还是哪个从库)放到需要建立连接时的地方,为此我们创建了 BackendConnection(传统是先连接数据库,然后再创建连接)。

在获取数据库连接时,通过对请求的 SQL 进行解析和类型判别,识别为 DML 和 DQL。如果是 DML,则在线程的单 SQL 线程本地变量上设置为 master,DQL 则设置为 slave,为后续选择数据库提供选择参考。

如果要支持方法级别的事务(也就是整个方法的 SQL 请求都发送到主库),需要借助拦截器,我们采用的是 AspectJ 方式的拦截器。会拦截所有带有类型为 dataSourceType 的 annotation 的方法。在执行方法前,在线程的多 SQL 线程本地变量上设置 dataSourceType 的 name 值(name 值为 master 代表走主库,name 值为 slave 代表走从库)。线程的多 SQL 线程本地变量为后续选择数据库提供选择参考。在方法执行完后,清理本地线程变量。

多 SQL 线程本地变量的优先级高于单 SQL 线程本地变量的优先级。

e8e2302ca81afd11ea64c568bbeb5ba3.png ec0bb6e2401e93636d9c993f58c47dcf.jpeg

注意点

本地线程变量要使用阿里包装的 Ttl,防止用户在方法内部启动线程池,导致普通的线程本地变量丢失,从而导致选库异常。

使用 Ttl 之后,需要在公司的 JVM 启动参数中增加

-javaagent:/{Path}/transmittable-thread-local-2.6.0-SNAPSHOT.jar

原理就是在 JVM 启动时,加载 transmittable-thread-local 中的类替换逻辑,将以后的 Runnable、Callable、ExecuteService 等线程池相关类替换成增强后的 TtlRunnable、TtlCallable、TtlExecuteService 等。

下面展示一下时序图中类的核心代码,仅供参考:

DataSoueceAspect

@Aspect
@Component
public class DataSourceAspect{
  @Around("execution(* *(..)) && @annotation(dataSourceType)")
  public Object aroundMethod(ProceedingJoinPoint pjd, DataSourceType dataSourceType) throws Throwable {      DataSourceContextHolder.setMultiSqlDataSourceType(dataSourceType.name());
    Object result = pjd.proceed();
    DataSourceContextHolder.clearMultiSqlDataSourceType();
    return result;
  }
}

BackendConnection

public final class BackendConnection extends AbstractConnectionAdapter {

  private AbstractRoutingDataSource abstractRoutingDataSource;

  //用于缓存一条sql(可能对应多个statement)或者一次事务中的连接
  private final Map<String, Connection> connectionMap = new HashMap<String, Connection>();

  //构造函数
  public BackendConnection(AbstractRoutingDataSource abstractRoutingDataSource) {
    this.abstractRoutingDataSource = abstractRoutingDataSource;
  }

  @Override
  public PreparedStatement prepareStatement(String sql) throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql);
  }

  @Override
  public DatabaseMetaData getMetaData() throws SQLException {
    if(connectionMap == null || connectionMap.isEmpty()){
      return abstractRoutingDataSource.getResolvedDefaultDataSource().getConnection().getMetaData();
    }
    return fetchCachedConnection(connectionMap.keySet().iterator().next().toString()).get().getMetaData();
  }

  @Override
  public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
          throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql,resultSetType,resultSetConcurrency);
  }

  @Override
  public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
                                            int resultSetHoldability) throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
  }

  @Override
  public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql, autoGeneratedKeys);
  }

  @Override
  public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql, columnIndexes);
  }

  @Override
  public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
    return getConnectionInternal(sql).prepareStatement(sql, columnNames);
  }

  @Override
  protected Collection<Connection> getConnections() {
    return connectionMap.values();
  }

  /**
   * 根据sql获取连接,对连接进行缓存
   * @param sql
   * @return
   * @throws SQLException
   */
  private Connection getConnectionInternal(final String sql) throws SQLException {
    //设置线程环境遍历
    if (ExecutionEventUtil.isDML(sql)) {
      DataSourceContextHolder.setSingleSqlDataSourceType(DataSourceType.MASTER);
    } else if (ExecutionEventUtil.isDQL(sql)) {
      DataSourceContextHolder.setSingleSqlDataSourceType(DataSourceType.SLAVE);
    }
    //根据上面设置的环境变量,选择相应的数据源
    Object dataSourceKey = abstractRoutingDataSource.determineCurrentLookupKey();
    String dataSourceName = dataSourceKey.toString();

    //看缓存中是否已经含有相应数据源的连接
    Optional<Connection> connectionOptional = fetchCachedConnection(dataSourceName);
    if (connectionOptional.isPresent()) {
      return connectionOptional.get();
    }
    //缓存中没有相应连接,建立相应连接,并放入缓存
    Connection connection = abstractRoutingDataSource.getTargetDataSource(dataSourceKey).getConnection();
    connection.setAutoCommit(super.getAutoCommit());
    connection.setTransactionIsolation(super.getTransactionIsolation());

    connectionMap.put(dataSourceKey.toString(), connection);

    return connection;
  }

  /**
   * 从缓存中取数据源
   * @param dataSourceName
   * @return
   */
  private Optional<Connection> fetchCachedConnection(final String dataSourceName) {
    if (connectionMap.containsKey(dataSourceName)) {
      return Optional.of(connectionMap.get(dataSourceName));
    }
    return Optional.absent();
  }

}

AbstractRoutingDataSource

/**
 *
 * @Type AbstractRoutingDataSource
 * @Desc 数据源路由器(spring的AbstractRoutingDataSource将resolvedDataSources的注入放在bean初始化)
 * @Version V1.0
 */
public abstract class AbstractRoutingDataSource extends AbstractDataSource {

  private boolean lenientFallback = true;

  private Map<Object, Object> targetDataSources;

  private Object defaultTargetDataSource;

  private Map<Object, DataSource> resolvedDataSources = new HashMap<Object, DataSource>();

  private DataSource resolvedDefaultDataSource;

  private Logger logger = LoggerFactory.getLogger(AbstractRoutingDataSource.class);


  public BackendConnection getConnection() throws SQLException {
    return new BackendConnection(this);
  }

  public BackendConnection getConnection(String username, String password)
          throws SQLException {
    return new BackendConnection(this);

  }

  public void afterPropertiesSet() {
    if (this.targetDataSources == null) {
      throw new IllegalArgumentException("Property 'targetDataSources' is required");
    }
    this.resolvedDataSources = new HashMap<Object, DataSource>(this.targetDataSources.size());
    for (Map.Entry entry : this.targetDataSources.entrySet()) {
      Object lookupKey = resolveSpecifiedLookupKey(entry.getKey());
      DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
      this.resolvedDataSources.put(lookupKey, dataSource);
    }
    if (this.defaultTargetDataSource != null) {
      this.resolvedDefaultDataSource = resolveSpecifiedDataSource(this.defaultTargetDataSource);
    }
  }

  public void putNewDataSource(Object key, DataSource dataSource){
    if(this.resolvedDataSources == null){
      this.resolvedDataSources = new HashMap<Object, DataSource>();
    }
    if(this.resolvedDataSources.containsKey(key)){
      this.resolvedDataSources.remove(key);
      logger.info("remove old key:" + key);
    }
    logger.info("add key:" + key + ", value=" + dataSource);
    this.resolvedDataSources.put(key, dataSource);
  }

  /**
   * 数据源选择逻辑
   */
  public DataSource determineTargetDataSource() {
    Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");

    Object lookupKey = determineCurrentLookupKey();
    DataSourceContextHolder.clearSingleSqlDataSourceType();

    int index = 0;
    for (Entry<Object, DataSource> element : resolvedDataSources.entrySet()) {
      logger.debug("myAbstractDS, index:" + index + ", key:" + element.getKey() + ", value:" + element.getValue().toString());
      index++;
    }
    DataSource dataSource = this.resolvedDataSources.get(lookupKey);
    if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
      dataSource = this.resolvedDefaultDataSource;
    }
    if (dataSource == null) {
      throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
    }
    logger.debug("myAbstractDS, hit DS is " + dataSource.toString());
    return dataSource;
  }

  public DataSource getTargetDataSource(Object lookupKey) {
    Assert.notNull(this.resolvedDataSources, "DataSource router not initialized");

    if(lookupKey == null){
      lookupKey = determineCurrentLookupKey();
    }
    DataSourceContextHolder.clearSingleSqlDataSourceType();

    int index = 0;
    for (Entry<Object, DataSource> element : resolvedDataSources.entrySet()) {
      logger.debug("myAbstractDS, index:" + index + ", key:" + element.getKey() + ", value:" + element.getValue().toString());
      index++;
    }
    DataSource dataSource = this.resolvedDataSources.get(lookupKey);
    if (dataSource == null && (this.lenientFallback || lookupKey == null)) {
      dataSource = this.resolvedDefaultDataSource;
    }
    if (dataSource == null) {
      throw new IllegalStateException("Cannot determine target DataSource for lookup key [" + lookupKey + "]");
    }
    logger.debug("myAbstractDS, hit DS is " + dataSource.toString());
    return dataSource;
  }

  public abstract Object determineCurrentLookupKey();

  public abstract Object getCurrentSlaveKey();

  @Override
  public boolean isWrapperFor(Class<?> iface) throws SQLException {
    return (iface.isInstance(this) || determineTargetDataSource().isWrapperFor(iface));
  }

  @SuppressWarnings("unchecked")
  @Override
  public <T> T unwrap(Class<T> iface) throws SQLException {
    if (iface.isInstance(this)){
      return (T) this;
    }
    return determineTargetDataSource().unwrap(iface);
  }

  protected Object resolveSpecifiedLookupKey(Object lookupKey) {
    return lookupKey;
  }

  protected DataSource resolveSpecifiedDataSource(Object dataSource) throws IllegalArgumentException {
    if (dataSource instanceof DataSource) {
      return (DataSource) dataSource;
    }
    else {
      throw new IllegalArgumentException(
              "Illegal data source value - only [javax.sql.DataSource] and String supported: " + dataSource);
    }
  }
  //get set方法省略
}

DataSourceContextHolder

public class DataSourceContextHolder {

  private static final TransmittableThreadLocal<String> singleSqlContextHolder = new TransmittableThreadLocal<String>();

  private static final TransmittableThreadLocal<String> multiSqlContextHolder = new TransmittableThreadLocal<String>();

  /**
   * @Description: 设置单条sql数据源类型
   * @param dataSourceType  数据库类型
   * @return void
   * @throws
   */
  public static void setSingleSqlDataSourceType(String dataSourceType) {
    singleSqlContextHolder.set(dataSourceType);
  }

  /**
   * @Description: 获取单条sql数据源类型
   * @param
   * @return String
   * @throws
   */
  public static String getSingleSqlDataSourceType() {
    return singleSqlContextHolder.get();
  }

  /**
   * @Description: 清除单条sql数据源类型
   * @param
   * @return void
   * @throws
   */
  public static void clearSingleSqlDataSourceType() {
    singleSqlContextHolder.remove();
  }

  /**
   * @Description: 设置多条sql数据源类型
   * @param dataSourceType  数据库类型
   * @return void
   * @throws
   */
  public static void setMultiSqlDataSourceType(String dataSourceType) {
    multiSqlContextHolder.set(dataSourceType);
  }

  /**
   * @Description: 获取多条sql数据源类型
   * @param
   * @return String
   * @throws
   */
  public static String getMultiSqlDataSourceType() {
    return multiSqlContextHolder.get();
  }

  /**
   * @Description: 清除多条sql数据源类型
   * @param
   * @return void
   * @throws
   */
  public static void clearMultiSqlDataSourceType() {
    multiSqlContextHolder.remove();
  }

  /**
   * 判断当前线程是否为使用从库为数据源. 最外层service有slave的aop标签  或者 service没有aop标签且单条sql为DQL
   *
   * @return
   */
  public static boolean isSlave() {
    return "slave".equals(multiSqlContextHolder.get()) || (multiSqlContextHolder.get()==null && "slave".equals(singleSqlContextHolder.get())) ;
  }

}

DynamicDataSource

public class DynamicDataSource extends AbstractRoutingDataSource implements InitializingBean{

  private static final Logger logger = LoggerFactory.getLogger(DynamicDataSource.class);

  private Integer slaveCount = 0;

  // 轮询计数,初始为-1,AtomicInteger是线程安全的  
  private AtomicInteger counter = new AtomicInteger(-1);

  // 记录读库的key  
  private List<Object> slaveDataSources = new ArrayList<Object>(0);

  // slave库的权重
  private  Map<Object,Integer>  slaveDataSourcesWeight;

  private Object currentSlaveKey;

  public DynamicDataSource() {
    super();
  }

  /**
   * 构造函数
   * @param defaultTargetDataSource
   * @param targetDataSources
   * @param slaveDataSourcesWeight
   */
  public DynamicDataSource(Object defaultTargetDataSource, Map<Object,Object> targetDataSources, Map<Object,Integer> slaveDataSourcesWeight) {
    this.setResolvedDataSources(new HashMap<Object, DataSource>(targetDataSources.size()));
    for (Map.Entry<Object, Object> entry : targetDataSources.entrySet()) {
      DataSource dataSource = resolveSpecifiedDataSource(entry.getValue());
      this.putNewDataSource(entry.getKey(), dataSource);
    }
    if (defaultTargetDataSource != null) {
      this.setResolvedDefaultDataSource(resolveSpecifiedDataSource(defaultTargetDataSource));
    }
    this.setSlaveDataSourcesWeight(slaveDataSourcesWeight);
    this.afterPropertiesSet();
  }

  @Override
  public Object determineCurrentLookupKey() {
    // 使用DataSourceContextHolder保证线程安全,并且得到当前线程中的数据源key  
    if (DataSourceContextHolder.isSlave()) {
      currentSlaveKey = getSlaveKey();
      return currentSlaveKey;
    }
    //TODO
    Object key = "master";
    return key;
  }


  @Override
  public void afterPropertiesSet() {
    try {
      super.afterPropertiesSet();
      Map<Object, DataSource> resolvedDataSources = this.getResolvedDataSources();
      //清空从库节点,重新生成
      slaveDataSources.clear();
      slaveCount = 0;
      for (Map.Entry<Object, DataSource> entry : resolvedDataSources.entrySet()) {
        if(slaveDataSourcesWeight.get(entry.getKey())==null){
          continue;
        }
        for(int i=0; i<slaveDataSourcesWeight.get(entry.getKey());i++){
          slaveDataSources.add(entry.getKey());
          slaveCount++;
        }
      }
    } catch (Exception e) {
      logger.error("afterPropertiesSet error! ", e);
    }
  }

  /**
   * 轮询算法实现 
   *
   * @return
   */
  public Object getSlaveKey() {
    if(slaveCount <= 0 || slaveDataSources == null || slaveDataSources.size() <= 0){
      return null;
    }
    Integer index = counter.incrementAndGet() % slaveCount;
    if (counter.get() > 9999) { // 以免超出Integer范围  
      counter.set(-1); // 还原  
    }
    return slaveDataSources.get(index);
  }

  public Map<Object, Integer> getSlaveDataSourcesWeight() {
    return slaveDataSourcesWeight;
  }

  public void setSlaveDataSourcesWeight(Map<Object, Integer> slaveDataSourcesWeight) {
    this.slaveDataSourcesWeight = slaveDataSourcesWeight;
  }

  public Object getCurrentSlaveKey() {
    return currentSlaveKey;
  }
}

2、读库流量分配策略设计

我们所有的数据库连接都是管控起来的,包括每个库的流量配置都是支持动态分配的。

支持读库按不同比例承接读请求。通过配置页面动态调整应用的数据库连接以及比例,支持随机或者顺序的方式将流量分配到相应的读库中去。

这里我们使用的配置管理下发中心是我们公司自己开发的 gconfig,当然替换成开源的 diamond 或者 applo 也是可以的。

当接收到配管中心的调整指令,会动态更新应用数据源连接,然后更新 beanFactory 中的 datasource。核心函数如下:

/**
 * 更新beanFactory
 * @param properties
 */
public void refreshDataSource(String properties) {
        YamlDynamicDataSource dataSource;
        try {
        dataSource = new YamlDynamicDataSource(properties);
        } catch (IOException e) {
        throw new RuntimeException("convert datasource config failed!");
        }

        // 验证必须字段是否存在
        if (dataSource == null && dataSource.getResolvedDataSources() == null
        || dataSource.getResolvedDefaultDataSource() == null || dataSource.getSlaveDataSourcesWeight() == null) {
        throw new RuntimeException("datasource config error!");
        }
        ConcurrentHashMap<Object, DataSource> newDataSource = new ConcurrentHashMap<Object, DataSource>(
        dataSource.getResolvedDataSources());

        //更新数据源的bean
        DynamicDataSource dynamicDataSource = (DynamicDataSource) ((DefaultListableBeanFactory) beanFactory)
        .getBean(dataSourceName);
        dynamicDataSource.setResolvedDefaultDataSource(dataSource.getResolvedDefaultDataSource());
        dynamicDataSource.setResolvedDataSources(new HashMap<Object, DataSource>());//将数据源清空,重新添加
        for (Entry<Object, DataSource> element : newDataSource.entrySet()) {
        dynamicDataSource.putNewDataSource(element.getKey(), element.getValue());
        }
        dynamicDataSource.setSlaveDataSourcesWeight(dataSource.getSlaveDataSourcesWeight());
        dynamicDataSource.afterPropertiesSet();

        }

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序,支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址:https://gitee.com/zhijiantianya/yudao-cloud

  • 视频教程:https://doc.iocoder.cn/video/

三、性能

我们经过性能测试,发现 Robustdb 的性能在一定层度上比 Atlas 性能更好。压测结果如下:

67051370d0a645753f13692d110932a4.png

参考

  • https://tech.meituan.com/mtddl.html

  • https://tech.meituan.com/%E6%95%B0%E6%8D%AE%E5%BA%93%E9%AB%98%E5%8F%AF%E7%94%A8%E6%9E%B6%E6%9E%84%E7%9A%84%E6%BC%94%E8%BF%9B%E4%B8%8E%E8%AE%BE%E6%83%B3.html



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

a5281de98658c7d20ba239458481ecb8.png

已在知识星球更新源码解析如下:

341da82c559245d24449e0b712faddda.jpeg

163562713e1852d34601b15c7d6ee3e4.jpeg

b54b15d9411c7aab3cc61a8bc047c872.jpeg

7bf51b373adc26451cd5c5798992b8d1.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 101 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。
谢谢支持哟 (*^__^*)
Mycat实现读写分离 原理 Mycat是什么?是一个开源的数据库中间件,在阿里Cobar基础上进行二次开发的,介于数据库与应用之间,进行数据处理与交互的中间件服务,可以简单的理解成数据库代理。 如上为Mycat的高可用架构图,通过keepalived搭建多个Mycat集群,其中writeHost表示主节点,readHost表示从节点,Mycat内部定期对一个dataHost里所有的writeHost与readHost节点发起心跳检测,正常情况下,Mycat会将第一个writeHost作为写节点,所有的DML SQL会发送 阅读详情

相关推荐

mysql读写分离net_.netcore实现一个读写分离的数据库访问中间件

原标题:.netcore实现一个读写分离的数据库访问中间件在实际业务系统中,当单个数据库不能承载负载压力的时候,一般我们采用数据库读写分离的方式来分担数据库负载。主库承担写以及事务操作,从库承担读操作。为了支持多种数据库我们先定义一个数据类型字典。key为连接字符串,value为数据库类型://////数据库方言集合///privatereadonlyDictionary< string, ...

weixin_39520149的博客 555

springboot多数据源配置

不是什么稀罕玩意,一百度一大堆,只是为了方便自己copy代码。 关于AbstractRoutingDataSource,看源码可以知道,这个是用来连数据库的,配置不同的数据库连接,根据不同的key选择不同的链接。 /* * Copyright 2002-2017 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use

耗子窝 498

RobustQ:RobustQ-用于量化蜂窝鲁棒性的Web服务

健壮的Q 量化蜂窝鲁棒性的网络服务。 该存储库包含设置本地开发服务器所需的一切。 仅在Linux(Ubuntu 19.04或更高版本,Debian 10)上进行了测试。 要求 要在本地运行开发服务器,您将需要 Python 3.6 的Django 3.0.4 芹菜4.4 python-libsbml mysql客户端 MySQL / MariaDB数据库 RabbitMQ服务器 眼镜蛇 安装 克隆存储库: git clone https://github.com/domvie/RobustQ.git 运行以下命令以一次安装所有要求: sudo apt-get update sudo apt-get install apache2 apache2-utils mariadb-server libmariadbclient-dev python3-dev libapache2-mo

基于aop+自定义注解来构建多数据源的切换

针对微服务架构中常用的设计模块,通常我们都会需要使用到druid作为我们的数据连接池,当架构发生扩展的时候 ,通常面对的数据存储服务器也会渐渐增加,从原本的单库架构逐渐扩展为复杂的多库架构。当在业务层需要涉及到查询多种同数据库的场景下,我们通常需要在执行sql的时候动态指定对应的datasource。 而Spring的AbstractRoutingDataSource则正好为我们提供了这一功能点,...

Danny_idea的博客 796

解决 TensorFlow 和 Keras 的 Python 版本兼容问题:详细技术指南

本文提供了TensorFlow和Keras与Python版本不兼容问题的完整解决方案。通过版本对照表指出不同TensorFlow版本对应的Python支持范围,强调2.13.x仅支持Python 3.9-3.11,且不兼容Python 3.12+。给出最佳实践建议:使用虚拟环境管理项目依赖,推荐venv或conda创建独立环境;指导正确安装TensorFlow和Keras版本,建议优先使用tf.keras避免冲突;针对常见报错如DLL加载失败、模块导入错误等提供具体解决方法。最后给出一个在兼容环境中运行的M

专注于Python爬虫开发,分享爬虫技巧、项目实战与反爬经验,使用Scrapy、BeautifulSoup等工具,解决数据抓取难题。 1667

湿式离合器KP点自学习:从怠速到高速,手把手教你两种主流方法的工程实现与避坑

本文深入解析湿式离合器KP点自学习的工程实现与避坑技巧,涵盖扭矩增量式和转速变化式两种主流方法。通过详细的操作步骤、参数设定和典型故障排除指南,帮助工程师精准捕捉摩擦片与钢片的接触瞬间,提升变速箱控制精度与稳定性,特别适用于DCT、AT及混动DHT系统的开发。

weixin_33686714的博客 412

spring配置多数据源

多数据场景: 在业务操作中需要对多个数据库进行访问或者操作。 原理: 实现AbstractRoutingDataSource接口, 其中包含两个比较重要的属性 private Map<Object, Object> targetDataSources; 最终的数据源 private Object defaultTargetDataSource; 默认数据源 private...

Java晋升 596

解决rt-thread上使用SPI+DMA

首先阐述下遇到的问题 使用SPI读取icm20602数据,读取频率为1000hz,使用stm32f407主控,发现CPU占用率达到了70%,将此线程注释掉后CPU占用率掉到25%,看来这里要着重优化,便萌生了使用DMA的想法。 使用SPI+DMA要进行的配置 1.开启RTT设备驱动。点击自己的工程 ->RT-Thread Setting2.在board.hzhong3.在board.c文件里加入以下函数,此函数受设备框架调用 void HAL_SPI_MspInit(SPI_HandleTypeDef

响望的博客 8091

手撸一个读写分离中间件

????????关注后回复“进群”,拉你进程序员交流群????????公司 DBA 一直埋怨 Atlas 的难用,希望从客户端层出一个读写分离的方案。开源市场上在客户端做读写分离的开源软件基本上没有。业务方利用 Spring 自带的路由数据源能实现部分读写分离的功能,但是功能不够完善。部分参考 Sharing-JDBC源码思想,利用部分业余时间,写了这个 Robustdb,总共只使用了十多个类,两千多行代码左右。一...

<sdffdsfsdfdfs>sfsfsfsdfsdffds</sdfsDS>Fsd 149

【图像分类】卷积神经网络之VGGNet网络模型实现花卉图像识别(附代码和数据集,PyTorch框架)

卷积神经网络之VGGNet网络模型实现花卉图像识别(附代码和数据集,PyTorch框架)

学无止境、积少成多、厚积薄发 2431

[QMT量化交易小白入门]-三十四、让deepseek分析北京炒家的首板策略后,在打板前增加了选股范围(量化python代码解析)

print(f'开始盘前选股')这行代码定义了一个名为的函数,当调用这个函数时,会首先打印出“开始盘前选股”的信息,表明选股流程正式启动。1、可根据情况增删部分条件,目前盘前选股目前可以选出140多支,比之前全市场监听带宽压力小了很多。2、还可以自行添加其他选股条件,比如换手率计算,炸板可能性检测。3、xtdata的数据是有可能缺失的,自己写策略时,有可能需要剔除,或者从第三方库校正,比如部分股票的流通股数。

木头大左的博客 2704

关于java.lang.IllegalArgumentException: 'dataSource' or 'jdbcTemplate' is required 类似问题的解决总结...

本文属原创,转载请注明出处。 这一类问题容易出现在应用Spring内置的一些DAO支持类的时候发生。 比如一个类需要继承 JdbcDaoSupport 这个类。 publicclassSearchProductLuceneDAOextendsJdbcDaoSupport{ } 使用Spring中DAO支持类的时候,需要在Spring的配置文件中定义一个...

weixin_30514745的博客 1421

永磁同步电机MTPA控制详解:从理论到实践的全方位指南

永磁同步电机(PMSM)凭借其高功率密度卓越的效率以及精准的控制性能,已在工业驱动、电动汽车和家用电器等领域获得广泛应用。而在PMSM的诸多控制策略中,最大转矩电流比(MTPA)控制因其能显著提升电机效率而占据核心地位。在输出特定转矩时,通过优化直轴电流(Id)和交轴电流(Iq)的分配,使定子电流的幅值最小化。对于电机测试工程师而言,理解MTPA意味着掌握了一把提升系统性能的关键钥匙。为什么这一点如此重要?因为定子电流的减小直接带来了铜损的降低。

优快云-新能源汽车研发测试专业博主 521

117分布式电商项目 - 读写分离(方案)

我们一般应用对数据库而言都是“读多写少”,也就说对数据库读取数据的压力比较大,有一个思路就是说采用数据库集群的方案。 其中一个是主库,负责写入数据,我们称之为:写库; 其它都是从库,负责读取数据,我们称之为:读库; 那么,对我们的要求是: 1、读库和写库的数据一致; 2、写数据必须写到写库; 3、读数据必须到读库; 解决读写分离的方案有两种:应用层解决和中间件解决。 应用层解决 优点: 1...

阿甘兄 773

大模型技术全景与核心概念解析:从基础原理到AI智能体架构(实时更新中)

本文系统解析了大模型技术的核心概念与架构。首先介绍了LLM(大语言模型)、LLMOps(模型运维)、AIGC(生成内容)、AGI(通用AI)等基础概念,重点阐述了大模型的工作原理,包括预处理、推理和后处理三个阶段。深入讲解了Token分词、FLOPs计算、Embedding向量表示等关键技术,并分析了LoRA微调、MoE架构等前沿方法。文章还探讨了AI智能体的发展前景,为理解大模型技术提供了全景视角。

算法工程师 1265

数字IC设计形式验证全攻略

本文介绍了数字IC设计中形式验证的关键技术与应用。主要内容包括:1)形式验证的两种主要方法——等价性检查(用于验证设计修改前后的功能一致性)和模型检查(通过数学方法验证系统是否满足时态逻辑规范);2)详细的工作流程,从需求分析到结果调试;3)常见挑战如状态空间爆炸的解决方案;4)通过SystemVerilog断言示例展示FIFO验证实践。文章强调形式验证与仿真验证结合能提高验证效率,适合IC设计工程师掌握的核心技术。

2301_79143213的博客 835

Maxscale实现Mysql的读写分离和GUI配置

maxscale读写分离

weixin_74344274的博客 1083

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

Mycat安装与配置读写分离

Mycat安装与配置读写分离

qq_38055805的博客 659

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

MariaDB *MaxScale*实现mysql8读写分离

可以在从库中 slave(192.168.121.152) 新增一条数据,登录主库 master(192.168.121.150) 进行查询如果查询不到,在中间件连接库中 maxscale(192.168.121.160) 可以查询到则成功(不建议,会破坏主从同步)中为 MaxScale 创建两个用户,用于监控模块和路由模块,已经实现主从复制的前提下,主库创建的用户,能同步到从库上。中创建一个访问用户,已经实现主从复制的前提下,主库创建的用户,能同步到从库上。在开始配置之前,需要在。

2302_77791905的博客 980

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

linux mysql 读写分离_MySQL Router实现MySQL的读写分离

1.简介MySQL Router是MySQL官方提供的一个轻量级MySQL中间件,用于取代以前老版本的SQL proxy。既然MySQL Router是一个数据库的中间件,那么MySQL Router必须能够分析来自前面客户端的SQL请求是写请求还是读请求,以便决定这个SQL请求是发送给master还是slave,以及发送给哪个master、哪个slave。这样,MySQL Router就实现了M...

weixin_28753691的博客 202

mysql代理和sqserver代理_ProxySQL+Mysql实现数据库读写分离实战

ProxySQL介绍ProxySQL是一个高性能的MySQL中间件,拥有强大的规则引擎。具有以下特性:http://www.proxysql.com/1、连接池,而且是multiplexing2、主机和用户的最大连接数限制3、自动下线后端DB延迟超过阀值ping 延迟超过阀值网络不通或宕机4、强大的规则路由引擎实现读写分离查询重写sql流量镜像5、支持prepared statement6、支持Q...

weixin_35923682的博客 570

MyCAT做读写分离

利用中间件MyCAT实现读写分离 MyCAT是一个开源的分布式数据库系统,但是真正的数据库需要存储需要存储引擎,然而MyCAT并没有存储引擎,所以不能算是完全意义的分布式数据库系统。其实MYCAT是数据库中间件,介于数据库和应用之间,进行数据处理与交互的中间服务。 MyCAT使用Java语言进行编写开发,使用前需要安装JAVA运行环境(JRE),由于MyCAT使用了JDK7新特性,所以必须安装JDK7以上的版本才行 在做读写分离之前,做好两台机器已经做好主从 主服务器:10.3.133.208 从服务器:1

jiaoqiubo的博客 356

数据库读写分离中间件——ShardingSphere和主从数据库笔记

数据库读写分离中间件——ShardingSphere一、ShardingSphere作用二、ShardingSphere实现过程三、集群的数据库四、宕机问题五、主从数据库的一些问题 一、ShardingSphere作用 ShardingSphere是一个用在数据库里的中间件,不像阿里的mycat配置很多还不更新,它不但配置很少,而且功能强大。 我们本来的数据库,一般我们自己写项目时,可能就会用到一个数据库,又是读又是写,再深的话顶多我们再为我们的项目配一套主从数据库,写到主数据库,同步到从数据库,这个操作实

6 1951

运维篇 读写分离

读写分离简单地说是把对数据库的读和写操作分开,以对应不同的数据库服务器。主数据库提供写操作,从数据库提供读操作,这样能有效地减轻单台数据库的压力。

weixin_56541352的博客 105
上一篇: 分享16个我总结的思维模型(程序员必读,受用终身)
下一篇: 接口请求合并的3种技巧,性能直接爆表!
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值