1. Toy模板网首页
  2. > Toy博客

[SSM]Spring面向切面编程AOP

9月前 作者：热咖啡不太冷 分类：Toy博客 阅读(48) 违法举报

这篇具有很好参考价值的文章主要介绍了[SSM]Spring面向切面编程AOP。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

十五、面向切面编程AOP

15.1AOP介绍

15.2AOP的七大术语

15.3切点表达式

15.4使用Spring的AOP

15.4.1准备工作

15.4.2基于AspectJ的AOP注解式开发

15.4.3基于XML配置方式的AOP（了解）

15.5AOP的实际案例：事务处理

15.6AOP的实际案例：安全日志

十五、面向切面编程AOP

  • IoC使软件组件松耦合。AOP让你能够捕捉系统中经常使用的功能，把它转化为组件。

  • AOP（Aspect Oriented Programming）：面向切面编程。

  • AOP是对OOP（面向对象编程）的补充延伸。

  • AOP底层使用的就是动态代理来实现的。

  • Spring的AOP使用的动态代理是：JDK动态代理+CGLIB动态代理技术。Spring在这两种动态代理中灵活切换，如果是代理接口，会默认使用JDK动态代理，如果要代理某个类，这个类没有实现接口，就会切换使用CGLIB。当然，你也可以强制通过一些配置让Spring只使用CGLIB。

15.1AOP介绍

  • 一般一个系统当中都会有一些系统服务，例如：日志、事务管理、安全等。这些系统服务被称为：交叉业务。

  • 这些交叉业务几乎是通用的，不管你是做银行账户转账，还是删除用户数据。日期、事务管理、安全，这些都是需要的。

  • 如果在每一个业务处理过程中，都掺杂这些交叉业务代码进去的话，存在两方面问题：

    • 第一：交叉业务代码在多个业务流程中反复出现，显然这个交叉业务代码没有得到复用，并且修改这些交叉业务代码的话，需要修改多处。

    • 第二：程序员无法专注核心业务代码的编写，在编写核心业务代码的同时还需要处理这些交叉业务。

  • 使用AOP可以很轻松的解决这些问题。

[SSM]Spring面向切面编程AOP,spring,java,后端

  • 用一句话总结AOP：将与核心业务无关的代码独立的抽取出来，形成一个独立的组件，然年以横向交叉的方式应用到业务流程当中的过程被称为AOP。

  • AOP的优点：

    • 代码复用性增强。

    • 代码易维护。

    • 使开发者更关注业务逻辑。

15.2AOP的七大术语

  • 连接点 Joinpoint

    • 在程序的整个执行流程中，可以织入切面的位置。方法的执行前后，异常抛出之后的位置。

  • 切点 Pointcut

    • 在程序执行流程中，真正注入切面的方法。（一个切点对应多个连接点）

  • 通知 Advice

    • 通知又叫做增强，就是具体你要织入的代码。

    • 通知包括：

      • 前置通知

      • 后置通知

      • 环绕通知

      • 异常通知

      • 最终通知

  • 切面 Aspect

    • 切点+通知就是切面

  • 织入 Weaving

    • 把通知应用到目标对象上的过程。

  • 代理对象 Proxy

    • 一个目标对象被织入通知后产生的新对象。

  • 目标对象 Target

    • 被织入通知的对象。

[SSM]Spring面向切面编程AOP,spring,java,后端 

 文章来源地址https://www.toymoban.com/news/detail-618178.html

15.3切点表达式

  • 切点表达式用来定义通知（Advice）往哪些方法上切入。

  • 切入点表达式语法格式：

execution([访问控制权限修饰符] 返回值类型 [全限定类名] 方法名(形式参数列表) [异常])

  • 访问控制权限修饰符：

    • 可选项

    • 没写就是4个权限都包括

    • 写public就表示只包括公开的方法

  • 返回值类型：

    • 必填项

    • *表示返回值类型任意

  • 全限定类名：

    • 可选项

    • 两个点".."代表当前包以及子包下的所有类

    • 省略时表示所有的类

  • 方法名：

    • 必填项

    • *表示所有方法

    • set*表示所有的set方法

  • 形式参数列表：

    • 必填项

    • ()表示没有参数的方法

    • (..)参数类型和个数随意的方法

    • (*)只有一个参数的方法

    • (*,String)第一个参数类型随意，第二个参数是String的

  • 异常：

    • 可选项

    • 省略时表示任意异常类型

execution(public * com.hhb.service.*.delete*(..))

  • service包下所有类中以delete开始的所有方法

execution(* com.hhb.mall..*(..))

  • mall包下所有的类的所有的方法

execution(* *(..))

  • 所有类的所有方法

15.4使用Spring的AOP

  • Spring对AOP的实现包括以下3种方式：

    • 第一种方式：Spring框架结合AspectJ框架实现的AOP，基于注解开发。

    • 第二种方式：Spring框架结合AspectJ框架实现的AOP，基于XML方式。

    • 第三种方式：Spring框架自己实现的AOP，基于XML配置方式。

  • 实际开发中，都是Spring+AspectJ来实现AOP，所有重点学习第一种和第二种方式。

  • 什么时AspectJ？

    • Eclipse组织的一个支持AOP的框架，AspectJ框架是独立于Spring框架之外的一个框架，Spring框架用了AspectJ。

15.4.1准备工作

  • 使用Spring+AspectJ的AOP需要引入的依赖如下：

<dependencies>
        <!--spring-context依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>6.0.3</version>
        </dependency>
        <!--spring-aspects依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.3</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

  • Spring配置文件中添加context命名空间和aop命名空间

<?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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
​
</beans>
15.4.2基于AspectJ的AOP注解式开发

第一步：定义目标类以及目标方法

package com.hhb.service;
​
import org.springframework.stereotype.Service;
​
@Service("userService")
public class UserService {//目标类
​
    public void login() {//目标方法
        System.out.println("系统正在进行身份认证...");
    }
​
    public void logout() {
        System.out.println("退出系统...");
    }
}
package com.hhb.service;
​
import org.springframework.stereotype.Service;
​
@Service("orderService")
public class OrderService {//目标类
    //目标方法
    public void generate(){
        System.out.println("系统正在生成订单");
    }
}

第二步：定义切面类

package com.hhb.service;
​
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
​
@Component("logAspect")
@Aspect //切面类是需要使用@Aspect注解进行标注的
public class LogAspect {//切面
    //切面=通知+切点
    //通知就是增强，就是具体的要编写的增强代码
    //@Before注解标注的放法就是一个前置通知
    @Before("execution(* com.hhb.service..*(..))")
    public void 增强() {
        System.out.println("通知，增强代码");
    }
}

第三步：在spring配置文件中添加组件扫描和自动代理

<?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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
​
    <!--组件扫描-->
    <context:component-scan base-package="com.hhb.service"/>
​
    <!--开启aspectj的自动代理-->
    <!--spring容器在扫描类的时候，查看该类上是否有@Aspect注解，如果有，则给这个类生成代理对象-->
    <!--
        proxy-target-class="true"  表示强制使用CGLIB动态代理
        proxy-target-class="false" 这是默认值，表示接口使用JDK动态代理，反之使用CGLIB动态代理。
    -->
    <aop:aspectj-autoproxy/>
</beans>

第四步：测试

@Test
public void testBefore() {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    UserService userService = applicationContext.getBean("userService", UserService.class);
    userService.login();
    userService.logout();
​
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    orderService.generate();
}

[SSM]Spring面向切面编程AOP,spring,java,后端

 

通知类型

  • 通知类型包括：

    • 前置通知：@Before目标方法执行之前的通知

    • 后置通知：@AfterReturning目标方法执行之后的通知

    • 环绕通知：@Around目标方法之前添加通知，目标方法之后添加通知

    • 异常通知：@AfterThrowing发生异常之后执行的通知

    • 最终通知：@After放在finally语句块中的通知

  • 测试

 

package com.hhb.service;
​
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
​
@Component("logAspect")
@Aspect
public class LogAspect {//切面
​
    @Before("execution(* com.hhb.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }
​
    @AfterReturning("execution(* com.hhb.service..*(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }
​
    @Around("execution(* com.hhb.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("前环绕");
        //执行目标
        joinPoint.proceed();
        System.out.println("后环绕");
    }
​
    @AfterThrowing("execution(* com.hhb.service..*(..))")
    public void testAfterThrowing() {
        System.out.println("异常通知");
    }
    
    //最终通知（finally语句中执行的通知）
    @After("execution(* com.hhb.service..*(..))")
    public void testAfter() {
        System.out.println("最终通知");
    }
}
 

 [SSM]Spring面向切面编程AOP,spring,java,后端
 

  •  
    当发生异常时
     


[SSM]Spring面向切面编程AOP,spring,java,后端 
 

 
 
 

切面的先后执行顺序
 

  •  
    在业务中有多个切面的话，可以使用@Order注解来标识切面类，为@Order注解的value指定一个整数型的数字，数字越小，优先级越高。
     


package com.hhb.service;
​
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
​
@Component("logAspect")
@Aspect 
@Order(0)
public class LogAspect {//切面
​
    @Before("execution(* com.hhb.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }
​
    @AfterReturning("execution(* com.hhb.service..*(..))")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }
​
    @Around("execution(* com.hhb.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("前环绕");
        joinPoint.proceed();
        System.out.println("后环绕");
    }
​
    @AfterThrowing("execution(* com.hhb.service..*(..))")
    public void testAfterThrowing() {
        System.out.println("异常通知");
    }
​
    @After("execution(* com.hhb.service..*(..))")
    public void testAfter() {
        System.out.println("最终通知");
    }
}
 

package com.hhb.service;
​
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
​
@Aspect
@Component
@Order(1)//数字越小，优先级越高
public class SecurityAspect {
    @Before("execution(* com.hhb.service..*(..))")
    public void beforeAdvice() {
        System.out.println("前置通知，安全");
    }
}
 

[SSM]Spring面向切面编程AOP,spring,java,后端
 

 
 
 

通用切点
 

    

  •  
    之前的切点表达式缺点：
     
  
      

    •  
      切点表达式重复写了多次，没有得到复用。
       
      • 

    •  
      如果要修改切点表达式，需要修改多处，难维护。
       
      • 

    

    • 

  •  
    改进：将切点表达式单独的定义出来，在需要的位置引入即可。如下：
     
    • 



package com.hhb.service;
​
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
​
@Component("logAspect")
@Aspect //切面类是需要使用@Aspect注解进行标注的
@Order(0)
public class LogAspect {//切面
​
    //定义通用的切点表达式
    @Pointcut("execution(* com.hhb.service..*(..))")
    public void 通用切点() {
        //这个方法只是一个标记，方法名随意，方法体中也不需要写任何代码
    }
    
    /* @Before("execution(* com.hhb.service..*(..))")*/
    @Before("通用切点()")
    public void beforeAdvice() {
        System.out.println("前置通知");
    }
​
    @AfterReturning("通用切点()")
    public void afterReturningAdvice() {
        System.out.println("后置通知");
    }
​
    @Around("通用切点()")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("前环绕");
        joinPoint.proceed();
        System.out.println("后环绕");
    }
​
    @AfterThrowing("通用切点()")
    public void testAfterThrowing() {
        System.out.println("异常通知");
    }
​
    @After("通用切点()")
    public void testAfter() {
        System.out.println("最终通知");
    }
}
 

 
 

package com.hhb.service;
​
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
​
@Aspect
@Component
@Order(1)//数字越小，优先级越高
public class SecurityAspect {
    @Before("com.hhb.service.LogAspect.通用切点()")
    public void beforeAdvice() {
        System.out.println("前置通知，安全");
    }
}
 

连接点
 

@Before("通用切点()")
public void beforeAdvice(JoinPoint joinPoint) {
    System.out.println("前置通知");
    System.out.println("目标方法的方法名:"+joinPoint.getSignature().getName());
}
 

    

  •  
    JoinPoint在Spring容器调用这个方法的时候传过来，我们可以直接使用。
     
    • 

  •  
    joinPoint.getSignature(); 获取目标方法的签名。
     
    • 

  •  
    通过方法的签名可以获取到一个方法的具体信息。
     
    • 



全注解式开发AOP
 

  •  
    就是编写一个类，在这个类上面使用大量注解来代替spring的配置文件，如下Spring6Config：
     


package com.hhb.service;
​
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
​
@Configuration//代替spring.xml文件
@ComponentScan({"com.hhb.service"})//组件扫描
@EnableAspectJAutoProxy(proxyTargetClass = true)//启用aspectj的自动代理机制
public class Spring6Config {
}
 

  •  
    测试程序发生变化
     


@Test
public void testNoXML(){
    ApplicationContext applicationContext=new AnnotationConfigApplicationContext(Spring6Config.class);
    OrderService orderService = applicationContext.getBean("orderService", OrderService.class);
    orderService.generate();
}
 

15.4.3基于XML配置方式的AOP（了解）
 

第一步：编写目标类
 

package com.hhb.service;
​
public class UserService {//目标对象
​
    //目标方法
    public void logout() {
        System.out.println("系统正在退出...");
    }
}
 

第二步：编写切面类，并编写通知
 

package com.hhb.service;
​
import org.aspectj.lang.ProceedingJoinPoint;
​
public class TimerAspect {
    //通知
    public void aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        //前环绕
        long begin = System.currentTimeMillis();
        //目标
        joinPoint.proceed();
        //后环绕
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - begin) + "毫秒");
    }
}
 

第三步：编写的spring配置文件
 

<?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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
​
    <!--纳入spring ioc-->
    <bean id="userService" class="com.hhb.service.UserService"/>
    <bean id="timerAspect" class="com.hhb.service.TimerAspect"/>
​
    <!--aop的配置-->
    <aop:config>
        <!--切点表达式-->
        <aop:pointcut id="mypointcut" expression="execution(* com.hhb.service..*())"/>
        <!--切面=通知+切点-->
        <aop:aspect ref="timerAspect">
            <aop:around method="aroundAdvice" pointcut-ref="mypointcut"/>
        </aop:aspect>
    </aop:config>
</beans>
 

第四步：测试
 

[SSM]Spring面向切面编程AOP,spring,java,后端
 
 

15.5AOP的实际案例：事务处理
 

    

  •  
    项目中的事务控制是在所难免的，在一个业务流程当中，可能需要多条DML语句共同完成，为了保证数据的安全，这多条DML语句要么同时成功，要么同时失败，这就需要添加事务控制的代码。
     
    • 

  •  
    控制事务的代码就是和业务逻辑没有关系的”交叉业务“。可以使用AOP思想解决，可以把以上控制事务的代码作为环绕通知，切入到目标类的方法当中。
     
    • 



业务类
 

package com.hhb.service;
​
import org.springframework.stereotype.Service;
​
@Service
public class AccountService {
    public void transfer() {
        System.out.println("正在转账");
    }
​
    public void withdraw() {
        System.out.println("正在取款");
        String s=null;
        s.toString();
    }
}
 

package com.hhb.service;
​
import org.springframework.stereotype.Service;
​
@Service
public class OrderService {
    public void generate() {
        System.out.println("正在生成订单");
    }
​
    public void cancel() {
        System.out.println("订单已取消");
    }
}
 
 

事务切面类
 

package com.hhb.service;
​
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
​
@Component
@Aspect
public class TransactionAspect {
    //编程式事务解决方案
    @Around("execution(* com.hhb.service..*(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) {
        try {
            //前环绕
            System.out.println("开启事务");
            //执行目标
            joinPoint.proceed();
            //后环绕
            System.out.println("提交事务");
        } catch (Throwable e) {
            System.out.println("回滚事务");
        }
    }
}
 

spring配置文件
 

<?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:context="http://www.springframework.org/schema/context"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
​
    <!--组件扫描-->
    <context:component-scan base-package="com.hhb.service"/>
    <!--启动自动代理-->
    <aop:aspectj-autoproxy/>
</beans>
 

测试
 

[SSM]Spring面向切面编程AOP,spring,java,后端
 

 
 
 

15.6AOP的实际案例：安全日志
 

  •  
    项目开发结束，已经上线了并且运行正常。客户提出新的需求：凡是在系统中进行修改、删除、新增操作的，都要把这个人记录下拉，因为这几个操作是属于危险行为。
     


业务类
 

package com.hhb.biz;
​
import org.springframework.stereotype.Service;
​
@Service
public class UserService {
​
    public void saveUser(){
        System.out.println("新增用户信息");
    }
​
    public void deleteUser(){
        System.out.println("删除用户信息");
    }
​
    public void modifyUser(){
        System.out.println("修改用户信息");
    }
​
    public void getUser(){
        System.out.println("获取用户信息");
    }
}
 

package com.hhb.biz;
​
import org.springframework.stereotype.Service;
​
@Service
public class VipService {
​
    public void saveVip(){
        System.out.println("新增会员信息");
    }
​
    public void deleteVip(){
        System.out.println("删除会员信息");
    }
​
    public void modifyVip(){
        System.out.println("修改会员信息");
    }
​
    public void getVip(){
        System.out.println("获取会员信息");
    }
}
 

切面类
 

package com.hhb.biz;
​
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
​
import java.text.SimpleDateFormat;
import java.util.Date;
​
@Component
@Aspect
public class SecurityLogAspect {
    @Pointcut("execution(* com.hhb.biz..save*(..))")
    public void savePointcut() {
    }
​
    @Pointcut("execution(* com.hhb.biz..delete*(..))")
    public void deletePointcut() {
    }
​
    @Pointcut("execution(* com.hhb.biz..modify*(..))")
    public void modifyPointcut() {
    }
​
    @Before("savePointcut()||deletePointcut()||modifyPointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        //系统时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String nowTime = sdf.format(new Date());
        //输出日志信息
        System.out.println(nowTime + " XXX : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
    }
}
 

测试
 

[SSM]Spring面向切面编程AOP,spring,java,后端
 

 
                    
到了这里，关于[SSM]Spring面向切面编程AOP的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

                

                

                                                

                   

                       
                            
                            
                            
                            
                    
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

                

                                

                    
分享到：

                    领支付宝红包
                    赞助服务器费用
                

                            

            

		        
相关文章

			    
    
			        			        
  • 
			                                    
    
                            
                                认识 spring AOP (面向切面编程) - springboot
                            
                        
    
                                                
    
                            
    
                                认识 spring AOP (面向切面编程) - springboot
                            
    
                            
    
                                
    本篇介绍什么是spring AOP, AOP的优点，使用场景，spring AOP的组成，简单实现AOP 并 了解它的通知；如有错误，请在评论区指正，让我们一起交流，共同进步！ 本文开始 AOP: 面向切面编程，也就是面向某一类编程，对某一类事情进行统一处理； spring AOP: 是实现了AOP这种思想的一
    
                            
    
                            
    
                                2024年02月14日
                                
    
                                    浏览(50)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                Spring AOP（面向切面编程）和方法拦截
                            
    
                            
    
                                
    Spring AOP（面向切面编程）和方法拦截 Spring是一款广泛使用的Java开发框架，提供了丰富的功能和工具，用于简化企业级应用程序的开发。其中一个重要的特性是面向切面编程（AOP）和方法拦截。本文将介绍Spring AOP和方法拦截的概念、工作原理以及在实际开发中的应用。 在软
    
                            
    
                            
    
                                2024年02月05日
                                
    
                                    浏览(45)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                切面的魔力：解密Spring AOP 面向切面编程
                            
                        
    
                                                
    
                            
    
                                切面的魔力：解密Spring AOP 面向切面编程
                            
    
                            
    
                                
    目录 一、AOP简介 1.1 什么是AOP ？ 1.2 什么是面向切面编程 ？ 1.3 AOP 的特点 二、 AOP的基本概念解读 2.1 AOP的基本概念 2.2 AOP 概念趣事解读 三、代码情景演示 3.1 编写目标对象（超级英雄们正常的行动） 3.2 编写通知类 3.2.1 前置通知 3.2.2 后置通知 3.2.3 异常通知 3.2.4 环绕通知
    
                            
    
                            
    
                                2024年02月11日
                                
    
                                    浏览(57)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                spring6-AOP面向切面编程
                            
                        
    
                                                
    
                            
    
                                spring6-AOP面向切面编程
                            
    
                            
    
                                
    1、场景模拟 搭建子模块：spring6-aop 1.1、声明接口 声明计算器接口Calculator，包含加减乘除的抽象方法 1.2、创建实现类 1.3、创建带日志功能的实现类 1.4、提出问题 ①现有代码缺陷 针对带日志功能的实现类，我们发现有如下缺陷： 对核心业务功能有干扰，导致程序员在开发核
    
                            
    
                            
    
                                2024年02月08日
                                
    
                                    浏览(54)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
    
                                【Spring AOP】结合日志面向切面编程 两种写法
                            
    
                            
    
                                
            这里需要提前了解什么是Spring的AOP（Aspect Oriented Programming）。是在OOP（面向对象）思想的一种拓展思想。 简单来说就是将某个代码块嵌入到其它的代码块中 。笔者先前学Spring也有学什么IoC啊AOP啊，但实际上没有用过、就那听过学过没啥用的。。没会儿就忘记了。
    
                            
    
                            
    
                                2024年02月13日
                                
    
                                    浏览(44)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring AOP使用指南: 强大的面向切面编程技术
                            
                        
    
                                                
    
                            
    
                                Spring AOP使用指南: 强大的面向切面编程技术
                            
    
                            
    
                                
    🌷🍁 博主猫头虎（🐅🐾）带您 Go to New World✨🍁 🦄 博客首页 ——🐅🐾猫头虎的博客🎐 🐳 《面试题大全专栏》 🦕 文章图文并茂🦖生动形象🐅简单易学！欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍专栏》 🐾 学会IDEA常用操作，工作效率翻倍~💐 🌊 《100天精通Golang(基础
    
                            
    
                            
    
                                2024年02月09日
                                
    
                                    浏览(51)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring AOP (面向切面编程）原理与代理模式—实例演示
                            
                        
    
                                                
    
                            
    
                                Spring AOP (面向切面编程）原理与代理模式—实例演示
                            
    
                            
    
                                
    Spring 中文文档 (springdoc.cn) Spring | Home 官网         Java是一个面向对象（OOP）的语言，但它有一些弊端。虽然使用OOP可以通过组合或继承的方式来实现代码的重用。但当我们需要为多个不具有继承关系的对象（一般指的是两个不同的类，它们之间没有继承自同一个父类或接
    
                            
    
                            
    
                                2024年02月15日
                                
    
                                    浏览(56)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                【JavaEE】面向切面编程AOP是什么-Spring AOP框架的基本使用
                            
                        
    
                                                
    
                            
    
                                【JavaEE】面向切面编程AOP是什么-Spring AOP框架的基本使用
                            
    
                            
    
                                
    【JavaEE】 AOP（1） 1.1 AOP 与 Spring AOP AOP （ A spect O riented P rogramming），是一种思想，即 面向切面编程 Spring AOP 则是一个框架，Spring项目中需要引入依赖而使用 AOP和Spring AOP的关系就相当于IoC和DI Spring AOP让开发者能够半自动的开发AOP思想下实现的功能 1.2 没有AOP的世界是怎样的
    
                            
    
                            
    
                                2024年02月11日
                                
    
                                    浏览(47)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                Spring AOP：面向切面编程在实际项目中的应用
                            
                        
    
                                                
    
                            
    
                                Spring AOP：面向切面编程在实际项目中的应用
                            
    
                            
    
                                
    🌷🍁 博主猫头虎（🐅🐾）带您 Go to New World✨🍁 🦄 博客首页 ——🐅🐾猫头虎的博客🎐 🐳 《面试题大全专栏》 🦕 文章图文并茂🦖生动形象🐅简单易学！欢迎大家来踩踩~🌺 🌊 《IDEA开发秘籍专栏》 🐾 学会IDEA常用操作，工作效率翻倍~💐 🌊 《100天精通Golang(基础
    
                            
    
                            
    
                                2024年02月09日
                                
    
                                    浏览(45)
                                 
    
                            
    
                        
    
                    
    • 			        
  • 
			                                    
    
                            
                                【Spring】一文带你吃透AOP面向切面编程技术(上篇)
                            
                        
    
                                                
    
                            
    
                                【Spring】一文带你吃透AOP面向切面编程技术(上篇)
                            
    
                            
    
                                
    个人主页： 几分醉意的CSDN博客_传送门 什么是AOP？ AOP（Aspect Orient Programming）：面向切面编程 Aspect：表示切面，给业务方法增加的功能，叫做切面。切面一般都是非业务功能，而且切面功能一般都是可以复用的。例如日志功能，事务功能，权限检查，参数检查，统计信息等等
    
                            
    
                            
    
                                2024年01月16日
                                
    
                                    浏览(65)
                                 
    
                            
    
                        
    
                    
    • 			    

			

        

                
    

    



    
觉得文章有用就打赏一下文章作者



    
支付宝扫一扫打赏

    
博客赞助





    
微信扫一扫打赏

    
请作者喝杯咖啡吧~博客赞助











    
支付宝扫一扫领取红包，优惠每天领

	

	    
二维码1

	    
领取红包

	

	

	    
二维码2

	    
领红包