Básicamente, los artículos en Internet solo tienen múltiples fuentes de datos o solo fuentes de datos dinámicos, mientras que los proyectos recientes deben usar dos métodos al mismo tiempo. Registremos los métodos de configuración para su referencia.
Escenarios de aplicación
El proyecto necesita conectar dos bases de datos diferentes A y B al mismo tiempo, y ambas son arquitecturas de esclavo maestro, una biblioteca de escritura y múltiples bibliotecas de lectura.
Múltiples fuentes de datos
Primero, debe deshabilitar el DataSourCeautoconfiguration que viene con el arranque de Spring, porque leerá Spring.DataSource.* Propiedad del archivo Application.Properties y configurará automáticamente una sola fuente de datos. Simplemente agregue el atributo de exclusión a la anotación @SpringBootApplication:
@SpringBootApplication (excluir = {dataSourCeautoconfiguration.class}) clase pública TitanWebApplication {public static void main (string [] args) {springapplication.run (titanwebapplication.class, args); }}Luego configure la información de conexión de origen de múltiples datos en la aplicación.
# Biblioteca Titan spring.datasource.titan-master.url = jdbc: mysql: // xxxx: puerto/titan? caracterSencoding = utf-8spring.datasource.titan-master.u SERNAME = Spring.DataSource.titan-Master.password = Spring.datasource.titan-Master.Driver-Class-Name = com.mysql.jdbc.driver# Connection Pool Configuración# omitir# Otras bibliotecas spring.datasource.db2.url = jdbc: mysql: // xxxx: puerto/titan2? caracterSencoding = utf-8spring.dataSource.db2.username = spring.datasource.db2.password = spring.datasource.db2.driver-classs = com.mysql.jdbc.driver
Dado que hemos deshabilitado la configuración de la fuente de datos automática, necesitamos crear manualmente estas fuentes de datos en el siguiente paso:
@ConfigurationPublic Class DataSourCeConFig {@Bean (name = "TitanMasterds") @ConfigurationProperties (prefix = "Spring.datasource.titan-Master") // Prefix de la propiedad correspondiente en Application.Properteis Public DataSource DataSource1 () {return DataSource.Create ().).). } @Bean (name = "ds2") @configurationProperties (prefix = "spring.dataSource.db2") // Prefijo de la propiedad correspondiente en Application.Properteis Public DataSource DataSource2 () {return dataSourceBuilder.create (). Build (); }}A continuación, debe configurar dos mybatis sqlsessionFactory para usar diferentes fuentes de datos:
@Configuración @mapperscan (basepackages = {"titan.mapper"}, sqlsessionFactoryRef = "sqlSessionFactory1") clase pública myBatisDBaconfig {@aUtowired @Qualifier ("TitanMasterds") DataSource privado DS1; @Bean public sqlSessionFactory sqlSessionFactory1 () lanza la excepción {sqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean (); FactoryBean.SetDataSource (DS1); // Use la fuente de datos Titan para conectarse a la biblioteca Titan FactoryBean.getObject (); } @Bean public sqlSessionTemplate sqlSessionTemplate1 () lanza la excepción {sqlsessionTemplate plantplate = new SqlSessionTemplate (sqlSessionFactory1 ()); // Use la fábrica configurada anteriormente para devolver la plantilla; }}Después de la configuración anterior, la interfaz mapper en Titan.mapper usará la fuente de datos de Titan. Del mismo modo, puede usar la segunda SQLSessionFactory:
@Configuration @mapperscan (basepackages = {"other.mapper"}, sqlsessionFactoryRef = "sqlSessionFactory2") clase pública mybatisdbbconfig {@aUtowired @Qualifier ("ds2") DataSource privado DS2; @Bean public sqlSessionFactory sqlSessionFactory2 () lanza la excepción {sqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean (); FactoryBean.SetDataSource (DS2); return factoryBean.getObject (); } @Bean public sqlSessionTemplate sqlSessionTemplate2 () lanza la excepción {sqlSessionTemplate plantplate = new SqlSessionTemplate (SQLSessionFactory2 ()); plantilla de retorno; }}Después de completar estas configuraciones, suponga que hay 2 mapper titan.mapper.usermapper y otros.mapper.rolemapper. Al usar el primero, la biblioteca Titan se conectará automáticamente y la última se conectará a la biblioteca DS2.
Fuentes de datos dinámicas
La intención original de usar fuentes de datos dinámicas es poder separar la lectura y escribir en la capa de aplicación, es decir, para controlar los diferentes métodos de consulta en el código de programa para conectarse a diferentes bibliotecas. Además de este método, el middleware de la base de datos también es una buena opción. Su ventaja es que el clúster de la base de datos solo está expuesto a una sola biblioteca para la aplicación y no necesita cambiar la lógica del código de la fuente de datos.
Nos damos cuenta del cambio de fuente de datos dinámico a través de anotaciones personalizadas + AOP.
Primero defina un ContexTholder para guardar el nombre de origen de datos utilizado por el subproceso actual:
Public Class DataSourCeceTExTholder {public static final logger log = loggerFactory.getLogger (dataSoUrceTextholder.class); / *** fuente de datos predeterminada*/ public static final cadena default_ds = "titan-master"; Private Static Final ThreadLocal <String> contextholder = new ThreadLocal <> (); // Establezca el nombre de fuente de datos public static void setdb (string dbtype) {log.debug ("cambiar a {} fuente de datos", dbtype); cotexTholder.set (dbType); } // Obtener el nombre de fuente de datos public static String getDb () {return (cotexTholder.get ()); } // Borrar el nombre de origen de datos public static void clearDb () {cotextholder.remove (); }}Luego personalice la implementación de la interfaz Javax.sql.DataSource. Aquí solo necesita heredar la clase matriz abstrutingdataSource que Spring ha implementado para nosotros por adelantado:
Public Class DynamicDataSource extiende AbstrutingDataSource {Private static final Logger log = loggerFactory.getLogger (DynamicDataSource.class); @Override Objeto protegido DetetInECRENTLOVEWUpKey () {log.debug ("La fuente de datos es {}", dataSoUrceCtexTholder.getDb ()); return dataSourCeTeTexTholder.getDb (); }}Crear fuentes de datos dinámicas:
/ *** Fuente de datos dinámicos: cambio dinámico entre diferentes fuentes de datos a través de AOP* @return*/ @Bean (name = "DynamicDS1") public dataSource dataSource () {DynamicDataSource DynamicDataSource = new DynamicDataSource (); // Fuente de datos predeterminado DynamicDataSource.setDefaultTargetDataSource (DataSource1 ()); // Configurar el mapa de origen de múltiples datos <objeto, objeto> dsmap = new HashMap (5); dsmap.put ("Titan-Master", DataSource1 ()); dsmap.put ("ds2", dataSource2 ()); dynamicDataSource.settArgetDataSources (DSMAP); return DynamicDataSource; }La anotación personalizada @DS se usa para especificar qué fuente de datos utiliza el método al codificar:
@Retention (retentionPolicy.Runtime) @Target ({elementType.method}) public @interface ds {string value () predeterminado "titan-master";}Escriba secciones AOP para implementar la lógica de conmutación:
@Aspecto@ComponentPublic Class DynamicDataSourCeAspect {@before ("@annotation (ds)") public void befefefefeSwitchds (unión de punto de unión) {// Obtenga la clase de acceso actual <?> ClassName = Point.getTarget (). GetClass (); // Obtenga el nombre de Método de acceso String MethodName = Point.getSignature (). GetName (); // Obtenga el tipo de parámetro de la clase de método [] argClass = ((Methodsignature) Point.getSignature ()). GetParametertyPes (); String DataSource = DataSourCeTexTholder.default_ds; Pruebe {// El objeto de método accedido es método método = classname.getMethod (MethodName, ArgClass); // Determinar si la anotación @DS existe si (Method.IsannotationPresent (ds.class)) {ds anotation = método.getAnnotation (ds.class); // Saque el nombre de la fuente de datos en la anotación dataSource = annotation.value (); }} catch (Exception e) {E.PrintStackTrace (); } // cambia la fuente de datos DataSourCeTeTexTholder.SetDB (DataSource); } @After (" @annotation (ds)") public void AfterSwitchds (unión de punto de unión) {dataSoUrceTexTholder.CLearDB (); }}Después de completar la configuración anterior, especificando DynamicDataSource en la configuración SQLSessionFactory anterior para usar DynamicDataSource para cambiar felizmente las fuentes de datos en el servicio:
@AUTOWIREDIREDIRDER UserAmodelMapper UserAmapper; @Ds ("Titan-Master") public String ds1 () {return userAmapper.SelectByPrimaryKey (1) .getName (); } @Ds ("ds2") public String ds2 () {return userAmapper.SelectByPrimaryKey (1) .getName (); }Resumir
Lo anterior es el Spring Boot + MyBatis Multi-Data Source y el método de configuración de la fuente de datos dinámico que el editor le presenta. Espero que te sea útil. Si tiene alguna pregunta, déjame un mensaje y el editor le responderá a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!