Spring---IoC（控制反转）原理学习笔记【全】

1、IoC创建对象的方式

1. 使用无参构造创建对象

2. 假如要使用有参构造创建：

   1. 下标赋值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;
      	}
      

   2. 通过类型type="java.lang.String"

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

   1. 通过参数名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中有三种装配方式

1. 在xml中配置
2. 在Java中配置
3. 隐式自动装配【重要】

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：

1. 所有的类都要放到bean中
2. 每一个bean都是一个实例化的对象
3. 所有的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();
	}
}