Spring IOC复习与回顾

已于 2022-11-16 11:20:32 修改
阅读量417 收藏
点赞数
分类专栏： Java学习 文章标签： spring java 后端
于 2022-11-16 11:12:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43600941/article/details/127881529
版权
IOC

  1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂，DI(依赖注入)是IOC思想的具体实现

  2. Spring提供IOC容器实现的两种方式：

    • BeanFactory:IOC容器的基本实现方式，是Spring内部的使用接口，不提供开发人员使用

      加载配置文件时候不会创建对象，在获取对象时采取创建对象

    • ApplicatioContext:BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用

      加载配置文件的时候就会把配置文件中的对象进行创建

  3. Bean的作用域

    Spring中Bean默认是单例的，表示对IOC容器中的同一个Bean多次getBean得到的是同一个实例：

       @Test
    public void testStu(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Stu stu = (Stu) context.getBean("stu");
        Stu stu2 = (Stu) context.getBean("stu");
        System.out.println(stu);  //com.dxy.spring5.Stu@17776a8
        System.out.println(stu2); //com.dxy.spring5.Stu@17776a8
    }

    当然我们可以通过bean中 scope=”prototype“ 属性设置为多例

    <bean id="stu" class="com.dxy.spring5.Stu" scope="prototype"></bean>

    修改后得到的输出为

    @Test
    public void testStu(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Stu stu = (Stu) context.getBean("stu");
        Stu stu2 = (Stu) context.getBean("stu");
        System.out.println(stu);  //com.dxy.spring5.Stu@17776a8
        System.out.println(stu2); //com.dxy.spring5.Stu@69a10787
    }

    除此之外，singleton与prototype还有以下区别：

    scope值设置为singleton时，在加载spring配置文件的时候就会创建对象

    scope值设置为prototype时，不会在加载spring配置文件的时候创建对象，而是在调用getBean方法时创建对象（每调一次就会创建一个全新的实例）

  4. Bean的生命周期

    ①通过构造器创建bean实例（无参构造）

    ②为bean 的属性设置值和对其他bean的引用（调用set方法）

    ③调用bean 的初始化方法（需要进行配置初始化的方法）

    ④bean可以使用了（对象获取到了）

    ⑤当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）

    如果考虑bean的后置处理器，则bean完整的生命周期应该为七步

    ①通过构造器创建bean实例（无参构造）

    ②为bean 的属性设置值和对其他bean的引用（调用set方法）

    ③把bean实例传递给bean后置处理器的方法postProcessBeforeInitialization

    ④调用bean 的初始化方法（需要进行配置初始化的方法）

    ⑤把bean实例传递给bean后置处理器的方法postProcessAfterInitialization

    ⑥bean可以使用了（对象获取到了）

    ⑦当容器关闭的时候，调用bean的销毁方法（需要进行配置销毁的方法）

  5. Bean管理

    Bean管理指的是两个操作：①Spring创建对象；②Spring注入属性

    Bean管理操作有两种方式：①基于xml配置文件方式实现；②基于注解方式实现

    基于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"
       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">
<!--Spring创建对象、注入属性
 每个bean对应一个实例，id的值可以任取，class的值为包类名
 set注入时需要对应类有属性的set方法
 有参构造注入时对应类需要有相应的有参构造器
 -->

<!--  set注入属性  -->
    <bean id="user" class="com.dxy.spring5.User">
        <property name="userName" value="zhangsan"></property>
    </bean>

<!--p空间注入    对set注入的简化，先引入p空间，再注入属性-->
    <bean id="user1" class="com.dxy.spring5.User" p:userName="lisi"></bean>

<!--    有参构造注入属性-->
    <bean id="order" class="com.dxy.spring5.Orders">
        <constructor-arg name="oname" value="box"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>
<!--外部bean  使用ref引入id为order的bean对象-->
    <bean id="user2" class="com.dxy.spring5.User">
        <property name="userName" value="zhangsan"></property>
        <property name="orders" ref="order"></property>
        <!--级联赋值  User需要有属性orders的get方法  Orders中需要有set方法 以为这里是有set注入-->
        <property name="orders.oname" value="bottle"></property>
    </bean>

<!--内部bean  order为对象，使用内部bean为其赋值-->
    <bean id="user3" class="com.dxy.spring5.User">
        <!--userName为普通属性   -->
        <property name="userName" value="zhangsan"></property>
        <property name="orders">
            <bean id="order1" class="com.dxy.spring5.Orders">
                <constructor-arg name="oname" value="computer"></constructor-arg>
                <constructor-arg name="address" value="China"></constructor-arg>
            </bean>
        </property>
    </bean>

</beans>

    集合的属性注入

    <?xml version="1.0" encoding="UTF-8"?>
<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-4.0.xsd">

    <bean id="stu" class="com.dxy.spring5.Stu">
        <!-- 数组注入   -->
        <property name="courses">
            <array>
                <value>数学</value>
                <value>语文</value>
                <value>历史</value>
            </array>
        </property>

        <!--list注入，且元素为对象 -->
        <property name="books" >
            <list>
                <ref bean="book1"></ref>
                <ref bean="book2"></ref>
            </list>
        </property>

        <!--可以引入util空间，对公共部分进行抽取-->
<!--        <property name="books" ref="bookList"></property>-->

        <!--map注入-->
        <property name="numbers">
            <map>
                <entry key="zhangsan" value="001"></entry>
                <entry key="lisi" value="002"></entry>
            </map>
        </property>

    </bean>

    <util:list id="bookList">
        <ref bean="book1"></ref>
        <ref bean="book2"></ref>
    </util:list>

    <bean id="book1" class="com.dxy.spring5.Book">
        <property name="bookName" value="Java并发编程"></property>
    </bean>
    <bean id="book2" class="com.dxy.spring5.Book">
        <property name="bookName" value="深入理解Java虚拟机"></property>
    </bean>
</beans>

    用的实体类：

    User类

    package com.dxy.spring5;

/**
 * Description: <br/>
 * date: 2022/11/15 18:42
 *
 * @author dxy
 * @since JDK 1.8
 */
public class User {

    private String userName;
    private  Orders orders;

    public void setUserName(String name){
        this.userName=name;
    }

    public void setOrders(Orders orders) {
        this.orders = orders;
    }

    public Orders getOrders() {
        return orders;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", orders=" + orders +
                '}';
    }
}

    Orders类

    package com.dxy.spring5;

/**
 * Description: <br/>
 * date: 2022/11/15 19:24
 *
 * @author dxy
 * @since JDK 1.8
 */
public class Orders {
    private String oname;
    private String address;

    public Orders(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }

    public void setOname(String oname) {
        this.oname = oname;
    }

    @Override
    public String toString() {
        return "Orders{" +
                "oname='" + oname + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

    Stu类

    package com.dxy.spring5;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * Description: <br/>
 * date: 2022/11/15 20:43
 *
 * @author dxy
 * @since JDK 1.8
 */
public class Stu {
    private String[] courses;
    private List<Book> books;
    private Map<String,Integer> numbers;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setBooks(List<Book> books) {
        this.books = books;
    }

    public void setNumbers(Map<String, Integer> numbers) {
        this.numbers = numbers;
    }

    @Override
    public String toString() {
        return "Stu{" +
                "courses=" + Arrays.toString(courses) +
                ", books=" + books+
                ", numbers=" + numbers +
                '}';
    }
}

    Book类

    package com.dxy.spring5;

/**
 * Description: <br/>
 * date: 2022/11/15 20:46
 *
 * @author dxy
 * @since JDK 1.8
 */
public class Book {
    private String bookName;

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

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                '}';
    }
}

    用于测试的类：

    TestSpring5

    package com.dxy.spring5.testdemo;

import com.dxy.spring5.Orders;
import com.dxy.spring5.Stu;
import com.dxy.spring5.User;
import org.junit.Test;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Description: <br/>
 * date: 2022/11/15 18:31
 *
 * @author dxy
 * @since JDK 1.8
 */
public class TestSpring5 {


    @Test
    public void testStu(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Stu stu = (Stu) context.getBean("stu");
        System.out.println(stu);
    }

    @Test
    public void testAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = (User)context.getBean("user2");
        Orders order = (Orders) context.getBean("order");
        System.out.println(user.toString());
    }
}

    以上我们都是进行手动装配的，即在bean中指定属性以及我们要设置的值，下面我们介绍一下Spring的自动装配

    自动装配：根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

    在xml中演示自动装配

    基于byName的自动装配：（在bean中设置autowire=“byName”，此时会根据属性名称来寻找对应id的bean,并将属性值注入）

    <!--这里userName为普通属性，我们用set手动注入，orders为对象，我们使用byName自动装配  注意：此时不许有一个bean的id值与orders属性名称完全一致，才能自动装配成功-->
<bean id="user" class="com.dxy.spring5.User" autowire="byName">
        <property name="userName" value="zhangsan"></property>
    </bean>

    <bean id="orders" class="com.dxy.spring5.Orders">
        <constructor-arg name="oname" value="box"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

    运行测试类中得到：

    User{userName='zhangsan', orders=Orders{oname='box', address='China'}}

    基于byType的自动装配：在bean中设置autowire=“byType”，此时会根据属性的类型来寻找对应class的bean,并将属性值注入）

    <bean id="user" class="com.dxy.spring5.User" autowire="byType">
        <property name="userName" value="zhangsan"></property>
    </bean>

    <bean id="orders" class="com.dxy.spring5.Orders">
        <constructor-arg name="oname" value="box"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

    我们可以得到相同的输出结果。但需要特别注意的是，如果有多个类型相同的bean，我们就不能使用byType来进行自动装配了！

    基于注解的实现方式

    使用注解的目的：简化xml配置

    Spring针对Bean管理中创建对象提供注解：@Component @Service @Controoler @Repository

    上面四个注解功能一致，都可以创建bean实例，只不过我们习惯在不同的层上使用不同的注解，是开发更加规范

    我们先引入了context空间，然后开启组件扫描

    <?xml version="1.0" encoding="UTF-8"?>
<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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

<!-- 基于注解实现-->
        <!--开启组件扫描
            方式1.如果扫描多个包，多个包使用逗号隔开
            方式2.扫描包的上层目录-->
    <context:component-scan base-package="com.dxy"></context:component-scan>
</beans>

    创建UserService类，使用注解实现Spring创建对象：

    package com.dxy.spring5.service;

import org.springframework.stereotype.Service;

/**
 * Description: <br/>
 * date: 2022/11/16 10:30
 *
 * @author dxy
 * @since JDK 1.8
 */
//注解中value属性值可以不写，默认值是类名称首字母小写
@Service(value = "userService") //等价于<bean id="userService" class="com.dxy.spring5.testdemo.UserService"></bean>
public class UserService {
    public void print(){
        System.out.println("test...");
    }
}

    @Test
    public void testUserService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.print(); 
    }

    使用注解方式实现属性注入：

    @Autowired:根据属性类型进行自动装配 （使用最多）

    @Qualifier:根据属性名称进行注入,使用@Qualifier时需要和@Autowired一起使用

    @Resource:既可以根据类型注入（使用@Resource），也可以根据名称注入 （使用@Resource（name=“xxx”））

    @Value:可以注入普通属性

    package com.dxy.spring5.service;

import com.dxy.spring5.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Description: <br/>
 * date: 2022/11/16 10:30
 *
 * @author dxy
 * @since JDK 1.8
 */
//注解中value属性值可以不写，默认值是类名称首字母小写
@Service(value = "userService") //等价于<bean id="userService" class="com.dxy.spring5.testdemo.UserService"></bean>
public class UserService {
    //在service中注入dao对象，添加注入属性注解
    @Autowired
    private UserDao userDao;

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

    UserDao

    package com.dxy.spring5.dao;

/**
 * Description: <br/>
 * date: 2022/11/16 10:47
 *
 * @author dxy
 * @since JDK 1.8
 */
public interface UserDao {
    public void print();
}

    UserDaoImpl

    package com.dxy.spring5.dao;

import org.springframework.stereotype.Repository;

/**
 * Description: <br/>
 * date: 2022/11/16 10:47
 *
 * @author dxy
 * @since JDK 1.8
 */
@Repository
public class UserDaoImpl implements UserDao{

    public void print() {
        System.out.println("dao test...");
    }
}

    完全注解开发

    创建配置类，替代xml配置文件

    package com.dxy.spring5.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * Description: <br/>
 * date: 2022/11/16 11:03
 *
 * @author dxy
 * @since JDK 1.8
 */
@Configuration    //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.dxy"})
public class SpringConfig {

}

    测试时也有点变化：

     @Test
    public void testUserService1(){
        //加载配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = (UserService) context.getBean("userService");
        userService.print();
    }
InitiativeYu
关注
专栏目录
Spring文件第四课SpringIOC 的三种方案利用注解的方式.
qq_56248592的博客
04-24 624
@1 Spring定义： Spring是-一个容器.它是整合其它框架的框架.它的核心是IOC和AOP.它由20多个模块构成.它在很多领域都提供优秀的解决方案. @2 Spring框架的特点： 轻量级由20多个模块构成,每个jar包都很小，小于1M,核心包也就3M左右.对代码无污染. @3 面向接口编程 使用接口,就是面向灵活,项目的可扩展性,可维护性都极高接口不关心实现类的类型.使用时接口指向实现类,切换实现类即可切换整个功能 @4AOP:面向切面编程。 就是将公共的,通用的,重复的代码单独开
Spring框架（复习总结——Spring IoC）
qq_42009262的博客
07-12 341
关于Spring框架的总结（二、Spring IoC） 2.Spring IoC Spring IoC 2.1.Spring IoC的基本概念 2.2.Spring IoC容器 2.3.bean标签 2.4.依赖注入 2.1.Spring IoC的基本概念 2.2.Spring IoC容器 2.3.bean标签 2.4.依赖注入
Spring基本操作和原理（复习笔记之IOC）
编程小敬的博客
02-15 213
概念 针对bean的生命周期进行管理的轻量级容器,提供了功能强大IOC、AOP及Web MVC等功能 IOC 控制反转，DI依赖注入,将创建对象的过程交给spring管理 AOP 动态代理，在不修改源码的情况下修改或添加功能 特点 1.方便解耦，简化开发 2.Aop编程支持 3.方便测试 4.方便整合各种框架 5.方便进行事务操作 6.降低javaEE API开发难度（例如jdbc） 入门 创建实体类 package com.zwj.bean; /** * @author zwj * @date
Spring IOC 复习和理解
Linn的博客
02-24 506
前面部分知识点为摘抄，后面部分是自己读后的笔记 SpringIOC和DI IOC：Inversion Of Control，即控制反转，是一种设计思想。在传统的 Java SE 程序设计中，我们直接在对象内部通过 new 的方式来创建对象，是程序主动创建依赖对象；而在Spring程序设计中，IOC 是有专门的容器去控制对象。 所谓控制就是对象的创建、初始化、销毁。 创建对象：原来是 new 一个...
Spring IoC容器与Bean管理
weixin_50216991的博客
11-18 2088
Spring核心知识点全总结一.Spring IoC容器与Bean管理1.Spring快速入门IoC控制反转DI依赖注入 从本节开始，我将要学习作为java高级阶段最最最最重要的一个框架体系，名为Spring。Spring是整个Java生态中最重要的一环。这篇博客是我一边学习Spring一边总结后的产物，但也并不完全是纯知识点总结，里面也有一套完整的案例与之结合。方便自己以后复习，同时也希望大家看了也能有收获。 一.Spring IoC容器与Bean管理 这一小节，要学习Spring入门、Spring X
Spring IOC理论总结
许诗宇的博客
03-02 336
注意：本文参考 docs/system-design/framework/spring/spring-knowledge-and-questions-summary.md · SnailClimb/JavaGuide - Gitee.com 谈谈自己对于 Spring IoC 的了解 IoC（Inverse of Control:控制反转）是一种设计思想，而不是一个具体的技术实现。IoC 的思想就是将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。不过， IoC 并非 Spir.
Spring复习回顾之手写IOC容器
bubbleTg的博客
10-05 175
Spring复习回顾之手写IOC容器 手写IOC之前，我们先来看看下面问题： 1. 请问什么是IoC和DI？并且简要说明一下DI是如何实现的？ ​ IOC是控制反转，是Inversion of Contro 的缩写。DI（Dependency Injection） 是依赖注入,是对IOC更简单的诠释。 ​ 控制反转是把传统上由程序代码直接操控的对象的调用权交给容器，通过容器来实现对象组件的装配和管...
复习回顾---Spring
m0_61656944的博客
12-10 297
1.什么是spring? spring是一个轻量级的IOC和AOP容器框架，目的是用于简化企业应用程序开发，其中最主要的两个特性是IOC（控制反转）和AOP(面向切面)。 2.什么是IOC? IOC（控制反转）是将对象的控制权限转移给spring管理，由spring框架来控制对象的生命周期和对象的依赖关系。 3.什么是AOP? AOP（面向切面）是指将一些与业务无关，但对多个对象产生影响的公共行为和逻辑进行抽取封装，使这些模块可以重新使用，这个模块就叫做切面，减少系统中重复的代码，降低了模块之间的
Spring Ioc剩余部分内容
半束海棠的博客
07-18 248
主要是复习前文的Spring Ioc内容，还有就是对于bean对象管理的内容的补充，以及使用注解开发的内容。
Spring教程与源代码
04-11
"Spring知识点回顾"和"Spring知识点回顾1"是对Spring框架的关键概念和功能的复习，可能包含Bean的生命周期管理、事件传播、国际化支持、Spring Boot的快速开发特性等内容。这部分可以帮助开发者巩固和深化对Spring的...
qfedu三段Spring以及Spring整合MyBatis
03-07
#### 一、复习昨日知识点回顾 昨日我们学习了Spring框架中的核心概念以及如何使用注解来实现IoC（控制反转）和DI（依赖注入）。其中涉及到了多种注解的使用方法及其应用场景。 1. **IoC与DI的注解实现**： - **...
spring -第十四章 spring事务
m0_74606902的博客
11-11 781
要在spring中实现事务有两种方式编程式事务：编写代码手动的开启、提交、回滚事务。声明式事务：使用注解或xml配置文件进行事务管理。
基于Java+SpringBoot在线考试系统
最新发布
源码好优多
11-12 284
项目编号：springbootA004传统的教育方式受限于时间和空间，无法满足人们的灵活学习需求。而在线教育通过利用互联网技术，打破了传统教育的限制，提供了更加灵活、自主、便捷和高效的学习途径。在线考试作为在线教育的一部分，成为了评估学生学习成果的重要手段。传统的考试方式存在很多缺点，如需要纸质试卷、人工评分、时间和空间限制等。这些问题不仅增加了教师的工作量，也限制了考试的效率和准确性1.管理员。
Spring AOP
学无止境
11-12 532
2.目标对象（实现行为）3.
SpringBoot后端解决跨域问题
theLuckyLong的博客
11-10 207
【代码】SpringBoot后端解决跨域问题。
为何选择Spring AI Alibaba开发智能客服平台？
JavaEdge全是干货的技术号
11-09 797
本文来看如何使用Spring AI Alibaba构建Agent应用。
七、Spring Boot集成Spring Security之前后分离认证最佳实现
JavaEE技术进阶之路
11-06 1060
前后分离项目认证流程代码实现，基于spring security原生流程设计，实现RESTFUL接口、分布式缓存
SpringBoot 实战：文件上传之秒传、断点续传、分片上传
江南一点雨的专栏
11-12 366
好了，以上就是关于文件上传中秒传、断点续传和分片上传的实战分享。通过这些技术的应用，我们可以极大地提升文件上传的效率和稳定性，改善用户体验。希望各位小伙伴在自己的项目中也能灵活运用这些技巧，解决实际问题。
Spring-Day8
2301_78630849的博客
11-09 656
一组关联的数据库操作；要么都成功，要么都失败，保证业务操作完整性的一种数据库机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值