SpringBoot高级

已于 2024-03-17 14:57:30 修改
阅读量1.4k 收藏 23
点赞数 41
分类专栏： Springboot 文章标签： spring boot 后端 java mysql mybatis spring
于 2024-03-15 15:04:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61611746/article/details/134901251
版权

1.自动配置-Condition

Condition是Spring4.0后引入的条件化配置接口，通过实现Condition接口可以完成有条件的加载相应的Bean

进入 SpringBoot 启动类，点击进入 run()

可以看到这个方法是有返回值的，返回值为 ConfigurableApplicationContext

这个返回值就是 IOC 容器

通过获取 run() 的返回值再获取容器中的bean

导入redis起步依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);

        //获取Bean，RedisTemplate
        Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);
    }

案例

在Spring的IOC容器中有一个User的Bean，现要求：
    
    1.导入Jedis坐标后，加载该Bean，没导入，则不加载

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
package com.domain;

public class User {
}

package com.config;

import com.condition.ClassCondition;
import com.domain.User;
import org.springframework.boot.autoconfigure.security.SecurityProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

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

package com.condition;

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

public class ClassCondition implements Condition {

    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        //需求：导入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;
    }
}

package com.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，RedisTemplate
        /*Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);*/

        Object user = context.getBean("user");
        System.out.println(user);
    }

}

如果把 pom.xml 文件中的 Jedis 坐标注释掉

那么Spring 容器则不会创建 User 对应的 Bean，运行启动类就获取不到 user 对象

2.将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定

package com.condition;

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();
}

package com.condition;

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

import java.util.Map;
import java.util.Objects;

public class ClassCondition implements Condition {
    //context  上下文对象。用于获取环境，IOC容器，ClassLoader对象
    //metadata  注解元对象。可以用于获取注解定义的属性值
    /*@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;
    }*/
    @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;
    }
}

package com.config;

import com.condition.ConditionOnClass;
import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {
    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("redis.clients.jedis.Jedis")
    public User user(){
        return new User();
    }
}

package com.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，RedisTemplate
        /*Object redisTemplate = context.getBean("redisTemplate");
        System.out.println(redisTemplate);*/

        Object user = context.getBean("user");
        System.out.println(user);
    }

}

Condition-小结

自定义条件

1.定义条件类：自定义类实现 Condition 接口，重写 matches 方法，在 matches 方法中进行逻辑判断，返回 boolean 值。matches 方法两个参数：

    context：上下文对象，可以获取属性值、类加载器、BeanFactory 等

    metadata：元数据对象，用于获取注解属性

2.判断条件：在初始化 Bean 时，使用 @Conditional(条件类.class) 注解

SpringBoot 提供的常用条件注解：

ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean

ConditionalOnClass：判断内存在中是否有对应字节码文件才初始化Bean (jar 包有没有导入)

ConditionalOnMissingBean：判断容器中没有对应Bean才初始化Bean(执行这个方法时要求所依赖的bean 已经被初始化了)

2.切换内置web服务器

SpringBoot的web环境中默认使用tomcat作为内置服务器，其实SpringBoot提供了4种内置服务器供我们选择，我们可以很方便的进行切换

<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的依赖-->
<dependency>
    <artifactId>spring-boot-starter-jetty</artifactId>
    <groupId>org.springframework.boot</groupId>
</dependency>

3.Enable注解原理 

pringBoot中提供了很多Enable开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注解导入一些配置类，实现Bean的动态加载

package com.springbootenable;

import com.config.EnableUser;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * @ComponentScan 扫描范围：当前引导类所在包及其子包
 *
 * com.springbootenable
 * com.config
 * //1.使用@ComponentScan扫描com.config包
 * //2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
 * //3.可以对Import注解进行封装。
 */

//@ComponentScan("com.config")
//@Import(UserConfig.class)
@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);
    }
}

pom中引入springboot-enable-other

记得在enable-other中打包（install）

        <pendency>
            <groupId>com</groupId>
            <artifactId>springboot-enable-other</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
package com.domain;

public class User {
}

package com.config;

import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

package com.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

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

SpringBoot不能直接获取在其他工程中定义的Bean

原因：@ComponentScan 扫描范围：当前引导类所在包及其子包

三种解决方案：

1.使用@ComponentScan扫描com.lichee.config包

2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器

3.可以对Import注解进行封装

注：Enable注解底层原理是使用@Import注解实现Bean的动态加载

4.@Import详解

@Enable*底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：

1.导入Bean

2.导入配置类

3.导入 ImportSelector 实现类。一般用于加载配置文件中的类

4.导入 ImportBeanDefinitionRegistrar 实现类。

package com.domain;

public class Role {
}

package com.config;

import com.domain.Role;
import com.domain.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

 导入Bean @Import(User.class)

导入配置类 @Import(UserConfig.class)

导入 ImportSelector 实现类 @Import(MyImportSelector.class)

package com.springbootenable;

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.domain.User", "com.domain.Role"};
    }
}

导入 ImportBeanDefinitionRegistrar 实现类。@Import({MyImportBeanDefinitionRegistrar.class})

package com.springbootenable;

import com.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);
    }
}

SpringbootEnableApplication测试代码 

package com.springbootenable;

import com.config.EnableUser;
import com.domain.Role;
import com.domain.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Import;

import java.util.Map;

/**
 - 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);*/
    }
}

5.@EnableAutoConfiguration详解 

@EnableAutoConfiguration 注解内部使用@Import(AutoConfigurationImportSelector.class)来加载配置类

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

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

6.自定义starter配置

需求：自定义redis-starter。要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean

步骤分析

1.创建 redis-spring-boot-autoconfigure 模块

2.创建 redis-spring-boot-starter 模块,依赖 redis-spring-boot-autoconfigure的模块

3.在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。并定义META-INF/spring.factories 文件

4.在测试模块中引入自定义的 redis-starter 依赖，测试获取 Jedis 的Bean，操作 redis

实现

创建redis-spring-boot-starter工程

pom文件中引入redis-spring-boot-autoconfigure

        <!--引入configure-->
        <dependency>
            <groupId>com</groupId>
            <artifactId>redis-springboot-autoconfigure</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>

创建redis-spring-boot-autoconfigure配置工程

@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;
    }
}
package com.springbootautoconfigure;

import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    /**
     * 提供Jedis的bean
     */
    @Bean
    public RedisProperties.Jedis jedis(RedisProperties redisProperties) {
        return new RedisProperties.Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

在resource目录下创建META-INF文件夹并创建spring.factories

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

注意：”\ “是换行使用的 

在springboot-enable工程中引入自定义的redis的starter

<!--自定义的redis的starter-->
<dependency>
    <groupId>com</groupId>
    <artifactId>redis-springboot-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

在SpringbootEnableApplication启动类中测试

    Jedis jedis = context.getBean(Jedis.class);
    System.out.println(jedis);

测试springboot-enable工程中的application.properties中的配置参数

redis.port=6666

使用注解完成有条件加载配置类

@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());
    }
}

7.SpringBoot事件监听 

Java中的事件监听机制

事件：Event，继承 java.util.EventObject 类的对象

事件源：Source ，任意对象Object

监听器：Listener，实现 java.util.EventListener 接口 的对象

SpringBoot 在项目启动时，会对几个监听器进行回调，我们可以实现这些监听器接口，在项目启动时完成一些操作

ApplicationContextInitializer、

SpringApplicationRunListener、

CommandLineRunner、

ApplicationRunner

package com.springbootlistener.listener;

import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;

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

package com.springbootlistener.listener;

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

import java.util.Arrays;

/**
 * 当项目启动后执行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()));
    }
}

package com.springbootlistener.listener;

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

import java.util.Arrays;

@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));
    }
}

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

org.springframework.context.ApplicationContextInitializer=com.springbootlistener.listener.MyApplicationContextInitializer
org.springframework.boot.SpringApplicationRunListener=com.springbootlistener.listener.MySpringApplicationRunListener

MySpringApplicationRunListener的使用要添加构造器 

package com.springbootlistener.listener;

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

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...项目启动失败");
    }
}

8.SpringBoot流程分析-初始化 

配置启动引导类（判断是否有启动主类）

判断是否是Web环境

获取初始化类、监听器类

9.SpringBoot流程分析-run

1.启动计时器

2.执行监听器

3.准备环境

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

5.创建context

refreshContext(context);

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

10.SpringBoot监控-actuator基本使用 

监控概述

SpringBoot自带监控功能Actuator，可以帮助实现对程序内部运行情况监控，比如监控状况，Bean加载情况，配置属性，日志信息等

监控使用

1.导入依赖坐标

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

2.访问http://localhost:8080/acruator

{
    "_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
        }
    }
}

在application.properties中配置

info.name=zhangsan
info.age=23

http://localhost:8080/actuator/info

开启健康检查详细信息

management.endpoint.health.show-details=always

{
    "status":"UP",
    "components":{
        "diskSpace":{
            "status":"UP",
            "details":{
                "total":256048623616,
                "free":41103265792,
                "threshold":10485760,
                "exists":true
            }
        },
        "ping":{
            "status":"UP"
        }
    }
}

11.SpringBoot监控-actuator开启所有endpoint

开启所有endpoint

在application.properties中配置：

#将所有的监控endpoint暴露出来
management.endpoints.web.exposure.include=*
{
    "_links":{
        "self":{
            "href":"http://localhost:8080/actuator",
            "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":{
            "href":"http://localhost:8080/actuator/health",
            "templated":false
        },
        "health-path":{
            "href":"http://localhost:8080/actuator/health/{*path}",
            "templated":true
        },
        "info":{
            "href":"http://localhost:8080/actuator/info",
            "templated":false
        },
        "conditions":{
            "href":"http://localhost:8080/actuator/conditions",
            "templated":false
        },
        "configprops":{
            "href":"http://localhost:8080/actuator/configprops",
            "templated":false
        },
        "configprops-prefix":{
            "href":"http://localhost:8080/actuator/configprops/{prefix}",
            "templated":true
        },
        "env":{
            "href":"http://localhost:8080/actuator/env",
            "templated":false
        },
        "env-toMatch":{
            "href":"http://localhost:8080/actuator/env/{toMatch}",
            "templated":true
        },
        "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
        },
        "mappings":{
            "href":"http://localhost:8080/actuator/mappings",
            "templated":false
        }
    }
}

12.SpringBoot监控-springboot admin图形化界面使用 

SpringBoot 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：

1创建 admin-server 模块

2导入依赖坐标 admin-starter-server

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

3.在引导类上启用监控功能@EnableAdminServer

package com.springbootadminserver;

import de.codecentric.boot.admin.server.config.EnableAdminServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

admin-client：

1.创建 admin-client 模块

2.导入依赖坐标 admin-starter-client

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

3.配置相关信息：server地址等

server的application.properties

server.port=9000

client的

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

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

4.启动server和client服务，访问server

http://localhost:9000/applications

idea中也有这样的功能

13.SpringBoot部署

SpringBoot 项目开发完毕后，支持两种方式部署到服务器：

1.jar包(官方推荐)

2.war包

不修改则默认为打jar包

更改pom文件中的打包方式为war

修改启动类

package com.springbootdeploy;

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);
    }
}

packaging改为war 

    <name>springboot-deploy</name>
    <description>springboot-deploy</description>
    <packaging>war</packaging>

指定打包的名称

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

打出的war包名就为springboot 

天演L
关注
专栏目录
springboot高级-后8章-源码、资料、课件.rar
08-31
"springboot高级-后8章-源码、资料、课件.rar"这个压缩包文件，显然包含了尚硅谷教育机构关于SpringBoot高级主题的深入学习资源，包括源码、相关资料和课件。下面将对这些章节涉及的知识点进行详细阐述。 1. **缓存...
加深难度-对标大厂SpringBoot高级应用特训 SpringBoot开发实践与高级应用
06-16
课程围绕着SpringBoot开发实践和SpringBoot高级应用两个主题展开，是真正意义上的大厂级开发技术，同时技术拥有很强的实用性，学习完成可以快速的运用在工作中，实战性非常强。 (1)\开发实践；目录中文件数:28个 ...
SpringBoot高级教程
阿巴阿巴
04-02 1107
1、异步处理同步机制[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nOPJYrHD-1680443179350)(E:\工作文档\SpringBoot\images2\09.同步.png)]并发机制[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bq7eYDcP-1680443179352)(E:\工作文档\SpringBoot\images2\10.异步.png)]消息队列机制。
SpringBoot高级用法
酸奶盖儿的博客
10-30 966
1.SpringBoot高级用法 1.1 关于SpringBoot配置文件的说明 1.1.1 properties说明 1.语法: k-v结构 key=value 2.数据类型: 默认是String数据类型 不要添加多余的""号 3.字符数据类型: properties的默认的加载的编码格式为ISO-8859-1 所以添加中文是需要字符转意. 4.缺点: 所有的key都必须手动的编辑 没有办法复用 所以引入了yml配置 1.1.2 YML 配置文件说明 1.语法 K-V结构 写法上 key:val
SpringBoot 高级特性
Mr_changxin的博客
12-02 1163
SpringBoot 高级特性以及SpringBoot的整个执行流程
自学SpringBoot高级篇
TotoroChinchilla的博客
08-03 231
在SpringBoot基础篇的基础上再加深学习
SpringBoot高级特性
越努力越幸运的博客
09-23 805
文章目录SpringBoot高级特性1、Profile1.1、定制我们不同环境下的配置文件1.2、定制我们不同环境下的类和方法1.3、Profile分组2、外部化配置2.1 SpringBoot常用外部化配置源2.2 SpringBoot配置源的优先级2.2 SpringBoot配置文件的查找顺序和加载顺序 SpringBoot高级特性 1、Profile 1.1、定制我们不同环境下的配置文件 Profile主要用于环境切换。让我们在不同的环境下（比如测试和生产环境）能快速地切换所需的配置等等。 怎么用呢？
SpringBoot高级原理详解
m0_69266818的博客
05-25 387
详细介绍了springboot中注解的底层原理，还有健康监控，@lombok注解
SpringBoot高级应用
Pigeon
09-23 557
1.创建工程 **创建SpringBoot项目的方式② Maven→SpringBoot pom文件CV 只需要复制除了坐标之外的内容 此方法适用于网不好的情况 然后添加启动类....... arg是jvm进行的参数的传递.java 默认值 环境分割 需求：需要端口号不同 实现代码： #指定环境的默认配置 spring: profiles: active: prod --- #为环境定义名称 server: port: 8080 spring: ...
SpringBoot高级进阶
qq_42082278的博客
12-27 485
111
springboot高级笔记
weixin_44771582的博客
02-11 310
https://niceseason.github.io/2020/04/18/springboot
SpringBoot高级特性揭秘
06-13
Spring Boot的设计目的是用来简化Spring应用的初始搭建以及开发过程，默认帮我们做了很多“地下工作”，是一个集大成的框架，但对于很多开发者来说它也是大包大揽，运行原理说不清道不明，可以说SpringBoot是真正的...
Spring Boot2.0之九 使用EasyExcel导出Excel
sinat_31986807的博客
11-06 446
SpringBoot项目实现Excel文件导出功能，可以使用alibaba开源项目EasyExcel实现。
Java项目实战II基于Spring Boot的药店管理系统的设计与实现（开发文档+数据库+源码）
2401_86524610的博客
11-06 668
随着医疗行业的快速发展和人们对健康需求的日益增长，药店管理系统的智能化和高效化成为提升服务质量的关键。为了应对这一挑战，我们设计并实现了一套基于Spring Boot的药店管理系统。该系统充分利用Spring Boot框架的轻量级、高并发和易扩展特性，为药店提供了全面的药品管理、销售记录、库存监控以及客户信息管理等功能。通过该系统，药店能够实时掌握药品库存情况，优化采购计划，减少库存积压，提高资金利用率。
Spring Boot驱动的多维分类知识管理系统
2401_85439108的博客
11-06 905
关于程序的数据结构设计，数据的字段设计，为了更好的、更规范的使用数据库，在数据库里进行了字段的设计挑选。用我的话来理解，就是 Spring Boot 其实不是什么新的框架，它默认配置了很多框架的使用方式，就像 Maven 整合了所有的 Jar 包，Spring Boot 整合了所有的框架。通过网络进行文章的转移展示，可以让用户和管理员都能感受到互联网的魅力，让用户解除了地理的远近的限制和降低欣赏时间的成本。开发技术：开发技术部分主要还是介绍开发的平台，使用的技术与开发的语言等内容。
Spring Boot框架下的知识管理与多维分类
2401_85702623的博客
11-06 1106
那么在分析用户这个实体的时候，都会设计出它的属性，有最基本的登录程序的账号属性，有用户的姓名属性，有用户的电话或联系地址属性等内容。在上述内容中，已经设计出相应的E-R模型，就可以在数据库里面根据各个实体创建相应的数据表，不过在初次使用数据库工具的时候，是需要创建一个针对程序的数据库文件，有了此步操作之后，才在刚创建的数据库文件里面创建数据表，创建数据表需要涉及到字段的设计，主键的设计，字段长度与类型的设计等内容，只有设计好的数据表结构才可以按照此规则存放对应的程序数据。
Spring Boot框架：计算机课程管理的工程认证之光
最新发布
2401_85339615的博客
11-10 654
同时，一个大型的计算机网站系统，必须有一个正确的设计指导思想，通过合理选择数据结构、网络结构、操作系统以及开发环境，构成一个完善的网络体系结构，才能充分发挥计算机信息管理的优势。如果采用电子化的存储方式就会带来很大的改善，而且给用户的查询带来了很大便利，因此设计一个基于工程教育认证的计算机课程管理平台刻不容缓，能够提高信息的管理水平。开发合适的基于工程教育认证的计算机课程管理平台，可以方便管理人员对基于工程教育认证的计算机课程管理平台的管理，提高信息管理工作效率及查询效率，有利于更好的为人们服务。
springboot高级应用
03-27
作为一名AI语言模型，我无法具体体验Springboot高级应用，但我可以为你提供一些Springboot高级应用的示例和建议： 1. 使用Spring Cloud构建分布式微服务架构：Spring Cloud是基于Spring Boot的微服务架构开发工具包，它提供了一系列开箱即用的分布式系统模式，如服务注册与发现、配置中心、断路器、网关等，帮助开发者快速构建分布式应用。 2. 基于Spring Security实现安全控制：Spring Security是一套基于Spring的安全框架，它提供了一系列安全特性，如身份认证、授权、加密等，可以帮助开发者构建安全可靠的应用系统。 3. 使用Spring Data JPA实现数据访问：Spring Data JPA是Spring框架的一个子项目，它为开发者提供了一套简单易用的数据访问API，支持多种数据源，如关系型数据库、NoSQL数据库等。 4. 使用Spring Cache实现缓存：Spring Cache是Spring框架的一个缓存模块，它提供了一套统一的缓存API，支持多种缓存实现，如Ehcache、Redis等，可以帮助开发者实现高效的缓存策略。 5. 使用Spring Boot Actuator实现监控与管理：Spring Boot Actuator是Spring框架的一个监控与管理模块，它提供了一系列端点，可以查看应用程序的健康状况、性能指标、日志信息等，帮助开发者实时监控和管理应用程序。 除此之外，还有很多Springboot高级应用，如消息队列、分布式事务等，开发者可以根据具体业务需求进行选择和应用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值