mybatis操作多數(shù)據(jù)源實(shí)現(xiàn)的方法

本文講解"mybatis操作多數(shù)據(jù)源實(shí)現(xiàn)的方法"，希望能夠解決相關(guān)問題。

現(xiàn)在有一個mysql數(shù)據(jù)源和一個postgresql數(shù)據(jù)源，使用mybatis對兩個數(shù)據(jù)源進(jìn)行操作：

1. 注入多數(shù)據(jù)源

可以對兩個數(shù)據(jù)源分別實(shí)現(xiàn)其service層和mapper層，以及mybatis的配置類：

@configuration
// 這里需要配置掃描包路徑，以及sqlsessiontemplateref
@mapperscan(basepackages = "com.example.mybatisdemo.mapper.mysql", sqlsessiontemplateref = "mysqlsqlsessiontemplate")
public class mysqlmybatisconfigurer {
    /**
     * 注入mysql數(shù)據(jù)源
     */
    @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);
        // 設(shè)置對應(yīng)的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數(shù)據(jù)源
     */
    @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);
        // 設(shè)置對應(yīng)的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);
    }
}

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

2. 動態(tài)數(shù)據(jù)源

spring中提供了abstractroutingdatasource抽象類，可以用于動態(tài)地選擇數(shù)據(jù)源。

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;
    // 略
}

通過源碼可以看到，該抽象類實(shí)現(xiàn)了initializingbean接口，并在其afterpropertiesset方法中將數(shù)據(jù)源以的形式放入一個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);
            // 將數(shù)據(jù)源以的形式放入map中
            this.resolveddatasources.put(lookupkey, datasource);
        });
        if (this.defaulttargetdatasource != null) {
            this.resolveddefaultdatasource = this.resolvespecifieddatasource(this.defaulttargetdatasource);
        }
    }
}

該類中還有一個determinetargetdatasource方法，是根據(jù)lookupkey從map中獲取對應(yīng)的數(shù)據(jù)源，如果沒有獲取到，則使用默認(rèn)的數(shù)據(jù)源。

protected datasource determinetargetdatasource() {
    assert.notnull(this.resolveddatasources, "datasource router not initialized");
    object lookupkey = this.determinecurrentlookupkey();
    // 根據(jù)lookupkey從map中獲取對應(yīng)的數(shù)據(jù)源
    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方法獲取到的，而它是一個抽象方法，我們要做的就是通過實(shí)現(xiàn)這個方法，來控制獲取到的數(shù)據(jù)源。

@nullable
protected abstract object determinecurrentlookupkey();

(1) 創(chuàng)建并注入動態(tài)數(shù)據(jù)源

創(chuàng)建abstractroutingdatasource的子類，實(shí)現(xiàn)determinecurrentlookupkey方法

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

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

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

通過調(diào)用datasourcecontextholder.mysql()或者datasourcecontextholder.postgresql()就能修改contextholder的值，從而在動態(tài)數(shù)據(jù)源的determinetargetdatasource方法中就能獲取到對應(yīng)的數(shù)據(jù)源。

在數(shù)據(jù)源配置類中，將mysql和postgresql的數(shù)據(jù)源設(shè)置到動態(tài)數(shù)據(jù)源的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);
        // 設(shè)置數(shù)據(jù)源
        routingdatasource.settargetdatasources(datasources);
        return routingdatasource;
    }
}

(2) mybatis配置類

由于使用了動態(tài)數(shù)據(jù)源，所以只需要編寫一個配置類即可。

@configuration
@mapperscan(basepackages = "com.example.mybatisdemo.mapper", sqlsessiontemplateref = "sqlsessiontemplate")
public class mybatisconfigurer {
    // 注入動態(tài)數(shù)據(jù)源
    @resource
    private routingdatasource routingdatasource;
    @bean
    public sqlsessionfactory sqlsessionfactory() throws exception {
        sqlsessionfactorybean sqlsessionfactorybean = new sqlsessionfactorybean();
        sqlsessionfactorybean.setdatasource(routingdatasource);
        // 這里可以直接設(shè)置所有的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) 使用注解簡化數(shù)據(jù)源切換

我們雖然可以使用datasourcecontextholder類中的方法進(jìn)行動態(tài)數(shù)據(jù)源切換，但是這種方式有些繁瑣，不夠優(yōu)雅?？梢钥紤]使用注解的形式簡化數(shù)據(jù)源切換。
我們先定義兩個注解，表示使用mysql數(shù)據(jù)源或postgresql數(shù)據(jù)源：

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

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

再定義一個切面，當(dāng)使用了注解時，會先調(diào)用切換數(shù)據(jù)源的方法，再執(zhí)行后續(xù)邏輯。

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

在使用動態(tài)數(shù)據(jù)源的事務(wù)操作時有兩個需要注意的問題：

問題一    同一個事務(wù)操作兩個數(shù)據(jù)源

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

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

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

問題二      兩個獨(dú)立事務(wù)分別操作兩個數(shù)據(jù)源

(1) 在開啟事務(wù)的時候，datasourcetransactionmanager中的dobegin方法會先獲取connection，并保存到connectionholder中，將數(shù)據(jù)源和connectionholder的對應(yīng)關(guān)系綁定到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();
        // 略
        // 將數(shù)據(jù)源和connectionholder的關(guān)系綁定到transactionsynchronizationmanager中
        if (txobject.isnewconnectionholder()) {
            transactionsynchronizationmanager.bindresource(this.obtaindatasource(), txobject.getconnectionholder());
        }
         // 略
}

(2) transactionsynchronizationmanager的bindresource方法將數(shù)據(jù)源和connectionholder的對應(yīng)關(guān)系存入線程變量resources中。

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