Prefacio:
Septiembre del año pasado, mis colegas y yo en los frikis tiempo ganado Ding Xuefeng Familia del resorte cubo de aprendizaje 's, plan de estudios se divide en 16 capítulos en total, he aprendido la mayor parte, son registrados en un cuaderno antes, hoy quiero registro en el blog, compartir más conocimiento a las personas que necesitan ayuda, voy a ser el número de capítulos como el contenido del artículo, el curso original hablar con más detalle, yo estoy aquí para hacer un resumen sobre algunos puntos específicos.
1.Spring cubo de la familia contiene lo que?
Nacido en 2002, de un Rod Johnson, la primavera ha desarrollado ahora a la versión 5.x
Spring Framework
solución ligera para crear aplicaciones empresariales
concepto:
- 1. encarnan el espíritu de la tolerancia a la diversidad sea
- 2. mantener la compatibilidad hacia atrás
- 3. Diseño de la API de enfoque
- 4. persiguen calidad riguroso código
SpringBoot
El concepto: a construir rápidamente aplicaciones basadas en primavera
características:
- 1. rápido
- 2. fuera de la caja.
- 3. Para proporcionar una variedad de propiedades no funcionales
- 4. no generan código de configuración XML
- 5. contenedor Tomcat edificio, comienza muy conveniente.
II. Entender la tendencia de desarrollo de la primavera
Los cambios apuntan:
- 1.Java 8+ Kotlin
- 2.WebFlux (el ascenso de modelo de programación asíncrona)
- 3. Retirar un gran apoyo (portlets obsoleta, la velocidad no mantiene una JasperReport fuera de moda)
III. La creación de un Programa de Primavera
omisión
IV. Cómo configurar una única fuente de datos
SpringBoot hacer lo que la configuración
- DataSourceAutoConfiguration (配置 DataSource)
- DataSourceTransactionManagerAutoConfiguation (配置 DataSourceTransactionManager)
- JdbcTemplateAutoConfiguration (Configuración JdbcTemplate)
la información de configuración de conexión Mysql
spring.datasource.url=jdbc:mysql://localhost:3306/prod?useUnicode=true&characterEncoding=utf8&useSSL=false spring.datasource.username=root spring.datasource.password=root spring.datasource.driver-class-name=com.mysql.jdbc.Driver
pom archivo dependiente introdujo
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.39</version>
</dependency>Configuración de base de datos integrada h2
(1) Crear un nuevo proyecto SpringBoot
(2) En la creación de este proyecto SpringBoot cuando introdujo Hz y JDBC
el contenido del archivo pom.xml son los siguientes:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.5.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>spring-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jdbc</artifactId>
</dependency>
<!--h2内嵌数据库-->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
la información de configuración de conexión (3) h2 en el archivo de configuración
server.port=8007
management.endpoints.web.exposure.include=*
spring.output.ansi.enabled=ALWAYS
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.username=sa
spring.datasource.password=(4) a la base de datos predeterminada para agregar datos h2
(5) para iniciar el servicio de esta primavera
Imprimir los datos cuando la conexión es h2 base de datos.
V. Cómo configurar múltiples fuentes de datos
Notas sobre la configuración de fuentes de datos múltiples:
- 1. Las diferentes fuentes de datos a ser fijado por separado
- 2. atención cada vez que utilice una fuente de datos
- a. DataSource pluralidad de cómo debe determinarse el sistema de
- b. las instalaciones correspondientes (asuntos, ORM, etc.) cómo elegir DataSource
configuración de múltiples fuentes de datos tiene dos formas:
La primera, confía completamente en la configuración manual, dependencias relacionadas SpringBoot excluidos, esto es totalmente posible.
En segundo lugar, si quieres colaborar con SpringBoot (elegir uno).
Una forma de tipo @Primary Configuración de frijol
Segunda manera. Excluido configura automáticamente fuera de SpringBoot
(DataSourceAutoConfiguation DataSourceTransactionManagerAutoConfiguation JdbcTemplateAutoConfiguation)
Hoy en día, nos dice acerca de la utilización del segundo enfoque:
Paso (1):
Configurar la información de conexión en el archivo de configuración:
server.port=8007
management.endpoints.web.exposure.include=*
spring.output.ansi.enabled=ALWAYS
foo.datasource.url=jdbc:h2:mem:foo
foo.datasource.username=sa
foo.datasource.password=
bar.datasource.url=jdbc:h2:mem:bar
bar.datasource.username=sa
bar.datasource.password=Etapa (2):
package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration;
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class,
DataSourceTransactionManagerAutoConfiguration.class,
JdbcTemplateAutoConfiguration.class})
public class SpringDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringDemoApplication.class, args);
}
}
Paso (3):
package com.example.config;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.annotation.Resource;
import javax.sql.DataSource;
@Configuration
public class MultiDataSourceConfig {
private Logger log = LoggerFactory.getLogger(MultiDataSourceConfig.class);
/**
* Config Foo DataSource
* @return
*/
@Bean
@ConfigurationProperties("foo.datasource")
public DataSourceProperties fooDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
public DataSource fooDataSource() {
DataSourceProperties dataSourceProperties = fooDataSourceProperties();
log.info("foo datasource: {}", dataSourceProperties.getUrl());
return dataSourceProperties.initializeDataSourceBuilder().build();
}
@Bean
@Resource
public PlatformTransactionManager fooTxManager(DataSource fooDataSource) {
return new DataSourceTransactionManager(fooDataSource);
}
/**
* Config Bar DataSource
* @return
*/
@Bean
@ConfigurationProperties("bar.datasource")
public DataSourceProperties barDataSourceProperties() {
return new DataSourceProperties();
}
@Bean
public DataSource barDataSource() {
DataSourceProperties dataSourceProperties = barDataSourceProperties();
log.info("bar datasource: {}", dataSourceProperties.getUrl());
return dataSourceProperties.initializeDataSourceBuilder().build();
}
@Bean
@Resource
public PlatformTransactionManager barTxManager(DataSource barDataSource) {
return new DataSourceTransactionManager(barDataSource);
}
}En este artículo se llegó a la conclusión de que en primer lugar, en los pobres legibilidad del contenido del artículo demasiado, voy a salir en algunos de los artículos
