Spring--->aop面向切面編程

時間 2020-12-28

標籤 java spring 編程 app jvm ide 函數 post 測試 this 欄目 Spring 简体版

原文原文鏈接

AOP編程java

1. AOP概念

 AOP (Aspect Oriented Programing) 面向切面編程 = Spring動態代理開發
 以切面爲基本單位的程序開發，經過切面間的彼此協同，相互調用，完成程序的構建
 切面 = 切入點 + 額外功能

 OOP (Object Oriented Programing) 面向對象編程 Java
 以對象爲基本單位的程序開發，經過對象間的彼此協同，相互調用，完成程序的構建

 POP (Procedure Oriented Programing) 面向過程(方法、函數)編程 C 
 以過程爲基本單位的程序開發，經過過程間的彼此協同，相互調用，完成程序的構建

aop的本質就是spring的動態代理開發spring

想要實現動態代理須要知足三個條件：編程

目標對象
接口代理對象和目標對象的相同接口
加強功能

AOP的底層實現原理

1. 核心問題

AOP如何建立動態代理類？(動態字節碼技術)app
Spring工廠如何加工建立代理對象？經過原始對象的id值，得到的是代理對象。jvm

2. 動態代理類的建立

2.1 JDK的動態代理

TestJDKProxy.java
ide

package proxy.jdk;


import proxy.service.UserService;
import proxy.service.impl.UserServiceImpl;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


public class TestJDKProxy {
    public static void main(String[] args) {
        //1.建立原始對象
        //注意：因爲後面匿名子類的方法中用到了userService，因此應該用final修飾
        //     而JDK1.8之後默認加了final，不須要手動加
        UserService userService = new UserServiceImpl();

        //2.JDK建立代理對象
        InvocationHandler handler = new InvocationHandler() {
               /**
                 *proxy:代理對象
                 *method：額外功能要增長的原始方法
                 *args：原始方法的參數
                 *
                **/
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----------- JDKProxy log -----------");\
                //目標方法運行：
                Object ret = method.invoke(userService, args);
                return ret;
            }
        };

                /**
                 *ClassLoader:類加載對象
                 *inerface：實現的接口（相同的接口）
                 *handler：額外增長的功能
                 *
                **/

UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(),handler); 
userServiceProxy.login("海綿寶寶", "1111"); userServiceProxy.register(new User());
 } 
}

在InvocationHandler中invoke的方法中增長額外功能，程序在執行Proxy.newProxyInstance的過程當中就是動態字節碼加載的過程(沒有代理類，這個過程就是經過動態字節碼技術在jvm內存中建立代理類，再經過ClassLoad類加載，繼而建立代理類對象)，借用的類加載器，借誰的均可以

2.2 CGlib動態代理函數

原理：post

1.目標類測試

StudentService
this

package proxy.cglib;

import proxy.service.User;


public class StudentServiceImpl {
    public boolean login(String name,String password){
        System.out.println("StudentService.login");
        return true;
    }

    public void register(User user) {
        System.out.println("StudentService.register");
    }
}

2.測試類 Enhancer java中已經提供了

package com.yuziyan.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class TestCGlibProxy {
    public static void main(String[] args) {
        //1.建立原始對象
        UserServiceImpl userService = new UserServiceImpl();

        //2.經過CGlib建立代理對象
        //  2.1 建立Enhancer
        Enhancer enhancer = new Enhancer();
        //  2.2 設置借用類加載器
        enhancer.setClassLoader(TestCGlibProxy.class.getClassLoader());
        //  2.3 設置父類（目標類）
        enhancer.setSuperclass(userService.getClass());
        //  2.4 設置回調，額外功能寫在裏面
        enhancer.setCallback(new MethodInterceptor() {
            //至關於 InvocationHandler --> invoke()
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //額外功能：
                System.out.println("========= CGlibProxy log ========");
                //目標方法執行：
                Object ret = method.invoke(userService, objects);
                return ret;
            }
        });
        //  2.5 經過Enhancer對象建立代理
        UserServiceImpl service = (UserServiceImpl) enhancer.create();

        //測試：
        service.register();
        service.login();

    }
}

jdk和cglib的本質不一樣

1. JDK動態代理 Proxy.newProxyInstance() 經過目標類實現的接口建立代理類

2. Cglib動態代理 Enhancer 經過繼承目標類建立代理類

3. Spring工廠如何返回代理對象

思路分析：

編碼模擬：

public class ProxyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        InvocationHandler invocation = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----------- 模擬Spring返回代理對象的方式 log -----------");

                Object ret = method.invoke(bean, args);

                return ret;
            }
        };

        return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), invocation);
    }
}

配置文件

<!-- 1.配置原始對象 -->
<bean id="userService" class="com.yuziyan.factory.UserServiceImpl"></bean>
<!-- 2.配置本身模擬的ProxyBeanPostProcessor -->
<bean id="proxyBeanPostProcessor" class="com.yuziyan.factory.ProxyBeanPostProcessor"/>

爲何從spring容器中拿原始id的值，獲取的是代理對象

由於是經過BeanPostProcessor方式拿到的

基於註解的AOP編程

1. 開發步驟：

原始對象
額外功能
切入點
組裝切面

/**
 * 聲明切面類     @Aspect
 * 定義額外功能   @Around
 * 定義切入點     @Around("execution(* login(..))")
 *
 */
@Aspect
public class MyAspect {

    @Around("execution(* login(..))")//組裝了切入點和額外功能
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //額外功能：
        System.out.println("--------- 基於註解的AOP編程 log --------");
        //原始方法執行：
        Object ret = joinPoint.proceed();

        return ret;
    }
}

配置文件

<!-- 原始對象 -->
<bean id="userService" class="com.yuziyan.aspect.UserServiceImpl"></bean>

<!-- 切面 -->
<bean id="myAspect" class="com.yuziyan.aspect.MyAspect"/>

<!-- 開啓基於註解的AOP編程 -->
<aop:aspectj-autoproxy/>

2. 細節分析：

切入點複用：

@Aspect
public class MyAspect {

    /**
     * 切入點複用：定義一個函數，加上@Pointcut註解，經過該註解的value定義切入點表達式，之後能夠複用。
     */
    @Pointcut("execution(* login(..))")
    public void myPointcut(){}

    @Around("myPointcut()")//組裝了切入點和額外功能
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //額外功能：
        System.out.println("--------- 基於註解的AOP編程 log --------");
        //原始方法執行：
        Object ret = joinPoint.proceed();

        return ret;
    }


    @Around("myPointcut()")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        //額外功能：
        System.out.println("--------- 基於註解的AOP編程 tx --------");
        //原始方法執行：
        Object ret = joinPoint.proceed();

        return ret;
    }

}

動態代理的建立方式：

AOP底層實現  2種代理建立方式
  1.  JDK   經過實現接口，建立代理對象
  2.  Cglib 經過繼承目標類，建立代理對象
  
  默認狀況 AOP編程 底層應用JDK動態代理建立方式 
  若是要切換Cglib
       1. 基於註解AOP開發
          <aop:aspectj-autoproxy proxy-target-class="true" />
       2. 傳統的AOP開發
          <aop:config proxy-target-class="true">
          </aop>

AOP開發中的一個坑

坑：在同一個業務類中，業務方法間相互調用時，只有最外層的方法,加入了額外功能(內部的方法，經過普通的方式調用，運行的都是原始方法)。若是想讓內層的方法也調用代理對象的方法，就要實現AppicationContextAware得到工廠，進而得到代理對象。

一個調用的是原始對象，一個是代理對象，spring的aop只會對代理對象有效

public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
              this.ctx = applicationContext;
    }

    @Log
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register 業務運算 + DAO ");
        //throw new RuntimeException("測試異常");

        //調用的是原始對象的login方法 ---> 核心功能
        /*
            設計目的：代理對象的login方法 --->  額外功能+核心功能
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
            UserService userService = (UserService) ctx.getBean("userService");
            userService.login();

            Spring工廠重量級資源 一個應用中 應該只建立一個工廠
         */

        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("suns", "123456");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}