10、AOP

10.1、什么是AOP

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

dnKv1H.png

10.2、AOP在Spring中的使用

提供声明事务;允许用户自定义切面

  • 横切关注点:跨越应用程序多个模块的方法或功能,即是,于我们业务逻辑无关的,但是我们许哟啊关注的部分,就是横切关注点。如日志、安全、缓存、事务等等
  • 切面(ASPECT):横切关注点被模块化的特殊对象。即,他是一个类。
  • 通知(Advice):切面必须要完成的工作。即,他是类中的一个方法。
  • 目标(Target):被通知对象。
  • 代理(Proxy):向目标对象应用通知之后创建的对象。
  • 切入点(PointCut):切面通知执行的“地点”的定义。
  • 连接点(JointPoint):与切入点匹配的执行点。

dnKLtO.png

SpringAOP中,通过Advice定义横切逻辑,Spring中支持5中类型的Advice:

dnKWhF.png

即AOP在不改变原有代码的情况下,去增加新的功能。

10.3、使用Spring实现AOP

使用AOP织入,需要导入一个依赖包

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

方法一:通过Spring API实现

首先编写我们的业务接口和实现类

public interface UserService {

   public void add();

   public void delete();

   public void update();

   public void search();

}
public class UserServiceImpl implements UserService{

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

   @Override
   public void delete() {
       System.out.println("删除用户");
  }

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

   @Override
   public void search() {
       System.out.println("查询用户");
  }
}

然后去写增强类,这里编写两个,一个前置增强,一个后置增强

public class Log implements MethodBeforeAdvice {

   //method : 要执行的目标对象的方法
   //objects : 被调用的方法的参数
   //Object : 目标对象
   @Override
   public void before(Method method, Object[] objects, Object o) throws Throwable {
       System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
  }
}
public class AfterLog implements AfterReturningAdvice {
   //returnValue 返回值
   //method被调用的方法
   //args 被调用的方法的对象的参数
   //target 被调用的目标对象
   @Override
   public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
       System.out.println("执行了" + target.getClass().getName()
       +"的"+method.getName()+"方法,"
       +"返回值:"+returnValue);
  }
}

最后去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">

   <!--注册bean-->
   <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
   <bean id="log" class="com.kuang.log.Log"/>
   <bean id="afterLog" class="com.kuang.log.AfterLog"/>

   <!--aop的配置-->
   <aop:config>
       <!--切入点 expression:表达式匹配要执行的方法-->
       <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
       <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
       <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
       <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
   </aop:config>

</beans>

测试类

public class MyTest {
   @Test
   public void test(){
       ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
       UserService userService = (UserService) context.getBean("userService");
       userService.search();
  }
}

AOP的重要性:很重要,一定要理解其中的思路,主要是思想理解这一方面

Spring的AOP就是将公共的业务(日志、安全等等)和领域业务结合起来,当执行领域业务时,将会把公共业务加进来,是西安公共业务的重复利用,领域业务更存粹,程序员专注领域业务,其本质还是动态代理。

方法二:自定义类实现AOP

目标业务类不变,依旧是UserServiceImpl

  1. 编写我们自己的一个切入类
    public class DiyPointcut {
    
      public void before(){
          System.out.println("---------方法执行前---------");
     }
      public void after(){
          System.out.println("---------方法执行后---------");
     }
    
    }
    
  2. 去Spring中配置
    <!--第二种方式自定义实现-->
    <!--注册bean-->
    <bean id="diy" class="com.kuang.config.DiyPointcut"/>
    <bean id="userService" class="com.kuang.service.UserServiceImpl" />
    <!--aop的配置-->
    <aop:config>
      <!--第二种方式:使用AOP的标签实现-->
      <aop:aspect ref="diy">
          <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
          <aop:before pointcut-ref="diyPonitcut" method="before"/>
          <aop:after pointcut-ref="diyPonitcut" method="after"/>
      </aop:aspect>
    </aop:config>
    
  3. 测试
    public class MyTest {
      @Test
      public void test(){
          ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
          UserService userService = (UserService) context.getBean("userService");
          userService.add();
     }
    }
    

方法三:使用注解实现

  1. 编写一个注解实现的增强类
    package com.kuang.config;
    
    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
    public class AnnotationPointcut {
      @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
      public void before(){
          System.out.println("---------方法执行前---------");
     }
    
      @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
      public void after(){
          System.out.println("---------方法执行后---------");
     }
    
      @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
      public void around(ProceedingJoinPoint jp) throws Throwable {
          System.out.println("环绕前");
          System.out.println("签名:"+jp.getSignature());
          //执行目标方法proceed
          Object proceed = jp.proceed();
          System.out.println("环绕后");
          System.out.println(proceed);
     }
    }
    
  2. 在Spring配置文件中,注册bean,并增加支持注解的配置
    <!--第三种方式:注解实现-->
    <bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
    <aop:aspectj-autoproxy/>
    

    aop:aspectj-autoproxy:说明

    通过aop命名空间的声明自动为spring容器中那些配置@aspectj切面的bean创建代理,织入切面。当然,spring在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的创建工作,但具体实现的细节已经被隐藏起来了

    有一个proxy-target-class属性,默认为false,表示使用jdk动态代理织入增强,当配为时,表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false,如果目标类没有生命接口,则spring将自动使用CGLib动态代理。

暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇