Notas de estudio de SpringBoot (1) - Nodo de alimentación de la estación B

001- JavaConfig

1.1 ¿Por qué usar springboot?

1.2 JavaConfig

JavaConfig: 使用java类作为xml配置文件的替代， 是配置spring容器的纯java的方式。 
在这个java类就可以创建java对象，把对象放入spring容器中（注入到容器）

使用两个注解：
1）@Configuration： 放在一个类的上面，表示这个类是作为配置文件使用的。
2）@Bean：声明对象，把对象注入到容器中。

---

创建一个空项目 再创建一个maven java 模块进行演示

---

使用原本的方法 xml配置文件

---

使用javaconfig

1.3 @ImportarRecurso

作用：导入其他的xml配置文件，等于在xml中的

<import resources="其他配置文件"/>

1.4 @RecursoPropiedad

@PropertyResource: 
	读取properties属性配置文件。
	使用属性配置文件可以实现外部化配置，在程序代码之外提供数据。

步骤：
	在resources目录下，创建properties文件， 使用k=v的格式提供数据
	在@PropertyResource 指定properties文件的位置
	使用@Value（value=“${key}”）

002- Primeros pasos con springboot

2.1 Introducción

SpringBoot是Spring中的一个成员，可以简化Spring，SpringMVC的使用。
他的核心还是IOC容器。

Características:

• Cree aplicaciones Spring independientes

  Crear una aplicación de primavera

• Incruste Tomcat, Jetty o Undertow directamente (no es necesario implementar archivos WAR)

  Tomcat incrustado, embarcadero, resaca

• Proporcione dependencias "iniciales" obstinadas para simplificar su configuración de compilación

  La dependencia de inicio se proporciona para simplificar la configuración de la aplicación.

  
  Por ejemplo, para usar el marco MyBatis, debe configurar el objeto MyBatis SqlSessionFactory y el objeto proxy Dao en el proyecto Spring .

  En el proyecto SpringBoot, agregue una dependencia mybatis-spring-boot-starter en pom.xml, y
  la configuración del objeto anterior se ha configurado y se puede usar directamente.

• Configure automáticamente Spring y bibliotecas de terceros siempre que sea posible

  Configure las bibliotecas Spring y de terceros tanto como sea posible.
  Se llama configuración automática (es decir, todos los objetos en Spring y las bibliotecas de terceros se crean y colocan en el contenedor, y los desarrolladores pueden usarlos directamente)

• Proporcione funciones listas para producción, como métricas, controles de estado y configuración externalizada

  Proporciona controles de salud, estadísticas, configuración externalizada

• Absolutamente sin generación de código y sin requisitos para la configuración XML

  No es necesario generar código, no hay configuración xml.

2.2 Crear un proyecto springboot

使用Spring提供的初始化器，就是向导，创建SpringBoot应用

默认使用的地址：Default：https://start.spring.io
国内地址：Custom：https://start.springboot.io

pom.xml文件：

<?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>

	<!--SpringBoot的父项目-->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.4.2</version>
		<relativePath/>
	</parent>

	<!--当前项目的gav-->
	<groupId>com.bjpowernode</groupId>
	<artifactId>002-springboot-first</artifactId>
	<version>1.0.0</version>


	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

---

---

2.3 Proyecto de inicio

使用springboot实现简单的控制层操作

和上面一样 使用maven创建一个模块 spring initializr
只选spring web 依赖

2.4 @SpringBootApplication

@SpringBootApplication：
	是一个复合注解，主要由以下三个组成
		@SpringBootConfiguration
		@EnableAutoConfiguration
		@ComponentScan

1.@SpringBootConfiguration

@Configuration
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用，
    可以使用@Bean声明对象，注入到容器，如下：

2.@EnableAutoConfiguration

启用自动配置，把java对象配置好，注入到spring容器中。
例如可以把mybatis的对象创建好，放入到容器中

3.@ComponentScan

@ComponentScan 扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。
默认扫描的包：有@ComponentScan注解的类所在的包和子包。

Por lo tanto, otro código debe estar al mismo nivel que el archivo de la aplicación o más pequeño que

2.5 archivos de configuración importantes de springboot

即application.properties
springboot的配置文件有两种格式 .properties 和.yml

配置文件名称：application

扩展名有：
	properties	(k=v)
	yml 		(k: v) (k:空格v)

使用application.properties，application.yml
.yml更轻量 主推这个

Ejemplo 1: puerto y contexto de configuración de application.properties

#设置端口号
server.port=8082

#设置访问应用上下文路径，contextpath
server.servlet.context-path=/myboot

Ejemplo 2: aplicación.yml

server:
  port: 8083
  servlet:
    context-path: /myboot2

2.6 Configuración multientorno

Hay un entorno de desarrollo, un entorno de prueba y un entorno en línea.

Cada entorno tiene información de configuración diferente, como puerto, archivos superior e inferior, URL de la base de datos, nombre de usuario, contraseña, etc.

Al usar archivos de configuración de múltiples entornos, puede cambiar fácilmente entre diferentes configuraciones.

Uso: crear múltiples archivos de configuración, regla de nombre: application-environment name.properties(yml)

Cree un archivo de configuración para el entorno de desarrollo: application-dev.properties( application-dev.yml )

Cree la configuración utilizada por el probador: application-test.properties

2.7 configuración personalizada springboot

(1) @Valor

SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以在自定义配置，
然后采用如下注解去读取配置的属性值
	@Value("${key}") ， key 来自 application.properties(yml)

(2) @ConfigurationProperties

将整个文件映射成一个对象，用于自定义配置项比较多的情况

Springboot 2.8 usa jsp

不推荐在spingboot使用jsp
springboot也不提供使用jsp 需要进行配置才能使用
在springboot中使用jsp逐渐会被淘汰

会使用模板来完成视图层的操作

Usar jsp requiere configuración:

1. Agregue una dependencia para manejar jsp. Responsable de compilar archivos jsp

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

2. Si necesita usar las funciones de servlet, jsp, jstl

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>jstl</artifactId>
</dependency>

<dependency>
	<groupId>javax.servlet</groupId>
	<artifactId>javax.servlet-api</artifactId>
</dependency>

<dependency>
<groupId>javax.servlet.jsp</groupId>
	<artifactId>javax.servlet.jsp-api</artifactId>
	<version>2.3.1</version>
</dependency>

3. Cree un directorio para almacenar jsp, generalmente llamado webapp

   índice.jsp

4. Es necesario especificar el directorio de almacenamiento del archivo jsp compilado en pom.xml.

   META-INF/recursos

5. Crear controlador, acceder a jsp

6. Configure la resolución de vista en el archivo application.propertis

---

具体操作见视频

2.9 Usar el contenedor ApplicationContext en springboot

如果你想通过代码，从容器中获取对象。
SpringApplication.run(Application.class, args)的返回值就是ApplicationContext容器。

2.10 Interfaz ComnandLineRunner Interfaz ApplcationRunner

开发中可能会有这样的情景。需要在容器启动后执行一些内容。
比如读取配置文件，数据库连接之类的。
SpringBoot 给我们提供了两个接口来帮助我们实现这种需求。
这两个接口分别为 CommandLineRunner 和 ApplicationRunner。
他们的执行时机为容器启动完成的时候。

这两个接口都有一个 run 方法，我们只需要实现这个方法即可。
这两个接口的不同之处在于： 
	ApplicationRunner 中 run 方法的参数为 ApplicationArguments
	而CommandLineRunner接口中 run 方法的参数为 String 数组

@FunctionalInterface
public interface CommandLineRunner {
    
    
    void run(String... args) throws Exception;
}

@FunctionalInterface
public interface ApplicationRunner {
    
    
    void run(ApplicationArguments args) throws Exception;
}