万字Spring5框架初学笔记记录——IOC

看到我打电动请叫我去学习

已于 2022-08-04 23:07:53 修改

阅读量775

点赞数

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

于 2022-08-03 11:35:10 首次发布

本文链接：https://blog.csdn.net/weixin_53716018/article/details/126093578

版权

Spring 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

1：IOC容器

1：IOC容器

IOC又名控制反转（反转控制），把对象创建和对象之间的调用过程，交给Spring进行管理。这样可以使得程序的耦合度降低

1.1：IOC底层原理

1.1.1：IOC相关的技术

1：xml解析
2：工厂模式
3：反射

1.1.2：IOC过程（原理）图解

过程相关类：User类，UserService类，UserFactory类（工厂类）
在这里插入图片描述

在这里插入图片描述

1.2：IOC接口（beanFactory）

1：IOC思想基于IOC容器完成，而IOC容器底层就是对象工厂

2：Spring提供IOC容器两种实现方式（两个接口）：

（1）：BeanFactory：IOC容器的基本实现，是Spring内部的使用接口，不提供给开发人员使用。
该接口特点在加载配置文件的时候（如下图）不会创建对象，只有在获取对象是才去创建对象。
在这里插入图片描述

（2）ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。该接口在加载配制1文件时就会创建配置文件对象

3：ApplicationContext有两个实现类：
在这里插入图片描述

1.3：IOC操作Bean管理

Bean管理包含两步操作：

①Spring创建对象
②Spring注入属性

1.3.1：基于xml方式

1.3.1.1基于xml方式创建对象

在这里插入图片描述
（1）在Spring配置文件中使用bean标签，并在标签内添加对应属性，就可以实现对象的创建
（2）bean标签属性的介绍
①id属性：唯一标识
②class属性：类全路径（包类路径）
（3）创建对象时，默认是执行类的无参构造函数进行对象创建

1.3.1.2基于xml方式注入属性（DI：依赖注入，就是注入属性）

1.3.1.2.1：第一种注入方式：使用set方法进行注入

①：Book类的创建

public class Book {

    private String bookName;

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

	 //无参构造函数
    public Book() {
    }

	 //有参构造函数
    public Book(String bookName) {
        this.bookName = bookName;
    }
    //测试属性是否注入成功
    public  void showBookName(){
        System.out.println(bookName);
    }
}

②：在Spring配置文件中配置对象创建，配置属性注入

  <!--配置Book对象的创建-->
    <!--    set方法注入属性-->
    <bean id="book" class="spring5_1.Book">
        <!--使用properties完成属性注入
            name：类里面的属性名称
            value：向属性注入的值
         -->
        <property name="bookName" value="金瓶梅"></property>
    </bean>

③：测试


    @Test
    public void testBook(){
        //加载xml配置文件
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean1.xml");
        //获取配置文件创建的对象
        Book book = context.getBean("book", Book.class);
        //调用方法查看属性注入是否成功
        book.showBookName();
    }

1.3.1.2.2：第二种注入方式：使用有参构造函数进行注入

Spring配置文件中代码如下，类的代码与测试代码同方式一（使用set注入）：

 <!--有参构造函数注入属性-->
    <bean id="book" class="spring5_1.Book">
    <!-- name属性也可以用index属性来代替，
    index从0开始依次对应有参构造函数中的第一个参数，第二个参数……       -->
    <constructor-arg name="bookName" value="金瓶梅"></constructor-arg>
    </bean>

1.3.1.2.3：第三种注入方式：p名称空间注入（了解即可，底层运用了set方法注入）

Spring配置文件中代码如下，类的代码与测试代码同方式一（使用set注入）：
①：添加p名称空间在配置文件中（即在beans标签处）

 <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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

②：bean标签代码如下

  <bean id="book" class="spring5_1.Book" p:bookName="金瓶梅" >
        </bean>

1.3.1.3：注入其他属性

1.3.1.3.1：字面量（null值或特殊符号）

1：null值
（1）相关类代码如下

public class Book {

    private String bookName;
    private String address;

    public void setAddress(String address) {
        this.address = address;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    //测试属性是否注入成功
    public  void showBookName() {
        System.out.println(bookName+"::"+address);
    }
    }

（2）xml中配置代码

 <bean id="book" class="spring5_1.Book">
            <property name="bookName" value="金瓶梅"></property>
            <!-- 将address属性设置为空值-->
            <property name="address" >
                <null/>
            </property>
        </bean>

2：特殊符号（如<>)
要想将属性设置为特殊符号，一是可以将特殊符号进行转义，二是可以把特殊符号内容写到CDATA中

（1）相关类代码与设置null值的类代码相同
（2）xml中配置代码

<bean id="book" class="spring5_1.Book">
            <property name="bookName" value="金瓶梅"></property>
<!--            将”<<china>>“注入属性-->
            <property name="address">
                <value><![CDATA[<<china>>]]></value>
            </property>

        </bean>

1.3.1.3.2：注入属性——外部bean

（1）创建两个类——service类和dao类
UserService类代码如下

public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add......");
        userDao.update();
    }
}

UserDaoImpl类代码如下

public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("dao update......");
    }
}

（2）在Spring配置文件中进行配置，实现在UserService类中调用UserDaoImpl里面的方法

<!--    service和dao对象创建-->
    <bean id="userService" class="spring5_1.service.UserService">
<!--        注入userDao对象
            ref属性：创建userDao对象bean标签的id值
-->
        <property name="userDao" ref="userDao"></property>
    </bean>
<!--    注意：
         在Service类中userDao属性为借口，
         此处的class属性的值需要设置为UserDao类的实现类
-->
    <bean id="userDao" class="spring5_1.dao.UserDaoImpl"></bean>

（3）测试

   @Test
    public void test2(){
        //加载xml配置文件
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean2.xml");
        //获取配置文件创建的对象
        UserService us= context.getBean("userService", UserService.class);
        //调用方法查看属性注入是否成功
      us.add();
    }

1.3.1.3.2：注入属性——内部bean

（1）创建两个类——Dept类和Emp类
Eept类代码如下

public class Dept {
    private String dName;

    public void setdName(String dName) {
        this.dName = dName;
    }

    @Override
    public String toString() {
        return dName;
    }
}

Emp类代码如下

public class Emp {
    private String eName;
    private String gender;
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void seteName(String eName) {
        this.eName = eName;
    }

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

    //查看属性是否注入成功
    public void show(){
        System.out.println(eName+":"+gender+":"+dept);
    }
}

（2）在Spring配置文件中进行配置，使用内部bean的方式对Emp的对象的对象属性进行注入

<!--内部bean的写法-->
    <bean id="emp" class="spring5_1.bean.Emp">
<!--        设置两个普通属性-->
        <property name="eName" value="jayen"></property>
        <property name="gender" value="man"></property>
<!--        通过内部bean的方式对对象属性进行复制-->
        <property name="dept">
            <bean id="depat" class="spring5_1.bean.Dept">
                <property name="dName" value="IT"></property>
            </bean>
        </property>
    </bean>

（3）测试

   @Test
   @Test
    public void test3(){
        //加载xml配置文件
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean3.xml");
        //获取配置文件创建的对象
        Emp e= context.getBean("emp", Emp.class);
        //调用方法查看属性注入是否成功
        e.show();
    }

1.3.1.3.2：注入属性——级联赋值

（1）使用的类与”内部bean”相同，不同的只是xml配置文件
（2）编写xml配置文件
①：写法一

    <bean id="emp" class="spring5_1.bean.Emp">
        <!--        设置两个普通属性-->
        <property name="eName" value="jayen"></property>
        <property name="gender" value="man"></property>
        <!--        级联赋值-->
       <property name="dept" ref="dept"></property>
    </bean>
    
    <bean id="dept" class="spring5_1.bean.Dept">
        <property name="dName" value="manager"></property>
    </bean>

①：写法二（这种写法再在Emp对象中提供get方法）

  <bean id="emp" class="spring5_1.bean.Emp">
        <!--        设置两个普通属性-->
        <property name="eName" value="jayen"></property>
        <property name="gender" value="man"></property>
        <!--        级联赋值-->
       <property name="dept" ref="dept"></property>
        <property name="dept.dName" value="supplement">

        </property>
    </bean>

    <bean id="dept" class="spring5_1.bean.Dept">
<!--        <property name="dName" value="manager"></property>-->
    </bean>

1.3.1.4：xml注入集合属性（数组，list，map和set）

xml配置文件相关代码如下

  <!--集合属性的注入-->
    <bean id="stu" class="spring5_1.collectionType.Stu">
<!--     数组类型-->
        <property name="courses">
            <array>
                <value>java</value>
                <value>C++</value>
            </array>
        </property>
<!--        集合类型-->
        <property name="list">
            <list>
                <value>jayen</value>
                <value>jimi</value>
            </list>
        </property>
<!--        map类型-->
        <property name="maps">
            <map>
                <entry key="chinese" value="100"></entry>
                <entry key="math" value="100"></entry>
            </map>
        </property>
<!--        set类型-->
        <property name="sets">
            <set>
                <value> primary</value>
                <value>high</value>
            </set>
        </property>
<!--        存放对象类型的集合的注入-->
<!--        对象类型的集合的注入类似与外部bean，
            需要在bean标签外部先创建对象在实现引入-->
        <property name="courseList">
            <list>
                <ref bean="course1"></ref>
                <ref bean="course2"></ref>
            </list>
        </property>
    </bean>
<!--    为对象集合创建对象-->
    <bean id="course1" class="spring5_1.collectionType.Course">
        <property name="couName" value="Spring"></property>
    </bean>
    <bean id="course2" class="spring5_1.collectionType.Course">
        <property name="couName" value="Cloud"></property>
    </bean>

1.3.1.5：xml提取”集合属性注入“

（1）编写xml配置文件在Spring配置文件中引入名称空间util

<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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

（2）使用util标签完成list标签集合注入提取

 <!--提取list集合类型的注入-->
    <util:list id="bookList">
        <value>Spring</value>
        <value>mysql</value>
    </util:list>

<!--    使用提取list集合类型的注入-->
    <bean id="book" class="spring5_1.collectionType.Book">
        <property name="list" ref="bookList"></property>
    </bean>

1.3.2：FactoryBean的介绍，Bean作用域和Bean的生命周期

1.3.2.1：FactoryBean的介绍

1：Spring有两种类型bean——普通bean与FactoryBean（工厂bean）
（1）：普通bean：在配置文件中定义的bean类型（即bean标签中的class属性）就是返回类型
（2）：工厂bean：在配置文件中定义的bean类型可以与返回类型不一致
①第一步：创建类，让这个类作为工厂bean，实现接口FactoryBean
②第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型

1.3.2.2：Bean作用域

1.3.2.2.1：单实例对象和多实例对象

单实例对象指的是在使用“ClassPathXmlApplicationContext”对象多次获取bean实例的时候，得到的是同一个对象，而多实例指的是多次获取bean实例时，获取到的是不同的对象。此外，在默认条件下，Bean实例为单实例对象。

1.3.2.2.2：将bean实例设置为多实例对象

bean标签里的scope用于设置单实例或者多实例，属性值“singleton”对应单实例对象，“prototype”对应多实例对象

 <bean id="book" class="spring5_1.collectionType.Book" scope="prototype">
        <property name="list" ref="bookList"></property>
    </bean>

1.3.2.2.3：singleton与prototype的区别

当scope属性的值为singleton时，程序在加载xml配置文件时就会创建一个单实例对象。
当scope属性的值为prototype时，程序在调用getBean()方法是才会创建一个多实例对象

1.3.2.2：Bean的生命周期（不包含后置处理器部分）

作者在后置处理部分在被摩擦了，所以这部分以后接触到在更新吧QAQ。

Bean的生命周期如下：
1：通过构造器创建bean实例（无参数构造函数）、
2：为bean的属性设置值和对其他bean进行引用（调用set方法）
3：调用bean的初始化的方法（需要进行配置初始化的方法）
4：bean可以使用了（对象获取到了）
5：当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）
相关Java代码如下：

ublic class Orders {
    private String  oName;

    public Orders() {
        System.out.println("第一步 执行无参数构造创建bean实例");
    }

    public void setoName(String oName) {
        this.oName = oName;
        System.out.println("第二步 调用set方法设置属性值");
    }
    //创建执行的初始化方法
    public void initMethod(){
        System.out.println("第三步 执行初始化方法");
    }
    //创建执行的销毁方法
    public void destroyMethod(){
        System.out.println("第五步 执行销毁方法");
    }
    public  void test(){
        System.out.println("第四步 使用对象");
    }
}

//测试的代码
  @Test
    public void test4(){
        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("bean4.xml");

        Orders bean = context.getBean("order", Orders.class);

        bean.test();
        //手动将bean实例销毁,此步过后自动调用Orders里自定义的销毁方法
        context.close();

    }

1.3.3：xml自动装配

1.3.3.1：什么是自动装配

自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入
bean标签通过属性autowire配置自动装配
autowire属性两个常用值：
byName：根据属性名称注入，注入值的bean的id值要和被注入的bean的类属性名称一样
byType：根据属性类型注入，

1.3.3.2：根据名称自动装配

xml代码如下

<!--    实现自动装配
        bean标签属性autowire，配置自动装配
        autowire属性两个常用值：
                            byName：根据属性名称注入，注入值的bean的id值要和被注入的bean的类属性名称一样
                            byType：根据属性类型注入，注入的bean若超出一个会报错，这是就要用byName
-->
<!--    被注入的bean-->
    <bean id="emp" class="autowire.Emp" autowire="byName"></bean>
    <!--    注入的对象-->
    <bean id="dept" class="autowire.Dept"></bean>

1.3.3.3：根据类型自动装配

xml代码如下

<!--    被注入的bean-->
    <bean id="emp" class="autowire.Emp" autowire="byType"></bean>
    <!--    注入的对象-->
    <bean id="dept" class="autowire.Dept"></bean>
</beans>

1.3.4：基于注解方式

1.3.4.1：什么是注解（注解介绍）

1：注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值……）
2：使用注解，注解作用在类上面，方法上面，属性上面
3：使用注解的目的：简化xml配置

1.3.4.2：基于注解方式创建对象

1.3.4.2.1：基于注解方式创建对象相关的注解

Spring针对创建对象提供了四个注解，这四个注解在不同的层（如web层，service层）可以相互替换，只是为了方便开发人员进行开发，推荐我们在不同的层使用不同的注解。
这四个注解分别是：
（1）：@Component
（2）：@Service
（3）：@Controller
（4）：@Respository

1.3.4.2.2：基于注解方式创建对象步骤

1：第一步：引入依赖（即导入相关的jar包进工程里）
高亮选中的jar包
1：第二步：开启组件扫描
（1）：往xml配置文件中引入context名称空间：
在这里插入图片描述
（2）：使用context:component-scan标签开启组件扫描

<!--        开启组件扫描
            base-package属性的值填入想要被扫描的包的路径
            扫描多个包有两种写法：1：包与包之间用逗号隔开2：直接扫描这些包的上层目录
-->
    <context:component-scan base-package="spring5_1,Demo"></context:component-scan>
</beans>

（3）：创建类，再类上面添加对象注释（因不同得注解可以相互替换，此处只列出一种注解）

//注解里面的value属性与xml配置文件里的id属性对应
//注解里面得value属性可以不写，默认值是类名，且该名称得首字母小写
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("add...");
    }

1.3.4.2.3：基于注解方式创建对象步骤中开启组件扫描得相关细节

示例一：
在这里插入图片描述
示例二：

1.3.4.3：基于注解方式实现属性注入

1.3.4.3.1注解方式注入属性相关得注解

（1）：@Autowired：根据属性类型进行自动装配，针对于对象属性
（2）：@Qualifier：根据属性名称进行注入，针对于对象属性
（3）：@Resource：可以根据类型注入，可以根据名称注入，针对于对象属性
（4）：@Value：注入普通类型属性

1.3.4.3.1注解方式注入属性步骤演示

1.3.4.3.1.1@Autowired演示

（1）：把service和dao对象创建：在service和dao类添加创建对象注解
（2）：把在service注入dao对象：在service类添加dao类型属性，在属性上面使用注解
Service代码如下：

@Service
public class UserService {
    //定义dao类型属性，不需要提供set方法，添加注入属性注解
    @Autowired
    private UserDao userDao;

    public void add(){
        System.out.println("add...");
        userDao.add();
    }
}

Dao类代码如下：

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add...");
    }
}

测试代码如下：

    @Test
    public void test1() {

        ClassPathXmlApplicationContext context=
                new ClassPathXmlApplicationContext("bean1.xml");

        UserService bean = context.getBean("userService", UserService.class);
        System.out.println(bean);
        bean.add();
    }

1.3.4.3.1.2@Qualifier演示（@Qualifier注解要结合@Autowired注解使用）

在这里插入图片描述
@Qualifier标签中得value属性的值对应着
创建对象时标签的value值（如@Component(value = “userService”)）

1.3.4.3.1.3@Resource演示

作者不知为啥Idea里没有这个注解，这里直接截网课的图放上来了（好像是jdk11之后删除了Resource注解）
1：根据类型进行注入：
在这里插入图片描述
2：根据名称进行注入：

1.3.4.3.1.4@Value演示

1.3.4.4：完全注解开发（用配置类替代xml配置文件）

（1）：创建配置类，替代xml配置文件

@Configuration//作为配置类，替代xml文件
@ComponentScan(basePackages = {"spring5_1"})//对应context类中的component-scan属性
public class SpringConfig {
}

（2）：测试

    @Test
    public void test1() {

   ApplicationContext context=
                new AnnotationConfigApplicationContext(SpringConfig.class);

        UserService bean = context.getBean("userService", UserService.class);
        System.out.println(bean);
        bean.add();
    }