Spring IOC 和 AOP

• 2022 年 2 月 18 日
• 筆記
• spring

Spring

創建的類在spring 中的生命周期， 控制許可權交給了spring處理，拋棄了之前手動創建對象和實例對象。

 bean容器： 一個對象被創建和被實例化的過程發生的事。
 
 myclass --> 推斷構造器 --> 初始化前 --> 初始化中 --> 初始化後 --> 代理對象aop --> （IOC bean）單例池 --> Bean對象

spring的特性：

​ 控制反轉 inversion of control ： 指將對象的創建權力交給spring控制，每個對象稱為bean

​ 依賴注入 dependency injection : 依賴的對象不需要手動調用setxxx方法去設置，而是通過配置賦值

​ 面向切面編程 aspect oriented programming : 在spring初始化實例對象前，通過切面設置，可以執行指定的切面方法。

​ spring容器： spring它是一個容器，我們的對象的生命周期在spring容器中控制著。

​ 組件化：使用簡單的組件配置組合成一個複雜的應用。在 Spring 中可以使用XML和Java註解組合這些對象。

​

其他概念：

​ 單例： 一個類只有一個實例對象，實例化對象後將提供整系統使用。 bean是單例池，在多執行緒中，每個bean對象都只能存在一個單線中！

​ 同步機制：

​ ThreadLocal和執行緒同步機制相比有什麼優勢呢？他們都是為了解決多執行緒中相同變數的訪問衝突問題。在同步機制中，通過對象的鎖機制保證同一時間只有一個執行緒訪問變數。這時該變數是多個執行緒共享的，使用同步機制要求程式慎密地分析什麼時候對變數進行讀寫，什麼時候需要鎖定某個對象，什麼時候釋放對象鎖等繁雜的問題，程式設計和編寫難度相對較大。

概括起來說，對於多執行緒資源共享的問題，同步機制採用了「以時間換空間」的方式，而ThreadLocal採用了「以空間換時間」的方式。前者僅提供一份變數，讓不同的執行緒排隊訪問，而後者為每一個執行緒都提供了一份變數，因此可以同時訪問而互不影響。

​

spring核心：

1 控制反轉 inversion of control

為什麼要使用控制反轉：

bean對象變得靈活，應用對象的創建的權力交給spring管理，用戶可以通過spring容器獲取應用對象。

減少耦合度

實現的方式有哪些？

依賴注入DI:

​ 構造函數的依賴注入

​ 設值函數的依賴注入

​ 注入內部beans

​ 注入集合

推斷構造方法（默認的無參構造法）

Setter方法注入

使用xml配置應用對象

1.1 Bean

定義： bean是一個被實例化組裝，通過springioc管理的對象，並由容器提供的配置 元數據 創建的。

bean的屬性參數：

配置bean元數據的方式：

• 基於 XML 的配置文件
• 基於註解的配置
• 基於 Java 的配置

bean的後置處理器

在初始化bean的前後對bean進行其他處理

如何做後置處理：

​ 繼承BeanPostProcessor 介面 實現初始化 前和初始化後方法。

public class InitHelloWorld implements BeanPostProcessor {
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("BeforeInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("AfterInitialization : " + beanName);
      return bean;  // you can return any other object as well
   }
}

bean的作用域

通過配置xml 中的 scope 指定哪種作用域

基於xml配置bean對象

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

   <bean id="" class="" 
      scope="">
   </bean>

</beans>

import

當有多個bean.xml配置文件時，可以通過總的application.xml文件用Import到管理多個bean.xml文件

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

    <import resource="bean.xml"/>
    <import resource="bean1.xml"/>


</beans>```

2 依賴注入

​ 給bean對象賦值元數據，元數據可以是引用class （注入內部Bean），有參構造方法，普通元數， 集合等複雜的數據賦值。

基本注入

2.1 有參構造方法

2.2 內部Bean注入

2.3 普通參數注入

2.4 集合參數注入

​ set , map ,array , 屬性propr, null

類元數據
	private String beanname;
    private BeanLife beanLife; //內部Bena注入
    //集合注入
    private Set<String> setdi;
    private Map<String,String> mapdi;
    private String[] arrayListdi;
    private String nulldi;
    private Properties propertiesdi;

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="//www.springframework.org/schema/beans"
       xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="//www.springframework.org/schema/beans
    //www.springframework.org/schema/beans/spring-beans-3.0.xsd">
    內部bean
    <bean id="beanLife" class="spring.bean.BeanLife"/>

    <bean id="beanDI" class="spring.bean.BeanDI">
        <!--基本參數-->
       <property name="beanname" value="hellobean"/>

        <!-- 內部bean-->
        <property name="beanLife" ref="beanLife"/>

        <!-- 集合-->
        set
        <property name="setdi">
            <set>
                <value>set值</value>
                <value>set值1</value>
            </set>
        </property>
        map
        <property name="mapdi">
           <map>
               <entry key="用名" value="root"></entry>
               <entry key="密碼" value="root"></entry>
           </map>
        </property>
        數組
        <property name="arrayListdi">
            <array>
                <value>西縣及</value>
                <value>數組類型</value>
            </array>
        </property>
        null
        <property name="nulldi">
            <null/>
        </property>
        
        屬性propety
        <property name="propertiesdi">
            <props>
                <prop key="one">INDIA</prop>
                <prop key="two">Pakistan</prop>
                <prop key="three">USA</prop>
                <prop key="four">USA</prop>
            </props>
        </property>



    </bean>

</beans>

簡化注入

2.5 p 標籤注入

xmlns:p=”//www.springframework.org/schema/p” 引入

屬性命名空間注入
傳統的屬性參數 property name = "pname" value ="valuename"  ===  p:pname="valuename"

<beans xmlns="//www.springframework.org/schema/beans"
    xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
    xmlns:p="//www.springframework.org/schema/p"
    xsi:schemaLocation="//www.springframework.org/schema/beans
        //www.springframework.org/schema/beans/spring-beans.xsd">
	傳統屬性注入
    <bean name="classic" class="com.example.ExampleBean">
        <property name="email" value="[email protected]"/>
    </bean>
	
    p命名注入
    <bean name="p-namespace" class="com.example.ExampleBean"
        p:email="[email protected]"/>
    
    注入的是內部bean對象時   p:spouse-ref
	    <bean name="classic" class="com.example.ExampleBean" 
              p:name = "Jane Doe" p:spouse-ref = "user"
              >
         <bean name="user" class="com.example.User">
            <property name="name" value="Jane Doe"/>
        </bean>     

</beans>

2.6 c 標籤注入

配置有參構造函數參數注入

xmlns:c="//www.springframework.org/schema/c"

<!--    使用c p 標籤簡化注入-->
 <bean id="userBean" class="spring.bean.UserBean" p:beanname="helloUserBean" c:beanname="有參構造"/>

2.7 depends-on

用來指定多個內部bean對象

depends-on 屬性既可以指定初始化時間依賴，也可以指定對應的銷毀時間依賴（僅在單例 bean 的情況下）。 與給定 bean 定義依賴關係的依賴 bean 首先被銷毀，在給定 bean 本身被銷毀之前。 因此，depends-on 也可以控制關閉順序。

<bean id="beanOne" class="ExampleBean" depends-on="bean1,bean2">
    <property name="manager" ref="manager" />
</bean>

<bean id="bean1" class="ManagerBean" />
<bean id="bean2" class="x.y.jdbc.JdbcAccountDao" />

3.自動裝配 autowired

沒有自動裝配之前，我們用xml配置內部Bean對象屬性，通過 ref 或者p標籤 p:spouse-ref，引入內部Bena的元數據。

現在用自動裝配 autowired=”byName/byType” ，自己去容器找到內部類的屬性名和類型。

byName：內部bean對象屬性名

byType： 內部bean對象數據類型

	<!--    自動裝配-->
	兩個內部類
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="gegir" class="spring.bean.userclass.Gegir"/>

	bean對象
    <bean id="proson"  class="spring.bean.userclass.Proson" p:name="人們" autowire="byType">

    </bean>

構造函數的自動裝配 constructor-arg

<!--    自動裝配-->
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="gegir" class="spring.bean.userclass.Gegir"/>

    <bean id="proson"  class="spring.bean.userclass.Proson" p:name="人們" autowire="constructor">
        <constructor-arg value="這是man構造函數"/>
        <constructor-arg value="這是gegir構造函數"/>
    </bean>

4.面向切面AOP

面向切面是基於動態代理的反射機制，通過創建代理對象，可以將方法切入到指定目標類方法前後，或者環繞，或者拋異常

創建aop的方法有哪些

1. 原生的spring api

2. 基於 bean.xml 配置文件

3. 基於註解

什麼是切面（<aop:aspect ref=”日誌類”> 自定義的切入面）

​ 切入目標類的，代理類

什麼是切點（expression=”execution(* aop.serve.UserServceImp.*(..))）又是實現類

​ 切入點是被代理類的方法執行的目標類

每個類執行完方法之前和之後切入面類的方法就會根據應用場景來執行你方法的前後通知

依賴Spring5的AOP依賴

   <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.1.RELEASE</version>
        </dependency>

基於xml配置實現AOP

場景：

​ 我有一個資料庫操作的業務類，它繼承了userDao並實現增刪改查方法，userDaoImp繼承類執行sql的業務操作。 我想在執行sql操作的前後都加一個通過，執行中，和執行完成

UserDao.interface

package aop.dao;

public interface UserDao {
    public void add();
    public void delete();
    public void update();
    public void select();
    public void insert();
}

UserServceImp.class

package aop.serve;


import aop.dao.UserDao;

public class UserServceImp implements UserDao {
    @Override
    public void add() {
        System.out.println("執行添加操作");
    }

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

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

    @Override
    public void select() {
        System.out.println("查詢");
    }

    @Override
    public void insert() {
        System.out.println("插入");
    }

}

切面類Logger.class

public class Logger {

    public void befor(){
        System.out.println("正在執行操作！");
    }
    public void after(){
        System.out.println("執行完成！");
    }
    
 }

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

    注入bean對象
    <bean id="userServceImp" class="aop.serve.UserServceImp"/>
    <bean id="logger" class="aop.log.Logger"/>
    
    
    配置aop
    <aop:config>

        <!--自定義的日誌切面-->
        <aop:aspect ref="logger">
            <aop:pointcut id="pointcut" expression="execution(* aop.serve.UserServceImp.*(..))"/>
            <aop:before method="befor" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/>
        </aop:aspect>

    </aop:config>
    
    
    
</beans>

execution( * * * * ) 五個 * 號所代表的含義

execution( 返回值類型 切點類路徑 子包 所有類 所有方法)

Spring註解

一 IOC註解

簡化之前的bean.xml配置操作

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="//www.springframework.org/schema/beans"
    xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
    xmlns:context="//www.springframework.org/schema/context"
    xsi:schemaLocation="//www.springframework.org/schema/beans
    //www.springframework.org/schema/beans/spring-beans-3.0.xsd
    //www.springframework.org/schema/context
    //www.springframework.org/schema/context/spring-context-3.0.xsd">
    
    開啟註解模式
   <context:annotation-config/>

 

</beans>

Bean （@component ）

@Component

等價於 xml 中的標籤 ，指定名稱用 @component(“user”) ===

開啟組件掃描
<context:component-scan  base-package=「掃描包下帶有component的類」/>

生命周期

​

作用域@Scope

@Scope（「singleton」）：單例模式
@Scope（「prototype」）：多例模式

依賴注入

普通參數的依賴注入@Value

注入集合

構造函數的注入

內部Bean對象的注入

自動裝配 @Autowired @Resource

解決內部bean對象的byName屬性名和byType類型，構造方法等元數據

@Resource
private Man man;
@Autowired
private Gegir gegir;

<!--    開啟註解模式-->
    <context:annotation-config/>
	autowired註解
    <bean id="gegir1" class="spring.bean.userclass.Gegir"/>

	resouce註解 javax自帶的
    <bean id="man" class="spring.bean.userclass.Man"/>
    <bean id="man2" class="spring.bean.userclass.Man"/>

    <bean id="proson" class="spring.bean.userclass.Proson"/>

@Autowired @Resourc的區別

1. 功能相同都是用來自動裝配的，都可以放在內部bean對象上
2. @Autowired通過byname方法來實現
3. @Resourc通過byname方法來實現，如果找不到屬性名，則通過byType實現

其他註解

JSR250

bean的初始化 @PostConstruct 注釋作為初始化回調函數的一個替代，

bean的銷毀 @PreDestroy 注釋作為銷毀回調函數的一個替代

@Required 註解應用於 bean 屬性的 setter 方法**

@Qualifier 指定bean.xml中使用的是哪某個beans對象

package com.tutorialspoint;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
public class Profile {
   @Autowired
   @Qualifier("student1")  指定bean.xml另外的byName值
   private Student student;
   public Profile(){
      System.out.println("Inside Profile constructor." );
   }
   public void printAge() {
      System.out.println("Age : " + student.getAge() );
   }
   public void printName() {
      System.out.println("Name : " + student.getName() );
   }
}

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="//www.springframework.org/schema/beans"
    xmlns:xsi="//www.w3.org/2001/XMLSchema-instance"
    xmlns:context="//www.springframework.org/schema/context"
    xsi:schemaLocation="//www.springframework.org/schema/beans
    //www.springframework.org/schema/beans/spring-beans-3.0.xsd
    //www.springframework.org/schema/context
    //www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>

   <!-- Definition for profile bean -->
   <bean id="profile" class="com.tutorialspoint.Profile">
   </bean>

   <!-- 同個byTpye 不同byName -->
   <bean id="student1" class="com.tutorialspoint.Student">
      <property name="name"  value="Zara" />
      <property name="age"  value="11"/>
   </bean>

   <bean id="student2" class="com.tutorialspoint.Student">
      <property name="name"  value="Nuha" />
      <property name="age"  value="2"/>
   </bean>

</beans>

​

二 AOP註解

切點@Pointcut(“execution(* 目標類路徑 *(..))”)

切面@Aspect

前置通知 @Before

後置通知 @After

環繞通知 @Around

最後環繞通知 @AfterReturning(pointcut = “”, returning=”返回值”)

異常通知 @AfterThrowing(pointcut = “”, throwing = “拋異常的參數”)

實現

注入bean

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

    <!--開啟切面註解-->
    <aop:aspectj-autoproxy/>

    切面
    <bean id="aLogger" class="aop.annotation.ALogger"/>
    切點
    <bean id="aUserDaoImp" class="aop.annotation.AUserDaoImp"/>



</beans>

日誌註解切面

package aop.annotation;


import org.aspectj.lang.annotation.*;

@Aspect
public class ALogger {
	
    單獨抽取指向切點的方法供其他切面方法使用
    @Pointcut("execution(* aop.annotation.AUserDaoImp.*(..))")
    public void selecall(){}

    @Before("selecall()")
    public void befor(){
        System.out.println("執行之前！");
    }

    @After("selecall()")
    public void after(){
        System.out.println("執行之後！");
    }

    public void aroutd(){ System.out.println("在方法之前之後，環繞通知");}
    public void afterreturning(){
        System.out.println("afterreturning");
    }

    @AfterThrowing(pointcut = "selecall()", throwing = "E")
    public void throwing(IllegalArgumentException  E){
        System.out.println("throwing"+ E.toString());
    }


}

切點

import org.springframework.stereotype.Component;

@Component
public class AUserDaoImp implements AUserDao{
    @Override
    public void add() {
        System.out.println("執行添加操作");
    }

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

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

    @Override
    public void select() {
        System.out.println("查詢");
    }

    @Override
    public void insert() {
        System.out.println("插入");
    }
}

Spring使用的註解大全和解釋