MySQL的读写分离（二）

最新推荐文章于 2024-05-04 13:51:18 发布
最新推荐文章于 2024-05-04 13:51:18 发布
阅读量654 收藏 1
点赞数 1
分类专栏： mysql 文章标签： mysql

1、在Navicat把3个mysql连接好

2、把3306的mysql的数据库备份



3、3380和3381数据库新建数据库


4、把备份好的数据导入3380和3381mysql里


5、主库配置

①、进入3380\data\my.ini


在my.ini修改：

 

#开启主从复制，主库的配置,指定二进制的日志


#指定主库serverid

server-id=80

#指定同步的数据库，如果不指定则同步全部数据库

binlog-do-db=taotao

②、重启下3380服务


③、3380mysql（主库）执行sql语句

SHOW MASTER STATUS


需要记录下Position值，需要在从库中设置同步起始值：


④、在3380mysql主库创建同步用户

#授权用户slave01使用123456密码登录mysql

grant replication slave on *.* to 'slave01'@'127.0.0.1' identified by '123456';

flush privileges;


6、从库配置

在my.ini修改：

 

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

server-id=81

 

以下执行SQL：

CHANGE MASTER TO

 master_host='127.0.0.1',

 master_user='slave01',

 master_password='123456',

 master_port=3380,

 master_log_file='mysql-bin.000003',

 master_log_pos=420;


#启动slave同步

START SLAVE;


#查看同步状态

执行sql语句：SHOW SLAVE STATUS;


结果：


这里启动复制失败解决方案：

分析 --   看日志。

打开3381\logs\mysql.err.log文件


解决UUID问题

设置MySQL的UUID：打开3381\data\data\auto.cnf文件


这里随便修改一个数字或者字母即可：


重启3381服务


然后：


至此，两个mysql的数据库表的数据已经连在一起，可以对3381数据库的表进行修改，3380的表数据也同样被修改了，下面就可以进行读写分离了。

1. 方案

解决读写分离的方案有两种：应用层解决和中间件解决。

 

1.1. 应用层解决：


 

优点：

1、 多数据源切换方便，由程序自动完成；

2、 不需要引入中间件；

3、 理论上支持任何数据库；

缺点：

1、 由程序员完成，运维参与不到；

2、 不能做到动态增加数据源；

 

1.2. 中间件解决


优缺点：

 

优点：

1、 源程序不需要做任何改动就可以实现读写分离；

2、 动态添加数据源不需要重启程序；

 

缺点：

1、 程序依赖于中间件，会导致切换数据库变得困难；

2、 由中间件做了中转代理，性能有所下降；

 

相关中间件产品使用：

mysql-proxy：http://hi.baidu.com/geshuai2008/item/0ded5389c685645f850fab07

Amoeba for MySQL：http://www.iteye.com/topic/188598和http://www.iteye.com/topic/1113437

2. 使用Spring基于应用层实现

2.1. 原理


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

代码：

先写3个类：

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

}

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

}

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

}

修改jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/taotao?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
jdbc.username=root
jdbc.password=root


jdbc.master.driver=com.mysql.jdbc.Driver
jdbc.master.url=jdbc:mysql://127.0.0.1:3380/taotao?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
jdbc.master.username=root
jdbc.master.password=root


jdbc.slave01.driver=com.mysql.jdbc.Driver
jdbc.slave01.url=jdbc:mysql://127.0.0.1:3381/taotao?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true
jdbc.slave01.username=root
jdbc.slave01.password=root

定义连接池（修改applicationContext.xml）

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

	<!-- 使用spring自带的占位符替换功能 -->
	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<!-- 允许JVM参数覆盖 -->
		<property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
		<!-- 忽略没有找到的资源文件 -->
		<property name="ignoreResourceNotFound" value="true" />
		<!-- 配置资源文件 -->
		<property name="locations">
			<list>
				<value>classpath:jdbc.properties</value>
				<value>classpath:upload.properties</value>
				<value>classpath:redis.properties</value>
				<value>classpath:env.properties</value>
				<value>classpath:httpclinet.properties</value>
				<value>classpath:rabbitmq.properties</value>
			</list>
		</property>
	</bean>
	
	<!-- 扫描包 -->
	<context:component-scan base-package="com.taotao"/>

	 <!-- 定义数据源 -->
	<!-- <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
		destroy-method="close">
		数据库驱动
		<property name="driverClass" value="${jdbc.driver}" />
		相应驱动的jdbcUrl
		<property name="jdbcUrl" value="${jdbc.url}" />
		数据库的用户名
		<property name="username" value="${jdbc.username}" />
		数据库的密码
		<property name="password" value="${jdbc.password}" />
		检查数据库连接池中空闲连接的间隔时间，单位是分，默认值：240，如果要取消则设置为0
		<property name="idleConnectionTestPeriod" value="60" />
		连接池中未使用的链接最大存活时间，单位是分，默认值：60，如果要永远存活设置为0
		<property name="idleMaxAge" value="30" />
		每个分区最大的连接数
		
			判断依据：请求并发数
		
		<property name="maxConnectionsPerPartition" value="100" />
		每个分区最小的连接数
		<property name="minConnectionsPerPartition" value="5" />
	</bean> -->
	
	<!-- 配置连接池 -->
	<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>
	
	<!-- 定义数据源，使用自己实现的数据源 -->
	<bean id="dataSource" class="com.taotao.manage.datasource.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>

</beans>

配置事务管理以及动态切换数据源切面

定义事务管理器（如果有了可以不用再定义）

	<!-- 定义事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

定义事务策略（如果有了可以不用再定义）

<!-- 定义事务策略 -->
	<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>

定义切面（修改applicationContext-transaction.xml）

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
	http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
	
	<!-- 定义事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 定义事务策略 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!--所有以query开头的方法都是只读的 -->
			<tx:method name="query*" read-only="true" />
			<!--其他方法使用默认事务策略 -->
			<tx:method name="*" />
		</tx:attributes>
	</tx:advice>
	
	<!-- 定义AOP切面处理器 -->
	<bean class="com.taotao.manage.datasource.DataSourceAspect" id="dataSourceAspect" />
	
	<aop:config>
		<!--pointcut元素定义一个切入点，execution中的第一个星号 用以匹配方法的返回类型，
			这里星号表明匹配所有返回类型。 com.abc.dao.*.*(..)表明匹配cn.itcast.mybatis.service包下的所有类的所有 
			方法 -->
		<aop:pointcut id="myPointcut" expression="execution(* com.taotao.manage.service.*.*(..))" />
		<!--将定义好的事务处理策略应用到上述的切入点 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut" />
		
		<!-- 将切面应用到自定义的切面处理器上，-9999保证该切面优先级最高执行 -->
		<aop:aspect ref="dataSourceAspect" order="-9999">
			<aop:before method="before" pointcut-ref="myPointcut" />
		</aop:aspect>
		
	</aop:config>
	
</beans>

至此，读写分离已经实现完成。需要改进的可以再往下学习：

3. 改进切面实现，使用事务策略规则匹配

之前的实现我们是将通过方法名匹配，而不是使用事务策略中的定义，我们使用事务管理策略中的规则匹配。

 

3.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>

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

4. 一主多从的实现

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


4.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);
    }

}

参考资料

http://www.iteye.com/topic/1127642

http://634871.blog.51cto.com/624871/1329301





















浪屿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+mysql读写分离
07-29
springboot结合mysql主从来实现读写分离 一、实现的功能 1、基于springboot框架，application.yml配置多个数据源，使用AOP以及AbstractRootingDataSource、ThreadLocal来实现多数据源切换，以实现读写分离。mysql...
mysql(三)使用mycat实现读写分离
daziyuanazhen的博客
10-05 303
MyCat介绍 MyCat是一款由阿里Cobar演变而来的用于支持数据库读写分离、分表分库的分布式中间件。mycatz支持oracle、mssql、mysql、pg、db2关系型数据库，也支持mongodb等非关系型数据库. mycat原理主要是通过对sql的拦截，然后经过一定规则的分片解析、路由分析、读写分离分析、缓存分析等，然后将sql发给后端真实的数据块，并将返回的结果做适当处理返回给客...
mysql读写分离优点_mysql读写分离
weixin_30633869的博客
01-19 2023
什么是读写分离在数据库集群架构中，让主库负责处理事务性查询，而从库只负责处理select查询，让两者分工明确达到提高数据库整体读写性能。当然，主数据库另外一个功能就是负责将事务性查询导致的数据变更同步到从库中，也就是写操作。读写分离的好处1)分摊服务器压力，提高机器的系统处理效率读写分离适用于读远比写的场景，如果有一台服务器，当select很多时，update和delete会被这些select访问...
mysql 读写分离_详解MySQL读写分离
weixin_33173924的博客
01-18 2978
主从复制的原理MySQL的主从复制和读写分离两者有着紧密的联系，首先要部署主从复制，只有主从复制完成了才能在此基础上进行数据的读写分离。读写分离的原理简单来说，读写分离就是只在主服务器上写，只在从服务器上读。基本原理是让主数据库处理事务性查询，而从服务器处理select查询。数据库复制被用来把事务性查询导致的变更同步到从数据库中。基于中间代理层实现：代理一般位于客户端和服务器之间，代理服务器接到客...
Amoeba实现mysql读写分离
大道至简，持之以恒！
03-11 2287
一、关于读写分离 amoeba : 英[ə’mi:bə] 读写分离（Read/Write Splitting），基本的原理是让主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。 数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。 二、Amoeba 是什么 Amoeba(变形虫)项目，专注 分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、高可用性、sql过滤、读写分离、可路
Atlas中间件实现Mysql读写分离
大道至简，持之以恒！
03-11 1437
目录 一、Atlas介绍 二、实现Mysql读写分离 1、实验环境 2、搭建一主一从配置 3、安装Atlas 一、Atlas介绍 [ˈætləs] Atlas 是由 Qihoo 360公司Web平台部基础架构团队开发维护的一个基于MySQL协议的数据中间层项目。它在MySQL官方推出的MySQL-Proxy 0.8.2版本的基础上，修改了大量bug，添加了很多功能特性。目前该项目在360公司内部得到了广泛应用，很多MySQL业务已经接入了Atlas平台，每天承载的读写请求数达几十亿条。
MySQL 读写分离实例详解
12-15
MySQL读写分离又一好办法 使用 com.mysql.jdbc.ReplicationDriver 在用过Amoeba 和 Cobar，还有dbware 等读写分离组件后，今天我的一个好朋友跟我讲，MySQL自身的也是可以读写分离的，因为他们提供了一个新的驱动，...
MySQL读写分离技术
01-27
阅读目录1、简介2、基本环境3、配置主从复制4、MySQL读写分离配置4.1、安装lua4.2、安装mysql-proxy5、MySQL读写分离测试1）、修改rw-splitting.lua文件2）、修改完成后，启动mysql-proxy3）、创建用于读写分离的...
MYSQL读写分离最佳实战
04-22
MYSQL读写分离最佳实战,面对越来越大的访问压力，单台的服务器的性能成为瓶颈，需要分担负载
『MySQL 实战 45 讲』20 - 幻读是什么，幻读有什么问题？
最新发布
Gavinjou大笨象的博客
05-04 765
3. 当执行 select * from t where d=5 for update 的时候，6 个记录加上了行锁，还同时加了 7 个间隙锁，这样就确保无法再插入新的记录。
MySQL —— 表的基本操作
学习C++的小陈同学
04-30 399
本篇整理了和表结构相关的各种基本操作（增删查改等等）
MySQL 之 主从复制
我见青山多妩媚,料青山见我应如是
04-28 559
复制是指将主数据库的DDL 和 DML 操作通过二进制日志传到从库服务器中，然后在从库上对这些日志重新执行，从而使得从库和主库的数据保持同步。MySQL支持一台主库同时向多台从库进行复制， 从库同时也可以作为其他从服务器的主库，实现链状复制。
【MySQL】1.安装与配置
2301_79719531的博客
04-28 829
文件的安全性问题。文件不利于数据查询和管理。文件不利于存储海量数据。文件在程序中控制不方便。数据库存储介质：磁盘+内存。为了解决上述问题，专家们设计出更加利于管理数据的软件——数据库，他能更加有效的管理数据。数据库可以提供远程服务，即通过远程连接来使用数据库，因此也称为数据库服务器。
MySQL 高级 - 第四章 | 配置文件与系统变量
xhmico的博客
04-29 1288
MySQLmax_connections：允许同时连入的客户端数量default_storage_engine：表的默认存储引擎用系统变量query_cache_size：查询缓存的大小。
MySQL的数据备份和恢复
本科在读，致力于Linux/C++方向的学习，同时涉及数据结构与算法，操作系统，数据库mysql等等
04-28 653
本博客主要内容涉及到mysql数据库的备份和恢复
基于springboot+vue+Mysql的生鲜交易系统
老卓爱爪哇 的博客
04-29 1043
理员使用本系统涉到的功能主要有：首页，个人中心，用户管理，商家管理，生鲜信息管理，生鲜分类管理，广告信息管理，生鲜仓库管理，生鲜出库管理，管理等功能。商家使用本系统涉到的功能主要有：首页，个人中心，生鲜信息管理，广告信息管理，生鲜仓库管理，生鲜出库管理，订单管理等功能。用户主要包括首页、个人中心功能。
MYSQL三个日志
weixin_68742131的博客
05-03 407
是 Innodb 存储引擎层生成的日志，实现了事务中的，主要。：是 Innodb 存储引擎层生成的日志，实现了事务中的，主要。：是 Server 层生成的日志，主要；
Mysql - 聚合函数和分组查询
acegi13579的专栏
04-28 432
通过本文的介绍，您应该对MySQL中的聚合函数和分组查询有了更清晰的理解。这些功能可以帮助你对大量数据进行统计和分析，从而得出有意义的结论。如果你有任何问题或需要更多帮助，请随时联系我。
MySQL——88张表汇总——DDL+外键
bengbeng2345的博客
04-28 253
【代码】MySQL——88张表汇总——DDL+外键。
mysql 读写分离中间件
09-02
MySQL读写分离中间件是一种用于实现MySQL数据库读写分离的工具或软件。它可以帮助解决高并发访问下读写操作的瓶颈问题，提高系统的性能和可靠性。 读写分离是指将数据库的读操作和写操作分别在不同的数据库节点上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值