学习笔记——springboot

SpringBoot简介

意义

spring整合多个框架时需要写很多配置文件，为了简化配置引出了springboot框架。

优点

内嵌web服务器

自动starter依赖，简化依赖引用——不会出现版本问题

自动配置spring——不需要写大量配置文件

提供生产级别的监控，健康检测及外部化配置

缺点

封装太深，内部原理复杂

版本迭代较快

时代背景

微服务:将功能划分为一个个模块，部署在多个服务器中，之间通过http调用

分布式：微服务牵扯出分布式问题。

使用springboot+springcloud

配置

配置流程

创建maven空项目

配置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.4.10-SNAPSHOT</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   <groupId>net.xmclass</groupId>
   <artifactId>online_xmclass</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <name>online_xmclass</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>org.mybatis.spring.boot</groupId>
         <artifactId>mybatis-spring-boot-starter</artifactId>
         <version>2.1.4</version>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>org.apache.commons</groupId>
         <artifactId>commons-lang3</artifactId>
      </dependency>
      <dependency>
         <groupId>io.jsonwebtoken</groupId>
         <artifactId>jjwt</artifactId>
         <version>0.7.0</version>
      </dependency>

      <!--guava依赖包-->
      <dependency>
         <groupId>com.google.guava</groupId>
         <artifactId>guava</artifactId>
         <version>19.0</version>
      </dependency>

      <dependency>
         <groupId>com.google.gcloud</groupId>
         <artifactId>gcloud-java-bigquery</artifactId>
         <version>0.1.7</version>
      </dependency>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
      </dependency>
   </dependencies>

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

      </plugins>
   </build>
   <repositories>
      <repository>
         <id>spring-milestones</id>
         <name>Spring Milestones</name>
         <url>https://repo.spring.io/milestone</url>
         <snapshots>
            <enabled>false</enabled>
         </snapshots>
      </repository>
      <repository>
         <id>spring-snapshots</id>
         <name>Spring Snapshots</name>
         <url>https://repo.spring.io/snapshot</url>
         <releases>
            <enabled>false</enabled>
         </releases>
      </repository>
   </repositories>
   <pluginRepositories>
      <pluginRepository>
         <id>spring-milestones</id>
         <name>Spring Milestones</name>
         <url>https://repo.spring.io/milestone</url>
         <snapshots>
            <enabled>false</enabled>
         </snapshots>
      </pluginRepository>
      <pluginRepository>
         <id>spring-snapshots</id>
         <name>Spring Snapshots</name>
         <url>https://repo.spring.io/snapshot</url>
         <releases>
            <enabled>false</enabled>
         </releases>
      </pluginRepository>
   </pluginRepositories>
</project>

主方法

@SpringBootApplication
public class OnlineXmclassApplication {

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

}

简化配置

application.properties——主配置文件，不需要xml了。所有配置都在该文件中

编写业务

测试

简化的部署

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

​ 打包成jar包 注意取消cmd的快速编辑模式

依赖管理

开发导入starter场景启动器：只要引进场景，场景相关的依赖都会自动引入

被引入的依赖无需关注版本号，有自动版本仲裁

修改版本号

​ 人为控制版本：

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

​ 或者加上版本号version

自动配置

自动配置特性

自动配好tomcat

自动配好springMVC

自动配好web常见功能如：字符编码问题（配好了拦截器）

默认包结构

​ 主程序所在的包及其以下的所有子包都会被扫描进来，无需配置包扫描，将主程序写 在项目包的下一级。

​ 使用@ComponentScan(“com.example”)

各种配置都有默认值

按需加载所有自动配置 引入哪些场景，该场景才会自动配置

自动配置原理

引导加载自动配置类

@SpringBootApplication
@MapperScan("net.xmclass.online_xmclass.mapper")
@EnableTransactionManagement
public class OnlineXmclassApplication {

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

@SpringBootApplication ——配置类

@EnableAutoConfiguration

1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}

​ 包含 AutoConfigurationPackage

@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
public @interface AutoConfigurationPackage {}

//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来,MainApplication 所在包下。

​ 包含@Import(AutoConfigurationImportSelector.class)

1,2,3，4嵌套关系
1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
	默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
    spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
    

容器功能

@Configuration

​ 1.配置类里使用@bean注册bean实例，默认单实例

​ 2.配置类本身也是bean实例

​ 3.proxyBeanMethods代理bean的方法

​ Full:true 保证bean对象被调用多少次返回的组件都是单实例的，每次调用都会在IOC 容器中查找是否已经存在

​ Lite:false 不检查是否已创建过，每个bean对象被调用多少次返回的组件都是新创建 的，多实例

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user01(){
        User zhangsan = new User("zhangsan", 18);
        //user组件依赖了Pet组件
        zhangsan.setPet(tomcatPet());
        return zhangsan;
    }

    @Bean("tom")
    public Pet tomcatPet(){
        return new Pet("tomcat");
    }
}

其它

@Controller @Service @Component @Respository

@Import

import(User.class,DBHelper.class)

在容器中创建这两个类的bean实例

@Conditional——条件装配

属性配置

我们知道，在项目中，很多时候需要用到一些配置的信息，这些信息可能在测试环境和生产环境下会有不同的配置，后面根据实际业务情况有可能还会做修改，针对这种情况，我们不能将这些配置在代码中写死，最好就是写到配置文件中

少量配置信息的情形

举个例子，在微服务架构中，最常见的就是某个服务需要调用其他服务来获取其提供的相关信息，那么在该服务的配置文件中需要配置被调用的服务地址，比如在当前服务里，我们需要调用订单微服务获取订单相关的信息，假设 订单服务的端口号是 8002，那我们可以做如下配置：

server:
  port: 8001

# 配置微服务的地址
url:
  # 订单微服务的地址
  orderUrl: http://localhost:8002

然后在业务代码中如何获取到这个配置的订单服务地址呢？我们可以使用 @Value 注解来解决。在对应的类中加上一个属性，在属性上使用 @Value 注解即可获取到配置文件中的配置信息，如下：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class ConfigController {

    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigController.class);

    @Value("${url.orderUrl}")
    private String orderUrl;
    
    @RequestMapping("/config")
    public String testConfig() {
        LOGGER.info("=====获取的订单服务地址为：{}", orderUrl);
        return "success";
    }
}

@Value 注解上通过 ${key} 即可获取配置文件中和 key 对应的 value 值。我们启动一下项目，在浏览器中输入 localhost:8080/test/config 请求服务后，可以看到控制台会打印出订单服务的地址：

多个配置信息的情形

这里再引申一个问题，随着业务复杂度的增加，一个项目中可能会有越来越多的微服务，某个模块可能需要调用多个微服务获取不同的信息，那么就需要在配置文件中配置多个微服务的地址。可是，在需要调用这些微服务的代码中，如果这样一个个去使用 @Value 注解引入相应的微服务地址的话，太过于繁琐，也不科学。

所以，在实际项目中，业务繁琐，逻辑复杂的情况下，需要考虑封装一个或多个配置类。举个例子：假如在当前服务中，某个业务需要同时调用订单微服务、用户微服务和购物车微服务，分别获取订单、用户和购物车相关信息，然后对这些信息做一定的逻辑处理。那么在配置文件中，我们需要将这些微服务的地址都配置好：

# 配置多个微服务的地址
url:
  # 订单微服务的地址
  orderUrl: http://localhost:8002
  # 用户微服务的地址
  userUrl: http://localhost:8003
  # 购物车微服务的地址
  shoppingUrl: http://localhost:8004

@Component
@ConfigurationProperties(prefix = "url")
public class MicroServiceUrl {

    private String orderUrl;
    private String userUrl;
    private String shoppingUrl;
    // 省去get和set方法
}

使用 @ConfigurationProperties 注解并且使用 prefix 来指定一个前缀，然后该类中的属性名就是配置中去掉前缀后的名字，一一对应即可。即：前缀名 + 属性名就是配置文件中定义的 key。同时，该类上面需要加上 @Component 注解，把该类作为组件放到Spring容器中，让 Spring 去管理，我们使用的时候直接注入即可。

需要注意的是，使用 @ConfigurationProperties 注解需要导入它的依赖

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

拦截器

SpringMVC的内容

SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理。开发者可以自己定义一些拦截器来实现特定的功能。

过滤器与拦截器的区别：

拦截器是AOP思想的具体应用。

过滤器

servlet规范中的一部分，任何java web工程都可以使用

在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

springboot中拦截器放入ioc容器里

理解

aop代理，在controller方法前后增加了处理，preHandle返回true是放行，返回false是拦截

例子

编写一个拦截器

package com.kuang.interceptor;
 
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
public class MyInterceptor implements HandlerInterceptor {
 
    //在请求处理的方法之前执行
    //如果返回true执行下一个拦截器
    //如果返回false就不执行下一个拦截器
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("------------处理前------------");
        return true;
    }
 
    //在请求处理方法执行之后执行
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("------------处理后------------");
    }
 
    //在dispatcherServlet处理后执行,做清理工作.
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("------------清理------------");
    }
}

编写一个Controller，接收请求

package com.kuang.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
//测试拦截器的控制器
@Controller
public class InterceptorController {
 
    @RequestMapping("/interceptor")
    @ResponseBody
    public String testFunction() {
        System.out.println("控制器中的方法执行了");
        return "hello";
    }
}

拦截器配置

@Configuration
public class IntercepterConfig implements WebMvcConfigurer {

    //这里相当于在配置文件中配置bean，实际上就是通过IOC注入LoginIntercepter的对象，且只有一次
    @Bean
    LoginIntercepter loginIntercepter(){
        return new LoginIntercepter();
    }

    @Bean
    CorsIntercepter corsIntercepter() {return new CorsIntercepter();}

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        //拦截全部路径，这个跨域配置要放在最上面
        registry.addInterceptor(corsIntercepter()).addPathPatterns("/**");

        registry.addInterceptor(loginIntercepter()).addPathPatterns("/api/v1/pri/*/*/**")
                //不拦截哪些路径,注意以 / 开头
                .excludePathPatterns("/api/v1/pri/user/login","/api/v1/pri/user/register");
        WebMvcConfigurer.super.addInterceptors(registry);
    }
}

excludePathPatterns 不拦截的路径（controller方法）

addPathPatterns 拦截的路径（controller方法）