2：SpringIOC

一：Spring_IOC概念引入_重要

简单的说就是,创建对象的权利,或者是控制的位置,由JAVA代码转移到spring容器,由spring的容器控制对象的创建,就是控制反转,spring创建对象时,会读取配置文件中的信息,然后使用反射给我们创建好对象之后在容器中存储起来,当我们需要某个对象时,通过id获取对象即可,不需要我们自己去new.

一句话:创建对象交给容器

1：Spring解耦合的原理

图解

Spring IOC（控制反转）是 Spring 框架的一个关键概念，它是指将对象的创建和依赖关系的管理从应用程序代码中转移到框架中进行管理的过程。

想象一下，当我们在应用程序中使用对象时，通常会直接使用 new 关键字来创建对象，并在代码中处理对象之间的依赖关系。这意味着应用程序负责创建和管理对象。

然而，在使用 Spring IOC 时，控制权发生了转变。相反，我们告诉 Spring 框架我们需要哪些对象，而不是直接创建它们。Spring 框架负责创建对象，并且还负责解决对象之间的依赖关系。这种控制权的转移称为控制反转。

具体来说，Spring IOC 的实现方式是通过依赖注入（Dependency Injection）来实现的。在依赖注入中，对象的依赖关系是通过将依赖项传递给对象的构造函数、属性或者方法来解决的。这样，对象不再需要自己创建或者查找它们所依赖的对象，而是通过框架来提供它们。

下面举一个简单的例子来说明 Spring IOC 的概念。假设我们有一个名为 UserService 的类，它依赖于 UserDao 接口来进行数据库操作。在传统的方式下，我们可能会在 UserService 类中创建一个 UserDao 对象，如下所示：

javaCopy codepublic class UserService {
    private UserDao userDao = new UserDao();

    // 使用userDao进行数据库操作
    // ...
}

而在使用 Spring IOC 的方式下，我们可以使用依赖注入来解决对象的依赖关系。我们只需在 UserService 类中声明一个成员变量 UserDao，并在需要使用它的地方将其注入进来：

javaCopy codepublic class UserService {
    private UserDao userDao;

    // 使用setter方法进行依赖注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    // 使用userDao进行数据库操作
    // ...
}

在配置文件或者使用注解的方式下，我们可以告诉 Spring 框架将一个实现了 UserDao 接口的对象注入到 UserService 类中。这样，我们就将对象的创建和依赖关系的管理交给了 Spring 框架，实现了控制反转。

通过使用 Spring IOC，我们的代码变得更加灵活、可测试和可维护。我们可以更方便地切换对象的实现，而不需要修改依赖该对象的代码。此外，由于对象的创建和管理由框架负责，我们可以集中精力关注业务逻辑的实现，而不必过多关注对象的创建和依赖关系的管理。

总结：

spring IOC(控制反转) 主要指的是将对象的创建以及对象之间关系的依赖由原先的程序代码层转移到spring框架，这些任务交给框架来完成。这样带来的优点是不需要重复的创建对象，以及过度考虑对象之间的依赖关系，简化代码，让代码更灵活，可测试，可维护。

2：创建一个spring项目并实现IOC基本功能

创建maven项目,设置maven

先创建一个空项目

名字可以是spring_all

在项目下创建模块 名字可以是spring_test_01

pom.xml中导入spring依赖

1.      <dependencies>
2.          <dependency>
3.              <groupId>org.springframeworkgroupId>
4.              <artifactId>spring-coreartifactId>
5.              <version>5.3.5version>
6.          dependency>
7.   
8.          <dependency>
9.              <groupId>org.springframeworkgroupId>
10.            <artifactId>spring-beansartifactId>
11.            <version>5.3.5version>
12.        dependency>
13. 
14.        <dependency>
15.            <groupId>org.springframeworkgroupId>
16.            <artifactId>spring-contextartifactId>
17.            <version>5.3.5version>
18.        dependency>
19. 
20.        <dependency>
21.            <groupId>org.springframeworkgroupId>
22.            <artifactId>spring-expressionartifactId>
23.            <version>5.3.5version>
24.        dependency>
25. 
26.    dependencies>

四个依赖介绍

spring-context 上下文,容器

spring-beans 创建对象

spring-core 核心jar

spring-expression 表达式jar

但是事实上,我们导入spring-context的时候,会自动导入其他依赖的jar,自动进行了依赖传递

所以,导入一个spring-context 依赖也可以

依赖传递关系图如下

为了方便测试,我们导入Junit测试依赖

1.          <dependency>
2.              <groupId>junitgroupId>
3.              <artifactId>junitartifactId>
4.              <version>4.13.1version>
5.              <scope>testscope>
6.          dependency> 

在项目中定义一个接口和实现类

EmpDao接口和实现类

接口中定义一个方法并在实现类中实现

接口

实现类

在spring配置容器中的对象

创建spring配置文件

文件名没有明确要求,暂时可以叫spring

在spring.xml中配置一个需要由容器初始化的对象

<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="EmpDaoimpl" class="com.springIOC.Dao.impl.EmpDaoimpl">bean>

beans>

测试通过容器获取对象

package com.springIOC.Dao.test;

import com.springIOC.Dao.EmpDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test1 {
    @Test
    //通过容器来获取对象。
    public void testGetBean() {
        //获取一个容器对象，并读取spring.xml文件，实例化配置文件中的对象后自动放入容器中。
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //通过id从容器中获取对应的对象。
        EmpDao emptDao = (EmpDao) applicationContext.getBean("EmpDaoimpl");
        //第二种写法，后面的EmpDao.class的作用是告诉EmpDaoimpl所对应的值要强转成EmpDao类型。
        EmpDao empDaoimpl = applicationContext.getBean("EmpDaoimpl", EmpDao.class);
        //调用对象的方法。
        emptDao.addEmp();
    }
}

二：Spring_IOC原理分析 ***

IOC底层原理

1：XML解析技术读取配置文件

1.  <bean id="empDao" class="com.msb.dao.impl.EmpDaoImpl">bean>

将上面的信息读取进入程序 对象的ID ,一个是对象的类的全路径名

2：反射技术实例化对象,放到容器中

获得类的字节码

Class clazz =Class.forName("com.msb.dao.impl.EmpDaoImpl") 

通过字节码实例化对象

Object obj  = clazz.newInstance(); 

将对象放到一个map集合中

map.put(“empDao”,obj)

3：工厂模式返回Bean对象 getBean方法

public Object getBean(String name){
 Object obj =map.get(name); 
 return obj; 
}   

解释一下IOC接口

BeanFactory 接口: IOC容器基本功能接口,是spring内部使用的接口,我们在处理业务时一般不直接使用该接口

ApplicationContext 接口: BeanFactory的子接口,提供更多更强大的功能,研发人员一般使用的接口

查看当前接口/类下的实现类/接口 – 快捷键：CTRL + H

解释一下工厂模式

工厂模式是一种软件设计模式，它提供了一种创建对象的方法，使得客户端代码与具体对象的创建过程分离，从而提高代码的可维护性和灵活性。

想象一下你正在建造一座房子，需要安装门。你可以自己亲自去制作门，但这样做会非常耗时和复杂。相反，你可以雇佣一个门厂来制造门并交付给你。在这个例子中，门厂就是一个工厂，它负责制造门的过程，而你作为客户端只需告诉门厂你需要什么类型的门，并接收到制造好的门。

在软件开发中，工厂模式也是类似的。它定义了一个工厂类，负责创建对象，而客户端只需调用工厂类的方法，传递相应的参数，就可以获取到所需的对象。这样，客户端不需要关心具体对象的创建细节，只需与工厂类进行交互。

举个例子，假设你正在开发一个电商网站，需要根据用户选择的产品类型创建相应的产品对象。你可以使用工厂模式来实现。首先，你创建一个抽象的产品类，定义了产品的共同属性和方法。然后，创建具体的产品类，继承自抽象产品类，实现各自的特定功能。接下来，你创建一个工厂类，该工厂类有一个方法，根据用户选择的产品类型来创建相应的产品对象，并将其返回给客户端。

客户端只需调用工厂类的方法，传递用户选择的产品类型，工厂类会根据选择创建相应的产品对象，然后将其返回给客户端使用。这样，客户端不需要知道具体产品对象的创建过程，只需与工厂类进行交互，就能获取到所需的产品对象。

工厂模式使得对象的创建与使用分离，提供了一种灵活的方式来创建对象，并且在需要添加新的产品类型时，只需新增相应的产品类和对应的工厂方法，而不需要修改客户端代码，从而提高了代码的可维护性和扩展性。

总结：工厂模式主要是将创建对象的过程与使用对象分离开。工厂类专门负责创建对象，客户端只需调用工厂类的具体方法，传入参数即可得到想要的对象。客户端不用关系对象的创建过程，只需要与工厂进行交互。

三：spring中的Bean的管理:

Bean(汉译咖啡豆). 又称JAVABean.其实就是JAVA程序程序中的一个个对象,所以Bean的管理其实就是spring对于JAVA程序中的对象的管理

1：管理的内容是什么

（1）对象的创建 IOC

IOC 叫做控制反转,就是Spring给我们创建对象,然后我们直接用,不用自己NEW,前面已经解释过

IOC处理的是对象如何创建的问题

（2） 属性的赋值 DI

DI Dependency Injection，即“依赖注入” 就是创建属性时给对象属性赋值

对象功能的实现往往要依赖属性的值,那么给对象属性赋值就可以说成是依赖注入

由于对象属性不仅仅是基本数据类型,还可能是其他类,或者引用类型

那么依赖注入将会把更多的对象之间的关系整理到一起,可以行程一个庞大的依赖关系

DI处理的是对象的属性赋值和互相依赖的关系

2：spring提供了两种管理bean的方式

（1）基于XML方式的Bean管理

（2） 基于注解方式的Bean管理

小案例：

创建新的模块并导入以下依赖

依赖

1.          <dependency>
2.              <groupId>org.springframeworkgroupId>
3.              <artifactId>spring-contextartifactId>
4.              <version>5.3.5version>
5.          dependency>
6.   
7.          <dependency>
8.              <groupId>junitgroupId>
9.              <artifactId>junitartifactId>
10.            <version>4.13.1version>
11.            <scope>testscope>
12.        dependency>

创建spring配置文件,一般spring的配置文件很多人约定俗称为application****.xml

准备一个要实例化的类

package com.spring.bean;

public class User {
    private Integer userid;
    private String username;
    private String password;

    public Integer getUserid() {
        return userid;
    }

    public void setUserid(Integer userid) {
        this.userid = userid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "userid=" + userid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public User() {
        System.out.println("无参构造器");
    }

    public User(Integer userid, String username, String password) {
        System.out.println("有参构造器");
        this.password = password;
        this.userid = userid;
        this.username = username;
    }
}

IOC创建对象

通过无参构造方法构造对象

1.  <bean id="user1" class="com.msb.bean.User">bean>

标签的常见属性

1.  <bean id="user1" class="com.msb.bean.User" name="user1" scope="prototype" lazy-init="true" >bean>

id 对象的id

class 类的全路径名

name 和id类似,一般不用

scope 控制对象单例多例和使用范围

		singleton作用域(scope 默认值), Spring IOC容器中只会存在一个共享的bean实例 / 单例模式

		prototype作用域部署的bean，每一次获取都会产生一个新的bean实例，相当与一个new的操作 

		request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效 

		session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效 

		global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义 

lazy-init 懒加载 调用getBean的时候再去实例化对象

注意：

1：scope为prototype时，也不会当即创建对象和懒加载一样，getBean的时候才会创建两个不同的对象。

2：prototype作用域是多例，每次获取bean都会产生一个新的示例，并且这个实例时通过原型模式的深拷贝来实现的，

而懒加载，仅针对单实例bean生效。

3：在Spring 中，当 bean定义了 scope=session属性时，表示该 bean的作用域为 session，即在同一个HTTP会话中，该bean只会被创建一次，在这个HTTP会话期间，不论有多少个HTTP请求，都会共享同一个bean实例。获取scope =session的bean时，需要通过spring容器来获取。

ID是不可以相同的，但是同一个ID可以指向同一个对象