Spring学习笔记（一）IOC与Spring基础xml配置

最新推荐文章于 2024-09-05 20:31:40 发布
最新推荐文章于 2024-09-05 20:31:40 发布
阅读量438 收藏
点赞数
分类专栏： JavaEE 文章标签： spring ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z55887/article/details/52486844
版权

1. IOC与DI

IOC（Inversion of Control）：控制反转
DI（Dependency Injection）：依赖注入

“控制反转”和“依赖注入”其实是同一个概念：
改变由调用者创建被调用者的过程。被调用者依赖Spring容器注入到调用者中。

之所以出现两个名词是因为“控制反转”比较难懂，听者不明所以，所以有了更形象的“依赖注入”。

2. IOC的发展历程

3. Spring容器

简单说，就是Spring中生成“Bean”的工厂，并管理“Bean”的生命周期。Spring的配置文件说到底就是“Bean”的配置。

“Bean”是Spring管理的基本单位，不仅仅指简单的POJO类，组件也是“Bean”，例如数据源、事务管理器，Hibernate的SessionFactory。

Spring中内置了两种基础DI容器：BeanFactory和ApplicationContext。

ApplicationContext继承了BeanFactory的所有特性。关系如下图：

BeanFactory应用与内存、CPU资源受限的场合，一般情况下优先使用ApplicationContext，因为它除了拥有BeanFactory支持的所有功能，还可以：

  1. 载入多个配置文件
  2. 提供国际化支持
  3. 事件机制
  4. 默认初始化所有的singleton Bean（BeanFactory则不会）

常用的ApplicationContext的子类如下图：

  • XmlWebApplicationContext：面向Web应用
  • AnnotationConfigApplicationContext：基于注解存储DI元数据
  • XmlPortlerApplicationContext：面向Portal应用
  • ClassPathXmlApplicationContext、FileSystemXmlApplicationContext：适用于各种场景

4. 注入方式

Spring的注入方式有三种：设值注入、构造器注入、工厂注入。

设置注入和构造器注入

实体类：

public class Person{
    public String name;
    private Axe axe;

    public Person(Axe axe, String name) {
        System.out.println("Person 的带参构造方法");
        this.axe = axe;
        this.name = name;
    }
    /**
     * 砍柴
     */
    public void choopWood() {
        if(axe!=null){
            axe.useAxe();           
        }
    }

    public void info() {
        System.out.println("This person's name is " + name);
    }

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

    public void setAxe(Axe axe) {
        this.axe = axe;

    }

}

注入类：

public interface Axe {

    public void useAxe();
}

public class StoneAxe implements Axe {

    public void useAxe() {
        System.out.println(test + "石斧砍柴很慢");
    }
}

public class IronAxe implements Axe{

    public void useAxe() {
        System.out.println("铁斧砍柴很快");
    }

}

Spring配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!--spring配置文件的根元素，使用spring-beans-3.0.xsd语义约束（.xsd都是语言约束文件）
    xmlns:p配置可使用p标签更方便的配置属性 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
     xmlns:p="http://www.springframework.org/schema/p"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <!-- id 表示你这个组件的名字，class表示组件类；autowire为是否自动加载； lazy-init为是否懒加载，即applicationContext容器启动不自动加载 -->
    <bean id="person" class="test.wsz.spring.bean.Person" lazy-init="true" autowire="byType" >
        <!--自定义set注入,name 为成员变量名称，value为自定义的值 -->
        <property name="name" value="wsz"></property>
        <!--引用set注入,name 为成员变量名称，ref为注入bean的id -->
        <property name="axe" ref="ironaxe"></property>
        <!--构造注入,index为形参的位置，从0开始，ref为注入bean的id -->
        <constructor-arg ref="stoneaxe" index="0" /> 
        <constructor-arg value="wsz" index="1" />
    </bean>

    <!--其余实体Bean-->
    <bean id="ironaxe" class="test.wsz.spring.bean.IronAxe" />
    <bean id="stoneaxe" class="test.wsz.spring.bean.StoneAxe" />

</beans>

从配置的注释可以知道“设置注入”和“构造器注入”的配置方法。

  • “设置注入”会调用成员变量的setXXX方法。
  • “构造器注入”会调用类对应的构造方法。

测试代码：

ApplicationContext context=new ClassPathXmlApplicationContext("config/spring-config.xml");
Person person=context.getBean("person",Person.class);
person.info();
person.choopWood();

工厂方式注入

工厂方式注入有好几种，这里只举“静态工厂注入”和“工厂Bean的例子”

  • 静态工厂注入
    先创建一个工厂类：
/**
 * 静态简单工程类
 */
public class AxeFactory {
    /**
     * 获取产品的方法，根据形参返回不同的产品
     */
    public static Axe getAxe(String type) {
        if("stone".equals(type))
            return new StoneAxe();

        else if("iron".equals(type))
            return new IronAxe();

        return new StoneAxe();
    }
}

再修改之前的类当成产品类：

public class StoneAxe implements Axe {
    private String test;


    public StoneAxe() {
        System.out.println("调用StoneAxe的无参构造方法");
    }

    public void useAxe() {
        System.out.println(test + "石斧砍柴很慢");
    }

    public void setTest(String test) {
        this.test = test;
    }
}

再在xml文件中进行对应的配置：

<!--静态工厂类获取Bean,class为工厂类；factory-method为工厂获取方法-->
    <bean id="stone" class="test.wsz.spring.factory.AxeFactory" factory-method="getAxe">
        <!--设置传入工厂类获取产品方法形参的值-->
        <constructor-arg value="stone"/> 
        <!--设置注入产品Bean的属性-->
        <property name="test" value="哈哈，"></property>
    </bean>

根据配置我们可以知道，现在设置的工厂类返回StoneAxe，我们进行测试：

Axe axe=context.getBean("stone",Axe.class);
axe.useAxe();

输出：

哈哈，石斧砍柴很慢
  • 工厂Bean注入
    这种方式配置比较简单。只需要创建一个实现了Spring工厂接口的工厂类，再将这个工厂类配置在<Beans />中即可。

工厂类，需实现接口的三个方法：

public class AxeBeanFactory implements FactoryBean<Axe>{
    Axe axe=null;
    /**
     * 返回产品
     */
    public Axe getObject() throws Exception {
        if(axe==null){
            axe=new StoneAxe();
        }
        return axe;
    }
    /**
     * 返回产品的类型
     */
    public Class<?> getObjectType() {
        return Axe.class;
    }
    /**
     * 是否单例
     */
    public boolean isSingleton() {
        return true;
    }
}

xml配置：

<!--容器中的工厂Bean-->
    <bean id="stonefactory" class="test.wsz.spring.factory.AxeBeanFactory" />

值得注意的是，虽然<Bean />中配置的好像是工厂类，但实现了Spring工厂接口的该类，最终getBean()时返回的是对应的产品类。

测试代码：

Axe axe=context.getBean("stonefactory",Axe.class);
axe.useAxe();

输出：

null石斧砍柴很慢

5. 配置细节

Spring的配置的参数太多，这里只总结一些常用的。复杂的等用到时再看书就行。

<bean />中的常用配置

  • scope：
    Bean的作用域，有5种：
    • singleton：单例模式，即整个容器里面该Bean实例只有一个，默认
    • prototype：原型模式，每次getBean获取的是一个新创建的对象
    • request：每个HTTP请求，产生一个实例
    • session：每个HTTP session，产生一个实例
    • global session：每个全局的HTTP session，产生一个实例
  • lazy-init：
    懒加载，当使用使用ApplicationContext时，会自动初始化所有的singleton的“Bean”（“Bean”默认是singleton）。设置懒加载即不自动初始化这个类。
  • autowire：
    自动注入。即你不用在配置中设定成员变量的注入。设置为byType时，会自动匹配依赖类型相同的Bean，若有多个类型相同的会抛出异常。设置为byName时，会查找id名与属性名相等的Bean。
  • init-method：
    指定Bean依赖关系设置完毕后执行的方法。另外一种实现方式是让Bean类实现InitializingBean接口
  • destory-method：
    指定Bean销毁之前执行的方法。另外一种实现方式是让Bean类实现DisposableBean接口
  • p名称空间：
    可以看作一个语法糖，在<beans />中添加：
xmlns:p="http://www.springframework.org/schema/p"

即可更简单的设置注入：

<bean id="person" class="test.wsz.spring.bean.Person"
      p:name="name" />

等效于

<bean id="person" class="test.wsz.spring.bean.Person" >
       <property name="name" value="wsz"></property>
</bean>

6. 免XML的JAVA类配置

这个其实应用场景比较少，毕竟单纯用Java类完成复杂的Spring配置还是比较困难的。下面简单给个例子：

@Configuration
public class Config {

    @Value("大树") String personName;   //注入Bean的属性中的值
    @Bean(name="person")
    public Person person(){
        Person p=new Person();
        p.setName(personName);
        p.setAxe(stoneAxe());
        return p;
    }
    @Bean(name="stoneAxe")
    public Axe stoneAxe() {
        Axe axe=new StoneAxe();

        return axe;
    }   
}

除了纯粹的Java类配置，还可以在xml中引用Java类配置，或者在Java类配置中引用xml配置。有兴趣的朋友可以自行百度。

本文总结于
《疯狂JavaEE》的第七章《Spring的基本用法》

大树先生
关注
专栏目录
Spring IOC 快速入门 配置XML和使用
06-19 529
前置技能: Java、JDBC、 什么是IOC: 控制反转（Inversion of Control），是面向对象编程中的一种设计原则，可以降低代码之间的耦合度。 最常见的实现方式是依赖注入（Dependency Injection） 什么是DI： 依赖注入（Dependency Injection），A对象依赖B接口类型对象，容器把B接口的一个实现类实例化对象赋值给A中的属性b（使A持有...
Spring IOC(XML)
weixin_44545672的博客
01-21 176
开发工具与关键技术：eclipse.exe 作者：农村扛粑子 撰写时间：2020年12月28日 IOC 反转控制 是Spring的基础，Inversion Of Control 简单说就是创建对象由以前的程序员自己new 构造方法来调用，变成了交由Spring创建对象 DI 依赖注入 Dependency Inject. 简单地说就是拿到的对象的属性，已经被注入好相关值了，直接使用 即可。 首先创建Java项目。打开软件右上角点击File,点击New,在点击Dynamic Web Projiect然后就按
Spring IOC XML版
weixin_41978551的博客
08-10 131
将获取一个对象，从原来的主动new创建，转变成由一个容器进行管理，容器能够自动的创建和配置对象，程序员只需按需索取即可。 XML配置Bean <!--注册一个Person对象，Spring会自动创建这个Person对象--> <!-- 一个Bean标签可以注册一个组件(类、对象) class：写要注册的组件的全类名 id：这个对象的唯一表示，以后通过getBean(id)来从容器中找到这个对象，以及ref = id来将这个对象注入到其他组件中 --> <bean id = "
Spring-容器：IOC-基于XML管理Bean
最新发布
qq_45606619的博客
09-05 1331
​ IoC (Inversion of Control)，即控制反转，是一种设计模式或者说设计思想，它是面向对象编程中的一种概念，用来描述对象之间的依赖关系，指导我们如何设计出松耦合、更优良的程序。​ Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化控制对象与对象之间的依赖关系。我们将由 IoC 容器管理的 Java 对象称为 Spring Bean，它与使用关键字 new 创建的 Java 对象没有任何区别。
Spring IoC_xml
qq_17514043的博客
10-27 232
Spring IoC Spring IoC 容器组件，可以完成对象的创建、对象的属性赋值、对象管理 Spring框架部署（IoC） 新建Maven工程 java web 添加Spring IoC依赖 core beans aop expression context <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-beans --> &lt
Spring-IOC_xml
weixin_44919936的博客
04-27 195
文章目录概述入门案例IOC容器(IOC底层原理)IOC(接口）AppliactionContext接口的常用实现类IOC操作bean管理基于xml方式的bean管理（1）DI依赖注入-set和构造器两种方法Xml注入其他类型的属性（2）注入属性-外部bean（3）注入属性-内部bean和级联赋值Xml注入集合属性FactoryBean 工厂beanBean的作用域Bean的生命周期Xml自动装配引入外部属性文件 概述 Spring是开源的J2EE应用程序框架 目的是解决企业应用开发的复杂性 Sprin
Spring 2.5学习笔记：IoC与AOP详解
Spring2.5学习笔记是一份详细的指南，涵盖了Spring框架的多...这份学习笔记为读者提供了一个全面的学习路径，从基础概念到实际应用，对于希望通过Spring 2.5.6进行企业级开发的工程师来说，是一份非常实用的参考资料。
Spring学习笔记1之IOC详解尽量使用注解以及java代码
09-02
总之，Spring的IOC通过注解和Java配置提供了一种灵活的方式来管理对象的生命周期和依赖关系，降低了组件间的耦合，提高了代码的可读性和可维护性。在实际项目开发中，熟练掌握和运用这些知识，能够有效提升开发效率...
Spring框架学习笔记：IoC与AOP解析
本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性 - 反向控制（IoC）：IoC（Inverse of Control）也称为依赖注入（Dependency Injection），是Spring的核心之一。它通过容器...
Spring学习笔记+学习源码.zip
05-12
这份"Spring学习笔记+学习源码.zip"资源包含了深入学习Spring及其相关技术的知识点，以及实践代码，对提升Spring技能将大有裨益。 首先，我们来详细讨论Spring框架的主要组件和功能： 1. **依赖注入（Dependency ...
Spring_IoC入门笔记.md
05-29
在当前类需要用到其他类的对象时，由spring为我们提供，我们只需在配置文件中说明 依赖关系的维护：就称之为依赖注入 依赖注入： 注入方式：有三种 第一种：使用构造函数提供(创建对象时，必须提供数据，否则...
spring IOC容器依赖注入XML配置
02-05
spring IOC容器依赖注入XML配置详解 运行环境：eclipse 构建工具：maven 不提供maven构建，maven用来解决jar包的依赖
spring ioc(xml配置bean)
hewenjing8168的博客
05-26 510
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。1.xml配置实现iocpom.xml&lt;?xml version="1.0" encoding="UTF-8"?&g...
Spring系列---基本IoC/DI使用
qq_43404873的博客
11-16 282
Spring概述 什么是Spring Spring是一个以IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming)为内核的框架。IoC是Spring的基础。IoC实现的是一种控制，简单来说，就是以前调用new构造方法来创建对象，现在变成了使用Spring来创建对象。DI(Dependency Inject，依赖注入)与IoC的含义相同，从两个角度描述同一个概念。简单来说，DI就是对象的属性，已经被主任好相关值，直接使用即可。 控制反转(I
Spring-IOC实现（xml配置）
十月
04-15 290
IOC概念 IOC控制反转  是对象控制权的转移，从代码本身转移到外部容器，由spring容器来操作对象的创建、初始化、销毁工作。由spring控制对象的生命周期。 DI依赖注入  依赖注入是指程序运行过程中，遇到需要调用另一个对象协助时，无需在代码中闯将被调用者，而是依赖外部容器创建后传递给程序（依赖注入是最优秀的解耦方式），他是让spring的bean之间以配置文件方式组织咋一起。 两者之间...
Spring-IOC的XML配置
打酱油的葫芦娃
06-05 5130
引言 在Springboot编程实践中，我们偏向使用注解的方式进行Bean的注册和依赖注入等，但XML格式的容器信息管理方式仍是Spring提供的最为强大、支持最为全面的方式，本文对Spring-IOC的XML配置进行详细的讲解。 <beans>和<bean> BeanFactory和ApplicationContext的XML配置均采用统一的格式，在Spring2.0之前...
Spring(IoC的xml配置)
qq_39440949的博客
09-21 260
一、Spring概述 1、Spring的优势 Spring 出现是为了解决JavaEE 实际问题： 方便解耦，简化开发        通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。 AOP编程的支持        通过...
Spring-IOC-XML配置
Promise_J_Z
12-02 1333
Ioc是什么 IOC（inversion of control）控制反转，Spring反向控制应用程序所需要的外部资源，将控制的外部资源都放在spring容器中（ioc容器），开发者可以不用去管对象的创建和释放，全部都由spring代为完成。由我们之前主动去创建资源变为被动的由spring分配资源 简单的入门案例 第一步 配置spring的maven坐标 <dependencies> <dependency> <groupI..
Spring IoC的XML实现方式
My vegetable has exploded.
03-15 631
Spring学习笔记, 通过XML配置文件方式实现IoC
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值