Spring基础入门-aop（基于注解annotation）

最新推荐文章于 2024-07-16 17:40:50 发布
最新推荐文章于 2024-07-16 17:40:50 发布
阅读量330 收藏
点赞数
分类专栏： Spring 文章标签： spring基础入门-aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43736514/article/details/93516119
版权

Spring基础入门-aop（纯注解annotation）

项目目录结构
在这里插入图片描述
1.导入相应的jar包，创建相应的类
IUser.java

package com.zh.aop;

public interface IUser {
	/**
	 * 添加操作
	 */
	public abstract void add();
	
	/**
	 * 删除操作
	 */
	public abstract void delete();
	
	/**
	 * 更新操作
	 */
	public abstract void update();
	
	/**
	 * 查询操作
	 */
	public abstract void query();
}

User.java

package com.zh.aop;
import org.springframework.stereotype.Service;

@Service("getUser")
public class User implements IUser {

@Override
public void add() {
	System.out.println("User do add");
}

@Override
public void delete() {
	System.out.println("User do delete");
}

@Override
public void update() {
	System.out.println("User do update");
}

@Override
public void query() {
	System.out.println("User do query");
	}

}

Manager.java

package com.zh.aop;

import org.springframework.stereotype.Service;

@Service("getManager")
public class Manager implements IUser {
	
	@Override
public void add() {
	System.out.println("Manager do add");
}

@Override
public void delete() {
	System.out.println("Manager do delete");
}

@Override
public void update() {
	System.out.println("Manager do update");
}

@Override
public void query() {
	System.out.println("Manager do query");
}

}

Logger.java

package com.zh.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
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.springframework.stereotype.Component;

@Component("getQieMian")
@Aspect //标识配置切面
public class Logger {
	
/**
 * 配置切点
 */
@Pointcut("execution(* com.zh.aop..*(..))")
public void poitCut() {}

/**
 * 前置通知，在切入点执行前执行
 */
@Before(value = "poitCut()")
public void before() {
	System.out.println("before（前置通知）");
}

/**
 * 后置通知，在切入点正常执行后
 */
@AfterReturning(value = "poitCut()")
public void after_returning() {
	System.out.println("after-returning（后置通知）");
}

/**
 * 最终通知，无论切入点能不能正常执行，它都会
 */
@After(value = "poitCut()")
public void after() {
	System.out.println("after（最终通知）");
}


/**
 * 异常通知，在切入点执行产生异常后执行
 */
@AfterThrowing(value = "poitCut()")
public void after_throwing() {
	System.out.println("after-throwing（异常通知）");
}

/**
 * 环绕通知：
 * 		它是spring框架提供的一种可以在代码中手动控制通知方法什么时候执行的方式
 * 环绕通知问题：
 * 		当我们配置了<aop:around method="around()" pointcut-ref="doAop"/>之后
 * 		around方法执行了，但是切入点方法没有执行
 * 由动态代理可以知道，环绕通知指的是invoke方法，并且里面有明确的切入点方法调用。而现在我们的环绕通知没有明确切入点方法调用
 * 但Spring为我们提供了一个接口：ProceedingJoinPoint。该接口可以作为环绕通知的方法参数使用
 * 在程序运行时，spring框架为我们提供该接口的实现类，供我们使用
 * 该接口中有一个proceed方法，它相当于method.invoke，就是明确调用业务核心方法（切入点方法）
 */
@Around(value = "poitCut()")
public Object around(ProceedingJoinPoint pjp) {
	System.out.println("around（环绕通知开始）");
	Object o = null;
	try {
		//写这里相当于前置通知
		System.out.println("around（前置通知）");
		o = pjp.proceed();
		//写这里相当于后置通知
		System.out.println("around（后置通知）");
	} catch (Throwable e) {
		//写这里相当于异常通知
		System.out.println("around（异常通知）");
		e.printStackTrace();
	}finally {
		//写这里相当于最终通知
		System.out.println("around（最终通知）");
		
	}
	System.out.println("around（环绕通知结束）");
	return o;
}

}

Test_aop.java

package com.zh.aop;

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

public class Test_aop {
	public static void main(String[] args) {
		ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:beans.xml");
		
		//aop的底层原理是动态代理实现增强，有两种实现，一种是接口代理，另一种是cglib子类代理
		//所以这里必须要使用接口，而且必须使用接口来接收
		
		//获得普通用户对象，使用接口接收
		IUser user1 = ac.getBean("getUser",IUser.class);
		user1.add();
		System.out.println("-------------------");
		
		user1.delete();
		System.out.println("-------------------");
		
		user1.update();
		System.out.println("-------------------");
		
		user1.query();
		
		System.out.println("###################");
		//获得管理员对象，使用接口接收
		IUser user2 = (IUser) ac.getBean("getManager");
		user2.add();
		System.out.println("-------------------");
		
		user2.delete();
		System.out.println("-------------------");
		
		user2.update();
		System.out.println("-------------------");
		
		user2.query();
	}
}

beans.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:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
    
    <!-- 配置spring容器创建时要扫描的包 -->
    <context:component-scan base-package="com.zh.aop"></context:component-scan>
    
    <!-- 开启spring对注解aop的支持 -->
    <aop:aspectj-autoproxy/>
</beans>

2.运行效果
在这里插入图片描述

《提示》

1.使用具体哪个通知，就留哪个通知（其他内容全部注释掉）就可以运行出效果。
2.肯定有的人觉得after应该为后置通知，为什么会是最终通知？因为程序的调用问题，可以测试的，弄个异常，运行的时候，后置通知就不会执行。
3.推荐使用around（环绕通知），它可以控制通知的顺序，可以手动控制通知

完全使用注解，去掉xml文件

目录结构中去掉beans.xml。新增一个类
SpringConfiguration.java

package com.zh.aop;

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

@Configuration
@ComponentScan("com.zh.aop")
@EnableAspectJAutoProxy
public class SpringConfiguration {

}

修改Test_aop.java
使用 AnnotationConfigApplicationContext 而不是 ClassPathXmlApplicationContext

package com.zh.aop;

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

public class Test_aop {
	public static void main(String[] args) {
		ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);
		
		//aop的底层原理是动态代理实现增强，有两种实现，一种是接口代理，另一种是cglib子类代理
		//所以这里必须要使用接口，而且必须使用接口来接收
		
		IUser user1 = ac.getBean("getUser",IUser.class);
		user1.add();
	}
}

运行效果一样
项目源码

zh9131101
关注
专栏目录
Spring Boot - spring-boot-starter-aop
学无止境
06-12 1098
然后，我们创建了一个切面类LoggingAspect，它使用@Before和@After注解来定义前置通知和后置通知，这些通知将在UserService类的getUser()在工作中，spring-boot-starter-aop常用于在应用程序中实现切面编程，例如日志记录、性能监控、事务管理等。最后，在Application类的main()方法中，我们获取UserService的实例并调用getUser()方法。在这个示例中，我们创建了一个UserService类，它有一个getUser()
使用Spring的注解方式实现AOP入门
李阿昀的博客
10-20 1万+
首先在Eclipse中新建一个普通的Java Project，名称为springAOP。为了使用Spring的注解方式进行面向切面编程，需要在springAOP项目中加入与AOP相关的jar包，spring aop需要额外的jar包有： com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6
Spring AOP功能--基于Annotation的方式
SnAiL-__的blog
12-05 477
Spring中面向切面编程的两种方式：XML文件和Annotation的方式进行AOP开发 下面是基于Annotation的方式，代码如下//以下为声明切面，基于Annotation的方式实现AOP功能 @Aspect public class MyInterceptor { @Pointcut("execution(* cn.itcast.service.impl.PersonSer
自定义注解 + Spring AOP
最新发布
weixin_50871837的博客
07-16 1743
使用@interface自定义注解时，自动继承了 java.lang.annotation.Annotation 接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface 用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是 基本类型、Class、String、enum）。可以通过default来声明参数的默认值。public @interface 注解名{注解体}
spring AOP(通过annotation方式)
哲少
11-11 1233
 1.定义切面类:SecurityHandlerimport org.aspectj.lang.annotation.Aspect;import org.aspectj.lang.annotation.Before;import org.aspectj.lang.annotation.Pointcut;@Aspectpublic class SecurityHandler { /**  *
Spring4学习笔记-AOP（基于注解的方式）
weixin_33951761的博客
09-24 121
1.加入jar包com.springsource.org.aopalliance-1.0.0.jarcom.springsource.org.aspectj.weaver-1.6.8.RELEASE.jarcommons-logging-1.1.3.jarspring-aop-4.1.0.RELEASE.jarspring-aspects-4.1.0.RELEASE.jars...
Spring Aop实现——Annotation方式（注解式）and Schema-based式（xml配置）
zx317931876的专栏
05-22 579
<br /><br />Spring Aop实现——Annotation方式（注解式）<br />一、spring依赖库<br />* SPRING_HOME/dist/spring.jar<br />* SPRING_HOME/lib/jakarta-commons/commons-logging.jar<br />* SPRING_HOME/lib/log4j/log4j-1.2.14.jar<br />* SPRING_HOME/lib/aspectj/*.jar<br />二、编写切面aspect类
spring-aop-annotation-log-all
07-28
这里zip压缩包囊括了学习Spring过程中用到的所有的jar包； 有： ...spring-web-4.1.2.RELEASE.jar //aop注解需要 对于Spring环境的插件，你们可以到Eclipase中的help>Eclipse marketplace...去搜索安装
Spring用AspectJ开发AOP(基于Annotation)
08-25
Spring用AspectJ开发AOP(基于Annotation) 作为一名IT行业大师，我将详细介绍Spring用AspectJ开发AOP(基于Annotation)，并对标题、描述、标签和部分内容进行详细解释。 标题: Spring用AspectJ开发AOP(基于...
应用Spring AOP（六）-------Annotation注解配置方式
08-02
在本篇内容中，我们将深入探讨如何使用注解的方式来配置Spring AOP，以便在实际开发中更好地利用这一特性。 首先，我们要理解Spring AOP的基本概念。AOP通过切面（Aspect）实现了代码的模块化，切面包含了通知...
spring-nested-aop.zip_aop_spring aop
09-23
例如，我们可以看到使用`<aop:config>`标签来定义切面，`<tx:annotation-driven>`来启用基于注解的事务管理。 ```xml <aop:config> <aop:aspect id="transactionAspect" ref="transactionManager"> <!-- 定义...
spring中aop的简单使用（Annotation方式）
08-03
NULL 博文链接：https://dyygusi.iteye.com/blog/1995858
SpringAop @annotation\@Aspect练习
weixin_43600910的博客
01-17 487
切面记录日志练习 切面类 @Slf4j @Aspect @Component public class AspectForFeign { @Pointcut("execution(public * com.keke.remote..*Feign.*(..))") public void pointcut() { } @Around("pointcut()") public Object around(ProceedingJoinPoint joinPoin
Spring AOP 自定义注解annotation
myli92的博客
06-04 430
spring aop annotation注解
实现一个自定义的Spring AOP注解（AOP annotation）
Theworldwillbegood的博客
09-21 784
1. 介绍 在这篇文章中，我们将会使用Spring中的AOP支持来实现一个自定义的AOP注解（AOP annotation）。 首先，我们会给出AOP的一个高级（high-level）概述，解释它是什么和它的优点。接着，我们会一步一步地实现自己的注解，从而逐渐地对AOP有更深入的了解。 我们将会获得（outcome）：更好地理解AOP，以及将来创建自定义Spring注解的能力。 2. AOP注解是什么？ 快速总结一下，AOP表示面向切面编程（Aspect-Orientated Programming）。本质
Spring-AOP @AspectJ切点函数之@annotation()
热门推荐
小工匠
08-27 7万+
annotation概述 实例@annotation()概述代码已托管到Github—> https://github.com/yangshangwei/SpringMaster @annotation表示标注了某个注解的所有方法。 下面通过一个实例说明@annotation()的用法。 AnnotationTestAspect定义了一个后置切面增强，该增强将应用到标注了NeedTest的目标方法
Spring4.0学习笔记008——AOP的配置（基于注解）
可期
02-05 465
基于注解的方式来配置AOP
Spring---AOP与Annotation
weixin_44889526的博客
09-15 759
Spring---AOP面向切面编程AOP相关术语AOP通知类型AOP Schema通知类环绕通知（Around Advice）AspectJ中的Execution表达式 AOP相关术语 切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关 注点的很好的例子。在Spring AOP中，切面可以使用基于模式）或者基于@Aspect注解的方式来实现。 连接点（Joinpoint）：在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时
Spring4 AOP入门 （ApsectJ的注解方式）
23号员工的博客
06-07 405
1 创建web项目一路jar包（Spring4个+日志2个+AOP2个+2AspectJ） 2 在配置文件applicationContext.xml中引入aop约束（如果IOC要用注解开发的话就需要多引入一个context的约束） <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.sprin...
深入理解JavaWeb Spring注解Annotation及其应用
深入研究JavaWeb Spring注解Annotation不仅有助于理解基础的元数据处理，还能在实际开发中提高开发效率和代码的可读性。熟练掌握这些注解的使用，对于构建健壮、可扩展的Java Web应用至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值