Spring框架IOC和AOP介紹

阿新 • • 發佈：2020-12-14

說明：本文部分內容參考其他優秀部落格後結合自己實戰例子改編如下

Spring框架是個輕量級的Java EE框架。所謂輕量級，是指不依賴於容器就能執行的。Struts、Hibernate也是輕量級的。

輕量級框架是相對於重量級框架而言的，重量級框架必須依賴特定的容器，例如EJB框架就必須執行在Glassfish、JBoss等支援EJB的容器中，而不能執行在Tomcat中。——《Java Web整合開發王者歸來》

Spring以IoC、AOP為主要思想，其中IoC，Inversion of Control 指控制反轉或反向控制。在Spring框架中我們通過配置建立類物件，由Spring在執行階段例項化、組裝物件。

AOP，Aspect Oriented Programming，面向切面程式設計，其思想是在執行某些程式碼前執行另外的程式碼，使程式更靈活、擴充套件性更好，可以隨便地新增、刪除某些功能。Servlet中的Filter便是一種AOP思想的實現。

Spring的核心是控制反轉（IoC）和麵向切面（AOP）。簡單來說，Spring是一個分層的JavaSE/EE full-stack(一站式) 輕量級開源框架。

即Spring在JavaEE的三層架構[表現層（Web層）、業務邏輯層（Service層）、資料訪問層（DAO層）]中，每一層均提供了不同的解決技術。如下：

•表現層（Web層）：Spring MVC

•業務邏輯層（Service層）：Spring的IoC

•資料訪問層（DAO層）：Spring的jdbcTemplate

Spring的優點

方便解耦，簡化開發（高內聚低耦合）

Spring就是一個大工廠（容器），可以將所有物件建立和依賴關係維護，交給Spring管理

spring工廠是用於生成bean
AOP程式設計的支援

Spring提供面向切面程式設計，可以方便的實現對程式進行許可權攔截、執行監控等功能
宣告式事務的支援

只需要通過配置就可以完成對事務的管理，而無需手動程式設計
方便程式的測試

Spring對Junit4支援，可以通過註解方便的測試Spring程式
方便整合各種優秀框架

Spring不排斥各種優秀的開源框架，其內部提供了對各種優秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支援
降低JavaEE API的使用難度

Spring 對JavaEE開發中非常難用的一些API（JDBC、JavaMail、遠端呼叫等），都提供了封裝，使這些API應用難度大大降低

一、Spring中的IoC操作

　將物件的建立交由Spring框架進行管理。

　IoC操作分為：IoC配置檔案方式和IoC的註解方式。

1. IoC入門案例

（1）匯入Spring框架中的相關jar包，這裡只匯入Spring的Core模組（Core模組是框架的核心類庫）下的jar包（使用IoC的基本操作，並不需要匯入spring-framework-4.2.0的所有jar包，

只匯入spring-beans、spring-core、spring-context、spring-expression、spring-aop這5個jar包），以及支援日誌輸出的 commons-logging 和 log4j 的jar包；

（2）建立一個普通的Java類，並在該類中建立方法，如下：

package com.wm103.ioc;

/**
 * Created by DreamBoy on 2018/3/17.
 */
public class User {
    public void add() {
        System.out.println("User Add Method.");
    }

    @Override
    public String toString() {
        return "This is a user object.";
    }
}

（3）建立Spring的配置檔案，進行Bean的配置

Spring的核心配置檔名稱和位置不是固定的。但官方件建議將該核心配置檔案放在src目錄下，且命名為 applicationContext.xml。

這裡為了方便，將核心配置檔案放在src目錄下，並命名為 applicationContext.xml，內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!-- 配置service 
        <bean> 配置需要建立的物件
            id ：用於之後從spring容器獲得例項時使用的
            class ：需要建立例項的全限定類名
    -->
    <bean id="user" class="com.wm103.ioc.User"></bean>    
</beans>

（4）編寫測試類進行測試，通過配置檔案建立類物件　　

package com.wm103.ioc;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by DreamBoy on 2018/3/17.
 */
public class TestIoc {
    @Test
    public void runUser() {
        // 1. 載入Spring配置檔案，根據建立物件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 得到配置建立的物件
        User user = (User) context.getBean("user");
        System.out.println(user);
        user.add();
    }
}

2. Spring的bean管理（配置檔案）

Bean例項化的方式

　在Spring中通過配置檔案建立物件。

　Bean例項化三種方式實現：

（1）使用類的無引數構造建立，如：

<!-- 等同於 user = new com.wm103.ioc.User(); -->
<bean id="user" class="com.wm103.ioc.User"></bean>

（2）使用靜態工廠建立

如果一個Bean不能通過new直接例項化，而是通過工廠類的某個靜態方法建立的，需要把<bean>的class屬性配置為工廠類。如：

<!-- 等同於 user = com.wm103.ioc.HelloWorldFactory.createInstance(); --> 
<bean id="user" class="com.wm103.ioc.HelloWorldFactory" factory-method="createInstance"></bean>



//就是直接可以通過靜態方法來例項化一個物件

public class

HelloWorldFactory

{ 　　public static HelloWorld createInstance(){ 　　　　return new HelloWorld(); 　　} } HelloWorldFactory.createInstance()

（3）使用例項工廠建立

　如果一個Bean不能通過new直接例項化，而是通過工廠類的某個例項方法建立的，需要先配置工廠的<bean>標籤，然後在需要建立的物件的bean標籤的factory-bean屬性配置為工廠類物件，factory-method屬性配置為產生例項的方法。如：

<!-- 等同於 userFactory = new com.wm103.ioc.HelloWorldFactory(); -->
<bean id="userFactory" class="com.wm103.ioc.HelloWorldFactory"></bean>
<!-- 等同於 user = userFactory.createHelloWorld(); -->
<bean id="user" factory-bean="userFactory" factory-method="createHelloWorld"></bean>

就是先建立類物件，如何通過物件來呼叫建立例項物件的方法

public class HelloWorldFactory {
　　public HelloWorld createHelloWorld(){
　　　　return new HelloWorld();
　　}
}

HelloWorldFactory helloFactory = new HelloWorldFactory();
helloFactory.createHelloWorld();

Bean標籤的常用屬性

（1）id屬性：用於指定配置物件的名稱，不能包含特殊符號。
（2）class屬性：建立物件所在類的全路徑。
（3）name屬性：功能同id屬性一致。但是在name屬性值中可以包含特殊符號。
（4）scope屬性

singleton：預設值，單例

單例模式下，在程式下只有一個例項。非單態模式下，每次請求該Bean，都會生成一個新的物件。
prototype：多例
request：建立物件後將物件存放到request域
session：建立物件後將物件存放到session域
globalSession：建立物件後將物件存放到globalSession域

servlet三大作用域：

//1.request（每次請求都是一個域）
Integer numInRequest=(Integer)req.getAttribute("NUM_IN_REQUEST") ;
if (numInRequest == null) {
    req.setAttribute("NUM_IN_REQUEST",1);
}
else {
    req.setAttribute("NUM_IN_REQUEST",numInRequest+1);
}
//2.Session（一個會話期間）
Integer numInSession=(Integer)req.getSession().getAttribute("NUM_IN_SESSION") ;
if (numInSession == null) {
    req.getSession().setAttribute("NUM_IN_SESSION",1);
}
else {
    req.getSession().setAttribute("NUM_IN_SESSION",numInSession+1);
}
//3.application（tomcat啟動到關閉）
Integer numInApplication=(Integer) req.getServletContext().getAttribute("NUM_IN_APPLICATION");
if (numInApplication == null) {
    req.getServletContext().setAttribute("NUM_IN_APPLICATION",1);
}

屬性依賴注入3. DI的依賴注入

依賴注入方式：手動裝配和自動裝配
手動裝配：一般進行配置資訊都採用手動

基於xml裝配：構造方法、setter方法
自動裝配（基於註解裝配）：

　屬性注入指建立物件時，向類物件的屬性設定屬性值。

　在Spring框架中支援set方法注入和有參建構函式注入，即建立物件後通過set方法設定屬性或採用有參建構函式建立物件並初始化屬性。

3.1 使用有參建構函式注入屬性

　案例：Student.java 提供有單參的構造方法

package com.wm103.ioc;
public class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

spring bean的配置：

<bean id="student" class="com.wm103.ioc.Student">
    <constructor-arg name="name" value="DreamBoy"></constructor-arg>
</bean>

提供有多參的構造方法

public class User {

    private Integer uid;
    private String username;
    private Integer age;

    public User(Integer uid, String username) {
        super();
        this.uid = uid;
        this.username = username;
    }

    public User(String username, Integer age) {
        super();
        this.username = username;
        this.age = age;
    }

spring bean的配置：

<!-- 構造方法注入 
        * <constructor-arg> 用於配置構造方法一個引數argument
            name ：引數的名稱
            value：設定普通資料
            ref：引用資料，一般是另一個bean id值

            index ：引數的索引號，從0開始 。如果只有索引，匹配到了多個構造方法時，預設使用第一個。
            type ：確定引數型別
        例如：使用名稱name
            <constructor-arg name="username" value="jack"></constructor-arg>
            <constructor-arg name="age" value="18"></constructor-arg>
        例如2：【型別type 和  索引 index】
            <constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
            <constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    -->
    <bean id="userId" class="com.itheima.f_xml.a_constructor.User" >
        <constructor-arg index="0" type="java.lang.String" value="1"></constructor-arg>
        <constructor-arg index="1" type="java.lang.Integer" value="2"></constructor-arg>
    </bean>

建立Student物件進行測試：

@Test
public void runStudent() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    Student student = (Student) context.getBean("student");
    System.out.println(student);
}

3.2 使用set方法注入屬性

案例：Teacher.java 提供屬性的set方法

package com.wm103.ioc;
public class Teacher {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

bean的配置：

<bean id="teacher" class="com.wm103.ioc.Teacher">
    <property name="name" value="Teacher Wu"></property>
</bean>

建立Teacher物件進行測試：

public void runTeacher() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    Teacher teacher = (Teacher) context.getBean("teacher");
    System.out.println(teacher);
}

3.3 注入物件型別屬性

以三層架構中的service層和dao層為例，為了讓service層使用dao層的類建立的物件，需要將dao物件注入到service層類中。具體實現過程中如下：

（1）建立service類、dao層介面、dao類，如下：UserService.java

package com.wm103.exp;
public class UserService {
    private UserDao userDao; // 宣告為介面型別，降低service層與dao層的耦合度，不依賴於dao層的具體實現

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add() {
        System.out.println("UserService Add...");
        this.userDao.add();
    }
}

UserDao.java

package com.wm103.exp;

/**
 * 暴露給service層的介面
 * Created by DreamBoy on 2018/3/17.
 */
public interface UserDao {
    void add();
}

UserDaoImpl.java

package com.wm103.exp;

/**
 * 介面UserDao的具體實現
 * Created by DreamBoy on 2018/3/17.
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void add() {
        System.out.println("UserDaoImpl Add...");
    }
}

（2）在配置檔案中注入關係，如下：

<!-- 配置service和dao物件 -->
<!-- 因為service依賴於dao，所以先進行dao物件的bean配置 -->
<bean id="userDaoImpl" class="com.wm103.exp.UserDaoImpl"></bean>
<bean id="userService" class="com.wm103.exp.UserService">
    <!--
        注入dao物件
        name屬性值為：service中的某一屬性名稱
        ref屬性值為：被引用的物件對應的bean標籤的id屬性值
     -->
    <property name="userDao" ref="userDaoImpl"></property>
</bean>

（3）建立測試方法進行測試，如下：

@Test
public void runUserService() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

3.4 p名稱空間注入屬性

之前提到了一種set方法的屬性注入方式，這裡將介紹另一種屬性注入的方式，名為 p名稱空間注入。對比set方法的屬性注入方式，核心配置檔案配置修改如下：

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="teacher" class="com.wm103.ioc.Teacher" p:name="Teacher Wu"></bean>
</beans>

3.5 注入複雜型別屬性

物件注入複雜型別屬性，如陣列、List、Map、Properties。

案例：PropertyDemo.java

package com.wm103.ioc;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class PropertyDemo {
    private String[] arrs;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;

    public String[] getArrs() {
        return arrs;
    }

    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
}

bean配置檔案，內容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="prop" class="com.wm103.ioc.PropertyDemo">
        <!-- 注入陣列 -->
        <property name="arrs">
            <list>
                <value>Value 1 of Array</value>
                <value>Value 2 of Array</value>
                <value>Value 3 of Array</value>
            </list>
        </property>
        <!-- 注入List集合 -->
        <property name="list">
            <list>
                <value>Value 1 of List</value>
                <value>Value 2 of List</value>
                <value>Value 3 of List</value>
            </list>
        </property>
        <!-- 注入Map集合 -->
        <property name="map">
            <map>
                <entry key="key1" value="Value 1 of Map"></entry>
                <entry key="key2" value="Value 2 of Map"></entry>
                <entry key="key3" value="Value 3 of Map"></entry>
            </map>
        </property>
        <!-- 注入Properties -->
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
    </bean>
</beans>

建立PropertyDemo物件進行測試：

@Test
public void runPropertyDemo() {
    // 1. 載入Spring配置檔案，根據建立物件 
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    PropertyDemo pd = (PropertyDemo) context.getBean("prop");
    System.out.println(pd);
    System.out.println(Arrays.toString(pd.getArrs()));
    System.out.println(pd.getList());
    System.out.println(pd.getMap());
    System.out.println(pd.getProperties());
}

IoC和DI的區別

　IoC，控制反轉，將傳統的物件建立流程轉變為交由框架進行建立和管理。在Spring中，物件的建立交給Spring進行配置。它包括依賴注入。

　DI，依賴注入，向類的屬性設定值。

　IoC與DI的關係：依賴注入不能單獨存在，需要在IoC基礎之上完成操作。

4. Spring的bean管理（註解）

　註解是程式碼中特殊的標記，使用註解可以完成特定的功能。註解可以使用在類、方法或屬性上，寫法如：@註解名稱(屬性名稱=屬性值)。

Spring的bean管理註解方式，案例如下。

註解：就是一個類，使用@註解名稱
開發中：使用註解取代 xml配置檔案。
1.@Component取代<bean class="">
@Component("id") 取代 <bean id="" class="">
2. web開發，提供3個@Component註解衍生註解（功能一樣）取代
@Repository ：dao層
@Service：service層
@Controller：web層
3. 依賴注入，給私有欄位設值，也可以給setter方法設值
- 普通值：@Value(" ")
- 引用值：
  方式1：按照【型別】注入 @Autowired 方式2：按照【名稱】注入1 @Autowired @Qualifier("名稱") 方式3：按照【名稱】注入2 @Resource("名稱")
  4.生命週期
  初始化：@PostConstruct 銷燬：@PreDestroy
  5.作用域
  @Scope("prototype") 多例
  註解使用前提，新增名稱空間，讓spring掃描含有註解類

4.1 Spring註解開發準備

（1）匯入jar包：

匯入基本的jar包：commons-logging、log4j、spring-beans、spring-context、spring-core、spring-expression相關jar包。
匯入AOP的jar包：spring-aopjar包。

（2）建立類、方法

User.java

package com.wm103.anno;

import org.springframework.stereotype.Component;

public class User {
    public void add() {
        System.out.println("User Add Method.");
    }
}

（3）建立Spring配置檔案，引入約束；並開啟註解掃描　　

<?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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">

    <!--
        開啟註解掃描
            （1）到包中掃描類、方法、屬性上是否有註解
     -->
    <context:component-scan base-package="com.wm103"></context:component-scan>

    <!--
            （2）只掃描屬性上的註解
    -->
    <!--<context:annotation-config></context:annotation-config>-->
</beans>

4.2 註解建立物件

在建立物件的類上面使用註解實現，如：

@Component(value="user")
public class User {

建立測試類 TestAnno.java和測試方法，如：

package com.wm103.anno;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestAnno {

    @Test
    public void runUser() {
        // 1. 載入Spring配置檔案，根據建立物件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 得到配置建立的物件
        User user = (User) context.getBean("user");
        user.add();
    }
}

除了上述提到的@Component註解外，Spring中還提供了@Component的3個衍生註解，其功能就目前來說是一致的，均是為了建立物件。

@Controller ：WEB層
@Service ：業務層
@Repository ：持久層

以單例或多例項方式建立物件，預設為單例，多例物件設定註解如下：

@Component(value="user")
@Scope(value="prototype")
public class User {

4.3 註解注入屬性

　案例：建立Service類和Dao類，並在Service中注入Dao物件。如下：

（1）建立Dao和Service物件

　UserDao.java

package com.wm103.anno;

import org.springframework.stereotype.Repository;

@Repository(value="userDao")
public class UserDao {
    public void add() {
        System.out.println("UserDao Add Method.");
    }
}

UserService.java

package com.wm103.anno;

import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value="userService")
public class UserService {
    public void add() {
        System.out.println("UserService Add Method.");
        userDao.add();
    }
}

（2）在Service類中定義UserDao型別的屬性，並使用註解完成物件的注入

@Autowired：自動注入或自動裝配，是根據類名去找到類對應的物件來完成注入的。

@Autowired
private UserDao userDao;

或者@Resource

@Resource(name="userDao")
private UserDao userDao;

其中該註解的name屬性值為註解建立Dao物件的value屬性的值。

這兩種註解方式都不一定要為需要注入的屬性定義set方法。

（3）建立測試方法

@Test
public void runUserService() {
    // 1. 載入Spring配置檔案，根據建立物件
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    // 2. 得到配置建立的物件
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

注：配置檔案和註解混合使用

1）建立物件的操作一般使用配置檔案方式實現；

2）注入屬性的操作一般使用註解方式實現。

二、Spring框架—面向切面程式設計（AOP）

1. 什麼是AOP

在軟體業，AOP為Aspect Oriented Programming的縮寫，意為：面向切面程式設計，通過預編譯方式和執行期動態代理實現程式功能的統一維護的一種技術。AOP是OOP（面向物件程式設計）的延續，是軟體開發中的一個熱點，也是Spring框架中的一個重要內容，是函數語言程式設計的一種衍生範型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程式的可重用性，同時提高了開發的效率。
AOP採取橫向抽取機制，取代了傳統縱向繼承體系重複性程式碼
經典應用：事務管理、效能監視、安全檢查、快取、日誌等
Spring AOP使用純Java實現，不需要專門的編譯過程和類載入器，在執行期通過代理方式向目標類織入增強程式碼
AspectJ是一個基於Java語言的AOP框架，Spring2.0開始，Spring AOP引入對Aspect的支援，AspectJ擴充套件了Java語言，提供了一個專門的編譯器，在編譯時提供橫向程式碼的織入

2. AOP實現原理

aop底層將採用代理機制進行實現。
介面 + 實現類：spring採用 jdk 的動態代理Proxy。
實現類：spring 採用 cglib位元組碼增強。

3. AOP術語【掌握】

1. target：目標類，需要被代理的類。例如：UserService
2. Joinpoint(連線點):所謂連線點是指那些可能被攔截到的方法。例如：所有的方法
3. PointCut 切入點：已經被增強的連線點。例如：addUser()
4. advice 通知/增強，增強程式碼。例如：after、before
5. Weaving(織入):是指把增強advice應用到目標物件target來建立新的代理物件proxy的過程.
6. proxy 代理類
7. Aspect(切面): 是切入點pointcut和通知advice的結合
一個線是一個特殊的面。
一個切入點和一個通知，組成成一個特殊的面。

4. AOP實現方式

有四種實現方式：手動方式，半自動方式，全自動方式，註解方式

4.1 手動方式

4.1.1 JDK動態代理

JDK動態代理對“裝飾者”設計模式簡化。使用前提：必須有介面

1. 目標類：介面 + 實現類（UserServiceImpl）

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

2. 切面類：用於存通知 MyAspect

public class MyAspect { 
    public void before(){
        System.out.println("雞首");
    }   
    public void after(){
        System.out.println("牛後");
    }
}

3. 工廠類：編寫工廠生成代理

public class MyBeanFactory {

    public static UserService createService(){
        //1 目標類
        final UserService userService = new UserServiceImpl();
        //2切面類
        final MyAspect myAspect = new MyAspect();
        /* 3 代理類：將目標類（切入點）和 切面類（通知） 結合 --> 切面
         *  Proxy.newProxyInstance
         *      引數1：loader ，類載入器，動態代理類 執行時建立，任何類都需要類載入器將其載入到記憶體。
         *          一般情況：當前類.class.getClassLoader();
         *                  目標類例項.getClass().get...
         *      引數2：Class[] interfaces 代理類需要實現的所有介面
         *          方式1：目標類例項.getClass().getInterfaces()  ;注意：只能獲得自己介面，不能獲得父元素介面
         *          方式2：new Class[]{UserService.class}   
         *          例如：jdbc 驅動  --> DriverManager  獲得介面 Connection
         *      引數3：InvocationHandler  處理類，介面，必須進行實現類，一般採用匿名內部
         *          提供 invoke 方法，代理類的每一個方法執行時，都將呼叫一次invoke
         *              引數31：Object proxy ：代理物件
         *              引數32：Method method : 代理物件當前執行的方法的描述物件（反射）
         *                  執行方法名：method.getName()
         *                  執行方法：method.invoke(物件，實際引數)
         *              引數33：Object[] args :方法實際引數
         * 
         */
        UserService proxService = (UserService)Proxy.newProxyInstance(
                                MyBeanFactory.class.getClassLoader(), 
                                userService.getClass().getInterfaces(), 
                                new InvocationHandler() {

                                    @Override
                                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                                        //前執行
                                        myAspect.before();

                                        //執行目標類的方法
                                        Object obj = method.invoke(userService, args);

                                        //後執行
                                        myAspect.after();

                                        return obj;
                                    }
                                });

        return proxService;
    }

}

4. 測試

    @Test
    public void demo01(){
        UserService userService = MyBeanFactory.createService();
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

4.1.2 CGLIB位元組碼增強

沒有介面，只有實現類。
採用位元組碼增強框架 cglib，在執行時建立目標類的子類，從而對目標類進行增強。

工廠類

public class MyBeanFactory {

    public static UserServiceImpl createService(){
        //1 目標類
        final UserServiceImpl userService = new UserServiceImpl();
        //2切面類
        final MyAspect myAspect = new MyAspect();
        // 3.代理類 ，採用cglib，底層建立目標類的子類
        //3.1 核心類
        Enhancer enhancer = new Enhancer();
        //3.2 確定父類
        enhancer.setSuperclass(userService.getClass());
        /* 3.3 設定回撥函式 , MethodInterceptor介面 等效 jdk InvocationHandler介面
         *  intercept() 等效 jdk  invoke()
         *      引數1、引數2、引數3：以invoke一樣
         *      引數4：methodProxy 方法的代理
         *      
         * 
         */
        enhancer.setCallback(new MethodInterceptor(){

            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {

                //前
                myAspect.before();

                //執行目標類的方法
                Object obj = method.invoke(userService, args);
                // * 執行代理類的父類 ，執行目標類 （目標類和代理類 父子關係）
                methodProxy.invokeSuper(proxy, args);

                //後
                myAspect.after();

                return obj;
            }
        });
        //3.4 建立代理
        UserServiceImpl proxService = (UserServiceImpl) enhancer.create();

        return proxService;
    }
}

4.2 半自動

讓spring容器建立代理物件，從spring容器中手動的獲取代理物件

4.2.1 目標類

public interface UserService {
    public void addUser();
    public void updateUser();
    public void deleteUser();
}

4.2.2 切面類

package com.spring.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * 切面類：用於存通知
 * 切面類中確定通知，需要實現不同介面，介面就是規範，從而就確定方法名稱。
 * 採用“環繞通知” MethodInterceptor
 *
 */
public class MyAspect implements MethodInterceptor {
    
     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {
         Object result = null;
         try {
             System.out.println("--環繞通知開始--開啟事務--自動--");          
             long start = System.currentTimeMillis();

             //手動執行目標方法（有返回引數 則需返回值）
             result = invocation.proceed();

             long end = System.currentTimeMillis();
             System.out.println("總共執行時長" + (end - start) + " 毫秒");
                      
             System.out.println("--環繞通知結束--提交事務--自動--");
         } catch (Throwable t) {
             System.out.println("--環繞通知--出現錯誤");
         }
         return result;   
     }
}

4.2.3 Spring 配置

    <!-- 1 建立目標類 -->
    <bean id="userServiceId" class="com.spring.aop.UserServiceImpl"></bean>
    <bean id="orderServiceId" class="com.spring.aop.OrderService"></bean>
    <!-- 2 建立切面類（通知） -->
    <bean id="myAspectId" class="com.spring.aop.MyAspect"></bean>

    <!-- 3 建立代理類 
        * 使用工廠bean FactoryBean ，底層呼叫 getObject() 返回特殊bean
        * ProxyFactoryBean 用於建立代理工廠bean，生成特殊代理物件
            interfaces : 確定介面們
                通過<array>可以設定多個值
                只有一個值時，value=""
            target : 確定目標類
            interceptorNames : 通知 切面類的名稱，型別String[]，如果設定一個值 value=""
            optimize :強制使用cglib
                <property name="optimize" value="true"></property>
        底層機制
            如果目標類有介面，採用jdk動態代理
            如果沒有介面，採用cglib 位元組碼增強
            如果宣告 optimize = true ，無論是否有介面，都採用cglib
    -->
    <bean id="proxyServiceId" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="interfaces" value="com.spring.aop.UserService"></property>
        <property name="target" ref="userServiceId"></property>
        <property name="interceptorNames" value="myAspectId"></property>
    </bean>

4.2.4 測試

    @Test
    public void demo01(){
        // 1. 載入Spring配置檔案，根據建立物件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        //獲得代理類
        UserService userService = (UserService) applicationContext.getBean("proxyServiceId");
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();
    }

4.3 全自動

從spring 容器獲得目標類，如果配置aop，spring將自動生成代理。

4.3.1 切面類

package com.spring.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * 切面類：用於存通知
 * 切面類中確定通知，需要實現不同介面，介面就是規範，從而就確定方法名稱。
 * 採用“環繞通知” MethodInterceptor
 *
 */
public class MyAspectZD implements MethodInterceptor {
    
     @Override
     public Object invoke(MethodInvocation invocation) throws Throwable {
         Object result = null;
         try {
             System.out.println("--環繞通知開始--開啟事務--自動--");          
             long start = System.currentTimeMillis();

             //手動執行目標方法（有返回引數 則需返回值）
             result = invocation.proceed();

             long end = System.currentTimeMillis();
             System.out.println("總共執行時長" + (end - start) + " 毫秒");
                      
             System.out.println("--環繞通知結束--提交事務--自動--");
         } catch (Throwable t) {
             System.out.println("--環繞通知--出現錯誤");
         }
         return result;   
     }
}

切面類中根據獲取到的註解來通知，示例如下：

package com.demo.aop;

import com.demo.annotation.DataSourceChange;
import com.demo.datasource.DynamicDataSourceHolder;
import lombok.extern.slf4j.Slf4j;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

import java.lang.reflect.Method;

@Slf4j
public class DynamicDataSourceAspectDao implements MethodInterceptor {
    /**
     * 切面類：用於存通知
     * 切面類中確定通知，需要實現不同介面，介面就是規範，從而就確定方法名稱。
     * 採用“環繞通知” MethodInterceptor
     * @param invocation
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        log.info("around");
        Object result = null;
        //獲取代理介面或者類
        Object target = joinPoint.getTarget();
        String methodName = joinPoint.getSignature().getName();
        //獲取目標類的介面，所以註解@DataSourceChange需要寫在介面上
        //Class<?>[] clazz = target.getClass().getInterfaces();
        //獲取目標類，所以註解@DataSourceChange需要寫在類裡面
        Class<?>[] clazz = new Class<?>[]{target.getClass()};
        Class<?>[] parameterTypes = invocation.getMethod().getParameterTypes();
        try {
            Method method = clazz[0].getMethod(methodName, parameterTypes);
            //判斷是否使用了該註解
            if (method != null && method.isAnnotationPresent(DataSourceChange.class)) {
                DataSourceChange data = method.getAnnotation(DataSourceChange.class);
                if (data.slave()) {
                    DynamicDataSourceHolder.setDataSource(DynamicDataSourceHolder.DB_SLAVE);
                } else {
                    DynamicDataSourceHolder.setDataSource(DynamicDataSourceHolder.DB_MASTER);
                }
            }

            System.out.println("--環繞通知開始--開啟事務--自動--");
            long start = System.currentTimeMillis();

            //手動執行目標方法（有返回引數 則需返回值）
            result = invocation.proceed();

            long end = System.currentTimeMillis();
            System.out.println("總共執行時長" + (end - start) + " 毫秒");

            System.out.println("--環繞通知結束--提交事務--自動--");
        }
        catch (Throwable ex) {
            System.out.println("--環繞通知--出現錯誤");
            log.error(String.format("Choose DataSource error, method:%s, msg:%s", methodName, ex.getMessage()));
        }
        finally {
            DynamicDataSourceHolder.clearDataSource();
        }
        return result;
    }
}

4.3.2 Spring 配置

<?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:context="http://www.springframework.org/schema/context"
       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/context 
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop 
                           http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 1 建立目標類 -->
    <bean id="userServiceId" class="com.spring.aop.UserServiceImpl"></bean>
    <bean id="orderServiceId" class="com.spring.aop.OrderService"></bean>
    <!-- 2 建立切面類（通知） -->
    <bean id="myAspectId" class="com.spring.aop.MyAspectZD"></bean>

    <!-- 3 aop程式設計 
        3.1 匯入名稱空間
        3.2 使用 <aop:config>進行配置
                預設情況下會採用JDK的動態代理實現AOP（只能對實現了介面的類生成代理，而不能針對類）
                如果proxy-target-class="true" 宣告時強制使用cglib代理（針對類實現代理）
            <aop:pointcut> 切入點 ，從目標物件獲得具體方法
            <aop:advisor> 特殊的切面，只有一個通知 和 一個切入點
                advice-ref 通知引用
                pointcut-ref 切入點引用
                order 切面順序
        3.3 切入點表示式
            execution(* com.spring.aop..*.*(..))
                        選擇方法     返回值任意     包及所有子包      類名任意     方法名任意     引數任意
                        例如：匹配所有”set”開頭的方法:execution(* set*(..))
    -->
    <aop:config proxy-target-class="true">
        <aop:pointcut id="myPointCut" expression="execution(* com.spring.aop..*.update*(..))" />    
        <aop:advisor advice-ref="myAspectId" pointcut-ref="myPointCut" order="1" />
    </aop:config>
</beans>

4.3.3 測試

    @Test
    public void demo01(){
        // 1. 載入Spring配置檔案，根據建立物件
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 獲得目標類
        UserService userService = (UserService) applicationContext.getBean("userServiceId");
        userService.addUser();
        userService.updateUser();
        userService.deleteUser();

        // 獲得目標類
        OrderService orderService = (OrderService) applicationContext.getBean("orderServiceId");
        orderService.addOrder();
        orderService.updateOrder();
        orderService.deleteOrder();
    }

4.4 註解方式

Spring AOP基於註解的“零配置”方式實現

1. 為了在Spring中啟動@AspectJ支援，需要在類載入路徑下新增兩個AspectJ庫：aspectjweaver-1.74.jar和aspectjrt-1.74.jar。除此之外，Spring AOP還需要依賴一個aopalliance-1.0.jar包

2. 定義一個類似XmlAopDemoOrder.java這樣的切面

View Code

3. 定義一個業務元件，如：