Java-SpringAOP（面向切面编程）详解，Java代码学习案例

最新推荐文章于 2024-06-14 09:56:07 发布
最新推荐文章于 2024-06-14 09:56:07 发布
阅读量707 收藏 5
点赞数 3
文章标签： java aop 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56309075/article/details/119035909
版权

1.SpringAOP

1.1 AOP介绍

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP主要利用动态代理模式，降低程序的耦合度，拓展业务功能的方法

1.2 名词解释

1).连接点: 用户可以被扩展的方法 joinPoint
2).切入点: 用户实际扩展的方法(判断方法能否进入切面) pointcut 切入点表达式
3).通知: 扩展方法的具体实现 @before…
4).切面: 将通知应用到切入点的过程 方法功能得到扩展全部配置(切面=切入点表达式+通知方法)
在这里插入图片描述

（老王饿了去吃饭，路上被雷劈到了天庭，吃了饭吃了蟠桃，人参果，唐僧。)

(整个全过程=切面，连接点=eat（）/JoinPoint，切入点=被雷劈/pointcut，通知=进入天庭开始吃)

1.3 通知类型

1. @before: 在目标方法执行之前执行
 ​	2.@afterReturning: 在目标方法执行之后返回时执行
 ​	3.@afterThrowing: 在目标方法执行之后,抛出异常时执行
 ​	4.@after: 无论程序是否执行成功,都要最后执行的通知
 ​	5.@around: 在目标方法执行前后 都要执行的通知(完美体现了动态代理模式)，功能最为强大 只有环绕通知可以控制目标方法的执行

关于通知方法总结:
1.环绕通知是处理业务的首选. 可以修改程序的执行轨迹（控制目标方法的执行）
2.另外的四大通知一般用来做程序的监控.(监控系统) 只做记录

1.4 切入点表达式

概念:当程序满足切入点表达式,才能进入切面,执行通知方法.

1.bean(“bean的ID”) 根据beanId进行拦截 只能匹配一个
2.within(“包名.类名”) 可以使用通配符 ***** 能匹配多个.
粒度: 上述的切入点表达式 粒度是类级别的. 粗粒度.
3.execution(返回值类型 包名.类名.方法名(参数列表…))
粒度: 控制的是方法参数级别. 所以粒度较细. 最常用的.
4.@annotation(包名.注解名) 只拦截注解.
粒度: 注解是一种标记 根据规则标识某个方法/属性/类 细粒度

1.5 AOP入门案例

1.5.1 导入jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>spring_demo_9_aop</artifactId>
<version>1.0-SNAPSHOT</version>

<dependencies>

    <!--Spring核心包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>5.3.6</version>
    </dependency>

    <!--引入SpringBean-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.3.6</version>
    </dependency>

    <!--引入context包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.6</version>
    </dependency>

    <!--引入表达式jar包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>5.3.6</version>
    </dependency>

    <!--引入日志依赖-->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>

    <!--引入测试包-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>

    <!--引入AOP包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aop</artifactId>
        <version>5.3.6</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.6</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.6</version>
    </dependency>
</dependencies>
</project>

1.5.2 编写UserService/userServiceImpl类

package com.jt.vo.aop;

public interface UserService {
    void  addUser();

    void  deleteUser();
}


import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("新增用户");
    }

    @Override
    @Cath  // 被注解标识
    public void deleteUser() {
        System.out.println("删除用户");
    }


}

1.5.3 创建注解类

package com.jt.vo.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)  //控制注解的生命周期
//注解的作用对象，  方法有效   类有效   Type
@Target({ElementType.METHOD,ElementType.TYPE,ElementType.FIELD})
public @interface Cath {


}

1.5.4 配置切面类

切面 = 切入点表达式 + 通知方法

package com.jt.vo.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

//1.AOP需要被Spring容器管理
@Component
//2.标识该类为AOP切面
//  Spring容器默认不能识别切面注解,需要手动配置
@Aspect
public class SpringAOP {

     /**
     * 切入点表达式练习
     * within:
     *  1.within(com.jt.*.DeptServiceImpl)   一级包下的类
     *  2.within(com.jt..*.DeptServiceImpl)  ..代表多级包下的类
     *  3.within(com.jt..*)  包下的所有的类
     *
     * execution(返回值类型 包名.类名.方法名(参数列表))
     *  1.execution(* com.jt..*.DeptServiceImpl.add*())
     *  注释: 返回值类型任意的, com.jt下的所有包中的DeptServiceImpl的类
     *        的add开头的方法 ,并且没有参数.
     *
     *  2.execution(* com.jt..*.*(..))
     *  注释: 返回值类型任意,com.jt包下的所有包的所有类的所有方法 任意参数.
     *
     *  3.execution(int com.jt..*.*(int))
     *  4.execution(Integer com.jt..*.*(Integer))
     *  强调: 在Spring表达式中没有自动拆装箱功能! 注意参数类型
     *
     * @annotation(包名.注解名)
     *     @Before("@annotation(com.jt.anno.Cache)")
     *    只拦截特定注解的内容.
     */

    //        定义切入点表达式
    @Pointcut("@annotation(com.jt.vo.aop.Cath)")
    public void pointcut() {

    }

    //1.定义before通知
//    @Before("bean(userServiceImpl)")
    //@Before("within(com.jt..*)")
    //@Before("execution(* com.jt..*.userServiceImpl.add*())")
    @Before("pointcut()")
    public void before() {
        System.out.println("我是userServiceImpl的前置通知");
    }

    @AfterReturning("pointcut()")
    public void AfterReturning() {
        System.out.println("我是userServiceImpl的前置通知");
    }

    @AfterThrowing("pointcut()")
    public  void  afterThrowing(){
        System.out.println("我是userServiceImpl异常通知,不报错我不会出来");
    }

    @After("pointcut()")
    public  void  after(){
        System.out.println("我是userServiceImpl后置通知");
    }
//
//    @Around("pointcut()")
//    public  void  around(){
//        System.out.println("我是userServiceImpl环绕通知");
//    }

}

1.5.4 编辑配置类

package com.jt.vo;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.jt.vo")
@EnableAspectJAutoProxy(proxyTargetClass=false) //启动AOP注解 创建代理对象
//默认启用JDK动态代理,
//目标对象没有实现接口时,则采用CGLIB
//强制使用cglib proxyTargetClass=true
//JDK代理创建速度快.运行时稍慢
//CGLIB创建时速度较慢,运行时更快

public class SpringConfig {
}

1.5.5编写测试类

package com.jt.vo.aop;

import com.jt.vo.SpringConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestUser {

    @Test
    public  void  testUserService(){
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService= (UserService) context.getBean(UserService.class);
        userService.addUser();
        userService.deleteUser();
    }
}

1.5.6 测试结果

在这里插入图片描述

1.6.1 @Before作用

说明: 前置通知,在目标方法执行之前执行
用途: 如果需要记录程序在方法执行前的状态,则使用前置通知.
需求: 1.获取目标对象的类型
2.获取目标方法的名称
3.获取目标方法的参数

    /*Spring为了AOP动态获取目标对象及方法中的数据,则通过joinPoint对象
     * 进行数据的传递.
     * getSignature : 方法签名  获取方法的参数
     * */

    /*Spring为了AOP动态获取目标对象及方法中的数据,则通过joinPoint对象
     * 进行数据的传递.
     * getSignature : 方法签名  获取方法的参数
     * */
@Before("pointcut()")
public void before(JoinPoint joinPoint){
    System.out.println("获取目标对象的类型:"+joinPoint.getTarget().getClass());
    System.out.println("获取目标对象类名:"+joinPoint.getSignature().getDeclaringTypeName());
    System.out.println("获取目标对象方法名:"+joinPoint.getSignature().getName());
    System.out.println("获取方法参数:"+ Arrays.toString(joinPoint.getArgs()));
    System.out.println("我是before通知");
}

测试结果：

在这里插入图片描述

1.6.2 @AfterReturning

说明: afterReturning,在目标方法执行之之后执行
用途: 用来监控方法的返回值,进行日志的记录

1).在接口中添加测试方法 String after（Integer id）

package com.jt.vo.aop;

public interface UserService {
//    aop中的测试方法
    String after(Integer id);

2).实现目标方法 添加注解类 将其交由AOP切面

package com.jt.vo.aop;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService {
    @Override
    @Cath
    public String after(Integer id) {
        return "spring通知的测试" ;
    }
}

3).编辑AOP方法测试

package com.jt.vo.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

import java.util.Arrays;

//1.AOP需要被Spring容器管理
@Component
//2.标识该类为AOP切面
//  Spring容器默认不能识别切面注解,需要手动配置
@Aspect
public class SpringAOP {

    //        定义切入点表达式
    @Pointcut("@annotation(com.jt.vo.aop.Cath)")
    public void pointcut() {

    }
@AfterReturning(pointcut = "pointcut()",returning = "result")
public void AfterReturning(JoinPoint joinPoint,Object result) {
    System.out.println("我是userServiceImpl的运行通知"+joinPoint.getArgs());
    System.out.println("用户返回值的结果"+result);
}

4）编辑测试类

package com.jt.vo.aop;

import com.jt.vo.SpringConfig;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestUser {

@Test
public  void  testUserService2(){
    ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService= (UserService) context.getBean(UserService.class);
    userService.after(112);
}

5）测试结果

在这里插入图片描述

1.6.3 @AfterThrowing

作用: 当目标方法执行时,抛出异常时 可以使用AfterThrowing 进行记录.

1).编辑业务接口

在这里插入图片描述

2).编辑业务实现类

在这里插入图片描述

3）编辑异常通知类型

在这里插入图片描述

4）编辑测试类

在这里插入图片描述

5）查看结果

在这里插入图片描述

1.6.4 @Around

1.6.4.1 @Around作用

规则: 在目标方法执行前后都要执行
实际作用: 可以控制目标方法是否执行.

1.6.4.2 环绕通知学习
/**
 * 关于环绕通知的说明
 * 作用: 可以控制目标方法是否执行.
 * 参数: ProceedingJoinPoint 通过proceed方法控制目标方法执行.
 * 注意事项:
 *      ProceedingJoinPoint is only supported for around advice
 * @return
 */
@Around("pointcut()")
public Object around(ProceedingJoinPoint joinPoint){
    Object result = null;
    try {
        System.out.println("环绕通知开始");
        //1.执行下一个通知  2.执行目标方法 3.接收返回值
        Long start = System.currentTimeMillis();
        result = joinPoint.proceed();
        Long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start));
    } catch (Throwable throwable) {
        throwable.printStackTrace();
    }
    System.out.println("环绕通知结束");
    return result;
}

1.7 关于知识点讲解

1.7.1 pointcut

说明:判断方法能否进入切面 IF判断
注解说明: @Pointcut 内部编辑切入点表达式
判断依据:

在这里插入图片描述

1.7.2. joinPoint(连接点)

说明: 当用户执行方法时,如果方法满足pointcut表达式,则该方法就是连接点.
如果通知中需要获取方法相关参数 则Spring会将joinPoint对象进行封装.为通知参数进行赋值

在这里插入图片描述

通俗理解一点就是执行的原方法中途进入切面后改名并赋值 Joinpoint（） = addUser（）

1.8 关于通知方法的执行顺序

1.执行around开始
2.执行before
3.执行目标方法
4.执行afterReturning
5.执行afterThrowing
6.执行after
7,执行around通知结束

1.9 关于Order注解说明

说明: 研究如果是多个切面,如何控制切面的执行的顺序.
方法: 通过Order注解实现.

在这里插入图片描述

小时候的梨甜
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java切面获取到方法里类的值_spring aop 切面编程中获取具体方法的方法
weixin_35867127的博客
02-28 1575
@Around(value = "GlobalControllerAspect.controllerPointcut()")public Object around(ProceedingJoinPoint proceedingJoinPoint) throwsThrowable {Object result= null;try{long statrTime=System.currentTimeMi...
Spring AOP定义Before增加实战案例详解
08-25
Spring AOP（Aspect-Oriented Programming）是一种面向切面编程技术，允许开发者 modularize 和 reuse 代码，以便更好地实现软件系统的可维护性和可扩展性。其中，Before 增加是 AOP 中最基本也是最重要的一种 ...
【Java 初级】Spring核心之面向切面编程(AOP)
激流丶的博客
06-12 2914
AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。
CGB2102-SpringDay05-AOP
qq_16804847的博客
04-26 6348
Spring AOP 底层 实现就是动态代理 AOP 就是对动态代理的优化
深入理解Java中的AOP（面向切面编程）
最新发布
weixin_53840353的博客
06-14 1457
AOP是一种编程思想，它允许开发者将横切关注点从业务逻辑中分离出来，形成所谓的“切面”（Aspect）。切面可以定义在程序执行的特定点（如方法调用前后）插入额外的逻辑，这些点被称为“连接点”（Join Points）。AOP的主要目标是提高模块化，使得业务逻辑更加清晰，同时减少代码的重复。
java框架 Spring之 AOP 面向切面编程 切入点表达式 AOP通知类型 Spring事务
m0_73859807的博客
11-27 693
}}
spring的aop面向切面编程简单示例简介
qq_40390762的博客
01-05 312
aop是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要目的 将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。 pom中依赖： <!--切面依赖--> <dependency...
Spring AOP注解案例及基本原理详解
08-19
Spring AOP注解案例及基本原理详解 ...Spring AOP提供了一种强大的面向切面编程机制，可以将横切逻辑与业务逻辑分离，从而提高代码的可维护性和可读性。通过使用注解，可以轻松地将横切逻辑编织到目标对象中。
Spring框架系列(11) - Spring AOP实现原理详解之Cglib代理实现.doc
07-08
Spring AOP，全称Aspect Oriented Programming，即面向切面编程，是Spring框架的一个重要特性，用于实现横切关注点的模块化。AOP通过在运行时动态地将代码编织到一起，使得我们可以在不修改原有业务代码的情况下，对...
Java 反射机制详解及实例代码
09-01
3. **框架设计**：Spring框架中的依赖注入和AOP（面向切面编程）大量使用了反射。 4. **元数据操作**：例如JDBC中的`ResultSetMetaData`用于获取查询结果的列信息。 5. **测试工具**：JUnit等测试框架利用反射来调用...
关于Java spring 的网络购物中心项目
03-14
Spring的核心是依赖注入（Dependency Injection, DI）和面向切面编程（Aspect-Oriented Programming, AOP），这些特性使得代码更易于测试和维护。 2. **Spring MVC**： 在本项目中，Spring MVC作为前端控制器，...
Spring-aop面向切面编程实例
03-02
Spring-aop面向切面编程实例 日志系统,权限控制等.
Java AOP篇
wk3510的博客
11-12 1万+
AOP，一般成为面向切面，作为面向对象OOP的一种补充，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块之间的耦合度，提高了系统的可维护性。可用于权限认证，日志和事务处理.
spring aop面向切面原理，用处和实力讲解
热门推荐
小爷欣欣
07-27 2万+
先实例对比说说什么面向切面，看下面代码： @Override public void savePerson() { //现在我想把每个保存数据库的语句前后都打印一句话，如下： System.out.println("开始保存到数据库....."); save(person); //请把这句看做是保存数据库的语句 Syste...
java Spring AOP详解及简单实例
infi
08-26 229
一、什么是AOP AOP（Aspect Oriented Programming）面向切面编程不同于OOP（Object Oriented Programming）面向对象编程，AOP是将程序的运行看成一个流程切面，其中可以在切面中的点嵌入程序。 举个例子，有一个People类，也有一个Servant仆人类，在People吃饭之前，Servant会准备饭，在People吃完饭之后...
第3章：JavaSpringAOP概念详解
XiaoCai
05-26 241
AOP:Aspect Oriented Programming 面向切面编程 OOP:Object Oriented Programming 面向对象编程       面向切面编程：基于OOP基础上新的编程思想，OOP面向的主要对象是类，而AOP面向的主要对象是切面，再处理日志，安全管理，事务管理等方面有非常重要的作用。AOP是Spring中重要的核心点，虽然IOC容器没有依赖AOP，但是AOP提供了非常强大的功能，用来对IOC做补充。 &nbsp
Spring-----AOP面向切面编程
BUG专业户
07-07 607
SpringAOP面向切面编程
AOP的应用以及代码实现（详细剖析）
我是老伯的博客
02-20 2232
AOP的应用以及代码实现（详细剖析）
java 切面详解_Java-AOP(面向切面编程)详解
weixin_31115505的博客
02-25 6390
AOP(面向切面编程)是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。(以上为抄的，纯理论)。例如：在一个web工程(利用spring mvc搭建)中做了一个拦截器，拦截所有的url请求，对异常的请求进行拦截，实现安全...
Spring AOP详解：面向切面编程的概念与应用
在Spring框架中，AOP（Aspect Oriented Programming，面向切面编程）是一个重要的特性，它允许开发者将关注点分离，将横切关注点如日志记录、事务管理、权限检查等从核心业务逻辑中抽离出来，以提高代码的可复用性...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值