Spring aop

最新推荐文章于 2025-02-28 11:16:02 发布
原创 最新推荐文章于 2025-02-28 11:16:02 发布 · 244 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
框架

当前文章被收录于：

框架
8 篇文章 0 人学习
订阅专栏 查看详情
本文介绍了Spring AOP的三种实现方式：通过实现接口、自定义类和使用注解。每种方式都提供了示例代码及配置文件，帮助读者理解如何在实际项目中应用AOP。

Spring aop

概念：Springaop 就是将公共的业务（如日志，安全等）和领域业务结合，当执行领域业务时，将会把公共业务加进来，实现公共业务的重复利用，领域业务更加纯粹，程序员专注于业务，其本质还是动态代理

 

第一种：实现aop业务的相应接口

公共业务

package log;

 

 

import java.lang.reflect.Method;

 

import org.springframework.aop.AfterReturningAdvice;

/**

通过这种方式，需要实现对应的接口，然后重写相应的方法

一般方法分为before,after,around等

其实这些方法所不同之处就是加在领域业务方法的时候，执行顺序的不同

比如before就是在所加进去的方法之前所执行的

After就是在方法之后所执行

等等

*/

publicclass After implements AfterReturningAdvice{

 

   publicvoid afterReturning(Object returnValue, Method method,

         Object[] args, Object target) throws Throwable {

      System.out.println(target.getClass().getName()+"的"+method.getName()+"被成功执行，返回值是："+returnValue);

   }

}

package log;

 

import java.lang.reflect.Method;

 

import org.springframework.aop.MethodBeforeAdvice;

 

publicclass Before implements MethodBeforeAdvice{

 

   @Override

   publicvoid before(Method method, Object[] args, Object target)

         throws Throwable {

      System.out.println(target.getClass().getName()+"的"+method.getName()+"方法被执行");

   }

}

 

 

接口

package service;

 

publicinterface Service {

 

   public String add();

   publicvoid delete();

}

 

接口的实现类

package service;

 

publicclass ServiceImpl implements Service{

 

   @Override

   public String add() {

      System.out.println("增加用户");

      return"爱你一万年";

   }

 

   @Override

   publicvoid delete() {

      System.out.println("删除用户");

   }

 

}

 

测试类

package test;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

import service.Service;

 

public class Test {

 

         public static void main(String[] args) {

                   ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");

                   Service service = (Service) ac.getBean("service");

                   service.add();

                  

         }

}

Spring 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: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">

<!—将三个类纳入到ioc容器当中  -->

   <bean id="service" class="service.ServiceImpl"/>

   <bean id="After" class="log.After"/>

   <bean id="Before" class="log.Before"/>

<!—使用aop将公共业务和领域业务相关联-->

   <aop:config>

<!—切入目标-->

                                             返回值 包 类 方法 参数          

      <aop:pointcut expression="execution(* service.*.*(..))" id="pointcut"/>

<!—执行切入，代表将After中的方法切入进去-->

      <aop:advisor advice-ref="After" pointcut-ref="pointcut"/>

      <aop:advisor advice-ref="Before" pointcut-ref="pointcut"/>

   </aop:config>

</beans>

 

第二种：自定义类实现aop

公共业务

package com.ss.log;

 

 

/**

 *切面   自定义是实现

不用再实现接口

 */

publicclass Log {

 

   publicvoid before(){

      System.out.println("方法之前被调用");

   }

   publicvoid after(){

      System.out.println("方法之后调用");

   }

}

 

领域业务

package com.ss.service;

 

publicinterface Service {

 

   publicvoid add();

   publicvoid delete();

}

 

 

package com.ss.service;

 

publicclass ServiceImpl implements Service{

 

   @Override

   publicvoid add() {

      System.out.println("主类增加add方法");

   }

 

   @Override

   publicvoid delete() {

      System.out.println("主类增加delete方法");

   }

 

}

测试

package com.test;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

import com.ss.service.Service;

 

public class Test {

 

       public static void main(String[] args) {

              ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");

              Service service = (Service)ac.getBean("service");

              service.add();

       }

}

配置文件：

<?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="service" class="com.ss.service.ServiceImpl"/>

   <bean id="log" class="com.ss.log.Log"/>

   <aop:config>

<!—是将id=“log”的这个类切入-->

      <aop:aspect ref="log">

<!—切入目标-->

         <aop:pointcut expression="execution(* com.ss.service.ServiceImpl.*(..))" id="pointcut"/>

         <!—具体的某个方法切入-->

         <aop:before method="before" pointcut-ref="pointcut"/>

         <aop:after method="after" pointcut-ref="pointcut"/>

      </aop:aspect>

  

   </aop:config>      

</beans>

注意：当不在采用接口的时候，就必须得依赖于配置文件当中所提供的方法

结果：

 

采用注解开发

公共代码

package com.log;

 

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

 

@Aspect

publicclass log {

 

   @Before("execution(* com.service.*.*(..))")

   publicvoid add(){

      System.out.println("方法之前执行");

   }

   @After("execution(* com.service.*.*(..))")

   publicvoid delete(){

      System.out.println("方法之后执行");

   }

   @Around("execution(* com.service.*.*(..))")

   public Object aroud(ProceedingJoinPoint jp) throws Throwable{

      System.out.println("环绕前");

      System.out.println("签名："+jp.getSignature());

      //执行目标方法

       Object result = jp.proceed();

      System.out.println("环绕后");

      returnresult;

   }

}

 

领域业务

package com.service;

 

publicinterface Service {

 

   publicvoid add();

   publicvoid delete();

}

 

package com.service;

 

publicclass ServiceImpl implements Service{

 

   @Override

   publicvoid add() {

      System.out.println("增加方法");

   }

 

   @Override

   publicvoid delete() {

      // TODO Auto-generated method stub

      System.out.println("删除");

   }

 

}

 

测试

package com.test;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

import com.service.Service;

 

publicclass Test {

 

   publicstaticvoid main(String[] args) {

     

      ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");

      Service service = (Service) ac.getBean("service");

      service.add();

     

   }

}

 

配置文件代码

<?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="service" class="com.service.ServiceImpl"/>

   <bean id="log" class="com.log.log"/>

   <!-- 采用注解须配置 -->

   <aop:aspectj-autoproxy/>

</beans>

 

使用 Spring AOP 增强的类都要实现接口吗？
Show_line的博客
03-17 548
在基于接口的代理中，Spring会使用JDK动态代理来生成代理对象，而在基于类的代理中，Spring会使用CGLIB来生成代理对象。当目标对象至少实现了一个接口时，Spring AOP默认使用JDK的动态代理机制来创建代理对象。在Spring AOP中，如果目标类实现了接口，那么默认情况下会基于接口生成代理对象，这称为。这个处理器对象会在代理对象的方法被调用时负责执行增强逻辑，并调用目标对象的相应方法。众所周知，使用Spring AOP可以通过生成代理对象增强目标类的方法，那么如果你使用过。
Spring04-AOP介绍与使用
花哥的博客
08-22 216
Spring AOP介绍与使用 AOP：Aspect Oriented Programming 面向切面编程 OOP：Object Oriented Programming 面向对象编程 ​ 面向切面编程：基于OOP基础之上新的编程思想，OOP面向的主要对象是类，而AOP面向的主要对象是切面，在处理日志、安全管理、事务管理等方面有非常重要的作用。AOP是Spring中重要的核心点，虽然IOC容器没有依赖AOP，但是AOP提供了非常强大的功能，用来对IOC做补充。通俗点说的话就是在程序运行期间，将某段代
java之Spring（AOP）-Annotation实现添加切面
weixin_30399055的博客
11-20 399
我们已经知道之前的切面添加方式（动态代理），是定义了一个实现了InvocationHandler接口的Handlerservice类，然后 在这个类内部写好切面逻辑，包括切面放置的位置，很显然下面的这个切面逻辑是放置在原先方法之前的。 public class Handlerservice implements InvocationHandler { private UserDa...
详解Spring AOP
N_0050的博客
08-30 2001
Aspect Oriented Programming（面向切面编程），OOP是面向对象编程（开发的时候把一个个都抽象成对象来开发），两者的维度不同，处理的事情不同切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程。面向切面编程就是针对某一类特定问题统一进行编程比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。
Spring AOP详细介绍
JinXYan的博客
04-14 7万+
什么是AOP AOP（Aspect-OrientedProgramming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，...
Spring AOP 详解
2301_80035594的博客
10-19 6780
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP
2301_76161469的博客
11-04 5228
AOP（Aspect-Oriented Programming，面向切面编程）：是一种软件开发的编程范式，旨在将横切关注点（cross-cutting concerns）与核心业务逻辑分离，以提高代码的模块化性、可维护性和复用性
【Spring】AOP
最新发布
zhyhgx的博客
02-28 1846
AOP(Aspect Oriented Programming) 是一种编程范型，即面向切面编程。什么是面向切面编程？切面就是指某一类特定问题，所以AOP也可以理解为面向特定方法编程。面向编程旨在通过分离横切关注点来提高代码的模块化和可维护性，允许开发者将那些与业务逻辑无关，但又需要在多个地方使用的功能（如日志记录、事务管理、安全性等）从业务逻辑中分离出来。在前面我们的登录校验，用了拦截器，其实也是对AOP思想的一种实现。统一数据返回格式和统一异常处理也是AOP的一种实现。
【Spring】Spring AOP
bit me的博客
02-24 1930
SpringAOP 认识和实现原理
Spring Aop实例
热门推荐
鹏霄万里展雄飞
01-31 8万+
在上篇博文中，我向大家介绍了Aop重要概念和教程，这回给出代码示例。 一、XML方式 1. TestAspect：切面类 package com.spring.aop; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; public class TestAspect { pu
Spring 配置AOP Spring注解配置AOP Spring XML 配置AOP Spring Aspect AOP
HaHa_Sir的博客
06-03 1027
Spring 配置AOP Spring注解配置AOP Spring XML 配置AOP Spring Aspect AOP
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值