springboot 原理分析之自动配置

一、Condition

        Condition 是在 Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作。比如说，只有满足某一个条件才能创建这个 Bean，否则就不创建。

        SpringBoot 是如何知道要创建哪个 Bean 的？比如 SpringBoot 是如何知道要创建 RedisTemplate 的？

        其实 springboot 就是使用 Condition 来进行判断，它会去判断你当前的环境里面有没有导入 redis 的 starter，如果导入了它就帮你创建 RedisTemplate

1.1 获取 Bean

        如果我们想要在 spring 中获取一个 Bean，该如何操作呢，接下来我们演示，首先创建一个名称为 springboot-condition 的工程，如下图：

        可以在启动类里面通过 ConfigurableApplicationContext 来获取自己想要的 Bean，如下代码：

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

}

        启动工程，如下，可以发现，并没有找到名称为 redisTemplate 的 Bean，那是因为我们没有导入 redis 的依赖。

        我们在 pom.xml 中引入 redis 的依赖，如下，然后再次运行启动类

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

        可以看到获取到了，如下图 

1.2 需求

在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：

        需求一：如果导入了 redis 坐标，则加载该 Bean；若没导入，则不加载。

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

1.3 需求一实现

        首先，我们创建一个 User 和一个 UserConfig 的配置类，如下：

package com.condition.springbootcondition.demo;

public class User {

}
import com.condition.springbootcondition.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {

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

}

        运行 main 方法，可以发现，可以正常获取 user 对象，如下：

@SpringBootApplication
public class SpringbootConditionApplication {

	public static void main(String[] args) {
		// 启动 springboot 应用，返回 Spring 的 IOC 容器
		ConfigurableApplicationContext context = SpringApplication.run(SpringbootConditionApplication.class, args);
		// 获取 bean
		Object redisTemplate = context.getBean("user");
		System.out.println(redisTemplate);
	}
}

        可是需求里面要求的是如果存在 redis 坐标才创建，现在是存不存在都创建。

        我们可以让 spring 容器在创建 bean 的时候加上条件注解 conditional，来达到动态控制的效果，修改 UserConfig 代码，如下：

package com.condition.springbootcondition.config;

import com.condition.springbootcondition.condition.ClassCondition;
import com.condition.springbootcondition.demo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfig {

    @Bean
    // 使用 @Conditional 注解需要传入一个实现了 Condition 接口的实现类，并指定匹配规则
    @Conditional(ClassCondition.class)
    public User user(){
        return new User();
    }

}

        编写实现类 ClassCondition 它需要实现 Condition ，代码如下：

package com.condition.springbootcondition.condition;

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

public class ClassCondition implements Condition {

    // match 方法，返回 true 则创建 bean，返回 false 则不创建 bean
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 思路：判断 org.springframework.data.redis.core.RedisTemplate.class 是否存在
        boolean flag = true;
        try {
            Class<?> aClass = Class.forName("org.springframework.data.redis.core.RedisTemplate");
        } catch (ClassNotFoundException e) {
            flag = false;
        }
        return flag;
    }
}

        执行 main 方法进行测试，可以发现，如果注释掉了 redis 依赖则创建 bean 失败，未注释则创建成功。

1.4 需求二实现

        在实现需求一时，我们创建了一个 ClassCondition，他只能判断 redis 的坐标，太局限了。能不能采用一种动态的方式，任意的指定类是否存在于当前的环境中。

        首先，我们创建一个自定义注解 ConditionOnClass，这个注解要完成和 conditional 注解一摸一样的功能，

package com.condition.springbootcondition.condition;

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

public class ClassCondition implements Condition {

    /**
     *
     * @param context 上下文对象，用于获取环境，IOC 容器，ClassLoader 对象
     * @param metadata 注解元对象，可以用于获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 通过注解属性值 value 指定坐标后创建 bean
        Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
        // 遍历获取到的 value 数组
        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;
    }
}

        将自定义注解作用到 UserConfig 类上，如下：

package com.condition.springbootcondition.config;

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

@Configuration
    public class UserConfig {
    @Bean
    // 使用 @Conditional 注解需要传入一个实现了 Condition 接口的实现类，并指定匹配规则
    // @Conditional(ClassCondition.class)
    @ConditionOnClass("org.springframework.data.redis.core.RedisTemplate")
    public User user(){
        return new User();
    }
}

        此时就可以实现根据传入的类名判断 bean 是否被加载了，如下图：

1.5 总结

自定义条件

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

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

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

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

SpringBoot 提供的常用条件注解

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

        2、ConditionalOnClass：判断环境中是否有对应字节码文件才初始化

        3、BeanConditionalOnMissingBean：判断环境中没有对应 Bean 才初始化 Bean

二、切换内置 web 服务器

2.1 内置服务器

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

        首先我们引入 web 模块的依赖，然后启动工程，如下：

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

        可以看到，此时我们的工程是部署在 tomcat 服务器上的。 

2.2 内置服务器分类

        springboot 支持的内置 web 服务器一共有四种，分别为 Jetty、Netty、tomcat 和 Undertow，我们只需要导入服务器的坐标，就可以进行服务器的切换。

        修改 pom.xml 文件，添加 jetty 依赖，去除 tomcat 的依赖，启动工程，如下：

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

        此时就将工程部署到了 jetty 服务器上，如下 

三、Enable* 注解

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

        SpringBoot 工程是否可以直接获取 jar 包中定义的 Bean？答案是不可以的，需要做一些操作才可以。

3.1 现象演示

        接下来我们演示下不可以直接获取第三方 jar 包中定义的 Bean 的现象，首先创建两个模块，springboot-enable 和 springboot-enable-other。

        其中 springboot-enable-other 模块只是为了提供一个测试用的 Bean，在这个模块下创建一个 User 类和一个配置类 UserConfig，其他的不用配置，如下

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

        在 springboot-enable 模块下引入 springboot-enable-other 的依赖，如下：

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

        测试下是否可以在 springboot-enable 模块下获取 springboot-enable-other 模块里面的 Bean，如下：

@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.2 原因分析

        为什么不能直接获取其他工程的 Bean 呢？我们分析下原因，在我们的启动类上面有个 @SpringBootApplication 注解，点击去，可以看到它具体的定义，如下图：

        可以看到它上面有个 @ComponentScan 的注解，这个注解规定了扫描的范围为当前引导类所在包及其子包，如下图：

        而我们的 User 类的 Bean 的所在包为 com.config，他们之间没有一个包含的关系，所以无法加载 User 类的 Bean。

3.3 问题解决

        解决方式一：使用 @ComponentScan 扫描 User 类所在的路径，如下：

@SpringBootApplication
@ComponentScan("com.config")
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);
    }
}

        解决方式二：可以使用 @Import 注解来加载类，这些类都会被 Spring 创建并放入 IOC 容器，如下：

@SpringBootApplication
@Import(UserConfig.class)
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);
    }
}

        解决方式三：可以对 @Import 注解进行封装，在 springboot-enable-other 模块里面创建一个自定义注解 @EnableUser，内容如下：

package com.config;

import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 导出自己的 UserConfig
@Import(UserConfig.class)
public @interface EnableUser {
}

        将来在使用的时候只需要使用 @EnableUser 注解即可，如下：

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

四、@Import注解

        @Enable* 底层依赖于 @Import 注解导入一些类，使用 @Import 导入的类会被 Spring 加载到 IOC 容器中。而 @Import 提供四种用法，下面分别介绍下。

4.1 导入Bean

        直接通过 @Import 注解，将我们所需要的 Bean 直接导入进去，代码如下：

@SpringBootApplication
@Import(User.class)
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 类 Bean 的名字不一定叫 user。 

        我们换一种方式来获取，通过类型来获取，如下，这下就没啥问题了

@SpringBootApplication
@Import(User.class)
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
        // 获取 Bean
        User bean = context.getBean(User.class);
        System.out.println(bean);
    }
}

4.2 导入配置类

        这个我们上面演示过，只需要导入 UserConfig 即可。且 UserConfig 上面的 @Configuration 注解可以不写，如下：

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

        Object role = context.getBean(Role.class);
        System.out.println(role);
    }
}
public class UserConfig {

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

    @Bean
    public Role role(){
        return new Role();
    }
}

4.3 导入 ImportSelector 实现类

        在 springboot-enable-other 模块下新建一个 MyImportSelector 类并实现 ImportSelector 接口，如下：

package com.config;

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

        然后在启动类上面使用 @Import 注解导入 MyImportSelector 类即可，如下：

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

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

4.4 导入 ImportBeanDefinitionRegistrar 实现类

         在 springboot-enable-other 模块下新建一个 MyImportBeanDefinitionRegistrar 类并实现 ImportBeanDefinitionRegistrar 接口，如下：

package com.config;

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

        然后在启动类上面使用 @Import 注解导入 MyImportBeanDefinitionRegistrar 类即可，如下：

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

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

五、@EnableAutoConfiguration 注解

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

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

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

六、实现自定义 redis-starter

6.1 需求描述

        自定义实现一个 redis-starter，要求当导入 redis 坐标时，SpringBoot 自动创建 Jedis 的 Bean。

6.2 需求分析

        SpringBoot 提供了很多的 starter，但是有一些起步依赖 SpringBoot 并没有提供，而是由那些技术本身自己实现的，它期望和 SpringBoot 整合，所以它自己实现了起步依赖，比如说 mybatis 就是自己实现的，如下图：

        springBoot 官方所提供的起步依赖它的功能名字都在最后面，比如说上面的 -test，而 mybatis 提供的起步依赖功能名字在最前面，比如说上面的 mybatis-。

        总结起来说就是一般第三方自己实现的起步依赖功能名字都在前面， springBoot 官方所提供的起步依赖的功能名字都在最后面，以示区分。

        此时我们可以点击 mybatis 的坐标，看看它涉及到的依赖，最重要的就是 mybatis-spring-boot-autoconfigure 这个依赖，从名字上就可以看出来这个是 mybatis 自动配置的坐标。只有引入了这个坐标，我们才可以加载 mybatis 的相关类。

        同样的，我们也可以打开对应的 jar 包看下，我们可以看到，其实 mybatis-spring-boot-starter 它里面没有代码，只有一个 META-INF 文件夹，它只是将上图的那些坐标整合到一起对外提供一个依赖坐标，方标导入，仅此而已。

        我们再来看下 mybatis-spring-boot-autoconfigure 的实现，如下，可以看到，他里面就有很多代码了，如下图。

        比如说，他里面有个 MybatisAutoConfiguration 的类，他就是一个 mybatis 的自动配置类，这个自动配置类将来如果想要被 Spring 所识别，从而加载配置类里面的 Bean，它的具体实现是定义一个 META-INF 文件夹，里面会有一个 spring.factories 文件，在这个文件里面配置一个 EnableAutoConfiguration 指向上面的 MybatisAutoConfiguration，内容如下：

        SpringBoot 在启动的时候就加载 META-INF 文件夹里面的 spring.factories 文件，从而识别到这个自动配置类。

6.3 需求实现

        1、创建 redis-spring-boot-autoconfigure 模块，如下图，把没用的文件都删除掉。

        2、创建 redis-spring-boot-starter 模块，依赖 redis-spring-boot-autoconfigure 的模块，如下图，也是把没用的文件都删除掉，如下图

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<!--引入自己的 autoconfigure 模块-->
	<dependency>
		<groupId>com</groupId>
		<artifactId>redis-spring-boot-autoconfigure</artifactId>
		<version>0.0.1-SNAPSHOT</version>
	</dependency>
</dependencies>

        3、在 redis-spring-boot-autoconfigure 模块中初始化 Jedis 的 Bean。

<!-- 引入 jedis 依赖-->
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</dependency>

        接下来在 redis-spring-boot-autoconfigure 模块中编写一个核心的 redis 的自动配置类 RedisAutoConfiguration ，内容如下：

package com.redis.config;

import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;

@Configuration
// 启用 RedisProperties 类，让其受 Spring IOC 容器管理
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoConfiguration {
    /**
     * 提供 Jedis 的bean
     */
    @Bean
    public Jedis jedis(RedisProperties redisProperties) {
        // 一般使用两个参数的构造方法
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

        创建一个 ConfigurationProperties 类让实体类和配置文件相绑定，动态的指定 redis 的 ip 地址和端口号，如下所示：

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

@Component
// 以后以 redis 开头的配置文件都会和 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;
    }
}

        创建 META-INF/spring.factories 文件，结构如下所示：

        并在 spring.factories 里面输入以下的内容：

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

        4、在测试模块中引入自定义的 redis-starter 依赖，随便找一个模块，配置依赖，如下：

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

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

        在测试类获取 Jedis 的 Bean ，如下所示：

@SpringBootApplication
public class RedisSpringBootTestApplication {
    public static void main(String[] args) {

        // 启动 springboot 应用，返回 Spring 的 IOC 容器
        ConfigurableApplicationContext context = SpringApplication.run(RedisSpringBootTestApplication.class, args);
        // 获取 bean
        Jedis jedis = context.getBean(Jedis.class);
        System.out.println(jedis);

        jedis.set("name","zhangsan");
        String name = jedis.get("name");
        System.out.println(name);
    }
}

        可以看到，获取了 Jedis 的 Bean 了。 

6.4 需求优化

6.4.1 验证配置文件

        刚才我们创建一个 ConfigurationProperties 类让实体类和配置文件相绑定，接下来我们测试下，在 application.properties 里面配置 redis 的端口号，如下：

redis.port=6666

        启动工程，报错了，可以看到，我们的配置文件是生效了的。

        当我们程序启动的时候 RedisAutoConfiguration 这个 Bean 就会被加载，我们可以给它加一些条件，当 Jedis 在的时候才会去加载这个 Bean，如下：

@Configuration
// 启用 RedisProperties 类，让其受 Spring IOC 容器管理
@EnableConfigurationProperties(RedisProperties.class)
@ConditionalOnClass(Jedis.class)
public class RedisAutoConfiguration {
    /**
     * 提供 Jedis 的bean
     */
    @Bean
    // 如果没有一个名字为 jedis 的Bean 才加载这个
    @ConditionalOnMissingBean(name="jedis")
    public Jedis jedis(RedisProperties redisProperties) {
        System.out.println("RedisAutoConfiguration......");
        // 一般使用两个参数的构造方法
        return new Jedis(redisProperties.getHost(), redisProperties.getPort());
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/331190.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

[C++] opencv - copyTo函数介绍和使用案例

[C++] opencv - copyTo函数介绍和使用案例

copyTo函数介绍 copyTo函数是OpenCV库中的一个成员函数&#xff0c;用于将一个Mat对象的内容复制到另一个Mat对象中。 函数原型&#xff1a; void cv::Mat::copyTo(OutputArray m) const;void cv::Mat::copyTo(OutputArray m, InputArray mask) const; 参数说明&#xff1a;…
阅读更多...
动手学深度学习6 自动求导

动手学深度学习6 自动求导

自动求导 1. 自动求导2. 自动求导实现1. 示例 y 2 X T X y2X^TX y2XTX 关于列向量x求导。2. 非标量变量的反向传播3. 分离计算4. Python控制流的梯度计算 QA 视频&#xff1a; https://www.bilibili.com/video/BV1KA411N7Px/?spm_id_fromautoNext&vd_sourceeb04c9a33e87…
阅读更多...
STL中的stack、queue以及deque

STL中的stack、queue以及deque

目录 一、关于deque容器&#xff08;双端队列&#xff09; 1、deque的底层实现 2、deque的缺点 3、关于stack与squeue默认使用deque容器 二、stack简介 1、stack的成员函数&#xff08;接口&#xff09; 2、stack的模拟实现 三、queue简介 1、queue的成员函数&#xff08…
阅读更多...
js：锚点滚动到页面对应区域

js：锚点滚动到页面对应区域

锚点跳转到对应页面的区域使用 scrollIntoView // anchor即你要跳转到的元素 anchor.scrollIntoView({behavior: "smooth", block: "center", inline: "nearest" });1、behavior&#xff1a;定义滚动行为。它可以设置为 “auto” 或 “smoo…
阅读更多...
老师布置作业的技巧有哪些

老师布置作业的技巧有哪些

布置作业可不只是简单地给学生分配任务&#xff0c;而是需要运用一些技巧&#xff0c;以达到更好的教学效果。那么&#xff0c;老师应该如何布置作业呢&#xff1f; 一、作业要有针对性 布置作业时&#xff0c;老师应该根据学生的实际情况和课程要求&#xff0c;有针对性地设…
阅读更多...
小程序商城在易货模式中的可行性

小程序商城在易货模式中的可行性

一、引言 随着科技的快速发展和互联网的普及&#xff0c;电子商务已经深入人们的生活。小程序商城作为电子商务的一种形式&#xff0c;凭借其便捷性、高效性和广泛覆盖的优势&#xff0c;成为商业领域的新宠。本文将探讨使用小程序商城实现易货模式的可行性。 二、小程序商城的…
阅读更多...
Grind75第9天 | 733.图像渲染、542.01矩阵、1235.规划兼职工作

Grind75第9天 | 733.图像渲染、542.01矩阵、1235.规划兼职工作

733.图像渲染 题目链接&#xff1a;https://leetcode.com/problems/flood-fill 解法&#xff1a; 可以用深度优先搜索和广度优先搜索。 深度优先搜索。每次搜索到一个方格时&#xff0c;如果其与初始位置的方格颜色相同&#xff0c;就将该方格的染色&#xff0c;然后继续对…
阅读更多...
鸿蒙NEXT来了，操作系统的寒武纪时代

鸿蒙NEXT来了，操作系统的寒武纪时代

鸿蒙来了&#xff0c;加上Android、iOS&#xff0c;企业又要投入人力物力财力&#xff0c;多支持一个技术阵营的一种技术平台。从IT角度看&#xff0c;是更多的责任&#xff1a;新技能培训、新员工招聘、新小组成立&#xff0c;也是新增的代码、新的bug、新的测试任务&#xff…
阅读更多...
智能车培训——硬件篇：电源转换的硬件设计

智能车培训——硬件篇：电源转换的硬件设计

培训课件及资料 链接&#xff1a;https://pan.baidu.com/s/1IikVfZ04Wl9UmEuizfP12A?pwd89gs 提取码&#xff1a;89gs 一.BUCK降压电路的设计 1.什么是BUCK降压&#xff1f;&#xff08;原理&#xff09; &#xff08;1&#xff09;导通回路与续流回路 电流的环路是电源通…
阅读更多...
【H3C】配置AAA认证和Telnet远程登陆，S5130 Series交换机

【H3C】配置AAA认证和Telnet远程登陆，S5130 Series交换机

AAA配置步骤为&#xff1a; 1.开启telent远程登陆服务 2.创建用户&#xff0c;设置用户名、密码、用户的服务类型 3.配置终端登录的数量 4.配置vlan-if的ip地址&#xff0c;用来远程登陆 5.允许对应的vlan通过 1.开启telent远程登陆服务 sys …
阅读更多...
react umi/max 页签(react-activation)

react umi/max 页签(react-activation)

思路&#xff1a;通过react-activation实现页面缓存&#xff0c;通过umi-plugin-keep-alive将react-activation注入umi框架&#xff0c;封装页签组件最后通过路由的wrappers属性引入页面。 浏览本博客之前先看一下我的博客实现的功能是否满足需求&#xff0c;实现功能&#xf…
阅读更多...
C++I/O流——(4)格式化输入/输出(第二节)

C++I/O流——(4)格式化输入/输出(第二节)

归纳编程学习的感悟&#xff0c; 记录奋斗路上的点滴&#xff0c; 希望能帮到一样刻苦的你&#xff01; 如有不足欢迎指正&#xff01; 共同学习交流&#xff01; &#x1f30e;欢迎各位→点赞 &#x1f44d; 收藏⭐ 留言​&#x1f4dd; 含泪播种的人一定能含笑收获&#xff…
阅读更多...
一文极速了解【自注意力机制】

一文极速了解【自注意力机制】

当下如火如荼的大模型&#xff0c;其中的关键技术就是注意力机制&#xff08;Attention&#xff09;&#xff0c;于2015年提出。2017年的“Attention is all you need”一文提出了Transformer模型&#xff0c;去掉RNN&#xff0c;只保留注意力&#xff0c;性能吊打所有机器翻译…
阅读更多...
用Airtest快速实现手机文件读写与删除功能

用Airtest快速实现手机文件读写与删除功能

1. 前言 前几天有同学留言&#xff0c;能不能安排“读写手机文件”的示例。我们今天就来实现这个小功能。 当然&#xff0c;熟悉adb的同学&#xff0c;看到这个需求&#xff0c;肯定很开心&#xff0c;不就是一个 adb push 和 adb pull 嘛&#xff0c;非常简单呀。 确实如此&…
阅读更多...
Python 利用pandas对数据进行特定排序

Python 利用pandas对数据进行特定排序

背景 小编最近在处理hive表存储大小时&#xff0c;需要对每个表的大小进行排序&#xff0c;因通过 hadoop fs -du -s -h /path/table 命令获取的数据表大小&#xff0c;其结果是展示为人能直观理解的大小&#xff0c;例如 1.1T、1.9G、49.6M 等&#xff0c;如果想对这些表根据…
阅读更多...
如何安装配置VisualSVN服务并实现公网访问本地服务【内网穿透】

如何安装配置VisualSVN服务并实现公网访问本地服务【内网穿透】

文章目录 前言1. VisualSVN安装与配置2. VisualSVN Server管理界面配置3. 安装cpolar内网穿透3.1 注册账号3.2 下载cpolar客户端3.3 登录cpolar web ui管理界面3.4 创建公网地址 4. 固定公网地址访问 前言 SVN 是 subversion 的缩写&#xff0c;是一个开放源代码的版本控制系统…
阅读更多...
2018年认证杯SPSSPRO杯数学建模A题(第一阶段)海豚与沙丁鱼全过程文档及程序

2018年认证杯SPSSPRO杯数学建模A题(第一阶段)海豚与沙丁鱼全过程文档及程序

2018年认证杯SPSSPRO杯数学建模 探究海豚猎捕时沙丁鱼群的躲避运动模型 A题 海豚与沙丁鱼 原题再现&#xff1a; 沙丁鱼以聚成大群的方式来对抗海豚的捕食。由于水下光线很暗&#xff0c;所以在距离较远时&#xff0c;海豚只能使用回声定位方法来判断鱼群的整体位置&#xf…
阅读更多...
网页版短信系统功能简介|短信平台开发搭建源码

网页版短信系统功能简介|短信平台开发搭建源码

网页版短信系统功能简介|短信平台开发搭建源码 随着互联网的发展&#xff0c;科技的进步和人们对通讯方式的需求不断增加&#xff0c;短信成为了人们日常生活中必不可少的沟通工具之一。而网页版短信系统的出现&#xff0c;为人们提供了更加便捷和灵活的短信发送和接收方式。 网…
阅读更多...
Ant Design Vue上传多个图片

Ant Design Vue上传多个图片

模板代码&#xff1a; 定义变量&#xff1a; 文件限制的函数&#xff1a; 上传的函数&#xff1a; 样式函数&#xff1a; 完整代码&#xff1a; <template><div class"dialog-upload" v-if"showUploadDialog"><div class"dialog-uplo…
阅读更多...
MySQL 基于创建时间进行RANGE分区

MySQL 基于创建时间进行RANGE分区

MySQL是一款广泛使用的关系型数据库。在MySQL中&#xff0c;大量数据场景提高查询效率是非常关键的&#xff0c;所以&#xff0c;对数据表进行分区是一个很好的选择。 在创建分区表之前&#xff0c;需要了解一下MySQL分区的基本概念。MySQL分区可以将一个大表分成多个小表&…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站