Spring 是一个 IOC 和 AOP 容器框架。 Spring 容器的主要核心是：

? 控制反转（ IOC ），传统的 java 开发模式中，当需要一个对象时，我们会自己

使用 new 或者 getInstance 等直接或者间接调用构造方法创建一个对象。而在

spring 开发模式中， spring 容器 使用了 工厂模式 为我们创建了所需要的对象，

不需要我们自己创建了，直接调用 spring 提供的对象就可以了，这是控制反

转的思想。

? 依赖注入（ DI ）， spring 使用 javaBean 对象的 set 方法或者带参数的构造方

法 为我们在创建所需对象时将其 属性自动设置所需要的值的过程 ，就是依赖注

入的思想。

? 面向切面编程（ AOP ），在面向对象编程（ oop ）思想中，我们将事物纵向抽成

一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横

向抽成一个切面，对这个切面进行一些如 权限控制、事物管理，记录日志 等。

公用操作处理的过程就是面向切面编程的思想。 AOP 底层是 动态代理 ，如果是

接口采用 JDK 动态代理 ，如果是类采用 CGLIB 方式 实现动态代理。（2022黑马）

Spring 是一个开源框架，为简化企业级应用开发而生。Spring 可以是使简单的JavaBean 实现以前只有EJB 才能实现的功能。Spring 是一个 IOC 和 AOP 容器框架。

Spring 容器的主要核心是：

控制反转（IOC），传统的 java 开发模式中，当需要一个对象时，我们会自己使用 new 或者 getInstance 等直接或者间接调用构造方法创建一个对象。而在 spring 开发模式中，spring 容器使用了工厂模式为我们创建了所需要的对象，不需要我们自己创建了，直接调用spring 提供的对象就可以了，这是控制反转的思想。

依赖注入（DI），spring 使用 javaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程，就是依赖注入的思想。

面向切面编程（AOP），在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。(硅谷)

?双击shift 查找IOC的具体实现

BeanFactory就是IOC容器最根本的实现

ctrl+H? 查看子接口或类的继承关系

提问：

1.如何把对象交给IOC容器管理

2.如何获取ioc容器

3.如何从ioc容器中获得我们当前所管理的对象

?2、基于XML管理bean

?入门准备工作? ??com.atguigu.spring

spring管理对象, 管理的对象我们叫做组件? 也叫做been 所以spring管理对象也可以叫做spring管理been

<packaging>jar</packaging>

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

依赖解释：

spring-context中context是上下文的意思

③创建类HelloWorld

对象从类来的

public class HelloWorld {

    public void sayHello(){
        System.out.println("hello,spring");
    }

}

?现在要把HelloWorld这个类交给spring

如何交给spring 做法：?

⑤在Spring的配置文件中配置bean

   <!--
        bean：配置一个bean对象，将对象交给IOC容器管理
        属性：
        id：bean的唯一标识，不能重复
        class：设置bean对象所对应的类型
    -->
    <bean id="helloworld" class="com.atguigu.spring.pojo.HelloWorld"></bean>

<!--

配置 HelloWorld 所对应的 bean ，即将 HelloWorld 的对象交给 Spring 的 IOC 容器管理

通过 bean 标签配置 IOC 容器所管理的 bean

属性：

id ：设置 bean 的唯一标识

class ：设置 bean 所对应类型的全类名

-->

解释：

1 为什么要设置class:一个bean对应一个对象? ?对象从类来 所以我们要通过class,来设置我们当前bean所对应对象的类型

2. 解释<bean id="helloworld" class="com.atguigu.spring.pojo.HelloWorld"></bean>

? ? 把helloworld类型的对象交给IOC容器管理

⑥创建测试类测试

   @Test
    public void test(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取IOC容器中的bean
        HelloWorld helloworld = (HelloWorld) ioc.getBean("helloworld");
        helloworld.sayHello();
    }

?思路：

把对象交给ioc容器来管理，我们获取ioc容器 就能够获取ioc容器中的对象，然后就可以调用对象中的方法

⑦思路

⑧注意

Spring 底层默认通过反射技术调用组件类的无参构造器来创建组件对象，这一点需要注意。如果在需要

无参构造器时，没有无参构造器，则会抛出下面的异常：

org.springframework.beans.factory.BeanCreationException: Error creating bean with name

'helloworld' defined in class path resource [applicationContext.xml]: Instantiation of bean

failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed

to instantiate [com.atguigu.spring.bean.HelloWorld]: No default constructor found; nested

exception is java.lang.NoSuchMethodException: com.atguigu.spring.bean.HelloWorld.<init>

()

2.2、ioc容器创建对象的方式

com.atguigu.spring

①创建spring_ioc_xml

②引入依赖

<packaging>jar</packaging>

<dependencies>
    <!-- 基于Maven依赖传递性，导入spring-context依赖即可导入当前所需所有jar包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.1</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.16</version>
    </dependency>
    <!-- 数据源 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.0.31</version>
    </dependency>
</dependencies>

③创建学生类Student? ? ??package com.atguigu.spring.pojo

package com.atguigu.spring.pojo;

public class Student {

    private Integer sid;

    private String sname;

    private Integer age;

    private String gender;

    public Student() {
    }

    public Student(Integer sid, String sname, Integer age, String gender) {
        this.sid = sid;
        this.sname = sname;
        this.age = age;
        this.gender = gender;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

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

④创建spring配置文件spring-ioc.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="studentOne" class="com.atguigu.spring.pojo.Student"></bean>
    
</beans>

⑤测试IOCByXMLTest

    @Test
    public void testIOC(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取bean
        Student studentOne = (Student) ioc.getBean("studentOne");
        System.out.println(studentOne);
        
    }

当前我们只是创建一个对象，并没有为我们对象中的成员变量赋值，所以我们可以获取到对象的 不过对象里面成员变量的值都是null

每个成员变量都有一个默认值，比如基本数据 int是0,???double是0.0? ?引用类型是null

ioc底层是工厂模式，因为他的基本的实现叫做BeanFactory，具体是如何帮我们创建对象 我们在没有学习spring之前，我们要创建对象我们用的是new构造方法，spring是如何帮我们创建对象？

想要获取ioc容器是通过配置文件来获取 所以是根据我们的<bean来创建的对象 我们bean标签里面设置的id是唯一标识，这个和我们创建对象没有关系 有关系的是calss? 所以我们在解析xml的时候 就可以获取<bean标签里面的callss的属性值? 所以我们现在知道了我们当前管理对象所对应的类型，知道类型后如何创建对象

总结：在ioc容器中，就是通过反射+工厂模式来帮助我们创建对象，管理对象

如果把无参构造删掉 那么spring无法帮我们把对象创建出来?

因为无参构造是固定的，写法是固定的，有参构造要设置各自成员变量，然后为成员变量进行赋值，所以有参构造可以设置多种方式，可以设置多个重载的方法，里面可以有sid，或者说只有sname或是有sid和sname,所以它并不知道我们的有参构造是什么，但是他知道我们无参构造的样子，我们以后主要有反射 通过反射创建实例化对象用的都是无参构造

总上所述 如果这时我们把无参构造删除后 会出现如下问题：

Caused by: java.lang.NoSuchMethodException: com.atguigu.spring.pojo.Student.<init>()

没有足够的方法异常，Student方法没有? 所以这个报错的意思就是没有无参构造?

?总结：以后在写一个类的时候 一定要加上无参构造（宁可没有有参也要有无参，当前如果没有设置有参时 无参是默认的 总之一句话? 写一个类? 一定要写上无参构造）

2.3、实验二：获取bean的三种方式和注意事项

①方式一：根据 id 获取

由于 id 属性指定了 bean 的唯一标识，所以根据 bean 标签的 id 属性可以精确获取到一个组件对象。

上个实验中我们使用的就是这种方式。

②方式二：根据类型获取

    @Test
    public void testIOC(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取bean
       // Student studentOne = (Student) ioc.getBean("studentOne");
        Student student = ioc.getBean(Student.class);
        System.out.println(student);
    }

注意事项：

1 .如果有二个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">

    <bean id="studentOne" class="com.atguigu.spring.pojo.Student"></bean>

    <bean id="studentTwo" class="com.atguigu.spring.pojo.Student"></bean>
</beans>

?报错如下：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.atguigu.spring.pojo.Student' available: expected single matching bean but found 2: studentOne,studentTwo
解释：Unique唯一? 当前没有一个唯一的并发现异常? ?我们根据类型来获取Student对象，但是我们现在可有的有二个?studentOne,studentTwo?

总结：注意：根据类型获取bean时，要求IOC容器中有且只有一个类型匹配的bean

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


</beans>

报错：

org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.atguigu.spring.pojo.Student' available

当前没有足够的bean并发现异常

③方式三：根据 id 和类型

    @Test
    public void testIOC(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取bean
        //根据id获取
       // Student studentOne = (Student) ioc.getBean("studentOne");
        //根据类型获取
        //Student student = ioc.getBean(Student.class);
        //根据id和类型
        Student student = ioc.getBean("studentOne", Student.class);
        System.out.println(student);
    }

④注意

当根据类型获取 bean 时，要求 IOC 容器中指定类型的 bean 有且只能有一个

当 IOC 容器中一共配置了两个：

<bean id = "helloworldOne" class = "com.atguigu.spring.bean.HelloWorld" ></bean>

<bean id = "helloworldTwo" class = "com.atguigu.spring.bean.HelloWorld" ></bean>

根据类型获取时会抛出异常：

org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean

of type 'com.atguigu.spring.bean.HelloWorld' available: expected single matching bean but

found 2: helloworldOne,helloworldTwo

⑤扩展

如果组件类实现了接口，根据接口类型可以获取 bean 吗？

组件类:当前交给ioc管理所管理的类? ?每一个bean 就是一个组件? 就是ioc所管理的对象

可以，前提是 bean 唯一

验证：

创建一个接口Person

让Student实现当前接口

    @Test
    public void testIOC(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取bean
        //根据id获取
       // Student studentOne = (Student) ioc.getBean("studentOne");
        //根据类型获取
        //Student student = ioc.getBean(Student.class);
        //根据id和类型
        //Student student = ioc.getBean("studentOne", Student.class);
        //这个是可以的  这个的意思是通过Student类型获取到bean之后 把获取的对象  通过向上转型  赋值给接口对象
        Person student = ioc.getBean(Student.class);
        System.out.println(student);
    }

?而我们这题的意思是如下：

    @Test
    public void testIOC(){
        //获取IOC容器
        ApplicationContext ioc = new ClassPathXmlApplicationContext("spring-ioc.xml");
        //获取bean
        //根据id获取
       // Student studentOne = (Student) ioc.getBean("studentOne");
        //根据类型获取
        //Student student = ioc.getBean(Student.class);
        //根据id和类型
        //Student student = ioc.getBean("studentOne", Student.class);
        //这个是可以的  这个的意思是通过Student类型获取到bean之后 把获取的对象  通过向上转型  赋值给接口对象
        //Person student = ioc.getBean(Student.class);
        //通过接口类型在ioc里面匹配一个baen来进行获取
        //可以的  因为是根据类型来找 只要类型能够兼容匹配就可以
        //也就是说，我们在ioc容器中配置一个bean后  是可以通过它所继承的父类或所实现的接口 都可以来获取
        Person person = ioc.getBean(Person.class);
        System.out.println(person);

    }

如果一个接口有多个实现类，这些实现类都配置了 bean ，根据接口类型可以获取 bean 吗？

不行，因为 bean 不唯一

⑥结论

根据类型来获取 bean 时，在满足 bean 唯一性的前提下，其实只是看：『对象 instanceof 指定的类

型』的返回结果，只要返回的是 true 就可以认定为和类型匹配，能够获取到。

总结：

 * 获取bean的三种方式：
 * 1、根据bean的id获取
 * 2、根据bean的类型获取
 * 注意：根据类型获取bean时，要求IOC容器中有且只有一个类型匹配的bean
 * 若没有任何一个类型匹配的bean，此时抛出异常：NoSuchBeanDefinitionException
 * 若有多个类型匹配的bean，此时抛出异常：NoUniqueBeanDefinitionException
 * 3、根据bean的id和类型获取
 * 结论：
 * 根据类型来获取bean时，在满足bean唯一性的前提下
 * 其实只是看：『对象 instanceof 指定的类型』的返回结果
 * 只要返回的是true就可以认定为和类型匹配，能够获取到。
 * 即通过bean的类型、bean所继承的类的类型、bean所实现的接口的类型都可以获取bean