spring系列(四):切面编程(aop)2

最新推荐文章于 2022-06-30 17:10:37 发布
最新推荐文章于 2022-06-30 17:10:37 发布
阅读量1k 收藏
点赞数
分类专栏： spring 文章标签： spring aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx5040257/article/details/78877653
版权

在上一篇博文中我们讲了前置增强处理。在这篇文章中我们将结合案例继续讲解其它各种增强处理。

一   后置增强

LoggerAfterReturning类则通过AfterReturningAdvice接口实现后置增强，该接口要求实现afterReturning()方法。Spring会将该方法添加到目标方法正常返回之后执行。afterReturning()方法有4个参数，target表示被代理的目标对象，method表示被代理的目标方法，arguments表示传递给目标方法的参数歹I表，retumValue表示目标方法的返回值。

================LoggerAfter.java================== 

package com.obtk.advise;

import java.lang.reflect.Method;
import java.util.Arrays;
import org.apache.log4j.Logger;
import org.springframework.aop.AfterReturningAdvice;

public class LoggerAfter implements AfterReturningAdvice {
	private static final Logger log=Logger.getLogger(LoggerAfter.class);
	public void afterReturning(Object result, Method method, Object[] args,
			Object target) throws Throwable {
		log.info("调用了"+target+"的方法:"+method.getName()+",方法参数:"
				+Arrays.toString(args)+",返回值:"+result);
	}
}


要切入的方法

=================== 
public int save(UsersEntity user) {
		System.out.println("方法执行开始...");
		int result=0;
		SqlSession session=null;
		try {
			session=MybatisUtil.getSession();
			result=session.insert("user.save", user);
			session.commit();
		} catch (Exception e) {
			session.rollback();
			e.printStackTrace();
		}finally{
			MybatisUtil.closeSession();
		}
		System.out.println("方法执行结束...");
		return result;
	}

配置 

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	 http://www.springframework.org/schema/aop
	 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="dbUserDao" class="com.obtk.dao.DbUserDaoImpl"></bean>
	<bean id="userServ" class="com.obtk.service.UserService" p:userDao-ref="dbUserDao">	
	</bean>
	<bean id="afterAdvise" class="com.obtk.advise.LoggerAfter"></bean>
	<aop:config>
		<aop:pointcut id="myCut" expression="execution(* com.obtk.dao.*.*(..))" />
		<aop:advisor advice-ref="afterAdvise" pointcut-ref="myCut"/>
	</aop:config>
</beans>


二   异常抛出增强
异常抛出增强的特点是在目标方法抛出异常时织人增强处理。

增强处理代码

package com.obtk.advise;

import java.lang.reflect.Method;

import org.apache.log4j.Logger;
import org.springframework.aop.ThrowsAdvice;

public class ExceptionAdvise implements ThrowsAdvice {
	private static final Logger log=Logger.getLogger(ExceptionAdvise.class);
	public void afterThrowing(Method method,Object[] args
			,Object target,RuntimeException e){
		log.info("调用"+target+"的方法"+method.getName()+"发生了异常==>\n"+e);
	}
}

以上代码通过ThrowsAdvice接口实现异常抛出增强。ThrowsAdvice接口中并没有定义任何方法，但是我们在定义异常抛出的增强方法时必须遵守以下方法签名。

   void afterThrowing( Method method, Object[]  arguments,  Object  target,  Throwable ex)

   这里规定了方法名必须是afterThrowing。方法的人参只有最后1个是必需的，前3个人参是可选的，但是前3个参数要么都提供，要么一个也不提供。

切入的方法 

package com.obtk.dao;


import org.apache.ibatis.session.SqlSession;

import com.obtk.entitys.UsersEntity;
import com.obtk.utils.MybatisUtil;

public class DbUserDaoImpl implements UserDao{
	
	public int save(UsersEntity user) {
		System.out.println("方法执行开始...");
		int result=0;
		SqlSession session=null;
		try {
			session=MybatisUtil.getSession();
			result=session.insert("user.save", user);
			session.commit();
		} catch (Exception e) {
			session.rollback();
			//要使异常抛出增强代码生效，需要抛出异常
			throw new RuntimeException("我抛出的:"+e);
		}finally{
			MybatisUtil.closeSession();
		}
		System.out.println("方法执行结束...");
		return result;
	}
}
配置 

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	 http://www.springframework.org/schema/aop
	 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="dbUserDao" class="com.obtk.dao.DbUserDaoImpl"></bean>
	<bean id="userServ" class="com.obtk.service.UserService" p:userDao-ref="dbUserDao">	
	</bean>
	<bean id="beforeAdvise" class="com.obtk.advise.LoggerBefore"></bean>
	<bean id="afterAdvise" class="com.obtk.advise.LoggerAfter"></bean>
	<bean id="throwAdvise" class="com.obtk.advise.ExceptionAdvise"></bean>
	<aop:config>
		<aop:pointcut id="myCut" expression="execution(* com.obtk.dao.*.*(..))" />
		<aop:advisor advice-ref="beforeAdvise" pointcut-ref="myCut"/>
		<aop:advisor advice-ref="afterAdvise" pointcut-ref="myCut"/>
		<aop:advisor advice-ref="throwAdvise" pointcut-ref="myCut"/>
	</aop:config>
</beans>

三  环绕增强

环绕增强在目标方法的前后都可以织入增强处理。环绕增强是功能最强大的增强处理，Spring把目标方法的控制权全部交给了它。在环绕增强处理中，可以获取或修改目标方法的参数、返回值，可以对它进行异常处理，甚至可以决定目标方法是否执行。

环绕增强代码 

package com.obtk.advise;

import java.lang.reflect.Method;
import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.apache.log4j.Logger;

public class AroundAdvise implements MethodInterceptor {
	private static final Logger log=Logger.getLogger(AroundAdvise.class);
	public Object invoke(MethodInvocation arg0) throws Throwable {
		Object target=arg0.getThis();  //获取被代理的类的对象
		Method method=arg0.getMethod();  //获得要切入的方法
		Object[] args=arg0.getArguments(); //获得参数列表
		log.info("之前:调用了"+target+"的"+method.getName()+"方法,方法的入参是:" +
				Arrays.toString(args));
		Object result=null;
		try {
			result=arg0.proceed();  //执行save方法
			log.info("之后:调用了"+target+"的方法:"+method.getName()+",方法参数:"
					+Arrays.toString(args)+",返回值:"+result);
		} catch (Exception e) {
			log.info("发生了异常:调用"+target+"的方法"+method.getName()+"发生了异常==>\n"+e);
		}
		return result;
	}
}
切入的方法 

package com.obtk.dao;


import org.apache.ibatis.session.SqlSession;

import com.obtk.entitys.UsersEntity;
import com.obtk.utils.MybatisUtil;

public class DbUserDaoImpl implements UserDao{
	
	public int save(UsersEntity user) {
		System.out.println("方法执行开始...");
		int result=0;
		SqlSession session=null;
		try {
			session=MybatisUtil.getSession();
			result=session.insert("user.save", user);
			session.commit();
		} catch (Exception e) {
			session.rollback();
			//要使异常抛出增强代码生效，需要抛出异常
			throw new RuntimeException("我抛出的:"+e);
		}finally{
			MybatisUtil.closeSession();
		}
		System.out.println("方法执行结束...");
		return result;
	}
}
配置 

<?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:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	 http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	 http://www.springframework.org/schema/aop
	 http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
	
	<bean id="dbUserDao" class="com.obtk.dao.DbUserDaoImpl"></bean>
	<bean id="userServ" class="com.obtk.service.UserService" p:userDao-ref="dbUserDao">	
	</bean>
	<bean id="aroundAdvise" class="com.obtk.advise.AroundAdvise"></bean>
	<aop:config>
		<aop:pointcut id="myCut" expression="execution(* com.obtk.dao.*.*(..))" />
		<aop:advisor advice-ref="aroundAdvise" pointcut-ref="myCut"/>
	</aop:config>
</beans>









御前两把刀刀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
浅谈Android面向切面编程（AOP）
01-04
一、简述 1、AOP的概念 如果你用java做过后台开发，那么你一定知道AOP这个概念。如果不知道也无妨，套用百度百科的介绍，也能让你明白这玩意是干什么的： AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、项目场景 项目开发过程中，可能会有这样的需
@AfterReturning配置
z69183787的专栏
01-07 8939
AfterReturning和before，after，around不同是可以获取织入函数的返回值，配置复杂一点。 如果切入点如下： [java] view plaincopyprint? package com.leanyu.lcsystem.pointcut;      import org.aspectj.lang.annotat
Spring AOP面向切面编程实现原理方法详解
08-18
主要介绍了Spring AOP面向切面编程实现原理方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringAOP切面编程依赖jar包.rar
04-30
学习Spring开发的AOP面向切面编程时所需要的jar包，包括com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
abjectj--@AfterReturning讲解
qq_39071012的博客
06-06 1万+
1、@AfterReturning有两个参value、returning，vlue=excution()标明切片的切入位置，returning切入的目标类的返回值。@AfterReturning注解的切面方法是在目标方法执行后执行。 doOther方法是接口的实现方法，该方法新建并且返回一个对象student public Student doOther(String name, String age) { Student s = new Student(); s.s
Spring(二）AOP
hellowangyuqiang的博客
05-13 193
概念 AOP(Aspect Oriented Programming) 切点（pointcut）：原有功能 前置通知（before advice）：切点前执行的功能 后置通知(after advice）: 在切点之后执行的功能 异常通知(throws advice):切点执行过程中出现异常时触发. 实现方式 spring 提供了2 种AOP 实现方式 1.Schema_based 每个通知都需...
spring的切面，AOP的afterThrowing参数处理解释说明
一天不写代码难受的博客
11-09 5867
package com.sam.annotation; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.aspectj.lang.reflect.MethodSignature; import org.springframework.stereotype.Component; import jav
Spring框架中@AfterReturning的returning返回值对于String类型与自定义对象类型的参数值在方法中改变，返回值前者没有变化而后者改变问题的看法。
tiantian469的博客
04-17 2333
萌新的第一篇文章，还请轻喷！ 1.定义一个实体类，名为Student，参数有String name和Integer age，里面有toString方法，有参构造方法，set和get方法。 2.定义一个名为ServiceTest接口，里面有两个方法，doString()与doStudent()，第一个方法返回值为String，第二个方法返回值为Student。 3.定义接口实现类ServiceTestImpl，实现两个方法，第一个返回return “abc”;第二个返回return new Student(“
Spring AOP之@Around,@AfterReturning使用、切不进去问题解决
热门推荐
大吉的博客
03-02 2万+
本文主要举几个工作中典型AOP的实操案例，还有经常出现的问题（切不进去，ctrl+左键跳不到被切方法中）等等。
Spring AOP切面通过@AfterReturning获取返回参数时返回null
lzhfdxhxm的博客
01-02 9116
@AfterReturning如果和@Around一起使用，那么就需要给@Around的方法设置返回参数，因为@AfterReturning接收到的值其实是@Around返回的。 如果@Around的方法没设置返回参数，有2种可能： 1.@AfterReturning接收到的返回值为null 2.如果目标方法的返回值类型不是封装类型如Integer，而是基本类型比如int，则执行会报错： ...
Spring 面向切面编程AOP实现详解
08-25
主要介绍了Spring 面向切面编程AOP实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
揭秘AOP：切面编程的综合指南配套演示项目资源
最新发布
03-23
《揭秘AOP：切面编程的综合指南》文章配套演示项目资源
Spring AOP 切面编程实战Demo项目
01-26
2、面向切面编程AOP 在实现过程中，我尽量贴近实际开发与场景，麻雀虽小，五脏俱全，个人感觉这个项目是web框架搭建的一个极简之道实践。 项目中可能还存在很多的问题，希望大家不吝赐教，谢谢。
使用Spring框架实现AOP切面编程.zip
03-09
本资源通过一个Category和Publisher表的实例，使用Spring框架实现AOP切面编程，其中实现了增删改查的功能，通过事物(tx)管理器、扫描业务逻辑、声明式事务达到切面编程效果。代码中有很详细的备注，适合新手入门
@AfterReturning里面的Returning值解释,以及获取自定义注解参数值
weixin_47733858的博客
07-21 1万+
今天写代码遇到了@AfterReturning(returning = ‘var’) 查了很多网络资料都只说这个是方法返回值,并没有说是什么方法返回值,这里坐下代码解释 // 被切方法 @RestController @RequestMapping("/show") public class ControllerTwo { @RequestMapping("/test") @Hh(status = "2") public String test(){ retur.
Aop切面编程详解
▶『 迟墨 』◀的博客
09-02 1507
1、什么叫做面向切面编程（aop）及其应用场景 对比面向对象编程（oop），oop中模块化的核心单位是类，而aop的核心单位是切面。切面使事务管理等关注点的模块化得到实现。比如跨多个类型和对象的事务管理。登录token校验、方法执行的权限校验（访问控制）、性能检测、事务管理、日志记录等2、切面编程的名词 切面（Aspetct）：切点和通知的关系称为切面 连接点（Join Point）：类中所有的方法都是连接点 切点（Point Cut）：缺少共性功能代码的方法 （切入点一定是连接点，连接点不一定是切入点）.
（Spring笔记）AspectJ后置通知——@AfterReturning切面开发
张松的博客
06-30 2872
AspectJ后置通知——@AfterReturning切面开发
spring @AfterReturning 返回值
weixin_38312502的博客
03-04 7664
@AfterReturning是用于做aop的，其中返回值的问题，坑了我比较久，特地写出来。 1. 正确的使用 @AfterReturning(value = "pointCut()", returning = "obj") public Object doAfterReturning(JoinPoint joinPoint, Object obj) { // 正常情况下，我们想要修改obj，只需要强转为对应的对象，再重新设置值即可，如下 User user = (User)obj;
spring aop切面编程
09-01
Spring AOP切面编程是一种通过配置的方式，实现在Spring开发中的AOP功能。切面由切点和增强组成，切点用于定义在哪些连接点上应用增强，而增强指的是在连接点上要执行的逻辑操作。Spring的AOP强大之处在于不需要通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

御前两把刀刀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值