SpringBoot（三）-阿里云开发者社区

SpringBoot打包部署

将项目打成jar包

导入依赖：

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

使用maven package代码打包就可以

项目打成war包

排除项目中自带的所有的Tomcat插件和jsp servlet 依赖,因为这里要将项目放到一个Tomcat上运行

  <!--配置SpringBoot的web启动器-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
      <!--排除web启动中自动依赖的tomcat插件-->
      <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-tomcat</artifactId>
          </exclusion>
      </exclusions>
</dependency>
  <!--
    手动依赖tomcat插件，但是表明项目打包时该依赖不会被打进去，目的主要是保证开发阶段本地SpringBoot
      项目可以正常运行
  -->
  <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
    <!--打包的时候可以不用包进去，别的设施会提供。事实上该依赖理论上可以参与编译，测试，运行等周期。
        相当于compile，但是打包阶段做了exclude操作-->
   <scope>provided</scope>
  </dependency>

SpringBoot的启动类继承SpringBootServletInitializer，并重写configure

@SpringBootApplication
public class Springboot04Application extends SpringBootServletInitializer {
    //重写配置方法
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(Springboot04Application.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(Springboot04Application.class, args);
    }
}

使用install命令打包项目，并将war包放到tomcat下的webapps下，启动tomcat即可。

SpringBoot拦截器配置

自定义拦截器类：

@Component
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

拦截器配置：

@Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {
    @Autowired
    MyInterceptor myInterceptor;
    //设置拦截器路径
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        InterceptorRegistration interceptorRegistration = registry.addInterceptor(myInterceptor);
        interceptorRegistration.addPathPatterns("/**").excludePathPatterns("/login");
    }
}

SpringBoot其他注解

@Configuration

用来编写配置类，里面有一些bean实例，spring容器从配置类中来获取这些实例。

配置类：

@Configuration
public class MyConfig {
    @Bean // 向容器中添加一个Bean,以方法名作为Bean的id,返回值类型作为组件的类型
    public User user1(){
        return new User("张三","123");
    }
}

启动类：

@SpringBootApplication
public class Springboot04Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext Context = SpringApplication.run(Springboot04Application.class, args);
        User user1=Context.getBean("user1",User.class);
        System.out.println(user1);
    }
}

@Import

@Import(User.class)
@Configuration
public class MyConfig {
    @Bean // 向容器中添加一个Bean,以方法名作为Bean的id,返回值类型作为组件的类型
    public User user1(){
        return new User("张三","123");
    }
}

根据类型来获取bean实例，默认使用无参构造方法来创建实例对象。

@ImportResource

原生配置文件引入，允许我们自己定义xml配置文件，在文件中配置bean

@ImportResource("classpath:beans.xml")
@Configuration
public class MyConfig {
    @Bean // 向容器中添加一个Bean,以方法名作为Bean的id,返回值类型作为组件的类型
    public User user1(){
        return new User("张三","123");
    }
}

@ConfigurationProperties

读取application.properties配置文件中的内容,读取进入bean

JUnit5

JUnit5常见注解

class Springboot04ApplicationTests {
    @DisplayName("测试方法1：")//是对类的描述
    @Test  //方法可以独立的运行，不需要再测试了
    public void test1(){
    }
    @BeforeAll
    public void beforeAll(){
        System.out.println("在所有的测试方法执行之前先执行一次");
    }
    @BeforeEach
    public void beforeEach(){
        System.out.println("在每一个测试方法之前执行该方法");
    }
    @AfterEach
    public void afterEach(){
       System.out.println("在每一个测试方法之后执行该方法");
    }
    @AfterAll
    public void afterAll(){
        System.out.println("在所有方法执行之后执行该方法");
    }
    @RepeatedTest(3)
    public void repeatTest(){
        System.out.println("重复测试3次");
    }
}

JUnit5断言

@DisplayName("JUnit5断言")
@SpringBootTest(classes = Springboot04ApplicationTests2.class)//在测试的时候可以导入spring中的一些组件
class Springboot04ApplicationTests2 {
    @DisplayName("简单断言1")
    @Test
  public void testAssertions1(){
      int x=add(1,2);
      Assertions.assertEquals(2,x,"add运算结果错误");
  }
  public int add(int a,int b){
        return a+b;
  }
  @DisplayName("组合断言")
  @Test
  public void testAssertAll(){
        Assertions.assertAll("AssertAll",
                ()->Assertions.assertTrue(1>0),
                ()->Assertions.assertTrue(2>3));
  }
    @DisplayName("异常断言")
    @Test//断言它会出现指定的异常，如果没出现，则表示测试失败
    public void testAssertExcepion(){
       Assertions.assertThrows(ArithmeticException.class,()->{int i=1/0;},"竟然没有出现异常");
    }
    @DisplayName("超时异常")
    @Test
    public void testAssertTimeOut(){
        Assertions.assertTimeout(Duration.ofMillis(1000),()->Thread.sleep(900));
    }
    @DisplayName("快速失败")
    @Test //如果测试时出现了某些情况，直接生成测试失败的报告，后续也不再测试了
    public void testFail(){
        Assertions.fail("测试失败");
    }
}

JUnit5前置条件

@DisplayName("JUnit5前置条件")
@SpringBootTest(classes = Springboot04ApplicationTests3.class)//在测试的时候可以导入spring中的一些组件
class Springboot04ApplicationTests3 {
    @DisplayName("测试前置条件")
    @Test
  public void testAssumptions(){
      //假设的条件为true的时候才会执行测试，否则取消测试
      Assumptions.assumeTrue(true);
      System.out.println("测试了");
  }
}

JUnit5嵌套测试

@DisplayName("JUnit5嵌套测试")
@SpringBootTest(classes = Springboot04ApplicationTests4.class)//在测试的时候可以导入spring中的一些组件
class Springboot04ApplicationTests4 {
   @BeforeEach
    public void outerBeforEach(){
       System.out.println("outerBeforeEach");
    }
   @Test
    public void outerTest1(){
       System.out.println("outerTest");
   }
   @Nested
   @DisplayName("内部嵌套测试")
   class InnerClass{
       @BeforeEach
       public void outerBeforEach(){
           System.out.println("innerBeforeEach");
       }
       @Test
       public void outerTest1(){
           System.out.println("innerTest");
       }
   }
}

SpringBoot（三）