Spring框架学习--AOP

最新推荐文章于 2024-09-13 18:30:21 发布
最新推荐文章于 2024-09-13 18:30:21 发布
阅读量123 收藏
点赞数
分类专栏： 笔记 j2ee学习 文章标签： spring aop xml proxy java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41870237/article/details/108669978
版权

Spring框架学习--AOP


(jar包版本写的是我用的版本)

AOP的实现方式：

JDK

需要的Jar包

commons-logging-1.2.jar

spring-beans-5.0.2.RELEASE.jar
spring-context-5.0.2.RELEASE.jar
spring-core-5.0.2.RELEASE.jar
spring-expression-5.0.2.RELEASE.jar

实现方法

使用JDK实现AOP（面向切面编程）要求被代理的类属于接口实现类
即类似

public interface TestDao(){
	public void work();
}

public class TestDaoImpl implements TestDao{
	@Override
	public void work(){
		System.out.println("Work start");
	}
}

之后需要实现切面类（即包含通知方法的类）

import java.util.Date;

public class MyAspect {
	public void check() {
		System.out.println("权限控制");
	}

	public void except() {
		System.out.println("异常处理");
	}

	public void log() {
		System.out.println("日志记录");
	}

	public void monitor() {
		System.out.println("性能监控");
	}
	
	public void gettime() {
		System.out.println(new Date());
	}
}

再之后创建代理类 注意代理类需要实现InvocationHandler接口

package dynamic.jdk;

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

import aspect.MyAspect;

public class JDKProxy implements InvocationHandler{
	private TestDao dao;
	public Object init(TestDao dao) {
		this.dao=dao;
		ClassLoader cl=MyAspect.class.getClassLoader();
		Class[] clazz=dao.getClass().getInterfaces();
		return Proxy.newProxyInstance(cl, clazz, this);
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// TODO Auto-generated method stub
		MyAspect msp=new MyAspect();
		msp.gettime();
		Object obj=method.invoke(dao, args);
		System.out.println("JDKProxy OK");
		msp.log();
		return obj;
	}
}

其中的init函数用于增强TestDao类 主要函数是Proxy.newProxyInstance() 参数则分别为切面类的类加载器，被代理类实现的接口以及代理类本身
第二个函数是实现InvocationHandler接口的函数，method.invoke函数可以看作被包装类的方法的执行，前后的函数结果都会被打印出来
测试代码如下：

		TestDao tdao=new TestDaoImpl();
		JDKProxy jp=new JDKProxy();
		TestDao newtdao=(TestDao) jp.init(tdao);
		newtdao.save();

Fri Sep 18 17:06:55 CST 2020
Save Successed!
JDKProxy OK

这样就用JDK实现了AOP 但是这种方法必须要求类提供接口 而CGLIB的方法不需要类提供接口

CGLIB

需要的JAR包

在spring core包里面以及集成了所需的jar包 使用和jdk相同的jar包即可

实现方法

目标类可以直接写

public class Dao {
	public void work() {
		System.out.println("Im Working!");
	}
	
	public void run() {
		System.out.println("Im running!");
	}
}

之后依然是创建代理类，不同地方在于这里实现的接口是MethodInterceptor
代码如下：

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import aspect.MyAspect;

public class CGProxy implements MethodInterceptor{
	public Object init(Object target) {
		Enhancer enhancer =new Enhancer();
		enhancer.setSuperclass(target.getClass());
		enhancer.setCallback(this);
		return enhancer.create();
	}

	@Override
	public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
		// TODO Auto-generated method stub
		MyAspect masp=new MyAspect();
		masp.gettime();
		Object obj=arg3.invokeSuper(arg0, arg2);
		System.out.println("CGProxy OK");
		return obj;
	}
}

init依然是用来包装被代理类，这里使用了Object做参数，同时不同于JDK使用Proxy的函数进行强化，CGLIB是使用的Enhancer类，setsuperclass对被包装类进行强化，callback确定代理逻辑对象为当前对象（当前对象需要实现MethodInterceptor接口），返回enhancer.create()；
测试类如下

		Dao dao=new Dao();
		CGProxy cgp=new CGProxy();
		Dao newdao=(Dao)cgp.init(dao);
		newdao.work();

结果如下：

Fri Sep 18 17:06:55 CST 2020
Im Working!
CGProxy OK

AspectJ

基于XML实现

需要的jar包：
spring-aspects-5.0.2.RELEASE.jar（之前JDK处下载spring-frame的时候已经下载）
aspectjweaver-1.8.13

首先创建切面类 注意在这里编写切面类时各个函数的参数
环绕通知的部分可以类比前面两种方式

public class MyAspect {
	public void before(JoinPoint jp) {
		System.out.println("前置通知：");
		System.out.println("目标类："+jp.getTarget()+",增强方法"+jp.getSignature().getName());
	}
	
	public void after(JoinPoint jp) {
		System.out.println("后置通知：");
		System.out.println("模拟删除");
	}
	
	public Object around(ProceedingJoinPoint pjp) throws Throwable  {
		System.out.println("环绕开始");
		Object obj=pjp.proceed();
		System.out.println("环绕结束");
		return obj;
	}
	
	public void except(Throwable e) {
		System.out.println("模拟异常处理"+e.getMessage());
	}
	
	public void finall() {
		System.out.println("最终通知 释放资源");
	}
}

各种通知的顺序如下：
无异常：
前置通知->环绕开始->目标方法（被代理类的函数）->最终通知（finall）->环绕结束->后置返回通知（after）
有异常：
前置通知->环绕开始->目标方法（被代理类的函数）->最终通知（finall）->异常

之后创建配置文件
（函数名我起的不是很好 最终通知的标签是after 之前提的后置通知应该叫做后置返回通知 标签是after-returning）
每个通知标签都标定了一个方法和一个切入点

<?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"
    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">

    <bean id="testDao" class="dynamic.jdk.TestDaoImpl" /><!--被代理类加载-->
   
    <bean id="myAspect" class="aspectj.xml.MyAspect"/><!--加载切面-->
    
    <aop:config> <!--AOP配置-->
    	<aop:aspect ref="myAspect"><!--设置切面-->
    		<aop:pointcut expression="execution(* dynamic.jdk.*.*(..))" id="myPointCut"/><!--设置切入点-->
    		<aop:before method="before" pointcut-ref="myPointCut"/><!--前置-->
    		<aop:after-returning method="after" pointcut-ref="myPointCut"/><!--后置-->
    		<aop:around method="around" pointcut-ref="myPointCut"/><!--环绕-->
    		<aop:after-throwing method="except" pointcut-ref="myPointCut" throwing="e"/><!--异常-->
    		<aop:after method="finall" pointcut-ref="myPointCut" /><!--最终-->
    	</aop:aspect>
    </aop:config>
     
</beans>

测试类(使用了之前编写的的被代理类)

package aspectj.xml;

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

import dynamic.jdk.TestDao;

public class Test {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ApplicationContext appCon=new ClassPathXmlApplicationContext("/aspectj/xml/applicationContext.xml");
		TestDao td=(TestDao) appCon.getBean("testDao");
		td.save();
	}
}

前置通知：
目标类：dynamic.jdk.TestDaoImpl@5dd6264,增强方法save
环绕开始
Save Successed!
最终通知 释放资源
环绕结束
后置通知：
模拟删除

基于注解的实现

注意前面的两个注解@Aspect（相当于前面的<aop:aspect ref=“myAspect”>）和@Component（用来在框架中作为组件使用）
切面类实现：

package aspectj.annotation;

import java.util.Date;

import org.aspectj.lang.JoinPoint;
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;

@Aspect
@Component
public class MyAspect {
	@Pointcut("execution(* dynamic.jdk.*.* (..))")
	private void pcut() {
		
	}
	@Before("pcut()")
	public void before(JoinPoint jp) {
		System.out.println("前置通知开始：\n"+new Date());
	}
	@AfterReturning("pcut()")
	public void afterreturning(JoinPoint jp) {
		System.out.println("后置返回 afterreturning");
	}
	@After("pcut()")
	public void after(JoinPoint jp) {
		System.out.println("后置最终");
	}
	@Around("pcut()")
	public Object around(ProceedingJoinPoint pjp) throws Throwable {
		System.out.println("环绕开始");
		Object obj=pjp.proceed();
		System.out.println("环绕结束");
		return obj;
	}
	@AfterThrowing(value="pcut()",throwing="e")
	public void except(Throwable e) {
		System.out.println("错误通知"+e.getMessage());
	}
}

对目标类进行注解（在目标类上面把注解写进去）

@Repository("testDao")

最后配置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">
        <!--确定扫描包 使配置文件生效-->
	<context:component-scan base-package="aspectj.annotation"/>
	<context:component-scan base-package="dynamic.jdk"/><!--被代理类的位置 自己编写的时候可以不一样-->
	<aop:aspectj-autoproxy/>
</beans>

小结

以上就是AOP实现的不同方式，选择一种使用即可，最常用最方便的方法应该是最后的基于注解的AspectJ

代码一部分来自陈恒老师编写的JavaEE框架整合开发入门到实战

Gustuy
关注
专栏目录
AOP源码分析三：pointcut的配置说明
qq_28825857的博客
09-02 701
aop配置中有如下一行： <aop:pointcut expression="execution(* com.aop.service..*(..))" 其中expression="execution(* com.aop.service..*(..))"的配置规则如下： execution(modifiers-pattern? ret-type-pattern declaring-...
spring-aop-4.2.xsd.zip
05-31
标题中的"spring-aop-4.2.xsd.zip"表明这是一个与Spring框架的AOP（面向切面编程）相关的资源，版本为4.2，并且是XML Schema Definition（XSD）文件的压缩包。XSD文件用于定义XML文档的结构和数据类型，它在Spring...
【spring】Cglib动态代理的使用
morris
03-30 3593
cglib代理使用ASM对字节码进行操作生成新的类，从而实现对对象方法的增强。我们都知道Java中自带了一个动态代理，那我们为什么不直接使用Java动态代理，而要使用cglib呢？因为cglib相比于JDK动态代理更加强大，JDK动态代理虽然简单易用，但是其有一个致命缺陷是，只能对接口进行代理。如果要代理的类为一个普通类、没有实现接口，那么Java动态代理就没法使用了。 cglib的使用 CallbackFilter CglibCallbackFilter用来判断方法走那个Callback。 package
spring学习笔记（十八）Spring CGLlB动态代理
Ufridy的博客
10-21 172
通过学习《Spring JDK动态代理》一节可以了解到，JDK 动态代理使用起来非常简单，但是 JDK 动态代理的目标类必须要实现一个或多个接口，具有一定的局限性。如果不希望实现接口，可以使用 CGLIB代理。 CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它被许多 AOP 框架所使用，其底层是通过使用一个小而快的字节码处理框架 ASM（Java 字节码操控框架）转换字节码并生成新的类。使用 CGLIB 需要导入 CGLIB 和 ASM 包，即 asm-x.x.j
java基础--3动态代理
shining曙光的博客
12-03 87
动态代理是什么 动态代理提供一种抽象，能够将对象中不同方法的调用重定向到一个统一的处理函数，做自定义的逻辑处理。 但是对于调用者，对此毫无察觉，就好像调用的方法是用传统方式实现的一般。 这种语法，在java中被称为动态代理。之所以叫做动态代理，是因为它能避免传统代理模式实现中人工一个一个的将java函数转发过去， 而是能够让代码自动做到这一点，这样代理类的代码是和业务无关的，不会因为业务类的方法增多而逐渐庞大。 使代码更易维护更易修改，实现自动化搬砖。 实际上，被代理的类不一定位于本机类，动态代理语法提.
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
手写Spring框架---AOP实现
汤键的博客
06-18 782
手写Spring框架---AOP实现
spring框架--全面详解（学习笔记）
swy2560666141的博客
02-26 1万+
由 Spring IoC 容器管理的对象称为 Bean，Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂，Bean 相当于工厂的产品，如果希望这个大工厂生产和管理 Bean，则需要告诉容器需要哪些 Bean，以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式，即 XML 文件格式和 Properties 文件格式。
Spring框架----AOP的概念及术语
Java硬件工程师的博客
08-13 2235
1.什么是AOP AOP：全称是 Aspect Oriented Programming 即：面向切面编程 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。 2.AOP 的作用及优势 作用： 在程序运行期间，不修改源码对已有方法进行增强。 优势： 减少重复代码，提高开发效率，维护方便 3.AOP 的实现方式 使用动态代理技术 4.AOP 的术语及实现细节 1.Joinpoint(连接点):所谓连接点是指那些被拦截到的点。
spring学习日记-day6-AOP
2301_79789506的博客
09-02 1076
-注册bean-->--aop的配置-->--aop的配置-->
Spring框架----AOP全集
weixin_39038328的博客
03-14 772
Spring框架AOP全集
spring-aop-4.2.6.RELEASE.zip
09-25
无论是对于理解面向切面编程，还是深入学习Spring框架，甚至是参与开源项目，这些资料都将提供宝贵的帮助。开源项目的优势在于其透明度和社区支持，开发者可以通过参与讨论、提交问题、贡献代码等方式，与全球的同行...
spring-5.3.9-dist.zip（spring-framework-5.3.9）
01-07
Spring框架由多个模块组成，如Core Container（核心容器）、Data Access/Integration（数据访问/集成）、Web、AOP（面向切面编程）、Test等。每个模块都有相应的jar包，例如`spring-context.jar`提供了上下文支持，`...
spring-sec-aop-jpa-mysql-mongo-int---base:spring-sec-aop-jpa-mysql-mongo-int - 基础
06-18
在本项目"spring-sec-aop-jpa-mysql-mongo-int---base"中，我们主要关注的是基于Spring框架的安全性（Spring Security）、面向切面编程（AOP）、Java持久层API（JPA）、MySQL数据库以及MongoDB数据库的集成与基础...
spring-framework-4.3.30.RELEASE-dist.zip
01-07
对于学习和理解Spring框架的用法、配置以及最佳实践至关重要。通过阅读这些文档，开发者可以了解到Spring的核心概念、模块结构、配置方式以及如何将Spring集成到实际项目中。 2. **libs文件夹**：包含了一系列的jar...
第三章 SpringBoot项目构建 - 整合Spring Security入门
想做一个小孩的杨先生的博客
09-11 610
Spring Security 是一个强大的框架，用于保护基于 Spring 的应用程序。它提供了全面的认证和授权功能，使得安全机制与应用逻辑相分离。以下是 Spring Security 的基本使用指南，包括如何集成 Spring Security、定义用户角色和权限、以及自定义安全配置。在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。
Spring Framework 学习总结博客
最新发布
2302_80084329的博客
09-13 1055
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1400
本文写了基于spring mvc创建的博客系统；
SpringCloud gateway
c1tenj2的博客
09-11 1103
由此案例，我们可以感受到gateway带给我们的方便。有了gateway，前端就只需要请求8080端口，以模块进行路径的书写，就能访问所有的后端接口了，同时gateway也解决了跨域的问题。
深入理解Spring2-AOP：实战教程与核心原理解析
然后，通过一个综合案例，读者将学习如何利用Spring框架和相关技术构建完整的J2EE应用程序，这将涉及Spring的IoC（控制反转）容器、bean的配置和管理，以及AOP的集成。 在深入Spring的原理部分，作者将带领读者探索...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值