Spring项目数据库读写分离改造方案：PostgreSQL环境下的实现

数据库 java 问题解决系列

引言

随着系统规模的增长和并发访问量的增加，单一数据库实例往往难以应对高并发读写请求，导致性能瓶颈。为了解决这一问题，数据库读写分离成为提高系统性能和可扩展性的关键技术之一。本报告将详细介绍如何在Spring历史项目中引入数据库读写分离机制，使用PostgreSQL作为数据库，结合JDK7环境下的Spring+Hibernate+Struts2技术栈，提供完整的改造方案。

数据库读写分离概述

数据库读写分离是一种常见的优化策略，通过将读操作和写操作分别分配给不同的数据库实例，以提高系统的吞吐量和性能。在Spring项目中实现读写分离，可以通过动态数据源、AOP（面向切面编程）策略以及多从库负载均衡来实现这一目标[35]。

PostgreSQL主从复制与读写分离

PostgreSQL主从复制配置

在PostgreSQL中实现读写分离，首先需要配置主从复制，确保数据可以从主节点同步到从节点。以下是PostgreSQL主从复制的基本配置步骤：

配置主服务器：

修改postgresql.conf文件，设置参数wal_level = replica，启用流复制
设置max_wal_senders为至少1，和wal_keep_segments为至少8

创建复制用户：

在主服务器上创建一个用于复制的用户，授予REPLICATION权限

配置访问控制：

修改pg_hba.conf文件，添加从服务器的IP地址和访问权限

备份与恢复：

使用pg_basebackup命令备份主服务器数据，并将备份文件传输到从服务器
在从服务器上创建与主服务器相同的数据库，并将备份文件恢复

配置从服务器：

创建recovery.conf文件，设置参数standby_mode = on
配置primary_conninfo参数，指定主服务器的连接信息

启动从服务器：

启动PostgreSQL服务，从服务器将自动连接到主服务器并开始同步数据[55][57]

读写分离实现方式

PostgreSQL中实现读写分离主要有以下几种策略：

数据库代理或负载均衡器：

Pgpool-II是一个流行的连接池和中间件，可以用于实现读写分离。它可以将读请求转发到从服务器，而写请求发送到主服务器，并提供负载均衡和故障转移功能[54]
HAProxy是另一个流行的负载均衡器，可以通过配置将读请求分发到多个从服务器，而写请求发送到主服务器[54]

应用程序层面实现：

在应用程序中实现数据源切换，根据操作类型选择使用主库或从库
通过Spring AOP实现透明的数据源切换，无需修改业务代码[35]

Spring项目读写分离实现方案

技术路线选择

基于Spring+Hibernate+Struts2的技术栈，我们选择在应用程序层面实现读写分离，具体方案如下：

使用Spring AOP实现透明的数据源切换：

通过定义主从数据源
使用AOP切面拦截方法调用
根据方法的读写特性切换数据源

利用@Transactional注解的readOnly属性：

读操作使用@Transactional(readOnly = true)
写操作使用默认的事务配置

实现动态数据源切换：

使用AbstractRoutingDataSource实现数据源路由
通过ThreadLocal保存当前线程的数据源标识

结合Spring事务管理：

配置事务管理器以确保事务一致性
启用Spring AOP代理以支持事务和数据源切换

详细实现步骤

1. 定义数据源配置

首先，需要配置主数据库（写）和从数据库（读）的数据源。在Spring配置文件中完成。

<!-- 主库数据源（写操作） -->
<bean id="masterDataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
    <property name="driverClassName" value="org.postgresql.Driver"/>
    <property name="url" value="jdbc:postgresql://master-host:5432/chatdb"/>
    <property name="username" value="chat_user"/>
    <property name="password" value="chat_pass"/>
</bean>
<!-- 从库数据源（读操作） -->
<bean id="slaveDataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
    <property name="driverClassName" value="org.postgresql.Driver"/>
    <property name="url" value="jdbc:postgresql://slave-host:5432/chatdb"/>
    <property name="username" value="chat_user"/>
    <property name="password" value="chat_pass"/>
</bean>
<!-- 动态数据源 -->
<bean id="dynamicDataSource" class="com.example.DynamicDataSource">
    <property name="targetDataSources">
        <map key-type="java.lang.String">
            <entry key="master" value-ref="masterDataSource"/>
            <entry key="slave" value-ref="slaveDataSource"/>
        </map>
    </property>
    <property name="defaultTargetDataSource" ref="masterDataSource"/>
</bean>

2. 创建数据源Bean

在Spring配置类中，创建对应的数据源Bean。

@Configuration
public class DataSourceConfig {
    
    @Bean(name = "masterDataSource")
    @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
    public DataSource dynamicDataSource(
            @Qualifier("masterDataSource") DataSource masterDataSource,
            @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("master", masterDataSource);
        targetDataSources.put("slave", slaveDataSource);
        
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
        return dynamicDataSource;
    }
}

3. 负载均衡策略

实现一个简单的轮询负载均衡器来选择从数据库：

public class LoadBalanceDataSourceRouter {
    private AtomicInteger index = new AtomicInteger(0);
    private List<String> slaveDataSourceKeys = new ArrayList<>();
    
    public LoadBalanceDataSourceRouter() {
        // 假设有两个从数据源
        slaveDataSourceKeys.add("slave");
        // 如果有更多从数据源，继续添加
    }
    
    public String routeSlaveDataSource() {
        // 简单的轮询算法，可以根据实际应用进行修改
        int currentIndex = Math.abs(index.getAndIncrement() % slaveDataSourceKeys.size());
        return slaveDataSourceKeys.get(currentIndex);
    }
}

4. 配置动态数据源

创建一个动态数据源，它可以根据当前的上下文动态决定使用哪个数据源。

public class DynamicDataSource extends AbstractRoutingDataSource {
    private LoadBalanceDataSourceRouter loadBalanceRouter = new LoadBalanceDataSourceRouter();
    
    @Override
    protected Object determineCurrentLookupKey() {
        String dataSourceType = DataSourceContextHolder.getDataSourceType();
        if ("slave".equals(dataSourceType)) {
            return loadBalanceRouter.routeSlaveDataSource();
        } else {
            return "master";
        }
    }
}

使用ThreadLocal来保存当前线程的数据源标识：

public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
    
    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }
    
    public static String getDataSourceType() {
        return contextHolder.get();
    }
    
    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}

5. 定义AOP切面

创建一个切面来拦截方法调用，并根据方法的读写特性来切换数据源。

@Aspect
@Component
public class DataSourceAspect {
    
    @Before("@annotation(Transactional) && execution(* com.yourpackage..*.*(..))")
    public void setDataSourceType(JoinPoint joinPoint) throws Exception {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Transactional transactional = methodSignature.getMethod().getAnnotation(Transactional.class);
        
        if (transactional != null && transactional.readOnly()) {
            try {
                DataSourceContextHolder.setDataSourceType("slave");
            } catch (Exception e) {
                // 如果从数据源发生异常，切换到主数据源
                DataSourceContextHolder.setDataSourceType("master");
            }
        } else {
            DataSourceContextHolder.setDataSourceType("master");
        }
    }
    
    @After("@annotation(Transactional) && execution(* com.yourpackage..*.*(..))")
    public void clearDataSourceType(JoinPoint joinPoint) {
        DataSourceContextHolder.clearDataSourceType();
    }
}

6. 使用@Transactional注解

在服务层或者DAO层，使用@Transactional注解来标识方法的事务属性。如果是只读操作，设置readOnly属性为true。

@Service
public class YourService {
    
    @Transactional(readOnly = true)
    public Object readOperation() {
        // 执行读操作...
    }
    
    @Transactional
    public Object writeOperation() {
        // 执行写操作...
    }
}

7. 其他配置

为了使动态数据源生效，还需要配置事务管理器以及确保：

配置事务管理器以确保事务一致性：

@Configuration
@EnableTransactionManagement
public class TransactionManagerConfig {
    
    @Bean
    public PlatformTransactionManager transactionManager(@Qualifier("dynamicDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

确保Spring Boot应用程序主类或配置类中包含@EnableAspectJAutoProxy注解，以启用AOP代理：

@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

通过这种方式，当执行到读操作时，AOP切面会将数据源切换到从数据库；当执行写操作时，数据源切换回主数据库。

Hibernate与PostgreSQL集成

Hibernate配置

在Spring配置文件中配置HibernateSessionFactory，使用动态数据源：

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="dataSource" ref="dynamicDataSource"/>
    <property name="packagesToScan" value="com.example.entity"/>
    <property name="hibernateProperties">
        <props>
            <prop>hibernate.dialect</prop>org.hibernate.dialect.PostgreSQLDialect
            <prop>hibernate.show_sql</prop>true
            <prop>hibernate.format_sql</prop>true
            <prop>hibernate.hbm2ddl.auto</prop>update
        </props>
    </property>
</bean>

Hibernate事务管理

配置Spring事务管理器以支持Hibernate：

<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

Struts2与Spring整合

Struts2配置

在Struts2配置文件中配置Spring插件：

<constant name="struts.i18n.encoding" value="UTF-8"/>
<constant name="struts.devMode" value="false"/>
<constant name="struts.serve.static" value="false"/>
<constant name="struts.ui.theme" value="simple"/>
<interceptor-ref name="spring">
    <param name="excludePatterns">/static/**
    </param>
</interceptor-ref>
<package name="default" namespace="/" extends="struts-default,spring">
    <action name="*" class="{1}" method="{2}">
        <result type="tiles">{1}.{2}</result>
    </action>
</package>

Spring配置

在Spring配置文件中配置Struts2的Action作为Spring Bean：

<bean id="yourAction" class="com.example.YourAction">
    <!-- 配置依赖注入 -->
</bean>

JDK7兼容性考虑

由于项目使用JDK7，需要确保所有使用的库和框架都兼容JDK7。特别注意以下几点：

PostgreSQL驱动版本：选择兼容JDK7的PostgreSQL驱动版本。对于JDK7，推荐使用PostgreSQL JDBC Driver 9.4-1201-jdbc41或更高版本。
Spring版本：确保使用的Spring版本支持JDK7。Spring 3.2.x和4.3.x版本都支持JDK7。
Hibernate版本：对于JDK7，推荐使用Hibernate 4.3.x版本，该版本支持JDK7。
其他依赖库：确保所有依赖库都兼容JDK7。

完整改造方案

项目结构

your-project/
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   ├── com/
│   │   │   │   ├── example/
│   │   │   │   │   ├── config/          # 配置类
│   │   │   │   │   ├── controller/      # Struts2 Action类
│   │   │   │   │   ├── service/         # 业务逻辑类
│   │   │   │   │   ├── dao/             # 数据访问类
│   │   │   │   │   ├── entity/          # 实体类
│   │   │   │   │   ├── aspect/          # AOP切面类
│   │   │   │   │   └── util/            # 工具类
│   │   ├── resources/
│   │   │   ├── application-context.xml # Spring配置文件
│   │   │   ├── hibernate.cfg.xml        # Hibernate配置文件
│   │   │   ├── struts.xml               # Struts2配置文件
│   │   │   ├── log4j.xml                # 日志配置文件
│   │   │   └── META-INF/
│   │   │       └── persistence.xml      # JPA配置文件（可选）
│   └── test/
│       └── java/
│           └── com/
│               └── example/
│                   └── test/             # 测试类

Spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/tx
           http://www.springframework.org/schema/tx/spring-tx.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 配置组件扫描 -->
    <context:component-scan base-package="com.example"/>
    <!-- 配置数据源 -->
    <bean id="masterDataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
        <property name="driverClassName" value="org.postgresql.Driver"/>
        <property name="url" value="jdbc:postgresql://master-host:5432/your_database"/>
        <property name="username" value="your_username"/>
        <property name="password" value="your_password"/>
        <property name="maxTotal" value="10"/>
        <property name="maxIdle" value="5"/>
        <property name="minIdle" value="2"/>
        <property name="initialSize" value="5"/>
        <property name="removeAbandoned" value="true"/>
        <property name="removeAbandonedTimeout" value="60"/>
        <property name="logAbandoned" value="true"/>
        <property name="testOnBorrow" value="true"/>
        <property name="validationQuery" value="SELECT 1"/>
    </bean>
    <bean id="slaveDataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
        <property name="driverClassName" value="org.postgresql.Driver"/>
        <property name="url" value="jdbc:postgresql://slave-host:5432/your_database"/>
        <property name="username" value="your_username"/>
        <property name="password" value="your_password"/>
        <property name="maxTotal" value="20"/>
        <property name="maxIdle" value="10"/>
        <property name="minIdle" value="5"/>
        <property name="initialSize" value="10"/>
        <property name="removeAbandoned" value="true"/>
        <property name="removeAbandonedTimeout" value="60"/>
        <property name="logAbandoned" value="true"/>
        <property name="testOnBorrow" value="true"/>
        <property name="validationQuery" value="SELECT 1"/>
    </bean>
    <bean id="dynamicDataSource" class="com.example.util.DynamicDataSource">
        <property name="targetDataSources">
            <map key-type="java.lang.String">
                <entry key="master" value-ref="masterDataSource"/>
                <entry key="slave" value-ref="slaveDataSource"/>
            </map>
        </property>
        <property name="defaultTargetDataSource" ref="masterDataSource"/>
    </bean>
    <!-- 配置SessionFactory -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dynamicDataSource"/>
        <property name="packagesToScan" value="com.example.entity"/>
        <property name="hibernateProperties">
            <props>
                <prop>hibernate.dialect</prop>org.hibernate.dialect.PostgreSQLDialect
                <prop>hibernate.show_sql</prop>${hibernate.show_sql}
                <prop>hibernate.format_sql</prop>${hibernate.format_sql}
                <prop>hibernate.hbm2ddl.auto</prop>${hibernate.hbm2ddl.auto}
            </props>
        </property>
    </bean>
    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 配置事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
    <!-- 配置AOP -->
    <aop:config>
        <aop:aspect ref="dataSourceAspect">
            <aop:before method="setDataSourceType" pointcut="@annotation(org.springframework.transaction.annotation.Transactional)"/>
            <aop:after method="clearDataSourceType" pointcut="@annotation(org.springframework.transaction.annotation.Transactional)"/>
        </aop:aspect>
    </aop:config>
</beans>

AOP切面类

package com.example.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class DataSourceAspect {
    @Before("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void setDataSourceType(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Transactional transactional = methodSignature.getMethod().getAnnotation(Transactional.class);
        
        if (transactional != null && transactional.readOnly()) {
            try {
                DataSourceContextHolder.setDataSourceType("slave");
            } catch (Exception e) {
                // 如果从数据源发生异常，切换到主数据源
                DataSourceContextHolder.setDataSourceType("master");
            }
        } else {
            DataSourceContextHolder.setDataSourceType("master");
        }
    }
    
    @After("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void clearDataSourceType(JoinPoint joinPoint) {
        DataSourceContextHolder.clearDataSourceType();
    }
}

数据源切换工具类

package com.example.util;
public class DataSourceContextHolder {
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();
    
    public static void setDataSourceType(String dataSourceType) {
        contextHolder.set(dataSourceType);
    }
    
    public static String getDataSourceType() {
        return contextHolder.get();
    }
    
    public static void clearDataSourceType() {
        contextHolder.remove();
    }
}

动态数据源类

package com.example.util;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.getDataSourceType();
    }
}

Hibernate配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
        <property name="hibernate.show_sql">${hibernate.show_sql}</property>
        <property name="hibernate.format_sql">${hibernate.format_sql}</property>
        <property name="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</property>
        <property name="hibernate.c3p0.min_size">5</property>
        <property name="hibernate.c3p0.max_size">20</property>
        <property name="hibernate.c3p0.timeout">300</property>
        <property name="hibernate.c3p0.max_statements">50</property>
        <property name="hibernate.c3p0.idle_test_period">3000</property>
        
        <!-- 映射实体类 -->
        <mapping class="com.example.entity.User"/>
        <mapping class="com.example.entity.Message"/>
        <!-- 其他实体类 -->
    </session-factory>
</hibernate-configuration>

application.properties配置

# 数据源配置
spring.datasource.master.url=jdbc:postgresql://master-host:5432/your_database
spring.datasource.master.username=your_username
spring.datasource.master.password=your_password
spring.datasource.master.driver-class-name=org.postgresql.Driver
spring.datasource.slave.url=jdbc:postgresql://slave-host:5432/your_database
spring.datasource.slave.username=your_username
spring.datasource.slave.password=your_password
spring.datasource.slave.driver-class-name=org.postgresql.Driver
# Hibernate配置
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=update
# 其他配置
server.port=8080
server.servlet.context-path=/

Struts2配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
        "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.i18n.encoding" value="UTF-8"/>
    <constant name="struts.devMode" value="false"/>
    <constant name="struts.serve.static" value="false"/>
    <constant name="struts.ui.theme" value="simple"/>
    <interceptor-ref name="spring">
        <param name="excludePatterns">/static/**
        </param>
    </interceptor-ref>
    <package name="default" namespace="/" extends="struts-default,spring">
        <action name="*" class="{1}" method="{2}">
            <result type="tiles">{1}.{2}</result>
        </action>
    </package>
</struts>

读写分离实现原理

在实现读写分离时，我们利用了Spring的AOP机制和AbstractRoutingDataSource类来实现数据源的动态切换。具体原理如下：

数据源配置：

定义主从数据源，分别用于处理写操作和读操作
配置动态数据源，根据当前线程的上下文决定使用哪个数据源

AOP切面：

拦截被@Transactional注解标注的方法
根据@Transactional注解的readOnly属性判断是读操作还是写操作
设置当前线程的数据源类型

动态数据源：

继承AbstractRoutingDataSource类
重写determineCurrentLookupKey方法，根据ThreadLocal中的数据源类型决定使用哪个实际数据源

事务管理：

使用Spring提供的事务管理器
通过@Transactional注解配置事务属性
这种实现方式具有以下优势：

无需修改业务代码，通过注解即可控制数据源切换
支持事务管理，确保数据一致性
可以动态添加数据源，无需重启程序
简化了数据源管理，提高了系统的灵活性和可维护性

读写分离的负载均衡策略

为了提高系统的性能和可靠性，我们需要实现负载均衡策略，特别是在有多个从库的情况下。以下是几种常见的负载均衡算法：

轮询算法

public class RoundRobinLoadBalance {
    private AtomicInteger index = new AtomicInteger(0);
    private List<String> slaveDataSourceKeys = new ArrayList<>();
    
    public RoundRobinLoadBalance(List<String> slaveDataSourceKeys) {
        this.slaveDataSourceKeys = slaveDataSourceKeys;
    }
    
    public String selectDataSource() {
        int currentIndex = Math.abs(index.getAndIncrement() % slaveDataSourceKeys.size());
        return slaveDataSourceKeys.get(currentIndex);
    }
}

加权轮询算法

public class WeightedRoundRobinLoadBalance {
    private AtomicInteger index = new AtomicInteger(0);
    private List<WeightedDataSource> weightedDataSources = new ArrayList<>();
    
    public WeightedRoundRobinLoadBalance(List<WeightedDataSource> weightedDataSources) {
        this.weightedDataSources = weightedDataSources;
    }
    
    public String selectDataSource() {
        int totalWeight = weightedDataSources.stream()
                .mapToInt(WeightedDataSource::getWeight)
                .sum();
        
        int randomValue = new Random().nextInt(totalWeight);
        int currentWeight = 0;
        
        for (WeightedDataSource dataSource : weightedDataSources) {
            currentWeight += dataSource.getWeight();
            if (randomValue < currentWeight) {
                return dataSource.getDataSourceKey();
            }
        }
        
        return weightedDataSources.get(0).getDataSourceKey();
    }
    
    static class WeightedDataSource {
        private String dataSourceKey;
        private int weight;
        
        public WeightedDataSource(String dataSourceKey, int weight) {
            this.dataSourceKey = dataSourceKey;
            this.weight = weight;
        }
        
        public String getDataSourceKey() {
            return dataSourceKey;
        }
        
        public int getWeight() {
            return weight;
        }
    }
}

随机算法

public class RandomLoadBalance {
    private List<String> slaveDataSourceKeys = new ArrayList<>();
    
    public RandomLoadBalance(List<String> slaveDataSourceKeys) {
        this.slaveDataSourceKeys = slaveDataSourceKeys;
    }
    
    public String selectDataSource() {
        int randomIndex = new Random().nextInt(slaveDataSourceKeys.size());
        return slaveDataSourceKeys.get(randomIndex);
    }
}

最小活跃连接数算法

public class LeastActiveLoadBalance {
    private Map<String, AtomicInteger> connectionCounts = new HashMap<>();
    
    public String selectDataSource(List<String> slaveDataSourceKeys) {
        String selectedDataSource = null;
        int minConnections = Integer.MAX_VALUE;
        
        for (String dataSourceKey : slaveDataSourceKeys) {
            int currentConnections = connectionCounts.getOrDefault(dataSourceKey, new AtomicInteger(0)).get();
            if (currentConnections < minConnections) {
                minConnections = currentConnections;
                selectedDataSource = dataSourceKey;
            }
        }
        
        if (selectedDataSource != null) {
            connectionCounts.computeIfAbsent(selectedDataSource, k -> new AtomicInteger(0)).incrementAndGet();
        }
        
        return selectedDataSource;
    }
    
    public void releaseDataSource(String dataSourceKey) {
        if (connectionCounts.containsKey(dataSourceKey)) {
            int currentConnections = connectionCounts.get(dataSourceKey).decrementAndGet();
            if (currentConnections < 0) {
                currentConnections = 0;
            }
            connectionCounts.put(dataSourceKey, new AtomicInteger(currentConnections));
        }
    }
}

在实际应用中，可以根据系统的具体需求和从库的性能特点选择合适的负载均衡算法。对于大多数场景，简单的轮询算法已经足够，但对于性能要求较高的系统，可以考虑使用加权轮询或最小活跃连接数算法。

读写分离的故障转移策略

为了确保系统的高可用性，我们需要实现故障转移策略。当主库或某个从库发生故障时，系统能够自动切换到可用的节点，从而减少停机时间。

数据库连接健康检查

public class DataSourceHealthChecker {
    public boolean isHealthy(DataSource dataSource) {
        try (Connection connection = dataSource.getConnection()) {
            return connection != null && !connection.isClosed();
        } catch (SQLException e) {
            return false;
        }
    }
}

自动故障转移

public class FailoverStrategy {
    private List<String> allDataSources = new ArrayList<>();
    private Set<String> failedDataSources = new HashSet<>();
    
    public FailoverStrategy(List<String> allDataSources) {
        this.allDataSources = allDataSources;
    }
    
    public String selectDataSource() {
        List<String> availableDataSources = allDataSources.stream()
                .filter(dataSource -> !failedDataSources.contains(dataSource))
                .collect(Collectors.toList());
        
        if (availableDataSources.isEmpty()) {
            // 所有数据源都失败，尝试恢复
            availableDataSources.addAll(allDataSources);
            failedDataSources.clear();
        }
        
        // 使用负载均衡策略选择数据源
        return new RoundRobinLoadBalance(availableDataSources).selectDataSource();
    }
    
    public void markAsFailed(String dataSourceKey) {
        failedDataSources.add(dataSourceKey);
    }
    
    public void clearFailures() {
        failedDataSources.clear();
    }
}

定期健康检查

public class HealthCheckScheduler {
    private final DataSourceHealthChecker healthChecker;
    private final FailoverStrategy failoverStrategy;
    private final Map<String, DataSource> dataSourceMap;
    
    public HealthCheckScheduler(DataSourceHealthChecker healthChecker,
                               FailoverStrategy failoverStrategy,
                               Map<String, DataSource> dataSourceMap) {
        this.healthChecker = healthChecker;
        this.failoverStrategy = failoverStrategy;
        this.dataSourceMap = dataSourceMap;
    }
    
    public void scheduleHealthCheck(final int intervalSeconds) {
        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
            for (Map.Entry<String, DataSource> entry : dataSourceMap.entrySet()) {
                String dataSourceKey = entry.getKey();
                DataSource dataSource = entry.getValue();
                
                if (!healthChecker.isHealthy(dataSource)) {
                    failoverStrategy.markAsFailed(dataSourceKey);
                    System.out.println("Data source " + dataSourceKey + " is marked as failed.");
                } else {
                    if (failoverStrategy.getFailedDataSources().contains(dataSourceKey)) {
                        failoverStrategy.clearFailures();
                        System.out.println("Data source " + dataSourceKey + " has been recovered.");
                    }
                }
            }
        }, 0, intervalSeconds, TimeUnit.SECONDS);
    }
    
    public Set<String> getFailedDataSources() {
        return failoverStrategy.getFailedDataSources();
    }
}

实际应用中的考虑因素

在实际应用中，实现读写分离时需要考虑以下因素：

事务一致性

读写分离可能会导致事务一致性问题，特别是当读操作使用的是从库，而从库的数据可能与主库不同步。为了解决这个问题，可以采取以下措施：

使用合适的复制方式：

对于PostgreSQL，使用同步复制可以确保从库的数据与主库保持一致，但会降低写操作的性能
使用异步复制可以提高写操作的性能，但可能导致从库的数据延迟

控制事务隔离级别：

在读操作中使用适当的隔离级别，如REPEATABLE READ或SERIALIZABLE
对于需要强一致性的操作，使用主库进行读操作

应用层面的补偿机制：

对于需要严格一致性的操作，读写都使用主库
对于可以容忍一定延迟的操作，使用从库进行读操作

数据库连接池管理

由于使用了多个数据源，需要合理配置连接池参数：

主库连接池：

由于主要处理写操作，连接池可以配置较小的大小
配置适当的超时时间和验证查询

从库连接池：

由于主要处理读操作，连接池可以配置较大的大小
根据从库的数量和预期的读负载进行调整

连接池监控：

监控连接池的使用情况，及时发现和解决连接泄漏问题
定期清理空闲连接，防止资源耗尽

性能监控与优化

为了确保读写分离的效果，需要进行性能监控和优化：

监控指标：

数据库连接池使用情况
SQL执行时间
事务提交和回滚次数
读写操作比例

性能优化：

优化SQL查询，减少不必要的数据库操作
建立适当的索引，提高查询性能
考虑使用缓存技术，减少数据库访问

负载测试：

进行压力测试，验证系统的性能和稳定性
根据测试结果调整系统配置和业务逻辑

代码改造策略

在改造现有代码时，可以采取以下策略：

注解驱动：

使用@Transactional(readOnly = true)标记读操作
默认的@Transactional用于写操作

AOP切面：

创建一个切面，拦截所有标记的方法
根据readOnly属性切换数据源

业务逻辑分离：

将读操作和写操作分离到不同的服务类或方法中
在读操作方法上使用@ReadOnly注解

遗留代码处理：

对于没有使用Spring事务注解的遗留代码，可以使用@Around切面进行拦截
分析SQL语句，自动判断是读操作还是写操作

总结与最佳实践

改造方案总结

本报告详细介绍了如何在Spring历史项目中引入数据库读写分离机制，使用PostgreSQL作为数据库，结合JDK7环境下的Spring+Hibernate+Struts2技术栈。主要改造方案包括：

数据库层面：

配置PostgreSQL主从复制，实现数据同步
使用Pgpool-II或HAProxy等代理工具实现读写分离

应用层面：

配置主从数据源，实现动态数据源切换
使用Spring AOP实现透明的数据源切换
通过@Transactional注解的readOnly属性区分读写操作

框架整合：

配置Hibernate与PostgreSQL的集成
整合Struts2与Spring，确保数据源切换在Action层生效

负载均衡与故障转移：

实现轮询、加权轮询、随机等负载均衡算法
实现数据库连接健康检查和自动故障转移

最佳实践

在实施读写分离时，建议遵循以下最佳实践：

合理规划数据库架构：

根据业务需求和性能要求，合理设计主从架构
考虑数据同步的延迟和一致性要求

选择合适的复制方式：

根据业务特点选择同步复制或异步复制
对于强一致性要求高的业务，使用同步复制
对于可以容忍一定延迟的业务，使用异步复制

优化SQL查询：

避免复杂的SQL查询，减少数据库负载
为常用查询建立适当的索引
使用ORM框架的批量操作功能，减少数据库调用次数

监控和调优：

实施全面的监控，包括数据库性能、连接池使用情况等
定期分析查询性能，优化慢查询
根据监控数据调整系统配置和业务逻辑

测试和验证：

进行充分的功能测试，确保数据一致性
进行性能测试，验证系统的吞吐量和响应时间
进行故障恢复测试，验证系统的高可用性
通过以上改造方案和最佳实践，可以有效提高Spring项目的数据库访问性能，提升系统的可扩展性和高可用性，为业务发展提供强有力的技术支持。

参考文献

[35] Spring框架下的数据库读写分离实践. https://zhuanlan.zhihu.com/p/706728967.
[54] 解释在PostgreSQL中实施读写分离的策略和技术 - 关系型数据库 - 亿速云. https://www.yisu.com/jc/824571.html.
[55] postgresql 实现读写分离,主从复制_postgre数据库实现读写分离和主从同步-CSDN博客. https://blog.csdn.net/sheng990303/article/details/135669679.
[57] PostgreSQL中如何实现主从复制_云计算_筋斗云. https://www.jindouyun.cn/document/cloud/details/87601.

如果觉得文章对你有用，请随意赞赏

Spring读写分离 PostgreSQL主从复制动态数据源 AOP切面负载均衡 JDK7兼容 Hibernate配置 Struts2整合数据库性能优化故障转移策略

Spring项目数据库读写分离改造方案：PostgreSQL环境下的实现

https://www.fengyege.top/archives/8a8d5c20-c762-4f97-92db-70f04afe5bf8

作者

枫夜求索阁

发布于

2025-04-17

更新于

2025-04-17

许可协议

CC BY 4.0

Spring项目数据库读写分离改造方案：PostgreSQL环境下的实现

引言

数据库读写分离概述

PostgreSQL主从复制与读写分离

PostgreSQL主从复制配置

读写分离实现方式

Spring项目读写分离实现方案

技术路线选择

详细实现步骤

1. 定义数据源配置

2. 创建数据源Bean

3. 负载均衡策略

4. 配置动态数据源

5. 定义AOP切面

6. 使用@Transactional注解

7. 其他配置

Hibernate与PostgreSQL集成

Hibernate配置

Hibernate事务管理

Struts2与Spring整合

Struts2配置

Spring配置

JDK7兼容性考虑

完整改造方案

项目结构

Spring配置文件

AOP切面类

数据源切换工具类

动态数据源类

Hibernate配置文件

application.properties配置

Struts2配置文件

读写分离实现原理

读写分离的负载均衡策略

轮询算法

加权轮询算法

随机算法

最小活跃连接数算法

读写分离的故障转移策略

数据库连接健康检查

自动故障转移

定期健康检查

实际应用中的考虑因素

事务一致性

数据库连接池管理

性能监控与优化

代码改造策略

总结与最佳实践

改造方案总结

最佳实践

参考文献

作者

发布于

更新于

许可协议

评论