Spring AOP技术小结

最新推荐文章于 2024-10-19 14:41:34 发布
最新推荐文章于 2024-10-19 14:41:34 发布
阅读量173 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44971038/article/details/104181195
版权

AOP：面向切面编程；该技术可以很大程度的简化代码，我们先不对AOP进行展开，先看例子，从例子中逐步了解AOP技术的作用。

注：本篇博客使用的数据库连接技术为 HikariCP，具体性能分析与详细（不常用的用法）请看我的下一篇博客：数据源库连接池。

为什么使用AOP

开头说了，AOP技术可以很大程度的简化代码，那如何简化呢，我们往下看；

我们先定义一个springtest web项目；建立如下图的一个简单的框架结构：

CalculatorService.java

package com.jd.calculator.service;

public class CalculatorService implements ICalculatorService {

	public int mul(int a, int b) {
		System.out.println("This mul method begins");
		System.out.println("This mul method args:["+a+","+b+"]");
		return a*b;
	}

	public int div(int a, int b) {
		System.out.println("This div method begins");
		System.out.println("This div method args:["+a+","+b+"]");
		return a/b;
	}
}

Test.java

package com.jd.test;

import com.jd.calculator.service.CalculatorService;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ICalculatorService calculatorService = new CalculatorService();
		System.out.println(calculatorService.mul(2, 2));
	}
}

显示结果如下：

但是，我们发现：我们仅写了乘和除两种方法，就出现了冗余的代码，如果我们将加、减、混合运算等都写出来，我们就会发现大段代码的冗余，因此，针对 CalculatorService.java 中代码作出修改，如下：

package com.jd.calculator.service;

public class CalculatorService implements ICalculatorService {

	public int mul(int a, int b) {
		before("mul",a,b);
		return a*b;
	}

	public int div(int a, int b) {
		before("mul",a,b);
		return a/b;
	}
	
	public void before(String methodName, int a, int b) {
		System.out.println("This "+methodName+" method begins");
		System.out.println("This "+methodName+" method args:["+a+","+b+"]");
	}
}

这样的话，当方法过多时，我们就可以去除很多冗余的代码；但是，我们依旧会发现，每次调用一次 before 方法还是多余的，而AOP技术可以在此的基础上继续优化代码。

AOP技术的实现

实现AOP技术我们需要以下jar包：

先看一些概念：

          概念

            说  明

切面（Aspect）

一个横切关注点的模块化，这个关注点可能会横切多个对象。它是横切关注点的另一种表达方式。

连接点（Joinpoint）

在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点表示一个方法的执行，即所有方法都可以嵌入横切逻辑。

切入点（Pointcut）

匹配连接点的断言。它通常是一个表达式，有专门的语法，用于指明在哪里（或者说在哪些方法调用上）嵌入横切逻辑

通知（Advice）

在切面的某个特定的连接点上执行的动作，也就是我们前面提到的横切逻辑，如日志处理逻辑，事务处理逻辑。切入点致命在哪里嵌入横切逻辑，通知指明切入什么，即干什么。

目标对象（Target Object）

被一个或者多个切面所通知的对象，也被称作被通知对象

代理对象（Proxy Object）

AOP框架创建的对象，它和目标对象遵循同样的接口，使用它的方式和使用目标对象的方式是一样的，但是它是目标对象的增强版，“通知”中的代码执行将会被代理对象的方法调用触发。在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

修改 CalculatorService.java 代码

package com.jd.calculator.service;

import org.springframework.stereotype.Service;

@Service  //注解，方便在xml中实例化
public class CalculatorService implements ICalculatorService {

	public int mul(int a, int b) {
		return a*b;
	}

	public int div(int a, int b) {
		return a/b;
	}
}

新建切面包，创建切面类 CalculatorAspect.java 

package com.jd.aspect;

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

@Aspect  //拥有该注解的类为切面类
@Component 
public class CalculatorAspect {

	@Before("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
	public void before(JoinPoint jp) {
		Object [] args = jp.getArgs();
		//获取代理类和被代理类的信息。
		Signature signature = jp.getSignature();
		//获取方法名称
		String methodName = signature.getName();
		System.out.println("This "+methodName+" method begins.");
		System.out.println("This "+methodName+" arg: ["+args[0]+","+args[1]+"]");
	}
}

@Before 为前置增强，其功能是在目标方法执行之前执行，（）中的参数为固定格式 "execution(public 数据类型 目标方法的路径(参数列表))"  其中，路径的末尾用 * 表示匹配指定路径的所有子方法，(..) 表示匹配所有参数，即不限个数与类型

建立Spring的xml文件 application.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: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/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">
	
	<context:component-scan base-package="com.jd"></context:component-scan>
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

<aop:aspectj-autoproxy></aop:aspectj-autoproxy> 的作用是将被 @Aspect 标记的切面类自动生成代理；

Test.java

package com.jd.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		//注意：这里的获取是 接口.class，不是 类.class
		ICalculatorService calculatorService = application.getBean(ICalculatorService.class);
		System.out.println(calculatorService.mul(2, 2));
		application.close();
	}
}

执行该代码可得如下结果：

乍一看，代码似乎没有变少反而变多了，但是细想一下我们可以发现，当 CalculatorService.java  中方法有很多的时候，这种技术可以减少很多冗余的代码。

现在我们简单说一下 AOP切面编程技术 

上图是我手动绘制的示意图，其中最左边的条形框就是目标方法，而目标方法右边的均属于切面，从关系上来说，切面类似于生活中的代理；我们想要执行目标方法，不需要自取去寻找方法，只要找到代理即可，由代理执行方法；

从执行顺序来说，调用目标方法，会先调用切面，所有相关切面调用之后，再执行目标函数，类似于上示意图；

AOP的增强方法

前置增强

package com.jd.aspect;

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

@Aspect  //拥有该注解的类为切面类
@Component 
public class CalculatorAspect {

	//前置增强：目标方法执行之前执行
	@Before("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
	public void before(JoinPoint jp) {
		Object [] args = jp.getArgs();
		Signature signature = jp.getSignature();
		String methodName = signature.getName();
		System.out.println("This "+methodName+" method begins.");
		System.out.println("This "+methodName+" arg: ["+args[0]+","+args[1]+"]");
	}
}

@Before 为前置增强，其功能是在目标方法执行之前执行，（）中的参数为固定格式 "execution(public 数据类型 目标方法的路径(参数列表))"  其中，路径的末尾用 * 表示匹配指定路径的所有子方法，(..) 表示匹配所有参数，即不限个数与类型

后置增强 （仅修改增强方法，因此仅放出增强方法的代码）

//后置增强：目标方法执行完毕执行
@After("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
public void After(JoinPoint jp) {
	Signature signature = jp.getSignature();
	String name = signature.getName();
	System.out.println("This "+name+" method ends.");
}

@After 为后置增强，其功能是在目标方法执行完毕后执行，其余同前置增强；

返回增强

//返回增强：目标方法执行return之后执行
@AfterReturning(value="execution(public int com.jd.calculator.service.CalculatorService.*(..))",returning="result")
public void AfterReturning(JoinPoint jp, Object result) {
	Signature signature = jp.getSignature();
	String name = signature.getName();
	System.out.println("This "+name+" method result "+result+".");
}

 @AfterReturning 为返回增强，其功能是在目标方法执行return之后执行，有两个参数，value 和 returning ，value 同上（参数只有一个可直接写参数值）；returning 的参数值为返回结果不需要拼写同目标方法的返回值，但是，必须和后置增强方法中的 Object类 的参数相同；

后置增强和返回增强的区别：正常情况下，后置增强先于返回增强执行；异常情况下后置增强执行，返回增强不执行（后文验证）；

异常增强

//异常增强：在目标方法发生异常时执行
@AfterThrowing(value="execution(public int com.jd.calculator.service.CalculatorService.*(..))",throwing="e")
public void After(JoinPoint jp,Exception e) {
	Signature signature = jp.getSignature();
	String name = signature.getName();
	System.out.println("This "+name+" method Exception"+e+".");
}

@AfterThrowing 异常增强，其功能是在目标方法出现异常时执行，同样有两个参数，value 和 throwing 的用法类似于返回增强的参数，这里不再累述。

还有一个增强方法为 @Around 即循环增强，可以同时实现以上四种增强方法，在下文中详述。

AOP的运行时机

以上四种增强方法的执行顺序为（加目标方法）：前置增强 --> 目标方法 --> 后置增强  --> 返回值 --> 返回增强                                           或            前置增强 --> 目标方法 --> 后置增强  --> 返回值异常 --> 异常增强

仅修改 CalculatorAspect.java 中代码，其余部分直接使用以上相对应的代码即可；

package com.jd.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CalculatorAspect {

	//前置增强：目标方法执行之前执行
	@Before("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
	public void before(JoinPoint jp) {
		Object [] args = jp.getArgs();
		//获取代理类和被代理类的信息。
		Signature signature = jp.getSignature();
		String methodName = signature.getName();
		System.out.println("This "+methodName+" method begins.");
		System.out.println("This "+methodName+" arg: ["+args[0]+","+args[1]+"]");
	}
	
	//后置增强：目标方法执行完毕执行
	@After("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
	public void After(JoinPoint jp) {
		Signature signature = jp.getSignature();
		String name = signature.getName();
		System.out.println("This "+name+" method ends.");
	}
	
	//返回增强：目标方法执行return之后执行
	//后置增强和返回增强的区别：正常情况下，后置增强先于返回增强执行；异常情况下后置增强执行，返回增强不执行
	@AfterReturning(value="execution(public int com.jd.calculator.service.CalculatorService.*(..))",returning="result")
	public void AfterReturning(JoinPoint jp, Object result) {
		Signature signature = jp.getSignature();
		String name = signature.getName();
		System.out.println("This "+name+" method result "+result+".");
	}
	
	//异常增强：在目标方法发生异常时执行
	@AfterThrowing(value="execution(public int com.jd.calculator.service.CalculatorService.*(..))",throwing="e")
	public void After(JoinPoint jp,Exception e) {
		Signature signature = jp.getSignature();
		String name = signature.getName();
		System.out.println("This "+name+" method Exception"+e+".");
	}
}

Test.java

package com.jd.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		//注意：这里的获取是 接口.class，不是 类.class
		ICalculatorService calculatorService = application.getBean(ICalculatorService.class);
		System.out.println(calculatorService.mul(2, 2));
		application.close();
	}
}

执行结果如下：

我们修改 Test.java 中的代码，将调用乘法方法改为调用除法方法，并将除数设为 0 （故意除法异常）

package com.jd.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		//注意：这里的获取是 接口.class，不是 类.class
		ICalculatorService calculatorService = application.getBean(ICalculatorService.class);
		System.out.println(calculatorService.div(2, 0));
		application.close();
	}
}

执行结果如下：

@Around 循环增强 以及 @Pointcut 作用

@Around 循环增强可以直接实现以上四种增强方法； @Pointcut 是为了简化增强注解的value参数，形式如下：

CalculatorAspect.java

package com.jd.aspect;

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

@Aspect
@Component
public class CalculatorAspect {

	@Pointcut("execution(public int com.jd.calculator.service.CalculatorService.*(..))")
	public void pointCut() {
		
	}
	
	//循环增强：可实现以上所有增强
	@Around("pointCut()")  //简化部分
	public Object around(ProceedingJoinPoint joinPoint) {
		Object result = null;
		Object target = joinPoint.getTarget();  //目标对象
		String methodName = joinPoint.getSignature().getName();
		Object [] params = joinPoint.getArgs();
		
		try {
			try {
				//前置增强
				System.out.println(target.getClass().getName()+": This "+methodName+" method begins.");
				System.out.println(target.getClass().getName()+": Parameters of the "+methodName+"method:["+params[0]+","+params[1]+"]");
				//执行目标对象内的方法
				result = joinPoint.proceed();
			}finally {
				//后置增强
				System.out.println(target.getClass().getName()+": This "+methodName+" method ends");
			}
			//返回增强
			System.out.println(target.getClass().getName()+": This "+methodName+" method result: "+result);
		}catch(Throwable e){
			//异常增强
			System.out.println(target.getClass().getName()+": Execption of the "+methodName+": "+e);
		}
		return result;
	}
}

Test.java

package com.jd.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		//注意：这里的获取是 接口.class，不是 类.class
		ICalculatorService calculatorService = application.getBean(ICalculatorService.class);
		System.out.println(calculatorService.div(2, 1));
		application.close();
	}
}

执行结果如下：

Spring XML配置 以及 切面的执行顺序

直接在 xml 中配置 <aop:aspectj-autoproxy></aop:aspectj-autoproxy> 自动生成代理切面的执行顺序为字母顺序，即下图中先执行 ArgAspect 切面，再执行 ArgAspect 切面；也可以在各个切面中注解 @Order("数字") 指定切面的执行顺序，数字越小优先级越高。

另外一种配置方法如下：

如上，我们建立两个类（就是我们将其作为切面类的类，因为这里没用使用 @Aspect 注解，因此为普通的类），一个输出参数，一个输出目标方法的名字；代码如下：

ArgAspect.java

package com.jd.aspect;

import org.aspectj.lang.JoinPoint;

public class ArgAspect {

	public void before(JoinPoint jp) {
		Object [] args = jp.getArgs();
		System.out.println("Arg of the "+jp.getSignature().getName()+" method: ["+args[0]+","+args[1]+"]");
	}
}

MethodAspect.java

package com.jd.aspect;

import org.aspectj.lang.JoinPoint;

public class MethodAspect {

	public void before(JoinPoint jp) {
		String name = jp.getSignature().getName();
		System.out.println("This "+name+" method begins");
	}
}

application.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: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/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

	<context:component-scan base-package="com.jd"></context:component-scan>
	
	<bean id="argAspect" class="com.jd.aspect.ArgAspect"></bean>
	<bean id="methodAspect" class="com.jd.aspect.MethodAspect"></bean>
	
	<aop:config>
		<aop:pointcut expression="execution(public int com.jd.calculator.service.CalculatorService.*(..))" id="pointCut"/>
		<aop:aspect ref="methodAspect" order="1">
			<aop:before method="before" pointcut-ref="pointCut"/>
		</aop:aspect>
		<aop:aspect ref="argAspect" order="2">
			<aop:before method="before" pointcut-ref="pointCut"/>
		</aop:aspect>
	</aop:config>
</beans>

使用 bean标签 直接生成类实例（因为这里没用使用 @Aspect 注解，因此为普通的类），然后使用 aop标签 进行配置具体的内容，aop:pointcut 作用同 @Pointcut；aop:aspect  指定已生成的类的实例为切面类实例；aop:before 前置增强，method 指定前置增强的方法为那个方法，  pointcut-ref 指定 Pointcut；order 则是指定切面的执行顺序；

Test.java

package com.jd.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.calculator.service.ICalculatorService;

public class Test {

	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		//注意：这里的获取是 接口.class，不是 类.class
		ICalculatorService calculatorService = application.getBean(ICalculatorService.class);
		System.out.println(calculatorService.div(2, 1));
		application.close();
	}
}

执行结果如下：

梦忆长安
关注
Spring系列（七）AOP的三种实现方式
大鱼的博客
04-21 1052
扩展：Spring系列学习汇总 文章目录
SpringAOP(图文详解)
热门推荐
lhj520cb的博客
07-16 4万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
SpringAOP学习总结
wcrnice的博客
11-21 386
一、什么是AOP AOP为Aspect Oriented Programming，意为面向切面编程。是通过预编译方式和运行期动态 代理实现程序功能的统一维护的一种技术,在不修改源码的情况下，程序运行期间对方法增强。在开发中的应用就是将业务核心代码和服务(切面)代码分离，然后通过编织的方法，核心代码和服务代码融合，达到增强核心业务方法的功能。 ...
Spring面试题之AOP增强顺序
weixin_44153131的博客
10-13 383
数值越低，表明优先级越高，@Order 默认为最低优先级，即最大数值。不同aspect，advice的执行顺序：先入后出，后入先出。直接上结果，图片转自。
spring多个AOP执行先后顺序
qqXHwwqwq的博客
06-15 2万+
众所周知，spring声明式事务是基于AOP实现的，那么，如果我们在同一个方法自定义多个AOP，我们如何指定他们的执行顺序呢？
Spring AOP知识总结
Black_Me的博客
03-25 1258
文章目录1.AOP（面向切面编程思想）1.1概念1.2核心概念1.3AOP的通知类型2.AOP的实现原理和场景2.1场景2.2实现技术3.Spring AOP的两种代理模式3.1JDK动态代理3.2CGLIB动态代理3.3JDK动态代理与CGLIB动态代理的区别4.Spring AOP 的两种代理方式使用4.1接口使用JDK代理4.1.1定义接口4.1.2实现类4.1.3定义切面4.1.4输出4.2非接口使用CGLIB代理4.2.1类定义4.2.2定义切面4.2.3输出5.Spring AOP的切入点（po
Spring AOP总结
Charles_Clark的博客
03-29 795
通过使用 Spring AOP，开发者可以将这些横切关注点从业务逻辑代码中分离出来，放在独立的模块中，实现业务逻辑与系统服务的解耦。这不仅提高了代码的可维护性和重用性，还使得系统更加灵活。
Spring AOP学习总结
weixin_38002497的博客
02-23 382
Spring的两大特征，IOC和AOP相信做过java的都应该知道，但有几个人能把AOP说清楚呢？ 最近在开发一个缓存组件，需要用到aop，但由于是工具项目，不能像业务开发一样使用@Aspect 和 xml配置的方式，这时才发现自己对aop的理解只是使用级。 所以自己又重新整理学习了AOP，受益良多，将学习的内容整理总结，方便以后自己复习也分享给需要的小伙伴。 （只是个人总结，如有错误欢迎指正） 首先分享一个自己整理的学习思维导图，可以从整体先了解下AOP的知识体系。 一、面向切面编程（AOP）基本概念
Spring AOP 详解
2301_80035594的博客
10-19 2417
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
SpringAOP.rar_springAOP
09-23
《Spring AOP：面向切面编程的深度解析》 在软件开发中，Spring框架以其强大的功能和灵活性，已经成为Java企业级应用的首选框架之一。其中，Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架...
spring中AOP个人总结
01-21
spring中AOP个人总结 简介 aop（aspect oriented programming）面向切面编程是spring当中一个重要内容，在学习之后感觉这个思想挺不错的，做个总结 AOP讲解 一、面向切面编程 ​ 听说过面向对象编程（oop），但是...
spring-aop.rar_aop1270_spring_spring aop
09-23
《深入解析Spring AOP：源码解读与应用实践》 Spring AOP，即Spring的面向切面编程，是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强或统一处理的方法。本文将围绕Spring AOP...
stays mad 反PCL宣传库。Anti PCL pro.zip
10-31
stays mad 反PCL宣传库。Anti PCL pro
伊犁师范大学在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
yolo算法-植物数据集-1417张图像带标签adamweeds.zip
最新发布
10-31
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
clickhouse-jdbc驱动jar文件用于建立jdbc链接
10-31
clickhouse-jdbc驱动jar文件用于建立jdbc链接
辽宁何氏医学院在四川2020-2024各专业最低录取分数及位次表.pdf
10-31
那些年，与你同分同位次的同学都去了哪里？全国各大学在四川2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
泰尔指数、泰尔指数模型（含案例源码+数据+stata详细操作过程）-最新出炉.zip
10-31
泰尔指数、泰尔指数模型（含案例源码+数据+stata详细操作过程）-最新出炉.zip
SpringIOC和SpringAOP实验小结
05-27
好的，我来回答你的问题。 Spring IOC（Inversion of Control，控制反转）是一种设计模式，它可以帮助我们实现...以上就是我对SpringIOC和SpringAOP实验的小结，希望能对你有所帮助。如果你有其他问题，可以继续问我。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值