JAVA —— SpringBoot ②_java导入springboot模块-程序员宅基地

技术标签： spring spring boot java基础架构 java 后端

文章目录

01-SpringBoot高级

SpringBoot自定配置
SpringBoot事件监听
SpringBoot流程分析
SpringBoot监控
SpringBoot部署

02-SpringBoot自动配置-Condition-1

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

@Conditional要配和Condition的实现类（ClassCondition）进行使用

ClassCondition

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

UserConfig

@Configuration
public class UserConfig {
    

    @Bean
    @Conditional(ClassCondition.class)
    public User user(){
    
        return new 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);

    }

}

03-SpringBoot自动配置-Condition-2

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

Condition实现类

package com.xxx.springbootcondition.config2;

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

import java.util.Map;

public class ClassCondition2 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(ConditionOnClass2.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;
    }
}

自定义条件注解类

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

注意： 此处@ConditionOnClass为自定义注解

@Configuration
public class UserConfig {
    

    @Bean
    //@Conditional(ClassCondition.class)
    @ConditionOnClass("com.alibaba.fastjson.JSON")
    public User user(){
    
        return new User();
    }

    @Bean
    @ConditionalOnProperty(name = "xxx",havingValue = "xxx")
    public User user2(){
    
        return new User();
    }

}

测试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

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

ConditionalOnMissingBean：判断容器中没有对应Bean才初始化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的依赖-->
        <dependency>
            <artifactId>spring-boot-starter-jetty</artifactId>
            <groupId>org.springframework.boot</groupId>
        </dependency>

05-SpringBoot自动配置-Enable注解原理

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

演示代码：

springboot-enable工程

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

//@ComponentScan("com.xxx.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

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

springboot-enable-other工程

UserConfig

@Configuration
public class UserConfig {
      

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

EnableUser注解类

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

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

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

三种解决方案：

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

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

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

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

06-SpringBoot自动配置-@Import详解

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

①导入Bean

②导入配置类

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

④导入 ImportBeanDefinitionRegistrar 实现类。

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

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

MyImportSelector

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

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

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-SpringBoot自动配置-@EnableAutoConfiguration详解

在这里插入图片描述

@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。
配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean
并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean

08-SpringBoot自动配置-自定义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 文件

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

09-SpringBoot自动配置-自定义starter实现-1

创建redis-spring-boot-starter工程

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

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

创建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)
public class RedisAutoConfiguration {
    

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

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

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

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

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

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

在SpringbootEnableApplication启动类中测试

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

10-SpringBoot自动配置-自定义starter实现-2

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

11-SpringBoot事件监听

Java中的事件监听机制定义了以下几个角色：

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

②事件源：Source ，任意对象Object

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

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

ApplicationContextInitializer、
SpringApplicationRunListener、
CommandLineRunner、
ApplicationRunner

自定义监听器的启动时机：MyApplicationRunner和MyCommandLineRunner都是当项目启动后执行，使用@Component放入容器即可使用

MyApplicationRunner

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

MyCommandLineRunner

@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.xxx.springbootlistener.listener.MyApplicationContextInitializer

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

MySpringApplicationRunListener的使用要添加构造器

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

ApplicationRunner / CommandLineRunner : 在项目启动后加载完毕其他所有配置后,执行
ApplicationContextInitializer/SpringApplicationRunListener : 在项目启动后,容器初始化前执行

12-SpringBoot流程分析-初始化

配置启动引导类（判断是否有启动主类）
判断是否是Web环境
获取初始化类、监听器类

在这里插入图片描述

13-SpringBoot流程分析-run

启动计时器
执行监听器
准备环境
打印banner：可以resource下粘贴自定义的banner
创建context
```
refreshContext(context);
```
执行refreshContext方法后才真正创建Bean

在这里插入图片描述

14-SpringBoot监控-actuator基本使用

①导入依赖坐标

<dependency>

  <groupId>org.springframework.boot</groupId>

  <artifactId>spring-boot-starter-actuator</artifactId>

</dependency>

②访问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
        }
    }
}

http://localhost:8080/actuator/info

在application.properties中配置

info.name=lucy
info.age=99

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-SpringBoot监控-springboot admin图形化界面使用

SpringBoot Admin 有两个角色，客户端(Client)和服务端(Server)。

以下为创建服务端和客户端工程步骤：

admin-server：

①创建 admin-server 模块

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

在这里插入图片描述

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

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

@EnableAdminServer
@SpringBootApplication
public class SpringbootAdminServerApplication {
    

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

}

admin-client：

①创建 admin-client 模块

②导入依赖坐标 admin-starter-client

  		<dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
        </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

17-SpringBoot部署

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

①jar包(官方推荐)

②war包

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

修改启动类

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>

本文链接：https://blog.csdn.net/weixin_50594210/article/details/121728282

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

省二计算机二级vb程序设计题,2018年3月计算机二级考试VB语言程序设计试题-程序员宅基地

文章浏览阅读124次。(21)窗体上有一个文本框，用于接收正整数。为保证输入数据的合法性　　(即正整数)，可以在该数据输入结束后准备继续其他操作时进行数据的合法性检查。为实现上述目的，应选用的事件是(22)设有如下程序：Private Sub Command1_Click()Dim a(10) As IntegerDim i As Integer, n As Integern = 6For i = 1 To na(i)..._编写以下程序,程序运行后,如果单击命令按钮,则输出结果为。sub proc(x as si

Java API 参考文档, 第 2 部分,使用 JavaTOC doclet 生成的 Eclipse Javadoc API 参考结构_@options @packages-程序员宅基地

文章浏览阅读683次。通过 JavaTOC doclet 生成的 Eclipse Javadoc API 参考文档结构设计的约束条件 _@options @packages

Android逆向：iOS逆向YouTube：protobuf逆向 (crifan.org)_android逆向protobuf-程序员宅基地

文章浏览阅读526次。之前折腾过iOS逆向和安全，期间弄过YouTube的逆向，期间涉及过protobuf的逆向。注：仅供技术学习，请勿用于非法用途。_android逆向protobuf

Matlab获取当前.m文件的位置以及文件名称_matlab显示之前那的.m-程序员宅基地

文章浏览阅读9.6k次，点赞4次，收藏10次。Matlab获取当前.m文件的位置以及文件名称Matlab获取当前.m文件的位置以及文件名称Matlab获取当前.m文件的位置以及文件名称获取当前的位置以及名称fullpath = mfilename('fullpath'); [path,name]=fileparts(fullpath);得到的path变量就是当前.m文件所在的目录，name是.m文件的名称（不带.m后缀）。..._matlab显示之前那的.m

0803_0803什么意思-程序员宅基地

文章浏览阅读814次。0803_0803什么意思

高光谱异常探测研究背景与意义_侯增福博客-程序员宅基地

文章浏览阅读2.2k次，点赞3次，收藏9次。高光谱异常探测研究背景与意义侯增福. 基于协同表示与非监督最邻近规则子空间的高光谱影像异常探测[D]. 2019.研究背景与意义人类对地球表面的认知与探索同人类的历史进程一样经历了数万年之久。得益于科学技术的进步，人类对外太空的探索方式不断地更新，20世纪60年代初，人类首次通过发射人造地球卫星来获取对地观测影像，空间与信息技术的飞速发展使得人类逐渐有能力从更为广阔的空间与视角来观测与..._侯增福博客

随便推点

oracle job线程数,GaussDB T : 100 的多线程模式及后台线程介绍-程序员宅基地

文章浏览阅读328次。GaussDB T : 100 的多线程模式及后台线程介绍在 GaussDB 启动的过程中，可以从日志中清晰的看到，后台依次启动了一系列的线程。GaussDB 100采用单进程、多线程结构。服务器在运行时由各种内存数据结构和一系列线程组成，不同类型的线程完成不同的任务，这其中包括 LGWR / DBWR / CKPT / SMON / STATS ，基本上与 Oracle 命名保持一致。UTC+8..._gaussdb后台线程有哪些

Centos 8 /lib64/libk5crypto.so.3: undefined symbol: EVP_KDF_ctrl, version OPENSSL_1_1_1b #1127-程序员宅基地

文章浏览阅读1.5w次，点赞2次，收藏10次。Centos 8 /lib64/libk5crypto.so.3: undefined symbol: EVP_KDF_ctrl, version OPENSSL_1_1_1b#1127openssl编译完成后，使用sudo su提示如上命令，并且SSH无法连接。centos8，openssl默认为1.1.1b，编译安装的为1.1.1k原因如下：https://blog.csdn.net/qq_36428903/article/details/114025840这个问题的原因是，red._/lib64/libk5crypto.so.3: undefined symbol: evp_kdf_ctrl, version openssl_1_1

产品分析 | 数据资产目录竞品分析_数据资产产品-程序员宅基地

文章浏览阅读824次，点赞19次，收藏14次。怎么建设数据资产目录产品？或许我们可以看看这篇竞品分析，从而帮助自己理清思路。这篇文章里，作者便分析了市场上主流的包含数据资产目录的产品，并梳理了一份竞品分析，一起来看看，或许会对你有所帮助。_数据资产产品

7-5 公路村村通 (30分)-程序员宅基地

文章浏览阅读1.1k次，点赞3次，收藏3次。现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。输入格式:输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。输出格式:输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。输入样例:6 151 2 51 3 31 4 71 5 4_7-5 公路村村通

SQLSERVER2016 无域控AlwaysOn 实施步骤-程序员宅基地

文章浏览阅读252次。SQLSERVER2016无域控AlwaysOn 实施步骤步骤：一、安装3个windows server 2016系统1）在3台机器建立具有administrators权限的相同账号密码，本例子直接使用administrator；2）分别修改计算机名称为 sqldb1,sqldb2,sqldb3；3）配置dns，如testag.com；4）在3台服务器上做好hosts映射..._sql server 2016 always on无域控

signature=56fb98dd01d319598da978dafd71e5db,Tacrolimus-程序员宅基地

文章浏览阅读69次。摘要：Ce contenu est une compilation d'articles de l'encyclopédie libre Wikipedia. Le Tacrolimus, aussi connu sous le nom de FK-506 ou de Fujimycine, est un immunosuppresseur utilisé principalement en tr...