Spring從入門到入土——AOP就這麼簡單

AOP

什麼是AOP

面向切面編程。通過預編譯的方式和運行期動態代理實現程序功能的統一維護的一種技術。AOP是OOP的延續，是軟件開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生泛型，利用AOP可以對業務邏輯的各個部分進行隔離，從而使業務邏輯各個部分的耦合度降低，提高程序的可重用性，同時提高了開發效率。

AOP在Spring中的作用

提供聲明式事務；允許用戶自定義切面

核心名詞

橫切關注點：橫跨應用程序多個模塊的方法或功能。即是，與我們業務邏輯無關的，但是我們需要關注的地方，就是橫切關注點，如：日誌、安全、緩存、事務
切面：橫切關注點被模塊化的特性對象，即：它是一個類
通知：切面必須要完成的工作。即它是類中的一個方法
目標：被通知對象
代理：向目標對象應用通知以後創建的對象。
切入點：切面通知執行的“地點的定義
連接點：與切入點匹配的執行點

Spring中支持的五種類型的Advice

通知類型	連接點	實現接口
前置通知	方法前	org.springframework.aop.MethodBeforeAdvice
後置通知	方法後	org.springframework.aop.AfterReturningAdvice
環繞通知	方法前後	org.springframework.aop.MethodInterceptor
異常拋出通知	方法拋出異常	org.springframework.aop.ThrowsAdvice
引介通知	類中增加新方法屬性	org.springframework.aop.IntroductionOnterceptor

即Aop在不改變原有代碼的情況下，去增加新的功能

使用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.zhonghu.service.UserServiceImpl"/>
   <bean id="log" class="com.zhonghu.log.Log"/>
   <bean id="afterLog" class="com.zhonghu.log.AfterLog"/>

   <!--aop的配置-->
   <aop:config>
       <!--切入點 expression:表達式匹配要執行的方法-->
       <aop:pointcut id="pointcut" expression="execution(* com.zhonghu.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

切入類

public class DiyPointcut {

   public void before(){
       System.out.println("---------方法執行前---------");
  }
   public void after(){
       System.out.println("---------方法執行後---------");
  }
   
}

去spring中配置

<!--第二種方式自定義實現-->
<!--註冊bean-->
<bean id="diy" class="com.zhonghu.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
   <!--第二種方式：使用AOP的標籤實現-->
   <aop:aspect ref="diy">
       <aop:pointcut id="diyPonitcut" expression="execution(* com.zhonghu.service.UserServiceImpl.*(..))"/>
       <aop:before pointcut-ref="diyPonitcut" method="before"/>
       <aop:after pointcut-ref="diyPonitcut" method="after"/>
   </aop:aspect>
</aop:config>

測試

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

第三種方式——使用註解

註解實現的增強類

package com.zhonghu.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.zhonghu.service.UserServiceImpl.*(..))")
   public void before(){
       System.out.println("---------方法執行前---------");
  }

   @After("execution(* com.zhonghu.service.UserServiceImpl.*(..))")
   public void after(){
       System.out.println("---------方法執行後---------");
  }

   @Around("execution(* com.zhonghu.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);
  }
}

在spring配置文件中，註冊bean，並增加支持註解的配置

<!--第三種方式:註解實現-->
<bean id="annotationPointcut" class="com.zhonghu.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy：說明

通過aop創建的命名空間的<aop:aspectj-autoproxy />聲明自動爲spring容器中那些配置@aspectJ切面的bean創建代理，織入切面。當然，spring 在內部依舊採用AnnotationAwareAspectJAutoProxyCreator進行自動代理的創建工作，但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了

<aop:aspectj-autoproxy />有一個proxy-target-class屬性，默認爲false，表示使用jdk動態代理織入增強，當配爲<aop:aspectj-autoproxy poxy-target-class=“true”/>時，表示使用CGLib動態代理技術織入增強。不過即使proxy-target-class設置爲false，如果目標類沒有聲明接口，則spring將自動使用CGLib動態代理

進行自動代理的創建工作，但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了

<aop:aspectj-autoproxy />有一個proxy-target-class屬性，默認爲false，表示使用jdk動態代理織入增強，當配爲<aop:aspectj-autoproxy poxy-target-class=“true”/>時，表示使用CGLib動態代理技術織入增強。不過即使proxy-target-class設置爲false，如果目標類沒有聲明接口，則spring將自動使用CGLib動態代理

Spring從入門到入土——AOP就這麼簡單

這裏寫目錄標題

AOP

什麼是AOP

AOP在Spring中的作用

核心名詞

Spring中支持的五種類型的Advice

使用Spring實現Aop

第一種方式——通過Spring API實現

業務接口和實現類

增強類

前置增強

後置增強

去Spring的文件中註冊,並實現aop切入實現

測試

第二種方式：自定義類來實現Aop

切入類

去spring中配置

測試

第三種方式——使用註解

註解實現的增強類

在spring配置文件中，註冊bean，並增加支持註解的配置

認知提升的方法

螞蟻面試：Springcloud核心組件的底層原理，你知道多少？

Servlet入門到入土——生命週期

spring boot入門到入土——錯誤處理機制

Java8 中的Stream API詳解

Spring Boot從入門到入土——快速開始

LeetCode146.LRU緩存機制

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結