spring怎么配置sql主从分离

不及物动词 1年前其他 43

共3条回复我来回复

worktile

Worktile官方账号

配置SQL主从分离是在Spring中实现数据库读写分离的一种常用方式。下面我将详细介绍如何在Spring中配置SQL主从分离。

添加相关依赖

首先，在pom.xml文件中添加相关依赖。Spring框架提供了对MyBatis和MyBatis Plus的支持，你可以选择使用其中任何一个作为ORM框架。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>

配置数据源

在application.properties或application.yml文件中配置主从数据库的连接信息。假设我们有一个主数据库和两个从数据库，配置如下：

spring.datasource.url=jdbc:mysql://localhost:3306/main_db
spring.datasource.username=root
spring.datasource.password=123456

slave.datasource.url=jdbc:mysql://localhost:3306/slave_db1,jdbc:mysql://localhost:3306/slave_db2
slave.datasource.username=root
slave.datasource.password=123456

配置数据源路由

在Spring中使用AbstractRoutingDataSource来实现数据源的动态切换。创建一个继承AbstractRoutingDataSource的类，并重写determineCurrentLookupKey()方法来根据需求切换数据源。

public class DynamicRoutingDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}

配置数据源上下文

创建一个单例的DataSourceContextHolder类来保存当前线程使用的数据源信息。

public class DataSourceContextHolder {
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        CONTEXT_HOLDER.set(dataSource);
    }

    public static String getDataSource() {
        return CONTEXT_HOLDER.get();
    }

    public static void clearDataSource() {
        CONTEXT_HOLDER.remove();
    }
}

配置MyBatis使用多数据源

在配置类中注入主从数据源和数据源路由，然后将它们配置给MyBatis。

@Configuration
public class MyBatisConfig {
    @Primary
    @Bean("masterDataSource")
    @ConfigurationProperties(prefix="spring.datasource")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean("slaveDataSource")
    @ConfigurationProperties(prefix="slave.datasource")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean
    public AbstractRoutingDataSource routingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
                                                       @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource);
        targetDataSources.put("slave", slaveDataSource);

        DynamicRoutingDataSource routingDataSource = new DynamicRoutingDataSource();
        routingDataSource.setDefaultTargetDataSource(masterDataSource);
        routingDataSource.setTargetDataSources(targetDataSources);

        return routingDataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(AbstractRoutingDataSource routingDataSource) throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(routingDataSource);
        sessionFactory.setTypeAliasesPackage("com.example.domain");

        return sessionFactory.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

以上就是在Spring中配置SQL主从分离的过程。通过以上步骤，当你使用MyBatis进行数据库操作时，会根据设置的数据源来选择主库或从库，实现读写分离的效果。请注意，写操作应该发送到主库，读操作应该发送到从库，以保证数据的一致性和准确性。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

要配置Spring框架实现SQL主从分离，需要以下步骤：

引入依赖：首先，需要引入相关的依赖。使用Spring框架需要引入Spring JDBC和数据库驱动依赖。如果使用MySQL作为数据库，则需要引入MySQL的JDBC驱动。可以在项目的pom.xml文件中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

配置数据源：在Spring的配置文件中配置主从数据库的数据源。可以使用Spring的DataSource接口实现类来创建数据源对象。可以分别创建主数据库和从数据库的数据源对象，并进行相应的配置。

@Configuration
public class DataSourceConfig {

    @Bean(name = "masterDataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "slaveDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaveDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "routingDataSource")
    public AbstractRoutingDataSource routingDataSource(
            @Qualifier("masterDataSource") DataSource masterDataSource,
            @Qualifier("slaveDataSource") DataSource slaveDataSource) {

        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER, masterDataSource);
        targetDataSources.put(DataSourceType.SLAVE, slaveDataSource);

        AbstractRoutingDataSource routingDataSource = new RoutingDataSource();
        routingDataSource.setDefaultTargetDataSource(masterDataSource);
        routingDataSource.setTargetDataSources(targetDataSources);

        return routingDataSource;
    }
}

上面的示例中，使用@Configuration注解标记该类为配置类，通过@Bean注解创建数据源对象。其中，@Primary注解表示主数据源，@Qualifier注解表示从数据源。配置类中还创建了一个路由数据源对象，用于决定具体使用主数据源还是从数据源。

配置SQLSessionFactory和事务管理器：配置主从分离的数据库连接工厂和事务管理器。

@Configuration
@EnableTransactionManagement
public class MyBatisConfig {

    @Autowired
    @Qualifier("routingDataSource")
    private DataSource routingDataSource;

    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
        sessionFactory.setDataSource(routingDataSource);
        sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver()
                .getResources("classpath:/mapper/*.xml"));
        return sessionFactory.getObject();
    }

    @Bean
    public DataSourceTransactionManager transactionManager() {
        return new DataSourceTransactionManager(routingDataSource);
    }
}

上面的示例中，使用@EnableTransactionManagement注解开启事务管理器的自动配置。配置类中创建了一个SqlSessionFactory对象，并设置数据源和Mapper文件的位置。还创建了一个数据源事务管理器对象。

配置事务注解支持：要在Spring中使用事务注解，需要在配置类中添加@EnableTransactionManagement注解，并配置事务管理器对象。

@Configuration
@EnableTransactionManagement
public class MyBatisConfig {

    // ...

    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(routingDataSource);
    }

    @Bean
    public TransactionTemplate transactionTemplate() {
        return new TransactionTemplate(transactionManager());
    }
}

上面示例中，使用@EnableTransactionManagement注解开启事务管理器的自动配置，并创建了一个事务模板对象。

配置动态数据源切换：实现SQL主从分离的关键就是实现动态数据源切换。可以通过编写自定义的数据源切换类来实现。下面是一个简单的示例：

public class RoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        DataSourceType dataSourceType = DataSourceContextHolder.getDataSourceType();
        return dataSourceType != null ? dataSourceType : DataSourceType.MASTER;
    }
}

上面示例中，定义了一个继承自AbstractRoutingDataSource的RoutingDataSource类，并重写determineCurrentLookupKey()方法，根据当前线程上下文中的数据源类型来决定使用主数据源还是从数据源。

总结：以上就是在Spring框架中配置SQL主从分离的步骤。首先需要引入相关依赖，配置主从数据库的数据源，配置SQLSessionFactory和事务管理器，配置事务注解支持，以及实现动态数据源切换。通过以上步骤，就可以实现SQL主从分离。

1年前 0条评论

不及物动词
这个人很懒，什么都没有留下～
评论
在Spring项目中实现SQL主从分离有多种方式，包括使用数据库的复制功能、使用中间件来实现主从分离等。其中，使用中间件是比较常见且灵活的一种方式。本文将重点介绍使用MyBatis和MyCat实现Spring项目中的SQL主从分离的配置方法和操作流程。

#1. 准备工作
在进行SQL主从分离的配置之前，需完成以下准备工作：
- 安装配置好MySQL数据库服务，并确保主从数据库实例已经创建和配置好复制关系；
- 配置好Spring项目，并引入相应的依赖，如MyBatis和MyCat。
#2. 配置数据源
首先，我们需要在Spring项目中配置两个数据源，一个用于读操作（从库），一个用于写操作（主库）。

##2.1. 配置主库数据源
首先，在application.properties（或者application.yml）文件中配置主库数据源相关信息：
```
spring.datasource.master.jdbc-url=jdbc:mysql://主库地址:端口号/数据库名
spring.datasource.master.username=主库用户名
spring.datasource.master.password=主库密码

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
```
其中，spring.datasource.master是主库数据源的配置前缀，该配置会在Spring项目启动时根据前缀自动加载。

##2.2. 配置从库数据源
接下来，在application.properties文件中配置从库数据源相关信息：
```
spring.datasource.slave.jdbc-url=jdbc:mysql://从库地址:端口号/数据库名
spring.datasource.slave.username=从库用户名
spring.datasource.slave.password=从库密码

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
```
同样，spring.datasource.slave是从库数据源的配置前缀。

#3. 配置MyBatis
在完成数据源的配置后，我们需要对MyBatis进行配置，以使其能够根据读写操作自动切换数据源。

##3.1. 创建数据源配置类
首先，我们需要创建一个数据源配置类，用于动态切换数据源。在该类中，需要实现RoutingDataSource接口，并重写determineCurrentLookupKey()方法。
```
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSource();
    }
}
```
##3.2. 配置数据源上下文
接下来，我们需要创建一个数据源上下文类，用于设置当前使用的数据源。在该类中，通过线程本地变量来保存当前数据源的标识。
```
public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}
```
##3.3. 配置MyBatis拦截器
最后，在MyBatis配置文件中添加一个拦截器，用于根据读写操作切换数据源。
```
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <property name="plugins">
        <array>
            <bean class="com.example.MyBatisInterceptor" />
        </array>
    </property>
</bean>
```
在以上配置中，MyBatisInterceptor是我们自定义的一个拦截器，用于在SQL执行前判断是否进行读操作。该拦截器的实现可以参考MyBatis的Interceptor接口实现。

#4. 配置MyCat
在完成MyBatis的配置后，我们需要对MyCat进行配置，以使其能够正确进行主从分离。

##4.1. 配置MyCat服务器
首先，确保已经安装并配置好MyCat服务器，并且主从复制已经正常运行。

##4.2. 配置MyCat数据源
在MyCat的配置文件中，对数据源进行配置，设置Master数据库和Slave数据库的连接信息。
```
<dataHost name="masterhost" writeType="1" maxCon="1000" minCon="10" balance="1">
    <heartbeat><![CDATA[show @@version]]></heartbeat>
    <writeHost host="writehost" url="主库数据库连接" user="主库用户名" password="主库密码" />
</dataHost>

<dataHost name="slavehost" writeType="0" maxCon="1000" minCon="10" balance="1">
    <heartbeat><![CDATA[show @@version]]></heartbeat>
    <readHost host="readhost1" url="从库1数据库连接" user="从库1用户名" password="从库1密码" />
    <readHost host="readhost2" url="从库2数据库连接" user="从库2用户名" password="从库2密码" />
</dataHost>
```
在以上配置中，writeType="1"代表写操作，writeType="0"代表读操作。maxCon和minCon分别表示最大和最小连接数。

##4.3. 配置MyCat规则
在MyCat的配置文件中，对规则进行配置，指定表的读写分离策略。
```
<schema name="myschema" checkSQLschema="false" sqlMaxLimit="100">
    <table name="mytable" dataNode="masterhost" rule="mod-long" />
</schema>
```
在以上配置中，dataNode="masterhost"表示使用主库进行写操作，rule="mod-long"代表使用一致性hash规则将读操作进行负载均衡分配到从库上。

#5. 测试验证
在完成以上配置后，我们即可进行测试验证SQL主从分离是否生效。
```
@Repository
public interface MyTableMapper {
    @ReadDataSource // 读操作使用从库数据源
    List<MyTable> selectAll();

    @WriteDataSource // 写操作使用主库数据源
    int insert(MyTable myTable);

    // ...
}
```
在以上示例中，使用了自定义注解@ReadDataSource和@WriteDataSource来标注读写操作所使用的数据源。可以根据实际需求自定义不同的注解。

参考资料：
1年前 0条评论