`
virusfu
  • 浏览: 182899 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Spring AOP

AOPSpringJavajunitBean 
阅读更多

Spring的AOP

一、总括

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。然而殊途同归，实现AOP的技术特性却是相同的，分别为：

http://wayfarer.cnblogs.com/articles/241024.html


1、join point（连接点）：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个join point。

2、point cut（切入点）：本质上是一个捕获连接点的结构。在AOP中，可以定义一个point cut，来捕获相关方法的调用。

3、advice（通知）：是point cut的执行代码，是执行“方面”的具体逻辑。

4、aspect（方面）：point cut和advice结合起来就是aspect，它类似于OOP中定义的一个类，但它代表的更多是对象间横向的关系。

5、introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的AOP工具又将其称为mixin。

image
       上述的技术特性组成了基本的AOP技术，大多数AOP工具均实现了这些技术。它们也可以是研究AOP技术的基本术语。

clip_image002

所需的jar包

clip_image002[5]

 

二、基于注解的AOP

clip_image002[7]

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

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
<bean id="myInterceptor" class="com.persia.service.MyInterceptor"></bean>
<bean id="personServiceImpl" class="com.persia.service.impl.PersonServiceImpl"></bean>
</beans>
一个切面的定义如下：
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterThrowing;
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.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.After;


@Aspect //声明一个切面
public class MyInterceptor {
	 //用来定义要拦截的方法
   @Pointcut("execution (* com.persia.service.impl.PersonServiceImpl.*(..))")
   private void anyMethod(){}//声明一个切入点
   
   @Before("anyMethod() &&args(userName)")//切入点的名称,附加条件:要求有String类型的参数，即这里只拦截save(String name)方法
   public void doAccessCheck(String userName){
	   System.out.println("前置通知"+userName);
   }
   
   @AfterReturning(pointcut="anyMethod()",returning="result")
   public void doAfterReturning(String result){
	   System.out.println("后置通知"+result);
   }
   
   @After("anyMethod()")
   public void doAfter(){
	   System.out.println("最终通知");  
   }
   
   @AfterThrowing(pointcut="anyMethod()",throwing="e")
   public void doThrowing(Exception e){
	   System.out.println("例外通知"+e);
   }
   
   @Around("anyMethod()")
   public Object arround(ProceedingJoinPoint pjp) throws Throwable{
	   System.out.println("进入方法");
	   Object result=pjp.proceed();//确保切面能够进行，比较适合在这里做权限判断，没有权限则不执行proceed
	   System.out.println("退出进入方法");
	   return result;
   }
}

Junit测试如下：
package junit.test;


import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.persia.service.IPersonService;

public class SpringAopTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}
     
	@Test public void interceptorTest(){
		ApplicationContext cxt=new ClassPathXmlApplicationContext("applicationContext.xml");
	    IPersonService personService=(IPersonService) cxt.getBean("personServiceImpl");
	    personService.save("hello");
	   // personService.getPersonName(1);
	
	}
}

服务类：

public class PersonServiceImpl implements IPersonService {

	public String getPersonName(Integer id) {
		// TODO Auto-generated method stub
		System.out.println("我是getPersonName方法");
		return "spring aop";
	}

	public void save(String name) {
		// TODO Auto-generated method stub
		//throw new RuntimeException("测试例外异常");
        System.out.println("我是save方法");
	}

	public void update(String name, Integer id) {
		// TODO Auto-generated method stub
		System.out.println("我是update方法");
	}

}

结果：

前置通知hello
进入方法
我是save方法
后置通知null
最终通知
退出进入方法

三、基于XML的AOP

clip_image002[9]

 

 

 

 

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

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

<bean id="personService" class="com.persia.service.impl.PersonServiceImpl"></bean>
<bean id="aspectBean" class="com.persia.service.MyInterceptor"></bean>

<aop:config>
 <aop:aspect id="myaop" ref="aspectBean">
    <aop:pointcut id="mycut" expression="execution(* com.persia.service.impl.PersonServiceImpl.*(..))"/>
    <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
    <aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
    <aop:after-throwing pointcut-ref="mycut" method="doThrowing"/>
    <aop:after pointcut-ref="mycut" method="doAfter"/>
    <aop:around pointcut-ref="mycut" method="arround"/>
 </aop:aspect>
  
</aop:config>

</beans>

切面的定义无需注解：

import org.aspectj.lang.ProceedingJoinPoint;

public class MyInterceptor {

     
   public void doAccessCheck(){
	   System.out.println("前置通知");
   }
   
  
   public void doAfterReturning(){
	   System.out.println("后置通知");
   }
   
 
   public void doAfter(){
	   System.out.println("最终通知");  
   }
   
 
   public void doThrowing(){
	   System.out.println("例外通知");
   }
   
  
   public Object arround(ProceedingJoinPoint pjp) throws Throwable{
	   System.out.println("进入方法");
	   Object result=pjp.proceed();//确保切面能够进行，比较适合在这里做权限判断，没有权限则不执行proceed
	   System.out.println("退出进入方法");
	   return result;
   }
}

注意，上面的XML配置不提供参数的支持，若切面里的方法有参数，会报错：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'personServiceImpl' defined in class path resource [applicationContext.xml]: BeanPostProcessor before instantiation of bean failed; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0': Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [org.springframework.aop.aspectj.AspectJPointcutAdvisor]: Constructor threw exception; nested exception is java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut 
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory$1.run(AbstractAutowireCapableBeanFactory.java:405)
	at java.security.AccessController.doPrivileged(Native Method)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:380)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:264)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:220)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:261)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:185)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:164)
	at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:429)
	at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:729)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:381)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:139)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:83)
	at junit.test.SpringAopTest.interceptorTest(SpringAopTest.java:18)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.junit.internal.runners.TestMethodRunner.executeMethodBody(TestMethodRunner.java:99)
	at org.junit.internal.runners.TestMethodRunner.runUnprotected(TestMethodRunner.java:81)
	at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
	at org.junit.internal.runners.TestMethodRunner.runMethod(TestMethodRunner.java:75)
	at org.junit.internal.runners.TestMethodRunner.run(TestMethodRunner.java:45)
	at org.junit.internal.runners.TestClassMethodsRunner.invokeTestMethod(TestClassMethodsRunner.java:66)
	at org.junit.internal.runners.TestClassMethodsRunner.run(TestClassMethodsRunner.java:35)
	at org.junit.internal.runners.TestClassRunner$1.runUnprotected(TestClassRunner.java:42)
	at org.junit.internal.runners.BeforeAndAfterRunner.runProtected(BeforeAndAfterRunner.java:34)
	at org.junit.internal.runners.TestClassRunner.run(TestClassRunner.java:52)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:45)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:460)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:673)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:386)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:196)
Caused by: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.aop.aspectj.AspectJPointcutAdvisor#0': Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [org.springframework.aop.aspectj.AspectJPointcutAdvisor]: Constructor threw exception; nested exception is java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut 
	at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:243)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:923)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:833)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:440)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory$1.run(AbstractAutowireCapableBeanFactory.java:409)
	at java.security.AccessController.doPrivileged(Native Method)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:380)
	at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:264)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:220)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:261)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:185)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:164)
	at org.springframework.aop.framework.autoproxy.BeanFactoryAdvisorRetrievalHelper.findAdvisorBeans(BeanFactoryAdvisorRetrievalHelper.java:87)
	at org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator.findCandidateAdvisors(AbstractAdvisorAutoProxyCreator.java:98)
	at org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors(AnnotationAwareAspectJAutoProxyCreator.java:83)
	at org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator.shouldSkip(AspectJAwareAdvisorAutoProxyCreator.java:105)
	at org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator.postProcessBeforeInstantiation(AbstractAutoProxyCreator.java:266)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInstantiation(AbstractAutowireCapableBeanFactory.java:789)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.resolveBeforeInstantiation(AbstractAutowireCapableBeanFactory.java:760)
	at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory$1.run(AbstractAutowireCapableBeanFactory.java:399)
	... 33 more
Caused by: org.springframework.beans.BeanInstantiationException: Could not instantiate bean class [org.springframework.aop.aspectj.AspectJPointcutAdvisor]: Constructor threw exception; nested exception is java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut 
	at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:111)
	at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:87)
	at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:237)
	... 52 more
Caused by: java.lang.IllegalArgumentException: error at ::0 formal unbound in pointcut 
	at org.aspectj.weaver.tools.PointcutParser.parsePointcutExpression(PointcutParser.java:316)
	at org.springframework.aop.aspectj.AspectJExpressionPointcut.buildPointcutExpression(AspectJExpressionPointcut.java:205)
	at org.springframework.aop.aspectj.AspectJExpressionPointcut.checkReadyToMatch(AspectJExpressionPointcut.java:192)
	at org.springframework.aop.aspectj.AspectJExpressionPointcut.getMethodMatcher(AspectJExpressionPointcut.java:178)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.buildSafePointcut(AbstractAspectJAdvice.java:189)
	at org.springframework.aop.aspectj.AspectJPointcutAdvisor.<init>(AspectJPointcutAdvisor.java:51)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(Unknown Source)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(Unknown Source)
	at java.lang.reflect.Constructor.newInstance(Unknown Source)
	at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:96)
	... 54 more

去掉所有方法的参数即可，或者对XML的配置如下：

"execution(java.lang.String com.persia.service.impl.PersonServiceImpl.*(..))"

代表要拦截返回值为String类型的方法。

"execution(* com.persia.service.impl.PersonServiceImpl.*(java.lang.String,..))"

代表要拦截第一个参数为String类型的方法，其他参数不限制。

"execution(!void com.persia.service.impl.PersonServiceImpl.*(..))"

代表要拦截返回值不是void类型的方法。

"execution(!void com.persia.service..*.*(..))"

代表要拦截com.persia.servie这个包的所有子包.*下的类的所有方法.*

给Advice传递参数如下：

<aop:config>
 <aop:aspect id="myaop" ref="aspectBean">
 <aop:pointcut id="mycut" expression="execution(* com.persia.service.impl.PersonServiceImpl.*(..))"/>
 <aop:pointcut id="argcut" expression="execution(* com.persia.service.impl.PersonServiceImpl.*(..)) and args(name)"/>  
 <aop:before pointcut-ref="mycut" method="doAccessCheck"  />
 <aop:after-returning pointcut-ref="mycut" method="doAfterReturning"/>
   <aop:after-throwing pointcut-ref="mycut" method="doThrowing"/>
   <aop:after pointcut-ref="argcut" method="doAfter" arg-names="name"/>
 <aop:around pointcut-ref="mycut" method="arround"/>
 </aop:aspect>
  
</aop:config>

切面的方法定义如下：

 public void doAfter(String name){
	   System.out.println("最终通知" +name);  
   }
分享到：
| java反射
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    spring aop jar 包

    Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...

    Spring AOP 16道面试题及答案.docx

    Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...

    简单spring aop 例子

    Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题，如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP，通过实际的...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    3、对spring aop认识模糊的，不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf

    Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...

    Spring AOP完整例子

    Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许开发者在不修改源代码的情况下，通过插入切面来增强或改变程序的行为。在本教程中，我们将深入探讨Spring AOP的不同使用方法，包括定义切点、通知类型...

    Spring Aop四个依赖的Jar包

    Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的一个重要模块，它通过提供声明式的方式来实现面向切面编程，从而简化了应用程序的开发和维护。在Spring AOP中，我们无需深入到每个...

    spring aop依赖jar包

    现在，我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中，使用Spring AOP通常需要以下核心jar包： - `spring-aop.jar`：这是Spring AOP的核心库，包含了AOP相关的类和接口。 - `spring-beans.jar`：...

    spring AOP 引入jar包，spring IOC 引入Jar包

    Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件，它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP（面向切面编程）允许开发者在不修改源代码的情况下，通过“切面”来插入新的行为或增强已...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理）

    面向切面编程（AOP）是一种编程范式，旨在将横切关注点（如日志、安全等）与业务逻辑分离，从而提高模块化。...利用Java反射机制和Spring AOP框架，开发者可以方便地实现AOP，从而提升代码的模块化和可维护性。

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP（面向切面编程）是Spring框架的核心特性之一，它允许程序员在不修改源代码的情况下，通过“切面”来插入额外的业务逻辑，如日志、事务管理等。AOP的引入极大地提高了代码的...

    springAOP配置动态代理实现

    Spring AOP（面向切面编程）是Spring框架的重要组成部分，它允许程序员在不修改源代码的情况下，通过在运行时插入额外的行为（如日志记录、性能监控等）来增强对象的功能。动态代理则是Spring AOP实现的核心技术之一...

    Spring AOP面向方面编程原理：AOP概念

    ### Spring AOP面向方面编程原理：AOP概念详解 #### 一、引言 随着软件系统的日益复杂，传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战，面向方面编程...

    小马哥讲 Spring AOP 编程思想 - API 线索图.pdf

    在讨论Spring AOP（面向切面编程）时，首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块，它允许开发者将横切关注点（cross-cutting concerns）从业务逻辑中解耦出来，通过在方法调用前后进行...

    spring aop切面拦截指定类和方法实现流程日志跟踪

    ### Spring AOP 实现流程日志跟踪 #### 一、背景与目的 在现代软件开发过程中，为了确保系统的稳定性和可维护性，通常会引入非功能性的需求来增强应用程序的功能，比如日志记录、安全控制等。这些需求往往不是业务...

    spring aop 五个依赖jar

    Spring AOP（面向切面编程）是Spring框架的重要组成部分，它提供了一种模块化和声明式的方式来处理系统中的交叉关注点，如日志、事务管理等。在Java应用中，AOP通过代理模式实现了切面编程，使得我们可以将业务逻辑...

    Spring AOP 入门作者：廖雪峰

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP（Aspect Oriented Programming，面向切面编程）是Spring框架的一个关键特性，它为开发者提供了在运行时动态添加代码（即横切关注点或切面）到已有...

    Spring源码最难问题：当Spring AOP遇上循环依赖.docx

    Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...

    spring AOP依赖三个jar包

    Spring AOP，即Spring的面向切面编程模块，是Spring框架的重要组成部分，它允许开发者在不修改源代码的情况下，对程序进行横切关注点的处理，如日志、事务管理等。实现这一功能，主要依赖于三个核心的jar包：aop...

    spring aop的demo

    在`springAop1`这个压缩包中，可能包含了一个简单的应用示例，展示了如何定义一个切面类，以及如何在该类中定义通知方法。例如，我们可能会看到一个名为`LoggingAspect`的类，其中包含了`@Before`注解的方法，用于在...

Magicbox
Global site tag (gtag.js) - Google Analytics