springBoot快速學習筆記-有解無憂

springBoot快速學習筆記

概述：

springboot快速入門：

1.新添加一個module

2.通過maven創建專案

在pom.xml中匯入依賴等：

<!--springboot鞏華城需要繼承的父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.18.RELEASE</version>
    </parent>

    <!--    web開發的起步依賴-->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

在Java源代碼目錄下創建controller類：

package com.xiaowei.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-09-20:56
 */
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello Spring Boot!";
    }
}

撰寫springboot的引導類：

package com.xiaowei;

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

/**
 * @author xiaowei
 * @description:引導類，SpringBoot專案的入口
 * @create 2021-09-09-21:05
 */
@SpringBootApplication
public class HelloApplication {
    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class,args);
    }
}

運行引導類，在控制臺可以看到：

打開瀏覽器，輸入 http:localhost:8080/hello:

使用idea快速構建springboot工程：

與之前不同的是這一次，我們選擇 spring initializr ,可以看到它有提示：

點擊選擇下一步(這里的網址是springboot構建的默認網址):

網址如下：

配置：

使用圖形化界面配置依賴,可以選擇相應的依賴配置:

一路next即可；

等待依賴匯入，如果匯入有問題，可參考：

匯入成功如下：

<?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.1.18.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.xiaowei</groupId>
    <artifactId>springboot-init</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-init</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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

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

</project>

可以看到已經自動創建好引導類、測驗等，我們只需創建controller類即可：

創建controller類：

package com.xiaowei.springbootinit;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-09-21:55
 */
@RestController
public class HelloController {
@RequestMapping("/hello")
    public  String Hello(){
        return "hello spring boot1111";
    }
}

點擊運行，發現出錯！

根據提示得知原來是埠8080 被占用，原來是之前專案的tomcat并沒有關閉，只需關閉tomcat，然后重啟當前工程即可，

springboot起步依賴原理分析：

首先分析這個parent，ctrl點擊進入：

我們可以看它還依賴另一個parent，再次點擊進入：

可以看到里面有一個dependencyManagement(版本鎖定),里面配置了各個依賴的版本坐標資訊，當然也不僅僅是依賴

接下來分析spring-boot-starter-web,點進去查看，發現：

可以看到它的里面仍然引入了很多相關的依賴：(即相當如匯入了這一個依賴即匯入了以下依賴)

組態檔分類：

springboot是基于約定的，所以很多配置都有默認值，但如果想使用自己的配置替換默認配置的話，可以使用application.properties或者application.yml(application.yaml)進行配置，

propertie：

server.port=8080

yaml:

server:
  port: 8080

我們可以看到已經創建好的工程已經有一個已經創建好的組態檔，我們嘗試修改一下，并啟動工程

打開瀏覽器訪問：

加載組態檔中自定義內容：

如果同時在三個組態檔(application.properties、application.yml、application.yaml)中配置埠號那個會生效呢？

優先級從高到低依次為：application.properties > application.yml > application.yaml

yaml：

備注：使用idea等高級開發工會據時可忽略tab鍵問題，可直接使用

純量可直接認為是常量

自定義組態檔內容：

name: xiaowei

person:
  name: ${name}
  age: 18

address:
  - beijing
  - shanghai

address1: [hefei,zobo]

msg1: 'hello \n world'
msg2: "hello \n world"

測驗第一種方式：

@RestController
public class HelloController {

    @Value("${name}")
    private  String name;
    @RequestMapping("/hello2")
    public  String Hello2(){
        return name;
    }
}

測驗結果：

測驗陣列：

@RestController
public class HelloController {

    @Value("${address[0]}")
    private  String address1;
    @RequestMapping("/hello2")
    public  String Hello2(){
        return "我家在" + address1;
    }
 }

最終總結：組態檔內容一定切記加空格加空格加空格

第二種方式：

注意：在匯入environment的時候一定不要匯入錯了

public class HelloController {

    @Value("${msg1}")
    private  String msg1;

    @Value("${msg2}")
    private  String msg2;

    @Autowired
    private Environment env;

    @RequestMapping("/hello2")
    public  String Hello2(){

        System.out.println(env.getProperty("person.name"));
        System.out.println(env.getProperty("address[0]"));
        return "xinxi" + msg2;
    }
 }

第三種方式：注冊物件將對應屬性值注入

首先創建對應類：

package com.xiaowei.springbootinit;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-11-14:43
 */
//@Component 注解用于被spring識別為bean
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private int age;
    private  String name;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

測驗：

package com.xiaowei.springbootinit;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.core.env.Environment;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-09-21:55
 */
@RestController
public class HelloController {

    @Value("${msg1}")
    private  String msg1;

    @Value("${msg2}")
    private  String msg2;

    @Autowired
    private Environment env;
    @Autowired
    private Person person;

    @RequestMapping("/hello2")
    public  String Hello2(){

        System.out.println(env.getProperty("person.name"));
        System.out.println(env.getProperty("address[0]"));
        System.out.println(person);
        return "xinxi" + msg2;
    }
}

同時我們注意到在創建person Bean類加入@ConfigurationProperties的時候，有以下提示：

根據檔案提示，在pom.xml中加入以下依賴：

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

可以使得組態檔在添加屬性是有相應提示；

profile：

方式一：多profile檔案方式

在開發環境組態檔中修改埠號為：8081

在主組態檔添加: spring.profiles.active=dev

方式二：yml多檔案方式

即在一個yml檔案中以分隔符分成多個檔案，并為每個檔案起個名

---
server:
  port: 8081
spring:
  profiles: dev


---
server:
  port: 8082
spring:
  profiles: test


---
server:
  port: 8083

spring:
  profiles: pro
  
---
spring:
  profiles:
    active: dev

結果：

激活方式：虛擬機引數

測驗結果：

激活方式：命令列引數

測驗結果：

在非idea開發環境下如何傳入引數：

使用maven工程將專案打包：

在空白處按 shift 加滑鼠右鍵選擇打開Windows PowerShell ：

這樣即可給它加上引數

內部組態檔加載順序：

外部配置加載順序：

參考官方檔案：https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html

springboot整合redis:

1.創建springboot工程

2.選擇對應的依賴

redis未學，學完再看

springboot整合junit:

1.創建springboot工程

2.引入junit測驗的依賴(一般默認自帶)

3.創建對應業務類（service類）

4.創建對應測驗類

一個注意事項：

在創建測驗類的程序中如果對應service類的包名和test對應測驗類的包名相同，則@SpringBootTest注解中不需要添加classes屬性

springboot整合mybatis:

1.創建springboot工程

2.引入mybatis依賴，以及mysql驅動：

查看相應pom依賴檔案：

不同于之前的專案的start，這個是以mybatis開頭的，不是springboot官方提供的依賴，是mybatis提供的

3.在mybatis中新建一個資料庫：

4.創建對應的物體類：

5.創建對應資料庫的組態檔：

# datasource

spring:
  datasource:
    url: jdbc:mysql:///springboot
    username: root
    password: 123456
    driver-class-name: com.mysql.jdbc.Driver

6.1創建對應mapper檔案(注解方式)：

package com.xiaowei.springbootmybatis.mapper;

import com.xiaowei.springbootmybatis.domain.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-12-14:52
 */
@Mapper
public interface UserMapper {
    @Select("select * from t_user")
    public List<User> findAll();
}

6.2創建對應mapper檔案（組態檔方式）

package com.xiaowei.springbootmybatis.mapper;

import com.xiaowei.springbootmybatis.domain.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-12-15:05
 */
@Mapper
public interface UserXmlMapper {
    public List<User> findAll();
}

7.創建對應的mapper.xml檔案

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xiaowei.springbootmybatis.mapper.UserXmlMapper">
    <select id="findAll" resultType="user">
        select * from t_user
    </select>
</mapper>

8.配置mybatis對應組態檔：

# mybatis
mybatis:
  mapper-locations: classpath:mapper/*Mapper.xml #mapper映射檔案路徑
  type-aliases-package: com.xiaowei.springbootmybatis.domin
  #config-location: #指定mybatis的核心組態檔

9.創建測驗類測驗：

package com.xiaowei.springbootmybatis;

import com.xiaowei.springbootmybatis.domain.User;
import com.xiaowei.springbootmybatis.mapper.UserMapper;
import com.xiaowei.springbootmybatis.mapper.UserXmlMapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class SpringbootMybatisApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private UserXmlMapper userXmlMapper;
    @Test
   public void testFindAll() {
        List<User> list = userMapper.findAll();
        System.out.println(list);
    }

    @Test
    public void testFindAll1() {
        List<User> list = userXmlMapper.findAll();
        System.out.println(list);
    }

}

springboot自動配置原理分析：

condition：

condition是在spring4.0增加的條件判斷功能，通過這個可以實作選擇性的創建bean操作

實作需求1：

0.匯入jedis坐標：

dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

1.創建user的bean：

public class User {
}

2.嘗試是否能獲取這個bean :

package com.itheima.springbootcondition;

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

@SpringBootApplication
public class SpringbootConditionApplication {

    public static void main(String[] args) {
        //啟動SpringBoot的應用，回傳Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //獲取Bean
        Object user = context.getBean("user");
        

       
        System.out.println(user);

    }

}

3.創建條件判斷對應類：

package com.itheima.springbootcondition.condtion;

import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.env.Environment;
import org.springframework.core.type.AnnotatedTypeMetadata;

import java.util.Map;

public class ClassCondition implements Condition {
    /**
     *
     * @param context 背景關系物件，用于獲取環境，IOC容器，ClassLoader物件
     * @param metadata 注解元物件， 可以用于獲取注解定義的屬性值
     * @return
     */
    @Override
    //該方法判斷決定是否創建對應的bean
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
      
        //1.需求： 匯入Jedis坐標后創建Bean
        //思路：判斷redis.clients.jedis.Jedis.class檔案是否存在(匯入坐標即存在)
        boolean flag = true;
        try {
            Class<?> cls = Class.forName("redis.clients.jedis.Jedis");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;  

    }
}

4.寫user bean對應的J配置類：

package com.itheima.springbootcondition.config;

import com.itheima.springbootcondition.condtion.ClassCondition;
import com.itheima.springbootcondition.condtion.ConditionOnClass;
import com.itheima.springbootcondition.domain.User;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {

    @Bean
    //conditional內部指定創建的條件物件，回傳true創建物件，false不創建物件
    //@Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }
}

實作需求2：判斷位元組碼檔案可以動態指定

1.創建一個自定義注解：

上面三個注解為參考原始碼的元注解，第一個代表注解可以添加的范圍，第二個代表注解生效的時機，第三個代表生成javadoc的檔案

同時還需要加上內部指定創建的條件物件

package condition;

import org.springframework.context.annotation.Conditional;

import java.lang.annotation.*;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-13-20:09
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
String[] value();
}

2.修改config類：

@Configuration
public class UserConfig {
    @Bean
    //改為自己配置的注解，內部指定判斷位元組碼檔案
  @ConditionOnClass("redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}

3.修改條件判斷類：

public class ClassCondition implements Condition {
    /**
     *
     * @param context 背景關系物件，用于獲取環境，IOC容器，ClassLoader物件
     * @param metadata 注解元物件， 可以用于獲取注解定義的屬性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
       
       
        //2.需求： 匯入通過注解屬性值value指定坐標后創建Bean

        //獲取注解屬性值  value
        Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        //System.out.println(map);
        String[] value = https://www.cnblogs.com/xiaowei99/p/(String[]) map.get("value");

        boolean flag = true;
        try {
            for (String className : value) {
                Class<?> cls = Class.forName(className);
            }
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;

    }
}

切換內置web服務器：

springboot默認使用tomcat作為內置服務器，springboot提供了4種內置服務器供我們選擇，

tomcat是在web-start坐標內包含的，我們需要將其祛除，再引入別的web服務器：

按照下圖式操作，可查看依賴圖示：

打開如下，找到對應tomcat依賴，右鍵選擇exclude：

發現pom檔案有一些改動：

此時我們再引入需要的web服務器：

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

此時我們重啟服務：

@Enable注解：

SpringBoot中提供了很多Enable開頭的注解，這些注解都是用于動態啟用某些功能的，而其底層原理是使用@Import注 解匯入一些配置類，實作Bean的動態加載，

springboot不能直接獲取外部包里定義的bean

解決方案：

1.使用@componentScan掃描要引入外部包

eg: @ComponentScan("com.xiaowei.config")

2.可以使用@import注解，加載類，這些類都會被spring創建，并放入IOC容器

eg:@import(UserConfig.class)

3.將@import注解封裝

package com.itheima.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(UserConfig.class)
public @interface EnableUser {
}

在外部需要使用的地方，直接使用@EnableUser注解即可

@import注解：

@Enable*底層依賴于@Import注解匯入一些類，使用@Import匯入的類會被Spring加載到IOC容器中，而@Import提供4種用法：

① 匯入Bean

@Import(User.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
      User user = context.getBean(User.class);
        System.out.println(user);
  }

② 匯入配置類（可以匯入配置類中的所有類）

@Import(UserConfig.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);


      	User user = context.getBean(User.class);
        System.out.println(user);

        Role role = context.getBean(Role.class);
        System.out.println(role);
    }

③ 匯入 ImportSelector 實作類，一般用于加載組態檔中的類

實作類：

import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.itheima.domain.User", "com.itheima.domain.Role"};
    }
}

匯入：

@Import(MyImportSelector.class)
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

        User user = context.getBean(User.class);
        System.out.println(user);

        Role role = context.getBean(Role.class);
        System.out.println(role);
  }

④ 匯入 ImportBeanDefinitionRegistrar 實作類，

實作類：

package com.itheima.config;

import com.itheima.domain.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
        registry.registerBeanDefinition("user", beanDefinition);
    }
}

匯入

@Import({MyImportBeanDefinitionRegistrar.class})
@SpringBootApplication
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);

    	User user = context.getBean(User.class);
        System.out.println(user);
 }

@EnableAutoConfiguration注解

? @EnableAutoConfiguration 注解內部使用 @Import(AutoConfigurationImportSelector.class)來加載配置類，

? 組態檔位置：META-INF/spring.factories，該組態檔中定義了大量的配置類，當 SpringBoot 應用啟動時，會自動加載這些配置類，初始化Bean
? 并不是所有的Bean都會被初始化，在配置類中使用Condition來加載滿足條件的Bean

自定義starter:

實作步驟：

1.創建模塊：

redis-springboot-starter模塊添加依賴：

redis-springboot-autoconfigure模塊添加依賴：

在autoconfigure中配置

配置從用戶段獲取redis的主機名與埠號：

初始化jedis的bean：

創建檔案：

復制全名稱寫入檔案：

關閉mybatis依賴，啟用自定義starter依賴：

測驗是否成功：

springboot監聽機制：

ApplicationContextInitializer：

@Component
public class MyListenner implements ApplicationContextInitializer {
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("監聽器已生效！！！！！");
    }
}

SpringApplicationRunListener：

package com.xiaowei.springbootlistenner.listenner;

import org.springframework.boot.ConfigurableBootstrapContext;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.stereotype.Component;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-15-20:04
 */
@Component
public class MyListenner2 implements SpringApplicationRunListener {
    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("專案啟動中！");
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        System.out.println("環境準備中！！！");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件開始準備！！!");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件開始加載！！！");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件加載完成！！！");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("專案開始運行！！！！");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("專案啟動失敗！！!");
    }
}

CommandLineRunner：

package com.xiaowei.springbootlistenner.listenner;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-15-20:12
 */
@Component
public class MyListenner3 implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        System.out.println("runner!!!!");
    }
}

ApplicationRunner：

package com.xiaowei.springbootlistenner.listenner;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-15-20:14
 */
@Component
public class MyListenner4 implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        System.out.println("runner!!!!!");
    }
}

嘗試啟動專案后發現只有后兩種方案可以列印出來，前兩種需要配置；

如何配置前兩種：

在resource檔案夾下創建 META-INF/spring.factories,在其中配置 實作介面全類名=實作類的全類名

org.springframework.context.ApplicationContextInitializer=com.xiaowei.springbootlistenner.listenner.MyListenner

org.springframework.boot.SpringApplicationRunListener=com.xiaowei.springbootlistenner.listenner.MyListenner2

第一個實作沒有問題，我們發現第二個出錯：

經過分析原始碼，查看其他實作類得知需要一個初始化的構造器方法（將@component注解去除）：

package com.xiaowei.springbootlistenner.listenner;

import org.springframework.boot.ConfigurableBootstrapContext;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.SpringApplicationRunListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.core.env.ConfigurableEnvironment;

/**
 * @author xiaowei
 * @description:
 * @create 2021-09-15-20:04
 */

public class MyListenner2 implements SpringApplicationRunListener {
    public MyListenner2(SpringApplication application,String[] args) {
    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        System.out.println("專案啟動中！");
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
        System.out.println("環境準備中！！！");
    }

    @Override
    public void contextPrepared(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件開始準備！！!");
    }

    @Override
    public void contextLoaded(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件開始加載！！！");
    }

    @Override
    public void started(ConfigurableApplicationContext context) {
        System.out.println("背景關系物件加載完成！！！");
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        System.out.println("專案開始運行！！！！");
    }

    @Override
    public void failed(ConfigurableApplicationContext context, Throwable exception) {
        System.out.println("專案啟動失敗！！!");
    }
}

springboot啟動流程分析：

springboot監控：

SpringBoot自帶監控功能Actuator，可以幫助實作對程式內部運行情況監控，比如監控狀況、Bean加載情況、配置屬性、日志資訊等，

使用步驟：

在springboot里創建新模塊，匯入依賴：

啟動專案：

查看：

得到json字串，決議有：

health是專案的健康資訊，不暴露過多

在application.properties添加

#開啟健康資訊
management.endpoint.health.show-details=always

運行結果為：

開啟所有endpoint ：

在application.properties添加

#將所有的endpoint暴露出來
management.endpoints.web.exposure.include=*

查看：

Admin圖形化界面使用：

? Spring Boot Admin是一個開源社區專案，用于管理和監控SpringBoot應用程式，

? Spring Boot Admin 有兩個角色，客戶端(Client)和服務端(Server)，

? 應用程式作為Spring Boot Admin Client向為Spring Boot Admin Server注冊

? Spring Boot Admin Server 的UI界面將Spring Boot Admin Client的Actuator Endpoint上的一些監控資訊，

admin-server：

① 創建 admin-server 模塊

② 匯入依賴坐標 admin-starter-server

③ 在引導類上啟用監控功能@EnableAdminServer

admin-client：

① 創建 admin-client 模塊

② 匯入依賴坐標 admin-starter-client

③ 配置相關資訊：server地址等

④ 啟動server和client服務，訪問server

使用：

創建一個新模塊：

查看pom.xml檔案，引入了相關依賴：

在啟動類加上EnableAdminServer：

創建一個client類：

查看依賴;

在屬性中添加配置：

#執行admin.server地址
spring.boot.admin.client.url=http://localhost:9000

management.endpoint.health.show-details=always
management.endpoints.jmx.exposure.include=*

注意：server的埠號已改為9000

將兩個模塊都啟動，并在瀏覽器輸入：localhost：9000

同時在IDEA中我們也能直接看到endpoint相關的資訊：

springboot專案部署：

使用maven打包，默認打jar包；

如何打war包：在啟動類：

將pom.xml中打包方式改為 war，可以指定外部服務器

打包好后如何部署：

直接放到外部服務器（tomcat）的webapps中，啟動服務器即可

轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/300859.html

標籤：其他

上一篇：Jmeter-集合點【同步定時器】應用

下一篇：穿越時空，跟我一起探索云棲數字谷（2021云棲大會免費送票）