学习 Spring 框架的第二天

最新推荐文章于 2024-10-15 23:23:29 发布
最新推荐文章于 2024-10-15 23:23:29 发布
阅读量88 收藏
点赞数 1
分类专栏： Spring 文章标签： 学习 spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LingHua_hhh/article/details/132451300
版权

一 . AOP的五种增强

                AOP的增强可以分为：前置增强、后置增强、环绕增强、异常增强、最终增强。

          学会AOP的五种增强方式可以帮助我们将通用的横切逻辑与核心业务逻辑分离开来，提高代码的重用性、可维护性和可扩展性，同时也方便了对非核心功能的管理和控制

               增强名称                                 作用
前置增强（Before Advice）在目标方法执行之前执行的横切逻辑。可以用于执行一些预处理操作，如参数验证、权限检查等。
后置增强（After Advice）在目标方法执行之后执行的横切逻辑。可以用于执行一些清理操作，如资源释放、日志记录等。
环绕增强（Around Advice）在目标方法执行前后都可以执行的横切逻辑。环绕增强可以完全控制目标方法的执行过程，可以选择是否调用目标方法以及何时调用。
异常增强（After Throwing Advice）在目标方法抛出异常时执行的横切逻辑。可以用于处理异常、发送通知等。
最终增强（After finally）它在目标方法执行结束后（无论是否发生异常）都会执行。最终增强通常用于资源清理或日志记录等必须执行的操作。

      ① 前置增强

               特点：

               a. 执行时机：前置增强在目标方法执行之前执行，可以在目标方法执行之前进行一些预处理操作。例如，参数验证、权限控制等。

               b. 无法阻止目标方法执行：前置增强不能中断目标方法的执行，只能在目标方法执行之前插入一些额外的逻辑操作。

               c. 参数传递：前置增强可以获取目标方法的参数信息，并根据需要对参数进行修改或验证。这使得我们可以在目标方法执行之前对输入参数进行检查和修正。

               d. 代码重用性：通过前置增强，我们可以将一些通用的逻辑与业务逻辑分离开来，提高代码的重用性。例如，可以将许多不同的方法都需要进行相同的权限验证的逻辑抽取出来，作为一个独立的前置增强，然后应用到需要权限验证的方法上。

               e. 可扩展性：前置增强可以方便地添加新的切面逻辑，而无需修改目标方法的代码。这样，在不改变原有功能实现的情况下，可以灵活地增加新的功能。

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {

   @Before("execution( * service..*.*(..))")
   public void before(){
       System.out.println("前置通知.... 在方法之前要执行的公共代码放在这里");
   }

}

      ② 后置增强

                特点：

                a. 执行时机：后置增强在目标方法执行之后执行，无论目标方法是否发生异常都会执行。它提供了一个统一的处理点，可以进行一些与核心业务逻辑无关的后续操作

                b. 不影响目标方法的返回值：后置增强不能改变目标方法的返回值，它只是在目标方法执行完毕后进行额外的处理。

                c. 资源释放和清理：后置增强常用于进行资源释放、日志记录等操作。例如，在执行完数据库操作后，可以在后置增强中关闭数据库连接，释放资源，或者在后置增强中记录日志，以便后续的跟踪和分析。

                d. 与异常处理相结合：后置增强可以与异常处理相结合，用于统一处理异常情况。无论目标方法是否抛出异常，后置增强都会执行，因此可以在后置增强中对异常进行记录、通知等处理。

                e. 可扩展性：后置增强可以方便地添加新的切面逻辑，而不需要修改目标方法的代码。这样可以灵活地增加新的功能，而且不会影响原有的功能实现。

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {

    @AfterReturning(value="execution(* service..*.*(..)))",returning = "returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知...."+returnVal);
    }

}

      ③ 环绕增强

                特点：

                a.  灵活性：AOP可以在不修改源代码的情况下，通过配置或注解的方式对方法进行增强。这种灵活性使得开发人员能够将关注点（cross-cutting concern）从核心业务逻辑中分离出来，使代码更加模块化、可维护和易于理解。

                b. 集中管理：AOP允许将多个方法间共享的逻辑集中管理。通过定义切面（Aspect）和切点（Pointcut），可以将横跨多个方法的通用操作（如日志记录、事务管理等）统一放置在一个地方，提高了代码的可重用性和可维护性。

                c. 低耦合：AOP的环绕增强特点实现了将关注点与主要业务逻辑相分离，减少了代码间的耦合度。在系统演化和需求变更时，可以更加方便地对关注点进行修改和调整，而不会对核心业务逻辑产生影响。

                d. 代码简洁：AOP通过将通用的横切逻辑抽象为切面和增强，使得核心业务逻辑的代码更加简洁、清晰。开发人员只需要关注业务本身，而不必关心与业务无关的细节逻辑。

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {

    @Around("execution(* service..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕通知前....");

        Object obj= (Object) joinPoint.proceed();

        System.out.println("环绕通知后....");
        return obj;
    }

}

      ④ 异常增强

                特点：

                a. 集中处理异常：AOP可以将异常处理逻辑集中到一个地方，从而避免在每个方法中重复编写相同的异常处理代码。通过定义切面和切点，可以将异常处理逻辑应用于多个方法，实现统一的异常管理。

                b. 解耦业务逻辑和异常处理逻辑：AOP的异常增强特点将异常处理逻辑从业务逻辑中分离出来，降低了它们之间的耦合度。开发人员可以专注于业务逻辑的实现，而不必过多关注异常处理细节。

                c. 异常转换和封装：AOP可以对抛出的异常进行转换和封装，使得异常信息更加友好和易于理解。通过定义切面，在捕获异常时可以对异常进行处理、包装或转换，以便于上层调用者能够更好地理解和处理异常情况。

                d. 异常日志记录：AOP可以实现对异常的日志记录功能，方便开发人员进行故障排查和系统监控。通过定义切面，在捕获异常时可以记录异常信息、方法调用堆栈等相关信息，为问题定位提供有价值的线索。

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {

    @AfterThrowing(value="execution(* service..*.*(..))",throwing = "e")
    public void afterThrowable(Throwable e){
        System.out.println("出现异常:msg="+e.getMessage());
    }
        
}

      ⑤ 最终增强

                特点：

                a. 资源释放：在最终增强中，可以进行资源的释放操作，确保资源在方法执行完毕后得到正确释放，避免资源泄漏和内存溢出等问题。例如，关闭数据库连接、释放文件句柄等。

                b. 事务处理：最终增强常被用于实现事务处理，确保在方法执行结束后，对数据进行提交或回滚操作。通过最终增强，可以保证数据库事务的一致性和完整性。

                c. 日志记录：最终增强可用于记录方法的执行情况和结果，生成详细的操作日志。这对于调试和监控系统非常有帮助，可以追踪方法的执行轨迹，并记录重要的返回结果和状态信息。

                d. 缓存更新：最终增强可以应用于缓存场景，当方法执行完成后，根据需要更新相关的缓存数据，以保持缓存与数据源的一致性。例如，在写操作完成后更新缓存中的数据。     

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;

@Aspect
public class MyAspect {
    
    @After(value="execution(* service..*.*(..))")
    public void after(){
        System.out.println("最终通知....");
    }

}

二 . P命名空间注入

                在Spring框架中，P命名空间注入主要存在于使用XML配置文件进行依赖注入的情况下。通过使用P命名空间，可以将属性值直接注入到Bean的属性中，它允许我们使用更简洁的语法来进行属性注入。这种方式可以减少配置的冗余代码，使配置文件更加清晰易读。但如果没有正确地验证和过滤用户提供的属性值，就会导致安全漏洞。

使用p命名空间注入时，我们通过在XML配置文件中使用xmlns:p="http://www.springframework.org/schema/p"来引入命名空间，并使用p:前缀来指定属性值。

<bean id="唯一标识" class="类的全路径" p:"属性1"="注入的值" p:"属性2"="注入的值"  />
<bean id="唯一标识" class="类的全路径" p:属性-ref="注入的Bean" />

三 . 不同的数据类型注入方式

       ① 使用 List 注入

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入  list集合特点: 有序  允许重复 有下标
    List manList;
}
    <!--注入不同数据类型 list-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manList">
            <list>
                <value>List01</value>
                <value>List02</value>
                <value>List03</value>
                <value>List04</value>
            </list>
        </property>
    </bean>
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
    collection.getManList().stream().forEach(item->{
            System.out.println(item);
    });

        ② 使用 Set 注入

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入  set集合的特点： 无序 不允许重复
    Set manSet;
}
    <!--注入不同数据类型 set-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
<property name="manSet">
      <set>
           <value>Set01</value>
           <value>Set02</value>
           <value>Set03</value>
           <value>Set04</value>
      </set>
</property>
    </bean>
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManSet().stream().forEach(item->{
            System.out.println(item);
        });

        ③ 使用 Map 注入

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    //注入 Map集合特点：键值对 key值不能重复  value 可以
    Map manMap;
}
    <!--注入不同数据类型 map-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manMap">
            <map>
                <entry key="1" value="Map01" />
                <entry key="2" value="Map02" />
                <entry key="3" value="Map03" />
                <entry key="4" value="Map04" />
            </map>
        </property>
    </bean>
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManMap().forEach((key,value)->{
            System.out.println(value);
        });

         ④ 使用 Prop 注入

package com.cskt.DayTwo;
 
import lombok.Data;
 
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
@Data
public class JavaCollection {
    Properties manProp;
}
    <!--注入不同数据类型 Prop-->
    <bean id="JavaCollection" class="com.cskt.DayTwo.JavaCollection">
        <property name="manProp">
            <props>
                <prop key="one">Prop01</prop>
                <prop key="one">Prop04</prop>
                <prop key="two">Prop05</prop>
                <prop key="three">Prop06</prop>
                <prop key="four">Prop07</prop>
            </props>
        </property>
    </bean>
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
JavaCollection collection = (JavaCollection) context.getBean("JavaCollection");
        collection.getManProp().forEach((key,value)->{
            System.out.println(value);
        });

四 . 使用注解实现Spring  IoC

          ① IoC的常用注解                 

 

 

          ② 实现

                 （1）@Component：用于标记一个类为Spring的组件，通常用于自动扫描组件并将其注册到Spring容器中。示例代码如下：

@Component
public class ExampleComponent {
    // 类的实现...
}

                （2）@Autowired：用于自动注入依赖对象。当一个Bean需要依赖其他Bean时，可以使用@Autowired注解标记在字段、构造函数或Setter方法上，Spring会自动查找匹配的Bean进行注入。示例代码如下：

@Component
public class ExampleBean {
    @Autowired
    private ExampleDependency exampleDependency;
    
    // 其他方法...
}

                （3）@Qualifier：与@Autowired一起使用，用于指定具体的Bean进行注入。当存在多个类型兼容的Bean时，可以使用@Qualifier注解指定具体的Bean名称进行注入。示例代码如下：

@Component
public class ExampleBean {
    @Autowired
    @Qualifier("specificDependency")
    private ExampleDependency exampleDependency;
    
    // 其他方法...
}
 
@Component("specificDependency")
public class SpecificDependency implements ExampleDependency {
    // 类的实现...
}

                （4）@Value：用于将值注入到Bean的属性中。可以通过@Value注解直接注入常量值，也可以通过SpEL（Spring表达式语言）注入动态值。示例代码如下：

@Component
public class ExampleBean {
    @Value("18")
    private int age;
    
    @Value("${app.name}")
    private String appName;
    
    // 其他方法...
}

在上述代码中，@Value注解将值"18"注入到age属性中，${app.name}表示从配置文件中读取名为app.name的属性值。

除了上述注解，Spring还提供了许多其他的注解，如@Service、@Repository、@Controller等用于标记不同类型的组件，以及@Scope、@PostConstruct、@PreDestroy等用于管理Bean的作用域和生命周期。

使用注解实现Spring IoC具有简洁、便捷的特点，能够减少配置的工作量，并提高代码的可读性和维护性。然而，需要注意合理使用注解，避免过度使用导致代码可读性降低。

 

五 . 使用注解实现 Spring AOP

        注解方式实现aop我们主要分为如下几个步骤

1.在切面类（为切点服务的类）前用@Aspect注释修饰，声明为一个切面类。

2.用@Pointcut注释声明一个切点，目的是为了告诉切面，谁是它的服务对象。（此注释修饰的方法的方法体为空，不需要写功能比如 public void say(){};就可以了，方法名可以被候命的具体服务功能所以引用，它可以被理解为切点对象的一个代理对象方法）

3.在对应的方法前用对应的通知类型注释修饰，将对应的方法声明称一个切面功能，为了切点而服务

4.在spring配置文件中开启aop注释自动代理。如：<aop:aspectj-autoproxy/>

        代码如下：

package com.cjh.aop;

import org.springframework.stereotype.Component;
@Component("knight")
public class BraveKnight {
    public void saying(){
        System.out.println("我是尊嘟假嘟o.O..（切点方法）");
    }
}

package com.cjh.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;


/**
 * 注解方式声明aop
 * 1.用@Aspect注解将类声明为切面(如果用@Component("")注解注释为一个bean对象，那么就要在spring配置文件中开启注解扫描，<context:component-scan base-package="com.cjh.aop"/>
 *      否则要在spring配置文件中声明一个bean对象)
 * 2.在切面需要实现相应方法的前面加上相应的注释，也就是通知类型。
 * 3.此处有环绕通知，环绕通知方法一定要有ProceedingJoinPoint类型的参数传入，然后执行对应的proceed()方法，环绕才能实现。
 */
@Component("annotationTest")
@Aspect
public class AnnotationTest {
    //定义切点
    @Pointcut("execution(* *.saying(..))")
    public void sayings(){}
    /**
     * 前置通知(注解中的sayings()方法，其实就是上面定义pointcut切点注解所修饰的方法名，那只是个代理对象,不需要写具体方法，
     * 相当于xml声明切面的id名，如下，相当于id="embark",用于供其他通知类型引用)
     * <aop:config>
        <aop:aspect ref="mistrel">
            <!-- 定义切点 -->
            <aop:pointcut expression="execution(* *.saying(..))" id="embark"/>
            <!-- 声明前置通知 (在切点方法被执行前调用) -->
            <aop:before method="beforSay" pointcut-ref="embark"/>
            <!-- 声明后置通知 (在切点方法被执行后调用) -->
            <aop:after method="afterSay" pointcut-ref="embark"/>
        </aop:aspect>
       </aop:config>
     */
    @Before("sayings()")
    public void sayHello(){
        System.out.println("注解类型前置通知");
    }
    //后置通知
    @After("sayings()")
    public void sayGoodbey(){
        System.out.println("注解类型后置通知");
    }
    //环绕通知。注意要有ProceedingJoinPoint参数传入。
    @Around("sayings()")
    public void sayAround(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("注解类型环绕通知..环绕前");
        pjp.proceed();//执行方法
        System.out.println("注解类型环绕通知..环绕后");
    }
}

<?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:context="http://www.springframework.org/schema/context"
    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-4.3.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.cjh.aop"/>
    <!-- 开启aop注解方式，此步骤s不能少，这样java类中的aop注解才会生效 -->
    <aop:aspectj-autoproxy/>
</beans>

        优点： 使用注解实现Spring AOP简化了配置文件的编写，使得切面的定义更加直观和灵活。同时，可以根据实际需求选择不同类型的通知和切点表达式，实现细粒度的控制和扩展。

六 . 总结 

 

尊嘟假嘟o.O
关注
专栏目录
spring 学习第二天
11-26
#### 二、AOP 的核心概念 AOP 主要有以下几个核心概念： 1. **切面（Aspect）**：一个切面是封装了横切关注点的模块，它由两个部分组成：Pointcut 和 Advice。 2. **连接点（Join Point）**：程序执行过程中的某个...
spring5第二天.zip
05-25
在Spring 5框架的学习中，第二天的课程主要涵盖了Spring的核心特性——Inversion of Control (IoC)容器，以及如何利用它来实现账户的创建(Create)、读取(Retrieve)、更新(Update)和删除(Delete)操作。此外，课程还...
spring第二天.pdf
04-22
【Spring框架核心概念详解】 在Spring框架中，IoC（Inversion of ...通过这些知识点的学习，不仅可以了解Spring框架的基本构造，还能提升解决实际问题的能力，比如优化配置、调试代码、甚至开发基于Spring的扩展功能。
Spring框架是在2003年兴起的一门轻量级的JAVAEE框架技术 Spring框架学习资料第二天
10-29
本篇文章主要讲解了 Spring 框架的第二天学习资料，涵盖了 FactoryBean、Spring 工厂配置文件的参数化、静态代理、AOP 开发等知识点。 一、FactoryBean FactoryBean 是 Spring 框架中的一种机制，用于创建复杂对象...
javaEE商城第二天笔记.pdf
11-29
4. **框架应用**：Spring框架是JavaEE开发的常用工具，它提供了依赖注入(DI)和面向切面编程(AOP)等功能，简化了项目管理和事务控制。在商城系统中，Spring MVC可以用于构建前端控制器，Spring JDBC或MyBatis用于...
MySQL数据库的详细学习步骤
2401_87352036的博客
10-11 1160
MySQL数据库的详细学习步骤可以归纳为以下几个阶段，每个阶段都包含了特定的学习内容和目标。
10.9学习日志
m0_74998557的博客
10-09 1059
定积分表示函数 f(x)在区间 [a,b]上的累积效应或面积。分割区间： 将区间 [a,b]分割成 n 个小区间，每个小区间的长度为 Δxi，其中，且 x0=a，xn=b。取样本点： 在每个小区间内取一个样本点 ξi。构造黎曼和： 构造黎曼和，表示函数 f(x) 在区间 [a,b]上的近似累积效应或面积。取极限： 当分割的区间数 n 趋向于无穷大，且每个小区间的长度 Δxi趋向于零时，黎曼和的极限即为定积分：说明：黎曼和是通过将区间 [a,b]分成 n 个等宽的子区间，每个子区间的宽度为。
【人工智能学习之PaddleOCR快速上手】
Jiagym的博客
10-12 1118
在配置文件中，可以设置组建模型、优化器、损失函数、模型前后处理的参数，PaddleOCR从配置文件中读取到这些参数，进而组建出完整的训练流程，完成模型训练，在需要对模型进行优化的时，可以通过修改配置文件中的参数完成配置，使用简单且方便修改。而 L2 正则化中，添加正则化项的目的在于减少参数平方的总和。准确检测的标准是检测框与标注框的IOU大于某个阈值，正确识别的检测框中的文本与标注的文本相同。如果缺少带标注的数据，或者不想投入研发成本，建议直接调用开放的API，开放的API覆盖了目前比较常见的一些垂类。
【PHP小课堂】一起学习PHP中的反射（一）
硬核项目经理
10-14 671
一起学习PHP中的反射（一）反射这个名词相信大家不会陌生，但反过来说，这个反射到底是一个什么概念呢？其实反射，就是通过一些方法函数，来获得一个类或者一个实例化对象中的一些信息。当然，更重要的是，它可以是在运行时来动态获取这些信息的。这样的话，有很多功能就可以通过反射来实现了。比如说 Java 中的注解，在一些 PHP 的框架中，要实现类似的注解功能，就是通过反射来获得注释中的信息来实现的。大家可以...
如何用3个月零基础入门网络安全？_网络安全零基础怎么学习
2401_84466224的博客
10-15 553
我们知道计算机最早是在西方发明出来的，很多名词或者代码都是英文的，甚至现有的一些教程最初也是英文原版翻译过来的，而且一个漏洞被发现到翻译成中文一般需要一个星期的时间，在这个时间差上漏洞可能都修补了。”答案是否定的，黑客用的电脑,不需要什么高的配置,只要稳定就行.因为黑客所使用的一些程序,低端CPU也可以很好的运行,而且不占什么内存.还有一个,黑客是在DOS命令下对进行的,所以电脑能使用到最佳状态!观看学习近十年所有0day挖掘的帖，然后搭建环境，去复现漏洞，去思考学习笔者的挖洞思维，培养自己的渗透思维。
2024年网络安全进阶学习路径-2024年进阶学习指南
2401_85026965的博客
10-10 2049
网络安全可以基于攻击和防御视角来分类，我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。走安全行业的工程方向的，技术上面其实有很大的重叠性，抛开甲乙方、岗位名称、岗位职责等因素来看，作为学技术的，也根据以往我们给学员推荐就业和入职情况来看，只要好好掌握以下几种技术（网络协议与安全设备、Linux操作系统、Web服务部署/开发、主流渗透测试/安全工具、一门及以上的编程语言）中的2到3个，都可以较好的胜任工作需求。
论文及其创新点学习cvpr2022 On the Integration of Self-Attention and Convolution
qq_53536373的博客
10-13 360
论文创新点，将注意力机制 和卷积 相结合。
苍穹外卖学习笔记(二十一)
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
10-13 293
取消订单与再来一单
【YOLO学习】YOLOv4详解
m0_62881487的博客
10-09 1212
3. DIOU（Distance IOU）损失：DIOU 考虑到 GIOU 的缺点，也是增加了 C 检测框，将真实框和预测框都包含了进来，但是 DIOU 计算的不是框之间的交并，而是计算的每个检测框之间的欧氏距离，这样就可以解决 GIOU 包含出现的问题。concat：将两个特征图在通道数方向叠加在一起，原特征图信息完全保留下来，再对原特征图增加一些我们认为是较好的特征图，丰富了特征图的多样性，是在空间上对原特征图的增强，这样在下一次卷积的过程中我们能得到更好的特征图。
单片机（学习）2024.10.9
何物爱惜雨的博客
10-09 1012
汇编的分类，汇编代码（数据搬运指令，算术运算指令，比较指令，跳转指令，逻辑运算指令，内存操作指令），CPU栈机制，栈的应用
React 学习计划
最新发布
简序
10-15 711
希望这个学习计划能够帮助你系统地学习React，并最终成为一名优秀的React开发者。
拆解学习【无线充，EMMC，锂电池电量计，OTA】（二）
zjb6668的博客
10-12 1023
MT5727H内置ARM M0处理器，搭配8KB SRAM和16KB MTP存储器，支持私有无线充电协议，芯片内部集成同步整流器和LDO，芯片内置过压过流保护，支持I2C接口和可配置的GPIO接口。无线连接采用dialog DA16200 WiFi SoC芯片，是一款高度集成的超低功耗的WiFi SoC芯片，芯片内置基带处理器，内存，处理器，功放和放大器等。- 在多任务场景（如蓝牙传输、主动降噪和音频播放）下，需要快速存储和读取中间数据，而 eMMC 的**高速接口**能保证系统的实时性。
CUDA Graphs学习与实验
Hi20240217的博客
10-11 1304
CUDA图（CUDA Graphs）为CUDA引入了一种全新的工作提交模型。它允许将一系列操作（如内核启动）以图的形式表示，并通过依赖关系将这些操作连接起来。这种图的定义过程与其执行过程是分开的，这意味着我们可以提前定义好一个图，然后多次重复执行它
vue3学习记录-Teleport和KeepAlive
qq_45030898的博客
10-14 459
vue3学习记录-Teleport和KeepAlive
Spring框架入门第一天学习笔记
知识点五：Spring第一天学习要点 1. Spring环境搭建：了解如何搭建Spring开发环境，包括安装Java开发工具包（JDK）、配置环境变量、安装构建工具（如Maven或Gradle）。 2. Spring项目结构：熟悉Spring项目的目录...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值