Spring高手之路5——彻底掌握Bean的生命周期

news2024/11/26 20:21:08

文章目录

  • 1. 理解Bean的生命周期
    • 1.1 生命周期的各个阶段
  • 2. 理解init-method和destroy-method
    • 2.1 从XML配置创建Bean看生命周期
    • 2.2 从配置类注解配置创建Bean看生命周期
    • 2.3 初始化和销毁方法的特性
    • 2.4 探究Bean的初始化流程顺序
  • 3. @PostConstruct和@PreDestroy
    • 3.1 示例：@PostConstruct和@PreDestroy的使用
    • 3.2 初始化和销毁——注解和init-method共存对比
  • 4. 实现InitializingBean和DisposableBean接口
    • 4.1 示例：实现InitializingBean和DisposableBean接口
    • 4.2 三种生命周期并存
  • 5. 原型Bean的生命周期
  • 6. Spring中控制Bean生命周期的三种方式总结

1. 理解Bean的生命周期

1.1 生命周期的各个阶段

在Spring IOC容器中，Bean的生命周期大致如下：

  1. 实例化：当启动Spring应用时，IOC容器就会为在配置文件中声明的每个<bean>创建一个实例。

  2. 属性赋值：实例化后，Spring就通过反射机制给Bean的属性赋值。

  3. 调用初始化方法：如果Bean配置了初始化方法，Spring就会调用它。初始化方法是在Bean创建并赋值之后调用，可以在这个方法里面写一些业务处理代码或者做一些初始化的工作。

  4. Bean运行期：此时，Bean已经准备好被程序使用了，它已经被初始化并赋值完成。

  5. 应用程序关闭：当关闭IOC容器时，Spring会处理配置了销毁方法的Bean。

  6. 调用销毁方法：如果Bean配置了销毁方法，Spring会在所有Bean都已经使用完毕，且IOC容器关闭之前调用它，可以在销毁方法里面做一些资源释放的工作，比如关闭连接、清理缓存等。

这就是Spring IOC容器管理Bean的生命周期，帮助我们管理对象的创建和销毁，以及在适当的时机做适当的事情。

我们可以将生命周期的触发称为回调，因为生命周期的方法是我们自己定义的，但方法的调用是由框架内部帮我们完成的，所以可以称之为“回调”。

2. 理解init-method和destroy-method

让我们先了解一种最容易理解的生命周期阶段：初始化和销毁方法。这些方法可以在Bean的初始化和销毁阶段起作用，我们通过示例来演示这种方式。

为了方便演示XML和注解的方式，接下来我们会创建两个类来分别进行演示，分别为Lion和Elephant，让我们一步一步对比观察。

2.1 从XML配置创建Bean看生命周期

先创建一个类Lion

package com.example.demo.bean;

public class Lion {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void init() {
        System.out.println(name + " has been initialized...");
    }

    public void destroy() {
        System.out.println(name + " has been destroyed...");
    }
}

在XML中，我们使用<bean>标签来注册Lion：

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

        <bean class="com.example.demo.bean.Lion"
              init-method="init" destroy-method="destroy">
            <property name="name" value="simba"/>
        </bean>
</beans>

加上主程序

package com.example.demo.application;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@ComponentScan("com.example")
public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果

在这里插入图片描述

在<bean>标签中，有两个属性：init-method和destroy-method，这两个属性用于指定初始化和销毁方法。

这里"simba has been initialized...“，证明init()方法被调用了。当context.close()被调用时，看到"simba has been destroyed...”，证明destroy()方法被调用了。

在 IOC 容器初始化之前，默认情况下 Bean 已经创建好了，而且完成了初始化动作；容器调用销毁动作时，先销毁所有 Bean ，最后 IOC 容器全部销毁完成。

这个例子通过一个简单的Spring应用程序显示了Spring bean的生命周期。我们可以在创建bean时根据需要使用这些生命周期方法。

2.2 从配置类注解配置创建Bean看生命周期

这里再创建一个类Elephant和上面对比

package com.example.demo.bean;

public class Elephant {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public void init() {
        System.out.println(name + " has been initialized...");
    }

    public void destroy() {
        System.out.println(name + " has been destroyed...");
    }
}

对于注解，@Bean注解中也有类似的属性：initMethod和destroyMethod，这两个属性的作用与XML配置中的相同。

package com.example.demo.configuration;

import com.example.demo.bean.Elephant;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AnimalConfig {

    @Bean(initMethod = "init", destroyMethod = "destroy")
    public Elephant elephant() {
        Elephant elephant = new Elephant();
        elephant.setName("Dumbo");
        return elephant;
    }
}

这里用@ImportResource("classpath:applicationContext.xml")引入xml配置创建Bean进行对比。

主程序改为如下：

package com.example.demo.application;

import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@ComponentScan("com.example")
public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果

在这里插入图片描述

注意：在Spring中，如果在Java配置中定义了一个Bean，并在XML中定义了一个相同id或name的Bean，那么最后注册的那个Bean会覆盖之前注册的，这取决于配置文件加载顺序，无论在Java配置中还是XML配置中定义的initMethod或destroyMethod，最后生效的总是后加载的配置中定义的。

“init-method”是指定初始化回调方法的属性的统称，无论它是在XML配置还是Java配置中使用。同样地，“destroy-method”是指定销毁回调方法的属性的统称。后文我们讲解多种声明周期共存的时候，将延续这种说法。

2.3 初始化和销毁方法的特性

在Spring框架中配置Bean的初始化和销毁方法时，需要按照Spring的规范来配置这些方法，否则Spring可能无法正确地调用它们。下面给每个特性提供一个解释和示例：

  1. 方法的访问权限无限制：这意味着无论方法是public、protected还是private，Spring都可以调用。Spring通过反射来调用这些方法，所以它可以忽略Java的访问权限限制。示例：
public class MyBean {
    private void init() {
        // 初始化代码
    }
}

在上述代码中，即使init方法是private的，Spring也可以正常调用。

  1. 方法没有参数：由于Spring不知道需要传递什么参数给这些方法，所以这些方法不能有参数。示例：
public class MyBean {
    public void init() {
        // 初始化代码
    }
}

在上述代码中，init方法没有参数，如果添加了参数，如public void init(String arg)，Spring将无法调用此方法。

  1. 方法没有返回值：由于返回的值对Spring来说没有意义，所以这些方法不应该有返回值。示例：
public class MyBean {
    public void init() {
        // 初始化代码
    }
}

在上述代码中，init方法是void的，如果让此方法返回一个值，如public String init()，那么Spring将忽略此返回值。

  1. 方法可以抛出异常：如果在初始化或销毁过程中发生错误，这些方法可以抛出异常来通知Spring。示例：
public class MyBean {
    public void init() throws Exception {
        // 初始化代码
        if (somethingGoesWrong) {
            throw new Exception("Initialization failed.");
        }
    }
}

在上述代码中，如果在init方法中的初始化代码出错，它会抛出一个异常。Spring框架默认会停止Bean的创建，并抛出异常。

2.4 探究Bean的初始化流程顺序

  在上面的代码中，我们可以看出Bean在IOC容器初始化阶段就已经创建并初始化了，那么每个Bean的初始化动作又是如何进行的呢？我们修改一下Lion，在构造方法和setName方法中加入控制台打印，这样在调用这些方法时，会在控制台上得到反馈。

package com.example.demo.bean;

public class Lion {

    private String name;

    public Lion() {
        System.out.println("Lion's constructor is called...");
    }

    public void setName(String name) {
        System.out.println("setName method is called...");
        this.name = name;
    }

    public void init() {
        System.out.println(name + " has been initialized...");
    }

    public void destroy() {
        System.out.println(name + " has been destroyed...");
    }
}

我们重新运行主程序：

@ComponentScan("com.example")
public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果

在这里插入图片描述

我们可以得出结论：在Bean的生命周期中，首先进行属性赋值，然后执行init-method标记的方法。

3. @PostConstruct和@PreDestroy

在JSR250规范中，有两个与Bean生命周期相关的注解，即@PostConstruct和@PreDestroy。这两个注解对应了Bean的初始化和销毁阶段。

@PostConstruct注解标记的方法会在bean属性设置完毕后（即完成依赖注入），但在bean对外暴露（即可以被其他bean引用）之前被调用，这个时机通常用于完成一些初始化工作。

@PreDestroy注解标记的方法会在Spring容器销毁bean之前调用，这通常用于释放资源。

3.1 示例：@PostConstruct和@PreDestroy的使用

我们这里还是用Lion类来创建这个例子，将Lion类修改为使用@PostConstruct和@PreDestroy注解

package com.example.demo.bean;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Lion {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @PostConstruct
    public void init() {
        System.out.println("Lion is going through init.");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Lion is going through destroy.");
    }

    @Override
    public String toString() {
        return "Lion{" + "name=" + name + '}';
    }
}

给Lion类加上@Component注解，让IOC容器去管理这个类，我们这里就不把Elephant类加进来增加理解难度了。

被 @PostConstruct 和 @PreDestroy 注解标注的方法与 init-method / destroy-method 方法的初始化和销毁的要求是一样的，访问修饰符没有限制，private也可以。

我们可以注释掉之前的配置类和XML配置，因为和这里的例子没有关系，我们来看看主程序：

package com.example.demo.application;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.example.demo.bean");
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果

在这里插入图片描述

这里可以看到@PostConstruct和@PreDestroy注解正确地应用在了Lion的初始化和销毁过程中。

3.2 初始化和销毁——注解和init-method共存对比

@PostConstruct和@PreDestroy注解与init-method/destroy-method属性如何共存呢？我们来看看

我们只用Lion类来举例子，在Lion类中添加新的open()和close()方法

需要的全部代码如下：

Lion.java

package com.example.demo.bean;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;


public class Lion {

    private String name;

    public Lion() {
        System.out.println("Lion构造器");
    }

    public void setName(String name) {
        System.out.println("Lion设置name");
        this.name = name;
    }

    public void open() {
        System.out.println("配置类initMethod - 打开Lion。。。");
    }

    public void close() {
        System.out.println("配置类destroyMethod - 关闭Lion。。。");
    }

    @PostConstruct
    public void init() {
        System.out.println("@PostConstruct - Lion正在进行初始化。。。");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("@PreDestroy - Lion正在进行销毁。。。");
    }

    @Override
    public String toString() {
        return "Lion{" + "name=" + name + '}';
    }
}

配置类AnimalConfig.java

package com.example.demo.configuration;

import com.example.demo.bean.Lion;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AnimalConfig {

    @Bean(initMethod = "open", destroyMethod = "close")
    public Lion lion() {
        return new Lion();
    }
}

主程序

package com.example.demo.application;

import com.example.demo.configuration.AnimalConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnimalConfig.class);
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果

在这里插入图片描述

这里可以看到@PostConstruct和@PreDestroy注解的优先级始终高于配置类中@Bean注解的initMethod和destroyMethod属性。

4. 实现InitializingBean和DisposableBean接口

  这两个接口是 Spring 预定义的两个关于生命周期的接口。他们被触发的时机与上文中的 init-method / destroy-method 以及 JSR250 规范的注解相同，都是在 Bean 的初始化和销毁阶段回调的。下面演示如何使用这两个接口。

4.1 示例：实现InitializingBean和DisposableBean接口

创建Bean，我们让Lion类实现这两个接口：

Lion.java

package com.example.demo.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;


@Component
public class Lion implements InitializingBean, DisposableBean {

    private Integer energy;

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("狮子已经充满能量。。。");
        this.energy = 100;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("狮子已经消耗完所有能量。。。");
        this.energy = 0;
    }

    @Override
    public String toString() {
        return "Lion{" + "energy=" + energy + '}';
    }
}

  InitializingBean接口只有一个方法：afterPropertiesSet()。在Spring框架中，当一个bean的所有属性都已经被设置完毕后，这个方法就会被调用。也就是说，这个bean一旦被初始化，Spring就会调用这个方法。我们可以在bean的所有属性被设置后，进行一些自定义的初始化工作。

  DisposableBean接口也只有一个方法：destroy()。当Spring容器关闭并销毁bean时，这个方法就会被调用。我们可以在bean被销毁前，进行一些清理工作。

主程序：

package com.example.demo.application;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context
                = new AnnotationConfigApplicationContext("com.example.demo.bean");
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果：

在这里插入图片描述

4.2 三种生命周期并存

在Spring框架中，控制Bean生命周期的三种方式是：

  1. 使用Spring的init-method和destroy-method（在XML配置或者Java配置中自定义的初始化和销毁方法）；
  2. 使用JSR-250规范的@PostConstruct和@PreDestroy注解；
  3. 实现Spring的InitializingBean和DisposableBean接口。

  接下来我们测试一下，一个Bean同时定义init-method、destroy-method方法，使用@PostConstruct、@PreDestroy注解，以及实现InitializingBean、DisposableBean接口，执行顺序是怎样的。

我们创建一个新的类Lion2，并同时进行三种方式的生命周期控制：

需要运行的全部代码如下：

package com.example.demo.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class Lion2 implements InitializingBean, DisposableBean {

    private Integer energy;

    public void open() {
        System.out.println("init-method - 狮子开始行动。。。");
    }

    public void close() {
        System.out.println("destroy-method - 狮子结束行动。。。");
    }

    @PostConstruct
    public void gainEnergy() {
        System.out.println("@PostConstruct - 狮子已经充满能量。。。");
        this.energy = 100;
    }

    @PreDestroy
    public void loseEnergy() {
        System.out.println("@PreDestroy - 狮子已经消耗完所有能量。。。");
        this.energy = 0;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean - 狮子准备行动。。。");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean - 狮子行动结束。。。");
    }
}

接着，我们注册Lion2：

package com.example.demo.configuration;

import com.example.demo.bean.Lion2;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AnimalConfig {

    @Bean(initMethod = "open", destroyMethod = "close")
    public Lion2 lion2() {
        return new Lion2();
    }
}

然后让注解 IOC 容器驱动这个配置类，主程序如下：

package com.example.demo.application;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context
                = new AnnotationConfigApplicationContext("com.example.demo");
        System.out.println("Spring容器初始化完成。");
        System.out.println("==================");
        System.out.println("Spring容器准备关闭");
        context.close();
        System.out.println("Spring容器已关闭。");
    }
}

运行结果：

在这里插入图片描述

从上面的结果，我们可以得出以下结论，在Spring框架中单实例Bean的初始化和销毁过程有这样的执行顺序：

初始化顺序：@PostConstruct → InitializingBean → init-method
销毁顺序：@PreDestroy → DisposableBean → destroy-method

在初始化Bean时，@PostConstruct注解方法会首先被执行，然后是实现InitializingBean接口的afterPropertiesSet方法，最后是init-method指定的方法。

在销毁Bean时，@PreDestroy注解方法会首先被执行，然后是实现DisposableBean接口的destroy方法，最后是destroy-method指定的方法

结合前面说过的属性赋值(构造器方法和setter方法)，简单总结一下Spring Bean生命周期的流程：

  1. 实例化（通过构造器方法）；
  2. 设置Bean的属性（通过setter方法）；
  3. 调用Bean的初始化方法（@PostConstruct、afterPropertiesSet方法或者init-method指定的方法）；
  4. Bean可以被应用程序使用；
  5. 当容器关闭时，调用Bean的销毁方法（@PreDestroy、destroy方法或者destroy-method指定的方法）。

5. 原型Bean的生命周期

  原型Bean的创建和初始化过程与单例Bean类似，但由于原型Bean的性质，其生命周期与IOC容器的生命周期并不相同。

这里展示一下需要的全部代码。

Lion2.java

package com.example.demo.bean;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class Lion2 implements InitializingBean, DisposableBean {

    private Integer energy;

    public void roar() {
        System.out.println("The lion is roaring...");
    }

    public void rest() {
        System.out.println("The lion is resting...");
    }

    @PostConstruct
    public void gainEnergy() {
        System.out.println("@PostConstruct - 狮子已经充满能量。。。");
        this.energy = 100;
    }

    @PreDestroy
    public void loseEnergy() {
        System.out.println("@PreDestroy - 狮子已经消耗完所有能量。。。");
        this.energy = 0;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean - 狮子准备行动。。。");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean - 狮子行动结束。。。");
    }
}

然后在Spring的Java配置中声明并设定其为原型Bean

package com.example.demo.configuration;

import com.example.demo.bean.Lion2;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

@Configuration
public class PrototypeLifecycleConfiguration {

    @Bean(initMethod = "roar", destroyMethod = "rest")
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    public Lion2 lion() {
        return new Lion2();
    }
}

  如果我们只是启动了IOC容器，但并未请求Lion2的实例，Lion Bean的初始化不会立刻发生。也就是说，原型Bean不会随着IOC容器的启动而初始化。以下是启动容器但并未请求Bean的代码：

package com.example.demo.application;

import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                PrototypeLifecycleConfiguration.class);
    }
}

运行结果：

在这里插入图片描述

  当我们明确请求一个Lion2的实例时，我们会看到所有的初始化方法按照预定的顺序执行，这个顺序跟单例Bean完全一致：

package com.example.demo.application;

import com.example.demo.bean.Lion2;
import com.example.demo.configuration.PrototypeLifecycleConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        System.out.println("Spring容器初始化开始");
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(
                PrototypeLifecycleConfiguration.class);
        System.out.println("Ready to get a Lion instance...");
        Lion2 lion = context.getBean(Lion2.class);
        System.out.println("A Lion instance has been fetched...");
        System.out.println("Lion instance is no longer needed, preparing to destroy...");
        context.getBeanFactory().destroyBean(lion);
        System.out.println("Lion instance has been destroyed...");
    }
}

运行结果：

在这里插入图片描述

  将原型Bean和单例Bean的三种生命周期进行对比后发现，调用IOC容器的destroyBean()方法销毁原型Bean时，只有@PreDestroy注解和DisposableBean接口的destroy方法会被触发，而被destroy-method标记的自定义销毁方法并不会被执行。

  从这里我们可以得出结论：在销毁原型Bean时，Spring不会执行由destroy-method标记的自定义销毁方法，所以原型Bean的destroy-method的也有局限性。如果有重要的清理逻辑需要在Bean销毁时执行，那么应该将这部分逻辑放在@PreDestroy注解的方法或DisposableBean接口的destroy方法中。

6. Spring中控制Bean生命周期的三种方式总结

执行顺序代码依赖性容器支持单实例Bean原型Bean
init-method & destroy-method最后较低（依赖于Spring Bean配置，不侵入业务代码）xml、注解原生支持√只支持 init-method
@PostConstruct & @PreDestroy最先中等（需要在业务代码中添加JSR规范的注解）注解原生支持，xml需开启注解驱动√√
InitializingBean & DisposableBean中间较高（需要业务代码实现Spring特定接口）xml、注解原生支持√√

欢迎一键三连~

有问题请留言，大家一起探讨学习

----------------------Talk is cheap, show me the code-----------------------

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Scala入门

Scala入门

第1章 Scala入门 1.1 概述 Scala将面向对象和函数式编程结合成一种简洁的高级语言。 语言特点如下&#xff1a; &#xff08;1&#xff09;Scala和Java一样属于JVM语言&#xff0c;使用时都需要先编译为class字节码文件&#xff0c;并且Scala能够直接调用Java的类库。 &#…
阅读更多...
Linux进程信号 | 信号处理

Linux进程信号 | 信号处理

前面的文章中我们讲述了信号的产生与信号的保存这两个知识点&#xff0c;在本文中我们将继续讲述与信号处理有关的信息。 信号处理 之前我们说过在收到一个信号的时候&#xff0c;这个信号不是立即处理的&#xff0c;而是要得到的一定的时间。从信号的保存中我们可以知道如果…
阅读更多...
CSP-J组初赛历年真题讲解第1篇

CSP-J组初赛历年真题讲解第1篇

一、二进制基础 1.二进制数 00100100 和 00010100 的和是( )。 A.00101000 B.01100111 C.01000100 D.00111000 来源&#xff1a;模拟试题正确答案&#xff1a;D 讲解&#xff1a; 2.在二进制下&#xff0c;1011001()11001101011001( )1100110 A. 1011 B. 1101 C. 1010…
阅读更多...
仓库Vuex

仓库Vuex

1. 搭建vuex仓库 1.1 安装 npm install vuexnext 1.2 引入 创建store文件夹&#xff0c;里面创建index.js&#xff0c;该js文件中写&#xff1a; import { createStore } from vuex // 引入子仓库 import model1 from "./model1.js" import model2 from "…
阅读更多...
行为型设计模式05-备忘录模式

行为型设计模式05-备忘录模式

&#x1f9d1;‍&#x1f4bb;作者&#xff1a;猫十二懿 ❤️‍&#x1f525;账号&#xff1a;CSDN 、掘金 、个人博客 、Github &#x1f389;公众号&#xff1a;猫十二懿 备忘录模式 1、备忘录模式介绍 备忘录模式是一种行为型设计模式&#xff0c;用于在不破坏封装性的前提…
阅读更多...
Spring Resources资源操作

Spring Resources资源操作

文章目录 1、Spring Resources概述2、Resource接口3、Resource的实现类3.1、UrlResource访问网络资源3.2、ClassPathResource 访问类路径下资源3.3、FileSystemResource 访问文件系统资源3.4、ServletContextResource3.5、InputStreamResource3.6、ByteArrayResource 4、Resour…
阅读更多...
H桥级联型五电平三相逆变器MATLAB仿真模型

H桥级联型五电平三相逆变器MATLAB仿真模型

H桥级联型五电平逆变器MATLAB仿真模型资源-CSDN文库https://download.csdn.net/download/weixin_56691527/87899094 模型简介&#xff1a; MATLAB21b版本 逆变器采用H桥级联的形式连接&#xff0c;加设LCL滤波器&#xff0c;三相负载构成主电路。 采用SPWM调制&#xff0c;可…
阅读更多...
不宜使用Selenium自动化的10个测试场景

不宜使用Selenium自动化的10个测试场景

尽管在很多情况下测试自动化是有意义的&#xff0c;但一些测试场景是不应该使用自动化测试工具的&#xff0c;比如Selenium、WebDriver。 下面有10个示例&#xff0c;来解释为什么自动化在这种情况下使用时没有意义的&#xff0c;我还将为您提供每种方法的替代方法。 01.验证…
阅读更多...
TreeView 简单使用

TreeView 简单使用

本文主要介绍 QML 中 TreeView 的基本使用方法&#xff0c;包括&#xff1a;TreeView的适用场景&#xff1b; 控件简介 QML TreeView 是 Qt Quick 中的一个组件&#xff0c;用于显示树形结构的数据。它提供了一种以层次结构方式展示数据的方式&#xff0c;其中每个节点可以包含…
阅读更多...
ESP32学习之定时器和PWM

ESP32学习之定时器和PWM

一.定时器代码如下&#xff1a; #include <Arduino.h>hw_timer_t *timer NULL; int interruptCounter 0;// 函数名称&#xff1a;onTimer() // 函数功能&#xff1a;中断服务的功能&#xff0c;它必须是一个返回void&#xff08;空&#xff09;且没有输入参数的函数 //…
阅读更多...
【动态规划】路径问题

【动态规划】路径问题

冻龟算法系列之路径问题 文章目录 【动态规划】路径问题1. 不同路径1.1 题目解析1.2 算法原理1.2.1 状态表示1.2.2 状态转移方程1.2.3 初始化1.2.4 填表顺序1.2.5 返回值 1.3 编写代码 2. 不同路径Ⅱ2.1 题目解析2.2 算法原理2.2.1 状态表示2.2.2 状态转移方程2.2.3 初始化2.2.…
阅读更多...
性能测试学习之数据驱动性能测试

性能测试学习之数据驱动性能测试

了解数据驱动测试理念、能够如何在jmeter中用多种方式实现数据驱动测试。 知识点&#xff1a;字符串拼接、计数器、循环控制器 1. 数据驱动的理念 1.1 定义 从数据文件中读取测试数据,驱动测试过程的一-种测试方法数据驱动可以理解为更高级的参数化 1.2 特点 测试数据与测试…
阅读更多...
【Linux】socket 编程（socket套接字介绍、字节序、socket地址、IP地址转换函数、套接字函数、TCP通信实现）

【Linux】socket 编程（socket套接字介绍、字节序、socket地址、IP地址转换函数、套接字函数、TCP通信实现）

目录 1、socket套接字介绍2、字节序简介字节序转换函数 3、socket地址专用socket地址 4、IP地址转换函数5、套接字函数6、TCP通信实现&#xff08;服务器端和客户端&#xff09; 橙色 1、socket套接字介绍 所谓套接字&#xff0c;就是对网络中不同主机上的应用进程之间进行双…
阅读更多...
深入理解深度学习——Transformer：整合编码器（Encoder）和解码器Decoder）

深入理解深度学习——Transformer：整合编码器（Encoder）和解码器Decoder）

分类目录&#xff1a;《深入理解深度学习》总目录 相关文章&#xff1a; 注意力机制&#xff08;Attention Mechanism&#xff09;&#xff1a;基础知识 注意力机制&#xff08;Attention Mechanism&#xff09;&#xff1a;注意力汇聚与Nadaraya-Watson核回归 注意力机制&…
阅读更多...
国内唯一可以在本地搭建Stable Diffusion WebUI教程-安装时无需魔法安装全程流畅到尖叫

国内唯一可以在本地搭建Stable Diffusion WebUI教程-安装时无需魔法安装全程流畅到尖叫

Stable Diffusion是什么 Stable Diffusion简称SD是一款Ai图片生成工具。“输入几句话，生成精美图片。” 比如说我一开头这幅图片就是用的SD生成的。 我在我的“ChatGPT让我变成了“超人”-如何提升团队30%效能质量提高100%的阶段性总结报告”里提到过midjourney，但是midjou…
阅读更多...
使用Google工具类Guava自定义一个@Limiter接口限流注解

使用Google工具类Guava自定义一个@Limiter接口限流注解

在Springboot中引用RateLimiter工具类依赖 <dependency><groupId>com.google.guava</groupId><artifactId>guava</artifactId><version>30.1-jre</version> </dependency> 需要注意的是&#xff0c;Guava 的不同版本可能会有…
阅读更多...
新手第一次做性能测试？性能测试流程详全，从需求到报告一篇打通

新手第一次做性能测试？性能测试流程详全，从需求到报告一篇打通

目录&#xff1a;导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结&#xff08;尾部小惊喜&#xff09; 前言 1、确认需求 确定…
阅读更多...
3、互联网行业及产品经理分类

3、互联网行业及产品经理分类

上一篇文章&#xff1a;2、产品经理的工作内容_阿杰学编程的博客-CSDN博客 1、产品经理分类 我们把产品经理划分成这样两个大的类型&#xff0c;一个是传统行业的&#xff0c;一个是互联网行业的。这个简单了解一下就行。 这个里面会发现绝大多数也是体育劳动&#xff0c;你比…
阅读更多...
软件测试岗位都是女孩子在做吗？

软件测试岗位都是女孩子在做吗？

听我一朋友说&#xff0c;测试岗位基本都是女孩子做。” 不知道是不是以前“软件测试岗”给人印象是“不需要太多技术含量”的错觉&#xff0c;从而大部分外行认为从业软件测试的人员中女生应占了大多数。比如有人就觉得&#xff1a;软件测试主要是细心活&#xff0c;所以女生…
阅读更多...
2023 年各大互联网公司常见面试题（Java 岗）汇总

2023 年各大互联网公司常见面试题（Java 岗）汇总

很多人都说今年对于 IT 行业根本没有所谓的“金三银四”“金九银十”。在各大招聘网站或者软件上不管是大厂还是中小公司大多都是挂个招聘需求&#xff0c;实际并不招人&#xff1b;在行业内的程序员基本都已经感受到了任老前段时间口中所谓的“寒气”。 虽然事实确实是如此&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023