spring之AOP

最新推荐文章于 2022-11-25 23:21:14 发布
最新推荐文章于 2022-11-25 23:21:14 发布
阅读量75 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46690290/article/details/107887621
版权

springAop

AOP中关键性概念

连接点(Joinpoint)： 程序执行过程中明确的点，如方法的调用，或者异常的抛出.

目标(Target)：被通知(被代理)的对象
注1：完成具体的业务逻辑

通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
注2：完成切面编程

代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),
例子：外科医生+护士
注3：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的

切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。
(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)

适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut)

如何实现AOP
目标对象只负责业务逻辑代码
通知对象负责AOP代码，这二个对象都没有AOP的功能，只有代理对象才有

  1. AOP
    即面向切面编程

  2. AOP带来的好处
    让我们可以 “专心做事”
    案例：

   public void doSameBusiness (long lParam,String sParam){
     // 记录日志
     log.info("调用 doSameBusiness方法，参数是："+lParam);
     // 输入合法性验证
     if (lParam<=0){
          throws new IllegalArgumentException("xx应该大于0");
     }
     if (sParam==null || sParam.trim().equals("")){
          throws new IllegalArgumentException("xx不能为空");
     }
     // 异常处理
     try{ ...
     }catch(...){
     }catch(...){
     }
     // 事务控制
     tx.commit();
   }

3 工具类org.springframework.aop.framework.ProxyFactoryBean用来创建一个代理对象,在一般情况下它需要注入以下三个属性：
proxyInterfaces：代理应该实现的接口列表(List)
interceptorNames：需要应用到目标对象上的通知Bean的名字。(List)
target：目标对象 (Object)

  1. 前置通知(org.springframework.aop.MethodBeforeAdvice)：在连接点之前执行的通知()
    案例：在购书系统当中使用AOP方式实现日志系统

代理类伪代码:
public class BookBizImpl implements IBookBiz{}

public class $Proxy4 implements IBookBiz{

   IBookBiz target;

   String[] interceptorNames = new String[]{"myMethodBeforeAdvice"};

   buy(a,b,c){
      myMethodBeforeAdvice.before(....);
      target.buy(a,b,c);
      myAfterReturningAdvice.afterReturning(....);
   }

   comment(){ 
   }
}


       IBookBiz

 BookBizImple  $Proxy0


bookBiz.buy("张三", "西游记", 88d);
$Proxy0.buy("张三", "西游记", 88d)

  1. 后置通知(org.springframework.aop.AfterReturningAdvice)：在连接点正常完成后执行的通知 案例：在线购书系统中，要求不修改BookBizImpl代码的情况下增加如下功能：对买书的用户进行返利：每买本书返利3元。(后置通知)
    即：每调用一次buy方法打印：“[销售返利][时间]返利3元。”

  1. 环绕通知(org.aopalliance.intercept.MethodInterceptor)：包围一个连接点的通知，最大特点是可以修改返回值，由于它在方法前后都加入了自己的逻辑代码，因此功能异常强大。
    它通过MethodInvocation.proceed()来调用目标方法（甚至可以不调用，这样目标方法就不会执行） 案例：修改日志系统不光要输出参数，还要输出返回值(环绕通知)

这个接口里面没有定义方法，我们要求我们的类必须实现afterThrows这个方法

 public void afterThrowing( [Method method,] [Object args,] [Object target,] Throwable throwable );

前面三个参数都是可选的，只有第三个参数是必须的,同时我们还可以在同一个类中定义这个方法的多个版本，如：

 public void afterThrowing( MyException1 ex ) {}
 public void afterThrowing( MyException2 ex ) {}

具体那个方法被调用则根据具体的Exception来判断，
由AOP容器自动识别 执行

  1. 异常通知(org.springframework.aop.ThrowsAdvice)：这个通知会在方法抛出异常退出时执行
    案例： 书本价格为负数时抛出一个异常，通过异常通知取消此订单

  2. 适配器(org.springframework.aop.support.RegexpMethodPointcutAdvisor) 适配器=通知(Advice)+切入点(Pointcut)
    案例：通过适配器解决发书评时也返利的问题
    .*buy


  1. 请使用接口接收返回的代理对象
    A
    B C
    A a1 = new B();
    A a2 = new C();
    B b = (B) a2;

异常通知PriceException

package com.hzh.aop.biz;

public class PriceException extends RuntimeException {

	public PriceException() {
		super();
	}

	public PriceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
	}

	public PriceException(String message, Throwable cause) {
		super(message, cause);
	}

	public PriceException(String message) {
		super(message);
	}

	public PriceException(Throwable cause) {
		super(cause);
	}
	
}


package com.hzh.aop.advice;

import org.springframework.aop.ThrowsAdvice;

import com.hzh.aop.biz.PriceException;
/**
 * 异常通知
 * @author houzhihong
 *	案列：zs向ls转账
 *		biz.transfer(user1,user2)
 *		 UserDao.update(user1)
 *		 UserDao.update(user2)	
 * 2020年8月6日
 */
public class MyThrowsAdvice implements ThrowsAdvice {
		
	public void afterThrowing( PriceException ex ) {
		System.out.println("价格输入有误，购买失败，请重新输入！！！");
	}
}



service层

package com.hzh.aop.biz;

public class BookBizImpl implements IBookBiz {

	public BookBizImpl() {
		super();
	}

	public boolean buy(String userName, String bookName, Double price) {
		// 通过控制台的输出方式模拟购书
		if (null == price || price <= 0) {
			throw new PriceException("book price exception");
		}
		//谁买了那本书，多少钱
		System.out.println(userName + " buy " + bookName + ", spend " + price);
		return true;
	}

	public void comment(String userName, String comments) {
		// 通过控制台的输出方式模拟发表书评
		System.out.println(userName + " say:" + comments);
	}

}

各类通知（前置，后置，环绕）


1.前置通知

package com.hzh.aop.advice;

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

import org.springframework.aop.MethodBeforeAdvice;
/**
 * 买书.评论前加系统日志
 * @author houzhihong
 *
 * 2020年8月6日
 */
public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
			String clzName = target.getClass().getName();
			String methodName =method.getName();
			String params =Arrays.toString(args);
			System.out.println("[买书,评论前加系统日志]:"+clzName + "." +methodName +"("+params+")");
	}

}

2.后置通知

package com.hzh.aop.advice;

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

import org.springframework.aop.AfterReturningAdvice;
/**
 * 买书返利（存在bug）
 * @author houzhihong
 *
 * 2020年8月6日
 */
public class MyAfterReturningAdvice implements AfterReturningAdvice {

	@Override
	public void afterReturning(Object returnvalue, Method method, Object[] args, Object target) throws Throwable {
		String clzName = target.getClass().getName();
		String methodName =method.getName();
		String params =Arrays.toString(args);
		System.out.println("[买书返利的后置通知]:"+clzName + "." +methodName +"("+params+")"+"\t目标对象方法调用后的返回值:"+returnvalue);
	}

}

3.环绕通知

package com.hzh.aop.advice;

import java.util.Arrays;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
/**
 * 前置通知＋后置通知=环绕通知
 * @author houzhihong
 *
 * 2020年8月6日
 */
public class MyMethodInterceptor implements MethodInterceptor {

	@Override
	public Object invoke(MethodInvocation Invocation) throws Throwable {
		String clzName =Invocation.getThis().getClass().getName();
		String methodName =Invocation.getMethod().getName();
		String params =Arrays.toString(Invocation.getArguments());
		System.out.println("[环绕通知]:"+clzName + "." +methodName +"("+params+")");
			Object returnvalue = Invocation.proceed();
		System.out.println("[环绕通知]:\t目标对象方法调用后的返回值:"+returnvalue);
		return returnvalue;
	}

}

4.spring.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:cache="http://www.springframework.org/schema/cache"
	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-4.3.xsd
		http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-4.3.xsd">
		<!--AOP面向切面  -->
		<!--目标对象+通知=代理  -->
	<!--set 注入用  property标签-->
		<!--目标对象  -->
	<bean class="com.hzh.aop.biz.BookBizImpl" id="bookBiz"></bean>
		<!--前置通知  -->
	<bean class="com.hzh.aop.advice.MyMethodBeforeAdvice" id="myBefore"></bean>	
		<!--后置通知  -->
	<bean class="com.hzh.aop.advice.MyAfterReturningAdvice" id="myafter"></bean>	
		<!--环绕通知  -->
	<bean class="com.hzh.aop.advice.MyMethodInterceptor" id="Interceptor"></bean>
		<!--异常通知  -->
	<bean class="com.hzh.aop.advice.MyThrowsAdvice" id="ThrowsAdvice"></bean>	
		<!--过滤通知(适配器)  -->
	<bean class="org.springframework.aop.support.RegexpMethodPointcutAdvisor" id="myafter2">
		<property name="advice" ref="myafter"></property>
		<property name="pattern"  value=".*buy"></property>
	</bean>	
		<!--代理 ：由代理工厂来组装目标对象和通知 -->
	<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="bookproxy">
		<!--对象  -->
		<property name="target" ref="bookBiz"></property>
		<!-- 接口 -->
		<property name="proxyInterfaces">
			<list>
			<value>com.hzh.aop.biz.IBookBiz</value>
			</list>
		</property>
		<!-- 通知 -->
		<property name="interceptorNames">
			<list>
				<value>myBefore</value>
				<!-- <value>myafter</value> -->
				<value>myafter2</value>
				<value>Interceptor</value>
				<value>ThrowsAdvice</value>
			</list>
		
		</property>
	</bean>	
</beans>

5.测试结果
在这里插入图片描述

h0824_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring 之aop
03-06
博文链接：https://yunhaifeiwu.iteye.com/blog/198956
spring之AOP（动态代理）
09-06
spring之AOP（动态代理），包括jdk动态代理和CGLib动态代理
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring之aop注解实现
qq_47455973的博客
02-28 3630
Spring中的AOP1.什么是AOP2.怎么实现AOP# 2.1AOP相关的注解介绍# 2.2实现AOP的xml配置# 2.3实现AOP# 2.4对相同切入点的公共化# 2.5设置多个增强类的优先级 1.什么是AOP Aop是java的spring框架中的一种特性，aop是面向切面编程的缩写，那什么是面向切面编程呢？ 面向切面编程就是，在不对源码进行修改的情况下对源码所实现的功能进行增强。 举例说明 原本一个程序可以实现用户登入的功能，然后我想在这个功能的基础上，加入一个新的功能，就是对用户等级的判断，按
Spring之AOP入门篇
楠黎倾风的博客
11-15 1万+
spring之AOP入门篇
Spring之AOP适配器模式
波波烤鸭的博客
03-06 8136
  Spring架构中涉及了很多设计模式，本文来介绍下Spring中在AOP实现时Adapter模式的使用。AOP本质上是Java动态代理模式的实现和适配器模式的使用，关于这两种设计模式的具体介绍烦请参考我之前的文章 Java代理模式 Java适配器模式(adapter) 文章目录Spring中适配器模式一、AOP案例1.相关依赖2.创建目标对象3.创建通知4.配置文件5.测试二、适配器应用解...
Spring之AOP简介
weixin_43790613的博客
01-23 4514
文章目录定义AOP 的作用及优势 定义 AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强 AOP 的作用及优势 作用：在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便 实现方式 使用动态代理技术 ...
Spring之AOP的原理(一)--概述
IT利刃出鞘的博客
11-18 4590
本文介绍Spring中的AOP的原理。
Spring框架之AOP详解
qq_45515347的博客
09-05 1915
Spring AOP 详解，并实现demo
Spring之AOP的切点、通知、切点表达式以及知识要点
楠黎倾风的博客
11-25 1万+
Spring之AOP的切点、通知、切点表达式以及知识要点
Spring之AOP系列--使用场景/原理
IT利刃出鞘的博客
10-11 1万+
本文介绍Spring AOP的使用场景、原理、配置、使用方式。
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
Spring之AOP详细介绍 应用场景
最新发布
08-23
Spring之AOP详细介绍 应用场景
Spring之AOP介绍
03-19
对Spring框架中的AOP的介绍，能够全面了解Spring中AOP的功能和使用方法。
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring之AOP技术文档
03-18
这份文档以例子的形式讲诉了AOP技术，希望可以帮助学习的人！
Spring之AOP注解之引入通知
08-11
NULL 博文链接：https://ihuning.iteye.com/blog/2227042
spring-aop
03-17
在学spring时，做的有关aop的代码。可以直接导入使用。
spring aop aopalliance
08-07
Spring AOP是基于AOP联盟（aopalliance）的API构建的框架。AOP联盟定义了一系列的接口，用于实现面向切面编程的功能。在Spring框架中，将AOP联盟的接口以内嵌的形式放到了spring-aop包中，同时也引入了spring...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值