動態代理是一種設計模式。在Spring中，有倆種方式可以實現動態代理--JDK動態代理和CGLIB動態代理。

JDK動態代理

首先定義一個人的介面：

public interface Person {
    void study();
}

然後接上一個Student class

public class Student implements Person{
    @Override
    public void study() {
        System.out.println("學生要學習");
    }
}

然後我們建立一個動態代理類,需要實現InvocationHandler介面

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

public class AnimalInvocationHandler implements InvocationHandler {
    private Object target;
    
    public Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
    }
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
        Object result = null;
        System.out.println("----呼叫前處理");
        result = method.invoke(target,args);
        System.out.println("----呼叫後處理");
        return result;
    }
}
 

然後給一個main方法。

public class Test {
    public static void main(String[] args) {
        Student dog = new Student();
        AnimalInvocationHandler ani = new AnimalInvocationHandler();
        Person proxy = (Person)ani.bind(dog);
        proxy.study();
    }
}

執行結果如下。

想要在student物件前後加上額外的邏輯，可以不直接修改study方法。

這就是AOP實現的基本原理，只是Spring不需要開發人員自己維護。

但是這麼實現有個缺點，那就是必須實現介面。煩死了。所以我們要用CGLIB了。

CGLIB動態代理

首先把。這玩意是個開源包。
給個下載地址：
https://repo1.maven.org/maven2/cglib/cglib/3.3.0/cglib-3.3.0.jar
https://repo1.maven.org/maven2/org/ow2/asm/asm/7.0/asm-7.0.jar
下載之後新增到eclipse裡面。

首先是Teacher類

public class Teacher {
    public void play(){
        System.out.println("老師改作業");
    }
}

然後是這個,需要重寫MethodInterceptor

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class TeacherMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o,Method method,Object[] objects,MethodProxy methodProxy) throws Throwable{
        
        System.out.println("呼叫前。。。");
        Object obj = methodProxy.invokeSuper(o,objects);
        System.out.println("呼叫後。。。");
        return obj;
    }
}

main方法如下所示

import net.sf.cglib.proxy.Enhancer;

public class CglibDemo {
    public static void main(String[] args) {
        Enhancer en = new Enhancer();
        en.setSuperclass(Teacher.class);
        en.setCallback(new TeacherMethodInterceptor());
        Teacher t = (Teacher)en.create();
        t.play();
    }
}

執行結果如下：

這就實現了橫向程式設計。

AOP

面向切面程式設計是面向物件程式設計的一種補充。
以Java為例，提供了封裝，繼承，多型等概念，實現了面向物件程式設計。但是假如我們要實現以下場景。

給每個類設定許可權攔截器。

如果不用AOP思想，我們都能瘋掉。因為會有大量程式碼重用重寫。但是AOP的出現提供“橫向”的邏輯，將與多個物件有關的公共模組分裝成一個可重用模組，並且將這個模組整合成Aspect，即切面。

AOP的一些概念，整理成表如下：

Spring的AOP實現

由於Spring framework 的依賴過多，具體哪個jar包缺了啥報啥錯啥版本能把我弄吐血。
為了頭髮，我這裡採用SpringBoot來實現AOP

首先開啟InteliJ

new Project 完之後一直點就行。
啥都不用勾選。
然後我們會發現

啟動如果沒報錯，那就完事。

報錯了去搜搜怎麼搭建Spring-boot。都是一鍵生成的。

下面開始敲程式碼：注意！一個東西都不能落下！！

首先我們修改一下pom檔案

我的pom檔案如下所示：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo1</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

完整路徑如下所示：

首先是Fruit類

package com.example.demo1;

public interface Fruit {
    void eat();
}

然後是Apple類

package com.example.demo1;

import org.springframework.stereotype.Component;

@Component
public class Apple implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃蘋果");
    }
}

Orange類

package com.example.demo1;

import org.springframework.stereotype.Component;

@Component
public class Orange implements Fruit {
    @Override
    public void eat() {
        System.out.println("吃桔子");
    }
}

然後是FruitAnnotationHandler 類

@execution的含義是匹配該包下任意類的任意方法名的任意入參的任意方法返回值。

@Aspect用來宣告這是切面，註解“@Before”用來表明前置通知，“@After用來表示後置通知”

package com.example.demo1;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class FruitAnnotationHandler {
    /**
     * 定義切點
     */
    @Pointcut("execution(* com.example.demo1.*.*(..))")
    public void eatFruit(){

    }
    /**
     * 前置通知
     */
    @Before("eatFruit()")
    public void startEatFruit(){
        System.out.println("要開始吃了");
    }
    /**
     * 後置通知
     */
    @After("eatFruit()")
    public void endEatFruit(){
        System.out.println("吃完了");
    }
}

最後是Application類

package com.example.demo1;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;

@SpringBootApplication
public class Demo1Application {
    public static void main(String[] args) {
        ApplicationContext app = SpringApplication.run(Demo1Application.class, args);
        Fruit apple = app.getBean(Apple.class);
        Fruit orange = app.getBean(Orange.class);
        apple.eat();
        orange.eat();
    }
}

然後執行~

執行成功完美！

其實SpringBoot預設的AOP實現就是使用的CGLib代理。

我們並不用定義哪個Fruit介面。

但是你如果脾氣倔，非要用jdk代理的話。

把這個加上就OK了。

如果你沒定義介面的話，下場就是這樣。

Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.example.demo1.Apple' available
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:346)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:337)
at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1123)
at com.example.demo1.Demo1Application.main(Demo1Application.java:11)

至此我們就完成了AOP的入