Spring之AOP

最新推荐文章于 2024-04-09 11:22:05 发布
最新推荐文章于 2024-04-09 11:22:05 发布
阅读量237 收藏
点赞数
分类专栏： Spring系列 文章标签： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cactus_Lrg/article/details/82856033
版权

Spring之AOP

【什么是aop?】

AOP,Aspect-Oriented Programming 面向切面编程
【AOP的由来】
OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需 要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。
AOP技术利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为 “Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低 模块间的耦合度，并有利于未来的可操作性和可维护性。
AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为； 那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手 将这些剖开的切面复原，不留痕迹。

【知识铺垫】
Spring对AOP的支持，底层采用的是动态代理。所以我们要先来了解一下代理模式。

什么是代理模式？
Proxy Pattern，23种常用的面向对象软件的设计模式之一。
为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

代理模式的组成

  • 抽象角色：通过接口或抽象类声明真实角色实现的业务方法。
  • 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。
  • 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。

为什么要用代理模式？

  1. 中介隔离
    在某些情况下，一个客户类不想或者不能直接引用一个委托对象，而代理类对象可以在客户类和委托对象之间起到中介的作用，其特征是代理类和委托类实现相同的接口。

  2. 开闭原则，增加功能
    代理类除了是客户类和委托类的中介之外，我们还可以通过给代理类增加额外的功能来扩展委托类的功能，这样做我们只需要修改代理类而不需要再修改委托类，符合代码设计的开闭原则。

代理模式分类

1. 静态代理模式

优点：符合开闭原则，可以实现功能的增加，并起到中介隔离的作用
缺点：动态拓展性不好，一个代理类只能代理一个实际组件
实现：

抽象角色 UserService.java

package com.neusoft.SpringAop.Service;

public interface UserService {
	void add();
	void delete();
	void query();
	void modify();
}

真实角色 UserImpl .java

package com.neusoft.SpringAop.Impl;

import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

import com.neusoft.SpringAop.Service.UserService;

@Service
public class UserImpl implements UserService{

	@Override
	public void add() {
//		int a = 2/0;
		System.out.println("this is add method");
	}

	@Override
	public void delete() {
		System.out.println("this is delete method");
	}

	@Override
	public void query() {
		System.out.println("this is query method");
	}

	@Override
	public void modify() {
		System.out.println("this is modify method");
	}

}

代理角色 UserProxyStatic.java

package com.neusoft.SpringAop.proxy;

import com.neusoft.SpringAop.Impl.UserImpl;
import com.neusoft.SpringAop.Service.UserService;

public class UserProxyStatic implements UserService{
	private UserService us = new UserImpl();
	@Override
	public void add() {
		System.out.println(System.currentTimeMillis());
		us.add();
	}

	@Override
	public void delete() {
		System.out.println(System.currentTimeMillis());
		us.delete();
	}

	@Override
	public void query() {
		System.out.println(System.currentTimeMillis());
		us.query();
	}

	@Override
	public void modify() {
		System.out.println(System.currentTimeMillis());
		us.modify();
	}

}

测试类 Test1 .java

package com.neusoft.SpringAop.Test;

import com.neusoft.SpringAop.Service.UserService;
import com.neusoft.SpringAop.proxy.UserProxyStatic;

public class Test1 {
	public static void main(String[] args) {
		UserService us = new UserProxyStatic();
		us.add();
	}

}

2.动态代理模式
优点： 相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度
缺点： 无法摆脱仅支持interface代理的桎梏
实现：

抽象角色 UserService.java 如上
真实角色 UserImpl .java 如上
代理角色 UserProxyDynamic.java

package com.neusoft.SpringAop.proxy;

import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class UserProxyDynamic implements InvocationHandler{
	
	private Object target;
	
	public UserProxyDynamic(Object object) {
		this.target = object;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//功能添加区
			System.out.println(System.currentTimeMillis());
		//功能添加区
		//反射，获取对应方法
		Object result = method.invoke(target, args);
		return result;
	}
	
	//获取代理对象
	public <T> T getProxy(){
		return (T) Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}

}

测试类 Test.java

package com.neusoft.SpringAop.Test;

import java.util.HashMap;
import java.util.Map;

import com.neusoft.SpringAop.Impl.UserImpl;
import com.neusoft.SpringAop.Service.UserService;
import com.neusoft.SpringAop.proxy.UserProxyDynamic;
import com.neusoft.SpringAop.proxy.UserProxyStatic;

public class Test {
	public static void main(String[] args) {
		UserService us = new UserProxyDynamic(new UserImpl()).getProxy();
		Map<String, String> map = new UserProxyDynamic(new HashMap<String,String>()).getProxy();
		us.add();
		System.out.println(map.size());
	}

}

【Spring中AOP】
Spring中AOP的使用，分两种形式：

  • 声明式aop(依赖xml配置文件配置关系)
  • 注解式aop

在这里我们只介绍声明式AOP，因为在xml配置文件中会使相关的配置显的简单明了，若采用注解式，将会让人变的头大。

实现：
抽象角色 UserService.java 如上
真实角色 UserImpl .java 如上

配置文件 app.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" xmlns:tx="http://www.springframework.org/schema/tx"
       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
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
       
	<bean id = "userImpl" class = "com.neusoft.SpringAop.Impl.UserImpl"></bean>
	<bean id = "timer" class = "com.neusoft.SpringAop.util.Timer"></bean>
	
	<aop:config>
		<!-- 要切入的对象 -->
		<aop:aspect id = "test1" ref="timer">
			<!-- 切面 -->
			<aop:pointcut expression="execution(* com.neusoft.SpringAop.Service.*.*(..))" id="service"/>
			<aop:after-throwing method="showTime" pointcut-ref="service"/>
		</aop:aspect>
	</aop:config>
       
</beans>

其中，
<aop:aspect id = “test1” ref=“timer”> 声明要切入的对象

<aop:pointcut 中 expression 的值表示切面，即被代理对象
上述代码中expression 值表示，任意返回值 com.neusoft.SpringAop.Service中任意类 任意方法 任意参数

<aop:after-throwing method=“showTime” pointcut-ref=“service”/>代表切入对象切入的位置，这里又分5种情况

  1. 前置通知 <aop:before method=""/>
  2. 后置通知 <aop:after method=""/>
  3. 环绕通知(前+后) <aop:around method=""/>
  4. 最终通知 <aop:after-returning method=""/>
  5. 异常通知 <aop:after-throwing method=""/>

下面伪代码，可表示其位置

		try{
			前置通知
			目标方法
			后置通知
		}catch(){
			异常通知
		}finally{
			最终通知
		}

测试类：Test.java

package com.neusoft.SpringAop.Test;

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

import com.neusoft.SpringAop.Impl.UserImpl;
import com.neusoft.SpringAop.Service.UserService;
import com.neusoft.SpringAop.proxy.UserProxyStatic;

public class Test {
	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("app.xml");
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("app3.xml");
		UserService us = (UserService) applicationContext.getBean("userImpl");
		us.add();
	}

}

补充：
个人认为，使用AOP时，在获取bean采用标注形式，aop配置采用xml声明配置，效果最佳。

【AOP应用场景】

  • 日志
  • spring提供事务管理器,利用aop将事务管理器切入到我们的代码逻辑上
  • springmvc中的拦截器
喜鹊先生Richard
关注
专栏目录
spring 之aop
03-06
标题中的“Spring 之AOP”指的是在Spring框架中对面向切面编程（Aspect-Oriented Programming，简称AOP）的使用。AOP是软件设计的一种模式，它将关注点分离，使得我们可以独立地处理系统中的交叉关注点，如日志、...
spring之AOP（动态代理）
09-06
在Spring框架中，AOP（面向切面编程）是一种强大的设计模式，它允许开发者将关注点分离，将横切关注点（如日志、事务管理、权限检查等）与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
AOP FOR PHP 探讨----runkit
也想快乐的生活
06-30 5389
AOP FOR PHP 探讨----runkitrunkit扩展库是pecl的php扩展的一部分， 最近两天在用这个东西尝试实现无侵入式的AOP。runkit提供了一套函数，能让你动态的修改任意类和函数的定义。根据php提供的反射机制，得到所有用户定义的类和函数，你可以把他们重命名然后再用原来的函数名/方法名重新添加一个方法/函数，重新添加的函数的函数体，你可以任意定义---用字串儿，
Spring之AOP的详细讲解
最新发布
tq02的博客
04-09 4753
本文讲解的是SpringAOP，将切点、切面、通知点，逐步剖析，代码举例，配合理解！
Spring之AOP注解开发
楠黎倾风的博客
11-25 1万+
Spring之AOP注解开发
Spring之AOP日志记录
积跬步，至千里。
10-17 1588
在Java中，可以使用注解和切面技术来实现AOP（Aspect Oriented Programming）。AOP是一种编程范式，它通过将应用程序分解为关注点的模块来提高代码的可维护性和重用性。注解可以用于标记程序元素，例如类、方法和字段，以便切面可以识别和操作这些元素。
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring之aop注解实现
qq_47455973的博客
02-28 3841
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 8556
  Spring架构中涉及了很多设计模式，本文来介绍下Spring中在AOP实现时Adapter模式的使用。AOP本质上是Java动态代理模式的实现和适配器模式的使用，关于这两种设计模式的具体介绍烦请参考我之前的文章 Java代理模式 Java适配器模式(adapter) 文章目录Spring中适配器模式一、AOP案例1.相关依赖2.创建目标对象3.创建通知4.配置文件5.测试二、适配器应用解...
Spring之AOP简介
weixin_43790613的博客
01-23 5031
文章目录定义AOP 的作用及优势 定义 AOP： 全称是 Aspect Oriented Programming 即： 面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强 AOP 的作用及优势 作用：在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码 提高开发效率 维护方便 实现方式 使用动态代理技术 ...
Spring之AOP的原理(一)--概述
IT利刃出鞘的博客
11-18 5015
本文介绍Spring中的AOP的原理。
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
SpringBoot打jar包失败问题解决（无主清单属性或无依赖文件）
Cactus_Lrg的博客
12-02 764
一、问题背景 使用maven对SpringBoot项目打jar包，jar包无法正常运行，出现如下问题： 问题1： xxx.jar中没有主清单属性 问题2： Error: A JNI error has occurred, please check your installation and try again Caused by: java.lang.ClassNotFoundException: XXX 表面上报错是找不到依赖包的某一类，实际上解压jar包发现相关依赖并没有打进去 二、问题解决
SpringBoot项目，配置Redis多数据源
Cactus_Lrg的博客
06-08 500
一、maven依赖 Springboot版本: 1.5.6.RELEASE <!--redis--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!--多数据源--> <depend
Spring高级话题-@Enable*注解的工作原理
Cactus_Lrg的博客
12-09 471
一、@Enable*注解的工作原理 我们通过使用@Enable*来开启某一项功能的支持，从而避免配置大量大麦，降低使用难度 通过观察源码，@Enable*注解都使用了@Import注解，@Import是用来导入配置类的，这就意味着@Enable*的实现是通过导入了一些自动配置的Bean来实现的 二、导入配置方式的三种类型 1. 直接导入配置类 如：@EnableScheduling @Ta...
Spring常用配置 - EL及使用资源文件
Cactus_Lrg的博客
10-15 344
一、Spring EL是什么？ Spring表达式语言，支持在xml和注解中使用表达式，类似于JSP的el表达式语言。 二、怎么使用？ Spring主要在 @Value注解 使用表达式， 实现资源的注入。 可以注入包括以下内容： 普通字符 操作系统属性 表达式运算结果 其他Bean的属性 文件内容 网址内容 属性文件 三、ELDemo 一个憨憨的Bean package com.cac...
Spring 概述
Cactus_Lrg的博客
10-11 312
一、Spring概述 The Spring Framework is an application framework and inversion of control container for the Java platform. The framework’s core features can be used by any Java application, but there are ...
Spring高级话题-条件注解
Cactus_Lrg的博客
12-09 299
一、什么是条件注解 根据特定的条件来控制Bean的创建行为 使用到的注解 @Conditional 二、如何使用条件注解 通过实现Condition接口并重写matches方法（构造判断条件）来实现一个条件判断类 在配置Bean时使用@Conditional注解，并指定条件判断类，实现有条件地创建Bean 三、conditionDemo 通过判断程序在什么系统下运行，来创建对应的Be...
Spring框架AOP初学者指南
这使得Spring框架成为企业级Java应用中的首选框架之一。 在实际应用中，Spring AOP支持多种通知类型，包括前置通知（Before）、后置通知（After）、返回后通知（After Returning）、异常后通知（After Throwing）和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

喜鹊先生Richard

随缘~

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

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

打赏作者

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

抵扣说明：

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

余额充值