SpringIOC和AOP理解之深入淺出（建議收藏）-有解無憂

Spring框架介紹

概念：Spring是一個開源的框架，并且是一個輕量級的java開發框架
前身：interface21是他的前身
Spring理念：使現有的技術更加容易使用，本身就是一個大雜燴，整合了現有的主流技術框架
優點：

方便解耦，簡化開發（高內聚低耦合）
Spring就是一個大工廠（容器），可以將所有物件創建和依賴關系維護，交給Spring管理
spring工廠是用于生成bean
AOP編程的支持
Spring提供面向切面編程，可以方便的實作對程式進行權限攔截、運行監控等功能
宣告式事務的支持
只需要通過配置就可以完成對事務的管理，而無需手動編程
方便程式的測驗
Spring對Junit4支持，可以通過注解方便的測驗Spring程式
方便集成各種優秀框架
Spring不排斥各種優秀的開源框架，其內部提供了對各種優秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持
降低JavaEE API的使用難度
Spring 對JavaEE開發中非常難用的一些API（JDBC、JavaMail、遠程呼叫等），都提供了封裝，使這些API應用難度大大降低
Spring是一個開源的免費框架（容器）
Spring是一個輕量級的，非入侵式的框架
Spring支持事務的處理，對框架的整合的支持
總結：Spring就是一個輕量級的控制反轉（IOC）和面向切面編程（AOP）的框架

控制反轉（IOC容器）

IOC原型：
之前： userDao 介面 userDaoImpl實作類 userService業務介面 userServiceImpl業務實作類
缺點： 代碼量大，修改成本高，若是多個業務需要頻繁修改物件
解決： 在userServiceImpl使用set注入來被動創建物件
在這里插入圖片描述

區別： 之前是程式主動創建物件，是程式員來控制的，現在使用set注入后不在具有主動性，變成了被動接收物件，不用再修改業務模塊的代碼
優點： 這種思想本質上的解決了問題，程式員不需要再管理物件的創建，系統的耦合性大大降低，更加專注于業務的實作上，

IOC本質：

1.控制反轉loC(Inversion of Control),是一種設計思想，DI(依賴注入)是實作IoC的一種方法
2.沒有loC的程式中,我們使用面向物件編程,物件的創建與物件間的依賴關系完全硬編碼在程式中，物件的創建由程式自己控制，控制反轉后將物件的創建轉移給第三方，
3.控制反轉是一種通過描述(XML或注解)并通過第3方去生產或獲取特定物件的方式，在Spring中實作控制反轉的是IoC容器,其實作方法是依賴注入(Dependency Injection,DI)

接下來由一個小案例讓大家感受一下IOC

案例：HelloSpring
兩個Dao層實作類，一個業務層實作類由spring創建并統一管理
在這里插入圖片描述
業務層實作類物件含有Dao實作類的物件引數
由spring創建并統一管理后，直接操作xml檔案即可修改獲取的物件，物件統一管理創建，無須在硬代碼中頻繁創建物件，耦合性極大降低，

總結：
●hello物件是由誰創建的？
hello物件是由Spring創建的
●Hello 物件的屬性是怎么設定的?
hello物件的屬性是由Spring容器設定的，
這個程序就叫控制反轉:
控制: 誰來控制物件的創建？傳統應用程式的物件是由程式本身控制創建的，使用Spring后,物件是由Spring來創建
反轉: 程式本身不創建物件,而變成被動的接收物件.
依賴注入: 就是利用set方法來進行注入的.

IOC是一種編程思想，由主動的編程變成被動的接收.
OK,到了現在,我們徹底不用再程式中去改動了,要實作不同的操作,只需要在xm|組態檔中進行修改
所謂的IoC, 一句話搞定物件由Spring來創建，管理，裝配!

注意： 在組態檔加載的時候，也就使用getBean的時候，容器中的物件就已經初始化了！

接下來講解一下IOC的幾種注入方式

Bean的配置

1.關于bean的配置：
id : bean的唯一識別符號，也就是相當于物件的參考
class : bean物件所對應的類:包名+型別
name : 也是別名,而且name可以同時取多個別名
例子：<bean id="grade" class="com.auc.bean.Grade" name="grade2"></bean>
2.關于import的配置：
import一般用于團隊開發使用，他可以將多個組態檔，匯入合并為一個；

IOC------依賴注入

普通值注入

<property name="name" value="劉大帥"/>

bean注入

<property name="hello" ref="hello"></property>

陣列注入

<property name="books">
    <array>
        <value>西游記</value>
        <value>水滸傳</value>
        <value>紅樓夢</value>
    </array>
</property>

list集合注入

<property name="hobbys">
    <list>
        <value>玩游戲</value>
        <value>聽音樂</value>
    </list>
</property>

list集合注入

<property name="hobbys">
    <list>
        <value>玩游戲</value>
        <value>聽音樂</value>
    </list>
</property>

map集合注入

<property name="card">
    <map>
        <entry key="身份證" value="123123"></entry>
        <entry key="手機哈" value="12311"></entry>
    </map>
</property>

properties組態檔注入

 <property name="info">
            <props>
                <prop key="學號">JX200201</prop>
            </props>
 </property>

IOC------拓展注入

p命名空間注入，可以直接注入屬性的值: property

 <bean id="user2" class="com. kuang . pojo.User" p:name=" 秦疆" p:age="18"/>

c命名空間注入，通過構造器注入: construct-args

 <bean id="user2" class="com. kuang . pojo.User" c:age="18" c:name="偉偉"/>

Bean的作用域
1.單例模式(Spring默認機制)-(singleton)

<bean id="user2" class="com. kuang. pojo.User" c:age="18" c:name="偉偉" scope="singleton"/>

2.原型模式:每次從容器中get的時候，都會產生一新物件!(prototype)

 <bean id="accountservice" class="com. something. DefaultAccountservice" scope="prototype"/>

3.其余的request. session. application. 這些個只能在web開發中使用到!

在這里插入圖片描述

IOC------Bean的自動裝配

1.ByName自動裝配：byName:會自動在容器背景關系中查找，和自己物件set方法后面的值對應的beanid

<bean id="people" class="com. kuang. pojo. People" autowire="byName">
	<property name="name" Value=" 小偉偉呀"/>
</bean>

2.ByType自動裝配： byType:會自動在容器背景關系中查找，和自己物件屬性型別相同的bean

<bean class="com. kuang. pojo.Cat"/>
<bean class="com. kuang. pojo.Cat"/> 
<bean id="peop1e" class="com. kuang. pojo. People" autowi re="byType">
    <property name="name" value="小偉偉呀"/>
</bean>

小結:
●byname的時候，需要保證所有bean的id唯一，并且這個bean需要和自動注入的屬性的set方法的值一致!
●bytype的時候，需要保證所有bean的class唯一，并且這個bean需要和自動注入的屬性的型別一致!

IOC------注解實作自動裝配

要使用注解須知:

匯入約束: context約束
配置注解的支持: context annotation-config. [重要]

方式

指定要主描的包，這個包下的注解就會生效

<context:component-scan base-package="com.kuang.pojo" /> <context:annotation-config/>

@component

@Component 組件等價于<bean id= "user" class= "com. kuang. pojo. User"/>
@Component:組件放在類上，說明這個類被Spring管理了，就是bean；

@Component有幾個衍生注解，我們在web開發中，會按照mvc三層架構分層;

dao [@Repository]
service [@Service]
servlet [ @Controller]

這四個注解功能都是一樣的，都是代表將某個類注冊到Spring中，進行裝配
作用域注解： @Scope("")

4. @Autowired
直接在屬性.上使用即可!也可以在set方式上使用!
使用Autowired我們可以不用撰寫Set方法了，前提是你這個自動裝配的屬性在IOC(Spring) 容器

注意：
如果@Autowired自動裝配的環境比較復雜，自動裝配無法通過一個注解[@Autowired] 完成的時候、我們可以使用@Qualifier(value=“xx”)去配置@Autowired的使用，指定一個唯一的bean物件注入!

pub1ic class People {
    @Autowired
    @qualifier(value="cat111")
    private cat cat;
     @Autowired
     @qualifier(value=" dog222")
     private Dog dog;
}

總結：
@Resource和@ Autowired的區別:
●都是用來自動裝配的，都可以放在屬性欄位上
●@ Autowired通過byType的方式實作，而且必須要求這個物件存在! [常用]
●@ Resource默認通過byname的方式實作，如果找不到名字，則通過byType實作! 如果兩個都找不到的情況下，就報錯!

xml與注解：
xml 更加萬能,適用于任何場合! 維護簡單方便；
注解不是自己類使用不了，維護相對復雜，
xml與注解最佳實踐：
xml用來管理bean；
注解只負責完成屬性的注入；
我們在使用的程序中，只需要注意一個問題: 必須讓注解生效,就需要開啟注解的支持

SpringAOP（面向切面編程）

官方概念： AOP，即面向切面編程，可以說是OOP（Object Oriented Programming，面向物件編程）的補充和完善，OOP引入封裝、繼承、多型等概念來建立一種物件層次結構，用于模擬公共行為的一個集合，不過OOP允許開發者定義縱向的關系，但并不適合定義橫向的關系，
例如日志功能，日志代碼往往橫向地散布在所有物件層次中，而與它對應的物件的核心功能毫無關系對于其他型別的代碼，如安全性、例外處理和透明的持續性也都是如此，這種散布在各處的無關的代碼被稱為橫切在OOP設計中，它導致了大量代碼的重復，而不利于各個模塊的重用，
AOP技術恰恰相反，它利用一種稱為"橫切"的技術，剖解開封裝的物件內部，并將那些影響了多個類的公共行為封裝到一個可重用模塊，并將其命名為"Aspect"，即切面，所謂"切面"，簡單說就是那些與業務無關，卻為業務模塊所共同呼叫的邏輯或責任封裝起來，便于減少系統的重復代碼，降低模塊之間的耦合度，并有利于未來的可操作性和可維護性，

個人理解：
1.首先，AOP是OOP面向物件開發的擴展補充：面向切面編程，因為正常開發流程中為OOP縱向開發，由dao-service-servlet-web，當我們需要對其中一個模塊進行添加其他額外功能時，此時為橫向開發，已經不適用于使用OOP思想開發，為了不修改原有代碼，減小耦合性，便使用到了AOP橫向開發，他將需要擴展的定義為一個切面，對其進行添加想要的功能，
2.在實作面向切面編程中，使用了代理模式，代理模式是將要擴展的功能交給代理物件來操作，
首先要使用反射包中的InvocationHandler：用來執行代理物件的方法 Proxy：用來獲取代理實體
（而Spring對AOP提供了支持，Spring中AOP代理由Spring的IOC容器負責生成、管理，其依賴關系也由IOC容器負責管理）

在這里插入圖片描述

Spring對AOP的支持

Spring中AOP代理由Spring的IOC容器負責生成、管理，其依賴關系也由IOC容器負責管理，因此，AOP代理可以直接使用容器中的其它bean實體作為目標，這種關系可由IOC容器的依賴注入提供，
Spring創建代理的規則為：
1、默認使用Java動態代理來創建AOP代理，這樣就可以為任何介面實體創建代理了
2、當需要代理的類不是代理介面的時候，Spring會切換為使用CGLIB代理，也可強制使用CGLIB
AOP編程其實是很簡單的事情，縱觀AOP編程，程式員只需要參與三個部分：

定義普通業務組件
定義切入點，一個切入點可能橫切多個業務組件
定義增強處理，增強處理就是在AOP框架為普通業務組件織入的處理動作

所以進行AOP編程的關鍵就是定義切入點和定義增強處理，一旦定義了合適的切入點和增強處理，AOP框架將自動生成AOP代理，即：代理物件的方法=增強處理+被代理物件的方法，

Aop在Spring中的作用

提供宣告式事務;允許用戶自定義切面
橫切關注點: 跨越應用程式多個模塊的方法或功能，即是,與我們業務邏輯無關的,但是我們需要關注的部分,就是橫切關注點，如日志,安全,快取,事務等等
切面(ASPECT) : 橫切關注點被模塊化的特殊物件，即，它是一個類，
通知(Advice) : 切面必須要完成的作業，即,它是類中的一個方法
目標(Target) : 被通知物件
代理(Proxy) : 向目標物件應用通知之后創建的物件
切入點(PointCut) : 切面通知執行的"地點"的定義，
連接點(JointPoint) : 與切入點匹配的執行點

在這里插入圖片描述
Aop實作方式

注意：使用AOP織入，需要匯入依賴包

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

方式一：使用Spring API介面

<--方式一:使用原生:Spring API介面1-->
<!--配置aop:需要匯入aop的約束-->
<aop:config>
     <!--切入點:expression:運算式execution( 要執行的位置! *****-->
<aop:pointcut id=" pointcut" expression="execution(* com.kuang.service.UserServiceImp1.*(..))"/>
     <!--執行環繞增加! -->
<aop:advisor advice-ref="log" pointcut-ref=" pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>

方式二：自定義來實作AOP

自定義的類：
public class DiyPointCut {
    public void before( ){
        System. out . print1n("=======方法執行前========");
    }
    public void |after(){
        System. out . print1n("=======方法執行后========");
    }
}

<!--自定義類-->
<bean id="diy" class="com. kuang. diy.DiyPointCut"/>
<aop :config>
        <!--自定義切面，ref 要參考的類-->
<aop:aspect ref="diy">
        <!--切入點-->
<aop:pointcut id=" point" expression=" execution(*com.kuang.service.UserServiceImp1.*(..))"/>
        <!--通知-->
<aop: before method= "before" pointcut-ref="point"/>
<aop:after method="after" pointcut -ref="point"/>
</aop:aspect>
</aop : config>

方式三：使用注解實作

@Aspect //標注這個類是一個 切面
    public class AnnotationPointCut {
        @Before("execution(* com. kuang. service.UserServiceImp1.*(..))")
        public void before(){
            System. out. println("=====方法執行前=====");
        }
        @After("execution(* com. kuang. service . UserServiceImp1.*(..))")
        public void after(){
            System. out. print1n("=====方法執行后=====");
        }
        //在環繞增強中，我們可以給定一個引數， 代表我們要獲取處理切入的點;:
        @Around("execution(* com. kuang. service . UserServiceImp1. *(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable {
            System.out.print1n("環繞前");
            Signature signature = jp.getSignature();//獲得簽名
            System.out.println("signature :"+signature);
            object proceed = jp.proceed(); //執行方法
            System.out.print1n("環繞后");
            System.out.println( proceed);
}

<bean id=" annotationPointCut" class=" com. kuang. diy . AnnotationPointCut"/>
<!--開啟注解支持! JDK(默認 proxy-target-class= "false")  cglib (proxy-target-class="true") -->
<aop: aspectj-autoproxy  proxy-target-class= "true"/>

代理模式
優點:
●可以使真實角色的操作更加純粹不用去關注一些公共的業務
●公共也就就交給代理角色!實作了業務的分工
●公共業務發生擴展的時候，方便集中管理
缺點:
●一個真實角色就會產生一個代理角色;代碼量會翻倍，開發效率會變低

AOP面向切面編程-----代理模式

靜態代理
角色分析：
抽象角色：一般會使用介面或者抽象類來解決；
真實角色：被代理的角色；
代理角色：代理真實角色，代理真實角色后,我們一般會做一些附屬操作；
客戶：訪問代理物件的人，
動態代理
動態代理和靜態代理角色一樣；
動態代理的代理類是動態生成的，不是我們直接寫好的；
動態代理分為兩大類：
基于介面：JDK動態代理；
基于類：cglib；
java位元組碼實作：javasist，

以下是AOP理解小案例

//動態代理的寫法
//等我們會用這個類，自動生成代理類!
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的介面
    private Rent rent;
    public void setRent(Rent rent) {
        this.rent = rent;
        }
    //生成得到代理類
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
    }
    //處理代理實體，并回傳結果
    public object invoke(object proxy, Method method, object[] args) throws Throwable {|
    //動態代理的本質，就是使用反射機制實作!
            Object result =method.invoke(rent, args);
            seeHouse(); 
            return result;
            fare();|
    }
    public void seeHouse(){
        System. out . print1n("中介帶看房子");
    }
    public void fare(){
        System.out.print1n("收中介費");
    }
}

//主函式呼叫
public class Client {
public static void main(String[] args) {
        //真實角色
        Host host = new Host( ) ;
        //代理角色:現在沒有
        ProxyInvocationHandler pih = new ProxyInvocationHand1er() ;
        //通過呼叫程式處理角色來處理我們要呼叫的介面物件!
        pih. setRent(host);
       Rent proxy = (Rent) pih. getProxy();
       proxy .rent();
    }
}

以上是我個人對spring AOP IOC的的個人理解，希望大家多多探討一起學習交流~

個人推薦優秀文章：

文章1

文章2

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/249059.html

標籤：java

上一篇：低代碼，是否能“取代”開發者？

下一篇：Java微服務 vs Go微服務，究竟誰更強！？