Spring的AOP原理

article/2025/10/3 13:39:13

为什么80%的码农都做不了架构师？>>>   hot3.png

一、什么是 AOP

AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为（日志、安全、事务）的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，模块间的藕合度高，而不利于各个模块的重用。

 

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

 

使用“横切”技术，AOP把软件系统分为两个部分：核心业务逻辑组件和横切关注点。横切关注点模块化为特殊的类，这些类被称为“切面”，好处：1.横切关注点都集中于一块，不会出现大量重复代码；2.核心模块只关注核心功能的代码，模块间藕合度降低。

二、AOP 的实现原理

<img src="AOP代理.jpg" />

如图：AOP 实际上是由目标类的代理类实现的。AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异，AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。

三、AOP相关概念

连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。在Spring AOP中，一个连接点总是表示一个方法的执行。通俗的说就是加入切点的那个点

通知（Advice）：在切面的某个特定的连接点上执行的动作。其中包括了“around”、“before”和“after”等不同类型的通知（通知的类型将在后面部分进行讨论）。许多AOP框架（包括Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

切入点（Pointcut）：匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

引入（Introduction）：用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））。Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用引入来使一个bean实现IsModified接口，以便简化缓存机制。

织入（Weaving）：将切面应用到目标对象来创建新的代理对象的过程。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

增强（Advice）：是织入到目标类连接点上的一段程序代码。Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强还包括了在方法上的哪一点加入横切代码的方位信息，所以增强既包括横切逻辑、还包含部分连接点的信息。

引介（Introduction）：是一种特殊的增强，为类添加一些属性和方法。

切面（Advisor）：代表一般切面，包含了横切代码和连接点信息，本身是一个简单的切面，横切的连接点是目标类的所有方法。3种类型：一般切面（advisor）、切点切面（PointcutAdvisor）、引介切面（IntroductionAdvisor）。


四、Spring中AOP的实现

第一种是基于xml配置文件方式的实现，

第二种是基于注解方式的实现。

首先我们来看一下业务逻辑service层：

/** * RegisterService的实现类 * @author 曹胜欢 */  
public class RegisterServiceImpl implements RegisterService {  private  RegisterDao registerDao;  public RegisterServiceImpl() {}  /** 带参数的构造方法 */  public RegisterServiceImpl(RegisterDao  registerDao){  this.registerDao =registerDao;  }  public void save(String loginname, String password) {  registerDao.save(loginname, password);  throw new RuntimeException("故意抛出一个异常。。。。");  }  /** set方法 */  public void setRegisterDao(RegisterDao registerDao) {  this.registerDao = registerDao;  
}}

对于业务系统来说，RegisterServiceImpl类就是目标实现类，它的业务方法，如save()方法的前后或代码会出现异常的地方都是AOP的连接点。

 

下面是日志服务类的代码：

/** * 日志切面类 * @author 曹胜欢 */  
public class LogAspect {  //任何通知方法都可以将第一个参数定义为 org.aspectj.lang.JoinPoint类型   public void before(JoinPoint call) {  //获取目标对象对应的类名  String className = call.getTarget().getClass().getName();  //获取目标对象上正在执行的方法名  String methodName = call.getSignature().getName();  System.out.println("前置通知:" + className + "类的" + methodName + "方法开始了");  }  public void afterReturn() {  System.out.println("后置通知:方法正常结束了");  }  public void after(){  System.out.println("最终通知:不管方法有没有正常执行完成，一定会返回的");  }  public void afterThrowing() {  System.out.println("异常抛出后通知:方法执行时出异常了");  }  //用来做环绕通知的方法可以第一个参数定义为org.aspectj.lang.ProceedingJoinPoint类型  public Object doAround(ProceedingJoinPoint call) throws Throwable {  Object result = null;  this.before(call);//相当于前置通知  try {  result = call.proceed();  this.afterReturn(); //相当于后置通知  } catch (Throwable e) {  this.afterThrowing();  //相当于异常抛出后通知  throw e;  }finally{  this.after();  //相当于最终通知  }  return result;  }  
}

  这个类属于业务服务类，如果用AOP的术语来说，它就是一个切面类，它定义了许多通知。Before()、afterReturn()、after()和afterThrowing()这些方法都是通知。

 

下面我们就来看具体配置，首先来看一下：

<1>.基于xml配置文件的AOP实现：这种方式在实现AOP时，有4个步骤。



<?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-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>  <bean id="registerDaoImpl" class="com.zxf.dao.RegisterDaoImpl"/>  <bean id="registerService" class="com.zxf.service.RegisterServiceImpl">  <property name=" registerDaoImpl " ref=" RegisterDaoImpl "/>  </bean>  <!-- 日志切面类 -->  <bean id="logAspectBean" class="com.zxf.aspect.LogAspect"/>  <!-- 第1步： AOP的配置 -->  <aop:config>  <!-- 第2步：配置一个切面 -->  <aop:aspect id="logAspect" ref="logAspectBean">  <!-- 第3步：定义切入点,指定切入点表达式 -->  <aop:pointcut id="allMethod"   expression="execution(* com.zxf.service.*.*(..))"/>   <!-- 第4步：应用前置通知 -->  <aop:before method="before" pointcut-ref="allMethod" />  <!-- 第4步：应用后置通知 -->  <aop:after-returning method="afterReturn" pointcut-ref="allMethod"/>  <!-- 第4步：应用最终通知 -->  <aop:after method="after" pointcut-ref="allMethod"/>  <!-- 第4步：应用抛出异常后通知 -->  <aop:after-throwing method="afterThrowing" pointcut-ref="allMethod"/>  <!-- 第4步：应用环绕通知 -->  <!--  <aop:around method="doAround" pointcut-ref="allMethod" /> -->  </aop:aspect>  </aop:config>  
</beans>

上述配置针对切入点应用了前置、后置、最终，以及抛出异常后通知。这样在测试执行RegisterServiceImpl类的save()方法时，控制台会有如下结果输出：

 

前置通知：com.zxf.service.RegisterServiceImpl类的save方法开始了。

针对MySQL的RegisterDao实现中的save()方法。

后置通知:方法正常结束了。

最终通知:不管方法有没有正常执行完成，一定会返回的。

下面我们在来看一下第二种配置方式：

<2>基于注解的AOP的实现

 

     首先创建一个用来作为切面的类LogAnnotationAspect，同时把这个类配置在spring的配置文件中。

        在spring2.0以后引入了JDK5.0的注解Annotation的支持，提供了对AspectJ基于注解的切面的支持，从而 更进一步地简化AOP的配置。具体的步骤有两步。

 

Spring的配置文件是如下的配置：

 

<?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-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd>  <bean id="registerDao" class="com.zxf.dao.RegisterDaoImpl"/>  <bean id="registerService" class="com.zxf.service.RegisterServiceImpl">  <property name="registerDao" ref="registerDao"/>  </bean>  <!-- 把切面类交由Spring容器来管理 -->  <bean id="logAspectBean" class="com.zxf.aspect.LogAnnotationAspect"/>  <!-- 启用spring对AspectJ注解的支持 -->  <aop:aspectj-autoproxy/>  
</beans>

这是那个切面的类LogAnnotationAspect

/** * 日志切面类 */  
@Aspect  //定义切面类  
public class LogAnnotationAspect {  @SuppressWarnings("unused")  //定义切入点，提供一个方法，这个方法的名字就是改切入点的id  @Pointcut("execution(* com.zxf.service.*.*(..))")  private void allMethod(){}  //针对指定的切入点表达式选择的切入点应用前置通知  @Before("execution(* com. zxf.service.*.*(..))")  public void before(JoinPoint call) {  String className = call.getTarget().getClass().getName();  String methodName = call.getSignature().getName();  System.out.println("【注解-前置通知】:" + className + "类的"   + methodName + "方法开始了");  }  //访问命名切入点来应用后置通知  @AfterReturning("allMethod()")  public void afterReturn() {  System.out.println("【注解-后置通知】:方法正常结束了");  }  //应用最终通知  @After("allMethod()")  public void after(){  System.out.println("【注解-最终通知】:不管方法有没有正常执行完成,"   + "一定会返回的");  }  //应用异常抛出后通知  @AfterThrowing("allMethod()")  public void afterThrowing() {  System.out.println("【注解-异常抛出后通知】:方法执行时出异常了");  }  //应用周围通知  //@Around("allMethod()")  public Object doAround(ProceedingJoinPoint call) throws Throwable{  Object result = null;  this.before(call);//相当于前置通知  try {  result = call.proceed();  this.afterReturn(); //相当于后置通知  } catch (Throwable e) {  this.afterThrowing();  //相当于异常抛出后通知  throw e;  }finally{  this.after();  //相当于最终通知  }  return result;  }  
}

五：Spring中AOP的两种代理方式（Java动态代理和CGLIB代理）

Spring AOP使用动态代理技术在运行期织入增强代码。使用两种代理机制：基于JDK的动态代理（JDK本身只提供接口的代理）；基于CGlib的动态代理。

1. JDK的动态代理主要涉及java.lang.reflect包中的两个类：Proxy和InvocationHandler。其中InvocationHandler只是一个接口，可以通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态的将横切逻辑与业务逻辑织在一起。而Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。（只能为接口创建代理实例）

//需要被代理的接口
public interface ForumService {public void removeTopic(int topicId);public void removeForum(int forumId);
}//被代理接口的实现类，包含核心的业务逻辑
public class ForumServiceImpl implements ForumService{@Overridepublic void removeTopic(int topicId) {System.out.println("模拟删除Topic记录："+ topicId);try {Thread.currentThread().sleep(20);} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void removeForum(int forumId) {System.out.println("模拟删除Forum记录："+ forumId);try {Thread.currentThread().sleep(40);} catch (InterruptedException e) {e.printStackTrace();}}}
//性能监控核心代码生成
public class MethodPerformance {private long begin;private long end;private String serviceMethod;public MethodPerformance(String serviceMethod) {this.serviceMethod = serviceMethod;this.begin = System.currentTimeMillis();};public void printPerformance(){this.end = System.currentTimeMillis();long elapse = this.end - this.begin;System.out.println(serviceMethod + " cost " + elapse +"ms");}
}//线程安全的横切逻辑
public class PerformanceMonitor {private static ThreadLocal<MethodPerformance> tl= new ThreadLocal<MethodPerformance>();public static void begin(String method){System.out.println("begin monitor");MethodPerformance mp = new MethodPerformance(method);tl.set(mp);}public static void end(){System.out.println("end monitor");MethodPerformance mp = tl.get();mp.printPerformance();}
}//AOP横切模块
public class PerfermanceHandler implements InvocationHandler{private Object target;public PerfermanceHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName());Object object = method.invoke(target, args);PerformanceMonitor.end();return object;}}
//测试
public class TestForumService {public static void main(String[] args) {ForumService target = new ForumServiceImpl();//将目标业务类与横切代码编织到一起PerfermanceHandler handler = new PerfermanceHandler(target);//创建代理实例ForumService proxy = (ForumService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);proxy.removeForum(10);proxy.removeTopic(1012);}
}

begin monitor

模拟删除Forum记录：10

end monitor

com.baobaotao.proxy.ForumServiceImpl.removeForum cost 42ms

begin monitor

模拟删除Topic记录：1012

end monitor

com.baobaotao.proxy.ForumServiceImpl.removeTopic cost 21ms


2.CGLib采用底层的字节码技术，为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类的调用方法，并顺势织入横切逻辑。

package com.baobaotao.proxy;import java.lang.reflect.Method;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;public class CglibProxy implements MethodInterceptor{private Enhancer enhancer = new Enhancer();public Object getProxy(Class clazz){enhancer.setSuperclass(clazz);//设置创建子类的类enhancer.setCallback(this);return enhancer.create();//通过字节码技术动态创建子类实例}@Overridepublic Object intercept(Object target, Method method, Object[] args,MethodProxy proxy) throws Throwable {PerformanceMonitor.begin(target.getClass().getName()+"."+method.getName());Object object = proxy.invokeSuper(target, args);PerformanceMonitor.end();return object;}
}
package com.baobaotao.proxy;import java.lang.reflect.Proxy;
//测试
public class TestForumService {public static void main(String[] args) {	CglibProxy cglibProxy = new CglibProxy();ForumServiceImpl service = (ForumServiceImpl) cglibProxy.getProxy(ForumServiceImpl.class);service.removeForum(10);service.removeTopic(1012);}
}

begin monitor

模拟删除Forum记录：10

end monitor

com.baobaotao.proxy.ForumServiceImpl$$EnhancerByCGLIB$$626e31f5（子类）.removeForum cost 67ms

begin monitor

模拟删除Topic记录：1012

end monitor

com.baobaotao.proxy.ForumServiceImpl$$EnhancerByCGLIB$$626e31f5.removeTopic cost 20ms


Spring增强类

Spring支持5种增强类型：

1）前置增强：org.springframework.aop.BeforeAdvice代表前置增强，spring只支持方法级的增强，目前可用MethodBeforeAdvice。

public interface Waiter {public void greetTo(String name);public void serveTo(String name);
}
public class NaiveWaiter implements Waiter {@Overridepublic void greetTo(String name) {System.out.println("greetTo "+ name +"...");}@Overridepublic void serveTo(String name) {System.out.println("serveTo "+ name +"...");		}
}
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;public class GreeteBeforeAdvice implements MethodBeforeAdvice{@Overridepublic void before(Method arg0, Object[] arg1, Object arg2)throws Throwable {String client = (String) arg1[0];System.out.println("How are you!"+client+".");}
}
import org.springframework.aop.BeforeAdvice;
import org.springframework.aop.framework.ProxyFactory;public class TestBeforeAdvice {public static void main(String[] args) {Waiter target = new NaiveWaiter();BeforeAdvice advice = new GreeteBeforeAdvice();//Spring提供的代理工厂ProxyFactory pf = new ProxyFactory();//使用Cglib2AOPProx 即CGlib代理技术创建代理
//		pf.setInterfaces(target.getClass().getInterfaces());//使用JdkDynamicAopProxy//设置代理目标pf.setTarget(target);//添加增强处理pf.addAdvice(advice);//生成代理实例Waiter waiter = (Waiter) pf.getProxy();waiter.greetTo("Tom");waiter.serveTo("Lucy");//		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
//		Waiter waiter1 = (Waiter) ctx.getBean("waiter");
//		waiter1.greetTo("John");		}
}
<bean id="target" class="com.baobaotao.advice.NaiveWaiter" /><bean id="greeteAdvice" class="com.baobaotao.advice.GreeteBeforeAdvice" /><bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteAdvice"p:target-ref="target" />

2）后置增强：org.springframework.aop.AfterReturningAdvice代表后置增强，在目标方法执行后实施增强。

import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class GreeteAfterAdvice implements AfterReturningAdvice{@Overridepublic void afterReturning(Object arg0, Method arg1, Object[] arg2,Object arg3) throws Throwable {System.out.println("Please enjoy yourself!");}
}
<bean id="waiter" class="org.springframework.aop.framework.ProxyFactoryBean"p:proxyInterfaces="com.baobaotao.advice.Waiter" p:interceptorNames="greeteBefore,greeteAfter"p:target-ref="target" />

3）环绕增强：org.aopalliance.intercept.MethodInterceptor代表环绕增强，在目标方法执行前后实施增强。

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;public class GreeteInterceptor implements MethodInterceptor{@Overridepublic Object invoke(MethodInvocation inv) throws Throwable {Object[] args = inv.getArguments();String client = (String) args[0];System.out.println("How are you!"+client+".");Object obj = inv.proceed();System.out.println("Please enjoy yourself!");return obj;}}

4）异常抛出增强：org.springframework.aop.ThrowsAdvice，在目标方法执行抛出异常后实施增强。方法名必须为afterThrowing,如参前三个可选，最后一个是Throwable或其子类。

import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;
public class TransactionManager implements ThrowsAdvice {public void afterThrowing(Method method, Object[] args, Object target,Exception ex) throws Throwable {System.out.println("-----------");System.out.println("method:" + method.getName());System.out.println("抛出异常:" + ex.getMessage());System.out.println("成功回滚事务。");}
}

5）引介增强：org.springframework.aop.IntroductionInterceptor，表示目标类添加一些新的方法和属性，连接点是类级别，而不是方法级别。

import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.support.DelegatingIntroductionInterceptor;import com.baobaotao.proxy.PerformanceMonitor;public class ControllablePerformaceMonitor extends DelegatingIntroductionInterceptor implements Monitorable{private ThreadLocal<Boolean> MonitorStatusMap = new ThreadLocal<Boolean>();@Overridepublic void setMonitorActive(boolean active) {MonitorStatusMap.set(active);}@Overridepublic Object invoke(MethodInvocation mi) throws Throwable {Object obj = null;if (MonitorStatusMap.get() != null && MonitorStatusMap.get()) {PerformanceMonitor.begin(mi.getClass().getName() + "."+ mi.getMethod().getName());obj = super.invoke(mi);PerformanceMonitor.end();} else {obj = super.invoke(mi);}return obj;}}
<bean id="forumService" class="org.springframework.aop.framework.ProxyFactoryBean"p:interfaces="com.baobaotao.introduce.Monitorable" //引入引介增强要实现的接口p:target-ref="forumServiceTarget"p:interceptorNames="pmonitor" p:proxyTargetClass="true" />//只能通过为目标类型类创建子类的方式生成增强的代理

AOP切面的配置方式

1）基于Schema的配置：在xml中描述切点、增强类型，切面类为pojo

2）基于AspectJ的配置：切点、增强类型使用注解进行描述


转载于:https://my.oschina.net/elain/blog/382494


http://chatgpt.dhexx.cn/article/fqw2mm3t.shtml

相关文章

利用C语言实现动态数组

利用C语言实现动态数组

数组存在的问题&#xff1a;如果我们定义一个数组去存储数据&#xff0c;需要提前定义数组的个数&#xff0c;或者数组根据第一次存储的元素个数自动确定数组的大小&#xff0c;但是我们如果想对数组进行元素插入只能重新定义一个新数组&#xff0c;或者预定义一个空间非常大的…
阅读更多...
C++数组之动态数组

C++数组之动态数组

目录 1.摘要 2.动态数组内存分配 1一维数组 2多维数组&#xff08;以2维为例&#xff09; 3.动态数组初始化 1默认初始化 2.自定义初始化 4.动态数组释放 5.例子 Gradebook类的实现 6.参考文章 1.摘要 数组是一种顺序存储的数据结构&#xff0c;在定义数组时&…
阅读更多...
C++中如何定义动态数组

C++中如何定义动态数组

首先&#xff1a;为什么需要动态定义数组呢&#xff1f; 这是因为&#xff0c;很多情况下&#xff0c;在预编译过程阶段&#xff0c;数组的长度是不能预先知道的&#xff0c;必须在程序运行时动态的给出 但是问题是&#xff0c;c要求定义数组时&#xff0c;必须明确给定数组…
阅读更多...
c++ 动态数组

c++ 动态数组

动态数组 相关数组知识连接 数组详解 多维数组 在之前的文章中&#xff0c;讲解了数组的相关知识&#xff0c;那一种数组&#xff08;数组相关连接&#xff1a;https://blog.csdn.net/m0_62870588/article/details/123787052&#xff09;又称是静态数组&#xff0c;因为它的大小…
阅读更多...
C语言中动态分配数组

C语言中动态分配数组

很多人在编写C语言代码的时候很少使用动态数组&#xff0c;不管什么情况下通通使用静态数组的方法来解决&#xff0c;在当初学习C语言的时候我就是一个典型的例子&#xff0c;但是现在发现这是一个相当不好的习惯&#xff0c;甚至可能导致编写的程序出现一些致命的错误。尤其对…
阅读更多...
C语言学习笔记：动态数组

C语言学习笔记：动态数组

动态数组 数组是C语言中的很重要的一种构造类型&#xff0c;最初我们学习的都是静态数组&#xff0c;但是&#xff0c;静态数组有着自己难以改变的缺点——数组长度固定。 一般在静态数组定义后&#xff0c;系统就会为其分配对应长度的连续的专有内存空间&#xff0c;可是&am…
阅读更多...
C语言如何实现动态数组？

C语言如何实现动态数组？

提出问题 请问在c语言里如何实现动态大小的数组啊&#xff0c;比如说int a[N];&#xff0c;这里N的值可以在程序中定&#xff0c;或者有什么方法可以实现类似的功能&#xff1f;总之只要在编译时不用制定数组大小就行。 分析问题 嵌入式系统的内存是宝贵的&#xff0c;内存是否…
阅读更多...
C的动态数组的详细知识（网上收集到的大量详细知识以及个人理解的汇总）

C的动态数组的详细知识（网上收集到的大量详细知识以及个人理解的汇总）

动态数组是指在声明时没有确定数组大小的数组&#xff0c;即忽略圆括号中的下标&#xff1b;当要用它时&#xff0c;可随时用ReDim语句重新指出数组的大小。使用动态数组的优点是可以根据用户需要&#xff0c;有效利用存储空间。 可以了解动态数组的详细定义 一.C版本动态数组…
阅读更多...
动态数组C语言实现详解

动态数组C语言实现详解

目录 0、前言 一、动态数组数据结构 二、动态数组增删改查函数声明 三、数组创建 1、头部动态创建 2、头部静态创建 四、元素添加 五、元素删除 1、根据元素值删除 2、根据元素位置删除 六、元素修改 七、元素查找 八、数组清空 九、数组销毁 十、验证程序 0、前…
阅读更多...
C语言实现 动态数组 处理任意类型数据

C语言实现 动态数组 处理任意类型数据

引言&#xff1a;动态数组在C/C、Java、Python等语言中应用广泛&#xff0c;高级语言一般通过调用类或接口等可以快捷使用&#xff0c;C语言实现动态数组需要手动构造&#xff0c;以下为实现过程。 1 结构体构造动态数组 typedef struct Array {void **p; //维护在堆区…
阅读更多...
C语言创建动态数组

C语言创建动态数组

C语言创建动态数组 1.编写步骤 1. 添加所需头文件 stdlib.h 该头文件下包含的与分配存储区相关的函数如下&#xff1a; void* malloc (size_t size);//从堆中分配size字节的存储空间 void* calloc (size_t num, size_t size);//分配数组并将数组零初始化。为 num 个元素的数…
阅读更多...
在OpenCV里实现开运算

在OpenCV里实现开运算

前面学习腐蚀和膨胀算法，并且深刻地认识到它们的特性以及作用。如果由这两种组合出来的运算又有什么样的不同呢？比如一个图像先腐蚀后膨胀的操作，会有什么结果呢？因为腐蚀是把图片白色变小，膨胀又是把图片白色变大，是否会保持原图不变呢？带着这些问题来研究一下先腐蚀后…
阅读更多...
OpenCV python 形态学 圆形开运算

OpenCV python 形态学 圆形开运算

处理流程 # -*- coding: utf-8 -*- # note : 形态学 开运算 圆形内核 处理 # --------------------------------import cv2 as cv import numpy as npdef opening_circle(img_bin, kernel_size10):# 形态学kernel np.zeros((kernel_size, kernel_size), np.uint8)center_…
阅读更多...
腐蚀、膨胀、开运算、闭运算

腐蚀、膨胀、开运算、闭运算

一、腐蚀、膨胀、开运算、闭运算 腐蚀&#xff1a;图像中的高亮部分进行膨胀 膨胀&#xff1a;原图中的高亮部分被腐蚀&#xff0c;类似于领域被蚕食 开运算&#xff1a;先腐蚀再膨胀&#xff0c;可以去掉目标外孤立的点 闭运算&#xff1a;先膨胀再腐蚀&#xff0c;可以去掉目…
阅读更多...
【youcans 的 OpenCV 例程200篇】137. 灰度开运算和灰度闭运算原理

【youcans 的 OpenCV 例程200篇】137. 灰度开运算和灰度闭运算原理

欢迎关注 『youcans 的 OpenCV 例程 200 篇』 系列&#xff0c;持续更新中 欢迎关注 『youcans 的 OpenCV学习课』 系列&#xff0c;持续更新中 【youcans 的 OpenCV 例程200篇】137. 灰度开运算和灰度闭运算 5. 灰度级形态学 灰度级形态学将形态学操作从二值图像扩展到灰度图…
阅读更多...
开闭运算

开闭运算

开运算和闭运算是将腐蚀和膨胀按照一定的次序进行处理。但这两者并不是可逆的&#xff0c;即先开后闭并不能得到原来的图像。 开运算 开运算是先腐蚀后膨胀&#xff0c;其作用是&#xff1a;分离物体&#xff0c;消除小区域。特点&#xff1a;消除噪点&#xff0c;去除小的干扰…
阅读更多...
图像的形态学开操作(开运算)和闭操作(闭运算)的概念和作用,并用OpenCV的函数morphologyEx()实现对图像的开闭操作

图像的形态学开操作(开运算)和闭操作(闭运算)的概念和作用,并用OpenCV的函数morphologyEx()实现对图像的开闭操作

大家看这篇博文前可以先看一看下面这篇博文&#xff0c;下面这篇博文是这篇博文的基础&#xff1a; 详解图像形态学操作之图形的腐蚀和膨胀的概念和运算过程,并利用OpenCV的函数erode()和函数dilate()对图像进行腐蚀和膨胀操作 图像形态学腐蚀可以将细小的噪声区域去除&#x…
阅读更多...
OpenCV-Python图像运算变换处理：开运算和闭运算以及不同核矩阵的影响分析

OpenCV-Python图像运算变换处理：开运算和闭运算以及不同核矩阵的影响分析

☞ ░ 前往老猿Python博客 https://blog.csdn.net/LaoYuanPython ░ 一、引言 在《OpenCV-Python图像处理&#xff1a;腐蚀和膨胀原理及erode、dilate函数介绍 https://blog.csdn.net/LaoYuanPython/article/details/109441709》等系列博文中老猿详细介绍了腐蚀和膨胀的原理、…
阅读更多...
灰度级形态学 - 灰度开运算和灰度闭运算

灰度级形态学 - 灰度开运算和灰度闭运算

目录 1. 介绍 2. code 1. 介绍 灰度级的开运算和闭运算和二值图像的处理一样&#xff0c;只不过一个作用于灰度图&#xff0c;一个作用于二值图像 灰度级的开运算公式为&#xff1a; 先对图像做腐蚀&#xff0c;然后对腐蚀的结果做膨胀运算 灰度级的闭运算公式为&#xff…
阅读更多...
OpenCV（七）形态学操作2--开运算与闭运算

OpenCV（七）形态学操作2--开运算与闭运算

目录 概述&#xff1a; morphologyEX()函数 一、开运算&#xff08;分开&#xff09; 1、基础理论 1、作用&#xff1a; 2、代码 3、效果 二、闭运算&#xff08;封闭&#xff09; 1、基础理论 1、作用 2、过程 2、代码 3、效果 总代码 参考资料&#xff1a; 概述…
阅读更多...
推荐文章

Copyright @ 2022~2023