【Spring篇】IOC相关内容

这篇具有很好参考价值的文章主要介绍了【Spring篇】IOC相关内容。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🍓系列专栏:Spring系列专栏

🍉个人主页:个人主页

目录

一、bean基础配置

1.bean基础配置(id与class)

2.bean的name属性

3.bean作用范围scope配置

二、bean实例化

1.构造方法实例化

2.分析Spring的错误信息

3.静态工厂实例化

4.实例工厂

5.FactoryBean

三、bean的生命周期

1.环境准备

2.生命周期设置

3.close关闭容器


通过前面两个案例,我们已经学习了 bean 如何定义配置 DI 如何定义配置 以及 容器对象如何获取 的内容,接下来主要是把这三块内容展开进行详细的讲解,深入的学习下这三部分的内容,首先是bean 基础配置。

一、bean基础配置

对于 bean 的配置中,主要会讲解 bean 基础配置 , bean 的别名配置 , bean的作用范围配置(重点) , 这三部分内容:

1.bean基础配置(idclass)

对于 bean 的基础配置,在前面的案例中已经使用过 :
 <bean id="" class=""/>
其中, bean 标签的功能、使用方式以及 id class 属性的作用,我们通过一张图来描述下
【Spring篇】IOC相关内容

 这其中需要大家重点掌握的是:bean标签的idclass属性的使用

思考:

class属性能不能写接口如BookDao的类全名呢?

  • 答案肯定是不行,因为接口是没办法创建对象的。

2.beanname属性

首先来看下别名的配置说

【Spring篇】IOC相关内容

 步骤1:配置别名

打开 spring 的配置文件 applicationContext.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">

    <!--name:为bean指定别名,别名可以有多个,使用逗号,分号,空格进行分隔-->
    <bean id="bookService" name="service service4 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>

    <!--scope:为bean设置作用范围,可选值为单例singloton,非单例prototype-->
    <bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>
</beans>
说明 :Ebi 全称 Enterprise Business Interface ,翻译为企业业务接口
步骤 2: 根据名称容器中获取 bean 对象
public class AppForName {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookService bookService = (BookService) ctx.getBean("service4");

        bookService.save();
    }
}

运行:

【Spring篇】IOC相关内容

 注意事项:

【Spring篇】IOC相关内容

 如果不存在,则会报错,如下:

【Spring篇】IOC相关内容

 获取bean无论是通过id还是name获取,如果无法获取到,将抛出异常 NoSuchBeanDefinitionException

3.bean作用范围scope配置

关于bean的作用范围是bean属性配置的一个重点内容。

看到这个作用范围,我们就得思考bean的作用范围是来控制bean哪块内容的? 我们先来看下bean作用范围的配置属性:

【Spring篇】IOC相关内容

 验证IOC容器中对象是否为单例

验证思路
同一个 bean 获取两次,将对象打印到控制台,看打印出的地址值是否一致。
具体实现
创建一个 AppForScope 的类,在其 main 方法中来验证
【Spring篇】IOC相关内容

结论:默认情况下,Spring创建的bean对象都是单例的

配置bean为非单例

在Spring配置文件中,配置scope属性来实现bean的非单例创建

  • Spring的配置文件中,修改<bean>scope属性
scope 设置为 singleton
<?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">

    <!--name:为bean指定别名,别名可以有多个,使用逗号,分号,空格进行分隔-->
    <bean id="bookService" name="service service2 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>

    <!--scope:为bean设置作用范围,可选值为单例singloton,非单例prototype-->
    <bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl"  scope="singleton"/>
</beans>

运行AppForScope,打印看结果:

【Spring篇】IOC相关内容

 scope设置为prototype

【Spring篇】IOC相关内容

结论,使用beanscope属性可以控制bean的创建是否为单例:
  • singleton默认为单例
  • prototype为非单例
scope 使用后续思考
为什么 bean 默认为单例 ?
  • bean为单例的意思是在SpringIOC容器中只会有该类的一个对象
  • bean对象只有一个就避免了对象的频繁创建与销毁,达到了bean对象的复用,性能高
bean 在容器中是单例的,会不会产生线程安全问题 ?
  • 如果对象是有状态对象,即该对象有成员变量可以用来存储数据的,
  • 因为所有请求线程共用一个bean对象,所以会存在线程安全问题。
  • 如果对象是无状态对象,即该对象没有成员变量没有进行数据存储的,
  • 因方法中的局部变量在方法调用完成后会被销毁,所以不会存在线程安全问题。
哪些 bean 对象适合交给容器进行管理 ?
  • 表现层对象
  • 业务层对象
  • 数据层对象
  • 工具对象

哪些bean对象不适合交给容器进行管理?

  • 封装实例的域对象,因为会引发线程安全问题,所以不适合。

二、bean实例化

对象已经能交给 Spring IOC 容器来创建了,但是容器是如何来创建对象的呢 ?
就需要研究下 bean 的实例化过程 ,在这块内容中主要解决两部分内容,分别是
  • bean是如何创建的
  • 实例化bean的三种方式,构造方法,静态工厂实例工厂
在讲解这三种创建方式之前,我们需要先确认一件事 :
bean 本质上就是对象,对象在 new 的时候会使用构造方法完成,那创建 bean 也是使用构造方法完成的。
基于这个知识点出发,我们来验证 spring bean 的三种创建方式

1.构造方法实例化

步骤 1: 准备需要被创建的类
准备一个 BookDao BookDaoImpl
public interface BookDao {
    public void save();
}
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }

}
步骤 2: 将类配置到 Spring 容器
<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
</beans>
步骤 3: 编写运行程序
public class AppForInstanceBook {
    public static void main(String[] args) {

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();

    }
}
步骤 4: 类中提供构造函数测试
BookDaoImpl 类中添加一个无参构造函数,并打印一句话,方便观察结果。
public class BookDaoImpl implements BookDao {

    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }

    public void save() {
        System.out.println("book dao save ...");
    }

}
运行程序,如果控制台有打印构造函数中的输出,说明 Spring 容器在创建对象的时候也走的是构造函数
【Spring篇】IOC相关内容
步骤 5: 将构造函数改成 private 测试
【Spring篇】IOC相关内容
运行程序,能执行成功 , 说明内部走的依然是构造函数 , 能访问到类中的私有构造方法 , 显而易见
Spring 底层用的是反射
步骤 6: 构造函数中添加一个参数测试
public class BookDaoImpl implements BookDao {

    private BookDaoImpl(int i) {
        System.out.println("book dao constructor is running ....");
    }

    public void save() {
        System.out.println("book dao save ...");
    }

}
运行程序,
程序会报错,说明 Spring 底层使用的是类的无参构造方法。
【Spring篇】IOC相关内容

2.分析Spring的错误信息

接下来,我们主要研究下Spring的报错信息来学一学如阅读。

错误信息从下往上依次查看,因为上面的错误大都是对下面错误的一个包装,最核心错误是在最下

Caused by: java.lang.NoSuchMethodException:
com.itheima.dao.impl.BookDaoImpl. <init> ()
  • Caused by 翻译为引起,即出现错误的原因
  • java.lang.NoSuchMethodException:抛出的异常为  没有这样的方法异常
  • com.itheima.dao.impl.BookDaoImpl. <init> ():哪个类的哪个方法没有被找到导致的异常,<init> ()指定是类的构造方法,即该类的无参构造方法

如果最后一行错误获取不到错误信息,接下来查看第二层:

Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'bookDao' defined in class path resource [applicationContext.xml]: Instantiation of bean failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.itheima.dao.impl.BookDaoImpl]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.itheima.dao.impl.BookDaoImpl.<init>()

  • nested:嵌套的意思,后面的异常内容和最底层的异常是一致的
  • BeanInstantiationException:翻译为bean实例化异常
  • No default constructor found:没有一个默认的构造函数被发现

3.静态工厂实例化

接下来研究Spring中的第二种bean的创建方式静态工厂实例化:

工厂方式创建bean

在讲这种方式之前,我们需要先回顾一个知识点是使用工厂来创建对象的方式 :
(1) 准备一个 OrderDao OrderDaoImpl
public class OrderDaoImpl implements OrderDao {

    public void save() {
        System.out.println("order dao save ...");
    }
}
public interface OrderDao {
    public void save();
}
(2) 创建一个工厂类 OrderDaoFactory 并提供一个 静态方法
//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}
(3) 编写 AppForInstanceOrder 运行类,在类中通过工厂获取对象
public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();



    }
}

【Spring篇】IOC相关内容

 如果代码中对象是通过上面的这种方式来创建的,如何将其交给Spring来管理呢?

静态工厂实例化

这就要用到 Spring 中的静态工厂实例化的知识了,具体实现步骤为 :
(1) spring 的配置文件 application.properties 中添加以下内容 :
 <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
class: 工厂类的类全名
factory-mehod: 具体工厂类中创建对象的方法名
对应关系如下图
【Spring篇】IOC相关内容

 (2)AppForInstanceOrder运行类,使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过静态工厂创建对象
//        OrderDao orderDao = OrderDaoFactory.getOrderDao();
//        orderDao.save();


        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();

    }
}

【Spring篇】IOC相关内容

4.实例工厂

接下来继续来研究Spring的第三种bean的创建方式实例工厂实例化:

环境准备

(1) 准备一个 UserDao UserDaoImpl
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {

    public void save() {
        System.out.println("user dao save ...");
    }
}
(2) 创建一个工厂类 OrderDaoFactory 并提供一个普通方法,注意此处和静态工厂的工厂类不一样的
地方是方法不是静态方法
//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
(3) 编写 AppForInstanceUser 运行类,在类中通过工厂获取对象
public class AppForInstanceUser {
    public static void main(String[] args) {
        //创建实例工厂对象
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //通过实例工厂对象创建对象
        UserDao userDao = userDaoFactory.getUserDao();
        userDao.save();


    }
}
运行后,可以查看到结果
【Spring篇】IOC相关内容

对于上面这种实例工厂的方式如何交给Spring管理呢?

实例工厂实例化  

具体实现步骤为 :
(1) spring 的配置文件中添加以下内容 :
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
实例化工厂运行的顺序是 :
  • 创建实例化工厂对象,对应的是第一行配置
  • 调用对象中的方法来创建bean,对应的是第二行配置
  • factory-bean: 工厂的实例对象
  • factory-method:工厂对象中的具体创建对象的方法名 , 对应关系如下 :
【Spring篇】IOC相关内容

 factory-mehod:具体工厂类中创建对象的方法名

(2)AppForInstanceUser运行类,使用从IOC容器中获取bean的方法进行运行测试

public class AppForInstanceUser {
    public static void main(String[] args) {


        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = (UserDao) ctx.getBean("userDao");

        userDao.save();

    }
}

【Spring篇】IOC相关内容

 实例工厂实例化的方式就已经介绍完了,配置的过程还是比较复杂,所以Spring为了简化这种配置方式就提供了一种叫FactoryBean的方式来简化开发。

5.FactoryBean

具体的使用步骤为 :
(1) 创建一个 UserDaoFactoryBean 的类,实现 FactoryBean 接口,重写接口的方法
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }

}
(2) Spring 的配置文件中进行配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
(3)AppForInstanceUser 运行类不用做任何修改,直接运行
【Spring篇】IOC相关内容
这种方式在 Spring 去整合其他框架的时候会被用到,所以这种方式需要大家理解掌握。
查看源码会发现, FactoryBean 接口其实会有三个方法,分别是 :
 getObject() throws Exception;

 Class<?> getObjectType();

 default boolean isSingleton() {
 return true;
 }
方法一 :getObject() ,被重写后,在方法中进行对象的创建并返回
方法二 :getObjectType(), 被重写后,主要返回的是被创建类的 Class 对象
方法三 : 没有被重写,因为它已经给了默认值,从方法名中可以看出其作用是设置对象是否为单例,默认true ,从意思上来看,我们猜想默认应该是单例,如何来验证呢 ?
思路很简单,就是从容器中获取该对象的多个值,打印到控制台,查看是否为同一个对象。
public class AppForInstanceUser {
    public static void main(String[] args) {


        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao1 = (UserDao) ctx.getBean("userDao");
        UserDao userDao2 = (UserDao) ctx.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
//        userDao.save();

    }
}
打印结果,如下 :
【Spring篇】IOC相关内容

通过验证,会发现默认是单例,那如果想改成单例具体如何实现?

只需要将 isSingleton() 方法进行重写,修改返回为 false ,即可
public class UserDaoFactoryBean implements FactoryBean<UserDao> {


    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }

    public boolean isSingleton() {
        return false;
    }
 


}
重新运行 AppForInstanceUser ,查看结果
【Spring篇】IOC相关内容
从结果中可以看出现在已经是非单例了,但是一般情况下我们都会采用单例,也就是采用默认即可。所以isSingleton() 方法一般不需要进行重写。

三、bean的生命周期

关于 bean 的相关知识还有最后一个是 bean 的生命周期 , 对于生命周期,我们主要围绕着 bean 生命周期控制来讲解 :
首先理解下什么是生命周期 ?
  • 从创建到消亡的完整过程,例如人从出生到死亡的整个过程就是一个生命周期。
bean 生命周期是什么 ?
  • bean对象从创建到销毁的整体过程。
构造方法 bean 生命周期控制是什么 ?
  • bean创建后到销毁前做一些事情。
现在我们面临的问题是如何在 bean 的创建之后和销毁之前把我们需要添加的内容添加进去。

1.环境准备

项目结构: 

【Spring篇】IOC相关内容

(1)项目中添加BookDaoBookDaoImplBookServiceBookServiceImpl

public interface BookDao {
    public void save();
}
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
}
public class BookServiceImpl implements BookService{
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
}
(2)resources 下提供 spring 的配置文件
<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
</beans>
(3) 编写 AppForLifeCycle 运行类,加载 Spring IOC 容器,并从中获取对应的 bean 对象
public class AppForLifeCycle {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();

    }
}

2.生命周期设置

接下来,在上面这个环境中来为 BookDao 添加生命周期的控制方法,具体的控制有两个阶段 :
  • bean创建之后,想要添加内容,比如用来初始化需要用到资源
  • bean销毁之前,想要添加内容,比如用来释放用到的资源

步骤1:添加初始化和销毁方法

针对这两个阶段,我们在 BookDaoImpl 类中分别添加两个方法, 方法名任意
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
    //表示bean初始化对应的操作
    public void init(){
        System.out.println("init...");
    }
    //表示bean销毁前对应的操作
    public void destory(){
        System.out.println("destory...");
    }

}

步骤2:配置生命周期

在配置文件添加配置,如下 :
  <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory" ></bean>
运行程序
【Spring篇】IOC相关内容
从结果中可以看出, init 方法执行了,但是 destroy 方法却未执行,这是为什么呢 ?
  • SpringIOC容器是运行在JVM
  • 运行main方法后,JVM启动,Spring加载配置文件生成IOC容器,从容器获取bean对象,然后调方 法执行
  • main方法执行完后,JVM退出,这个时候IOC容器中的bean还没有来得及销毁就已经结束了 所以没有调用对应的destroy方法
知道了出现问题的原因,具体该如何解决呢 ?

3.close关闭容器

 调用ctxclose()方法

public class AppForLifeCycle {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        ctx.close();
    }
}
运行程序,就能执行 destroy 方法的内容:
【Spring篇】IOC相关内容
注册钩子关闭容器
  • 在容器未关闭之前,提前设置好回调函数,让JVM在退出之前回调此函数来关闭容器
  • 调用ctxregisterShutdownHook()方法
public class AppForLifeCycle {
    public static void main( String[] args ) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
//        注册关闭钩子函数,在虚拟机退出之前回调此函数,关闭容器
        ctx.registerShutdownHook();

    }
}

【Spring篇】IOC相关内容

两种方式介绍完后, close registerShutdownHook 选哪个 ?
相同点 : 这两种都能用来关闭容器
不同点 :close() 是在调用的时候关闭, registerShutdownHook() 是在 JVM 退出前调用关闭。
分析上面的实现过程,会发现添加初始化和销毁方法,即需要编码也需要配置,实现起来步骤比较多也比较乱。
Spring 提供了两个接口来完成生命周期的控制,好处是可以不用再进行配置 init - method 和destroy- method
接下来在 BookServiceImpl 完成这两个接口的使用 :
修改BookServiceImpl 类,添加两个接口 InitializingBean DisposableBean 并实现接口中的
两个方法 afterPropertiesSet destroy
public class BookServiceImpl implements BookService,InitializingBean,DisposableBean
{
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        System.out.println("set .....");
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

    public void destroy() throws Exception {
        System.out.println("service destroy");
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}
pox.xml:
  <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>
重新运行 AppForLifeCycle

 【Spring篇】IOC相关内容文章来源地址https://www.toymoban.com/news/detail-425018.html

bean 生命周期小结
(1) 关于 Spring 中对 bean 生命周期控制提供了两种方式 :
  • 在配置文件中的bean标签中添加init-methoddestroy-method属性
  • 类实现InitializingBeanDisposableBean接口,这种方式了解下即可。
(2) 对于 bean 的生命周期控制在 bean 的整个生命周期中所处的位置如下 :
初始化容器
  • 1.创建对象(内存分配)
  • 2.执行构造方法
  • 3.执行属性注入(set操作)
  • 4.执行bean初始化方法
使用 bean
  • 1.执行业务操作
关闭 / 销毁容器
  • 1.执行bean销毁方法
(3) 关闭容器的两种方式 :
ConfigurableApplicationContext ApplicationContext 的子类
  • close()方法
  • registerShutdownHook()方法

到了这里,关于【Spring篇】IOC相关内容的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • spring框架,以及和spring框架相关的Java面试题和spring ioc的注入方式

    目录 一.spring来源,以及介绍 1.spring诞生的背景 2.spring框架 介绍 3.spring框架在使用中的优点以及不足 3.1优点  3.2不足 3.3总结 4.为什么要使用spring  二.将spring框架部署在IDEA中  1.替换pom.xml  2.构建spring所需要的xml文件 三.spring的三种注入方式 0.定义需要的类,方法 1.方法注入

    2024年02月12日
    浏览(49)
  • spring 容器结构/机制debug分析--Spring 学习的核心内容和几个重要概念--IOC 的开发模式--综合解图

    😀前言 本片文章是spring 容器结构/机制debug分析和几个重要概念以及IOC 的开发模式 🏠个人主页:[尘觉主页](https://blog.csdn.net/apple_67445472?type=blog) 🧑个人简介:大家好,我是尘觉,希望我的文章可以帮助到大家,您的满意是我的动力😉😉 在csdn获奖荣誉: 🏆csdn城市之星2名

    2024年02月02日
    浏览(58)
  • 【Spring篇】DI相关内容

    🍓系列专栏:Spring系列专栏 🍉个人主页:个人主页 目录 一、setter注入 1.环境准备 2.注入引用数据类型 3.注入简单数据类型 二、构造器注入 1.环境准备 2.构造器注入引用数据类型 3.构造器注入多个引用数据类型 4.构造器注入多个简单数据类型 三、自动配置 1.什么是依赖自动装

    2023年04月27日
    浏览(31)
  • Spring IOC:IOC在Spring底层中如何实现?

    编译软件:IntelliJ IDEA 2019.2.4 x64 操作系统:win10 x64 位 家庭版 Maven版本:apache-maven-3.6.3 Mybatis版本:3.5.6 spring版本:5.3.1 第一章:初识Spring:如何在Maven工程上搭建Spring框架? 第二章:Spring IOC:IOC在Spring底层中如何实现? IOC ,英文全称为Inversion of Control,意为 反转控制 。不

    2024年02月03日
    浏览(36)
  • Spring IoC容器、IoC与DI

    目录 Spring是什么? 理解容器  什么是IoC(Inversion of Control) 传统的new创建对象的方式中类与类的耦合程度很大。  IoC的优势:  Spring IoC容器最核心的功能  什么是DI (Dependency Injection) IoC和DI的区别  Spring是指Spring Framework(Spring框架),它是开源的框架,有着很庞大的社区,通过

    2023年04月21日
    浏览(95)
  • Spring——Spring IOC原理

    IoC 不是一种技术,只是一种思想,一个重要的面向对象编程的法则,它能指导我们如何设计出松耦合、更优良的程序。传统应用程序都是由我们在类内部主动创建依赖对象,从而导致类与类之间高耦合,难于测试;有了IoC容器后,把创建和查找依赖对象的控制权交给了容器

    2024年02月09日
    浏览(46)
  • Spring核心容器IOC案例讲解,带你理解IOC

    Universe Infinity inc. 什么是IOC容器,先把IOC给忽略到,其实就是个容器。 什么?容器又是个啥玩意?容器是用来放东西的东西啊。 各个领域都喜欢起一些专业术语,显得很高级。给你讲IOC是不是很高级,给你讲Map是不是就明白了。 bean对象最终存储在spring容器中,在spring源码底

    2024年01月24日
    浏览(37)
  • 【Spring】Spring对IoC的实现

    根据 【动力节点】最新Spring框架教程,全网首套Spring6教程,跟老杜从零学spring入门到高级 以及老杜的原版笔记 https://www.yuque.com/docs/share/866abad4-7106-45e7-afcd-245a733b073f?# 《Spring6》 进行整理, 文档密码:mg9b Spring 相关文章整理汇总归纳于:https://www.yuque.com/u27599042/zuisie IoC 控制

    2024年02月15日
    浏览(35)
  • 什么是IoC?什么是Spring IoC?什么是DI?

    首先说明 IoC 是一种思想,IoC的全称是Inversion of Control,翻译成中文叫做 “控制反转” 用人话来说,IoC的思想就是将一个对象对另一个对象的控制权交出去(不必关心交给谁),从而让对象之间的依赖关系降低,降低代码之间耦合程度。 我们可以写一个简单的代码来举个例子

    2024年02月14日
    浏览(49)
  • Spring IOC & AOP

    IOC,全程Inversion of Control(控制反转) 通过控制反转(创建对象的权限交给框架,所以叫反转)创建的对象被称为 Spring Bean ,这个Bean和用new创建出来的对象是没有任何区别的。 官方解释:Spring 通过 IoC 容器来管理所有 Java 对象的实例化和初始化,控制对象与对象之间的依赖

    2024年02月16日
    浏览(37)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包