Spring AOP 注解配置方式和XML配置方式

最新推荐文章于 2022-06-21 12:26:20 发布
原创 最新推荐文章于 2022-06-21 12:26:20 发布 · 275 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍Spring AOP（面向切面编程）的使用方法，包括基于注解和XML配置的AOP实现，涵盖切点、通知类型（如Before、After、Around）、引入、多切面的配置及执行顺序等内容。

jar包

拿接口配置切点时，要注意execution里的路径

一.  @Aspect 注解配置

  • @component注解注释bean
  • @aspect注解注释 切面类
  • <context:component-scan base-package="com.qyc.aop"></context:component-scan> 开启注解扫描
  • <aop:aspectj-autoproxy ></aop:aspectj-autoproxy>  开启aop注解方式
  • （ps：jdk动态代理时，invoke参数是真实对象，所以需要在类里定义一个object）
<?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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


<context:component-scan base-package="com.qyc.aop"></context:component-scan>
<aop:aspectj-autoproxy ></aop:aspectj-autoproxy>
</beans>
package com.qyc.aop;

import org.springframework.stereotype.Component;

@Component
public class ComponentMethod {
		public void say() {
			System.out.println("我是切点方法！");
		}
}

package com.qyc.aop;

import java.lang.reflect.Method;

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;
@Component
@Aspect
public class AspectClass {
	@Pointcut("execution(* com.qyc.aop.ComponentMethod.say(..))")
	public void saying() {
		
	}
	@Before("saying()")
	public void before() {
		System.out.println("准备");
	}
	@After("saying()")
	public void	after() {
		System.out.println("完成");
	}

}

package com.qyc.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		ComponentMethod componentMethod = applicationContext.getBean(ComponentMethod.class);
		componentMethod.say();
	}
}

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
准备
我是切点方法！
完成

 

无XML配置

把AspectClass的@component删掉，再建一个AspectStar类

package com.qyc.aop;

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

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.qyc.aop")
public class AspectStart {
	@Bean
	public AspectClass getAspectClass() {
		return new AspectClass();
		
	}
}

package com.qyc.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
	public static void main(String[] args) {

		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AspectStart.class);
		ComponentMethod componentMethod = applicationContext.getBean(ComponentMethod.class);
		componentMethod.say();
	}
}

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
准备
我是切点方法！
完成

环绕 around

注意ProceedingjoinPoint是spring提供的

调用proceed方法，执行目标方法

@Around("saying()")
	public void around(ProceedingJoinPoint pt) {
		System.out.println("环绕前");
		try {
			pt.proceed();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("环绕后");
		
	}

 

 

引入

package com.qyc.aop;

public interface RoleVerifier {
	public boolean verify(Role role);
}

package com.qyc.aop;

public class RoleVerifierImpl implements RoleVerifier{

	@Override
	public boolean verify(Role role) {
		// TODO Auto-generated method stub
		if(role!=null) {
			return true;
		}
		return false;
	}

}

 

//引入，增强bean，将aop代理对象下挂导俩个接口之下，所以可以进行强转，
	@DeclareParents(value="com.qyc.aop.ComponentMethod+",defaultImpl=RoleVerifierImpl.class)
	public RoleVerifier roleVerifier;
package com.qyc.aop;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
	public static void main(String[] args) {
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AspectStart.class);
		ComponentMethod componentMethod = applicationContext.getBean(ComponentMethod.class);
		Role role = new Role("强月城","555");
		RoleVerifier roleVerifier = (RoleVerifier) componentMethod;
		System.out.println(roleVerifier.verify(role));
		componentMethod.say(role);
		
	}
}

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
true
Role [name=强月城, age=555]准备
Role [name=强月城, age=555]你好，我是切点方法！
完成 

 

多切面

  • 用@Order来确定顺序，否则无序
  • AspeConfig要有多个返回aspect的方法
  •  
package com.qyc.MoreAop;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


@Aspect
@Order(1)
public class Aspect1 {

	@Before("execution(* com.qyc.MoreAop.StudentMethodImpl.printStudent(..)) "+ "&& args(student)")
	public void before(Student student) {
		System.out.println(student.getName()+"Aspect1的before");
	}
	@After("execution(* com.qyc.MoreAop.StudentMethodImpl.printStudent(..)) "+"&& args(student)")
	public void after(Student student) {
		System.out.println(student.getName()+"Aspect1的after");
	}
	
}

package com.qyc.MoreAop;

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

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.qyc.MoreAop")
public class AspectConfig {
	@Bean
	public Aspect1 getAspect1() {
		return new Aspect1();
	}
	@Bean
	public Aspect2 getAspect2() {
		return new Aspect2();
	}
	@Bean
	public Aspect3 getAspect3() {
		return new Aspect3();
	}
}


import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestDemo {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AspectConfig.class);
//		ControllerClass controllerClass = applicationContext.getBean(ControllerClass.class);
		StudentMethod controllerClass = applicationContext.getBean(StudentMethod.class);
		controllerClass.printStudent(new Student("强月城","2017011418"));
	}
}

强月城Aspect1的before
强月城Aspect2的before
Aspect3的before
Student [name=强月城, id=2017011418]
Aspect3的after
强月城Aspect2的after
强月城Aspect1的after

 

 

 

二. XML文件配置

  • 先定义bean
  • 然后aop：config
  • aop：aspect
  • aop：pointcut   execution(*空格com.qyc.aopXML.Student.say(..))
  • aop：before
<?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.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">


<!-- <context:component-scan base-package="com.qyc.aop"></context:component-scan> -->
<!-- <aop:aspectj-autoproxy ></aop:aspectj-autoproxy> -->
<bean id="student" class="com.qyc.aopXML.Student"></bean>
<bean id="aspectMethod" class="com.qyc.aopXML.AspectMethod"></bean>
<aop:config>
	<aop:aspect ref="aspectMethod">
		<aop:pointcut expression="execution(* com.qyc.aopXML.Student.say(..))" id="pointcut"/>
		<aop:before method="before" pointcut-ref="pointcut"/>
		<aop:after method="after" pointcut-ref="pointcut"/>
	</aop:aspect>
</aop:config>

</beans>
package com.qyc.aopXML;

public class Student {
	public void say() {
			System.out.println("你好啊，刘琳！");
	}
}

package com.qyc.aopXML;

public class AspectMethod {
	public void before() {
		System.out.println("(｡･∀･)ﾉﾞ嗨");
	}

	public void after() {
		System.out.println("(￣o￣) . z Z");
	}
}

package com.qyc.aopXML;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestDemo {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		Student student = (Student) applicationContext.getBean("student");
		student.say();
	}
}

log4j:WARN No appenders could be found for logger (org.springframework.core.env.StandardEnvironment).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
(｡･∀･)ﾉﾞ嗨
你好啊，刘琳！
(￣o￣) . z Z

 

 

多切面

  • 导对包

 

<?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"
	xmlns:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	 http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd
     http://www.springframework.org/schema/aop 
     http://www.springframework.org/schema/aop/spring-aop.xsd">
     
     
     
<bean id="stu" class="com.qyc.MoreAopXml.Student">
	<property name="name" value="强月城"></property>
	<property name="id" value="2017011418"></property>
</bean>

<bean id="students" class="com.qyc.MoreAopXml.StudentMethodImpl"></bean>

<bean id="aspect1" class="com.qyc.MoreAopXml.Aspect1"></bean>
<bean id="aspect2" class="com.qyc.MoreAopXml.Aspect2"></bean>
<bean id="aspect3" class="com.qyc.MoreAopXml.Aspect3"></bean>
<aop:config>

<aop:aspect ref="aspect1" order="1">
		<aop:before method="before" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..)) and args(student)"/>
		<aop:after method="after" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..)) and args(student)"/>
	</aop:aspect>
	
	<aop:aspect ref="aspect2" order="2">
		<aop:before method="before" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..))"/>
		<aop:after method="after" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..))"/>
	</aop:aspect>
	
	<aop:aspect ref="aspect3" order="3">
		<aop:before method="before" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..))"/>
		<aop:after method="after" pointcut="execution(* com.qyc.MoreAopXml.StudentMethodImpl.showStudnet(..))"/>
	</aop:aspect>
</aop:config>




</beans>

强月城Aspect1的before
DEBUG 11-21 18:56:53,958 Returning cached instance of singleton bean 'aspect2'  (AbstractBeanFactory.java:251) 
Aspect2的before
DEBUG 11-21 18:56:53,958 Returning cached instance of singleton bean 'aspect3'  (AbstractBeanFactory.java:251) 
Aspect3的before
Student [name=强月城, id=2017011418]
DEBUG 11-21 18:56:53,958 Returning cached instance of singleton bean 'aspect3'  (AbstractBeanFactory.java:251) 
Aspect3的after
DEBUG 11-21 18:56:53,958 Returning cached instance of singleton bean 'aspect2'  (AbstractBeanFactory.java:251) 
Aspect2的after
DEBUG 11-21 18:56:53,958 Returning cached instance of singleton bean 'aspect1'  (AbstractBeanFactory.java:251) 
强月城Aspect1的after

spring aop注解方式、xml方式示例
11-27
下面将详细介绍Spring AOP的注解方式和XML配置方式。 ### 注解方式 #### 1. 定义切面（Aspect） 在Spring AOP中，切面是包含多个通知（advisors）的类。使用`@Aspect`注解标记切面类，例如： ```java @Aspect ...
SpringAOP配置，是基于java配置类和注解的方式。
最新发布
03-05
在SpringAOP中，配置可以通过多种方式进行，包括基于java配置类和注解的方式。这种方式非常适合现代的Spring应用程序，因为它们通常都是以Java配置为主的。 基于java配置类的SpringAOP配置通常涉及创建一个配置类，...
spring aop的使用（注解方式以及基于xml配置方式）
weixin_34297300的博客
12-30 144
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring源码分析之@EnableAspectJAutoProxy注解分析
cherry93925的博客
05-09 1067
纵观整个Spring的发展历史，注解的配置正逐步替代xml的配置，到SpringBoot时代，完全可以用注解的配置替换繁杂的xml配置，例如我们需要开启AOP功能只要在代码上配置上@EnableAspectJAutoProxy。废话不多说，我们这节来分析下@EnableAspectJAutoP...
使用AOP注解来代替.xml配置文件
liu182680的博客
12-12 592
AOP的注解就是把原本AOP里.xml配置文件里的配置以注释的方式表现出来，实际的作用是相同的，是简化代码工作量的一种方式，但是使用注解的方式不如使用.xml文件简单易懂，容易使他人看不懂你所书写的代码。 首先是在pom.xml中添加所需依赖 &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;junit&amp;lt;/groupId&amp;gt; ...
AOP基于XML和注解的配置
study_azhuo的博客
04-14 190
AOP 的相关概念 AOP 的作用及优势 作用： 在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便 AOP 的实现方式： 使用动态代理技术 AOP 相关术语 Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。 Pointcut(切入点): 所谓切入点是指我们...
spring aop注解方式与xml方式配置
weixin_34143774的博客
01-03 77
注解方式applicationContext.xml 加入下面配置<!--SpringAop启用自动代理注解--> <aop:aspectj-autoproxyproxy-target-class="true"/>LoggingAspect,javapackagecom.lingdong.spring.aop; importorg.asp...
spring aop注解配置代码实例
08-26
Spring AOP注解配置是Spring框架提供的一种便捷的面向切面编程的方式，它允许开发者在不使用XML配置的情况下，直接通过注解实现切面的功能。本文将深入探讨Spring AOP的注解配置，并通过具体的代码实例来阐述其使用...
SpringAOP中的注解配置详解
08-25
SpringAOP中的注解配置详解 ...SpringAOP中的注解配置详解是实现AOP功能的重要技术之一，它提供了一种灵活、可扩展的方式来拦截和扩展业务逻辑。通过使用注解和XML配置，开发者可以轻松地实现对业务逻辑的拦截和扩展。
Spring使用AspectJ注解和XML配置实现AOP
09-01
总的来说，Spring结合AspectJ注解和XML配置为开发者提供了灵活的AOP实现方式。注解方式简洁明了，适合简单场景；而XML配置则提供了更多灵活性，适用于更复杂的需求。在实际开发中，可以根据项目需求选择适合的方式。...
AOP的注解配置与xml文件配置
naruhina的博客
07-17 500
AOP的注解配置与xml文件配置
AOP的使用xml和注解方式
U2的博客
09-07 605
一.Aop 是什么？ Aspect Oriented Programing 面向切面编程，相比较 oop 面向对象编程来说，Aop 关注的不再是程序代码中某个类，某些方法，而 aop 考虑的更多的是一种面到面的切入 即层与层之间的一种切入，所以称之为切面。 二.Aop 能做什么？ AOP 主要应用于日志记录，性能统计，安全控制,事务处理等方面，实现公共功能性的重复使用。 三.Aop 带来的...
spring的xml配置和注解配置
weixin_45444336的博客
10-12 607
1.xml注入 （1）在使用xml注入的时候，首先要到xml中的bean标签下去配置你需要注入的文件。 （2）如果是构造方法注入，那么就在类中添加构造。如果是set方法注入，就在类中添加set方法 2.注解注入 （1）注解注入是直接在类中定义一个私有的类，再在类上添加@Autowired这个注解，就可以将类注入到这个方法中。 相对于xml注入就更简单了，因为xml注入可能会有构造或者set方法 什...
spring IOC基本配置（xml配置和注解配置）
xiuyuandashen的博客
05-22 1635
目录Spring IOCIOC是什么IOC可以做什么依赖注入IOC和DIIOC容器Bean配置IOC容器spring ioc 依赖XML配置实例化容器使用容器xml配置详解spring对bean的管理1、创建bean的三种方式2、bean对象的作用范围3、bean对象的生命周期构造函数依赖注入Setter方法依赖注入注解配置使用xml和注解配置xml配置@Component、@Controller、@Service、@Repository用于注入数据的注解@Autowired@Qualifier@Quali
[spring学习]11、AOP使用，注解&xml配置
秃头披风侠的博客
06-21 839
在这一篇文章中，将会介绍AOP的基本使用，以及注解配置和xml配置。在使用spring首先需要进行导入相应的jar包，如下 创建一个Calculate接口，然后创建一个该接口的实现类，如下 注解配置 在上一篇文章中说明了横切关注点，在aop中也是对这几个横切关注点进行切入的，如下在aop中与这几个位置想对应的就是几个注解 我们对方法进行切面编程，只需要写一个方法，然后在方法上面加上相应的注解，然后在注解里面指定要进行切入的方法即可。下面是一个简单
Java Aop 基础注解配置
wahaha
09-25 306
1.模拟业务层 @Service("accountService") public class AccountServiceImpl implements IAccountService{ public void saveAccount() { System.out.println("执行了保存"); } } 新注解 Component 社么层都不属...
Spring中.xml配置文件头部（常用不定期更新
qq_33645786的博客
12-14 373
bean文件的文件头部 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans
Spring之AOP
JustDoSelf的博客
10-14 221
Spring AOP AOP，即面向切面编程，是一种思想。Spring AOP是这种思想的实现，Spring底层同时支持jdk和cglib动态代理。Spring会根据被代理类是否有接口自动选择代理方式：如果有接口，就采用jdk动态代理（当然也可以强制使用cglib），如果没有接口，就使用cglib动态代理。 术语 目标对象：是指被代理的类产生的对象。 连接点：目标对象中所有的方法。 切入点：目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值