springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

2022-09-04 22:53:56

知识点梳理

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

课堂讲义

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

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

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高级:自动配置分析,事件监听,启动流程分析,监控,部署

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服务器

查看继承关系图

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

排除Tomcat

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

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高级:自动配置分析,事件监听,启动流程分析,监控,部署

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. 报错信息：

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

三种解决方案：

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类定义如下：

    springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

  • 配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean

    springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

    读取org.springframework.boot.autoconfigure.EnableAutoConfiguration对应的所有值

  • 并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

    springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

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

  1. 创建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);
    
    }
    
}
     

    springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

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. 获取初始化类、监听器类

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

13-SpringBoot流程分析-run

  1. 启动计时器

  2. 执行监听器

  3. 准备环境

  4. 打印banner：可以resource下粘贴自定义的banner

  5. 创建context

    refreshContext(context);

    执行refreshContext方法后才真正创建Bean

springBoot高级:自动配置分析,事件监听,启动流程分析,监控,部署

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

上一篇：Ombrophobic Bovines 分类： POJ 图论 最短路 查找 2015-08-10 20:32 2人阅读 评论(0) 收藏


下一篇：监听Web容器启动与关闭