實例說明spring三大核心思想

Spring的三大核心思想

IOC(控制反轉)，DI(依賴注入)，AOP（面向切面編程）。

IOC(控制反轉)：

說明：實現將組件間的關係從程序內部提到外部容器（spring的xml）來管理。
首先外部容器（spring.xml）中會動態的註冊業務所需的對象（接口/類）。
實例：

//1.定義一個接口
public interface IPrint {  
    /**   
    * onLine:  對象需要實現這個方法來實現打印對象的功能 
    * void  返回類型    
    */  
    String printObject();  

//2.實現接口
public class UserBean implements IPrint{  
    @Override  
    public String printObject() {  
        // TODO Auto-generated method stub  
        System.out.println("打印對象UserBean:");  
        return "abc";  
    }  

}  

public class MyBean implements IPrint{  
    @Override  
    public String printObject() {  
        // TODO Auto-generated method stub  
        System.out.println("打印對象MyBean:");  
        return null;  
    }  
}  
//3.測試
IPrint print = new UserBean();  
print.printObject(); 

/**很正常的執行結果（“打印對象UserBean：”）。但是這時候我想修改一下，打印第二個實現類，這時候就需要修改代碼了，修改代碼畢竟是不符合開閉原則，又比較麻煩的事，這時候就需要用到spring的控制反轉：對繼承了接口IPrint的具體實現類的具體對象的創建，不依賴於調用他的客戶端代碼，而將控制權交給spring（其實就是xml文件），這就是控制反轉。*/
//-------------------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" xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"  
    xmlns:p="http://www.springframework.org/schema/p"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
    http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
    http://www.springframework.org/schema/tx  
    http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
    http://www.springframework.org/schema/aop    
    http://www.springframework.org/schema/aop/spring-aop-3.2.xsd   
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-3.2.xsd">  
    <!-- 註冊bean --!>  
    <bean id="userBean" class="testSpring.business.bean.UserBean" />  
</beans> 
//-------------------------------------------------
//測試類：
/**讀取配置文件（將配置文件中的bean加載進內存）*/  
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/testSpring/resources/applicationContext.xml");  
        //獲取的實例    
        IPrint bean=(IPrint)ctx.getBean("userBean");    
        //調用方法    
        bean.printObject(); 
//-------------------------------------------------
//如果想要打印另一個實現類，只要修改配置文件：
<bean id="userBean" class="testSpring.business.bean.MyBean" />

總結：從spring的控制反轉實現可以看出，客戶端的實現不必去修改代碼，從而達到了鬆耦合的目的。控制反轉最後就是將主動權交給接口。

DI(依賴注入)

說明：利用xml的配置信息，在客戶端代碼中不用具體new任何的java對象了，java對象的創建工作，和對象中元素的賦值工作可以交給xml（spring）處理。組件之間的依賴關係由容器在應用系統運行期來決定，也就是由容器動態地將某種依賴關係的目標對象實例注入到應用系統中的各個關聯的組件之中。JavaBean：爲了寫出方便他人使用的類，於是規定，必須有一個零參的構造函數，同時還要用get/set方法，以便隱藏內部細節，方便使用和之後的代碼更新。

實例：首先應該明白兩個問題：1，誰依賴誰；2，誰注入，注入什麼？

package test; 
public class User { 
	private String name;
	private String gender; 
	
	public String getName() {
		return name; 
 	} 
   public User(String name, Integer age) {
   		this.name = name; this.age = age;
   	 } 
   public void setName(String name) { 
   		this.name = name; 
   		} 
   public String getGender() { 
   		return gender; 
   		} 
   public void setGender(String gender) { 
   		this.gender = gender; 
   		}
   @Override 
   public String toString() { 
   		return "User [name=" + name + ", gender=" + gender + "]"; } 
   	}
 //------------------1.屬性注入--------------------
//spring.xml文件配置：
<bean id="user" class="test.User"> 
	<property name="name" value="cup"></property> 
	<property name="gender" value="man"></property> 
</bean>
 //------------------2.構造注入--------------------
     <!-- 指定class屬性，通過構造方法創建Bean實例 -->  
    <bean id="person" class="com.mao.gouzao.Person">  
      <!-- 通過構造方法賦值 -->  
     <constructor-arg name="name" value="魔術師"></constructor-arg>
      <constructor-arg name="gender" value="魔術師"></constructor-arg> 
    </bean> 
//------------------3.工廠方法注入 --------------------
//非靜態工廠方法
//先定義工廠類：
package test; 
public class UserFactory { 
	public User createUser(){ 
	      User user = new User("cup",25); 
	      return user; 
	      } 
	}
//進行Bean配置：
<bean id="userFactory" class="test.UserFactory" /> 
<bean id="user3" factory-bean="userFactory" factory-method="createUser"></bean>
//------------------4.註解方式 --------------------
// 對類成員變量註解
//1.使用@Autowire實現自動注入,格式如：

@Component 
public class IdCard{ 
    ..... 
}

public class User{ 
//Autowired默認按類型注入，@required 表明如果找不到對應的bean則爲null，但如果設定爲true(也是默認值)，則要求一定要找到匹配的bean，否則會拋出異常。 //Qualifier常用於容器有一個以上相同類型的Bean,通過指定名字來指定唯一的Bean 
    @Autowired(required = false ) 
    @Qualifier("idCard") 
    private IdCard idCard;//也可以將IdCard配置在xml文件中注入 ..... 
}
// 2.對類成員方法進行註解
@Autowired 
public void init(
@Qualifier（“usar1")
User user1
@Qualifier("user2")
User user2){ 
      this.user1 = user1; 
      this.user2 = user2; 
}

AOP（面向切面編程）

說明：AOP（Aspect Oriented Programming），即面向切面編程，可以說是OOP（Object Oriented Programming，面向對象編程）的補充和完善。OOP引入封裝、繼承、多態等概念來建立一種對象層次結構，用於模擬公共行爲的一個集合。不過OOP允許開發者定義縱向的關係，但並不適合定義橫向的關係，例如日誌功能。日誌代碼往往橫向地散佈在所有對象層次中，而與它對應的對象的核心功能毫無關係對於其他類型的代碼，如安全性、異常處理和透明的持續性也都是如此，這種散佈在各處的無關的代碼被稱爲橫切（cross cutting），在OOP設計中，它導致了大量代碼的重複，而不利於各個模塊的重用。

AOP技術恰恰相反，它利用一種稱爲"橫切"的技術，剖解開封裝的對象內部，並將那些影響了多個類的公共行爲封裝到一個可重用模塊，並將其命名爲"Aspect"，即切面。所謂"切面"，簡單說就是那些與業務無關，卻爲業務模塊所共同調用的邏輯或責任封裝起來，便於減少系統的重複代碼，降低模塊之間的耦合度，並有利於未來的可操作性和可維護性。

使用"橫切"技術，AOP把軟件系統分爲兩個部分：核心關注點和橫切關注點。業務處理的主要流程是核心關注點，與之關係不大的部分是橫切關注點。橫切關注點的一個特點是，他們經常發生在覈心關注點的多處，而各處基本相似，比如權限認證、日誌、事物。AOP的作用在於分離系統中的各種關注點，將核心關注點和橫切關注點分離開來。
AOP核心概念：
1、橫切關注點
對哪些方法進行攔截，攔截後怎麼處理，這些關注點稱之爲橫切關注點
2、切面（aspect）
類是對物體特徵的抽象，切面就是對橫切關注點的抽象
3、連接點（joinpoint）
被攔截到的點，因爲Spring只支持方法類型的連接點，所以在Spring中連接點指的就是被攔截到的方法，實際上連接點還可以是字段或者構造器
4、切入點（pointcut）
對連接點進行攔截的定義
5、通知（advice）
所謂通知指的就是指攔截到連接點之後要執行的代碼，通知分爲前置、後置、異常、最終、環繞通知五類
6、目標對象
代理的目標對象
7、織入（weave）
將切面應用到目標對象並導致代理對象創建的過程
8、引入（introduction）
在不修改代碼的前提下，引入可以在運行期爲類動態地添加一些方法或字段
Spring對AOP的支持
Spring中AOP代理由Spring的IOC容器負責生成、管理，其依賴關係也由IOC容器負責管理。因此，AOP代理可以直接使用容器中的其它bean實例作爲目標，這種關係可由IOC容器的依賴注入提供。Spring創建代理的規則爲：
1、默認使用Java動態代理來創建AOP代理，這樣就可以爲任何接口實例創建代理了
2、當需要代理的類不是代理接口的時候，Spring會切換爲使用CGLIB代理，也可強制使用CGLIB
AOP編程其實是很簡單的事情，縱觀AOP編程，程序員只需要參與三個部分：
1、定義普通業務組件
2、定義切入點，一個切入點可能橫切多個業務組件
3、定義增強處理，增強處理就是在AOP框架爲普通業務組件織入的處理動作
所以進行AOP編程的關鍵就是定義切入點和定義增強處理，一旦定義了合適的切入點和增強處理，AOP框架將自動生成AOP代理，即：代理對象的方法=增強處理+被代理對象的方法。

下面給出一個Spring AOP的.xml文件模板，名字叫做aop.xml，之後的內容都在aop.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">           
</beans>

基於Spring的AOP簡單實現
注意一下，在講解之前，說明一點：使用Spring AOP，要成功運行起代碼，只用Spring提供給開發者的jar包是不夠的，請額外上網下載兩個jar包：
1、aopalliance.jar
2、aspectjweaver.jar
開始講解用Spring AOP的XML實現方式

//1.定義一個接口
public interface HelloWorld
{
    void printHelloWorld();
    void doPrint();
}
//2.定義兩個接口實現類
public class HelloWorldImpl1 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl1.doPrint()");
        return ;
    }
}

public class HelloWorldImpl2 implements HelloWorld
{
    public void printHelloWorld()
    {
        System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
    }
    
    public void doPrint()
    {
        System.out.println("Enter HelloWorldImpl2.doPrint()");
        return ;
    }
}
//3.橫切關注點，這裏是打印時間
public class TimeHandler
{
    public void printTime()
    {
        System.out.println("CurrentTime = " + System.currentTimeMillis());
    }
}
//4.有這三個類就可以實現一個簡單的Spring AOP了，看一下aop.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler">
                <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addAllMethod" />
                <aop:after method="printTime" pointcut-ref="addAllMethod" />
            </aop:aspect>
        </aop:config>
</beans>

//5.寫一個main函數調用一下
public static void main(String[] args)
{
    ApplicationContext ctx = 
            new ClassPathXmlApplicationContext("aop.xml");
        
    HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
    HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
    hw1.printHelloWorld();
    System.out.println();
    hw1.doPrint();
    
    System.out.println();
    hw2.printHelloWorld();
    System.out.println();
    hw2.doPrint();
}
//6.運行結果爲：
CurrentTime = 1446129611993
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1446129611993

CurrentTime = 1446129611994
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1446129611994
//看到給HelloWorld接口的兩個實現類的所有方法都加上了代理，代理內容就是打印時間


//------------------------基於Spring的AOP使用其他細節-------------------------------//
//1、增加一個橫切關注點，打印日誌，Java類爲
public class LogHandler
{
    public void LogBefore()
    {
        System.out.println("Log before method");
    }    
    public void LogAfter()
    {
        System.out.println("Log after method");
    }
}
//2.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"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>
//測試類不變，打印結果爲
CurrentTime = 1446130273734
Log before method
Enter HelloWorldImpl1.printHelloWorld()
Log after method
CurrentTime = 1446130273735

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl1.doPrint()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl2.printHelloWorld()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273737
Log before method
Enter HelloWorldImpl2.doPrint()
Log after method
CurrentTime = 1446130273737

//要想讓logHandler在timeHandler前使用有兩個辦法：
//（1）aspect裏面有一個order屬性，order屬性的數字就是橫切關注點的順序
//（2）把logHandler定義在timeHandler前面，Spring默認以aspect的定義順序作爲織入順序


//------------------------我只想織入接口中的某些方法-------------------------------//
//修改一下pointcut的expression就好了
<?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:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.print*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>
//表示timeHandler只會織入HelloWorld接口print開頭的方法，logHandler只會織入HelloWorld接口do開頭的方法
/**
強制使用CGLIB生成代理
前面說過Spring使用動態代理或是CGLIB生成代理是有規則的，高版本的Spring會自動選擇是使用動態代理還是CGLIB生成代理內容，當然我們也可以強制使用CGLIB生成代理，那就是<aop:config>裏面有一個"proxy-target-class"屬性，這個屬性值如果被設置爲true，那麼基於類的代理將起作用，如果proxy-target-class被設置爲false或者這個屬性被省略，那麼基於接口的代理將起作用
*/

實例說明spring三大核心思想

Spring的三大核心思想

IOC(控制反轉)：

DI(依賴注入)

AOP（面向切面編程）

用友軟件ERP5.7開發文檔整理

Map九大常見問題

jsp標籤遍歷之雙重List

實例說明spring三大核心思想

一張圖搞懂Spring bean的完整生命週期

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結