Spring | 事件监听器应用与最佳实践

news2024/10/7 20:30:33

引言

在复杂的软件开发环境中，组件之间的通信和信息交流显得尤为重要。Spring框架，作为Java世界中最受欢迎的开发框架之一，提供了一种强大的事件监听器模型，使得组件间的通信变得更加灵活和解耦。本文主要探讨Spring事件监听器的原理、使用方法及其在实际开发中的应用，希望为广大开发者提供实用的参考。

1.1 Spring事件监听器简介

Spring事件监听器是Spring应用中用于处理事件的一种机制。事件通常代表应用状态的变化，而监听器则负责响应这些变化。通过Spring的事件监听器，开发者可以在解耦的前提下，实现不同组件间的信息交流，提高代码的可维护性和可扩展性。

1.2 文章目的

本文旨在深入探讨Spring事件监听器的基本原理，引导读者如何在实际开发中使用监听器，并通过一些具体的例子来展示监听器的使用场景和实现方法。我们还将深入分析Spring监听器的源码，以期读者能更加深刻地理解其工作原理。希望通过本文，读者可以更加熟练地利用Spring事件监听器来构建灵活、可维护的应用。

以下所有示例均已上传至Github上，大家可以将项目拉取到本地进行运行

Github示例（如果对Gradle还不熟练，建议翻看我之前的文章）：gradle-spring-boot-demo

Spring事件监听器原理

理解Spring事件监听器的原理，是有效使用此机制的前提。这一章将深入探讨Spring事件监听器的核心组件以及它们如何协同工作。

2.1 组件介绍

在Spring的事件监听器模型中，主要涉及三个核心组件：事件（Event）、监听器（Listener）和事件发布器（Event Publisher）。

2.1.1 事件（Event）

事件通常是由某个特定的动作或者状态变化触发的。在Spring中，自定义事件通常需要继承ApplicationEvent类。事件类包含了事件的基本信息，例如事件源、发生时间等。

import org.springframework.context.ApplicationEvent;

public class CustomEvent extends ApplicationEvent {
    public CustomEvent(Object source) {
        super(source);
    }
}

2.1.2 监听器（Listener）

监听器负责接收并处理事件。在Spring中，监听器通常是实现ApplicationListener接口的类，需要定义一个onApplicationEvent方法来具体处理事件。

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        // 处理事件
        System.out.println("Received custom event - " + event);
    }
}

2.1.3 事件发布器（Event Publisher）

事件发布器的角色是将事件通知到所有注册的监听器。在Spring应用中，ApplicationEventPublisher接口负责事件的发布。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class CustomEventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void doSomethingAndPublishAnEvent(final String message) {
        System.out.println("Publishing custom event.");
        CustomEvent customEvent = new CustomEvent(message);
        applicationEventPublisher.publishEvent(customEvent);
    }
}

2.2 工作流程

事件监听器模型的基本工作流程如下：

  1. 事件源产生事件。
  2. 事件发布器发布事件。
  3. 注册的监听器接收到事件后进行处理。
    这种模型支持了组件之间的低耦合交互，使得开发者可以更灵活、更方便地进行开发。

如何使用Spring监听器

掌握了Spring事件监听器的基本原理和组成部分后，我们将进一步探讨如何在实际开发中使用它。通过定义事件、创建监听器和发布事件，我们可以实现不同组件间的信息交流。

3.1 定义事件

在Spring中，我们可以通过继承ApplicationEvent类来定义自己的事件。这个类需要包含所有与事件相关的信息。

public class TestEvent extends ApplicationEvent {
    private String message;

    public TestEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

在这个例子中，我们创建了一个名为TestEvent的事件类，该类中含有一个字符串类型的message字段，用于传递事件相关的信息。

3.2 创建监听器

事件定义好后，我们需要创建监听器来处理这个事件。监听器是实现了ApplicationListener接口的类，需要覆写onApplicationEvent方法来定义事件的处理逻辑。

@Component
public class TestEventListener implements ApplicationListener<TestEvent> {
    @Override
    public void onApplicationEvent(TestEvent testEvent) {
        // [3]在这里可以执行监听到事件后的逻辑, 监听到事件源，触发动作！
        System.out.println("监听到TestEvent：" + testEvent.getMessage());
    }
}

在这个例子中，我们定义了一个监听器TestEventListener，该监听器会打印出接收到的TestEvent事件中的message信息。

3.3 发布事件

最后，我们需要发布事件。事件的发布通常由事件发布器ApplicationEventPublisher来完成。

@Component
public class TestEventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publish(String message) {
        // [2]使用publishEvent方法发布事件，事件源为TestEvent
        applicationEventPublisher.publishEvent(new TestEvent(this, message));
    }
}

在这个例子中，TestEventPublisher类中的publishEvent方法会创建并发布一个新的TestEvent事件。
通过这三个步骤，我们就可以在Spring应用中实现事件的定义、监听和发布。这不仅有助于组件间的解耦，还能够增强代码的可维护性和可扩展性。

3.4 代码测试

@SpringBootTest
class GradleSpringBootDemoApplicationTests {


	@Autowired
	private TestEventPublisher testEventPublisher;

	@Test
	void contextLoads() {
		// [1] 发布事件
		testEventPublisher.publish("Hello, Spring!");
	}
}

执行完成，结果如下：
在这里插入图片描述

基于监听器设计模式的手写案例

为了更深入地理解Spring的监听器模式，我们来手写一个基于监听器设计模式的简单案例，逐步展示如何设计事件、监听器以及如何发布事件。

4.1 设计目标

我们将创建一个简单的用户注册系统。在用户成功注册之后，系统会发布一个注册事件，相关的监听器将监听这个事件，然后执行相应的操作，如发送欢迎邮件和记录日志。

4.2 实现步骤

4.2.1 定义事件

首先，我们定义一个用户注册成功的事件。该事件包含了用户的基本信息。

public class UserRegisterEvent {
    private final String username;
    private final String email;

    public UserRegisterEvent(String username, String email) {
        this.username = username;
        this.email = email;
    }

    // Getters
}

4.2.2 创建监听器

接下来，我们创建两个监听器：一个负责发送欢迎邮件，另一个负责记录用户注册日志。

public class WelcomeEmailListener {
    public void sendWelcomeEmail(UserRegisterEvent event) {
        System.out.println("Sending welcome email to " + event.getEmail());
    }
}

public class UserRegisterLogListener {
    public void logUserRegister(UserRegisterEvent event) {
        System.out.println("Logging user register: " + event.getUsername());
    }
}

4.2.3 发布事件

最后，我们创建一个用户注册服务，该服务在用户注册成功后发布事件。

import java.util.ArrayList;
import java.util.List;

public class UserRegisterService {
    private final List<Object> listeners = new ArrayList<>();

    public void registerUser(String username, String email) {
        // 用户注册逻辑（略）
        System.out.println("User registered: " + username);
        
        // 发布事件
        UserRegisterEvent event = new UserRegisterEvent(username, email);
        for (Object listener : listeners) {
            if (listener instanceof WelcomeEmailListener) {
                ((WelcomeEmailListener) listener).sendWelcomeEmail(event);
            } else if (listener instanceof UserRegisterLogListener) {
                ((UserRegisterLogListener) listener).logUserRegister(event);
            }
        }
    }

    public void addListener(Object listener) {
        listeners.add(listener);
    }
}

我们可以添加一个main方法来模拟用户的注册过程并触发事件的发布和监听。

public class Runner {
    public static void main(String[] args) {
        // 创建UserRegisterService实例
        UserRegisterService userRegisterService = new UserRegisterService();

        // 向UserRegisterService中添加监听器
        userRegisterService.addListener(new WelcomeEmailListener());
        userRegisterService.addListener(new UserRegisterLogListener());

        // 模拟用户注册
        userRegisterService.registerUser("JohnDoe", "john.doe@example.com");
    }
}

当你运行这个main方法时，UserRegisterService将执行注册逻辑，之后发布UserRegisterEvent事件，而WelcomeEmailListener和UserRegisterLogListener监听器将会捕获到这个事件并执行相应的操作。

在这里插入图片描述

运行结果如下：

User registered: kfaino
Sending welcome email to kfaino@example.com
Logging user register: kfaino

Spring监听器源码解读

在本章中，我们将探讨Spring监听器的实现细节，以更深入地理解Spring是如何设计和实现事件监听器的。

5.1 ApplicationEvent和ApplicationListener

ApplicationEvent和ApplicationListener是Spring事件监听机制的基石。

5.1.1 ApplicationEvent

ApplicationEvent是所有Spring事件的基类，它继承自java.util.EventObject。它包含了事件源和事件发生的时间戳。

public abstract class ApplicationEvent extends EventObject {
    private static final long serialVersionUID = 7099057708183571937L;
    private final long timestamp;

    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    public final long getTimestamp() {
        return this.timestamp;
    }
}

5.1.2 ApplicationListener

ApplicationListener是一个泛型接口，用于处理特定类型的事件。它包含一个方法onApplicationEvent，用户需要实现该方法来定义事件处理逻辑。

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

5.2 事件的发布

ApplicationEventPublisher是事件发布的核心接口。它定义了publishEvent方法，用于发布事件到所有匹配的监听器。

public interface ApplicationEventPublisher {
    void publishEvent(ApplicationEvent event);
    void publishEvent(Object event);
}

ApplicationContext继承了ApplicationEventPublisher接口，因此在Spring容器中，可以直接使用ApplicationContext来发布事件。

5.3 事件的传播

在Spring中，事件的传播是通过SimpleApplicationEventMulticaster类来实现的。这个类有一个multicastEvent方法，它会将事件传递给所有匹配的监听器。

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

    @Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        for (final ApplicationListener<?> listener : getApplicationListeners(event, eventType)) {
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            } else {
                invokeListener(listener, event);
            }
        }
    }
}

此方法中，getApplicationListeners用于获取所有匹配的监听器，然后invokeListener方法被用来触发这些监听器。

5.4 总结

通过深入分析Spring事件监听器的源码，我们可以更清晰地理解Spring是如何实现事件的定义、发布和处理的，这有助于我们更有效地在实际开发中使用这一机制。

Spring内置事件

Spring框架本身提供了一些内置的事件，这些事件代表了容器的一些生命周期阶段或特定操作，可以帮助我们更好地监控和管理应用。

6.1 ContextRefreshedEvent

ContextRefreshedEvent事件在Spring容器初始化或刷新时触发，即当所有的Bean都已经被成功加载、后处理器已经被调用，和所有单例Bean都已经被预实例化之后。

@EventListener
public void handleContextRefresh(ContextRefreshedEvent event) {
    System.out.println("Context Refreshed: " + event.getTimestamp());
}

在SpringBoot中，我们可以编写如下代码：

@Component
public class MyServletContextListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        // TODO 在这里可以执行一些初始化操作，比如查询数据库，缓存数据，加载配置等
        System.out.println("Spring容器加载完成触发");
    }
}

在Spring完成初始化后进行回调：
在这里插入图片描述

6.2 ContextClosedEvent

当Spring容器被关闭时，ContextClosedEvent事件会被触发。在这个阶段，所有的单例Bean都已经被销毁。

@EventListener
public void handleContextClose(ContextClosedEvent event) {
    System.out.println("Context Closed: " + event.getTimestamp());
}

6.3 ContextStartedEvent

当使用ConfigurableApplicationContext的start()方法启动Spring上下文时，会触发ContextStartedEvent事件。

@EventListener
public void handleContextStart(ContextStartedEvent event) {
    System.out.println("Context Started: " + event.getTimestamp());
}

6.4 ContextStoppedEvent

相对应地，当使用ConfigurableApplicationContext的stop()方法停止Spring上下文时，会触发ContextStoppedEvent事件。

@EventListener
public void handleContextStop(ContextStoppedEvent event) {
    System.out.println("Context Stopped: " + event.getTimestamp());
}

6.5 ApplicationReadyEvent

ApplicationReadyEvent事件在Spring应用运行完毕并准备接受请求时触发。

@EventListener
public void handleApplicationReady(ApplicationReadyEvent event) {
    System.out.println("Application Ready: " + event.getTimestamp());
}

6.6 其他事件

除了上述事件外，Spring还提供了一系列其他的内置事件，如RequestHandledEvent、ServletRequestHandledEvent等，可以帮助我们更全面地了解和管理应用的运行状态。

6.7 总结

了解和利用Spring的内置事件，可以帮助我们更加方便快捷地监控应用的生命周期和运行状态，优化应用性能和稳定性。同时，这也为我们提供了一种方便的手段，通过监听这些事件，执行自定义的逻辑，满足不同的业务需求。

优缺点分析

在这一章中，我们将详细探讨Spring监听器的优点和缺点。了解这些优缺点将帮助我们更为明智地决定何时以及如何使用Spring监听器。

7.1 优点

  • 低耦合性: Spring监听器允许不同组件之间交互，而无需它们直接相互引用，有助于实现代码的低耦合和高内聚。
  • 易于扩展: 通过监听器，可以方便地对系统进行扩展，为系统添加新的功能或行为，而无需修改现有代码。
  • 强大的事件处理能力: Spring提供的事件处理机制强大而灵活，可应对各种复杂的业务场景，满足多样化的业务需求。
  • 提高模块性: 监听器可以清晰地分隔关注点，有助于将不同功能的代码组织在不同的模块中，提高了代码的可维护性和可读性。

7.2 缺点

  • 性能开销: 监听器的使用会带来一定的性能开销，特别是在大量事件被触发和处理时，这可能会成为系统性能的瓶颈。
  • 复杂性: 当系统中存在大量的监听器和事件时，管理和维护这些监听器和事件的复杂性将增加，可能导致错误和难以调试的问题。
  • 不适合所有场景: 监听器并不适合所有场景。在一些简单的、需要快速响应的场合，引入监听器可能会显得过于重和繁琐。

7.3 权衡与建议

在考虑使用Spring监听器时，应该权衡其带来的便利性和可能的缺点。在确实需要利用事件来实现模块间解耦的复杂业务场景下，Spring监听器是一个非常合适的选择。但是，在不需要解耦的简单场景下，应该考虑避免使用监听器，以减少不必要的复杂性和性能开销。

最佳实践

在实际开发中，如何更为合理和高效地使用Spring监听器是至关重要的。以下是一些关于使用Spring监听器的最佳实践，可以帮助您更加明智和灵活地应用Spring监听器。

8.1 明确事件类型

在定义事件时，要清晰、明确地标明事件的类型和它所携带的信息，确保事件可以准确地反映出系统的状态变化。这也有助于代码的可读性和可维护性。

8.2 合理划分监听器职责

每个监听器都应该有一个明确且单一的职责。避免在一个监听器中处理过多不相关的逻辑，这将使得监听器变得复杂并难以维护。

8.3 优化事件发布

避免过度发布事件。例如，在循环中发布事件，或发布含有大量不必要信息的事件，都可能导致性能问题。在发布事件时要精确控制事件的范围和内容，避免不必要的性能开销。

8.4 使用异步监听器

在适合的场合，利用异步监听器可以提高系统的响应性和吞吐量。异步监听器可以在单独的线程中处理事件，防止阻塞主线程，提高系统的可用性。

@Async
@EventListener
public void handleAsyncEvent(MyEvent event) {
    // 处理事件
}

8.5 精心设计事件传播机制

根据业务需求，合理设计事件的传播机制。有时，事件需要按照一定的顺序传播，或者在某个监听器处理后停止传播，这时就需要精心设计事件的传播策略。

8.6 有效管理监听器

对于系统中的所有监听器，需要进行有效的管理和维护。定期审查监听器的代码，确保其符合设计原则，同时要及时更新和优化监听器，保持其高效运行。

8.7 注重监听器的测试

监听器中的业务逻辑也需要进行充分的测试。针对监听器的不同逻辑，编写单元测试和集成测试，确保监听器在各种情况下都能正确工作。

8.8 文档和注释

为监听器和事件提供清晰、完整的文档和注释，有助于团队成员理解代码的功能和用法，提高团队的开发效率。

8.9 保持学习和研究

Spring框架和Java语言本身在不断发展和更新，时刻关注它们的新特性和改进，学习和掌握最新的开发技巧和最佳实践，将有助于提高您在使用Spring监听器时的开发效率和代码质量。

8.10 总结

遵循上述最佳实践，可以帮助您更为合理、高效地使用Spring监听器，构建出更加健壮、可维护和高效的系统。同时，也要根据具体的业务需求和场景，灵活运用和调整这些实践原则，实现真正符合业务需求的解决方案。

总结

在本文中，我们深入探讨了Spring监听器的原理、使用方法、基于监听器设计模式的实际案例、Spring的内置事件、源码分析、优缺点以及最佳实践。下面我们将进行一个简短的回顾和总结。

9.1 回顾

通过学习，我们了解到：

  • Spring监听器原理：Spring监听器是基于观察者设计模式实现的，允许我们在不修改已有代码的基础上，增加对特定事件的响应。
  • 使用方法：我们学习了如何定义、注册和使用监听器以及如何发布事件。
  • 手写案例：我们通过一个实际案例理解了如何基于监听器设计模式来实现事件监听和处理。
  • Spring内置事件：Spring提供了一系列内置事件，帮助我们更好地管理和监控应用的生命周期和运行状态。
  • 源码分析：我们深入源码，探究了Spring监听器的工作机制和实现细节。
  • 优缺点：我们分析了Spring监听器的优缺点，明白在什么场景下使用监听器是合适的，以及需要注意的问题。
  • 最佳实践：我们学习了一系列最佳实践，以指导如何更加合理和高效地使用Spring监听器。

9.2 结语

希望本文能帮助您更深入地理解Spring监听器，掌握其使用方法和最佳实践，从而更为高效地开发出优质的软件产品。同时，也期望您能够不断学习、实践和探索，发现更多的使用Spring监听器的可能性和创新方法。
如果您对本文有任何建议或问题，请随时提出。感谢您的阅读！

参考文献

  1. 这次终于把Spring的监听器讲明白了 - 知乎
  2. 深入浅出Spring/SpringBoot 事件监听机制 - 知乎
  3. Spring 监听器listener原理-spring监听器源码分析（三） - CSDN
  4. spring–监听器（listener）原理解析 - CSDN
  5. Spring事件监听器之@EventListener原理 - CSDN
  6. 4.1 Spring源码 — 监听器的原理(一) - 掘金
  7. Spring Boot技术内幕：架构设计与实现原理
  8. Spring实战（第5版 ） - 豆瓣
  9. Spring源码深度解析（第2版） - 豆瓣
  10. Spring Boot源码解读与原理剖析 - 豆瓣

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

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

相关文章

数据治理-组织触点

数据治理-组织触点

协调工作的一部分包括为数据治理工作制定组织接触点 采购和合同&#xff1a;首席数据官与供应商/合作伙伴的管理部门或者采购部门合作&#xff0c;制定和执行有关数据管理合同的标准文本。 预算和资金&#xff1a;如果首席数据官没有直接孔子所有与数据采购相关的预算&#xff…
阅读更多...
sns.load_dataset(“iris“)报错原因探究+解决办法

sns.load_dataset(“iris“)报错原因探究+解决办法

问题描述 import seaborn as sns # 读取数据 iris sns.load_dataset("iris")在代码中使用了seaborn &#xff0c;并加载iris数据&#xff0c;结果产生了报错信息如下所示 问题分析 原因很简单&#xff0c;我们使用了sns.load_dataset("iris")来加载数据…
阅读更多...
在Python中创建相关系数矩阵的6种方法

在Python中创建相关系数矩阵的6种方法

相关系数矩阵&#xff08;Correlation matrix&#xff09;是数据分析的基本工具。它们让我们了解不同的变量是如何相互关联的。在Python中&#xff0c;有很多个方法可以计算相关系数矩阵&#xff0c;今天我们来对这些方法进行一个总结 Pandas Pandas的DataFrame对象可以使用c…
阅读更多...
解决编译中遇到的问题：Please port gnulib freadahead.c to your platform

解决编译中遇到的问题：Please port gnulib freadahead.c to your platform

今天在编译旧版的gzip-1.7时遇到了一个错误&#xff1a; error: #error "Please port gnulib freadahead.c to your platform! Look at the definition of fflush, fread, ungetc on your system, then report this to bug-gnulib." 在网上搜了一下解决方法&#xf…
阅读更多...
C++核心编程——P39~P44-运算符重载

C++核心编程——P39~P44-运算符重载

运算符重载的概念:对已有的运算符重新进行定义&#xff0c;赋予其另一种功能&#xff0c;以适应不同的数据类型。 1.加号运算符重载 作用&#xff1a;实现两个自定义数据类型相加的运算。 例如&#xff1a;两个整型相加编译器知道该怎么进行运算&#xff0c;如果是两个自定义…
阅读更多...
zabbix实现邮箱告

zabbix实现邮箱告

开启pop3/smtp/imap 安装mailx、sendmail、sendmail-cf yum install s-nail-14.9.22-6.el9.x86_64 sendmail sendmail-cf 修改配置文件 /etc/mail.rc、/etc/php.ini 注意 php.ini 里面sendmail值会影响发送邮件 [rootzabbix-server mail]# vim /etc/mail.rc set fromfcj_xun…
阅读更多...
Mybatis 映射器与XML配置职责分离

Mybatis 映射器与XML配置职责分离

之前我们介绍了使用XML配置方式完成对数据的增删改查操作&#xff0c;使用此方式在实际调用时需要使用【命名空间.标签编号】的方式执行&#xff0c;此方式在编写SQL语句时很方便&#xff0c;而在执行SQL语句环节就显得不太优雅&#xff1b;另外我们也介绍了使用映射器完成对数…
阅读更多...
数据治理-数据资产估值

数据治理-数据资产估值

数据生命周期大多数阶段涉及成本。数据只有使用时才有价值&#xff0c;使用时数据还产生与风险相关的成本。因此&#xff0c;当使用数据的经济效益超过了上述成本时&#xff0c;就会显现其价值。 其他的度量价值的方式包括&#xff1a; 替换成本。数据替换或恢复的成本。包括组…
阅读更多...
齿轮减速机设备类网站pbootcms模板（PC端+手机端自适应）

齿轮减速机设备类网站pbootcms模板（PC端+手机端自适应）

齿轮减速机设备类网站pbootcms模板-手机端自适应&#xff0c;优化SEO效果 模板介绍&#xff1a; 这是一款基于PbootCMS内核开发的模板&#xff0c;专为机械设备和加工机械类企业设计。该模板具有简洁简单的页面设计&#xff0c;易于管理&#xff0c;同时还附带测试数据。通过使…
阅读更多...
操作系统：系统引导以及虚拟机

操作系统：系统引导以及虚拟机

1.操作系统引导的过程 ①CPU从一个特定主存地址开始取指令&#xff0c;执行ROM中的引导程序&#xff08;先进行硬件自检&#xff0c;再开机)②将磁盘的第一块&#xff1a;主引导记录读入内存&#xff0c;执行磁盘引导程序&#xff0c;扫描分区表③从活动分区&#xff08;又称主…
阅读更多...
在win10上格式化Linux启动盘

在win10上格式化Linux启动盘

U盘制作Linux启动盘后无法在win10上格式化恢复原来的大小&#xff0c;可采取下面的方法&#xff1a; 在win10上进行操作:打开cmd输入:diskpart enter健会弹出一个新的对话框。 在新的对话框中输入:list disk&#xff0c;会列出计算机的磁盘列表。 List item选择u盘的序号:sele…
阅读更多...
Levels - UE5中的建模相关

Levels - UE5中的建模相关

一些日常的笔记&#xff1b; 可以使用Shapes面板建立基础模型&#xff1a; 可以在PolyModel中继续细分模型&#xff1a; UE5中的建模有PolyGroups概念&#xff0c;可以在Attributes面板中直接编辑&#xff1a; 使用GrpPnt方式可以直接用笔刷设定新的PolyGroups&#xff0c;这样…
阅读更多...
2-python：标识符命名

2-python：标识符命名

一、常量与变量 ①常量&#xff1a;程序中值不发生改变的元素。 PI3.1415926 ②变量&#xff1a;程序中值发生改变或者可以发生改变的元素。 A9 a4 aA print(a) 二、标识符命名 Python语言允许采用大写字母、小写字母、下划线&#xff08;_&#xff09;等字符及其组合给变量…
阅读更多...
JUC第七讲：关键字final详解

JUC第七讲：关键字final详解

JUC第七讲&#xff1a;关键字final详解 final 关键字看上去简单&#xff0c;但是真正深入理解的人可以说少之又少。本文是JUC第七讲&#xff1a;关键字final详解&#xff0c;将常规的用法简化&#xff0c;提出一些用法和深入的思考。 文章目录 JUC第七讲&#xff1a;关键字fina…
阅读更多...
Nginx之gzip模块解读

Nginx之gzip模块解读

目录 gzip基本介绍 gzip工作原理 Nginx中的gzip 不建议开启Nginx中的gzip场景 gzip基本介绍 gzip是GNUzip的缩写&#xff0c;最早用于UNIX系统的文件压缩。HTTP协议上的gzip编码是一种用来改进web应用程序性能的技术&#xff0c;web服务器和客户端&#xff08;浏览器&…
阅读更多...
diskGenius专业版使用：windows系统下加载ext4 linux系统分区并备份还原资源（文件的拷贝进、出）

diskGenius专业版使用：windows系统下加载ext4 linux系统分区并备份还原资源（文件的拷贝进、出）

前言 EXT4是第四代扩展文件系统&#xff08;英语&#xff1a;Fourth extended filesystem&#xff0c;缩写为 ext4&#xff09;是Linux系统下的日志文件系统&#xff0c;是ext3文件系统的后继版本。 所以我们在windows系统下是不能识别的&#xff0c;也不能对其写入、拷贝出文…
阅读更多...
竞赛 基于深度学习的植物识别算法 - cnn opencv python

竞赛 基于深度学习的植物识别算法 - cnn opencv python

文章目录 0 前言1 课题背景2 具体实现3 数据收集和处理3 MobileNetV2网络4 损失函数softmax 交叉熵4.1 softmax函数4.2 交叉熵损失函数 5 优化器SGD6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **基于深度学习的植物识别算法 ** …
阅读更多...
如何使用 Pyinstaller 编译打包 Python 项目生成 exe 可执行文件（2023 年最新详细教程）

如何使用 Pyinstaller 编译打包 Python 项目生成 exe 可执行文件（2023 年最新详细教程）

pyinstaller 概述 PyInstaller 是一个将 Python 程序转换为独立可执行文件的工具。它能够在 Windows、Linux、Mac OS X、AIX 和 Solaris 等系统上运行。相较于其他类似的工具 PyInstaller 主要优点 1. PyInstaller 与任何 Python 版本兼容&#xff0c;从 2.3 版本开始支持。 …
阅读更多...
包含漏洞的str_replace函数绕过

包含漏洞的str_replace函数绕过

str_replace函数绕过&#xff08;双写就可以绕过&#xff09; DWVA中等级别的时候会有防御过滤&#xff0c;过滤之后之前的本地远程包含就会发生执行错误 本地包含绕过 因为把../会替换成空&#xff0c;所以原来有../的地方要写成 ..././ 这样中间的红色部分去掉之后还剩…
阅读更多...
大词表语言模型在续写任务上的一个问题及对策

大词表语言模型在续写任务上的一个问题及对策

©PaperWeekly 原创 作者 | 苏剑林 单位 | 科学空间 研究方向 | NLP、神经网络 对于 LLM 来说&#xff0c;通过增大 Tokenizer 的词表来提高压缩率&#xff0c;从而缩短序列长度、降低解码成本&#xff0c;是大家都喜闻乐见的事情。毕竟增大词表只需要增大 Embedding 层和…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023