Spring Boot基础篇

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<!-- 指定父工程为spring-boot-starter-parent -->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.1.1.RELEASE</version>
</parent>

<dependencies>
  <!-- 引入web模块 -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
</dependencies>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

/**
 * @SpringBootApplication标识这是一个主程序类，说明这是个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {

  //Spring 应用启动起来
  public static void main(String[] args) {
    SpringApplication.run(HelloWorldMainApplication.class, args);
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

@Controller
public class HelloWorld {

  //直接Run就可以通过游览器访问地址
  @RequestMapping("/hello")
  @ResponseBody
  public String hello() {
    return "hello world";
  }
}

1
2
3
4
5

<!-- Spring Boot打包插件 -->
<plugin>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

project
 |
 +- src/main/java      【java代码存放位置】
 |
 +- src/main/resource  【资源文件】
 |   |
 |   +- static         【静态资源文件存放位置】
 |   |
 |   +- templates      【用于web开发的前端模板】
 |   |
 |   +- application.yml【配置文件】
 |
 +- src/test/java      【测试代码存放位置】

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

#对象行外写法
xiaoming:
  age: 19
  sex: f
  note: 'I\tlove\tLili'
#对象行内写法
xiaoming: {age: 19,sex: f,note: 'I\tlove\tLili'}

#对象行外写法
friends:
  - zhangsan
  - Lisi
  - WangWu
#对象行内写法
friends: [zhangsan,Lisi,WangWu]

1
2
3
4
5

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-configuration-processor</artifactId>
  <optional>true</optional>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

@Component
@ConfigurationProperties(prefix="person")
public class Person {
  private Integer id;
  private Integer age;
  private String  name;
  private Boolean boss;
  private Date	birth;
  private Map<String,Object> maps;
  private List<Object> list;
  private Dog		dog;
  //=============Getter/Setter方法=============
}

public class Dog {
  private String name;
  private String age;
  //=============Getter/Setter方法=============
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

person:
  id: 1
  name: 张三
  age: 18
  boss: false
  birth: 2019/01/01
  maps: {k1: v1,k2: v2}
  list:
  - list1
  - list2
  - list3
  dog:
    age: 10
    name: tom  

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

@Component
@ConfigurationProperties(prefix="person")//支持JSR303
@Validated//使用JSR303校验
public class Person {
  private Integer id;
  private Integer age;
  @NotEmpty
  private String  name;
  private Boolean boss;
  private Date    birth;
  private Map<String,Object> maps;
  private List<Object> list;
  private Dog	    dog;

  //=============Getter/Setter方法=============
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

person:
  id: 1
  name: 张三
  # 生成随机数
  # ${random.uuid}、${random.int}、${random.long}、${random.10}、${random.[20,50]}
  age: ${random.uuid}
  boss: false
  birth: 2019/01/01
  maps: {k1: v1,k2: v2}
  list:
  - list1
  - list2
  - list3
  dog:
    age: 10
    name: tom-${person.name:not-host} #使用占位符获取配置的值，如果没有使用:后值作为默认值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# 指定激活的profile
spring:
  profiles:
    active:
      - dev
---
server:
  port: 8081
  # profile环境名称
spring:
  profiles: dev
  
---
server:
  port: 8082
  # profile环境名称
spring: 
  profiles: prod  

1
2
3
4
5
6
7
8
9

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class HelloWorld {
  public static void main(String[] args) {
    Logger logger = LoggerFactory.getLogger(HelloWorld.class);
    logger.info("Hello World");
  }
}

1
2
3
4

  <!-- 可以指定某段配置只在某个环境下生效 -->
  <springProfile name="dev">
    <!-- 配置 -->
  </springProfile>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

  <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
    <!--
    日志输出格式：
        %d			表示日期时间
        %thread		表示线程名
        %‐5level	    级别从左显示5个字符宽度
        %logger{50}   表示logger名字最长50个字符，否则按照句点分割
        %msg		    日志消息
        %n			换行符
    -->
    <layout class="ch.qos.logback.classic.PatternLayout">
      <springProfile name="dev">
        <pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ‐‐‐‐> [%thread] ‐‐‐> %‐5level %logger{50} ‐ %msg%n
        </pattern>
      </springProfile>
      <springProfile name="!dev">
        <pattern>%d{yyyy‐MM‐dd HH:mm:ss.SSS} ==== [%thread] ==== %‐5level
          %logger{50} ‐ %msg%n
        </pattern>
      </springProfile>
    </layout>
  </appender>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
                     TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {

  //......

  @Configuration
  @Import(EnableWebMvcConfiguration.class)
  @EnableConfigurationProperties({ WebMvcProperties.class, ResourceProperties.class })
  @Order(0)
  public static class WebMvcAutoConfigurationAdapter
    implements WebMvcConfigurer, ResourceLoaderAware {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
      if (!this.resourceProperties.isAddMappings()) {
        logger.debug("Default resource handling disabled");
        return;
      }
      Duration cachePeriod = this.resourceProperties.getCache().getPeriod();
      CacheControl cacheControl = this.resourceProperties.getCache()
        .getCachecontrol().toHttpCacheControl();

      // 所有/webjars/**，都去classpath:/META-INF/resources/webjars/找资源
      // webjars：以jar包的方式引入静态资源【参考http://www.webjars.org】
      if (!registry.hasMappingForPattern("/webjars/**")) {
        customizeResourceHandlerRegistration(
          registry.addResourceHandler("/webjars/**")
          .addResourceLocations("classpath:/META-INF/resources/webjars/")
          .setCachePeriod(getSeconds(cachePeriod))
          .setCacheControl(cacheControl));
      }

      /**
        * staticPathPattern = "/**"
        * staticLocations = "classpath:/META-INF/resources/",
        *                   "classpath:/resources/",
        *                   "classpath:/static/", 
        *                   "classpath:/public/"
        */
      String staticPathPattern = this.mvcProperties.getStaticPathPattern();
      if (!registry.hasMappingForPattern(staticPathPattern)) {
        customizeResourceHandlerRegistration(
          registry.addResourceHandler(staticPathPattern)
          .addResourceLocations(getResourceLocations(this.resourceProperties.getStaticLocations()))
          .setCachePeriod(getSeconds(cachePeriod))
          .setCacheControl(cacheControl));
      }
    }

    //欢迎页请求映射处理
    @Bean
    public WelcomePageHandlerMapping welcomePageHandlerMapping(
      ApplicationContext applicationContext) {
      return new WelcomePageHandlerMapping(
        new TemplateAvailabilityProviders(applicationContext),
        applicationContext, getWelcomePage(),
        this.mvcProperties.getStaticPathPattern());
    }

    //欢迎图标
    @Bean
    public ResourceHttpRequestHandler faviconRequestHandler() {
      ResourceHttpRequestHandler requestHandler = new ResourceHttpRequestHandler();
      requestHandler.setLocations(resolveFaviconLocations());
      return requestHandler;
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

<!-- 引入thymeleaf的starter -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

<!--
 如果thymeleaf是2版本切换thymeleaf3版本方法
 <properties>
    <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
    <!‐‐ 布局功能的支持程序 thymeleaf3主程序 layout2以上版本 ‐‐>
    <thymeleaf‐layout‐dialect.version>2.2.2</thymeleaf‐layout‐dialect.version>
 </properties>
-->

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Configuration
public class AppWebMvcConfigurer implements WebMvcConfigurer{

  @Override
  public void addFormatters(FormatterRegistry registry) {
  }

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

  private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

  //从容器中获取所有WebMvcConfigurer，将配置全部保存起来用于扩展
  @Autowired(required = false)
  public void setConfigurers(List<WebMvcConfigurer> configurers) {
    if (!CollectionUtils.isEmpty(configurers)) {
      this.configurers.addWebMvcConfigurers(configurers);
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@EnableWebMvc
@Configuration
public class AppWebMvcConfigurer implements WebMvcConfigurer{

  @Override
  public void addFormatters(FormatterRegistry registry) {
  }

  @Override
  public void addInterceptors(InterceptorRegistry registry) {
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//存放页面展示需要使用错误的属性
@Override
public Map<String, Object> getErrorAttributes(WebRequest webRequest,
                                              boolean includeStackTrace) {
  Map<String, Object> errorAttributes = new LinkedHashMap<>();
  errorAttributes.put("timestamp", new Date());
  addStatus(errorAttributes, webRequest);
  addErrorDetails(errorAttributes, webRequest, includeStackTrace);
  addPath(errorAttributes, webRequest);
  return errorAttributes;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

@Controller
@RequestMapping("${server.error.path:${error.path:/error}}")
public class BasicErrorController extends AbstractErrorController {

  //......

  //返回HTML需要的错误界面
  @RequestMapping(produces = MediaType.TEXT_HTML_VALUE)
  public ModelAndView errorHtml(HttpServletRequest request,
                                HttpServletResponse response) {
    HttpStatus status = getStatus(request);
    Map<String, Object> model = Collections.unmodifiableMap(
      getErrorAttributes(request, isIncludeStackTrace(request, MediaType.TEXT_HTML)));
    response.setStatus(status.value());
    ModelAndView modelAndView = resolveErrorView(request, response, status, model);
    return (modelAndView != null) ? modelAndView : new ModelAndView("error", model);
  }

  //返回JSON错误数据
  @RequestMapping
  public ResponseEntity<Map<String, Object>> error(HttpServletRequest request) {
    Map<String, Object> body = getErrorAttributes(request,
                                                  isIncludeStackTrace(request, MediaType.ALL));
    HttpStatus status = getStatus(request);
    return new ResponseEntity<>(body, status);
  }   

  //......
}

1
2

@Value("${error.path:/error}")
private String path = "/error"; //系统出现错误以后来到error请求进行处理相当于web.xml注册的错误页面规则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

public class DefaultErrorViewResolver implements ErrorViewResolver, Ordered {

  private static final Map<Series, String> SERIES_VIEWS;

  static {
    Map<Series, String> views = new EnumMap<>(Series.class);
    views.put(Series.CLIENT_ERROR, "4xx");
    views.put(Series.SERVER_ERROR, "5xx");
    SERIES_VIEWS = Collections.unmodifiableMap(views);
  }

  @Override
  public ModelAndView resolveErrorView(HttpServletRequest request, 
                                       HttpStatus status,Map<String, Object> model) {
    ModelAndView modelAndView = resolve(String.valueOf(status.value()), model);
    if (modelAndView == null && SERIES_VIEWS.containsKey(status.series())) {
      modelAndView = resolve(SERIES_VIEWS.get(status.series()), model);
    }
    return modelAndView;
  }

  //寻找对应的错误视图
  private ModelAndView resolve(String viewName, Map<String, Object> model) {
    //viewName是错误代码
    String errorViewName = "error/" + viewName;

    //模板引擎可以解析这个页面地址就用模板引擎解析
    TemplateAvailabilityProvider provider = this.templateAvailabilityProviders
      .getProvider(errorViewName, this.applicationContext);
    if (provider != null) {
      return new ModelAndView(errorViewName, model);
    }
    //模板引擎不可用，就在静态资源文件夹下找errorViewName对应的页面   error/404.html
    return resolveResource(errorViewName, model);
  }

  private ModelAndView resolveResource(String viewName, Map<String, Object> model) {
    for (String location : this.resourceProperties.getStaticLocations()) {
      try {
        Resource resource = this.applicationContext.getResource(location);
        resource = resource.createRelative(viewName + ".html");
        if (resource.exists()) {
          return new ModelAndView(new HtmlResourceView(resource), model);
        }
      }
      catch (Exception ex) {
      }
    }
    return null;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

//给容器中加入我们自己定义的ErrorAttributes
@Component
public class MyErrorAttributes extends DefaultErrorAttributes {

  @Override
  public Map<String, Object> getErrorAttributes(RequestAttributes requestAttributes,
                                                boolean includeStackTrace) {
    Map<String, Object> map = super.getErrorAttributes(requestAttributes, includeStackTrace);
    String errorCode = requestAttributes.getAttribute("code");
    map.put("errorCode",errorCode);
    return map;
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

public @interface CrossOrigin {
  @AliasFor("origins")
  String[] value() default {};

  //允许可访问的域列表，*代表所有
  @AliasFor("value")
  String[] origins() default {};

  //运行的请求头
  String[] allowedHeaders() default {};

  //配置获取响应的头信息， 在其中可以设置其他的头信息，不进行配置时， 默认可以获取到
  //Cache-Control、Content-Language、Content-Type、Expires、Last-Modified、Pragma字段
  String[] exposedHeaders() default {};

  //允许可访问的域发送请求的方法
  RequestMethod[] methods() default {};

  //浏览器是否应该同时发送凭证(如cookie)。默认false，开启设置为true
  String allowCredentials() default "";

  //准备响应前的缓存持续的最大时间（以秒为单位）
  long maxAge() default -1L;
}
//----------------------------------------------------------------------------------
@SpringBootApplication
@CrossOrigin(origins = {"*"}, maxAge = 3600, methods = {RequestMethod.GET},allowCredentials = "true")
public class WebApplication {

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

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

@Configuration
public class AppWebMvcConfigurer implements WebMvcConfigurer {

  @Override
  public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**")
      .allowedOrigins("*")  
      .allowCredentials(true)
      .allowedMethods("GET", "POST", "DELETE", "PUT","PATCH")
      .maxAge(3600);  
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

/**
 * 类似于Controller，处理用户请求的真实逻辑
 */
public class StudentHandler {


  //这里采用Mono模式类似于点对点，也可使用Flux类似于发布、订阅
  public static Mono<ServerResponse> selectStudent(ServerRequest request) {
    Student studentBody = new Student();
    request.bodyToMono(Student.class).subscribe(
      student -> BeanUtils.copyProperties(student, studentBody));
    return ok().contentType(APPLICATION_JSON_UTF8).body(fromObject(studentBody));
  }

  public static Mono<ServerResponse> insertStudent(ServerRequest request){
    return ok().contentType(TEXT_PLAIN).body(fromObject("success"));

  }
  private static class Student {
    private Integer id;
    private String name;

    public Integer getId() {
      return id;
    }

    public void setId(Integer id) {
      this.id = id;
    }

    public String getName() {
      return name;
    }

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

//===================================================================================

//配置类
@Configuration
@EnableWebFlux
public class WebConfig implements WebFluxConfigurer {

  @Bean
  public RouterFunction<?> routerFunctionA() {
    RouterFunction<ServerResponse> route = route()
      .GET("/student/{id}", accept(APPLICATION_JSON), StudentHandler::selectStudent)
      .POST("/student", StudentHandler::insertStudent)
      .build();
    return route;
  }
}

1
2
3
4
5
6

#修改通用配置 
server:port: 8081
server:context-path: /crud

#修改tomcat特定配置，如修改其他容器，更改容器名
server:tomcat:uri-encoding: UTF-8

1
2
3
4

@Bean
public ServletRegistrationBean<HelloServlet> helloServletBean() {
  return new ServletRegistrationBean<HelloServlet>(new HelloServlet(), "/hello");
}

1
2
3
4
5
6

@Bean
public FilterRegistrationBean<HelloFilter> helloFilterBean() {
  FilterRegistrationBean<HelloFilter> helloFilterBean = new FilterRegistrationBean<HelloFilter>(new HelloFilter());
  helloFilterBean.addUrlPatterns("/hello");
  return helloFilterBean;
}

1
2
3
4

@Bean
public ServletListenerRegistrationBean<HelloListener> helloListenerBean() {
  return new ServletListenerRegistrationBean<HelloListener>(new HelloListener());
}

1
2
3
4
5

<dependency>
  <!-- 引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器 -->
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring‐boot‐starter‐web</artifactId>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<!-- 引入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>

<!-- 引入jetty -->
<dependency>
  <artifactId>spring‐boot‐starter‐jetty</artifactId>
  <groupId>org.springframework.boot</groupId>
</dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<!-- 引入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>

<!-- 引入undertow -->
<dependency>
  <artifactId>spring‐boot‐starter‐undertow<</artifactId>
    <groupId>org.springframework.boot</groupId>
    </dependency>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

@Configuration
@ConditionalOnWebApplication
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {

  //配置Tomcat的WebServer
  @Configuration
  @ConditionalOnClass({ Tomcat.class, UpgradeProtocol.class })
  public static class TomcatWebServerFactoryCustomizerConfiguration {
    @Bean
    public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(
      Environment environment, ServerProperties serverProperties) {
      return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
    }
  }

  //配置Jetty的WebServer
  @Configuration
  @ConditionalOnClass({ Server.class, Loader.class, WebAppContext.class })
  public static class JettyWebServerFactoryCustomizerConfiguration {
    @Bean
    public JettyWebServerFactoryCustomizer jettyWebServerFactoryCustomizer(
      Environment environment, ServerProperties serverProperties) {
      return new JettyWebServerFactoryCustomizer(environment, serverProperties);
    }
  }

  //配置Undertow的WebServer
  @Configuration
  @ConditionalOnClass({ Undertow.class, SslClientAuthMode.class })
  public static class UndertowWebServerFactoryCustomizerConfiguration {
    @Bean
    public UndertowWebServerFactoryCustomizer undertowWebServerFactoryCustomizer(
      Environment environment, ServerProperties serverProperties) {
      return new UndertowWebServerFactoryCustomizer(environment, serverProperties);
    }
  }

  //配置Netty的WebServer
  @Configuration
  @ConditionalOnClass(HttpServer.class)
  public static class NettyWebServerFactoryCustomizerConfiguration {
    @Bean
    public NettyWebServerFactoryCustomizer nettyWebServerFactoryCustomizer(
      Environment environment, ServerProperties serverProperties) {
      return new NettyWebServerFactoryCustomizer(environment, serverProperties);
    }
  }
}

1
2
3
4
5

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
  <scope>provided</scope>
</dependency>

1
2
3
4
5
6

public class ServletInitializer extends SpringBootServletInitializer {
  @Override
  protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    return application.sources(SpringBootAppWarApplication.class);
  }
}