Laravel登录时切换默认数据库并在会话全局生效的实现方法

要解决登录后全局生效的数据库切换问题，核心思路是将用户对应的数据库标识与登录会话绑定，让后续所有请求从会话中读取标识并动态路由到目标数据库。以下是不同主流后端框架的具体实现方案：

Java Spring Boot 实现 #

1. 配置多数据源 #

在 application.yml 中定义两个数据库的连接信息：

spring:
  datasource:
    database1:
      url: jdbc:mysql://localhost:3306/db1
      username: root
      password: your_password
    database2:
      url: jdbc:mysql://localhost:3306/db2
      username: root
      password: your_password

2. 实现动态数据源路由类 #

继承 AbstractRoutingDataSource，重写路由逻辑，从当前请求会话中获取数据库标识：

public class DynamicDataSource extends AbstractRoutingDataSource {
    @Override
    protected Object determineCurrentLookupKey() {
        // 从请求会话中读取预先存储的数据库标识
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpSession session = request.getSession(false);
        if (session != null) {
            return session.getAttribute("dbKey");
        }
        // 默认返回database1作为 fallback
        return "database1";
    }
}

3. 注册动态数据源为默认数据源 #

配置类中绑定多数据源并设置动态路由规则：

@Configuration
public class DataSourceConfig {
    @Bean(name = "database1")
    @ConfigurationProperties(prefix = "spring.datasource.database1")
    public DataSource database1() {
        return DataSourceBuilder.create().build();
    }

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

    @Bean
    public DataSource dynamicDataSource(@Qualifier("database1") DataSource db1, @Qualifier("database2") DataSource db2) {
        DynamicDataSource dynamicDS = new DynamicDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put("database1", db1);
        targetDataSources.put("database2", db2);
        dynamicDS.setTargetDataSources(targetDataSources);
        dynamicDS.setDefaultTargetDataSource(db1);
        return dynamicDS;
    }

    // 配置SqlSessionFactory使用动态数据源
    @Bean
    public SqlSessionFactory sqlSessionFactory(@Qualifier("dynamicDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSource);
        return factoryBean.getObject();
    }
}

4. 登录时绑定数据库标识到会话 #

登录接口中根据财年确定数据库标识，存入用户会话：

@PostMapping("/login")
public ResponseEntity<?> login(@RequestBody LoginRequest request, HttpSession session) {
    // 执行用户验证逻辑...
    String fiscalYear = getUserFiscalYear(request.getUsername());
    String dbKey = "2022-2023".equals(fiscalYear) ? "database1" : "database2";
    session.setAttribute("dbKey", dbKey);
    return ResponseEntity.ok("登录成功");
}

Python Django 实现 #

1. 配置多数据库 #

在 settings.py 中定义数据库列表：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'default_db',
        'USER': 'root',
        'PASSWORD': 'your_password',
        'HOST': 'localhost'
    },
    'database1': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db1',
        'USER': 'root',
        'PASSWORD': 'your_password',
        'HOST': 'localhost'
    },
    'database2': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'db2',
        'USER': 'root',
        'PASSWORD': 'your_password',
        'HOST': 'localhost'
    }
}

2. 编写动态数据库中间件 #

创建 middleware.py，将数据库标识绑定到当前请求：

class DynamicDatabaseMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.user.is_authenticated:
            # 从用户模型读取财年，或从会话中获取
            fiscal_year = request.user.fiscal_year
            request.db_alias = 'database1' if fiscal_year == '2022-2023' else 'database2'
        response = self.get_response(request)
        return response

在 settings.py 的 MIDDLEWARE 列表中添加该中间件（需放在认证中间件之后）。

3. 实现数据库路由规则 #

创建 routers.py，根据请求中的标识路由数据库：

class DynamicDatabaseRouter:
    def db_for_read(self, model, **hints):
        request = hints.get('request')
        if request and hasattr(request, 'db_alias'):
            return request.db_alias
        return 'default'

    def db_for_write(self, model, **hints):
        request = hints.get('request')
        if request and hasattr(request, 'db_alias'):
            return request.db_alias
        return 'default'

在 settings.py 中配置路由：

DATABASE_ROUTERS = ['your_app.routers.DynamicDatabaseRouter']

Node.js Express 实现 #

1. 创建多数据库连接池 #

在 db.js 中初始化两个数据库连接池：

const mysql = require('mysql2/promise');

const pool1 = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'db1'
});

const pool2 = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'your_password',
    database: 'db2'
});

module.exports = { pool1, pool2 };

2. 编写动态数据库中间件 #

将目标数据库实例绑定到 req 对象：

const { pool1, pool2 } = require('./db');

function dynamicDbMiddleware(req, res, next) {
    if (req.session && req.session.user) {
        const fiscalYear = req.session.user.fiscalYear;
        req.db = fiscalYear === '2022-2023' ? pool1 : pool2;
    } else {
        req.db = pool1; // 默认数据库
    }
    next();
}

// 注册中间件（需放在session中间件之后）
app.use(session({
    secret: 'your_session_secret',
    resave: false,
    saveUninitialized: false
}));
app.use(dynamicDbMiddleware);

3. 登录时存储财年信息 #

登录接口中将用户财年存入会话：

app.post('/login', async (req, res) => {
    // 执行用户验证逻辑...
    const user = await getUserByUsername(req.body.username);
    req.session.user = {
        username: user.username,
        fiscalYear: user.fiscalYear
    };
    res.json({ success: true });
});

4. 后续请求使用绑定的数据库 #

接口中直接通过 req.db 操作数据库：

app.get('/api/data', async (req, res) => {
    const [rows] = await req.db.query('SELECT * FROM your_table');
    res.json(rows);
});

关键注意事项 #

• 会话隔离：确保每个用户的数据库标识存储在独立会话中，避免多用户冲突
• 线程安全：在多线程框架中（如Spring），需使用线程安全的上下文存储标识（如RequestContextHolder）
• 权限校验：禁止用户手动修改会话中的数据库标识，可对标识进行签名验证
• fallback 处理：未登录或会话过期时，设置默认数据库避免报错

内容的提问来源于stack exchange，提问作者Nixon Darius