mybatis操作多數據源實現的方法

本文講解"mybatis操作多數據源實現的方法"，希望能夠解決相關問題。

現在有一個mysql數據源和一個postgresql數據源，使用mybatis對兩個數據源進行操作：

1. 注入多數據源

可以對兩個數據源分別實現其service層和mapper層，以及mybatis的配置類：

@configuration
// 這里需要配置掃描包路徑，以及sqlsessiontemplateref
@mapperscan(basepackages = "com.example.mybatisdemo.mapper.mysql", sqlsessiontemplateref = "mysqlsqlsessiontemplate")
public class mysqlmybatisconfigurer {
    /**
     * 注入mysql數據源
     */
    @bean
    @configurationproperties(prefix = "spring.datasource.mysql")
    public datasource mysqldatasource() {
        return new druiddatasource();
    }
    /**
     * 注入mysqlsqlsessionfactory
     */
    @bean
    public sqlsessionfactory mysqlsqlsessionfactory(datasource mysqldatasource) throws exception {
        sqlsessionfactorybean factorybean = new sqlsessionfactorybean();
        factorybean.setdatasource(mysqldatasource);
        // 設置對應的mapper文件
        factorybean.setmapperlocations(new pathmatchingresourcepatternresolver().getresources("classpath:" +
                "/mappers/mysqlmapper.xml"));
        return factorybean.getobject();
    }
    /**
     * 注入mysqlsqlsessiontemplate
     */
    @bean
    public sqlsessiontemplate mysqlsqlsessiontemplate(sqlsessionfactory mysqlsqlsessionfactory) {
        return new sqlsessiontemplate(mysqlsqlsessionfactory);
    }
    /**
     * 注入mysqltransactionalmanager
     */
    @bean
    public datasourcetransactionmanager mysqltransactionalmanager(datasource mysqldatasource) {
        return new datasourcetransactionmanager(mysqldatasource);
    }
}

@configuration
// 這里需要配置掃描包路徑，以及sqlsessiontemplateref
@mapperscan(basepackages = "com.example.mybatisdemo.mapper.postgresql", sqlsessiontemplateref = "postgresqlsqlsessiontemplate")
public class postgresqlmybatisconfigurer {
    /**
     * 注入postgresql數據源
     */
    @bean
    @configurationproperties(prefix = "spring.datasource.postgresql")
    public datasource postgresqldatasource() {
        return new druiddatasource();
    }
    /**
     * 注入postgresqlsqlsessionfactory
     */
    @bean
    public sqlsessionfactory postgresqlsqlsessionfactory(datasource postgresqldatasource) throws exception {
        sqlsessionfactorybean factorybean = new sqlsessionfactorybean();
        factorybean.setdatasource(postgresqldatasource);
        // 設置對應的mapper文件
        factorybean.setmapperlocations(new pathmatchingresourcepatternresolver().getresources("classpath:" +
                "/mappers/postgresqlmapper.xml"));
        return factorybean.getobject();
    }
    /**
     * 注入postgresqlsqlsessiontemplate
     */
    @bean
    public sqlsessiontemplate postgresqlsqlsessiontemplate(sqlsessionfactory postgresqlsqlsessionfactory) {
        return new sqlsessiontemplate(postgresqlsqlsessionfactory);
    }
    /**
     * 注入postgresqltransactionalmanager
     */
    @bean
    public datasourcetransactionmanager postgresqltransactionalmanager(datasource postgresqldatasource) {
        return new datasourcetransactionmanager(postgresqldatasource);
    }
}

在配置類中，分別注入了一個事務管理器transactionmanager，這個和事務管理是相關的。在使用@transactional注解時，需要配置其value屬性指定對應的事務管理器。

2. 動態數據源

spring中提供了abstractroutingdatasource抽象類，可以用于動態地選擇數據源。

public abstract class abstractroutingdatasource extends abstractdatasource implements initializingbean {
    @nullable
    private map targetdatasources;
    @nullable
    private object defaulttargetdatasource;
    private boolean lenientfallback = true;
    private datasourcelookup datasourcelookup = new jndidatasourcelookup();
    @nullable
    private map resolveddatasources;
    @nullable
    private datasource resolveddefaultdatasource;
    // 略
}

通過源碼可以看到，該抽象類實現了initializingbean接口，并在其afterpropertiesset方法中將數據源以的形式放入一個map中。

public void afterpropertiesset() {
    if (this.targetdatasources == null) {
        throw new illegalargumentexception("property 'targetdatasources' is required");
    } else {
        this.resolveddatasources = collectionutils.newhashmap(this.targetdatasources.size());
        this.targetdatasources.foreach((key, value) -> {
            object lookupkey = this.resolvespecifiedlookupkey(key);
            datasource datasource = this.resolvespecifieddatasource(value);
            // 將數據源以的形式放入map中
            this.resolveddatasources.put(lookupkey, datasource);
        });
        if (this.defaulttargetdatasource != null) {
            this.resolveddefaultdatasource = this.resolvespecifieddatasource(this.defaulttargetdatasource);
        }
    }
}

該類中還有一個determinetargetdatasource方法，是根據lookupkey從map中獲取對應的數據源，如果沒有獲取到，則使用默認的數據源。

protected datasource determinetargetdatasource() {
    assert.notnull(this.resolveddatasources, "datasource router not initialized");
    object lookupkey = this.determinecurrentlookupkey();
    // 根據lookupkey從map中獲取對應的數據源
    datasource datasource = (datasource)this.resolveddatasources.get(lookupkey);
    if (datasource == null && (this.lenientfallback || lookupkey == null)) {
        datasource = this.resolveddefaultdatasource;
    }
    if (datasource == null) {
        throw new illegalstateexception("cannot determine target datasource for lookup key [" + lookupkey + "]");
    } else {
        return datasource;
    }
}

lookupkey是通過determinetargetdatasource方法獲取到的，而它是一個抽象方法，我們要做的就是通過實現這個方法，來控制獲取到的數據源。

@nullable
protected abstract object determinecurrentlookupkey();

(1) 創建并注入動態數據源

創建abstractroutingdatasource的子類，實現determinecurrentlookupkey方法

public class routingdatasource extends abstractroutingdatasource {
    @override
    protected object determinecurrentlookupkey() {
        return datasourcecontextholder.get();
    }
}

這里的datasourcecontextholder是一個操作threadlocal對象的工具類

public class datasourcecontextholder {
    /**
     * 數據源上下文
     */
    private static final threadlocal contextholder = new threadlocal<>();
    /**
     * 設置數據源類型
     */
    public static void set(datasourcetype type) {
        contextholder.set(type);
    }
    /**
     * 獲取數據源類型
     *
     * @return datasourcetype
     */
    public static datasourcetype get() {
        return contextholder.get();
    }
    /**
     * 使用mysql數據源
     */
    public static void mysql() {
        set(datasourcetype.mysql);
    }
    /**
     * 使用postgresql數據源
     */
    public static void postgresql() {
        set(datasourcetype.postgresql);
    }
    public static void remove() {
        contextholder.remove();
    }
}

通過調用datasourcecontextholder.mysql()或者datasourcecontextholder.postgresql()就能修改contextholder的值，從而在動態數據源的determinetargetdatasource方法中就能獲取到對應的數據源。

在數據源配置類中，將mysql和postgresql的數據源設置到動態數據源的map中，并注入容器。

@configuration
public class datasourceconfigurer {
    @bean
    @configurationproperties(prefix = "spring.datasource.mysql")
    public datasource mysqldatasource() {
        return new druiddatasource();
    }
    @bean
    @configurationproperties(prefix = "spring.datasource.postgresql")
    public datasource postgresqldatasource() {
        return new druiddatasource();
    }
    @bean
    public routingdatasource routingdatasource(datasource mysqldatasource, datasource postgresqldatasource) {
        map datasources = new hashmap<>();
        datasources.put(datasourcetype.mysql, mysqldatasource);
        datasources.put(datasourcetype.postgresql, postgresqldatasource);
        routingdatasource routingdatasource = new routingdatasource();
        routingdatasource.setdefaulttargetdatasource(mysqldatasource);
        // 設置數據源
        routingdatasource.settargetdatasources(datasources);
        return routingdatasource;
    }
}

(2) mybatis配置類

由于使用了動態數據源，所以只需要編寫一個配置類即可。

@configuration
@mapperscan(basepackages = "com.example.mybatisdemo.mapper", sqlsessiontemplateref = "sqlsessiontemplate")
public class mybatisconfigurer {
    // 注入動態數據源
    @resource
    private routingdatasource routingdatasource;
    @bean
    public sqlsessionfactory sqlsessionfactory() throws exception {
        sqlsessionfactorybean sqlsessionfactorybean = new sqlsessionfactorybean();
        sqlsessionfactorybean.setdatasource(routingdatasource);
        // 這里可以直接設置所有的mapper.xml文件
        sqlsessionfactorybean.setmapperlocations(new pathmatchingresourcepatternresolver().getresources("classpath" +
                ":mappers/*.xml"));
        return sqlsessionfactorybean.getobject();
    }
    @bean
    public sqlsessiontemplate sqlsessiontemplate(sqlsessionfactory sqlsessionfactory) {
        return new sqlsessiontemplate(sqlsessionfactory);
    }
    @bean
    public datasourcetransactionmanager transactionalmanager(datasource mysqldatasource) {
        return new datasourcetransactionmanager(mysqldatasource);
    }
}

(3) 使用注解簡化數據源切換

我們雖然可以使用datasourcecontextholder類中的方法進行動態數據源切換，但是這種方式有些繁瑣，不夠優雅。可以考慮使用注解的形式簡化數據源切換。
我們先定義兩個注解，表示使用mysql數據源或postgresql數據源：

@target({elementtype.type, elementtype.method})
@retention(retentionpolicy.runtime)
public @interface mysql {
}

@target({elementtype.type, elementtype.method})
@retention(retentionpolicy.runtime)
public @interface postgresql {
}

再定義一個切面，當使用了注解時，會先調用切換數據源的方法，再執行后續邏輯。

@component
@aspect
public class datasourceaspect {
    @pointcut("@within(com.example.mybatisdemo.aop.mysql) || @annotation(com.example.mybatisdemo.aop.mysql)")
    public void mysqlpointcut() {
    }
    @pointcut("@within(com.example.mybatisdemo.aop.postgresql) || @annotation(com.example.mybatisdemo.aop.postgresql)")
    public void postgresqlpointcut() {
    }
    @before("mysqlpointcut()")
    public void mysql() {
        datasourcecontextholder.mysql();
    }
    @before("postgresqlpointcut()")
    public void postgresql() {
        datasourcecontextholder.postgresql();
    }
}

在使用動態數據源的事務操作時有兩個需要注意的問題：

問題一    同一個事務操作兩個數據源

mybatis使用executor執行sql時需要獲取連接，baseexecutor類中的getconnection方法調用了springmanagedtransaction中的getconnection方法，這里優先從connection字段獲取連接，如果connection為空，才會調用openconnection方法，并把連接賦給connection字段。

也就是說，如果你使用的是同一個事務來操作兩個數據源，那拿到的都是同一個連接，會導致數據源切換失敗。

protected connection getconnection(log statementlog) throws sqlexception {
    connection connection = this.transaction.getconnection();
    return statementlog.isdebugenabled() ? connectionlogger.newinstance(connection, statementlog, this.querystack) : connection;
}

public connection getconnection() throws sqlexception {
    if (this.connection == null) {
        this.openconnection();
    }
    return this.connection;
}

private void openconnection() throws sqlexception {
    this.connection = datasourceutils.getconnection(this.datasource);
    this.autocommit = this.connection.getautocommit();
    this.isconnectiontransactional = datasourceutils.isconnectiontransactional(this.connection, this.datasource);
    logger.debug(() -> {
        return "jdbc connection [" + this.connection + "] will" + (this.isconnectiontransactional ? " " : " not ") + "be managed by spring";
    });
}

問題二      兩個獨立事務分別操作兩個數據源

(1) 在開啟事務的時候，datasourcetransactionmanager中的dobegin方法會先獲取connection，并保存到connectionholder中，將數據源和connectionholder的對應關系綁定到transactionsynchronizationmanager中。

protected void dobegin(object transaction, transactiondefinition definition) {
    datasourcetransactionmanager.datasourcetransactionobject txobject = (datasourcetransactionmanager.datasourcetransactionobject)transaction;
    connection con = null;
    try {
        if (!txobject.hasconnectionholder() || txobject.getconnectionholder().issynchronizedwithtransaction()) {
            // 獲取連接
            connection newcon = this.obtaindatasource().getconnection();
            if (this.logger.isdebugenabled()) {
                this.logger.debug("acquired connection [" + newcon + "] for jdbc transaction");
            }
            // 保存到connectionholder中
            txobject.setconnectionholder(new connectionholder(newcon), true);
        }
        txobject.getconnectionholder().setsynchronizedwithtransaction(true);
        // 從connectionholder獲取連接
        con = txobject.getconnectionholder().getconnection();
        // 略
        // 將數據源和connectionholder的關系綁定到transactionsynchronizationmanager中
        if (txobject.isnewconnectionholder()) {
            transactionsynchronizationmanager.bindresource(this.obtaindatasource(), txobject.getconnectionholder());
        }
         // 略
}

(2) transactionsynchronizationmanager的bindresource方法將數據源和connectionholder的對應關系存入線程變量resources中。

public abstract class transactionsynchronizationmanager {
    // 線程變量
    private static final threadlocal