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

1、IoC創建物件的方式

使用無參構造創建物件

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

下標賦值constructor-arg

<!--有參-->
<bean id="User"  >
    <constructor-arg index="0" value="https://www.cnblogs.com/rainbow-1/p/靠譜楊"></constructor-arg>
</bean>

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

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

    <bean id="User"  >
        <constructor-arg type="java.lang.String" value="https://www.cnblogs.com/rainbow-1/p/靠譜楊"></constructor-arg>
    </bean>

通過引數名name="name" value="https://www.cnblogs.com/rainbow-1/p/reliable"

    <bean id="User"  >
        <constructor-arg name="name" value="https://www.cnblogs.com/rainbow-1/p/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" >
        <property name="name" value="https://www.cnblogs.com/rainbow-1/p/Spring"/>
    </bean>
    <!-- 無參 -->
    <!--<bean id="User" >-->
        <!--<property name="name" value="https://www.cnblogs.com/rainbow-1/p/靠譜"></property>-->
    <!--</bean>-->
    <!--有參第一種，index-->
    <!--<bean id="User"  >
        <constructor-arg index="0" value="https://www.cnblogs.com/rainbow-1/p/靠譜楊"></constructor-arg>
    </bean>-->
    <!-- 2 型別-->
   <!-- <bean id="User"  >
        <constructor-arg type="java.lang.String" value="https://www.cnblogs.com/rainbow-1/p/靠譜楊"></constructor-arg>
    </bean>-->
    <!-- 3 引數名字 -->
    <bean id="User"  >
        <constructor-arg name="name" value="https://www.cnblogs.com/rainbow-1/p/User"></constructor-arg>
    </bean>
    <bean id="User1" >
        <constructor-arg name="name" value="https://www.cnblogs.com/rainbow-1/p/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" >
        <property name="address" value="https://www.cnblogs.com/rainbow-1/p/石家莊"></property>
    </bean>
    <bean id="Student" >
        <!-- 第一種：普通值注入 -->
        <property name="name" value="https://www.cnblogs.com/rainbow-1/p/楊傳偉"></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="https://www.cnblogs.com/rainbow-1/p/1234567"></entry>
                <entry key="STcard" value="https://www.cnblogs.com/rainbow-1/p/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"  p:name="靠譜" p:age="21"/>
    <!--C(構造: Constructor)命名空間 , 屬性依然要設定set方法-->
    <bean id="user2"  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" />

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

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

<bean id="accountService"  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"  p:dogname="狗"/>
    <bean id="cat"  p:catname="貓"/>
    <bean id="people" >
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
        <property name="str" value="https://www.cnblogs.com/rainbow-1/p/***"/>

5.2、byName：

在容器背景關系尋找，id和物件set方法的引數值對應，id全域唯一

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

<bean id="dog"  p:dogname="狗"/>
<bean id="cat"  p:catname="貓"/>
<bean id="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" ></bean>
    <bean id="dog1" ></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=https://www.cnblogs.com/rainbow-1/p/“ 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();
	}
}

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

標籤：面向對象

上一篇：在字符級別對單詞串列進行編碼

下一篇：架構師之路-redis集群決議