Spring学习笔记3_Aop

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量122 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/D965213977/article/details/118254775
版权

OOP：Object Oriented Programming 面向对象编程
AOP: aspect oriented programming 面向切面编程

通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术

AOP：定义目标类----target 中的方法—切入点 pointcut
定义切面类----aspect 中的方法—通知 advice
把切面类中的通知切入到目标类中的切入点-----织入，实现织入使用动态代理

动态代理：
1. JDK动态代理—要求：必须有接口，基于父接口的动态代理

2：cglib实现动态代理，spring本身就支持cglib动态代理，不需要有接口，
代理对象是被代理类的子类对象
基于父类的动态代理

spring已经实现了aop：spring框架可以生成代理对象

1.定义目标类
2.定义切面类 AOP联盟，制定了切面类符合的接口规范
3.由spring生成代理对象，实现织入

AOP图：
在这里插入图片描述

具体实现的两种方法
1.JDK动态代理：基于接口的，必须存在父接口

Proxy.newProxyInstance(,,new InvocationHandler(){ })

（1）创建目标类

//目标类
public class UserServiceImpl implements UserService {

    @Override//pointcut切入点
    public void addUser() {
        System.out.println("add user...");
    }

    @Override
    public void deleteUser() {
        System.out.println("delete user...");
    }

    @Override
    public void updateUser() {
        System.out.println("update user...");
    }
}

（2）创建切面类

//切面类 aspect：在目标类的方法中要加入的功能
public class MyAspect {

    public void before(){//advice
        System.out.println("开启事务...");
    }
    public void after(){
        System.out.println("提交事务...");
    }
}

（3）JDK动态代理实现

public class Demo {
    public static void main(String[] args) {
        //创建目标类对象(被代理对象)
        UserService userService = new UserServiceImpl();

        //创建切面类对象
        MyAspect myAspect = new MyAspect();

        //利用JDK动态代理实现织入
        UserService proxyObj =(UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        myAspect.before();
                        Object obj = method.invoke(userService, args);
                        myAspect.after();
                        return obj;
                    }
                });
        proxyObj.addUser();
    }
}

2.基于父类的，代理对象是被代理的类的子类对象， spring自带cglib的jar包

Enhancer en=new Enhancer();
	      en.setSuperClass(目标类.class);

	      en.setCallBack(new MethodInterceptor(){
	      
	      });

	      en.create(); //返回代理对象

public class Demo {
    public static void main(String[] args) {
        //创建目标类对象
        UserServiceImpl userService = new UserServiceImpl();
        //创建切面类对象
        MyAspect myAspect = new MyAspect();

        //使用cglib生成代理对象
        //创建一个增强类对象
        Enhancer enhancer = new Enhancer();

        //指定代理对象的类型
        enhancer.setSuperclass(UserServiceImpl.class);

        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                myAspect.before();
                Object obj = method.invoke(userService, args);
                myAspect.after();
                return obj;
            }
        });
        //生成代理对象
        UserServiceImpl proxy = (UserServiceImpl) enhancer.create();
        proxy.addUser();
        proxy.deleteUser();
        proxy.updateUser();
    }
}

ps:coding过程中，发现Enhance不能自动导入，只能手动import相关的包，这一点比较奇怪，防止以后再次出现相应问题，我先备份一下：

import org.springframework.cglib.proxy.MethodProxy;

3.使用Aop联盟

//AOP联盟，制定了切面类的规范(接口)
public class MyAspect implements MethodInterceptor {
    //环绕通知，在目标类中的切入点之前和之后切入功能
    //前置通知，后置通知，异常抛出通知
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("开启事务...");
        Object obj = methodInvocation.proceed();//执行目标类对象的方法
        System.out.println("提交事务...");
        return obj;
    }
}

AOP联盟为通知Advice定义了

org.aopalliance.aop.Advice

Spring按照通知Advice在目标类方法的连接点位置，可以分为5类

• 前置通知 ：在目标方法执行前实施增强

org.springframework.aop.MethodBeforeAdvice

• 后置通知：在目标方法执行后实施增强

 org.springframework.aop.AfterReturningAdvice

• 环绕通知：在目标方法执行前后实施增强

 org.aopalliance.intercept.MethodInterceptor

• 异常抛出通知 ：在方法抛出异常后实施增强

org.springframework.aop.ThrowsAdvice  //在catch中切入代码

• 引介通知 ：在目标类中添加一些新的方法和属性

org.springframework.aop.IntroductionInterceptor

spring实现aop的两种方式：

1.半自动方式：

<bean id = "" class="org.springframework.aop.framework.ProxyFactoryBean">
      <!--指定代理对象实现的接口-->
      <property name="interfaces" value="com.aop3.UserService"></property>
      
      <!--指定目标类对象的名字-->
      <property name="targetName" value="userService"></property>

      <!--指定切面类对象-->
      <property name="interceptorNames"  value="aspectId"></property>
</bean>

2.全自动方式：

（1） 切面类符合aop联盟规范

<aop:config>
	<aop:pointcutid="points"expression="execution(*com.aop4.UserServiceImpl.*(..))"/>
	<aop:advisor advice-ref="aspectId" pointcut-ref="points"></aop:advisor>
</aop:config>

（2）切面类符合AspectJ规范

<aop:config>
        <aop:aspect ref="aspectId">
            <!--使用该标签说明myBefore方法属于前置通知-->
            <!--<aop:before method="myBefore" pointcut="execution(* com.aop5.UserServiceImpl.*(..))"></aop:before>-->
            
            <!--使用该标签说明myAfter方法属于前置通知-->
            <!--<aop:after-returning method="myAfter" pointcut="execution(* com.aop5.UserServiceImpl.*(..))" returning="ret"></aop:after-returning>-->

            <aop:pointcut id="points" expression="execution(* com.aop5.UserServiceImpl.*(..))"/>

            <!--环绕通知-->
             <aop:around method="myAround" pointcut-ref="points"></aop:around>

            <!--异常通知-->
            <aop:after-throwing method="myException" pointcut-ref="points" throwing="t"></aop:after-throwing>

            <!--最终通知-->
            <aop:after method="myFinal" pointcut-ref="points"></aop:after>
        </aop:aspect>

    </aop:config>

切入点表达式：

语法：execution(修饰符 返回值 包.类.方法名(参数) throws异常)
修饰符：一般省略
public： 公共方法
星号 ： 任意
返回值：不能省略
void ：返回没有值
String： 返回值字符串
星号 ： 任意

包：[省略]
com.dzc.com 固定包
com.dzc.com.kk.service
com.dzc.com.“星号”.service com包下面子包任意 （例如：com.dzc.com.staff.aa.bb…service）
com.dzc.com… com包下面的所有子包（含自己）com.dzc.com.staff.cc.kk
com.dzc.com.*.service… com包下面任意子包，固定目录service，service目录任意包

类，[省略]
UserServiceImp： 指定类
"星号"Impl ： 以Impl结尾
User"星号"： 以User开头
"星号"： 任意

方法名，不能省略
addUser：固定方法
add"星号"：以add开头
"星号"Do：以Do结尾
"星号"：任意

(参数)
()： 无参
(int)： 一个整型
(int ,int： 两个
(…)： 参数任意
throws ,可省略，一般不写。
利用spring配置.xml文件的方法定义AspectJ风格的切面类
1.切面类

//定义AspectJ风格的切面类
public class MyAspect {
    //自定义前置通知

    //前置通知
    public void myBefore(){
        System.out.println("事务执行前");
    }

    //后置通知  可以获取切入点方法的返回值
    public void myAfter(Object ret){
        System.out.println("事务执行后，返回值是"+ret);
    }

    //环绕通知:返回值类型必须是Object,参数必须是ProceddingJoinPoint类型  切入点发生异常执行
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务..");
        Object obj = joinPoint.proceed();//执行的是目标类对象的方法
        System.out.println("关闭事务..");
        return obj;
    }

    //异常通知
    public void myException(Throwable t){
        System.out.println("出大问题了老爷！"+t.getMessage());
    }

    //最终通知
    public void myFinal(){
        System.out.println("最终通知..");
    }
}

2.bean.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--    创建目标类对象：被代理的对象-->
    <bean id="userService" class="com.aop5.UserServiceImpl"></bean>
    <!--    创建切面类对象-->
    <bean id="aspectId" class="com.aop5.MyAspect"></bean>

    <aop:config>
        <aop:aspect ref="aspectId">
            <!--使用该标签说明myBefore方法属于前置通知-->
            <!--<aop:before method="myBefore" pointcut="execution(* com.aop5.UserServiceImpl.*(..))"></aop:before>-->
            
            <!--使用该标签说明myAfter方法属于前置通知-->
            <!--<aop:after-returning method="myAfter" pointcut="execution(* com.aop5.UserServiceImpl.*(..))" returning="ret"></aop:after-returning>-->

            <aop:pointcut id="points" expression="execution(* com.aop5.UserServiceImpl.*(..))"/>

            <!--环绕通知-->
             <aop:around method="myAround" pointcut-ref="points"></aop:around>

            <!--异常通知-->
            <aop:after-throwing method="myException" pointcut-ref="points" throwing="t"></aop:after-throwing>

            <!--最终通知-->
            <aop:after method="myFinal" pointcut-ref="points"></aop:after>
        </aop:aspect>

    </aop:config>

</beans>

利用注释的方法定义AspectJ风格的切面类

//定义AspectJ风格的切面类
@Component
//指定当前类是切面类
@Aspect
public class MyAspect {
    //前置通知
    @Before("execution(* com.aop6.UserServiceImpl.*(..))")
    public void myBefore(){
        System.out.println("事务执行前");
    }

    @Pointcut("execution(* com.aop6.UserServiceImpl.*(..))")
    public void myPoint(){}

    //后置通知  可以获取切入点方法的返回值
    @AfterReturning(value = "myPoint()",returning = "ret")
    public void myAfter(Object ret){
        System.out.println("事务执行后，返回值是"+ret);
    }

    //环绕通知:返回值类型必须是Object,参数必须是ProceddingJoinPoint类型  切入点发生异常执行
    @Around("myPoint()")
    public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("开启事务..");
        Object obj = joinPoint.proceed();//执行的是目标类对象的方法
        System.out.println("关闭事务..");
        return obj;
    }

    //异常通知
    @AfterThrowing(value = "myPoint()",throwing = "t")
    public void myException(Throwable t){
        System.out.println("出大问题了老爷！"+t.getMessage());
    }

    //最终通知
    @After("myPoint()")
    public void myFinal(){
        System.out.println("最终通知..");
    }
}
D965213977
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring学习笔记——AOP
qq_47102228的博客
04-11 673
Spring AOP，AspectJ
学习Spring笔记_AOP_Annotation实现和XML实现
08-05
NULL 博文链接：https://ysj5125094.iteye.com/blog/2055563
Spring学习笔记——AOP篇
qq_53149124的博客
08-12 767
除了spring的几个基础包外还需要导入aspectjweaver，下面是maven导入的配置信息 常用名词 名词 解释 连接点 可以被增强的方法 切入点 实际被增强的方法。切入点就是被增强的连接点 通知 增强的逻辑实现 切面 通知和切入点的组合 常用的通知类型 类型 解释 前置通知 在被增强方法之前执行的逻辑部分 后置通知 在被增强方法之后执行的逻辑部分，如果被增强方法出现异常就不会执行了 环绕通知 在被增强方法之前和之后执行的逻辑部分 异常通知
Spring学习笔记：AOP
qq_49019244的博客
02-20 773
学习内容：AOP 一、什么是AOP 当我们操作某些数据的时候，一般检验用户的权限，并且操作完数据后记录日志，按照正常的逻辑，我们可以这么做： 但是对数据的每一个操作都得检验权限和记录日志，不仅代码重复，而且也是非常的麻烦。我们可以把这些公共部分写入一个方法，每次操作数据需要检验和记录日志的时候，调用这个方法就行了： 虽然代码重复的问题解决了，但是，每个用户操作数据总得要调用这个方法吧。于是就有了切面的概念，我将方法注入到调用的某个地方（切点）。 二、AOP中的相关概念 术语 概念 A
Spring学习笔记——Spring AOP
运气只是当机会来临时，你已为它准备好。
04-15 520
Spring AOP AOP（Aspect-Oriented Programming，面向切面编程），通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离。从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP用来封装多个类的公共行为，将与业务无关，却被业务模块共同调用的逻辑封装起来，减少系统
Spring学习笔记（AOP）
weixin_51738373的博客
05-02 513
Spring学习笔记（AOP） 什么是AOP AOP，即面向切面编程，是OOP的补充，它也提供了模块化。在面向对象编程中，关键的单元是对象，AOP的关键单元是切面。 说得简单点，AOP就是一个能够在不修改源代码的情况下做功能增强的一种编程思想 AOP术语 连接点 可以增强的方法 切入点 实际上被增强的方法 通知（增强） 实际增强的逻辑部分 通知有多种类型： - 前置通知 在连接点之前执行的Advice，除非他抛出异常，否则没有能力中断执行流。使用@Before这个注解可以使用这个Adv
Spring5学习笔记__04
bh009的博客
06-30 4786
动态代理 1、创建接口 public interface UserDao { public int add(int a, int b); public String update(String s); } 2、创建实现类 @Controller(value = "userDaoImpl") public class UserDaoImpl implements UserDao { @Override public int add(int a, int b) {
Spring学习笔记-AOP（XML配置）
金鳞踏雨
03-10 930
Spring学习笔记-AOP。AOP(Aspect Oriented Programing)面向切面编程，一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构 AOP弥补了OOP的不足，基于OOP基础之上进行横向开发 OOP规定程序开发以类为主体模型，一切围绕对象进行，完成某个任务先构建模型 AOP程序开发主要关注基于OOP开发中的共性功能，一切围绕共性功能进行，完成某个任务先构建可能遇到的所有共性功能
Spring学习笔记3——AOP
李公子的博客
06-24 141
aop（面向切面编程）：将纵向重复代码，横向抽取解决，简称：横切 过滤器Filter体现了AOP思想 纵向重复的身份验证代码，横向抽取解决。 Spring-aop是基于动态代理的 – 优先选用JDKProxy动态代理； Proxy动态代理：被代理的对象必须要实现接口； Cglib动态代理：被代理的对象不能被final修饰，基于继承； Springaop相关名词说明 ...
spring框架学习笔记04（AOP）
08-03 639
目录
Spring_AOP学习笔记
yan_yzy的博客
12-07 330
概念：AOP（Aspect Oriented Programming）是一种面向切面的编程。比如当我们需要在一个已有的系统中添加日志，就需要到各个模块的控制层或是实现层添加代码，这样开发效率极低，并且代码冗余。如果利用AOP，就相当于，在所有的控制层上，划分出一个切面，这个切面定义了日志记录，所有经过控制层的代码，都会通过切面进行日志保存。 实例： 一 在配置文件中配置AOP
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
Spring_AOP_Demo
02-13
Spring 学习笔记《切面编程 AOP 之 暗黑肉夹馍诞生》源码
Spring Aop 学习笔记
03-25
Spring Aop 学习笔记
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 890
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 893
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Spring6基础笔记
质胜文则野，文胜质则史。文质彬彬，然后君子。
05-21 1206
Spring 是一款主流的 Java EE 轻量级开源框架 ，Spring 由“Spring 之父”Rod Johnson 提出并创立，其目的是用于简化 Java 企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。Spring 框架除了自己提供功能外，还提供整合其他技术和框架的能力。Spring 自诞生以来备受青睐，一直被广大开发人员作为 Java 企业级应用程序开发的首选。时至今日，Spring 俨然
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 493
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 226
【代码】Java手动启动jar包。
spring 学习笔记
04-10
以下是关于Spring学习的一些笔记： 1. IoC（控制反转）：Spring通过IoC容器管理对象的创建和依赖关系的注入。通过配置文件或注解，将对象的创建和依赖关系的维护交给Spring容器来管理，降低了组件之间的耦合度。 2...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值