Spring高手之路19——Spring AOP注解指南

文章目录

  • 1. 背景
  • 2. 基于AspectJ注解来实现AOP
  • 3. XML实现和注解实现AOP的代码对比
  • 4. AOP通知讲解
  • 5. AOP时序图

1. 背景

  在现代软件开发中，面向切面编程（AOP）是一种强大的编程范式，允许开发者跨越应用程序的多个部分定义横切关注点（如日志记录、事务管理等）。本文将介绍如何在Spring框架中通过AspectJ注解以及对应的XML配置来实现AOP，在不改变主业务逻辑的情况下增强应用程序的功能。

2. 基于AspectJ注解来实现AOP

对于一个使用Maven的Spring项目，需要在pom.xml中添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.6</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.6</version>
    </dependency>
</dependencies>

确保版本号与使用的Spring版本相匹配，可以自行调整。

  1. 创建业务逻辑接口MyService：
package com.example.demo.aop;


public interface MyService {
    void performAction();
}
  1. 创建业务逻辑类MyServiceImpl.java：
package com.example.demo.aop;

import org.springframework.stereotype.Service;

@Service
public class MyServiceImpl implements MyService {
    @Override
    public void performAction() {
        System.out.println("Performing an action in MyService");
    }
}
  1. 定义切面

创建切面类MyAspect.java，并使用注解定义切面和通知：

package com.example.demo.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")
    public void logBeforeAction() {
        System.out.println("Before performing action");
    }
}

  @Aspect注解是用来标识一个类作为AspectJ切面的一种方式，这在基于注解的AOP配置中是必需的。它相当于XML配置中定义切面的方式，但使用注解可以更加直观和便捷地在类级别上声明切面，而无需繁琐的XML配置。

  1. 配置Spring以启用注解和AOP

  创建一个Java配置类来代替XML配置，使用@Configuration注解标记为配置类，并通过@ComponentScan注解来启用组件扫描，通过@EnableAspectJAutoProxy启用AspectJ自动代理：

package com.example.demo.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy
public class AppConfig {
}

  @EnableAspectJAutoProxy注解在Spring中用于启用对AspectJ风格的切面的支持。它告诉Spring框架去寻找带有@Aspect注解的类，并将它们注册为Spring应用上下文中的切面，以便在运行时通过代理方式应用这些切面定义的通知（Advice）和切点（Pointcuts）。

  如果不写@EnableAspectJAutoProxy，Spring将不会自动处理@Aspect注解定义的切面，则定义的那些前置通知（@Before）、后置通知（@After、@AfterReturning、@AfterThrowing）和环绕通知（@Around）将不会被自动应用到目标方法上。这意味着定义的AOP逻辑不会被执行，失去了AOP带来的功能增强。

  @Before 注解定义了一个前置通知（Advice），它会在指定方法执行之前运行。切点表达式execution(* com.example.demo.aop.MyServiceImpl.performAction(..))精确地定义了这些连接点的位置。在这个例子中，切点表达式指定了MyServiceImpl类中的performAction方法作为连接点，而@Before注解标识的方法（logBeforeAction）将在这个连接点之前执行，即logBeforeAction方法（前置通知）会在performAction执行之前被执行。

  1. 创建主类和测试AOP功能

主程序如下：

package com.example.demo;

import com.example.demo.aop.MyService;
import com.example.demo.config.AppConfig;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service = context.getBean(MyService.class);
        service.performAction();
    }
}

运行结果如下：

在这里插入图片描述

3. XML实现和注解实现AOP的代码对比

  对于上面的代码，我们将原有基于注解的AOP配置改写为完全基于XML的形式，方便大家对比。首先需要移除切面类和业务逻辑类上的所有Spring相关注解，然后在XML文件中配置相应的bean和AOP逻辑。

移除注解
首先，我们移除业务逻辑类和切面类上的所有注解。

MyService.java (无变化，接口保持原样):

package com.example.demo.aop;

public interface MyService {
    void performAction();
}

MyServiceImpl.java (移除@Service注解):

package com.example.demo.aop;

public class MyServiceImpl implements MyService {
    @Override
    public void performAction() {
        System.out.println("Performing an action in MyService");
    }
}

MyAspect.java (移除@Aspect和@Component注解，同时去掉方法上的@Before注解):

package com.example.demo.aop;

public class MyAspect {
    public void logBeforeAction() {
        System.out.println("Before performing action");
    }
}

XML配置

接下来，删除AppConfig配置类，在Spring的XML配置文件中定义beans和AOP配置。

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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 定义业务逻辑bean -->
    <bean id="myService" class="com.example.demo.aop.MyServiceImpl"/>

    <!-- 定义切面 -->
    <bean id="myAspect" class="com.example.demo.aop.MyAspect"/>

    <!-- AOP配置 -->
    <aop:config>
        <aop:aspect id="aspect" ref="myAspect">
            <aop:pointcut id="serviceOperation" expression="execution(* com.example.demo.aop.MyService.performAction(..))"/>
            <aop:before pointcut-ref="serviceOperation" method="logBeforeAction"/>
        </aop:aspect>
    </aop:config>
</beans>

  在这个XML配置中，我们手动注册了MyServiceImpl和MyAspect作为beans，并通过<aop:config>元素定义了AOP逻辑。我们创建了一个切点serviceOperation，用于匹配MyService.performAction(..)方法的执行，并定义了一个前置通知，当匹配的方法被调用时，MyAspect的logBeforeAction方法将被执行。

主类和测试AOP功能

主类DemoApplication的代码不需要改变，只是在创建ApplicationContext时使用XML配置文件而不是Java配置类：

package com.example.demo;

import com.example.demo.aop.MyService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyService service = context.getBean(MyService.class);
        service.performAction();
    }
}

运行结果是一样的

在这里插入图片描述

4. AOP通知讲解

  在Spring AOP中，通知（Advice）定义了切面（Aspect）在目标方法调用过程中的具体行为。Spring AOP支持五种类型的通知，它们分别是：前置通知（Before）、后置通知（After）、返回通知（After Returning）、异常通知（After Throwing）和环绕通知（Around）。通过使用这些通知，开发者可以在目标方法的不同执行点插入自定义的逻辑。

  • @Before（前置通知）

前置通知是在目标方法执行之前执行的通知，通常用于执行一些预处理任务，如日志记录、安全检查等。

@Before("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")
public void logBeforeAction() {
    System.out.println("Before performing action");
}
  • @AfterReturning（返回通知）

返回通知在目标方法成功执行之后执行，可以访问方法的返回值。

@AfterReturning(pointcut = "execution(* com.example.demo.aop.MyServiceImpl.performAction(..))", returning = "result")
public void logAfterReturning(Object result) {
    System.out.println("Method returned value is : " + result);
}

  这里在@AfterReturning注解中指定returning = "result"时，Spring AOP框架将目标方法的返回值传递给切面方法的名为result的参数，因此，切面方法需要有一个与之匹配的参数，类型兼容目标方法的返回类型。如果两者不匹配，Spring在启动时会抛出异常，因为它无法将返回值绑定到切面方法的参数。

  • @AfterThrowing（异常通知）

异常通知在目标方法抛出异常时执行，允许访问抛出的异常。

@AfterThrowing(pointcut = "execution(* com.example.demo.aop.MyServiceImpl.performAction(..))", throwing = "ex")
public void logAfterThrowing(JoinPoint joinPoint, Throwable ex) {
    String methodName = joinPoint.getSignature().getName();
    System.out.println("@AfterThrowing: Exception in method: " + methodName + "; Exception: " + ex.toString());
}

  在@AfterThrowing注解的方法中包含JoinPoint参数是可选的，当想知道哪个连接点（即方法）引发了异常的详细信息时非常有用，假设有多个方法可能抛出相同类型的异常，而我们想在日志中明确指出是哪个方法引发了异常。通过访问JoinPoint提供的信息，可以记录下引发异常的方法名称和其他上下文信息，从而使得日志更加清晰和有用。

  • @After（后置通知）

后置通知在目标方法执行之后执行，无论方法执行是否成功，即便发生异常，仍然会执行。它类似于finally块。

@After("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")
public void logAfter() {
    System.out.println("After performing action");
}
  • @Around（环绕通知）

环绕通知围绕目标方法执行，可以在方法调用前后执行自定义逻辑，同时决定是否继续执行目标方法。环绕通知提供了最大的灵活性和控制力。

@Around("execution(* com.example.demo.aop.MyServiceImpl.performAction(..))")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Before method execution");
    Object result = joinPoint.proceed(); // 继续执行目标方法
    System.out.println("After method execution");
    return result;
}

接下来，我们来演示一下，全部代码如下：

服务接口（MyService.java）:

package com.example.demo.aop;

public interface MyService {
    String performAction(String input);
}

服务实现（MyServiceImpl.java）:

修改performAction方法，使其在接收到特定输入时抛出异常

package com.example.demo.aop;

import org.springframework.stereotype.Service;

@Service
public class MyServiceImpl implements MyService {
    @Override
    public String performAction(String input) {
        System.out.println("Performing action with: " + input);
        if ("error".equals(input)) {
            throw new RuntimeException("Simulated error");
        }
        return "Processed " + input;
    }
}

完整的切面类（包含所有通知类型）

切面类（MyAspect.java） - 保持不变，确保包含所有类型的通知：

package com.example.demo.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAspect {

    @Before("execution(* com.example.demo.aop.MyService.performAction(..))")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("@Before: Before calling performAction");
    }

    @After("execution(* com.example.demo.aop.MyService.performAction(..))")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("@After: After calling performAction");
    }

    @AfterReturning(pointcut = "execution(* com.example.demo.aop.MyService.performAction(..))", returning = "result")
    public void afterReturningAdvice(JoinPoint joinPoint, Object result) {
        System.out.println("@AfterReturning: Method returned value is : " + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.demo.aop.MyService.performAction(..))", throwing = "ex")
    public void afterThrowingAdvice(JoinPoint joinPoint, Throwable ex) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("@AfterThrowing: Exception in method: " + methodName + "; Exception: " + ex.toString());
    }

    @Around("execution(* com.example.demo.aop.MyService.performAction(..))")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("@Around: Before method execution");
        Object result = null;
        try {
            result = proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
        	// 如果执行方法出现异常，打印这里
            System.out.println("@Around: Exception in method execution");
            throw throwable;
        }
        // 如果执行方法正常，打印这里
        System.out.println("@Around: After method execution");
        return result;
    }
}

这里要强调几点：

  1. @Around环绕通知常见用例是异常捕获和重新抛出。在这个例子中，我们通过ProceedingJoinPoint的proceed()方法调用目标方法。如果目标方法执行成功，记录执行后的消息并返回结果。如果在执行过程中发生异常，在控制台上打印出异常信息，然后重新抛出这个异常。这样做可以确保异常不会被吞没，而是可以被上层调用者捕获或由其他异常通知处理。

  2. @AfterThrowing注解标明这个通知只有在目标方法因为异常而终止时才会执行。throwing属性指定了绑定到通知方法参数上的异常对象的名称。这样当异常发生时，异常对象会被传递到afterThrowingAdvice方法中，方法中可以对异常进行记录或处理。

  3. @AfterThrowing和@AfterReturning通知不会在同一个方法调用中同时执行。这两个通知的触发条件是互斥的。@AfterReturning 通知只有在目标方法成功执行并正常返回后才会被触发，这个通知可以访问方法的返回值。@AfterThrowing 通知只有在目标方法抛出异常时才会被触发，这个通知可以访问抛出的异常对象。

  4. 假设想要某个逻辑总是在方法返回时执行，不管是抛出异常还是正常返回，则考虑放在@After或者@Around通知里执行。

配置类

package com.example.demo.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.example")
@EnableAspectJAutoProxy
public class AppConfig {
}

测试不同情况

为了测试所有通知类型的触发，在主类中执行performAction方法两次：一次传入正常参数，一次传入会导致异常的参数。

主程序如下：

package com.example.demo;

import com.example.demo.aop.MyService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service = context.getBean(MyService.class);

        try {
            // 正常情况
            System.out.println("Calling performAction with 'test'");
            service.performAction("test");

            // 异常情况
            System.out.println("\nCalling performAction with 'error'");
            service.performAction("error");
        } catch (Exception e) {
            System.out.println("Exception caught in DemoApplication: " + e.getMessage());
        }
    }
}

在这个例子中，当performAction方法被第二次调用并传入"error"作为参数时，将会抛出异常，从而触发@AfterThrowing通知。

运行结果如下：

在这里插入图片描述

5. AOP时序图

  这里展示在Spring AOP框架中一个方法调用的典型处理流程，包括不同类型的通知（Advice）的执行时机。

在这里插入图片描述

  1. 客户端调用方法：
  • 客户端（Client）发起对某个方法的调用。这个调用首先被AOP代理（AOP Proxy）接收，这是因为在Spring AOP中，代理负责在真实对象（Target）和外界之间进行中介。
  1. 环绕通知开始 (@Around)：
  • AOP代理首先调用切面（Aspect）中定义的环绕通知的开始部分。环绕通知可以在方法执行前后执行代码，并且能决定是否继续执行方法或直接返回自定义结果。这里的“开始部分”通常包括方法执行前的逻辑。
  1. 前置通知 (@Before)：
  • 在目标方法执行之前，执行前置通知。这用于在方法执行前执行如日志记录、安全检查等操作。
  1. 执行目标方法：
  • 如果环绕通知和前置通知没有中断执行流程，代理会调用目标对象（Target）的实际方法。
  1. 方法完成：
  • 方法执行完成后，控制权返回到AOP代理。这里的“完成”可以是成功结束，也可以是抛出异常。
  1. 返回通知或异常通知：
  • 返回通知 (@AfterReturning)：如果方法成功完成，即没有抛出异常，执行返回通知。这可以用来处理方法的返回值或进行某些后续操作。
  • 异常通知 (@AfterThrowing)：如果方法执行过程中抛出异常，执行异常通知。这通常用于异常记录或进行异常处理。
  1. 后置通知 (@After)：
  • 独立于方法执行结果，后置通知总是会执行。这类似于在编程中的finally块，常用于资源清理。
  1. 环绕通知结束 (@Around)：
  • 在所有其他通知执行完毕后，环绕通知的结束部分被执行。这可以用于执行清理工作，或者在方法执行后修改返回值。
  1. 返回结果：
  • 最终，AOP代理将处理的结果返回给客户端。这个结果可能是方法的返回值，或者通过环绕通知修改后的值，或者是异常通知中处理的结果。

欢迎一键三连~

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

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

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

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

相关文章

数据隐私重塑：Web3时代的隐私保护创新

数据隐私重塑：Web3时代的隐私保护创新

随着数字化时代的不断深入&#xff0c;数据隐私保护已经成为了人们越来越关注的焦点之一。而在这个数字化时代的新篇章中&#xff0c;Web3技术作为下一代互联网的代表&#xff0c;正在为数据隐私保护带来全新的创新和可能性。本文将深入探讨数据隐私的重要性&#xff0c;Web3时…
阅读更多...
解锁数据宝藏：高效查找算法揭秘

解锁数据宝藏：高效查找算法揭秘

代码下载链接&#xff1a;https://gitee.com/flying-wolf-loves-learning/data-structure.git 目录 一、查找的原理 1.1 查找概念 1.2 查找方法 1.3平均查找长度 1.4顺序表的查找 1.5 顺序表的查找算法及分析 1.6 折半查找算法及分析 1.7 分块查找算法及分析 1.8 总结…
阅读更多...
很多人讲不明白HTTPS，但是我能

很多人讲不明白HTTPS，但是我能

很多人讲不明白HTTPS&#xff0c;但是我能 今天我们用问答的形式&#xff0c;来彻底弄明白HTTPS的过程 下面的问题都是 小明和小丽两个人通信为例 可以把小明想象成服务端&#xff0c;小丽想象成客户端 1. https是做什么用的&#xff1f; 答&#xff1a;数据安全传输用的。…
阅读更多...
数学建模 —— 聚类分析（3）

数学建模 —— 聚类分析（3）

目录 一、聚类分析概述 1.1 常用聚类要素的数据处理 1.1.1 总和标准化 1.1.2 标准差标准化 1.1.3 极大值标准化 1.1.4 极差的标准化 1.2 分类 1.2.1 快速聚类法&#xff08;K-均值聚类&#xff09; 1.2.2 系统聚类法&#xff08;分层聚类法&#xff09; 二、分类统计…
阅读更多...
Ubuntu18.04安装pwntools报错解决方案

Ubuntu18.04安装pwntools报错解决方案

报错1&#xff1a;ModuleNotFoundError: No module named ‘setuptools_rust’ 报错信息显示ModuleNotFoundError: No module named setuptools_rust&#xff0c;如下图所示 解决方案&#xff1a;pip install setuptools_rust 报错2&#xff1a;pip版本低 解决方案&#xff…
阅读更多...
【数据结构（邓俊辉）学习笔记】图02——搜索

【数据结构（邓俊辉）学习笔记】图02——搜索

文章目录 0. 概述1. 广度优先搜索1.1 策略1.2 实现1.3 可能情况1.4 实例1.5 多联通1.6 复杂度1.7 最短路径 2. 深度优先搜索2.1 算法2.2 框架2.3 细节2.4 无向边2.5 有向边2.6 多可达域2.7 嵌套引理 3 遍历算法的应用 0. 概述 此前已经介绍过图的基本概念以及它在计算机中的表…
阅读更多...
设计模式（十四）行为型模式---访问者模式（visitor）

设计模式（十四）行为型模式---访问者模式（visitor）

文章目录 访问者模式简介分派的分类什么是双分派&#xff1f;结构UML图具体实现UML图代码实现 优缺点 访问者模式简介 访问者模式&#xff08;visitor pattern&#xff09;是封装一些作用于某种数据结构中的元素的操作&#xff0c;它可以在不改变这个数据结构&#xff08;实现…
阅读更多...
Visual Studio Installer 点击闪退

Visual Studio Installer 点击闪退

Visual Studio Installer 点击闪退问题 1. 问题描述2. 错误类型3. 解决方法4. 结果5. 说明6. 参考 1. 问题描述 重装了系统后&#xff08;系统版本&#xff1a;如下图所示&#xff09;&#xff0c;我从官方网站&#xff08;https://visualstudio.microsoft.com/ ) 下载了安装程…
阅读更多...
Three.js-实现加载图片并旋转

Three.js-实现加载图片并旋转

1.实现效果 2. 实现步骤 2.1创建场景 const scene new THREE.Scene(); 2.2添加相机 说明&#xff1a; fov&#xff08;视场角&#xff09;&#xff1a;视场角决定了相机的视野范围&#xff0c;即相机可以看到的角度范围。较大的视场角表示更广阔的视野&#xff0c;但可能…
阅读更多...
如何在镜像中安装固定版本的node和npm

如何在镜像中安装固定版本的node和npm

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、使用 Dockerfile 创建自定义镜像二、如何安装固定版本的node及npm总结 前言 最近在做前端工程化相关的内容&#xff0c;需要在一个镜像内安装固定版本的 N…
阅读更多...
Microservices with Martin Fowler

Microservices with Martin Fowler

Summary The article “Microservices” by Martin Fowler discusses an architectural style for software systems that has been gaining popularity due to its flexibility and scalability. Here’s a summary highlighting the key points: Microservice Architectural…
阅读更多...
十_信号4-SIGCHLD信号

十_信号4-SIGCHLD信号

SIGCHLD信号 在学习进程控制的时候&#xff0c;使用wait和waitpid系统调用何以回收僵尸进程&#xff0c;父进程可以阻塞等待&#xff0c;也可以非阻塞等待&#xff0c;采用轮询的方式不停查询子进程是否退出。 采用阻塞式等待&#xff0c;父进程就被阻塞了&#xff0c;什么都干…
阅读更多...
【魅力网页的背后】：CSS基础魔法，从零打造视觉盛宴

【魅力网页的背后】：CSS基础魔法，从零打造视觉盛宴

文章目录 &#x1f680;一、css基础知识⭐1. 认识css &#x1f308;二、选择器初级❤️id与class命名 &#x1f680;一、css基础知识 ⭐1. 认识css 概念 CSS(英文全称&#xff1a;Cascading Style Sheets)&#xff0c;层叠样式表。它是网页的装饰者&#xff0c;用来修饰各标签…
阅读更多...
YOLOv5改进（六）--引入YOLOv8中C2F模块

YOLOv5改进（六）--引入YOLOv8中C2F模块

文章目录 1、前言2、C3模块和C2F模块2.1、C3模块2.2、BottleNeck模块2.3、C2F模块 3、C2F代码实现3.1、common.py3.2、yolo.py3.3、yolov5s_C2F.yaml 4、目标检测系列文章 1、前言 本文主要使用YOLOv8的C2F模块替换YOLOv5中的C3模块&#xff0c;经过实验测试&#xff0c;发现Y…
阅读更多...
深圳雷龙LSYT201B语音控制模组

深圳雷龙LSYT201B语音控制模组

文章目录 前言一、芯片简介处理器外设音频蓝牙电源封装温度 二、功能简介管脚描述 三、应用场景四、使用说明五、硬件连接六、FAQ总结 前言 今天拿到的语音控制板是LSYT201B模组&#xff0c;它是深圳市雷龙发展有限公司基于YT2228芯片开发的一款面向智能家居控制的离线语音控制…
阅读更多...
SSM高校社团管理系统-计算机毕业设计源码86128

SSM高校社团管理系统-计算机毕业设计源码86128

目 录 摘要 1 绪论 1.1研究背景与意义 1.2开发现状 1.3研究方法 1.4 ssm框架介绍 1.5论文结构与章节安排 2 高校社团管理系统系统分析 2.1 可行性分析 2.2 系统流程分析 2.2.1数据增加流程 2.2.2数据修改流程 2.2.3数据删除流程 2.3 系统功能分析 2.3.1 功能性分…
阅读更多...
大模型部署_书生浦语大模型 _作业2基本demo

大模型部署_书生浦语大模型 _作业2基本demo

本节课可以让同学们实践 4 个主要内容&#xff0c;分别是&#xff1a; 1、部署 InternLM2-Chat-1.8B 模型进行智能对话 1.1安装依赖库&#xff1a; pip install huggingface-hub0.17.3 pip install transformers4.34 pip install psutil5.9.8 pip install accelerate0.24.1…
阅读更多...
类和对象（一）（C++）

类和对象（一）（C++）

类和对象&#xff1a; 类的引入&#xff1a; C语言结构体中只能定义变量&#xff0c;在C中&#xff0c;结构体内不仅可以定义变量&#xff0c;也可以定义函数。比如&#xff1a; 之前在数据结构初阶中&#xff0c;用C语言方式实现的栈&#xff0c;结构体中只能定义变量&#…
阅读更多...
Java | Leetcode Java题解之第123题买卖股票的最佳时机III

Java | Leetcode Java题解之第123题买卖股票的最佳时机III

题目&#xff1a; 题解&#xff1a; class Solution {public int maxProfit(int[] prices) {int n prices.length;int buy1 -prices[0], sell1 0;int buy2 -prices[0], sell2 0;for (int i 1; i < n; i) {buy1 Math.max(buy1, -prices[i]);sell1 Math.max(sell1, b…
阅读更多...
Docker最新超详细版教程通俗易懂

Docker最新超详细版教程通俗易懂

文章目录 一、Docker 概述1. Docker 为什么出现2. Docker 的历史3. Docker 能做什么 二、Docker 安装1. Docker 的基本组成2. 安装 Docker3. 阿里云镜像加速4. 回顾 hello-world 流程5. 底层原理 三、Docker 的常用命令1. 帮助命令2. 镜像命令dokcer imagesdocker searchdocker…
阅读更多...
最新文章

Copyright @ 2022~2023