Spring---IoC（控制反轉）原理學習筆記【全】

靠譜楊發表於2021-10-31

1、IoC建立物件的方式

使用無參構造建立物件

假如要使用有參構造建立：

下標賦值constructor-arg

<!--有參-->
<bean id="User" class="com.reliable.pojo.User" >
    <constructor-arg index="0" value="靠譜楊"></constructor-arg>
</bean>

public User(String name){
		System.out.println("User的有參構造！");
		this.name=name;
	}

通過型別type="java.lang.String"

    <bean id="User" class="com.reliable.pojo.User" >
        <constructor-arg type="java.lang.String" value="靠譜楊"></constructor-arg>
    </bean>

通過引數名name="name" value="reliable"

    <bean id="User" class="com.reliable.pojo.User" >
        <constructor-arg name="name" value="reliable"></constructor-arg>
    </bean>

總結：在配置檔案載入的時候，Spring容器中管理的物件就已經初始化成功了！

2、Spring的配置

2.1、別名

    <!--別名-->
    <alias name="User" alias="new_user"></alias>

2.2、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">
    <!--
    型別 變數名 = new 型別();
    Hello hello = new Hello();

    bean就是java物件 , 由Spring建立和管理
    bean = 一個物件
    其中
    id = 變數名
    class = new的物件型別
    property相當於給物件裡的屬性設定一個值
    -->
    <bean id="Hello" class="com.reliable.pojo.Hello">
        <property name="name" value="Spring"/>
    </bean>
    <!-- 無參 -->
    <!--<bean id="User" class="com.reliable.pojo.User">-->
        <!--<property name="name" value="靠譜"></property>-->
    <!--</bean>-->
    <!--有參第一種，index-->
    <!--<bean id="User" class="com.reliable.pojo.User" >
        <constructor-arg index="0" value="靠譜楊"></constructor-arg>
    </bean>-->
    <!-- 2 型別-->
   <!-- <bean id="User" class="com.reliable.pojo.User" >
        <constructor-arg type="java.lang.String" value="靠譜楊"></constructor-arg>
    </bean>-->
    <!-- 3 引數名字 -->
    <bean id="User" class="com.reliable.pojo.User" >
        <constructor-arg name="name" value="User"></constructor-arg>
    </bean>
    <bean id="User1" class="com.reliable.pojo.User1">
        <constructor-arg name="name" value="User1"></constructor-arg>
    </bean>
    <!--別名 如果新增的別名 都可以使用-->
    <alias name="User" alias="new_user"></alias>
</beans>

2.3、import

一般用於團隊開發使用，可以將多個配置檔案匯入合併為一個

    <!--import -->
    <import resource="beans1.xml"></import>

3、依賴注入（DI）

3.1 構造器注入

依賴注入：Set注入
- 依賴：bean物件的建立依賴於容器
- 注入：bean物件中的所有屬性，由容器來注入！

3.2、Set方式注入【重點】

複雜型別

public class Address {
	private String address;
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}

實體物件

import java.util.*;

public class Student {
	public String getName() {
		return name;
	}

	public Address getAddress() {
		return address;
	}

	public String[] getBooks() {
		return books;
	}

	public List<String> getHobbies() {
		return hobbies;
	}

	public Map<String, String> getCard() {
		return card;
	}

	public Set<String> getGames() {
		return games;
	}

	public String getWife() {
		return wife;
	}

	public Properties getInfo() {
		return info;
	}
	private String name;
	private Address address;
	private String[] books;
	private List<String> hobbies;
	private Map<String,String> card;
	private Set<String> games;
	private String wife;
	private Properties info;
	public void setName(String name) {
		this.name = name;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	public void setBooks(String[] books) {
		this.books = books;
	}
	public void setHobbies(List<String> hobbies) {
		this.hobbies = hobbies;
	}
	public void setCard(Map<String, String> card) {
		this.card = card;
	}
	public void setGames(Set<String> games) {
		this.games = games;
	}
	public void setWife(String wife) {
		this.wife = wife;
	}
	public void setInfo(Properties info) {
		this.info = info;
	}

	@Override
	public String toString() {
		return "Student{" +
				"name='" + name + '\'' +
				", address=" + address +
				", books=" + Arrays.toString(books) +
				", hobbies=" + hobbies +
				", card=" + card +
				", games=" + games +
				", wife='" + wife + '\'' +
				", info=" + info +
				'}';
	}
	//show方法
	public void show(){
		System.out.println("name="+ name
				+ ",address="+ address.getAddress()
				+ ",books="
		);
		for (String book:books){
			System.out.print("<<"+book+">>\t");
		}
		System.out.println("\n愛好:"+ hobbies);
		System.out.println("card:"+card);
		System.out.println("games:"+games);
		System.out.println("wife:"+wife);
		System.out.println("info:"+info);
	}
}

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">
    <bean id="Address" class="com.kuang.pojo.Address">
        <property name="address" value="石家莊"></property>
    </bean>
    <bean id="Student" class="com.kuang.pojo.Student">
        <!-- 第一種：普通值注入 -->
        <property name="name" value="楊傳偉"></property>
        <!-- 第二種：ref注入 -->
        <property name="address" ref="Address"></property>
        <!-- 第三種：陣列注入 -->
        <property name="books">
            <array>
                <value>《紅樓夢》</value>
                <value>《西遊記》</value>
                <value>《水滸傳》</value>
                <value>《三國演義》</value>
            </array>
        </property>
        <!-- 第四種：List注入 -->
        <property name="hobbies">
            <list>
                <value>聽音樂</value>
                <value>看電影</value>
                <value>敲程式碼</value>
                <value>攝影</value>
            </list>
        </property>

        <!-- 第五種：Map注入 -->

        <property name="card">
            <map>
                <entry key="IDcard" value="1234567"></entry>
                <entry key="STcard" value="7654321"></entry>
            </map>
        </property>
        <!-- 第六種：Set注入 -->
        <property name="games">
            <set>
                <value>跑跑卡丁車官方競速版</value>
                <value>王者榮耀</value>
            </set>
        </property>

        <!-- 第七種：設定空值 -->
        <property name="wife">
            <null></null>
        </property>

        <!--properties-->
        <property name="info">
            <props>
                <prop key="學號">20194074</prop>
                <prop key="性別">男</prop>
                <prop key="姓名">楊傳偉</prop>
                <prop key="username">reliable</prop>
                <prop key="userpass">resetpass01</prop>
            </props>
        </property>
    </bean>
</beans>

3.3、擴充方式注入---使用p名稱空間和c名稱空間

使用：

package com.kuang.pojo;

public class User {
	private String name;
	private int age;

	public User(String name,int age) {
		this.name = name;
		this.age=age;
	}
	public User(){};
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

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

配置檔案：

<?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"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--P(屬性: properties)名稱空間 , 屬性依然要設定set方法-->
    <bean id="user" class="com.kuang.pojo.User" p:name="靠譜" p:age="21"/>
    <!--C(構造: Constructor)名稱空間 , 屬性依然要設定set方法-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="18"/>
</beans>

測試：

	public void test2(){
		ApplicationContext context=new ClassPathXmlApplicationContext("beans03.xml");
		User user = context.getBean("user", User.class);
		System.out.println(user);
		User user2 = context.getBean("user2", User.class);
		System.out.println(user2);
	}

注意

要引入c和p名稱空間：

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

4、bean的作用域

4.1、單例模式（default）

<bean id="accountService" class="com.something.DefaultAccountService"/>

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

4.2、原型模式：每次都產生一個新物件

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype">

4.3、request、session、application，web開發中使用

5、bean的自動裝配

自動裝配是Spring滿足Bean依賴的一種方式
- Spring自動在上下文尋找，裝配bean屬性

在Spring中有三種裝配方式

在xml中配置
在Java中配置
隱式自動裝配【重要】

5.1、自動裝配屬性

環境搭配：一個人有兩個寵物，一隻貓和一隻狗

思路：

三個實體類，均實現getter和setter，toString( ) 方法，在bean中配置

People類和貓、狗類有關聯關係，完成配置後例項化People類呼叫getDog( )方法呼叫Dog類的方法

<bean id="dog" class="com.kuang.pojo.Dog" p:dogname="狗"/>
    <bean id="cat" class="com.kuang.pojo.Cat" p:catname="貓"/>
    <bean id="people" class="com.kuang.pojo.People">
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
        <property name="str" value="***"/>

5.2、byName：

在容器上下文尋找，id和物件set方法的引數值對應，id全域性唯一

	public void setCat(Cat cat) {
		this.cat = cat;
	}

<bean id="dog" class="com.kuang.pojo.Dog" p:dogname="狗"/>
<bean id="cat" class="com.kuang.pojo.Cat" p:catname="貓"/>
<bean id="people" class="com.kuang.pojo.People" autowire="byName"></bean>

5.3、byType：

必須保證型別全域性唯一（class全域性唯一）這個bean需要和自動注入的屬性的型別一致

5.4、總結：

屬性：

	private Cat cat;
	private Dog dog1;

byName：類屬性的名字和bean的id名字保持一致，且id全域性唯一
byType：類屬性的資料型別和bean的class名字保持一致，且全域性唯一

6、註解實現自動裝配

```
@Autowired
```
```
public @interface Autowired {
    boolean required() default true;
}
```
Autowired（）可以傳一個引數，如果顯式定義了Autowired的required屬性為false，說明這個物件可以為NULL

直接在屬性上使用即可，也可以在set方法上使用!

使用Autowired可以不用編寫set方法，前提是這個自動裝配的屬性在IoC容器中存在，且id名字和屬性名字一致!

（Autowired 是先根據型別尋找，如果在IoC容器中發現了多個型別，則按名字尋找!）
```
	@Autowired
	private Cat cat;
	@Autowired
	private Dog dog;
```
***如果Autowired自動裝配的環境比較複雜，無法通過一個註解實現的時候，可以使用【@Qualifier（“ ”）】的方式給容器指定一個要使用的bean
```
    <bean id="dog2" class="com.kuang.pojo.Dog"></bean>
    <bean id="dog1" class="com.kuang.pojo.Dog"></bean>
```
```
	@Autowired
	@Qualifier("dog1")
	private Dog dog;
```
比如像上述這種情況：在bean中存在多個型別為Dog的物件，且找不到dog這個名字，這時候可以通過@Qualifier("dog1")制定使用容器中名字為dog1的那個bean來注入！

javax原生 @Resrouce（），首先尋找型別，再去尋找名字！

7、使用註解開發

在Spring4之後，要使用註解開發必須要匯入AOP包

匯入context約束，加入註解支援

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

    <context:annotation-config/>

</beans>

7.1、bean

@Component

一般放在類上，說明這個類被Spring託管了

7.2、屬性如何注入

package com.reliable.y;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//@Component 註解 這是一個元件
@Component
public class User {
	public String name;
	@Value("靠譜楊")
	public void setName(String name) {
		this.name = name;
	}
}

7.3、衍生的註解（放在類上）

@Component 有幾個衍生註解，我們在web開發中會按照MVC三成架構分層！

dao【@Repository】
service【@Service】
controller (servlet)【@Controller】

這四個註解功能是一樣的，都是程式碼把對應的類載入到容器中

7.4、自動裝配屬性（放在屬性上）

@Autowired：自動裝配通過型別名字，如果不能唯一裝配，則需要通過@Qualifier(value=“ xxx ”)制定id！

@Nullable：說明這個欄位可以為空!

@Resource：javax自動裝配型別名字!

7.5、作用域

@Component
@Scope("prototype")
public class User {
	public String name;
	@Value("靠譜楊")
	public void setName(String name) {
		this.name = name;
	}
}

7.6、小結

xml與註解：

xml適用面廣，維護簡單方便
註解不是自己的類是用不了的，維護相對複雜

xml與註解的最佳實踐：

xml管理bean，也就是xml檔案下只有一個個bean
註解負責值的注入@Value(“ xxx ”)

註解生效：

    <!--指定要掃描的包，這個包下面的註解就會生效-->
    <context:component-scan base-package="com.reliable"></context:component-scan>
    <context:annotation-config/>

8、使用Java的方式配置Spring

8.1、實體類：

package com.reliable.y;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//@Component 說明這個被被Spring接管，註冊到了容器中
@Component
public class User {
	private String name;
	@Override
	public String toString() {
		return "com.reliable.y.User{" +
				"name='" + name + '\'' +
				'}';
	}

	public String getName() {
		return name;
	}
	@Value("靠譜楊")
	public void setName(String name) {
		this.name = name;
	}
}

8.2、配置檔案類：

package com.reliable.config;
import com.reliable.y.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
//YConfig 也會被Spring託管
@Configuration
//@Configuration 代表這是一個配置類，就和之前看的beans.xml是一樣的
@ComponentScan("com.reliable")
public class YConfig {
	/*
	1.這裡註冊了一個bean，相當於一組bean標籤
	2.方法的名字相當於之前bean標籤裡的id
	3.方法的返回值相當於bean標籤中的class
	 */
	@Bean
	public User getUser(){
		return new User();  //要注入到bean的物件
	}
}

8.3、測試類：

import com.reliable.config.YConfig;
import com.reliable.y.User;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test06 {
	public static void main(String[] args) {
		//如果完全使用配置類方法去做，就要使用AnnotationConfigApplicationContext去獲取物件載入
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(YConfig.class);
		User user = (User) context.getBean("getUser");
		System.out.println(user.toString());
	}
}

三句話總結IoC：

所有的類都要放到bean中
每一個bean都是一個例項化的物件
所有的bean（物件）都要通過容器（ApplicationContext）去取

9、代理模式

代理模式是SpringAOP的底層！【SpringAOP和SpringMVC】

9.1、代理模式分類：

靜態代理
動態代理

9.2、角色分析

舉例：房東、中介、客戶、和租房這件事

抽象角色：一般會使用介面或者抽象類來實現（租房這件事就是一個抽象角色類或者介面）、

package com.reliable.y;
//租房
public interface Rent {
	public void rent();
}

真實角色：被代理的角色（房東）

package com.reliable.y;


public class Host implements Rent {
	public void rent() {
		System.out.println("房東要出租房子！");
	}
}

代理角色：代理真是角色處理一些事情的角色（中介）

package com.reliable.y;

public class Proxy implements Rent {
	private Host host;

	public Proxy(Host host) {
		this.host = host;
	}
	public Proxy(){}

	public void rent() {
		host.rent();
	}
	//看房
	public void seeHouse(){
		System.out.println("中介帶客戶看房子！");
	}
	//收中介費
	public void fare(){
		System.out.println("收中介費！");
	}
	//籤合同
	public void makeht(){
		System.out.println("籤合同！");
	}
}

客戶：訪問代理角色的角色

package com.reliable.y;

public class Client {
	public static void main(String[] args) {
		Host host = new Host();
		//代理角色一般會比真實角色多一些操作
		Proxy proxy = new Proxy(host);
		proxy.rent();
		proxy.seeHouse();
		proxy.fare();
		proxy.makeht();
	}
}

9.3、靜態代理模式的好處：

可以使真實角色的操作更加純粹，不需要去關注一些公共業務
公共業務交給了代理角色，實現了業務分工
公共業務發生擴充套件的時候，方便集中管理

靜態代理缺點：

一個真實角色就要產生一個代理角色，程式碼量大，開發效率變低

9.4、動態代理

和靜態代理角色一樣
動態代理類動態生成
分為兩類：基於介面的動態代理，基於類的動態代理
- 基於介面 --- JDK
- 基於類 --- cglib
- Java位元組碼 --- javasist

Rent介面

package com.reliable.demo1;
//抽象角色：租房
public interface Rent {
	public void rent();
}

真實角色：Host

package com.reliable.demo1;
//真實角色: 房東，房東要出租房子
public class Host implements Rent{
	public void rent() {
		System.out.println("房屋出租");
	}
}

動態獲取代理類：

package com.reliable.demo1;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

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);
	}
	// proxy : 代理類 method : 代理類的呼叫處理程式的方法物件.
	// 處理代理例項上的方法呼叫並返回結果
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		seeHouse();
		//核心：本質利用反射實現！
		Object result = method.invoke(rent, args);
		fare();
		return result;
	}
	//看房
	public void seeHouse(){
		System.out.println("帶房客看房");
	}
	//收中介費
	public void fare(){
		System.out.println("收中介費");
	}
}

測試呼叫類：

package com.reliable.demo1;
//租客
public class Client {
	public static void main(String[] args) {
		//真實角色
		Host host = new Host();
		//代理例項的呼叫處理程式
		ProxyInvocationHandler pih = new ProxyInvocationHandler();
		pih.setRent(host); //將真實角色放置進去！
		Rent proxy = (Rent)pih.getProxy(); //動態生成對應的代理類！
		proxy.rent();
	}
}

IoC（控制反轉）的理解筆記
2019-06-19
筆記
學習記錄-Laravel 核心依賴注入控制反轉反射
2019-08-08
Laravel依賴注入反射
《SQL 反模式》學習筆記
2020-04-19
SQL模式筆記
springmvc學習筆記（全）
2021-11-09
SpringMVC筆記
AQS原理學習筆記
2019-02-25
AQS筆記
synchronized原理學習筆記
2019-02-09
synchronized筆記
容斥原理學習筆記
2020-10-22
筆記
學習筆記詳解一種高效位反轉演算法
2020-10-01
筆記演算法
強化學習-學習筆記15 | 連續控制
2022-07-14
強化學習筆記
Swoft 學習筆記之控制器
2019-08-11
筆記
repuest轉發學習筆記一
2021-09-09
筆記
AD學習筆記----原理圖設計
2020-10-21
筆記
Python——格式轉換的學習筆記
2020-09-28
Python筆記
10g NewFeatures學習筆記(轉)
2019-06-23
筆記
比特幣學習筆記——————2、比特幣原理
2018-06-12
比特幣筆記
《通訊原理基礎》學習筆記（1）
2018-03-27
筆記
mysql學習筆記-底層原理詳解
2022-03-22
MySql筆記
Spring入門學習手冊 1：最簡單的反轉控制
2019-01-24
Spring
iOS學習筆記49 Swift(九)訪問控制
2018-06-02
iOS筆記Swift
iOS學習筆記——基礎控制元件（上）
2020-04-04
iOS筆記控制元件
<react學習筆記(9)>表單控制元件
2018-12-27
React筆記控制元件
全連線神經網路學習筆記
2021-11-28
神經網路筆記
人工智慧：原理與技術學習筆記
2024-11-15
人工智慧筆記
計算機組成原理學習筆記一
2020-12-15
計算機筆記
彙編學習筆記之轉移指令
2021-06-09
筆記
依賴倒轉原則--學習筆記
2020-11-27
筆記
numpy的學習筆記\pandas學習筆記
2018-03-18
筆記
集中式版本控制與分散式版本控制——Git 學習筆記01
2020-04-04
分散式Git筆記
Spring IOC--控制反轉
2018-07-16
Spring
網路學習筆記（二）：TCP可靠傳輸原理
2019-03-18
筆記TCP
學習筆記-React的簡單介紹&工作原理
2021-10-23
筆記React
學習筆記
2024-04-14
筆記
日誌庫 winston 的學習筆記 - logger.info 列印到控制檯上的實現原理
2021-10-27
筆記
iOS學習筆記07 運動事件和遠端控制
2018-06-02
iOS筆記事件
VBA 控制元件學習筆記（下拉選單實現）
2020-03-30
控制元件筆記
VBA 控制元件學習筆記（按鈕點選事件）
2020-03-30
控制元件筆記事件
Dubbo學習筆記(二) Dubbo 控制後臺的安裝
2018-04-13
筆記
MoveIt! 學習筆記2- MoveIt! Commander Scripting(命令列控制)
2020-12-28
筆記命令列