java操作主从的2种方式

最新推荐文章于 2025-05-27 06:30:00 发布
原创 最新推荐文章于 2025-05-27 06:30:00 发布 · 1k 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了在Java应用中实现主从数据库读写分离的两种策略：应用层解决和中间件解决。应用层解决通过AOP在进入Service前判断读写操作并切换数据源，动态数据源类`DynamicDataSource`使用`ThreadLocal`保证线程安全。中间件解决则不需要修改源代码，但会引入性能损耗。文章详细讲解了应用层解决方案的实现步骤，包括配置数据源、事务管理及AOP切面处理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  • 1. 背景
    我们一般应用对数据库而言都是“读多写少”，也就说对数据库读取数据的压力比较大，有一个思路就是说采用数据库集群的方案，
    其中一个是主库，负责写入数据，我们称之为：写库；
    其它都是从库，负责读取数据，我们称之为：读库；

    那么，对我们的要求是：
    1、 读库和写库的数据一致；
    2、 写数据必须写到写库；
    3、 读数据必须到读库；
    2. 方案
    解决读写分离的方案有两种：应用层解决和中间件解决。

    2.1. 应用层解决：


    优点：
    1、 多数据源切换方便，由程序自动完成；
    2、 不需要引入中间件；
    3、 理论上支持任何数据库；
    缺点：
    1、 由程序员完成，运维参与不到；
    2、 不能做到动态增加数据源；

    2.2. 中间件解决

    优缺点：

    优点：
    1、 源程序不需要做任何改动就可以实现读写分离；
    2、 动态添加数据源不需要重启程序；

    缺点：
    1、 程序依赖于中间件，会导致切换数据库变得困难；
    2、 由中间件做了中转代理，性能有所下降；

    相关中间件产品使用：
    3. 使用Spring基于应用层实现3.1. 原理

    在进入Service之前，使用AOP来做出判断，是使用写库还是读库，判断依据可以根据方法名判断，比如说以query、find、get等开头的就走读库，其他的走写库。
    3.2. DynamicDataSource
    import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

    /**
    * 定义动态数据源，实现通过集成spring提供的AbstractRoutingDataSource，只需要实现determineCurrentLookupKey方法即可
    *
    * 由于DynamicDataSource是单例的，线程不安全的，所以采用ThreadLocal保证线程安全，由DynamicDataSourceHolder完成。
    *
    * @author zhijun
    *
    */
    public class DynamicDataSource extends AbstractRoutingDataSource{

        @Override
        protected Object determineCurrentLookupKey() {
            // 使用DynamicDataSourceHolder保证线程安全，并且得到当前线程中的数据源key
            return DynamicDataSourceHolder.getDataSourceKey();
        }

    }
    3.3. DynamicDataSourceHolder
    /**
    *
    * 使用ThreadLocal技术来记录当前线程中的数据源的key
    *
    * @author zhijun
    *
    */
    public class DynamicDataSourceHolder {

        //写库对应的数据源key
        private static final String MASTER = "master";

        //读库对应的数据源key
        private static final String SLAVE = "slave";

        //使用ThreadLocal记录当前线程的数据源key
        private static final ThreadLocal<String> holder = new ThreadLocal<String>();

        /**
         * 设置数据源key
         * @param key
         */
        public static void putDataSourceKey(String key) {
            holder.set(key);
        }

        /**
         * 获取数据源key
         * @return
         */
        public static String getDataSourceKey() {
            return holder.get();
        }

        /**
         * 标记写库
         */
        public static void markMaster(){
            putDataSourceKey(MASTER);
        }

        /**
         * 标记读库
         */
        public static void markSlave(){
            putDataSourceKey(SLAVE);
        }

    }
    3.4. DataSourceAspect
    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.JoinPoint;

    /**
    * 定义数据源的AOP切面，通过该Service的方法名判断是应该走读库还是写库
    *
    * @author zhijun
    *
    */
    public class DataSourceAspect {

        /**
         * 在进入Service方法之前执行
         *
         * @param point 切面对象
         */
        public void before(JoinPoint point) {
            // 获取到当前执行的方法名
            String methodName = point.getSignature().getName();
            if (isSlave(methodName)) {
                // 标记为读库
                DynamicDataSourceHolder.markSlave();
            } else {
                // 标记为写库
                DynamicDataSourceHolder.markMaster();
            }
        }

        /**
         * 判断是否为读库
         *
         * @param methodName
         * @return
         */
        private Boolean isSlave(String methodName) {
            // 方法名以query、find、get开头的方法名走从库
            return StringUtils.startsWithAny(methodName, "query", "find", "get";
        }

    }

    3.5. 配置2个数据源3.5.1. jdbc.properties
    jdbc.master.driver=com.mysql.jdbc.Driver
    jdbc.master.url=jdbc:mysql://127.0.0.1:3306/mybatis_1128?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    jdbc.master.username=root
    jdbc.master.password=123456


    jdbc.slave01.driver=com.mysql.jdbc.Driver
    jdbc.slave01.url=jdbc:mysql://127.0.0.1:3307/mybatis_1128?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
    jdbc.slave01.username=root
    jdbc.slave01.password=123456
    3.5.2. 定义连接池
    <!-- 配置连接池 -->
    <bean id="masterDataSource" class="com.jolbox.bonecp.BoneCPDataSource"
    destroy-method="close">
    <!-- 数据库驱动 -->
    <property name="driverClass" value="${jdbc.master.driver}" />
    <!-- 相应驱动的jdbcUrl -->
    <property name="jdbcUrl" value="${jdbc.master.url}" />
    <!-- 数据库的用户名 -->
    <property name="username" value="${jdbc.master.username}" />
    <!-- 数据库的密码 -->
    <property name="password" value="${jdbc.master.password}" />
    <!-- 检查数据库连接池中空闲连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0 -->
    <property name="idleConnectionTestPeriod" value="60" />
    <!-- 连接池中未使用的链接较大存活时间，单位是分，默认值：60，如果要永远存活设置为0 -->
    <property name="idleMaxAge" value="30" />
    <!-- 每个分区较大的连接数 -->
    <property name="maxConnectionsPerPartition" value="150" />
    <!-- 每个分区最小的连接数 -->
    <property name="minConnectionsPerPartition" value="5" />
    </bean>

    <!-- 配置连接池 -->
    <bean id="slave01DataSource" class="com.jolbox.bonecp.BoneCPDataSource"
    destroy-method="close">
    <!-- 数据库驱动 -->
    <property name="driverClass" value="${jdbc.slave01.driver}" />
    <!-- 相应驱动的jdbcUrl -->
    <property name="jdbcUrl" value="${jdbc.slave01.url}" />
    <!-- 数据库的用户名 -->
    <property name="username" value="${jdbc.slave01.username}" />
    <!-- 数据库的密码 -->
    <property name="password" value="${jdbc.slave01.password}" />
    <!-- 检查数据库连接池中空闲连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0 -->
    <property name="idleConnectionTestPeriod" value="60" />
    <!-- 连接池中未使用的链接较大存活时间，单位是分，默认值：60，如果要永远存活设置为0 -->
    <property name="idleMaxAge" value="30" />
    <!-- 每个分区较大的连接数 -->
    <property name="maxConnectionsPerPartition" value="150" />
    <!-- 每个分区最小的连接数 -->
    <property name="minConnectionsPerPartition" value="5" />
    </bean>
    3.5.3. 定义DataSource
    <!-- 定义数据源，使用自己实现的数据源 -->
    <bean id="dataSource" class="cn.itcast.usermanage.spring.DynamicDataSource">
    <!-- 设置多个数据源 -->
    <property name="targetDataSources">
    <map key-type="Java.lang.String">
    <!-- 这个key需要和程序中的key一致 -->
    <entry key="master" value-ref="masterDataSource"/>
    <entry key="slave" value-ref="slave01DataSource"/>
    </map>
    </property>
    <!-- 设置默认的数据源，这里默认走写库 -->
    <property name="defaultTargetDataSource" ref="masterDataSource"/>
    </bean>
    3.6. 配置事务管理以及动态切换数据源切面3.6.1. 定义事务管理器
    <!-- 定义事务管理器 -->
    <bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource" />
    </bean>
    3.6.2. 定义事务策略
    <!-- 定义事务策略 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
    <!--定义查询方法都是只读的 -->
    <tx:method name="query*" read-only="true" />
    <tx:method name="find*" read-only="true" />
    <tx:method name="get*" read-only="true" />

    <!-- 主库执行操作，事务传播行为定义为默认行为 -->
    <tx:method name="save*" propagation="REQUIRED" />
    <tx:method name="update*" propagation="REQUIRED" />
    <tx:method name="delete*" propagation="REQUIRED" />

    <!--其他方法使用默认事务策略 -->
    <tx:method name="*" />
    </tx:attributes>
    </tx:advice>
    3.6.3. 定义切面
    <!-- 定义AOP切面处理器 -->
    <bean class="cn.itcast.usermanage.spring.DataSourceAspect" id="dataSourceAspect" />

    <aop:config>
    <!-- 定义切面，所有的service的所有方法 -->
    <aopointcut id="txPointcut" expression="execution(* xx.xxx.xxxxxxx.service.*.*(..))" />
    <!-- 应用事务策略到Service切面 -->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>

    <!-- 将切面应用到自定义的切面处理器上，-9999保证该切面优先级较高执行 -->
    <aop:aspect ref="dataSourceAspect" order="-9999">
    <aop:before method="before" pointcut-ref="txPointcut" />
    </aop:aspect>
    </aop:config>
    4. 改进切面实现，使用事务策略规则匹配
    之前的实现我们是将通过方法名匹配，而不是使用事务策略中的定义，我们使用事务管理策略中的规则匹配。

    4.1. 改进后的配置
    <!-- 定义AOP切面处理器 -->
    <bean class="cn.itcast.usermanage.spring.DataSourceAspect" id="dataSourceAspect">
    <!-- 指定事务策略 -->
    <property name="txAdvice" ref="txAdvice"/>
    <!-- 指定slave方法的前缀（非必须） -->
    <property name="slaveMethodStart" value="query,find,get"/>
    </bean>
    4.2. 改进后的实现
    import Java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;

    import org.apache.commons.lang3.StringUtils;
    import org.aspectj.lang.JoinPoint;
    import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;
    import org.springframework.transaction.interceptor.TransactionAttribute;
    import org.springframework.transaction.interceptor.TransactionAttributeSource;
    import org.springframework.transaction.interceptor.TransactionInterceptor;
    import org.springframework.util.PatternMatchUtils;
    import org.springframework.util.ReflectionUtils;

    /**
    * 定义数据源的AOP切面，该类控制了使用Master还是Slave。
    *
    * 如果事务管理中配置了事务策略，则采用配置的事务策略中的标记了ReadOnly的方法是用Slave，其它使用Master。
    *
    * 如果没有配置事务管理的策略，则采用方法名匹配的原则，以query、find、get开头方法用Slave，其它用Master。
    *
    * @author zhijun
    *
    */
    public class DataSourceAspect {

        private List<String> slaveMethodPattern = new ArrayList<String>();

        private static final String[] defaultSlaveMethodStart = new String[]{ "query", "find", "get" };

        private String[] slaveMethodStart;

        /**
         * 读取事务管理中的策略
         *
         * @param txAdvice
         * @throws Exception
         */
        @SuppressWarnings("unchecked")
        public void setTxAdvice(TransactionInterceptor txAdvice) throws Exception {
            if (txAdvice == null) {
                // 没有配置事务管理策略
                return;
            }
            //从txAdvice获取到策略配置信息
            TransactionAttributeSource transactionAttributeSource = txAdvice.getTransactionAttributeSource();
            if (!(transactionAttributeSource instanceof NameMatchTransactionAttributeSource)) {
                return;
            }
            //使用反射技术获取到NameMatchTransactionAttributeSource对象中的nameMap属性值
            NameMatchTransactionAttributeSource matchTransactionAttributeSource = (NameMatchTransactionAttributeSource) transactionAttributeSource;
            Field nameMapField = ReflectionUtils.findField(NameMatchTransactionAttributeSource.class, "nameMap");
            nameMapField.setAccessible(true); //设置该字段可访问
            //获取nameMap的值
            Map<String, TransactionAttribute> map = (Map<String, TransactionAttribute>) nameMapField.get(matchTransactionAttributeSource);

            //遍历nameMap
            for (Map.Entry<String, TransactionAttribute> entry : map.entrySet()) {
                if (!entry.getValue().isReadOnly()) {//判断之后定义了ReadOnly的策略才加入到slaveMethodPattern
                    continue;
                }
                slaveMethodPattern.add(entry.getKey());
            }
        }

        /**
         * 在进入Service方法之前执行
         *
         * @param point 切面对象
         */
        public void before(JoinPoint point) {
            // 获取到当前执行的方法名
            String methodName = point.getSignature().getName();

            boolean isSlave = false;

            if (slaveMethodPattern.isEmpty()) {
                // 当前Spring容器中没有配置事务策略，采用方法名匹配方式
                isSlave = isSlave(methodName);
            } else {
                // 使用策略规则匹配
                for (String mappedName : slaveMethodPattern) {
                    if (isMatch(methodName, mappedName)) {
                        isSlave = true;
                        break;
                    }
                }
            }

            if (isSlave) {
                // 标记为读库
                DynamicDataSourceHolder.markSlave();
            } else {
                // 标记为写库
                DynamicDataSourceHolder.markMaster();
            }
        }

        /**
         * 判断是否为读库
         *
         * @param methodName
         * @return
         */
        private Boolean isSlave(String methodName) {
            // 方法名以query、find、get开头的方法名走从库
            return StringUtils.startsWithAny(methodName, getSlaveMethodStart());
        }

        /**
         * 通配符匹配
         *
         * Return if the given method name matches the mapped name.
         * <p>
         * The default implementation checks for "xxx*", "*xxx" and "*xxx*" matches, as well as direct
         * equality. Can be overridden in subclasses.
         *
         * @param methodName the method name of the class
         * @param mappedName the name in the descriptor
         * @return if the names match
         * @see org.springframework.util.PatternMatchUtils#simpleMatch(String, String)
         */
        protected boolean isMatch(String methodName, String mappedName) {
            return PatternMatchUtils.simpleMatch(mappedName, methodName);
        }

        /**
         * 用户指定slave的方法名前缀
         * @param slaveMethodStart
         */
        public void setSlaveMethodStart(String[] slaveMethodStart) {
            this.slaveMethodStart = slaveMethodStart;
        }

        public String[] getSlaveMethodStart() {
            if(this.slaveMethodStart == null){
                // 没有指定，使用默认
                return defaultSlaveMethodStart;
            }
            return slaveMethodStart;
        }

    }
    5. 一主多从的实现
    很多实际使用场景下都是采用“一主多从”的架构的，所有我们现在对这种架构做支持，目前只需要修改DynamicDataSource即可。

    5.1. 实现
    import java.lang.reflect.Field;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Map;
    import java.util.concurrent.atomic.AtomicInteger;

    import javax.sql.DataSource;

    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    import org.springframework.util.ReflectionUtils;

    /**
    * 定义动态数据源，实现通过集成Spring提供的AbstractRoutingDataSource，只需要实现determineCurrentLookupKey方法即可
    *
    * 由于DynamicDataSource是单例的，线程不安全的，所以采用ThreadLocal保证线程安全，由DynamicDataSourceHolder完成。
    *
    * @author zhijun
    *
    */
    public class DynamicDataSource extends AbstractRoutingDataSource {

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

        private Integer slaveCount;

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

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

        @Override
        protected Object determineCurrentLookupKey() {
            // 使用DynamicDataSourceHolder保证线程安全，并且得到当前线程中的数据源key
            if (DynamicDataSourceHolder.isMaster()) {
                Object key = DynamicDataSourceHolder.getDataSourceKey();
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("当前DataSource的key为: " + key);
                }
                return key;
            }
            Object key = getSlaveKey();
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("当前DataSource的key为: " + key);
            }
            return key;

        }

        @SuppressWarnings("unchecked")
        @Override
        public void afterPropertiesSet() {
            super.afterPropertiesSet();

            // 由于父类的resolvedDataSources属性是私有的子类获取不到，需要使用反射获取
            Field field = ReflectionUtils.findField(AbstractRoutingDataSource.class, "resolvedDataSources");
            field.setAccessible(true); // 设置可访问

            try {
                Map<Object, DataSource> resolvedDataSources = (Map<Object, DataSource>) field.get(this);
                // 读库的数据量等于数据源总数减去写库的数量
                this.slaveCount = resolvedDataSources.size() - 1;
                for (Map.Entry<Object, DataSource> entry : resolvedDataSources.entrySet()) {
                    if (DynamicDataSourceHolder.MASTER.equals(entry.getKey())) {
                        continue;
                    }
                    slaveDataSources.add(entry.getKey());
                }
            } catch (Exception e) {
                LOGGER.error("afterPropertiesSet error! ", e);
            }
        }

        /**
         * 轮询算法实现
         *
         * @return
         */
        public Object getSlaveKey() {
            // 得到的下标为：0、1、2、3……
            Integer index = counter.incrementAndGet() % slaveCount;
            if (counter.get() > 9999) { // 以免超出Integer范围
                counter.set(-1); // 还原
            }
            return slaveDataSources.get(index);
        }

    }
    6. MySQL主从复制6.1. 原理

    mysql主(称master)从(称slave)复制的原理：
    1、 master将数据改变记录到二进制日志(binary log)中,也即是配置文件log-bin指定的文件(这些记录叫做二进制日志事件，binary log events)
    2、 slave将master的binary log events拷贝到它的中继日志(relay log)
    3、 slave重做中继日志中的事件,将改变反映它自己的数据(数据重演)
    6.2. 主从配置需要注意的地方
    1、 主DB server和从DB server数据库的版本一致
    2、 主DB server和从DB server数据库数据一致[ 这里就会可以把主的备份在从上还原，也可以直接将主的数据目录拷贝到从的相应数据目录]
    3、 主DB server开启二进制日志,主DB server和从DB server的server_id都必须
    6.3. 主库配置（windows，Linux下也类似）
    在my.ini修改：

    #开启主从复制，主库的配置
    log-bin = mysql3306-bin
    #指定主库serverid
    server-id=101
    #指定同步的数据库，如果不指定则同步全部数据库
    binlog-do-db=mybatis_1128

    执行SQL语句查询状态：
    SHOW MASTER STATUS


    需要记录下Position值，需要在从库中设置同步起始值。
    6.4. 在主库创建同步用户
    #授权用户slave01使用123456密码登录mysql
    grant replication slave on *.* to 'slave01'@'127.0.0.1' identified by '123456';
    flush privileges;

    6.5. 从库配置
    在my.ini修改：

    #指定serverid，只要不重复即可，从库也只有这一个配置，其他都在SQL语句中操作
    server-id=102

    以下执行SQL：
    CHANGE MASTER TO
    master_host='127.0.0.1',
    master_user='slave01',
    master_password='123456',
    master_port=3306,
    master_log_file='mysql3306-bin.000006',
    master_log_pos=1120;

    #启动slave同步
    START SLAVE;

    #查看同步状态
    SHOW SLAVE STATUS;



    7. 参考资料



大聪明教你学Java | 带你了解 Binlog 实现 MySQL 主从同步的原理及实现方式
不肯过江东丶
12-26 878
之前我们说过，大聪明新加入了一个智慧运输平台建设的项目组，在项目组中学习到了许多之前没有接触过的东西。这不，大聪明又发现平台的建设过程中使用了两套 MySQL 数据库，也就是我们常说的主从库，这时候大聪明有了一个新的疑问：“这个主库和从库是怎么保证数据一致的呢🤔？”。这个新的问题又激起了大聪明的求知欲，接下来我们一起看看大聪明的求知历程✍
Java学习 - Redis主从复制
paofuluolijiang的博客
06-27 624
找另外的节点成为主节点的从节点。恢复后重新成为主节点的从节点。
springboot 实现mysql读写分离
04-03
通过 sprigboot 搭建mysql读写分离 mysql服务器需搭建主从复制
使用Spring实现读写分离（MySQL实现主从复制）
小飞侠的博客
03-20 899
1. 背景 我们一般应用对数据库而言都是“读多写少”，也就说对数据库读取数据的压力比较大，有一个思路就是说采用数据库集群的方案， 其中一个是主库，负责写入数据，我们称之为：写库； 其它都是从库，负责读取数据，我们称之为：读库； 那么，对我们的要求是： 1、 读库和写库的数据一致； 2、 写数据必须写到写库； 3、 读数据必须到读库； 2. 方案
Java读写分离：主从复制环境下的ORM配置
最新发布
程序媛学姐的博客
05-27 770
读写分离作为数据库架构优化的重要策略，在高并发应用中发挥着关键作用。通过合理配置主从复制环境和ORM框架，可以显著提升系统的并发处理能力和查询响应速度。在Spring Boot环境下，利用动态数据源和AOP切面技术，能够实现透明的读写分离，业务代码无需感知底层的数据源切换逻辑。成功实施读写分离需要综合考虑数据一致性、事务管理、连接池配置和性能监控等多个方面。通过精心设计的注解体系和切面逻辑，开发者可以声明式地控制数据源选择，大大简化了开发复杂度，完善的监控和告警机制确保了系统在生产环境中的稳定运行。
SpringBoot+Mysql实现读写分离主从复制(二）
ch_csdn_ch的博客
02-02 673
mysql主从复制原理 为什么需要主从复制？ 1、在业务复杂的系统中，有这么一个情景，有一句sql语句需要锁表， 导致暂时不能使用读的服务，那么就很影响运行中的业务，使用主从复 制，让主库负责写，从库负责读，这样，即使主库出现了锁表的情景， 通过读从库也可以保证业务的正常运作。 2、做数据的热备 3、架构的扩展。业务量越来越大，I/O访问频率过高，单机无法满足， 此时做多库的存储，降低磁盘I/O访问的频率，提高单个机器的I/O性 能。 1、什么是mysql的主从复制？ MySQL 主从复制是指数.
springmvc-mybatis 整合druid多数据源配置读写实现读写分离，windows上mysql主从复制
10-27
springmvc mybatis 整合druid多数据源配置 实现简单的读写分离，windows上mysql主从复制
SpringBoot学习之MySQL主从复制
hxxx1314的博客
03-15 650
第一步：启动docker systemctl start docker.service 第二步：用Docker下载MySQL docker run --name mysql1 -p 33061:3306 -e MYSQL_ROOT_PASSWORD=123 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci docker run --name mysql2 -p 33062:3306 -e M
如何在 Java 应用中实现数据库的主从复制（读写分离）？请简要描述架构和关键代码实现？
程序员学习园地。
02-09 2625
【代码】如何在 Java 应用中实现数据库的主从复制（读写分离）？请简要描述架构和关键代码实现？
mongodb主从复制_动力节点Java学院整理
09-09
MongoDB的主从复制是一种常见的数据冗余和故障恢复策略，它允许数据在多个服务器之间进行同步，确保数据的安全性和可用性。主从复制的基本原理是，一个MongoDB实例作为主节点，负责处理所有写操作，而其他节点作为从...
【Java设计模式】主从模式
09-05
这个厨房操作模仿了主从模式，通过分配和管理任务来优化效率和输出。 2. **通俗解释**： - 主从模式涉及主进程将任务委托给多个工作进程，这些工作进程同时执行任务并报告结果，优化了并行任务处理和吞吐量。 3. **...
SpringBoot第 12 讲：SpringBoot+MySQL主从复制、读写分离
10-10
mysql_master_slave.zip
MySQL主从复制+Springboot读写分离
Ar1es
11-28 3950
1.简介 MySQL Replication (MySQL 主从复制)是指数据可以从一个MySQL数据库服务器主节点复制到一个或多个从节点。MySQL 默认采用异步复制方式（一级主从大概50~100 us），这样从节点不用一直访问主服务器来更新自己的数据，数据的更新可以在远程连接上进行，从节点可以复制主数据库中的所有数据库或者特定的数据库，或者特定的表。 2.为什么要做主从复制 读写分离。...
SpringBoot环境-MySQL主从复制，读写分离的实现
maohe的博客
02-14 3194
记录sharding-jdbc框架的使用-主从复制，读写分离实现的步骤及测试。
Mysql主从Java端实现
总有些事，值得你去努力
08-04 4865
继昨天的Mysql主从的概述及基本的配置。今天趁着不是很忙的时候整理一下主从JAVA端的代码实现。下面开始贴代码： Spring MVC 的datasorce配置，这里我们使用的阿里的druid（德鲁伊）数据库连接池，先配置两个数据库链接池。分别连接主、从两个库。然后使用spring 的一个主要特性AOP切面编程来根据方法的前缀命名来选择是使用主数据库还是使用从数据库。（我选择切的是contro
我们如何在代码中实现主从的选择-Java
小肥宅的博客
05-18 689
问题描述：我们在分布式任务系统之中，会经常遇见一种情况，比如：定时的对任务进行刷新，然后进行一些操作。通常我们会将这个定时任我Job单独部署成一个服务，这个服务如果我们不进行主选择，便会出现多个服务同时进行刷新，造成业务的紊乱。 解决方案：使用Zookeeper来进行主的选择 1、添加对应的依赖 <!-- zookeeper 客户端 --> <dependency> <groupId>org.apache.curator</groupId>.
java主从服务搭建及应用
qq_43675092的博客
08-27 982
主从服务搭建及应用
Java多线程之主从设计模式-yellowcong
10-06 1701
在Hadoop和Redis等集群的时候，都会有主从的概念，有一个主节点用于控制请求的分发和结果的统计，从节点用于真正的数据处理操作。在多线程中，我们可以把 一个大任务分割成多个小任务，给子节点处理，在这种设计模式中，我们需要使用到原子类 ConcurrentLinkedQueue （用于存储请求提交的任务），和ConcurrentHashMap（用于收集每一个节点获取的结果）。在这种无锁的设计模式中
Java实现主从机构间转账功能
标题“Transfer_between_cards”和描述“Transfer_between_cards 主分支机构状态徽章”指向一个与“转账”操作相关的主题，而“Java”标签表明这一过程可能会涉及Java编程语言。根据这些信息，我们可以推断出这是一...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值