SpringBoot基础——快速入门

最新推荐文章于 2022-11-25 10:05:37 发布

程序无言

最新推荐文章于 2022-11-25 10:05:37 发布

阅读量175

点赞数

分类专栏： SpringBoot 文章标签： spring boot spring java

本文链接：https://blog.csdn.net/qq_43526405/article/details/108828015

版权

SpringBoot 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

SpringBoot基础

一. Hello World起步

1. 代码编写流程

1.1 导入maven依赖

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

    <groupId>com.codinghit</groupId>
    <artifactId>spring-boot-01-helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>

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

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

    <!-- 这个插件，可以将应用打包成一个可执行的jar包；-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

1.2 主入口类

/**
 *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {
    public static void main(String[] args) {

        // Spring应用启动起来
        SpringApplication.run(HelloWorldMainApplication.class,args);
    }
}

2. @SpringBootApplication探究

Spring Boot应用标注在某个类上说明这个类是SpringBoot的主配置类，SpringBoot就应该运行这个类的main方法来启动SpringBoot应用。

2.1 @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 {

2.1.1 @SpringBootConfiguration

表示这是一个Spring Boot的配置类

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
}

2.1.2 @EnableAutoConfiguration

开启自动配置功能，@EnableAutoConfiguration告诉SpringBoot开启自动配置功能；这样自动配置才能生效。

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

@AutoConfigurationPackage：自动配置包
- AutoConfigurationPackages.Registrar.class，将主配置类（@SpringBootApplication标注的类）的所在包及下面所有子包里面的所有组件扫描到Spring容器。

@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

@Import(EnableAutoConfigurationImportSelector.class)：导入哪些组件的选择器。Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就生效，帮我们进行自动配置工作。

二. 配置文件

SpringBoot使用一个全局配置文件，配置文件名是固定的：
- application.properties
- application.yml
导入maven依赖：

<!‐‐导入配置文件处理器，配置文件进行绑定就会有提示‐‐>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐configuration‐processor</artifactId>
  <optional>true</optional>
</dependency>

1. 配置文件值注入

1.1 配置文件

person:
  lastName: hello
  age: 18
  boss: false
  birth: 2017/12/12
  maps: {k1: v1,k2: 12}
  lists:
    ‐ lisi
    ‐ zhaoliu
  dog:
  name: 小狗
  age: 12

1.2 JavaBean

/**
* 将配置文件中配置的每一个属性的值，映射到这个组件中
* @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
* prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
*只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
*/
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
  private String lastName;
  private Integer age;
  private Boolean boss;
  private Date birth;
  private Map<String,Object> maps;
  private List<Object> lists;
  private Dog dog;

@ConfigurationProperties(prefix = “person”)： 默认是从配置文件中获取对应的值

1.3 @PropertySource(加载指定的配置文件)

@Component
@PropertySource(value = {"classpath:person.properties"})
@ConfigurationProperties(prefix = "person")
public class Person {}

1.4 @ImportResource

导入Spring的配置文件，让配置文件里面的内容生效。

@ImportResource(locations = {"classpath:beans.xml"})

2. Profile

往往我们在开发和发布时所使用的的springBoot的配置文件不一样，因此我们可以使用profile来解决这个问题。

2.1 配置文件命名

开发时使用的配置文件名：application-dev.properties
发布时使用的配置文件名：application-prod.properties
我们可以在application.properties指定使用哪个配置文件：

server:
  port: 8081
spring:
  profiles:
    active: prod
---
server:
  port: 8083
spring:
  profiles: dev
---
server:
  port: 8084
spring:
  profiles: prod

我们也可以使用命令行的方式指定：java -jar spring-boot-02-config-0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

2.2 配置文件加载位置

–file:./config/
–file:./
–classpath:/config/
–classpath:/
优先级由高到底，高优先级的配置会覆盖低优先级的配置；如果有两个及以上会形成互补配置。

3. 自动配置原理

3.1 自动配置原理：

1)、SpringBoot启动的时候加载主配置类，开启了自动配置功能 @EnableAutoConfiguration
2)、@EnableAutoConfiguration 作用：
- 利用EnableAutoConfigurationImportSelector给容器中导入一些组件
- 可以查看selectImports()方法的内容
- List configurations = getCandidateConfigurations(annotationMetadata, attributes);获取候选的配置
- SpringFactoriesLoader.loadFactoryNames()：扫描所有jar包类路径下 META‐INF/spring.factories，把扫描到的这些文件的内容包装成properties对象，从properties中获取EnableAutoConfiguration.class类（类名）对应的值，然后把他们添加在容器中

3.2 HttpEncodingAutoConfiguration(Http编码自动配置)

以该例子解释自动配置原理：

@Configuration //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties(HttpEncodingProperties.class) //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
@ConditionalOnWebApplication //Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效； 判断当前应用是否是web应用，如果是，当前配置类生效
@ConditionalOnClass(CharacterEncodingFilter.class) //判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing =
true) //判断配置文件中是否存在某个配置 spring.http.encoding.enabled；如果不存在，判断也是成立的
//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
public class HttpEncodingAutoConfiguration {
//他已经和SpringBoot的配置文件映射了
private final HttpEncodingProperties properties;
//只有一个有参构造器的情况下，参数的值就会从容器中拿
public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
    this.properties = properties;
}
@Bean //给容器中添加一个组件，这个组件的某些值需要从properties中获取
@ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件？
public CharacterEncodingFilter characterEncodingFilter() {
    CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
    filter.setEncoding(this.properties.getCharset().name());
    filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
    filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
    return filter;
}

所有在配置文件中能配置的属性都是在xxxxProperties类中封装者：

@ConfigurationProperties(prefix = "spring.http.encoding") //从配置文件中获取指定的值和bean的属性进行绑定
public class HttpEncodingProperties {
  public static final Charset DEFAULT_CHARSET = Charset.forName("UTF‐8");

三. 日志

springBoot中选用的是sl4j门面(日志的抽象层)，logback(日志实现)。

1. 日志的使用

日志的级别：由低到高：trace<debug<info<warn<error

@RestController
@RequestMapping("/test")
public class TestController {
private final static Logger logger =
LoggerFactory.getLogger(TestController.class);
@RequestMapping("/log")
public String testLog() {
  logger.debug("=====测试日志debug级别打印====");
  logger.info("======测试日志info级别打印=====");
  logger.error("=====测试日志error级别打印====");
  logger.warn("======测试日志warn级别打印=====");
  return "success";
}

2. 日志的默认配置

#指定日志的级别
logging.level.com.atguigu=trace
#logging.path=
# 不指定路径在当前项目下生成springboot.log日志
# 可以指定完整的路径；
#logging.file=G:/springboot.log
# 在当前磁盘的根路径下创建spring文件夹和里面的log文件夹；使用 spring.log 作为默认文件
logging.path=/spring/log
# 在控制台输出的日志的格式
logging.pattern.console=%d{yyyy‐MM‐dd} [%thread] %‐5level %logger{50} ‐ %msg%n
# 指定文件中日志输出的格式
logging.pattern.file=%d{yyyy‐MM‐dd} === [%thread] === %‐5level === %logger{50} ==== %msg%n

四. Web开发

1. SpringBoot对静态资源的映射规则

1. 默认的静态资源文件夹

@ConfigurationProperties(prefix = "spring.resources", ignoreUnknownFields = false)
public class ResourceProperties implements ResourceLoaderAware {

	private static final String[] SERVLET_RESOURCE_LOCATIONS = { "/" };

	private static final String[] CLASSPATH_RESOURCE_LOCATIONS = {
			"classpath:/META-INF/resources/", "classpath:/resources/",
			"classpath:/static/", "classpath:/public/" };

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

2. SpringMVC自动配置

SpringBoot对SpringMVC的默认配置：WebMvcAutoConfiguration

2.1 扩展SpringMVC(一)

在SpringBoot2.0以前，使用WebMvcConfigurationAdapter来扩展SpringMVC的功能，但是在SpringBoot2.0之后，该方法已经被废弃了，取而代之的是WebMvcConfigurationSupport方法。
WebMvcConfigurationSupport在重写addInterceptors方法时，默认会拦截静态资源。可以添加一个addResourceHandlers解决这个问题。

//使用WebMvcConfigurationSupport可以来扩展SpringMVC的功能
@Configuration
public class MyMvcConfig extends WebMvcConfigurationSupport {
@Override
public void addViewControllers(ViewControllerRegistry registry) {
// super.addViewControllers(registry);
//浏览器发送 /atguigu 请求来到 success
  registry.addViewController("/atguigu").setViewName("success");
}

2.2 扩展SpringMVC(二)

可以实现WebMvcConfig接口中的方法

2.3 原理

1)、WebMvcAutoConfiguration是SpringMVC的自动配置类
2)、在做其他自动配置时会导入；@Import(EnableWebMvcConfiguration.class)

@Configuration
public static class EnableWebMvcConfiguration extends DelegatingWebMvcConfiguration {
private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();
//从容器中获取所有的WebMvcConfigurer
@Autowired(required = false)
public void setConfigurers(List<WebMvcConfigurer> configurers) {
  if (!CollectionUtils.isEmpty(configurers)) {
    this.configurers.addWebMvcConfigurers(configurers);
    //一个参考实现；将所有的WebMvcConfigurer相关配置都来一起调用；
      @Override
      // public void addViewControllers(ViewControllerRegistry registry) {
      // for (WebMvcConfigurer delegate : this.delegates) {
      // delegate.addViewControllers(registry);
      // }
      }
    }
}

3)、容器中所有的WebMvcConfigurer都会一起起作用

2.4 全面接管SpringMVC

SpringBoot对SpringMVC的自动配置不需要了，所有都是我们自己配置；所有的SpringMVC的自动配置都失效了。
我们需要在配置类中添加 @EnableWebMvc 即可。
原因：@EnableWebMvc将WebMvcConfigurationSupport组件导入进来，导致WebMvcAutoConfiguration配置失效。

3. 错误处理机制

1. 定制错误响应

在有模板引擎的情况下：在/templates/error/*.html下找到对应错误码的页面。
没有模板引擎：在静态资源文件夹下找
以上都没有错误页面，默认来到SpringBoot的错误提示页面

@ControllerAdvice
public class MyExceptionHandler {
  @ResponseBody
  @ExceptionHandler(UserNotExistException.class)
  public Map<String,Object> handleException(Exception e){
      Map<String,Object> map = new HashMap<>();
      map.put("code","user.notexist");
      map.put("message",e.getMessage());
      return map;
    }
}

@ControllerAdvice： 拦截项目中抛出的异常
@ExceptionHandler： 指定具体的异常，然后在方法中处理该异常信息

4. 嵌入式的Servlet容器

4.1 注册Servlet三大组件

注册Servlet：

@Bean
public ServletRegistrationBean myServlet(){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new
    MyServlet(),"/myServlet");
    return registrationBean;
}

注册Filter：

@Bean
public FilterRegistrationBean myFilter(){
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());
    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
    return registrationBean;
}

注册Listener：

@Bean
public ServletListenerRegistrationBean myListener(){
    ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
    return registrationBean;
}

4.2 替换嵌入式的Servlet容器

SpringBoot默认使用的是嵌入式的Tomcat作为Servlet容器
可以替换为Jetty: 适合长连接(通信)

<!‐‐ 引入web模块 ‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>spring‐boot‐starter‐tomcat</artifactId>
      <groupId>org.springframework.boot</groupId>
    </exclusion>
  </exclusions>
</dependency>
<!‐‐引入其他的Servlet容器‐‐>
<dependency>
    <artifactId>spring‐boot‐starter‐jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

可以替换为Undertow ：适合并发

<!‐‐ 引入web模块 ‐‐>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐web</artifactId>
  <exclusions>
    <exclusion>
      <artifactId>spring‐boot‐starter‐tomcat</artifactId>
      <groupId>org.springframework.boot</groupId>
    </exclusion>
  </exclusions>
</dependency>
<!‐‐引入其他的Servlet容器‐‐>
<dependency>
    <artifactId>spring‐boot‐starter‐undertow</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>