spring 什么是容器？什么是bean？

什么是容器？

存储的东西就是一个容器。
IOC 是一个容器，是一个具有依赖注入功能的容器, 我们要的对象就存在IOC这个容器里面。
IOC容器也就是Spring容器 spring三大核心技术：AOP(切面编程)、 IOC（控制反转）、 DI（依赖注入）

Spring中IOC容器的主要表现形式是BeanFactory（父类，功能低级点，算低级容器）和ApplicationContext（子类，功能高级点，算高级容器）这两个接口。这两个接口的具体实现类就可以看成是IOC容器在Spring中的具体体现

spring 的 IOC 负责对象的实例化、对象的初始化、对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找,对象的整个生命周期都是由容器来控制的。这个 IOC 是一个具有依赖注入功能的 容器。
我们需要的对象都是由 IOC （控制反转）容器进行创建管理的，不需要我们手动去new对象出来，由IOC容器帮我们组装好，我们需要某个对象的时候就去IOC容器里面拿就行了。
IOC容器怎么组装我们想要的对象？
我们把创建对象的控制权交给 IOC 容器，那么我们也需要给IOC一个创建对象的配置清单（我们需要的对象及该对象的依赖关系，这个配置支持 xml 格式和 java注解方式），IOC才能帮我们创建我们想要的对象。
当项目启动的时候，这个IOC 容器（也就是Spring 容器）就会去加载这些配置文件，然后将我们要的对象组装好以供外部访问者使用。

解释 --> IOC 是一个容器，是一个具有依赖注入功能的容器
IOC 控制反转
DI 依赖注入
解释---->IOC 也被成为DI ?
IOC就是容器,DI 就是注入这一行为,那么DI 确实就是 IOC 的具体功能的实现。而 IOC 则是 DI 发挥的平台和空间。所以说。IOC 和 DI 即是相辅相成的拍档。他们都是为了实现解耦而服务的
1、什么是控制，控制的是什么？
是bean的创建、管理的权利，控制bean的整个生命周期

2、什么是反转，反转了什么？
把原本我们自己主动创建管理对象的权利反转给了spring容器（IOC 容器）去创建、管理。这个就是反转。

3、什么是依赖，依赖了什么？
程序运行需要依赖外部的资源叫依赖
依赖的就是—程序内对象所需要的数据、资源，

4、什么是注入，注入了什么？
配置文件把资源从外部注入到内部，容器（IOC）加载了外部的文件、对象、数据，然后把这些资源注入给程序内的对象，维护了程序内外对象之间的依赖关系。
所以说控制反转就是通过依赖注入实现的。
IOC是设计思想，DI是具体的实现方式
IOC是理论，DI是实践
IOC也可以通过其他方式来实现，而DI只是Spring的选择。
IOC的作用就是解耦
它把对象之间的依赖关系转成用配置文件来管理，由spring Ioc Container 来管理

IOC为什么被称为容器？

IOC充当对象的容器，是管理对象生命周期的框架。负责实例化、解析引用并销毁。
对象的实例化、对象的初始化、对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找,管理对象的整个生命周期
IOC 为什么又被说成是一种思想？
控制反转是一种思想、思路。就是把我们创建对象的权利交给IOC这个容器管理

什么是bean？

什么是bean？
bean 是一个普通的java对象。

什么对象都叫bean吗？
由spring容器管理的对象统称为Bean对象。
只有由spring容器管理的对象才叫bean。

bean和自己new的对象有什么区别？
Bean就是普通的java对象，和我们自己new的对象实质上没有区别。
把对象叫成bean只因为这个对象不是我们主动创建的，而是由spring去创建和管理的对象才叫bean

要spring容器（IOC容器）帮我们创建，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要现在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

在Spring 中，构成应用程序主干并由Spring IoC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。

我们总结如下：
1.bean是对象，一个或者多个不限定
2.bean由Spring中一个叫IoC的东西管理
3.我们的应用程序由一个个bean构成

比如我们建立一个实体类Hello

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Hello {
    private String str;
}
1
2
3
4
5
6

将这个类在beans.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-3.0.xsd">

    <bean id="hello" class="com.kk.pojo.Hello">
        <!--    set注入 获取Hello中的属性str 并且给str赋值Spring-->
        <property name="str" value="Spring"/>
    </bean>

</beans>
1
2
3
4
5
6
7
8
9
10
11
12

使用Spring创建对象，在Spring中 这些都称为Bean

类型 变量名 = new 类型

Hello hello = new Hello()
bean id = new 对象()

id=变量名
class = new 的对象((Hello))

property 相当于给对象中的属性设置值

其核心就是,给属性str使用set进行赋值

 public void setStr(String str) {
    this.str = str;
}
1
2
3

测试：

public class Test {

    public static void main(String[] args) {
        //获取Spring的上下文对象 获取其中resources目录下的beans.xml文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        Hello hello = (Hello) context.getBean("hello"); //获取bean中参数id为hello
        System.out.println(hello.toString());
    }
}
1
2
3
4
5
6
7
8
9
10

获取Spring的上下文对象，使用getBean获得bean中的id,即可获得Hello这个对象并且获得赋给ta的值

1. JavaBean
JavaBean 是一种 Java语言写成的可重用组件。写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，long和class方法获取。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制发现和操作这些JavaBean 的属性。(这段话太官方，咱看的迷迷糊糊的，举个实例来说)

Q1：什么是JavaBean?

1. 所有的类必须放在一个包中；
2. 所有的类必须声明为public，这样才能够被外部所访问；
3. 类中所有的属性都必须封装，即：使用private声明；
4. 封装的属性如果需要被外部所操作，则必须编写对应的setter、getter方法；
5. 一个JavaBean中至少存在一个无参构造方法

一个简单JavaBean

public class User {
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;    
    }   
    
    public void setAge(int age) {
        this.age = age;    
    }
    
    public String getName() {
        return this.name;    
    }
    
    public int getAge() {
        return this.age;    
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

如果在一个类中只包含属性、setter、getter方法，那么这种类就成为简单JavaBean

对于简单的JavaBean也有几个名词：

VO：与简单Java对象对应，专门用于传递值的操作上
POJO：简单Java对象
TO：传输对象，进行远程传输时，对象所在的类必须实现java.io.Serializable接口。

为什么要写成JavaBean？

对于程序员来说，最好的一点就是 JavaBean可以实现代码的重复利用，模块独立，易于维护。

Bean：在计算机英语中，有可重用组件的含义。

JavaBean：用java语言编写的可重用组件

JavaBean > 实体类

2. Spring Bean
Spring其实就是一个大型的工厂，而Spring容器中的Bean就是该工厂的产品.

以前我们要用对象是通过自己new来生产的，现在是通过Spring这个工厂来代替我们管理生产，我们来使用。

对于Spring容器能够生产那些对象，则取决于配置文件中配置。

对于我们而言，我们使用Spring框架所做的就是两件事：开发Bean、配置Bean。

对于Spring框架来说，它要做的就是根据配置文件来创建Bean实例，并调用Bean实例的方法完成“依赖注入”。

简而言之，Spring Bean是Spring框架在运行时管理的对象。Spring Bean是任何Spring应用程序的基本构建块。使用Spring框架时编写的大多数应用程序逻辑代码都将放在Spring Bean中。

Spring Bean的管理包括：

创建一个对象
提供依赖项（例如其他Bean，配置属性）
拦截对象方法调用以提供额外的框架功能
销毁一个对象

3. Bean的定义
元素是Spring配置文件的根元素，元素是元素的子元素，元素可以包含多个子元素。

每个元素可以定义一个Bean实例，每一个Bean对应Spring容器里的一个Java实例。

定义Bean时通常需要指定两个属性：

id：确定该Bean的唯一标识符，容器对Bean管理、访问、以及该Bean的依赖关系，都通过该属性完成。Bean的id属性在Spring容器中是唯一的。

class：指定该Bean的具体实现类。通常情况下，Spring会直接使用new关键字创建该Bean的实例，因此，这里必须提供Bean实现类的全限定类名。

下面是定义一个Bean的简单配置

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	
	<bean id="bean1" class="com.Bean1" />
	
	
	<bean id="bean2" class="com.Bean2" />
	
bean>
1
2
3
4
5
6
7
8
9
10
11
12

Spring容器集中管理Bean的实例化，Bean实例可以通过BeanFactory的getBean(Stringbeanid)方法得到。BeanFactory是一个工厂，程序只需要获取BeanFactory引用，即可获得Spring容器管理全部实例的引用。程序不需要与具体实例的实现过程耦合（这就是用Spring解耦的原理）。

大部分Java EE应用里，应用在启动时，会自动创建Spring容器，组件之间直接以依赖注入的方式耦合，甚至无须主动访问Spring容器本身。

当我们在配置文件中通过方法配置一个Bean时，这样就需要该Bean实现类中必须有一个无参构造器。故Spring底层相当于调用了如下代码：

Xxx = new xx.XxClass()

4. bean标签的属性
id： id是bean的唯一标识符，在Spring容器中不可能同时存在两个相同的id；

class： 类的全限定名（包名+类名）

name： 用法：getBean(“name”)，支持设置多个别名，之间用英文逗号分割；

abstract： 设置bean是否为抽象类，默认abstract=“false”,如果设为true，将不能被实例化；

scope： bean的作用范围

destroy-method： 它的作用是在销毁bean之前可以执行指定的方法。注意：必须满足scope=“singleton”，并且destroy方法参数个数不能超过1，并且参数类型只能为boolean。

init-method： 它的作用是在创建一个bean之后调用该方法，初始化方法必须是一个无参方法。

factory-bean和factory-method： 设置了factory-bean属性后，将指定创建bean的工厂类对象，class属性将失效；设置了factory-method属性后，将指定创建bean的工厂方法；

parent： 指定bean的父类，class属性失效。

5. bean标签的子标签
：构造器参数（顺序注入），此种方式会按照顺序注入构造器的参数。

：Setter() 注入JavaBean的成员变量

二、Spring对Bean的管理细节
1. 创建Bean的三种方式
I. 使用默认构造函数创建
在Spring的配置文件中使用Bean标签，配以id和class属性之后，且没有其他属性和标签时。 采用的就是默认构造函数创建Bean对象，此时如果类中没有默认构造函数，则对象无法创建。

II. 使用普通工厂中的方法创建对象
使用某个类中的方法创建对象，并存入spring容器

III. 使用工厂中的静态方法创建对象
使用某个类中的静态方法创建对象，并存入Spring容器

2. Bean对象的作用范围
Bean标签的scope属性：

作用：用于指定bean的作用范围

取值： 常用的就是单例的和多例的

singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

3. Bean对象的生命周期
单例对象
出生：当容器创建时对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同
多例对象
出生：当我们使用对象时Spring框架为我们创建
活着：对象只要是在使用过程中就一直活着
死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器GC回收

<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="userService" class="org.iqqcode.service.impl.UserServiceImpl"/>
        
beans>
1
2
3
4
5
6
7
8
9
10