springBoot高級:自動配置分析,事件監聽,啟動流程分析,監控,部署

知識點梳理

 

課堂講義

02-SpringBoot自動配置-@Conditional使用

 

 

Condition是Spring4.0后引入的條件化配置接口，通過實現Condition接口可以完成有條件的加載相應的Bean。

• 作用：根據條件，決定類是否加載到Spring IoC容器中

• 需求： 導入Jedis坐標后創建user對象

• 編寫ClassCondition，實現Condition接口

public class ClassCondition implements Condition {
    /**
     *
     * @param context 上下文對象。用於獲取環境，IOC容器，ClassLoader對象
     * @param metadata 注解元對象。 可以用於獲取注解定義的屬性值
     * @return
     */
    @Override
    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;
    }
}

 

• 引入jedis包依賴

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

   

• @Conditional要配合Condition的實現類（ClassCondition）進行使用，編寫UserConfig

@Configuration
public class UserConfig {
​
    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }
​
}

 

測試：ApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

@SpringBootApplication
public class SpringbootConditionApplication {
​
    public static void main(String[] args) {
        //啟動SpringBoot的應用，返回Spring的IOC容器
        ApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
​
        Object user = context.getBean("user");
        System.out.println(user);
    }
​
}

 

控制打印出user對象的內存地址，證明SpringIoC中有user對象

03-SpringBoot自動配置-自定義@ConditionOnClass

03.1 注解定義（了解）

1. 注解類型的聲明部分：

   注解在Java中，與類、接口、枚舉類似，因此其聲明語法基本一致，只是所使用的關鍵字有所不同@interface。在底層實現上，所有定義的注解都會自動繼承java.lang.annotation.Annotation接口。

   public @interface MyAnnotation {
   }

    

2. 注解類型的實現部分：

   根據我們在自定義類的經驗，在類的實現部分無非就是書寫構造、屬性或方法。但是在自定義注解中，其實現部分只能定義一個東西：注解類型元素（annotation type element）。

   public @interface MyAnnotation {
       public String name();
       int age();
       int[] array();
   }

    

   定義注解類型元素時需要注意如下幾點：

   1. 訪問修飾符必須為public，不寫默認為public；

   2. 該元素的類型只能是基本數據類型、String、Class、枚舉類型、注解類型（體現了注解的嵌套效果：ComponentScan）以及上述類型的一位數組；

   3. 該元素的名稱一般定義為名詞，如果注解中只有一個元素，請把名字起為value（后面使用會帶來便利操作）；

   4. ()不是定義方法參數的地方，也不能在括號中定義任何參數，僅僅只是一個特殊的語法；

   5. default代表默認值，值必須和第2點定義的類型一致；

   6. 如果沒有默認值，代表后續使用注解時必須給該類型元素賦值。

3. @Target

   @Target注解，是專門用來限定某個自定義注解能夠被應用在哪些Java元素上面的

   public enum ElementType {
       /** 類，接口（包括注解類型）或枚舉的聲明 */
       TYPE,
   ​
       /** 屬性的聲明 */
       FIELD,
   ​
       /** 方法的聲明 */
       METHOD,
   ​
       /** 方法形式參數聲明 */
       PARAMETER,
   ​
       /** 構造方法的聲明 */
       CONSTRUCTOR,
   ​
       /** 局部變量聲明 */
       LOCAL_VARIABLE,
   ​
       /** 注解類型聲明 */
       ANNOTATION_TYPE,
   ​
       /** 包的聲明 */
       PACKAGE
   }
   
   //MyAnnotation被限定只能使用在類、接口或方法上面
   @Target(value = {ElementType.TYPE,ElementType.METHOD})
   public @interface MyAnnotation {
       String name();
       int age() default 18;
       int[] array();
   }

    

4. @Retention

   @Retention注解，翻譯為持久力、保持力。即用來修飾自定義注解的生命力。

   常用：@Retention(RetentionPolicy.RUNTIME)

   注解的生命周期有三個階段：1、Java源文件階段；2、編譯到class文件階段；3、運行期階段。同樣使用了RetentionPolicy枚舉類型定義了三個階段：

   public enum RetentionPolicy {
       /**
        * （注解將被編譯器忽略掉）
        */
       SOURCE,
   ​
       /**
        * （注解將被編譯器記錄在class文件中，但在運行時不會被虛擬機保留，這是一個默認的行為）
        */
       CLASS,
   ​
       /**
        * （注解將被編譯器記錄在class文件中，而且在運行時會被虛擬機保留，因此它們能通過反射被讀取到）
        */
       RUNTIME
   }

    

5. @Documented

   @Documented注解，是被用來指定自定義注解是否能隨着被定義的java文件生成到JavaDoc文檔當中。

03.2 自定義@ConditionOnClass

需求：將類的判斷定義為動態的，判斷哪個字節碼文件存在可以動態指定。（了解）

1.自定義條件注解類，注意：此處@ConditionOnClass為自定義注解

import org.springframework.context.annotation.Conditional;
​
import java.lang.annotation.*;
​
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(ClassCondition.class)
public @interface ConditionOnClass {
    String[] value();
}

 

2.修改ClassCondition，動態獲取類名

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 = (String[]) map.get("value");
​
        boolean flag = true;
        try {
            for (String className : value) {
                Class<?> cls = Class.forName(className);
            }
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

 

3.修改UserConfig

@Configuration
public class UserConfig {
​
    @Bean
    @ConditionOnClass("com.alibaba.fastjson.JSON")
    public User user(){
        return new User();
    }
}

 

4.測試User對象的創建

@SpringBootApplication
public class SpringbootConditionApplication {
​
    public static void main(String[] args) {
        //啟動SpringBoot的應用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
​
        Object user = context.getBean("user");
        System.out.println(user);
    }
​
}

 

查看條件注解源碼

 

 

 

SpringBoot 提供的常用條件注解：

ConditionalOnProperty：判斷配置文件中是否有對應屬性和值才初始化Bean

• application.properties

  itcast=itheima

• UserConfig

  @Configuration
  public class UserConfig2 {
  ​
      @Bean
      @ConditionalOnProperty(name = "itcast",havingValue = "itheima")
      public User user2(){
          return new User();
      }
  ​
  }

   

ConditionalOnClass：判斷環境中是否有對應字節碼文件才初始化Bean

@Configuration
public class UserConfig3 {
​
    @Bean
    @ConditionalOnClass(name = "redis.clients.jedis.Jedis")
    //@ConditionalOnClass(Jedis.class)
    public User user3(){
        return new User();
    }
​
}

 

ConditionalOnMissingBean：判斷環境中沒有對應Bean才初始化Bean

04-切換SpringBoot項目內置web服務器

查看繼承關系圖

 

 

排除Tomcat

 

 

pom文件中的排除依賴效果

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <!--排除tomcat依賴-->
     <exclusions>
         <exclusion>
             <artifactId>spring-boot-starter-tomcat</artifactId>
             <groupId>org.springframework.boot</groupId>
         </exclusion>
     </exclusions>
</dependency>

 

Jetty：基於Java語言編寫的一個開源servlet容器，為Jsp和servlet提供了運行環境，可以迅速為一些獨立運行的Java應用提供網絡和web連接。

引入jetty的依賴

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

 

 

05-Enable注解原理(理解)

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

 

 

SpringBoot是否能直接獲取在其他工程中定義的Bean？編寫代碼測試：

1. 新建springboot-enable-other工程

2. UserConfig

   @Configuration
   public class UserConfig {
    
     @Bean
     public User user() {
           return new User();
     }
   }

    

3. 新建springboot-enable工程，pom中引入springboot-enable-other

   <dependency>
       <groupId>com.itheima</groupId>
       <artifactId>springboot-enable-other</artifactId>
       <version>0.0.1-SNAPSHOT</version>
   </dependency>

    

4. SpringbootEnableApplication

   @SpringBootApplication
   public class SpringbootEnableApplication {
   
       public static void main(String[] args) {
           ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
   
           //獲取Bean
           Object user = context.getBean("user");
           System.out.println(user);
           }
   }

    

5. 報錯信息： 

 

 

三種解決方案：

1.使用@ComponentScan掃描com.itheima.config包

@ComponentScan("com.itheima.config")
@SpringBootApplication
public class SpringbootEnableApplication {

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

        //獲取Bean
        Object user = context.getBean("user");
        System.out.println(user);
        }
}

 

2.可以使用@Import注解，加載類。這些類都會被Spring創建，並放入IOC容器

@Import(UserConfig.class)
@SpringBootApplication
public class SpringbootEnableApplication {

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

        //獲取Bean
        Object user = context.getBean("user");
        System.out.println(user);
        }
}

 

3.可以對Import注解進行封裝：在springboot-enable-other工程中新建 EnableUser注解類

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

 

修改springboot-enable工程中的SpringbootEnableApplication類

@EnableUser
@SpringBootApplication
public class SpringbootEnableApplication {
​
  public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
​
     //獲取Bean
        Object user = context.getBean("user");
        System.out.println(user);
​
    }
​
}

 

Enable注解底層原理是使用@Import注解實現Bean的動態加載

 

06-@Import詳解（了解）

@Enable*底層依賴於@Import注解導入一些類，使用@Import導入的類會被Spring加載到IOC容器中。

@Import提供4中用法：

①導入Bean：@Import(User.class)

②導入配置類：@Import(UserConfig.class)

③導入 ImportSelector 實現類。一般用於加載配置文件中的類：@Import(MyImportSelector.class)

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

 

④導入 ImportBeanDefinitionRegistrar 實現類。

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

 

SpringbootEnableApplication測試代碼

/**
 * Import4中用法：
 *  1. 導入Bean
 *  2. 導入配置類
 *  3. 導入ImportSelector的實現類。
 *  4. 導入ImportBeanDefinitionRegistrar實現類
 */

//@Import(User.class)
//@Import(UserConfig.class)
//@Import(MyImportSelector.class)
//@Import({MyImportBeanDefinitionRegistrar.class})

@SpringBootApplication
public class SpringbootEnableApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
    
        /*//獲取Bean
        Object user = context.getBean("user");
        System.out.println(user);*/
    
        /*User user = context.getBean(User.class);
        System.out.println(user);
    
        Role role = context.getBean(Role.class);
        System.out.println(role);*/
    
      /*  Object user = context.getBean("user");
        System.out.println(user);*/
     Map<String, User> map = context.getBeansOfType(User.class);
        System.out.println(map);
    }

}

 

@EnableAutoConfiguration中使用的是第三種方式：@Import(AutoConfigurationImportSelector.class)

 

07@EnableAutoConfiguration詳解（了解）

• @EnableAutoConfiguration 注解內部使用 @Import(AutoConfigurationImportSelector.class)來加載配置類。 AutoConfigurationImportSelector類定義如下：

  

   

   

• 配置文件位置：META-INF/spring.factories，該配置文件中定義了大量的配置類，當 SpringBoot 應用啟動時，會自動加載這些配置類，初始化Bean

  

   

   

  讀取org.springframework.boot.autoconfigure.EnableAutoConfiguration對應的所有值

• 並不是所有的Bean都會被初始化，在配置類中使用Condition來加載滿足條件的Bean

  

   

   

08-自定義starter步驟分析

需求：自定義redis-starter，要求當導入redis坐標時，SpringBoot自動創建Jedis的Bean。

步驟：

①創建 redis-spring-boot-autoconfigure 模塊

②創建 redis-spring-boot-starter 模塊,依賴 redis-spring-boot-autoconfigure的模塊

③在 redis-spring-boot-autoconfigure 模塊中初始化 Jedis 的 Bean。並定義META-INF/spring.factories 文件

④在測試模塊springboot-enable中引入自定義的 redis-spring-boot-starter 依賴，測試獲取 Jedis 的Bean，操作 redis。

09-自定義starter實現

1. 創建redis-spring-boot-autoconfigure配置工程：

• 創建RedisProperties配置文件參數綁定類

  @ConfigurationProperties(prefix = "redis")
  public class RedisProperties {
      
      private String host = "localhost";
      private int port = 6379;
      
      public String getHost() {
          return host;
      }
  
      public void setHost(String host) {
          this.host = host;
      }
  
      public int getPort() {
          return port;
      }
  
      public void setPort(int port) {
          this.port = port;
      }
  }

   

• 創建RedisAutoConfiguration自動配置類

  @Configuration
  @EnableConfigurationProperties(RedisProperties.class)
  @ConditionalOnClass(Jedis.class)
  public class RedisAutoConfiguration {
  
      /**
       * 提供Jedis的bean
       */
      @Bean
      @ConditionalOnMissingBean(name = "jedis")
      public Jedis jedis(RedisProperties redisProperties) {
          System.out.println("RedisAutoConfiguration....");
          return new Jedis(redisProperties.getHost(), redisProperties.getPort());
      }
  }

   

• 在resource目錄下創建META-INF文件夾並創建spring.factories。注意：”\ “是換行使用的

  org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    com.itheima.redis.config.RedisAutoConfiguration

   

2. 創建redis-spring-boot-starter工程：pom文件中引入redis-spring-boot-autoconfigure

   <!--引入configure-->
   <dependency>
       <groupId>com.itheima</groupId>
       <artifactId>redis-spring-boot-autoconfigure</artifactId>
       <version>0.0.1-SNAPSHOT</version>
   </dependency>

    

10-測試自定義starter

1. 在springboot-enable工程中引入自定義的redis的starter

   <!--自定義的redis的starter-->
   <dependency>
       <groupId>com.itheima</groupId>
       <artifactId>redis-spring-boot-starter</artifactId>
       <version>0.0.1-SNAPSHOT</version>
   </dependency>

    

2. 在springboot-enable中的application.properties中的配置參數

   redis.host=127.0.0.1
   redis.port=6379

    

3. 在SpringbootEnableApplication啟動類中測試

   @SpringBootApplication
   public class SpringbootEnableApplication {
   ​
       public static void main(String[] args) {
           ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
   ​
           Jedis jedis = context.getBean(Jedis.class);
           System.out.println(jedis);
   ​
           jedis.set("name","itcast");
   ​
           String name = jedis.get("name");
           System.out.println(name);
       }
   }

    

   

    

    

11-SpringBoot事件監聽(了解)

11.1 事件監聽機制

Java中的事件監聽機制主要由事件源、事件對象、事件監聽器三個部分組成。

1. 事件對象（event object）

   一般繼承自java.util.EventObject類，封裝了事件源對象以及與事件相關的信息。它是在事件源和事件監聽器

   之間傳遞信息的。

2. 事件源（event source）：任意對象Object

   具體的事件源，比如說，你點擊一個button，那么button就是event source，要想使button對某些事件進行

   響應，你就需要注冊特定的listener。

3. 事件監聽器（event listener）

   實現java.util.EventListener接口,需要注冊在事件源上才能被調用。它監聽事件，並進行事件處理或者轉發。

11.2 SpringBoot 監聽機制

SpringBoot 的監聽機制，其實是對Java提供的事件監聽機制的封裝。

SpringBoot在項目啟動時會對幾個監聽器進行回調，我們可以實現這些監聽器接口在項目啟動時完成一些操作。

• 實現ApplicationContextInitializer接口

  public class MyApplicationContextInitializer implements ApplicationContextInitializer {
      @Override
      public void initialize(ConfigurableApplicationContext applicationContext) {
          System.out.println("ApplicationContextInitializer....initialize");
      }
  }

   

MyApplicationContextInitializer的使用要在resource文件夾下添加META-INF/spring.factories

org.springframework.context.ApplicationContextInitializer=com.itheima.springbootlistener.listener.MyApplicationContextInitializer

 

• 實現SpringApplicationRunListener接口：必須添加構造方法

  public class MySpringApplicationRunListener implements SpringApplicationRunListener {
  ​
      public MySpringApplicationRunListener(SpringApplication application, String[] args) {
      }
  ​
      @Override
      public void starting() {
          System.out.println("starting...項目啟動中");
      }
  ​
      @Override
      public void environmentPrepared(ConfigurableEnvironment environment) {
          System.out.println("environmentPrepared...環境對象開始准備");
      }
  ​
      @Override
      public void contextPrepared(ConfigurableApplicationContext context) {
          System.out.println("contextPrepared...上下文對象開始准備");
      }
  ​
      @Override
      public void contextLoaded(ConfigurableApplicationContext context) {
          System.out.println("contextLoaded...上下文對象開始加載");
      }
  ​
      @Override
      public void started(ConfigurableApplicationContext context) {
          System.out.println("started...上下文對象加載完成");
      }
  ​
      @Override
      public void running(ConfigurableApplicationContext context) {
          System.out.println("running...項目啟動完成，開始運行");
      }
  ​
      @Override
      public void failed(ConfigurableApplicationContext context, Throwable exception) {
          System.out.println("failed...項目啟動失敗");
      }
  }

   

  META-INF/spring.factories配置：

  org.springframework.boot.SpringApplicationRunListener=\
    com.itheima.springbootlistener.listener.MySpringApplicationRunListener

   

• 實現CommandLineRunner接口

  @Component
  public class MyCommandLineRunner implements CommandLineRunner {
      @Override
      public void run(String... args) throws Exception {
          System.out.println("CommandLineRunner...run");
          System.out.println(Arrays.asList(args));
      }
  }

   

• 實現ApplicationRunner接口

  /**
   * 當項目啟動后執行run方法。
   */
  @Component
  public class MyApplicationRunner implements ApplicationRunner {
      @Override
      public void run(ApplicationArguments args) throws Exception {
          System.out.println("ApplicationRunner...run");
          System.out.println(Arrays.asList(args.getSourceArgs()));
      }
  } 

   

自定義監聽器的啟動時機：

MyApplicationRunner和MyCommandLineRunner都是當項目啟動后執行，使用@Component放入容器即可使用

 

12-SpringBoot流程分析-初始化

1. 配置啟動引導類（判斷是否有啟動主類）

2. 判斷是否是Web環境

3. 獲取初始化類、監聽器類

 

 

13-SpringBoot流程分析-run

1. 啟動計時器

2. 執行監聽器

3. 准備環境

4. 打印banner：可以resource下粘貼自定義的banner

5. 創建context

   refreshContext(context);

   執行refreshContext方法后才真正創建Bean

 

 

 

14-SpringBoot監控-actuator基本使用

①導入依賴坐標

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

 

②訪問http://localhost:8080/actuator，顯示結果如下：

{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-component-instance":{
            "href":"http://localhost:8080/actuator/health/{component}/{instance}",
            "templated":true
        },
        "health-component":{
            "href":"http://localhost:8080/actuator/health/{component}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        }
    }
}

 

http://localhost:8080/actuator/info，顯示結果如下：

在application.properties中配置

info.name=zhangsan
info.age=23

 

http://localhost:8080/actuator/health

# 開啟健康檢查詳細信息
management.endpoint.health.show-details=always

 

顯示結果如下：

{
    "status":"UP",
    "details":{
        "diskSpace":{
            "status":"UP",
            "details":{
                "total":159579508736,
                "free":13558104064,
                "threshold":10485760
            }
        },
        "redis":{
            "status":"UP",
            "details":{
                "version":"2.4.5"
            }
        }
    }
}

 

15-SpringBoot監控-actuator開啟所有endpoint

開啟所有endpoint：在application.properties中配置：

management.endpoints.web.exposure.include=*

開啟所有endpoint的返回結果如下：

{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "templated":false
        },
        "auditevents":{
            "href":"http://localhost:8080/actuator/auditevents",
            "templated":false
        },
        "beans":{
            "href":"http://localhost:8080/actuator/beans",
            "templated":false
        },
        "caches-cache":{
            "href":"http://localhost:8080/actuator/caches/{cache}",
            "templated":true
        },
        "caches":{
            "href":"http://localhost:8080/actuator/caches",
            "templated":false
        },
        "health-component-instance":{
            "href":"http://localhost:8080/actuator/health/{component}/{instance}",
            "templated":true
        },
        "health":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-component":{
            "href":"http://localhost:8080/actuator/health/{component}",
            "templated":true
        },
        "conditions":{
            "href":"http://localhost:8080/actuator/conditions",
            "templated":false
        },
        "configprops":{
            "href":"http://localhost:8080/actuator/configprops",
            "templated":false
        },
        "env":{
            "href":"http://localhost:8080/actuator/env",
            "templated":false
        },
        "env-toMatch":{
            "href":"http://localhost:8080/actuator/env/{toMatch}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        },
        "loggers":{
            "href":"http://localhost:8080/actuator/loggers",
            "templated":false
        },
        "loggers-name":{
            "href":"http://localhost:8080/actuator/loggers/{name}",
            "templated":true
        },
        "heapdump":{
            "href":"http://localhost:8080/actuator/heapdump",
            "templated":false
        },
        "threaddump":{
            "href":"http://localhost:8080/actuator/threaddump",
            "templated":false
        },
        "metrics-requiredMetricName":{
            "href":"http://localhost:8080/actuator/metrics/{requiredMetricName}",
            "templated":true
        },
        "metrics":{
            "href":"http://localhost:8080/actuator/metrics",
            "templated":false
        },
        "scheduledtasks":{
            "href":"http://localhost:8080/actuator/scheduledtasks",
            "templated":false
        },
        "httptrace":{
            "href":"http://localhost:8080/actuator/httptrace",
            "templated":false
        },
        "mappings":{
            "href":"http://localhost:8080/actuator/mappings",
            "templated":false
        }
    }
}

 

16-Spring Boot Admin

Spring Boot Admin是一個開源社區項目，用於管理和監控SpringBoot應用程序。 應用程序作為Spring Boot Admin Client向為Spring Boot Admin Server注冊（通過HTTP）。UI是的AngularJs應用程序，展示Spring Boot Admin Client的Actuator端點上的一些監控。

SpringBoot Admin 有兩個角色，客戶端(Client)和服務端(Server)。

以下為創建服務端和客戶端工程步驟：

16.1-部署服務端

admin-server：

①創建 admin-server 模塊

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

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
    <version>2.1.5</version>
</dependency>

 

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

@EnableAdminServer
@SpringBootApplication
public class SpringbootAdminServerApplication {
​
    public static void main(String[] args) {
        SpringApplication.run(SpringbootAdminServerApplication.class, args);
    }
​
}

 

application.properties

server.port=9000

 

 

16.2-啟動客戶端

admin-client：

①創建 admin-client 模塊

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

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-client</artifactId>
    <version>2.1.5</version>
</dependency>

 

③配置相關信息：server地址等

# 執行admin.server地址
spring.boot.admin.client.url=http://localhost:9000
​
management.endpoint.health.show-details=always
management.endpoints.web.exposure.include=*

 

④啟動server和client服務，訪問server：http://localhost:9000/

 

 

17-SpringBoot項目部署

SpringBoot 項目開發完畢后，支持兩種方式部署到服務器：

第一種方式：jar包(官方推薦)，mvn package

第二種方式：war包，更改pom文件中的打包方式為war（了解）

<packaging>war</packaging>

 

修改啟動類

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
​
@SpringBootApplication
public class SpringbootDeployApplication extends SpringBootServletInitializer {
​
    public static void main(String[] args) {
        SpringApplication.run(SpringbootDeployApplication.class, args);
    }
  
​
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(SpringbootDeployApplication.class);
    }
}

 

指定打包的名稱

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

 

測試地址：http://localhost:8080/springboot/user/findAll