Question

我有两个类似的配置文件：

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = { "repo" },
    entityManagerFactoryRef = "db1",
    transactionManagerRef = "JpaTxnManager_db1")
public class RepositoryConfigSpringDataDb1 {
}

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(
    basePackages = { "repo" },
    entityManagerFactoryRef = "db2",
    transactionManagerRef = "JpaTxnManager_db2")
public class RepositoryConfigSpringDataDb2 {
}

我有一个dao类，它有很多方法。现在，在dao类中，我认为我可以使用在事务中指定的@Transactional注释来命中特定的数据库。

一些可以调用db1的示例方法是：

@Transactional(transactionManager="JpaTxnManager_db1")
public List<EntityOne> getAllEntitiesById(String id) { 
    return entityOneRepo.findById(id);
}

将调用db2 woudl的其他方法是：

@Transactional(transactionManager="JpaTxnManager_db2")
public List<EntityOne> getAllEntitiesById(String id) { 
    return entityOneRepo.findById(id);
}

回购定义如下：

@org.springframework.stereotype.Repository
public interface EntityOneRepository extends PagingAndSortingRepository<EntityOne, String> {
    // ommitted for brevity

-我已经为这些定义了不同的数据源，但是没有找到我定义的第二个数据源。

知道我想念的是什么吗？

是否可以使用相同的EntityOneRepository来扩展PagingAndSortingRepository，以基于transactionManagerRef和EntityManagerFactoryRef打2个不同的数据库？

Answer 1

我之前多次遇到这个问题，并使用Spring的DelegatingDataSource解决了这个问题，该问题允许您定义多个DataSource对象并通过某种类型的对象委托给所需的正确目标数据源查找键。其中的一个子类可能是TransactionAwareDataSourceProxy，可能是您在帖子中显示的代码的不错选择，正如JavaDoc描述的第一句话指出的那样：

目标JDBC数据源的代理，增加了对Spring管理的事务的认识。类似于Java EE服务器提供的事务性JNDI数据源。

通常，我总是在任何给定线程中使用相同的目标数据源，因此，我倾向于将查找键塞进ThreadLocal对象中，并让代理数据源在每次调用时都读取该密钥以查找实际的目标数据源。制成DataSource#getConnection。

如果创建了这样的委托（代理）数据源，则EntityManagerFactory可以将其用作其底层JDBC数据源，并在任何给定时间根据需要委托给正确的目标数据源。

多年来，我一直在使用JPA代码使用这种类型的方法，在该方法中，我需要使用相同的持久性单元访问多个数据源，这对我来说非常有用。应该也可以在Spring JPA数据存储库中正常工作。

下面是我之前从事的项目中的一些实现代码。该代码属于我，因此可以随意复制任何内容，并随心所欲地使用它。

这里是代理DataSource类，它委派给实际的目标JDBC DataSource。如上所述，它没有不扩展Spring的DelegatingDataSource，但它的作用完全相同。如果您不熟悉OSGI声明式服务及其注释（我想大多数人都不是），@Component(property = {"osgi.jndi.service.name=jdbc/customation"}就是将DataSource放入JNDI注册中心的位置，以便它可以由持久性单元描述符（persistence.xml）如下所示。

package com.custsoft.client.ds;

import com.custsoft.client.ClientXrefHolder;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.osgi.service.component.annotations.ReferencePolicy;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

import static com.custsoft.Constants.CLIENT;

/**
 * Proxy data source that delegates to an actual JDBC data source. 
 * There is one target JDBC data source per client.
 * 
 * Created by eric on 9/29/15.
 */
@Component(property = {"osgi.jndi.service.name=jdbc/customation"},
        service = DataSource.class)
public class ClientDelegatingDataSource implements DataSource {

    private static final Logger logger = LoggerFactory.getLogger(ClientDelegatingDataSource.class);

    private String DEFAULT_CLIENT_XREF = "customation";

    private Map<String, DataSource> clientDataSources = new HashMap<>();

    @Reference(target = "(client=*)",
            cardinality = ReferenceCardinality.MULTIPLE,
            policy = ReferencePolicy.DYNAMIC)
    protected void addDataSource(DataSource dataSource, Map<String, Object> properties) {
        final String clientId = getClientId(properties);
        clientDataSources.put(clientId, dataSource);
    }

    protected void removeDataSource(DataSource dataSource, Map<String, Object> properties) {
        final String clientId = getClientId(properties);
        clientDataSources.remove(clientId);
    }

    private String getClientId(Map<String, Object> properties) {
        return Objects.toString(properties.get(CLIENT), null);
    }

    @Override
    public Connection getConnection() throws SQLException {
        return determineTargetDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return determineTargetDataSource().getConnection(username, password);
    }

    private DataSource determineTargetDataSource() {

        String clientId = ClientXrefHolder.getClientXref();
        if (clientId == null) {
            clientId = DEFAULT_CLIENT_XREF;
        }

        DataSource dataSource = clientDataSources.get(clientId);
        if (dataSource == null) {
            final String message = String.format(
                    "Couldn't find data source for client \"%s\".", clientId);
            throw new IllegalStateException(message);
        }

        return dataSource;
    }

    @Override
    public <T> T unwrap(Class<T> iface) throws SQLException {
        return determineTargetDataSource().unwrap(iface);
    }

    @Override
    public boolean isWrapperFor(Class<?> iface) throws SQLException {
        return determineTargetDataSource().isWrapperFor(iface);
    }

    @Override
    public PrintWriter getLogWriter() throws SQLException {
        return determineTargetDataSource().getLogWriter();
    }

    @Override
    public void setLogWriter(PrintWriter out) throws SQLException {
        determineTargetDataSource().setLogWriter(out);
    }

    @Override
    public void setLoginTimeout(int seconds) throws SQLException {
        determineTargetDataSource().setLoginTimeout(seconds);
    }

    @Override
    public int getLoginTimeout() throws SQLException {
        return determineTargetDataSource().getLoginTimeout();
    }

    @Override
    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
        return determineTargetDataSource().getParentLogger();
    }

}

以下是在ThreadLocal中保存查找键的类：

package com.custsoft.client;

/**
 * Holds the client ID in the current thread. It is
 * generally placed there by a REST filter that reads
 * it from a "client" HTTP header.
 *
 * Created by eric on 8/25/15.
 */
public class ClientXrefHolder {

    private static final ThreadLocal<String> CLIENT_XREF_HOLDER = new ThreadLocal<>();

    public static String getClientXref() {
        return CLIENT_XREF_HOLDER.get();
    }

    public static void setClientXref(final String clientXref) {
        CLIENT_XREF_HOLDER.set(clientXref);
    }
}

persistence.xml：

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.0"
             xmlns="http://java.sun.com/xml/ns/persistence"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

    <persistence-unit name="customation" transaction-type="JTA">

        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>

        <!-- Only used when transaction-type=JTA -->
        <jta-data-source>osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=jdbc/customation)</jta-data-source>

        <!-- Only used when transaction-type=RESOURCE_LOCAL -->
        <non-jta-data-source>osgi:service/javax.sql.DataSource/(osgi.jndi.service.name=jdbc/customation)</non-jta-data-source>

        <class>com.custsoft.model.AccessToken</class>
        <class>com.custsoft.model.JpaModel</class>
        <class>com.custsoft.model.Role</class>
        <class>com.custsoft.model.stats.Stat</class>
        <class>com.custsoft.model.stats.StatDefinition</class>
        <class>com.custsoft.model.User</class>
        <class>com.custsoft.model.UserProperty</class>

        <properties>
            <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="validate"/>
        </properties>

    </persistence-unit>

</persistence>

Answer 2

我上面描述的解决方案为我工作。

当您拥有一个Repository类并且希望它能够访问多个数据源时要指出的主要事情，一种简单的方法是使用 @Transactional 注释。这样可以确保将匹配结果转到相应的数据库。

但是，我认为根据您的需求，埃里克·格林（Eric Green）的解决方案可能是在技术上更合适的方法。

是否可以使用相同的Spring数据存储库访问两个不同的数据库（数据源）？

2 个答案: