Spring两大核心思想之IOC：解耦思路，控制反转IOC，依赖注入DI，Bean的管理

最新推荐文章于 2024-01-04 21:11:42 发布

CodeMonkey-D

最新推荐文章于 2024-01-04 21:11:42 发布

阅读量288

点赞数 3

分类专栏： Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/HakerDONG/article/details/134046566

版权

Spring 专栏收录该内容

3 篇文章 1 订阅

订阅专栏

Spring介绍

Spring是什么：

Spring 是分层的 Java SE/EE 应⽤ full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：⾯向切⾯编程）为内核，提供了展现层Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应⽤技术，还能整合开源世界众多著名的第三⽅框架和类库，逐渐成为使⽤最多的 Java EE 企业应⽤开源框架
Spring的优势
1. 方便解耦，简化开发
  
  通过 Spring 提供的 IoC 容器，可以将对象间的依赖关系交由 Spring 进⾏控制，避免硬编码所造成的过度程序耦合。⽤户也不必再为单例模式类、属性⽂件解析等这些很底层的需求编写代码，可以更专注于上层的应⽤
2. AOP 编程的⽀持
  
  通过 Spring 的 AOP 功能，⽅便进⾏⾯向切⾯的编程，许多不容易⽤传统 OOP 实现的功能可以通过 AOP 轻松应付
3. 声明式事务的⽀持
  
  可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式⽅式灵活的进⾏事务的管理，提⾼开发效率和质量
4. ⽅便程序的测试
  
  可以⽤⾮容器依赖的编程⽅式进⾏⼏乎所有的测试⼯作，测试不再是昂贵的操作，⽽是随⼿可做的事情
5. ⽅便集成各种优秀框架
  
  Spring 可以降低各种框架的使⽤难度，提供了对各种优秀框架（SpringMVC、Mybatis、Hessian、Quartz 等）的直接⽀持
6. 降低 JavaEE API 的使⽤难度
  
  Spring 对 JavaEE API（如 JDBC、JavaMail、远程调⽤等）进⾏了薄薄的封装层，使这些API 的使⽤难度⼤为降低
7. Java 源码是经典学习范例
  
  Spring 的源代码设计精妙、结构清晰、匠⼼独⽤，处处体现着⼤师对 Java 设计模式灵活运⽤以及对 Java 技术的⾼深造诣。它的源代码⽆意是 Java 技术的最佳实践的范例
Spring的体系结构
Spring的生态系统

在这里插入图片描述

Spring IOC容器

IOC名词解释，作用是解耦，使用IOC容器管理项目组件之间的耦合关系是Spring框架的核心思想之一，主要用于解耦。IOC是指将创建对象的控制权转移给Spring框架进行管理。由Spring框架根据配置文件或注解等方式，创建bean对象并管理各个bean对象之间的依赖关系。使对象之间形成松散耦合的关系，实现解耦；
○ 控制：指的是对象创建（实例化、管理）的权力
○ 反转：控制权交给外部环境（Spring框架、IoC容器）

IOC的概念和作用

程序的耦合

耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接⼝的复杂性、调⽤模块的⽅式以及通过界⾯传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调⽤关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独⽴性越差( 降低耦合性，可以提⾼其独⽴性)。耦合性存在于各个领域，⽽⾮软件设计中独有的，但是我们只讨论软件⼯程中的耦合。在软件⼯程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越⾼，维护成本越⾼。因此对象的设计应使类和构件之间的耦合最⼩。软件设计中通常⽤耦合度和内聚度作为衡量模块独⽴程度的标准。 划分模块的⼀个准则就是⾼内聚低耦合

分类如下

内容耦合，当⼀个模块直接修改或操作另⼀个模块的数据时，或⼀个模块不通过正常⼊⼝⽽转⼊另⼀个模块时，这样的耦合被称为内容耦合。内容耦合是最⾼程度的耦合，应该避免使⽤之
公共耦合，两个或两个以上的模块共同引⽤⼀个全局数据项，这种耦合被称为公共耦合。在具有⼤量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了⼀个特定的值是⼗分困难的
外部耦合，⼀组模块都访问同⼀全局简单变量⽽不是同⼀全局数据结构，⽽且不是通过参数表传递该全局变量的信息，则称之为外部耦合
控制耦合，⼀个模块通过接⼝向另⼀个模块传递⼀个控制信号，接受信号的模块根据信号值⽽进⾏适当的动作，这种耦合被称为控制耦合
标记耦合，若⼀个模块 A 通过接⼝向两个模块 B 和 C 传递⼀个公共参数，那么称模块 B和 C 之间存在⼀个标记耦合
数据耦合，模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的⼀种耦合形式，系统中⼀般都存在这种类型的耦合，因为为了完成⼀些有意义的功能，往往需要将某些模块的输出数据作为另⼀些模块的输⼊数据
⾮直接耦合，两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调⽤来实现的

总结：

耦合是影响软件复杂程度和设计质量的⼀个重要因素，在设计上我们应采⽤以下原则：如果模块间必须存在耦合，就尽量使⽤数据耦合，少⽤控制耦合，限制公共耦合的范围，尽量避免使⽤内容耦合

解耦思路

案例：以耦合度逐步降低的⽅式实现JDBC连接数据库操作

耦合度高

DriverManager.registerDriver(new com.mysql.cj.jdbc.Driver());
Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool?serverTimezone=GMT", "root", "123456");
System.out.println(root);

耦合度中，通过反射的方式降低了耦合度

Class.forName("com.mysql.jdbc.Driver");
Connection root = DriverManager.getConnection("jdbc:mysql://localhost:3306/myschool?serverTimezone=GMT", "root", "123456");
System.out.println(root);

耦合度低，通过写properties文件降低耦合度

//1.创建工具类
Properties properties = new Properties();
//2.加载文件
InputStream stream = Test.class.getClassLoader().getResourceAsStream("jdbc.properties");
properties.load(stream);
//3.通过key获取value
String driver = properties.getProperty("driver");
String url = properties.getProperty("url");
String root = properties.getProperty("username");
String password = properties.getProperty("password");

Class.forName(driver);
Connection connection = DriverManager.getConnection(url, root, password);
System.out.println(connection);

工厂模式解耦

案例：以解耦⽅式维护三层之间的依赖关系

把三层的对象都使⽤配置⽂件配置起来，当启动服务器应⽤加载的时候，让⼀个类中的⽅法通过读取配置⽂件，把这些对象创建出来并存起来。在接下来的使⽤的时候，直接拿过来⽤就好了。那么，这个读取配置⽂件，创建和获取三层对象的类就是⼯⼚

耦合度强

在调用的地方直接new对象，耦合度高

IUserController接口

public interface IUserController {
    public void save();
}

UserControllerImpl实现类

public class UserControllerImpl implements  IUserController{
   	//耦合度强
    IUserService is =  new UserServiceImpl();
    @Override
    public void save() {
        System.out.println("controller层保存");
        is.save();
    }
}

IUserService接口

public interface IUserService {
    public void save();
}

UserServiceImpl实现类

public class UserServiceImpl implements IUserService {
    //耦合度强
	IUserDao iud = new UserDaoImpl();
    IUserDao iud = (IUserDao) BeansFactory.getBean("dao");
    @Override
    public void save() {
        System.out.println("service层新增");
        iud.save();
    }
}

IUserDao接口

public interface IUserDao {
    public void save();
}

UserDaoImpl实现类

public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("dao层新增");
    }
}

Test测试类

public class Test01 {
    public static void main(String[] args) {
        UserControllerImpl uc = new UserControllerImpl();
        uc.save();
    }
}

输出结果

controller层保存
service层新增
dao层新增

耦合度弱

通过写properties资源文件的方式降低耦合度，再将new对象替换为工厂模式创造对象

新增beans.propertie文件

dao=com.dong.dao.UserDaoImpl
service=com.dong.service.UserServiceImpl

创建工厂

public class BeansFactory {

    static Properties properties = null;

    static{
        try {
            properties = new Properties();
            InputStream s = BeansFactory.class.getClassLoader().getResourceAsStream("beans.properties");
            properties.load(s);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Object getBean(String key){
        try {
            String path = properties.getProperty(key);
            Object o = Class.forName(path).newInstance();
            return o;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

将所有new对象改为工厂模式，降低耦合

UserControllerImpl

public class UserControllerImpl implements  IUserController{
	// 耦合度弱
	UserServiceImpl is = 	 (UserServiceImpl)BeansFactory.getBean("service");

    @Override
    public void save() {
        System.out.println("controller层保存");
        is.save();
    }
}

UserServiceImpl

public class UserServiceImpl implements IUserService {
    // 耦合度弱
    IUserDao iud = (IUserDao) BeansFactory.getBean("dao");
    @Override
    public void save() {
        System.out.println("service层新增");
        iud.save();
    }
}

UserDaoImpl中没有调用不需要改变

小结：

上述通过properties资源文件和工厂模式降低了耦合
我们在获取对象时，都是采⽤ new 的⽅式，是主动的，而工厂模式是我们获取对象时，同时跟⼯⼚要，有⼯⼚为我们查找或者创建对象，是被动的

控制反转 IOC(Inversion of Control)

上述被动接收的⽅式获取对象的思想就是控制反转，它是 spring 框架的核⼼之⼀
控制反转概念：

控制反转(Inversion of Control,缩写为loC),是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入(Dependency Injection,简称Dl),还有一种方式叫“依赖查找”(DependencyLookup)。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

SpringIOC控制反转(DI依赖注入)
IOC控制反转：解耦，搭建IOC容器（spring容器），让容器进行解耦的方式创建对象

Spring IOC解决程序耦合

实现步骤：

环境搭建，pom.xml文件导入坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.29</version>
</dependency>

主配置文件，resorces下新建Spring Config模板xml文件

(坐标下载后才会有Spring Config模板）

<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">
    
</beans>

创建JavaBean

例如现在已有UserControllerImpl,UserServiceImpl,UserDaoImpl等类
将JavaBean对象注入到spring容器里

在主配置文件中添加<bean></bean>标签注入容器，需要写在<beans></beans>之间
```
<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>

<bean id="service" class="com.dong.service.UserServiceImpl"></bean>

<bean id="date" class="java.util.Date"></bean>
```
语法：<bean id="唯一标识" class="注入类的完全限定名称"></bean>

可以注入所有Bean，如Date

加载spring容器获取核心对象，获取实例

// 1.加载核心对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
// 2.获取实例
IUserDao dao = (IUserDao) applicationContext.getBean("dao");
dao.save();

IUserService service = (IUserService)applicationContext.getBean("service");
service.save();

Date date = (Date) applicationContext.getBean("date");
System.out.println(date);

核心对象：

ClassPathXmlApplicationContext========》通过相对路径加载主配置文件☆
FileSystemXmlApplicationContext=======》通过绝对路径加载主配置文件
AnnotationConfigApplicationContext====》通过相对路径加载配置类☆

getBean(id)：getBean方法中获取对象所填参数是配置文件中bean标签中的id

输入结果

dao层新增
service层新增
Tue Oct 24 21:50:52 CST 2023

基于XML的IOC细节

Spring中工厂的类结构图

在这里插入图片描述

BeanFactory 和 ApplicationContext 的区别
1. BeanFactory 才是 Spring 容器中的顶层接⼝，ApplicationContext 是它的⼦接⼝。
  
  BeanFactory 是多例模式
2. ApplicationContext：只要⼀读取配置⽂件，默认情况下就会创建对象。
  
  ApplicationContext是单例模式
3. BeanFactory：什么使⽤什么时候创建对象。
单例模式和多例模式
1. 单例模式：有且只有第一次创建对象，第二次只获取不创建，性能好，不安全
2. 多例模式：每次都创建对象，性能不好，但是安全

Spring DI依赖注入

DI：依赖注入，是对IOC概念的不同角度的描述，是指应用程序在运行时，每一个bean对象都依赖IOC容器注入当前bean对象所需要的另外一个bean对象。（例如在MyBatis整合Spring时，SqlSessionFactoryBean依赖IOC容器注入一个 DataSource数据源bean）

DI实现方式
1. 构造注入(通过构造方法进行粘合)
2. set注入(通过set方法进行粘合)
3. 注解注入(通过注解实现粘合)
DI数据类型
1. 注入基本数据类型与String
2. 注入javaBean
3. 注入复杂类型**（构造注入不支持）**
DI实现思路
1. 明确注入方式；明确注入数据类型
2. 提供对应的方法（构造，set）方法
3. 主配置文件中配置

构造注入

构造注入需要提供构造方法

例如：现有一个Student类，并且提供了构造方法

public class Student {
    private String sname;
    private int sage;

    public Student(String sname, int sage) {
        this.sname = sname;
        this.sage = sage;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sname='" + sname + '\'' +
                ", sage=" + sage +
                '}';
    }
}

在主配置文件applicationConfig.xml中注入bean

<bean id="student1" class="com.dong.bean.Student">
    <constructor-arg name="sname" value="董健翔"></constructor-arg>
    <constructor-arg name="sage" value="22"></constructor-arg>
</bean>

<bean id="student2" class="com.dong.bean.Student">
    <constructor-arg index="0" value="董健翔"></constructor-arg>
    <constructor-arg index="1" value="22"></constructor-arg>
</bean>

<bean id="student3" class="com.dong.bean.Student">
    <constructor-arg type="java.lang.String" value="董健翔"></constructor-arg>
    <constructor-arg type="int" value="22"></constructor-arg>
</bean>

<constructor-arg 属性名="属性值"></constructor-arg>

属性名：name=======>参数名
index======>参数索引
type=======>参数类型
value======>参数具体数据
ref========>参数数据的引用

获取实例：

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
        Student student1 = (Student) applicationContext.getBean("student1");
        System.out.println(student1);

        Student student2 = (Student) applicationContext.getBean("student2");
        System.out.println(student2);

        Student student3 = (Student) applicationContext.getBean("student3");
        System.out.println(student3);
    }
}

输出结果：

Student{sname='董健翔', sage=22}
Student{sname='董健翔', sage=22}
Student{sname='董健翔', sage=22}

案例二：UserControllerImpl、UserServiceImpl、UserDaoImpl

提供构造方法

UserControllerImpl中提供构造方法

public class UserControllerImpl implements  IUserController{
    UserServiceImpl is;

    public UserControllerImpl(UserServiceImpl is) {
        this.is = is;
    }

    @Override
    public void save() {
        System.out.println("controller层保存");
        is.save();
    }
}

UserServiceImpl中提供构造方法

public class UserServiceImpl implements IUserService {
    IUserDao iud;
    public UserServiceImpl(IUserDao iud) {
        this.iud = iud;
    }

    @Override
    public void save() {
        System.out.println("service层新增");
        iud.save();
    }
}

主配置文件中注入bean

<bean id="controller" class="com.dong.controller.UserControllerImpl">
    <constructor-arg name="is" ref="service"></constructor-arg>
</bean>

<bean id="service" class="com.dong.service.UserServiceImpl">
    <constructor-arg name="iud" ref="dao"></constructor-arg>
</bean>

<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>

ref引用需要注入的bean的id即可

获取实例

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        IUserController controller = (IUserController) applicationContext.getBean("controller");
        controller.save();
    }

}

输出结果

controller层保存
service层新增
dao层新增

set注入

set注入需要提供set方法

set注入基本类型&JavaBean

案例：UserControllerImpl、UserServiceImpl、UserDaoImpl

UserControllerImpl

public class UserControllerImpl implements  IUserController{
    UserServiceImpl is ;

    public void setIs(UserServiceImpl is) {
        this.is = is;
    }

    @Override
    public void save() {
        System.out.println("controller层保存");
        is.save();
    }
}

UserServiceImpl

public class UserServiceImpl implements IUserService {

    IUserDao iud;
    public void setIud(IUserDao iud) {
        this.iud = iud;
    }
    @Override
    public void save() {
        System.out.println("service层新增");
        iud.save();
    }
}

在主配置文件中注入bean

<bean id="controller" class="com.dong.controller.UserControllerImpl">
    <property name="is" ref="service"></property>
</bean>

<bean id="service" class="com.dong.service.UserServiceImpl">
    <property name="iud" ref="dao"></property>
</bean>

<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>

获取实例

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
        IUserController controller = (IUserController) applicationContext.getBean("controller");
        controller.save();
    }
}

输出结果：

controller层保存
service层新增
dao层新增

set注入复杂数据类型

复杂数据类型共五种：List，set，String[]，map，Properties

案例：现有一个Teacher类，有五种复杂数据类型，并且提供了set方法

public class Teacher {
    private List mylist;
    private Set myset;
    private Map mymap;
    private String[] myarr;
    private Properties pop;

    @Override
    public String toString() {
        return "Teacher{" +
                "mylist=" + mylist +
                ", myset=" + myset +
                ", mymap=" + mymap +
                ", myarr=" + Arrays.toString(myarr) +
                ", pop=" + pop +
                '}';
    }

    public void setMylist(List mylist) {
        this.mylist = mylist;
    }

    public void setMyset(Set myset) {
        this.myset = myset;
    }

    public void setMymap(Map mymap) {
        this.mymap = mymap;
    }

    public void setMyarr(String[] myarr) {
        this.myarr = myarr;
    }

    public void setPop(Properties pop) {
        this.pop = pop;
    }
}

主配置文件中注入bean，结构如下：

<bean id="teacher" class="com.dong.bean.Teacher">
    <property name="mylist">
        <list>
            <value>奔驰</value>
            <value>宝马</value>
            <value>福特</value>
            <value>理想</value>
        </list>
    </property>
    <property name="myset">
        <set>
            <value>辽宁丹东</value>
            <value>陕西西安</value>
            <value>山东菏泽</value>
            <value>辽宁大连</value>
        </set>
    </property>
    <property name="myarr">
        <array>
            <value>辽宁舰</value>
            <value>山东舰</value>
            <value>福建舰</value>
        </array>
    </property>
    <property name="mymap">
        <map>
            <entry key="日产" value="GTR"></entry>
            <entry key="福特猛禽" value="霸王龙"></entry>
            <entry key="奔驰" value="AMG"></entry>
        </map>
    </property>
    <property name="pop">
        <props>
            <prop key="辽宁">沈阳</prop>
            <prop key="陕西">西安</prop>
            <prop key="吉林">长春</prop>
            <prop key="黑龙江">哈尔滨</prop>
        </props>
    </property>
</bean>

获取实例：

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
        Teacher teacher = (Teacher) applicationContext.getBean("teacher");
        System.out.println(teacher);
    }
}

输出结果：

Teacher{mylist=[奔驰, 宝马, 福特, 理想], 
myset=[辽宁丹东, 陕西西安, 山东菏泽, 辽宁大连], 
mymap={日产=GTR, 福特猛禽=霸王龙, 奔驰=AMG}, 
myarr=[辽宁舰, 山东舰, 福建舰], 
pop={黑龙江=哈尔滨, 陕西=西安, 吉林=长春, 辽宁=沈阳}}

Bean容器对Bean的管理

Spring对于bean实例化的管理

默认情况下调用类的无参构造方法进行

Teacher类无参构造方法中有一句打印

public class Teacher{
    private String tname;
    public Teacher() {
        System.out.println("teacher无参构造");
    }
}

主配置文件注入Bean

<bean id="teacher" class="com.dong.bean.Teacher" >

获取实例

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
		Teacher teacher = (Teacher)                  				                             applicationContext.getBean("teacher");
        System.out.println(teacher);
    }

}

输出结果

teacher无参构造
Teacher{tname='null'}

通过普通工厂进行对象的实例化

创建一个普通工厂，方法中有一句打印

public class BeansFactory {
    public Teacher createTeac(){
        System.out.println("普通工厂creatTeac");
        return  new Teacher();
    }
}

主配置文件中需要注入工厂和Teacher类

<bean id="factory" class="com.dong.factory.BeansFactory"></bean>
<bean id="teacher" class="com.dong.bean.Teacher" 
      factory-bean="factory" factory-method="createTeac"></bean>

获取实例同上，输出结果

普通工厂creatTeac
teacher无参构造
Teacher{tname='null'}

通过静态工厂进行对象的实例化

创建静态工厂，方法中存在语句打印

public class StaticBeansFactory {
    public static Teacher createTeac(){
        System.out.println("静态工厂creatTeac");
        return  new Teacher();
    }
}

主配置文件中注入

<bean id="teacher" class="com.dong.factory.StaticBeansFactory" factory-method="createTeac" ></bean>

获取实例同上，输出结果

静态工厂creatTeac
teacher无参构造
Teacher{tname='null'}

Spring对于bean的作用域

含义：bean在spring容器中创建的策略以及访问的范围

编写位置:bean标签属性位置
编写语法:scope=“”

属性值:

singleton：单例模式，全局唯一，性能好，安全性低（默认方式）
prototype：多例模式，全局不唯一，性能差，安全性高

以下作用域数据web模块：
request：一次请求创建一个对象
session：一个会话创建一个对象

applicationConfig.xml如下情况时：

<bean id="teacher1" class="com.dong.bean.Teacher" scope="singleton">
<bean id="teacher2" class="com.dong.bean.Teacher" scope="prototype">

Test：

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
        Teacher teacher1 = (Teacher) applicationContext.getBean("teacher1");
        Teacher teacher2 = (Teacher) applicationContext.getBean("teacher1");
        Teacher teacher3 = (Teacher) applicationContext.getBean("teacher2");
        Teacher teacher4 = (Teacher) applicationContext.getBean("teacher2");
        
        System.out.println(teacher1==teacher2);
        System.out.println(teacher3==teacher4);
    }
}

输出结果：

true
false

单例模式：有且只有第一次创建对象，第二次只获取不创建，所以地址相同

多例模式：每次都创建对象，两次获取的对象地址不相同

Spring对于bean的生命周期管理

单例模式

实例化=====>容器创建的时候实例化
属性赋值(DI)
初始化=====>实例化完成，则自动初始化
InitializingBean类中的afterPropertiesSet
init-method属性绑定方法
使用操作
销毁======>容器关闭，所以的bean则自动销毁,销毁前会执行destroy-method=""方法，完成资源回收

JavaBean实体类Teacher

public class Teacher implements InitializingBean {
    private String tname;
    public Teacher() {
        System.out.println("teacher无参构造");
    }

    public void setTname(String tname) {
        System.out.println("属性赋值");
        this.tname = tname;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("接口初始化");
    }

    public void doinit(){
        System.out.println("属性初始化");
    }

    public void destory(){
        System.out.println("属性销毁");
    }

    @Override
    public String toString() {
        return "属性：Teacher{" +
                "tname='" + tname + '\'' +
                '}';
    }
}

主配置文件applicationConfig.xml

<bean id="teacher" class="com.dong.bean.Teacher" init-method="doinit" destroy-method="destory">
    <property name="tname" value="张三"></property>
</bean>

获取实例

public class Test01 {
    public static void main(String[] args) {
        // 1.加载核心对象
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        // 2.获取实例
        Teacher teacher = (Teacher) applicationContext.getBean("teacher");
        applicationContext.close();
    }
}

输出结果

teacher无参构造
属性赋值
接口初始化
属性初始化
属性：Teacher{tname='张三'}
属性销毁

spring管理bean的自动装配

手动注入:
<property name="service" ref="serviceImp"></property>
<constructor-arg></constructor-arg>
含义:将对象用DI的编程思想，自动注入给调用者（原先是手动）
编写位置：bean与beans标签的属性
编写语法:
autowire=“”=》局部设置
default-autowire=“”》全局设置
编写属性:
byType=>按照类型自动装配属性类型与bean的class一致**（通过set注入实现）**
byName>按照id属性自动装配属性名称与bean的id一致**（通过set注入实现**）
constructor===>按照类型自动装配属性类型与bean的class一致（通过构造方法注入实现）
no==========>默认设置，无自动装配
编写注意:
1.按照类型装配，避免容器中有相同类型
2.按照名字装配，要保证需要的对象名在spring容器中有对应的id
3.可以同时进行全局与局部设置，就近原则
4.自动装配能简化代码配置，但是在大型项目中不推荐使用，可读性差

byType

★byType需要有set方法★

案例：UserControllerImpl、UserServiceImpl、UserDaoImpl

UserControllerImpl

public class UserControllerImpl implements  IUserController{
    UserServiceImpl service;
    public void setService(UserServiceImpl service) {
        this.service = service;
    }
    @Override
    public void save() {
        System.out.println("controller层保存");
        service.save();
    }
}

UserServiceImpl

public class UserServiceImpl implements IUserService {
    UserDaoImpl dao;
    public void setDao(UserDaoImpl dao) {
        this.dao = dao;
    }
    @Override
    public void save() {
        System.out.println("service层新增");
        dao.save();
    }
}

UserDaoImpl

public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("dao层新增");
    }
}

主配置文件中

<bean id="controller" class="com.dong.controller.UserControllerImpl" autowire="byType"></bean>
<bean id="service" class="com.dong.service.UserServiceImpl" autowire="byType"></bean>
<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>

这样就完成了依赖注入，不需要再去手动的去写注入，一个autowire属性就解决了,byType会去找相对应的类型，完成注入

按照类型装配，避免容器中有相同类型

byName

★byName需要有set方法★

案例：UserControllerImpl、UserServiceImpl、UserDaoImpl

UserControllerImpl、UserServiceImpl、UserDaoImpl和上述"byType"相同，需要有set方法，但是主配置文件中不相同

<bean id="controller" class="com.dong.controller.UserControllerImpl" autowire="byName">
<bean id="service" class="com.dong.service.UserServiceImpl" autowire="byName">
<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>

byType通过类中的名字找bean标签中对应的id，完成注入

按照名字装配，要保证需要的对象名在spring容器中有对应的id

constructor

★byName需要有构造方法★

案例：UserControllerImpl、UserServiceImpl、UserDaoImpl

UserControllerImpl

public class UserControllerImpl implements  IUserController{
    UserServiceImpl service;
    public UserControllerImpl(UserServiceImpl service) {
        this.service = service;
    }
    @Override
    public void save() {
        System.out.println("controller层保存");
        service.save();
    }
}

UserServiceImpl

public class UserServiceImpl implements IUserService {
    UserDaoImpl dao;
   	public UserServiceImpl(UserDaoImpl dao) {
        this.dao = dao;
    }
    @Override
    public void save() {
        System.out.println("service层新增");
        dao.save();
    }
}

UserDaoImpl

public class UserDaoImpl implements IUserDao {
    @Override
    public void save() {
        System.out.println("dao层新增");
    }
}

主配置文件中

<bean id="controller" class="com.dong.controller.UserControllerImpl" autowire="constructor">
<bean id="service" class="com.dong.service.UserServiceImpl" autowire="constructor">
<bean id="dao" class="com.dong.dao.UserDaoImpl"></bean>