SpringBoot入门_spring boot commons-codec-程序员宅基地

一、SpringBoot简介

1、Spring的优缺点

Spring的优点

Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的EnterpriseJavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。

  1. 使用Spring的IOC容器,将对象之间的依赖关系交给Spring,降低组件之间的耦合性,让我们更专注于应用逻辑
  2. 可以提供众多服务,事务管理,WS等。
  3. AOP的很好支持,方便面向切面编程。
  4. 对主流的框架提供了很好的集成支持,如Hibernate,Struts2,JPA等
  5. Spring DI机制降低了业务对象替换的复杂性。
  6. Spring属于低侵入,代码污染极低。
  7. Spring的高度可开放性,并不强制依赖于Spring,开发者可以自由选择Spring部分或全部

Spring的缺点

虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。

一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。

所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。

除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。

  1. jsp中要写很多代码、控制器过于灵活,缺少一个公用控制器。
  2. Spring不支持分布式,这也是EJB仍然在用的原因之一。

2、SpringBoot的概述

（1）SpringBoot解决上述Spring的缺点

SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。

（2）SpringBoot的特点

  • 为基于Spring的开发提供更快的入门体验
  • 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
  • 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
  • SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

（3）SpringBoot的核心功能

  • 起步依赖
    起步依赖本质上是一个Maven项目对象模型（Project Object Model，POM），定义了对其他库的传递依
    赖，这些东西加在一起即支持某项功能。
    简单的说，起步依赖就是将具备某种功能的坐标打包到一起，并提供一些默认的功能。
  • 自动配置
    Spring Boot的自动配置是一个运行时（更准确地说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个。该过程是Spring自动完成的。

二、SpringBoot快速入门

1、体验

spring的官方文档为我们提供了quick、start

我们看看spring官网给我们提供了什么方式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dm55lpaQ-1593315002675)(D:\教学资料\总结文档\框架\springboot\img%5CUsers%5Czn%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1591088004783.png)]

mvn spring-boot:run 运行
在这里插入图片描述

测试，报错，说明成功了，因为没写controller
在这里插入图片描述

2、idea创建工程

1、普通maven工程创建
在这里插入图片描述
工程名spring-boot-test
在这里插入图片描述

2、添加依赖

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-parent</artifactId>
        <version>2.2.2.RELEASE</version>
    </parent>

    <artifactId>spring-boot-test</artifactId>

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

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

编写启动引导类

package com.xinzhi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author 迷迷糊糊
 * @date 2020/6/2
 */
@SpringBootApplication
public class Application {
    
    public static void main(String[] args) {
    
        SpringApplication.run(Application.class);
    }

}

写一个controller

/**
 * @author 迷迷糊糊
 * @date 2020/6/2
 */
@Controller
public class UserController {
    

    @RequestMapping("/")
    @ResponseBody
    public String test(){
    
        return "hello springboot";
    }

}

运行引导类的main方法
在这里插入图片描述
结果ok！

在这里插入图片描述

3、使用idea中的spring引导创建

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4、 SpringBoot工程热部署

我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间，我们可以在修改代码后不重启就能生效，在 pom.xml 中添加如下配置就可以实现这样的功能，我们称之为热部署。

<!--热部署配置-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
</dependency>

三、SpringBoot原理分析

3.1 起步依赖原理分析

3.1.1 分析spring-boot-starter-parent

按住Ctrl点击pom.xml中的spring-boot-starter-parent，跳转到了spring-boot-starter-parent的pom.xml，xml配置如下（只摘抄了部分重点配置）：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.3.0.RELEASE</version>
  </parent>

按住Ctrl点击pom.xml中的spring-boot-starter-dependencies，跳转到了spring-boot-starter-dependencies的pom.xml，xml配置如下（只摘抄了部分重点配置）：

<properties>
    <activemq.version>5.15.12</activemq.version>
    <commons-codec.version>1.14</commons-codec.version>
    <commons-dbcp2.version>2.7.0</commons-dbcp2.version>
    <commons-lang3.version>3.10</commons-lang3.version>
    <commons-pool.version>1.6</commons-pool.version>
    <commons-pool2.version>2.8.0</commons-pool2.version>
    <ehcache.version>2.10.6</ehcache.version>
    <ehcache3.version>3.8.1</ehcache3.version>
    <elasticsearch.version>7.6.2</elasticsearch.version>
    <freemarker.version>2.3.30</freemarker.version>
    <hibernate.version>5.4.15.Final</hibernate.version>
    <hibernate-validator.version>6.1.5.Final</hibernate-validator.version>
    <hikaricp.version>3.4.5</hikaricp.version>
    <jedis.version>3.3.0</jedis.version>
    <junit.version>4.13</junit.version>
    <junit-jupiter.version>5.6.2</junit-jupiter.version>
    <kafka.version>2.5.0</kafka.version>
    <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
    <maven-dependency-plugin.version>3.1.2</maven-dependency-plugin.version>
    <mysql.version>8.0.20</mysql.version>
    <neo4j-ogm.version>3.2.11</neo4j-ogm.version>
    <netty.version>4.1.49.Final</netty.version>
    <netty-tcnative.version>2.0.30.Final</netty-tcnative.version>
    <quartz.version>2.3.2</quartz.version>
    <servlet-api.version>4.0.1</servlet-api.version>
    <slf4j.version>1.7.30</slf4j.version>
    <snakeyaml.version>1.26</snakeyaml.version>
    <solr.version>8.5.1</solr.version>
    ...
</properties>
<dependencyManagement>
...
</dependencyManagement>

从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。

3.1.2 分析spring-boot-starter-web

按住Ctrl点击pom.xml中的spring-boot-starter-web，跳转到了spring-boot-starter-web的pom.xml，xml配置如下（只摘抄了部分重点配置）：

<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <!-- This module was also published with a richer model, Gradle metadata,  -->
  <!-- which should be used instead. Do not delete the following line which  -->
  <!-- is to indicate to Gradle or any Gradle module metadata file consumer  -->
  <!-- that they should prefer consuming it instead. -->
  <!-- do_not_remove: published-with-gradle-metadata -->
  <modelVersion>4.0.0</modelVersion>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.3.0.RELEASE</version>
  <name>spring-boot-starter-web</name>
  <description>Starter for building web, including RESTful, applications using Spring MVC. Uses Tomcat as the default embedded container</description>
  <url>https://spring.io/projects/spring-boot</url>
  <organization>
    <name>Pivotal Software, Inc.</name>
    <url>https://spring.io</url>
  </organization>
  <licenses>
    <license>
      <name>Apache License, Version 2.0</name>
      <url>http://www.apache.org/licenses/LICENSE-2.0</url>
    </license>
  </licenses>
  <developers>
    <developer>
      <name>Pivotal</name>
      <email>[email protected]</email>
      <organization>Pivotal Software, Inc.</organization>
      <organizationUrl>https://www.spring.io</organizationUrl>
    </developer>
  </developers>
  <scm>
    <connection>scm:git:git://github.com/spring-projects/spring-boot.git</connection>
    <developerConnection>scm:git:ssh://[email protected]/spring-projects/spring-boot.git</developerConnection>
    <url>https://github.com/spring-projects/spring-boot</url>
  </scm>
  <issueManagement>
    <system>GitHub</system>
    <url>https://github.com/spring-projects/spring-boot/issues</url>
  </issueManagement>
  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-dependencies</artifactId>
        <version>2.3.0.RELEASE</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.3.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.3.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.3.0.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

从上面的spring-boot-starter-web的pom.xml中我们可以发现，spring-boot-starter-web就是将web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”，这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的作用。

3.2 自动配置原理解析

@SpringBootApplication
public class HelloSpringBootStarterApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloSpringBootStarterApplication.class, args);
    }

}

按住Ctrl点击查看启动类MySpringBootApplication上的注解@SpringBootApplication

@SpringBootApplication
public class HelloSpringBootStarterApplication {
    
    public static void main(String[] args) {
    
        SpringApplication.run(HelloSpringBootStarterApplication.class, args);
    }

}

注解@SpringBootApplication的源码

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = {
     @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

其中，

@SpringBootConfiguration：等同与@Configuration，既标注该类是Spring的一个配置类

@EnableAutoConfiguration：SpringBoot自动配置功能开启

按住Ctrl点击查看注解@EnableAutoConfiguration

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {

其中，@Import(AutoConfigurationImportSelector.class) 导入了AutoConfigurationImportSelector类

按住Ctrl点击查看AutoConfigurationImportSelector源码

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    
    if (!isEnabled(annotationMetadata)) {
    
        return NO_IMPORTS;
    }
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    
    if (!isEnabled(annotationMetadata)) {
    
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    configurations = removeDuplicates(configurations);
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
    configurations = getConfigurationClassFilter().filter(configurations);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    
		List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
				getBeanClassLoader());
		Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
				+ "are using a custom packaging, make sure that file is correct.");
		return configurations;
	}

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    
		String factoryTypeName = factoryType.getName();
		return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
	}


/**
	 * The location to look for factories.
	 * <p>Can be present in multiple JAR files.
	 */
	public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
    
		MultiValueMap<String, String> result = cache.get(classLoader);
		if (result != null) {
    
			return result;
		}

		try {
    
			Enumeration<URL> urls = (classLoader != null ?
					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
			result = new LinkedMultiValueMap<>();
			while (urls.hasMoreElements()) {
    
				URL url = urls.nextElement();
				UrlResource resource = new UrlResource(url);
				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
				for (Map.Entry<?, ?> entry : properties.entrySet()) {
    
					String factoryTypeName = ((String) entry.getKey()).trim();
					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
    
						result.add(factoryTypeName, factoryImplementationName.trim());
					}
				}
			}
			cache.put(classLoader, result);
			return result;
		}
		catch (IOException ex) {
    
			throw new IllegalArgumentException("Unable to load factories from location [" +
					FACTORIES_RESOURCE_LOCATION + "]", ex);
		}
	}

其中，SpringFactoriesLoader.loadFactoryNames 方法的作用就是从META-INF/spring.factories文件中读取指定类对应的类名称列表
在这里插入图片描述
spring.factories 文件中有关自动配置的配置信息如下：

... ... ...

org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\

... ... ...

上面配置文件存在大量的以Configuration为结尾的类名称，这些类就是存有自动配置信息的类，而SpringApplication在获取这些类名后再加载

我们以ServletWebServerFactoryAutoConfiguration为例来分析源码：

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({
     ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
		ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
		ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
		ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    
	... ... ...
}

其中，

@EnableConfigurationProperties(ServerProperties.class) 代表加载ServerProperties服务器配置属性类

进入ServerProperties.class源码如下：

@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties {
    

	/**
	 * Server HTTP port.
	 */
	private Integer port;

	/**
	 * Network address to which the server should bind.
	 */
	private InetAddress address;
  
  	... ... ...
  
}

其中，prefix = “server” 表示SpringBoot配置文件中的前缀，SpringBoot会将配置文件中以server开始的属性映射到该类的字段中。映射关系如下：
在这里插入图片描述

四、SpringBoot的配置文件

4.1 SpringBoot配置文件类型

4.1.1 SpringBoot配置文件类型和作用

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。

SpringBoot默认会从Resources目录下加载application.properties或application.yml（application.yaml）文件

其中，application.properties文件是键值对类型的文件，之前一直在使用，所以此处不在对properties文件的格式进行阐述。除了properties文件外，SpringBoot还可以使用yml文件进行配置，下面对yml文件进行讲解。

4.1.2 application.yml配置文件

4.1.2.1 yml配置文件简介

YML文件格式是YAML (YAML Aint Markup Language)编写的文件格式，YAML是一种直观的能够被电脑识别的的数据数据序列化格式，并且容易被人类阅读，容易和脚本语言交互的，可以被支持YAML库的不同的编程语言程序导入，比如： C/C++, Ruby, Python, Java, Perl, C#, PHP等。YML文件是以数据为核心的，比传统的xml方式更加简洁。

YML文件的扩展名可以使用.yml或者.yaml。

4.1.2.2 yml配置文件的语法
4.1.2.2.1 配置普通数据

  • 语法： key: value

  • 示例代码：

  • name: haohao

  • 注意：value之前有一个空格

4.1.2.2.2 配置对象数据

  • 语法：

    ​ key:

    ​ key1: value1

    ​ key2: value2

    ​ 或者：

    ​ key: {key1: value1,key2: value2}

  • 示例代码：

  • person:
  name: haohao
  age: 31
  addr: beijing

#或者

person: {
      name: haohao,age: 31,addr: beijing}

  • 注意：key1前面的空格个数不限定，在yml语法中，相同缩进代表同一个级别

4.1.2.2.2 配置Map数据

同上面的对象写法

4.1.2.2.3 配置数组（List、Set）数据

  • 语法：

    ​ key:

    ​ - value1

    ​ - value2

    或者：

    ​ key: [value1,value2]

  • 示例代码：

  • city:
  - beijing
  - tianjin
  - shanghai
  - chongqing
  
#或者

city: [beijing,tianjin,shanghai,chongqing]

#集合中的元素是对象形式
student:
  - name: zhangsan
    age: 18
    score: 100
  - name: lisi
    age: 28
    score: 88
  - name: wangwu
    age: 38
    score: 90

  • 注意：value1与之间的 - 之间存在一个空格

4.1.3 SpringBoot常用配置

# QUARTZ SCHEDULER (QuartzProperties)
spring.quartz.jdbc.initialize-schema=embedded # Database schema initialization mode.
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql # Path to the SQL file to use to initialize the database schema.
spring.quartz.job-store-type=memory # Quartz job store type.
spring.quartz.properties.*= # Additional Quartz Scheduler properties.

# ----------------------------------------
# WEB PROPERTIES
# ----------------------------------------

# EMBEDDED SERVER CONFIGURATION (ServerProperties)
server.port=8080 # Server HTTP port.
server.servlet.context-path= # Context path of the application.
server.servlet.path=/ # Path of the main dispatcher servlet.

# HTTP encoding (HttpEncodingProperties)
spring.http.encoding.charset=UTF-8 # Charset of HTTP requests and responses. Added to the "Content-Type" header if not set explicitly.

# JACKSON (JacksonProperties)
spring.jackson.date-format= # Date format string or a fully-qualified date format class name. For instance, `yyyy-MM-dd HH:mm:ss`.

# SPRING MVC (WebMvcProperties)
spring.mvc.servlet.load-on-startup=-1 # Load on startup priority of the dispatcher servlet.
spring.mvc.static-path-pattern=/** # Path pattern used for static resources.
spring.mvc.view.prefix= # Spring MVC view prefix.
spring.mvc.view.suffix= # Spring MVC view suffix.

# DATASOURCE (DataSourceAutoConfiguration & DataSourceProperties)
spring.datasource.driver-class-name= # Fully qualified name of the JDBC driver. Auto-detected based on the URL by default.
spring.datasource.password= # Login password of the database.
spring.datasource.url= # JDBC URL of the database.
spring.datasource.username= # Login username of the database.

# JEST (Elasticsearch HTTP client) (JestProperties)
spring.elasticsearch.jest.password= # Login password.
spring.elasticsearch.jest.proxy.host= # Proxy host the HTTP client should use.
spring.elasticsearch.jest.proxy.port= # Proxy port the HTTP client should use.
spring.elasticsearch.jest.read-timeout=3s # Read timeout.
spring.elasticsearch.jest.username= # Login username.

我们可以通过配置application.poperties 或者 application.yml 来修改SpringBoot的默认配置

例如：

application.properties文件

server.port=8888
server.servlet.context-path=demo

application.yml文件

server:
  port: 8888
  servlet:
    context-path: /demo

4.2 配置文件与配置类的属性映射方式

4.2.1 使用注解@Value映射

我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上

例如：

application.properties配置如下：

person:
  name: zhangsan
  age: 18

或者，application.yml配置如下：

person:
  name: zhangsan
  age: 18

实体Bean代码如下：

@Controller
public class QuickStartController {
    

    @Value("${person.name}")
    private String name;
    @Value("${person.age}")
    private Integer age;


    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
    
        return "springboot 访问成功! name="+name+",age="+age;
    }

}

浏览器访问地址：http://localhost:8080/quick 结果如下：

在这里插入图片描述

4.2.2 使用注解@ConfigurationProperties映射

通过注解@ConfigurationProperties(prefix=“配置文件中的key的前缀”)可以将配置文件中的配置自动与实体进行映射

application.properties配置如下：

person:
  name: zhangsan
  age: 18

或者，application.yml配置如下：

person:
  name: zhangsan
  age: 18

实体Bean代码如下：

@Controller
@ConfigurationProperties(prefix = "person")
public class QuickStartController {
    

    private String name;
    private Integer age;

    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
    
        return "springboot 访问成功! name="+name+",age="+age;
    }

    public void setName(String name) {
    
        this.name = name;
    }

    public void setAge(Integer age) {
    
        this.age = age;
    }
}

浏览器访问地址：http://localhost:8080/quick 结果如下：

在这里插入图片描述

注意：使用@ConfigurationProperties方式可以进行配置文件与实体字段的自动映射，但需要字段必须提供set方法才可以，而使用@Value注解修饰的字段不需要提供set方法

五、web配置

1、定制banner

创建Banner文件
src/main/resource/banner.txt

${
    AnsiColor.BRIGHT_YELLOW}

//                          _ooOoo_                               //
//                         o8888888o                              //
//                         88" . "88                              //
//                         (| ^_^ |)                              //
//                         O\  =  /O                              //
//                      ____/`---'\____                           //
//                    .'  \\|     |//  `.                         //
//                   /  \\|||  :  |||//  \                        //
//                  /  _||||| -:- |||||-  \                       //
//                  |   | \\\  -  /// |   |                       //
//                  | \_|  ''\---/''  |   |                       //
//                  \  .-\__  `-`  ___/-. /                       //
//                ___`. .'  /--.--\  `. . ___                     //
//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
//      ========`-.____`-.___\_____/___.-`____.-'========         //
//                           `=---='                              //
//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
//            佛祖保佑       永不宕机     永无BUG                  //

${
    AnsiColor.BRIGHT_RED}
Application Version: ${
    application.version}${
    application.formatted-version}
Spring Boot Version: ${
    spring-boot.version}${
    spring-boot.formatted-version}

从上面的内容中可以看到，还使用了一些属性设置：

  • ${AnsiColor.BRIGHT_RED}：设置控制台中输出内容的颜色，可以自定义，具体参考org.springframework.boot.ansi.AnsiColor
  • ${application.version}：用来获取MANIFEST.MF文件中的版本号，这就是为什么要在Application.java中指定 SpringVersion.class
  • {application.formatted-version}：格式化后的{application.version}版本信息
  • ${spring-boot.version}：Spring Boot的版本号
  • {spring-boot.formatted-version}：格式化后的{spring-boot.version}版本信息

2、自定义欢迎页

默认回去static中中找index.html

classpath:/static/index.html 
classpath:/public/index.html

3、自定义favicon

浏览器左上角的图标可以放在静态资源下static中，

<随便找个网站http://www.bitbug.net/生成了放进去就行了>

4、其他的服务器配置如jetty

在某个博客看到改Jetty的好处，也真是我现在开发的项目后面要用长连接

好处：

1、Jetty适合长连接应用，就是聊天类的长连接

2、Jetty更轻量级。这是相对Tomcat而言的。

3、jetty更灵活，体现在其可插拔性和可扩展性，更易于开发者对Jetty本身进行二次开发，定制一个适合自身需求的Web Server。

4、使用Jetty，需要在spring-boot-starter-web排除spring-boot-starter-tomcat，因为SpringBoot默认使用tomcat

对于配置内置服务器的springBoot，都必定会配置

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

以上配置springBoot的启动web服务器，但默认是Tomcat

所以呢，要配置为jetty要去掉默认tomcat配置

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>  
        <exclusion>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-tomcat</artifactId>  
        </exclusion>  
    </exclusions> 
</dependency>

并且加上jetty启动

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

5、资源定义

默认，就用默认

classpath:/META-INF/resources/ 
classpath:/resources/
classpath:/static/ 
classpath:/public/

第一种：在配置文件中进行配置

#静态资源访问路径
spring.mvc.static-path-pattern=/**
#静态资源映射路径
spring.resources.static-locations=classpath:/

第二种：通过编程进行设置

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
    
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
    
　　　　　// 这里之所以多了一"/",是为了解决打war时访问不到问题
        registry.addResourceHandler("/**").addResourceLocations("/","classpath:/");
    }
}

6、json数据转换

默认jackson

切换

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.35</version>
</dependency>

加入消息转换器的配置

@Configuration
public class FJsonConfig {
    
    
    @Bean
    public HttpMessageConverter configureMessageConverters() {
    
        FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(
                // 保留map空的字段
                SerializerFeature.WriteMapNullValue,
                // 将String类型的null转成""
                SerializerFeature.WriteNullStringAsEmpty,
                // 将Number类型的null转成0
                SerializerFeature.WriteNullNumberAsZero,
                // 将List类型的null转成[]
                SerializerFeature.WriteNullListAsEmpty,
                // 将Boolean类型的null转成false
                SerializerFeature.WriteNullBooleanAsFalse,
                // 避免循环引用
                SerializerFeature.DisableCircularReferenceDetect
        );

        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        List<MediaType> mediaTypeList = new ArrayList<>();
        // 解决中文乱码问题，相当于在Controller上的@RequestMapping中加了个属性produces = "application/json"
        mediaTypeList.add(MediaType.APPLICATION_JSON);
        converter.setSupportedMediaTypes(mediaTypeList);
      return converter;
    }
}

7、配置错误页

在static目录下新建error目录

放入对应的错误页面就行了如404.html 500.html

9、拦截器、过滤器、监听器

首先我们实现拦截器类：

@Service
public class UserTokenInterceptor implements HandlerInterceptor {
    
	@Autowired
	private SysusertokenMapper sysusertokenMapper;
	@Autowired
	private SysloginuserMapper sysloginuserMapper;
	@Autowired
	private SysuserMapper sysuserMapper;
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
    
		//处理内容
		return isAccess;
	}
 
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
    
 
	}
 
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
    
 
	}
}

这里我们需要实现HandlerInterceptor这个接口，这个接口包括三个方法，preHandle是请求执行前执行的，postHandler是请求结束执行的，但只有preHandle方法返回true的时候才会执行，afterCompletion是视图渲染完成后才执行，同样需要preHandle返回true，该方法通常用于清理资源等工作。除了实现上面的接口外，我们还需对其进行配置：


package com.gcexe.monitor.filter;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;
 
@Component
public class UserTokenAppConfigurer extends WebMvcConfigurationSupport{
    
	
	@Autowired
	private UserTokenInterceptor userTokenInterceptor;
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
    
		// 多个拦截器组成一个拦截器链
        // addPathPatterns 用于添加拦截规则
        // excludePathPatterns 用户排除拦截
		registry.addInterceptor(userTokenInterceptor).addPathPatterns("/**")
		.excludePathPatterns("/account/login","/account/register");		
		super.addInterceptors(registry);
	}
}

这里我们继承了WebMVCConfigurerAdapter，看过前面的文章的朋友应该已经见过这个类了，在进行静态资源目录配置的时候我们用到过这个类。这里我们重写了addInterceptors这个方法，进行拦截器的配置，主要配置项就两个，一个是指定拦截器，第二个是指定拦截的URL。

过滤器、监听器自行学习

10、WebMvcConfigurer总结

WebMvcConfigurer配置类其实是Spring内部的一种配置方式，采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制，可以自定义一些Handler，Interceptor，ViewResolver，MessageConverter。基于java-based方式的spring mvc配置，需要创建一个配置类并实现WebMvcConfigurer 接口；

在Spring Boot 1.5版本都是靠重写WebMvcConfigurerAdapter的方法来添加自定义拦截器，消息转换器等。SpringBoot 2.0 后，该类被标记为@Deprecated（弃用）。官方推荐直接实现WebMvcConfigurer或者直接继承WebMvcConfigurationSupport，方式一实现WebMvcConfigurer接口（推荐），方式二继承WebMvcConfigurationSupport类。

WebMvcConfigurer接口

常用的方法：

 /* 拦截器配置 */
void addInterceptors(InterceptorRegistry var1);

/* 视图跳转控制器 */
void addViewControllers(ViewControllerRegistry registry);

/**
*静态资源处
**/
void addResourceHandlers(ResourceHandlerRegistry registry);

/* 默认静态资源处理器 */
void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer);

/**
* 这里配置视图解析器
 **/
void configureViewResolvers(ViewResolverRegistry registry);

/* 配置内容裁决的一些选项*/
void configureContentNegotiation(ContentNegotiationConfigurer configurer);

/** 解决跨域问题 **/
public void addCorsMappings(CorsRegistry registry) ;

addInterceptors：拦截器

  • addInterceptor：需要一个实现HandlerInterceptor接口的拦截器实例

  • addPathPatterns：用于设置拦截器的过滤路径规则；addPathPatterns("/**")对所有请求都拦截

  • excludePathPatterns：用于设置不需要拦截的过滤规则

默认静态资源处理器

@Override
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
    
        configurer.enable();
        configurer.enable("defaultServletName");
}

此时会注册一个默认的Handler：DefaultServletHttpRequestHandler，这个Handler也是用来处理静态文件的，它会尝试映射/。当DispatcherServelt映射/时（/ 和/ 是有区别的），并且没有找到合适的Handler来处理请求时，就会交给DefaultServletHttpRequestHandler 来处理。注意：这里的静态资源是放置在web根目录下，而非WEB-INF 下。
　　可能这里的描述有点不好懂（我自己也这么觉得），所以简单举个例子，例如：在webroot目录下有一个图片：1.png 我们知道Servelt规范中web根目录（webroot）下的文件可以直接访问的，但是由于DispatcherServlet配置了映射路径是：/ ，它几乎把所有的请求都拦截了，从而导致1.png 访问不到，这时注册一个DefaultServletHttpRequestHandler 就可以解决这个问题。其实可以理解为DispatcherServlet破坏了Servlet的一个特性（根目录下的文件可以直接访问），DefaultServletHttpRequestHandler是帮助回归这个特性的。

configureViewResolvers：视图解析器

这个方法是用来配置视图解析器的，该方法的参数ViewResolverRegistry 是一个注册器，用来注册你想自定义的视图解析器等。ViewResolverRegistry 常用的几个方法：https://blog.csdn.net/fmwind/article/details/81235401

/**
 * 配置请求视图映射
 * @return
 */
@Bean
public InternalResourceViewResolver resourceViewResolver(){
    

	InternalResourceViewResolver internalResourceViewResolver = new InternalResourceViewResolver();
	//请求视图文件的前缀地址
	internalResourceViewResolver.setPrefix("/WEB-INF/jsp/");
	//请求视图文件的后缀
	internalResourceViewResolver.setSuffix(".jsp");
	return internalResourceViewResolver;
}

addCorsMappings：跨域

@Override
public void addCorsMappings(CorsRegistry registry) {
    

    super.addCorsMappings(registry);
    registry.addMapping("/cors/**")
            .allowedHeaders("*")
            .allowedMethods("POST","GET")
            .allowedOrigins("*");
}

configureMessageConverters：信息转换器

/**
* 消息内容转换配置
* @param converters
*/



@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
    

    //调用父类的配置
    super.configureMessageConverters(converters);
    FastJsonHttpMessageConverter converter = new FastJsonHttpMessageConverter();
    FastJsonConfig config = new FastJsonConfig();
    config.setSerializerFeatures(
        // 保留map空的字段
        SerializerFeature.WriteMapNullValue,
        // 将String类型的null转成""
        SerializerFeature.WriteNullStringAsEmpty,
        // 将Number类型的null转成0
        SerializerFeature.WriteNullNumberAsZero,
        // 将List类型的null转成[]
        SerializerFeature.WriteNullListAsEmpty,
        // 将Boolean类型的null转成false
        SerializerFeature.WriteNullBooleanAsFalse,
        // 避免循环引用
        SerializerFeature.DisableCircularReferenceDetect
    );

    converter.setFastJsonConfig(config);
    converter.setDefaultCharset(Charset.forName("UTF-8"));
    List<MediaType> mediaTypeList = new ArrayList<>();
    // 解决中文乱码问题，相当于在Controller上的@RequestMapping中加了个属性produces = "application/json"
    mediaTypeList.add(MediaType.APPLICATION_JSON);
    converter.setSupportedMediaTypes(mediaTypeList);

    //将fastjson添加到视图消息转换器列表内
    converters.add(converter);

}

11、数据校验

和springmvc一样

12、https配置

使用jdk自带的 keytools 创建证书

打开cmd窗口,输入如下命令

keytool -genkey -alias tomcat -keyalg RSA -keystore ./server.keystore

按照提示进行操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SsYNcSVd-1593316052914)(D:\教学资料\总结文档\框架\springboot\img%5CUsers%5Czn%5CAppData%5CRoaming%5CTypora%5Ctypora-user-images%5C1591453279751.png)]

创建完成后,可在用户根目录查看生成的keystore文件

将上一步生成的keystone文件复制到项目的根目录,在application.properties添加如下配置

server.port=443
server.ssl.key-store=server.keystore
server.ssl.key-alias=tomcat
server.ssl.enabled=true
server.ssl.key-store-password=123456
server.ssl.key-store-type=JKS

这里将服务器端口号设置成443端口,即https的默认访问端口,那么在进行https访问的时候可以不带端口号直接访wen

在这里插入图片描述

在这里插入图片描述

因为我们的证书不是专业机构提供的，而是自己搞的，所以会显示不安全

springboot不能提供http和https两种请求同事存在，所有需要配几个bean实现

http访问自动转https访问

向spring容器中注入两个Bean,代码如下

    @Bean
    public Connector connector(){
    
        Connector connector=new Connector("org.apache.coyote.http11.Http11NioProtocol");
        connector.setScheme("http");
        connector.setPort(80);
        connector.setSecure(false);
        connector.setRedirectPort(443);
        return connector;
    }

    @Bean
    public TomcatServletWebServerFactory tomcatServletWebServerFactory(Connector connector){
    
        TomcatServletWebServerFactory tomcat=new TomcatServletWebServerFactory(){
    
            @Override
            protected void postProcessContext(Context context) {
    
                SecurityConstraint securityConstraint=new SecurityConstraint();
                securityConstraint.setUserConstraint("CONFIDENTIAL");
                SecurityCollection collection=new SecurityCollection();
                collection.addPattern("/*");
                securityConstraint.addCollection(collection);
                context.addConstraint(securityConstraint);
            }
        };
        tomcat.addAdditionalTomcatConnectors(connector);
        return tomcat;
    }

其次在这里设置http的监听端口为80端口,http默认端口,这样在访问的时候也可以不用带上端口号.
完成以上配置后,我们访问 http://localhost 即可自动跳转为 https://localhost

13、打包

jar包

在这里插入图片描述

搞定

在这里插入图片描述

war包

标志打包为war

<packaging>war</packaging>


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </exclusion>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <!--打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。
                相当于compile，但是打包阶段做了exclude操作-->
    <scope>provided</scope>
</dependency>

/**
 * @author 迷迷糊糊
 * @date 2020/6/7
 */
@Component
public class ServletInitializer extends SpringBootServletInitializer {
    
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
    
        return builder.sources(MySpringBootApplication.class);
    }
}

在这里插入图片描述

14、启动系统任务

有两个接口CommandLineRunner和ApplicationRunner，实现了这两项接口的类会在系统启动后自动调用执行run方法

/**
 * @author 迷迷糊糊
 * @date 2020/6/7
 */
@Component
@Order(1)
public class CommandRunnerOne implements CommandLineRunner {
    
    //args是获取的main方法传入的参数
    @Override
    public void run(String... args) throws Exception {
    
        //这里可以做一些事情比如redis预热，系统检查等工作
        System.out.println("commandOne---->" + Arrays.toString(args));
    }
}


@Component
@Order(2)
public class CommandRunnerTwo implements CommandLineRunner {
    
    //args是获取的main方法传入的参数
    @Override
    public void run(String... args) throws Exception {
    
        //这里可以做一些事情比如redis预热，系统检查等工作
        System.out.println("commandTwo---->" + Arrays.toString(args));
    }
}

测试

在这里插入图片描述

另一个和这个接口用法一样，知识参数不同，有兴趣的同学可以研究一下。

15、配置文件的读取顺序

Application属性文件，按优先级排序，位置高的将覆盖位置

  1. 当前项目目录下的一个/config子目录

  2. 当前项目目录

  3. 项目的resources即一个classpath下的/config包

  4. 项目的resources即classpath根路径（root）

    如图：

img

16、读取顺序

如果在不同的目录中存在多个配置文件，它的读取顺序是：
1、config/application.properties（项目根目录中config目录下）
2、config/application.yml
3、application.properties（项目根目录下）
4、application.yml
5、resources/config/application.properties（项目resources目录中config目录下）
6、resources/config/application.yml
7、resources/application.properties（项目的resources目录下）
8、resources/application.yml

有啥好处，打包后我们可以再jar包之外放置配置文件，随时修改

六、自定义starter

自定义starter实例

我们需要先创建两个工程 hello-spring-boot-starter 和 hello-spring-boot-starter-autoconfigurer

1. hello-spring-boot-starter

1.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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xinzhi</groupId>
    <artifactId>hello-spring-boot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>hello-spring-boot-starter</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-autoconfigure</artifactId>
        </dependency>
    </dependencies>

</project>

同时删除 启动类、resources下的文件，test文件。

2. HelloProperties
/**
 * @author 迷迷糊糊
 * @date 2020/6/5
 */
@ConfigurationProperties(prefix = "xinzhi.user")
public class UserProperties {
    
   private String username = "张三";
   private String password = "123";

    public String getUsername() {
    
        return username;
    }

    public void setUsername(String username) {
    
        this.username = username;
    }

    public String getPassword() {
    
        return password;
    }

    public void setPassword(String password) {
    
        this.password = password;
    }
}
3. HelloService
/**
 * @author 迷迷糊糊
 * @date 2020/6/5
 */
@Component
public class User {
    

    @Resource
    private UserProperties userProperties;

    public void say(){
    
        System.out.println(userProperties.getUsername()+"的密码是："+userProperties.getPassword());

    }
}
4. UserAutoConfiguration
/**
 * @author 迷迷糊糊
 * @date 2020/6/5
 */
@Configuration
@ConditionalOnClass(User.class)
@ConditionalOnProperty(prefix = "xinzhi.user",value = "enable",matchIfMissing = true)
@EnableConfigurationProperties(UserProperties.class)
public class UserAutoConfiguration {
    

    @Bean
    @ConditionalOnMissingBean
    public User greeter() {
    
        return new User();
    }
}
5. spring.factories

在 resources 下创建文件夹 META-INF 并在 META-INF 下创建文件 spring.factories ，内容如下：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
  com.xinzhi.config.UserAutoConfiguration

到这儿，我们的配置自定义的starter就写完了

执行：mvn install安装带本地仓库

三、测试自定义starter

我们创建个项目 hello-spring-boot-starter-test，来测试系我们写的stater。

1. 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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.0.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spring-boot-initializr</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-boot-initializr</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-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.xinzhi</groupId>
            <artifactId>hello-spring-boot-starter</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
    </dependencies>

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

</project>

2. HelloController

@Controller
public class UserController {
    

    @Resource
    private User user;

    @GetMapping("/user")
    @ResponseBody
    public void getUser(){
    
        user.say();
    }
}

在这里插入图片描述

3. 修改application.properties

xinzhi.user.username=李四
xinzhi.user.password=abc

在这里插入图片描述
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43532998/article/details/106996008

智能推荐

tomcat启动占了12g_tomcat服务为何报内存相关错误？？-程序员宅基地

文章浏览阅读86次。本帖最后由 linux_love 于 2014-9-19 11:46 编辑多谢各位英雄支持，这个问题困扰我N久了，昨天终于让我给拿下了，在Linux下有个CommitLimit 用于限制系统应用使用的内存资源，#grep -i commit /proc/meminfoCommitLimit: 20389524 kBCommitted_AS: 18541832 kB其中：CommitLim..._commited_as 被谁占了

计算机基础知识判断题答案,计算机基础知识试题及答案判断题模板.docx-程序员宅基地

文章浏览阅读1.5k次。优质文档PAGE 页码页码/NUMPAGES 总页数总页数计算机基础知识试题及答案判断题(一)1、　冯?诺依曼原理是计算机的唯一工作原理。.( × )2、　计算机能直接识别汇编语言程序。.( × )3、　计算机能直接执行高级语言源程序。.( × )4、　计算机掉电后，ROM中的信息会丢失。( × )5、　计算机掉电后，外存中的信息会丢失。( √ )6、　应用软件的作用是扩大计算机的存储容量。( ×..._计算机判断题及答案

最新全流程GMS地下水数值模拟及溶质（包含反应性溶质）运移模拟技术深度应用-程序员宅基地

文章浏览阅读704次，点赞30次，收藏18次。最新全流程GMS地下水数值模拟及溶质（包含反应性溶质）运移模拟技术深度应用_gms地下水数值模拟

Android 自定义横向进度条_android自定义横向进度条-程序员宅基地

文章浏览阅读2.4k次。private int max; private double progress; private int bgColor; private int progressColor; private int padding; private boolean openGradient; private int gradientFrom; private int gradientTo; private boolean showSecondProgres_android自定义横向进度条

宝塔打开后，内容渲染失败（405）【了解一下】_宝塔部署后405 not allowed-程序员宅基地

文章浏览阅读111次。如果你是以上这种情况，打开以后发现，数据渲染不上，很可能是因为你的配置反向代理的顺序搞错了，造成的结果就是反向代理没有替换成功！还是那些内容，只是改变了操作步骤；数据就能加载出来了！_宝塔部署后405 not allowed

联想计算机管理员权限设置,Windows XP系统如何新建administrator管理员权限账户-程序员宅基地

文章浏览阅读1.6k次。知识点分析:对于Windows XP系统，有很多种创建用户账户的操作方法。其中包括：使用CMD命令行的net命令进行，也可以使用控制面板的图形界面进行，还可以使用计算机管理控制台中的“本地用户和组”进行。其中后者自定义功能多，本文以此为例进行操作示范。操作步骤:1. 在系统桌面找到并使用鼠标右键点击“我的电脑”图标，然后在弹出菜单中选择“管理(G)”，如下图所示：2. 在弹出的计算机管理窗口，展开..._xp 开启管理员账户

随便推点

WebGL快速入门_webgl入门-程序员宅基地

文章浏览阅读2.3k次，点赞2次，收藏11次。WebGL是一种用于在Web浏览器中实现高性能3D图形的技术。本文将帮助读者快速入门WebGL，了解其基本概念和使用方法。我们将介绍WebGL的基本架构和API，包括如何创建WebGL上下文、渲染对象和着色器编程等。此外，我们还会深入探讨WebGL的基本原理和渲染管线，以及如何通过优化渲染流程来提升性能。通过学习本文，读者将能够理解WebGL的核心概念和使用方法，并能够开始开发高性能的3D应用程序。_webgl入门

C++中的String的常用函数用法总结_string函数-程序员宅基地

文章浏览阅读10w+次，点赞1.3k次，收藏6.1k次。一. string的构造函数的形式： string str：生成空字符串string s(str)：生成字符串为str的复制品string s(str, strbegin,strlen)：将字符串str中从下标strbegin开始、长度为strlen的部分作为字符串初值string s(cstr, char_len)：以C_string类型cstr的前char_len个字..._string函数

金融风控训练营金融风控基础知识学习笔记_风控师学习笔记-程序员宅基地

文章浏览阅读162次。一、赛题理解和学习目标：本次挑战赛以个人信贷为背景，要求选手对金融风控之贷款是否违约进行预测，以此判断是否通过此项贷款的一项问题型比赛。通过学习Task1了解第一个学习内容，要求对金融风控的问题建立数学模型最后给定金融风险程度。在此过程中要了解混淆矩阵、AUC评价指标，KS统计量等二、学习内容：混淆矩阵就是一个2×2的矩阵分为真正类TP、真分类TN、假正类FT、假反类FNFP FN TP TN AUC被定义在ROC曲线下与坐标轴围成的面积（ROC曲线:以真阳性率._风控师学习笔记

哈希表 添加 增添 删除 获取方法 Js封装_js hash追加-程序员宅基地

文章浏览阅读237次。<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>D._js hash追加

JS数据结构-Set集合，创建Set，常用Set方法_js set-程序员宅基地

文章浏览阅读7.6k次，点赞7次，收藏12次。Set　　ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。　　很多时候我们把Set叫做 集合,但是，Set可以是集合，集合不一定是Set。　　特性：唯一性=>不重复=>能够对数据进行去重操作。　　注：集合去重，是全等匹配，===。创建Set　　Set 本身是一个构造函数，调用构造函数用来生成 Set 数据结构。　　关键词　标识符　= new Set();　　例 let i = new Set();　　　　Set 函数可以接受一个数组_js set

C#版的抓包软件_c# winpcap-程序员宅基地

文章浏览阅读5.4k次，点赞3次，收藏27次。NetAnalyzer实现结构在上一篇中介绍一点VC++开发环境的配置，与基本的运行方式。因为NetAnalyzer使用的C#作为开发语言，所以在此主要介绍一些在C#环境下的开发环境的配置，与一些基本开发情况，力求在完成本篇后后，读者可以制作一个简单的抓包程序。在开始编程前先要介绍连个.Net类库SharpPcap.dll与PacketDotNet.dll。在2004年Tamir _c# winpcap

推荐文章

热门文章

相关标签