Spring通知（入门及使用方法）

最新推荐文章于 2024-07-06 14:21:42 发布
最新推荐文章于 2024-07-06 14:21:42 发布
阅读量724 收藏 1
点赞数
文章标签： spring aop java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wbw1314520/article/details/108607241
版权

Spring通知类型（入门使用方法）

需要导入的jar包

在这里插入图片描述

一.前置通知
作用：在目标方法执行之前执行的通知

1.定义一个含有业务方法的类

public class UserDao {	
	public void addUser(String name){
		System.out.println("addUser,name:"+name);
	}

2.前置通知类实现接口MethodBeforeAdvice中的方法

public class Log implements MethodBeforeAdvice {
	Logger log=Logger.getLogger("test.Log");
	@Override
	public void before(Method arg0, Object[] arg1, Object arg2)
			throws Throwable {	
		log.info(Level.INFO+",写日志");

	}

3.配置beans.xml文件

<bean id="userDao" class="test.UserDao"/>
	<bean id="log" class="test.Log"/>	
	<!--  配置代理对象bean -->	
	<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="target" ref="userDao"></property>
		<property name="interceptorNames">
			<list>
				<value>log</value>
			</list>
		</property>
	</bean>

4.编写测试类

public class Test {
	public static void main(String[] args) {
        //获取bean容器
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
		//获取代理对象
		UserDao userDaoProxy=(UserDao) act.getBean("userDaoProxy");
		userDaoProxy.addUser("lisi");		
	}
}
二.后置通知
作用：在目标方法执行之后执行

1.定义一个接口

public interface UserDaoIfac {
	public void addUser(String name);
}

2.创建实现接口的类

public class UserDao implements UserDaoIfac{
	public void addUser(String name)
	{
		System.out.println("addUser,name:"+name);	
	}
}

3.创建后置通知类实现AfterReturningAdvice接口中的afterReturning方法（调用目标对象方法后拦截）

public class RecordInterceptor implements AfterReturningAdvice {
	@Override
	public void afterReturning(Object arg0, Method method, Object[] arg2,
			Object arg3) throws Throwable {		
		System.out.println("ip 地址于"+new Date()+"访问方法"+method.getName());

	}

4.配置beans.xml文件

<bean id="userDao" class="test.UserDao"/>
	<bean id="RecordInterceptor" class="test.RecordInterceptor"/>	
	<!--  配置代理对象bean -->	
	<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="target" ref="userDao"></property>
		<property name="interceptorNames">
		<property name="proxyInterfaces" value="test.UserDaoIfac">
			<list>
				<value>recordInterceptor</value>
			</list>
		</property>
	</bean>

5.编写测试类

public class Test {
	public static void main(String[] args) {
        //获取bean容器
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
		//获取代理对象
		UserDao userDaoProxy=(UserDao) act.getBean("userDaoProxy");
		userDaoProxy.addUser("lisi");		
	}
}
三.环绕通知
作用：围绕着目标方法执行

1.定义一个接口

public interface UserDaoIfac {
	public String addUser(String name);
}

2.创建实现接口的类

public class UserDao implements UserDaoIfac{
	public String addUser(String name)
	{
		System.out.println("addUser,name:"+name);	
	}
    return name;
}

3.创建环绕通知类实现MethodInterceptor接口中的invoke方法（调用目标对象方法会被关在这个方法中）

public class MyFilter implements MethodInterceptor{
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {		
		System.out.println("进来了");		
		//调用目标对象方法
		String result=(String)invocation.proceed();		
		System.out.println("走了");		
		return result;
	}

}

4.配置beans.xml

<bean id="userDao" class="test.UserDao"/>
	<bean id="myFilter" class="test.MyFilter"></bean>
	
	<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="interceptorNames">
			<list>
				<value>myFilter</value>
			</list>
		</property>
		<!--  如果面向接口编程，需要配置接口信息 -->
		<property name="proxyInterfaces" value="test.UserDaoIfac"></property>
		<property name="target" ref="userDao"></property>
	</bean>

5.编写测试类

public class Test {
	public static void main(String[] args) {
        //获取bean容器
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
		//获取代理对象
		UserDao userDaoProxy=(UserDao) act.getBean("userDaoProxy");
		userDaoProxy.addUser("lisi");		
	}
}
四.异常通知
作用：在目标方法抛出异常之后

1.定义一个接口

public interface UserDaoIfac {
	public String addUser(String name);
}

2.创建实现接口的类

public class UserDao implements UserDaoIfac{
	public String addUser(String name)
	{
		System.out.println("addUser,name:"+name);	
        int i = 2/0;//异常语句
	}
    return name;
}

3.创建异常通知类实现ThrowsAdvice接口中的afterThrowing方法（调用目标对象方法抛异常时执行）

public class MyExceptionAdvice implements ThrowsAdvice {
	public void afterThrowing(Exception ex)
	{
		System.out.println("异常信息 ："+ex.getMessage());
	}
	
}

4.配置beans.xml

<bean id="userDao" class="test.UserDao"/>	
	<bean id="myExceptionAdvice" class="test.MyExceptionAdvice"></bean>	
	<bean id="userDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
		<property name="interceptorNames">
			<list>
				<value>myExceptionAdvice</value>
			</list>
		</property>
		<!--  如果面向接口编程，需要配置接口信息 -->
		<property name="proxyInterfaces" value="test.UserDaoIfac"></property>
		<property name="target" ref="userDao"></property>
	</bean>

5.编写测试类

public class Test {
	public static void main(String[] args) {
        //获取bean容器
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
		//获取代理对象
		UserDao userDaoProxy=(UserDao) act.getBean("userDaoProxy");
		userDaoProxy.addUser("lisi");		
	}
}

缺点：如果要对多个类进行拓展，那么就要手动配置多个bean代理，工作量大且不好维护。

SpringAOP之xmlConfig高级实现

1.定义一个含有业务方法的类

public class UserDao {
	public void addUser(String name)
	{
		System.out.println("addUser,name:"+name);
	}
	public void deleteUser(String name)
	{
		System.out.println("deleteUser,name:"+name);
	}
}

2.定义功能拓展类

前置通知记录日志

public class Log  {
	Logger log=Logger.getLogger("test.Log");
	public void before(){	
		log.info(Level.INFO+",写日志");
	}

后置通知记录ip

public class IPRecord {
	public  void ipRecord()
	{
		System.out.println("ipRecord");
	}
}

3.配置beans.xml 配置文件中多了3个AOP的属性文件

xmlns:aop=“http://www.springframework.org/schema/aop”

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

<?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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
	<bean id="userDao" class="test.UserDao"/>
	<bean id="log" class="test.Log"/>
	<bean id="iPRecord" class="test.IPRecord"/>
	
	<!-- 使用aop配置语法，配置切面，切入点和目标对象之间的关联关系 -->
	<aop:config>
		<!-- 可以配置多个，比如拦截dao的逻辑   比如拦截service的逻辑  比如拦截controller的逻辑都可以配置在这里 -->
		<aop:aspect id="myaspect" ref="log">
			<aop:pointcut expression="execution(* test.UserDao.add*(..))" id="addMethod"/>
			<aop:before method="before" pointcut-ref="addMethod"/>
		</aop:aspect>
		<aop:aspect id="mydeleteAspect" ref="iPRecord">
			<aop:pointcut expression="execution(* test..*.delete*(..))" id="deleteMethod"/>
			<aop:after method="ipRecord" pointcut-ref="deleteMethod"/>
		</aop:aspect>
	</aop:config>

</beans>
execution(* test.UserDao.add*(…)) 解释

{

*：不管方法有没有返回值

add*:test.UserDao下的所有add方法

（…）:不管方法需不需要参数

}执行

4.编写测试类

public static void main(String[] args) {	
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");	
		UserDao userDao=(UserDao) act.getBean("userDao");
		userDao.addUser("张三");
		userDao.deleteUser("lisi");
	}

5.测试结果

在这里插入图片描述

SpringAOP之annotcation高级实现

1.定义一个含有业务方法的类

public class UserDao {
	public void addUser(String name)
	{
		System.out.println("addUser,name:"+name);
	}
	public void deleteUser(String name)
	{
		System.out.println("deleteUser,name:"+name);
	}
}

2.配置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:p="http://www.springframework.org/schema/p"
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.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">

	<bean id="userDao" class="test.UserDao"/>
	<bean id="log" class="test.Log"/>
	<bean id="iPRecord" class="test.IPRecord"/>
	
	<!-- 使用注解，配置则写在拦截器上面，xml文件中要开启注解支持 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

</beans>

3.使用注解编写功能拓展类

@Aspect：使其成为切面类

@Pointcut：切入点

@Before：前置通知

@After：后置通知

@Aspect   
public class Log  {	
	Logger log=Logger.getLogger("test.Log");

	@Pointcut("execution(* test.UserDao.add*(..))")
	private void addMethod(){}
	
	//怎么配置切谁  pointcut 通过一个傀儡方法配置
	@Before(value="addMethod()")//前置通知
	public void abc(){
		
		log.info(Level.INFO+",写日志");

	}

}

@Aspect
public class IPRecord {
	Logger log=Logger.getLogger("test.IPRecord");
	
	@Pointcut("execution(* test.UserDao.delete*(..))")
	private void deleteMethod(){}
	@After(value="deleteMethod()")
	public  void ipRecord()
	{
		log.info(Level.INFO+",ip地址");
	}

}

4.测试

public static void main(String[] args) {
		ApplicationContext act=new ClassPathXmlApplicationContext("beans.xml");
		
		UserDao userDao=(UserDao) act.getBean("userDao");
		/**
		 * 终于可以直接调用目标对象然后发现功能被扩展了
		 */
		userDao.addUser("张三");
		userDao.deleteUser("lisi");
		
	}

5.执行结果
在这里插入图片描述

常用表达式tips：

第一种：表示在UserMangeImpl类下的所有方法，这种方式在之前的案例使用的。

@Pointcut("execution(* com.spring.two.UserMangeImpl.*(..))")

第二种：表示任意公共的方法，其他修饰符也同样的道理。

 @Pointcut("execution(public * *(..))")

第三种：任何一个以set开始的方法，不仅仅是set，save、update也都行。

 @Pointcut("execution(* set*(..))")

第四种：在指定包下的所有方法

@Pointcut("execution(* com.spring.*.*(..))")
wbw1314520
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring AOP入门Demo分享
08-28
在本文中，我们将通过一个简单的入门Demo来了解如何在Spring中使用AOP。首先，我们需要创建一个Maven项目，并添加相关的依赖。在`pom.xml`文件中，我们需要引入Spring的核心库、Spring的上下文库、Spring的AOP库以及...
Spring的五大通知类型
inexaustible的博客
04-24 9647
1、前置通知：在目标方法执行之前执行执行的通知 前置通知方法，可以没有参数，也可以额外接收一个JoinPoint，Spring会自动将该对象传入，代表当前的连接点，通过该对象可以获取目标对象和目标方法相关的信息。 注意，如果接收JoinPoint，必须保证其为方法的第一个参数，否则报错。 2、环绕通知：目标方法执行之前和之后都可以执行额外代码的通知 在环绕通知中必须手动的调用目标方法，否则目标方法不会执行。这个手动调用是通过ProceedingJoinPoint来...
Spring aop 五种通知类型
小熊
12-20 9735
Spring aop 五种通知类型 spring aop 的五种通知类型 前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常 后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行 异常通知 After throwing advice：在连接点抛出异常后执行 最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内
如何在Spring Boot中实现实时通知
最新发布
微赚开发者技术分享博客
07-06 1019
通过本文，我们详细介绍了在Spring Boot应用中实现实时通知的两种主要方式：WebSocket和Server-Sent Events (SSE)。我们通过具体的代码示例演示了如何在Spring Boot中配置和使用这些技术，以及如何在前端页面接收和展示实时通知。今天我们将讨论如何在Spring Boot应用中实现实时通知功能，这在现代Web应用程序和服务中是非常重要的一部分。与传统的轮询或定时拉取相比，实时通知能够实现更低的延迟和更高的实时性，为用户提供更好的交互体验。
Spring AOP（5种通知类型）
kimi
03-08 2655
Spring AOP（5种通知类型）
Spring中的五种通知
weixin_44390164的博客
11-05 844
1. 五种通知 前置通知：@Before 后置通知：@AfterReturn 异常通知：@AfterThrow 最终通知：@After 环绕通知：@Around 2. 环绕通知的写法 @Pointcut("execution(* com.*.*(..))") public void pt1(){} @Around("pt1()") public Object aroundAdvice(ProceedingJoinPoint pjp){ Obje
Spring的事件通知
m0_37506254的博客
08-27 993
Spring的事件通知理解与使用
Spring的AOP极简入门
08-26
**Spring的AOP极简入门** 面向切面编程（Aspect-Oriented Programming，简称AOP）是Spring框架中的一项重要特性，它允许开发者定义“横切关注点”，这些关注点通常涉及日志、事务管理、安全性等通用功能，可以在不...
Spring 入门AOP材料
02-13
1. **基于代理的AOP**：Spring默认使用JDK动态代理或CGLIB代理来创建目标对象的代理对象，代理对象在方法调用前后执行通知。 2. **基于注解的AOP**：通过在类或方法上添加注解来定义切面，更加简洁直观。 **AOP 的...
Spring Cloud 入门教程
10-29
它通常配合Config Server一起使用，当配置发生变化时，通过消息总线通知各个服务实例刷新配置。 八、熔断机制与健康检查 Spring Cloud Actuator提供了微服务的监控和健康检查功能，包括指标收集、审计、健康检查等...
spring入门上手小例子
07-19
在这个例子中，`ServiceImpl`通过Spring的DI得到了`Logger`实例，并在`doSomething()`方法中使用。`LoggingAspect`是一个切面，其`logBefore()`方法作为前置通知，在`doSomething()`方法执行前打印一条消息。 总结...
Spring框架之通知类型
你的调料包
09-15 927
继上一篇的知识：接下来就根据下面这张图的，UserDao类的增、删、改、查方法，来进行对Spring通知的了解。 一、Spring通知类型 1.1、前置通知：在目标方式执行之前的操作 获得切入点的信息 如： <!-- 配置切面 --> <aop:aspect ref="myAspect"> <aop:before...
Spring事件通知机制介绍及使用方法
qq_33987908的博客
09-19 127
ApplicationContext内部使用了ApplicationEventMulticaster类，该类负责维护所有的Listener，并通过事件广播其将事件通知到对应的Listener中。Spring事件通知机制相当于Spring内部提供的一个松耦合的通信框架，可以解耦组件之间的通讯，基于观察者模式实现。1、 事件：表示一个事件，如果要自定义Spring的事件，只需继承ApplicationEvent抽象类即可。1、 自定义事件类：直接继承ApplicationEvent，实现事件的构造和处理逻辑。
Spring 的通知类型
共勉
03-17 1435
Spring 中的通知按照在目标类方法的连接点位置，可以分为以下 5 种类型： org. aopalliance.intercept.MethodInterceptor (环绕通知) 在目标方法执行前后实施增强，可以应用于曰志、事务管理等功能。 org.springframework.aop.MethodBeforeAdvice (前置通知) 在目标方法执行前实施增强，可以应用于权限管理等功能。...
Spring AOP 通知详解
L
04-14 498
一、什么是Spring AOP AOP（Aspect Oriented Programming），即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在...
Spring中的通知
荣山的博客
01-11 323
Spring中的通知
Spring中Aop及日志通知
SAME_LOVE的博客
08-17 417
以上这些概念和机制一起协作，通过配置来实现AOP的功能。在Spring中，通过使用XML配置、注解或Java配置来定义切面、切点、通知等，并将切面应用到目标对象上。Spring框架在运行时会自动识别切点，并按照配置的通知类型执行切面的逻辑。总而言之，Spring框架的AOP通过切面、切点、通知等概念和机制，提供了一种机制来管理横切关注点的代码逻辑。这使得开发人员能够在不修改核心业务逻辑的情况下，实现横切关注点的复用和集中处理，提高了代码的模块化、重用性和可维护性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值