Spring IOC的四种手动注入方法

已于 2024-01-03 08:49:02 修改
阅读量1.1k 收藏 16
点赞数 14
分类专栏： spring 文章标签： spring java 数据库
于 2024-01-02 21:46:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52879387/article/details/135342334
版权

手动注入


Spring ⽀持的注⼊⽅式共有四种：set 注⼊、构造器注⼊、静态⼯⼚注⼊、实例化⼯⼚注⼊
注：注入前提均建立在建立好的spring环境内

1.Set方法注入-五种类型的注入

以业务对象JavaBean为主

1.1 业务对象JavaBean

第一步：创建dao包下的UserDao类

package com.svt.dao;

public class UserDao {
    public void test(){
        System.out.println("UserDao Test...");
    }
}

第二步：属性字段提供set⽅法

原先写的方式都是手动实例化，比如private UserDao userDao=new UserDao();，这样会耦合过高，所以我们采用了新的形式：注入

package com.svt.service;

import com.svt.dao.UserDao;

public class UserService {

    //手动实例化
    //private UserDao userDao=new UserDao();

    //业务逻辑对象JavaBean 提供set方法注入
    //在配置文件中还未告知set方法注入 所以userDao是空的
    //将这里bean对象实例化的过程交给IOC去做
    private UserDao userDao;

    //set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

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

第三步：配置⽂件的bean标签设置property标签

通过property属性实现注入

<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        Set方法注入
            通过property属性注入

    -->
    <bean id="userService" class="com.svt.service.UserService">
        <!--
            name:bean对象中属性字段的名称
            ref：指定bean标签的id属性值
        -->
        <property name="userDao" ref="userDao" />
    </bean>

    <bean id="userDao" class="com.svt.dao.UserDao"></bean>

</beans>

如果没有在资源文件夹xml内通过property属性实现注入，那么会出现空指针异常

在这里插入图片描述

第四步：测试

在UserService类中写测试方法

public void test(){
        System.out.println("UserService Test...");
        //JavaBean对象
        userDao.test();
    }

再在测试类中调用

import com.svt.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter01 {
    public static void main(String[] args) {
        //获取Spring的上下文环境 BeanFactory也是可以的
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");

        UserService userService= (UserService) ac.getBean("userService");
        userService.test();

    }
}

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

1.2 常用对象String（日期类型）| 基本类型Integer

第一步：属性字段提供 set ⽅法

    //常用对象String（日期类型）
    private String host;
    public void setHost(String host) {
        this.host = host;
    }

    //基本类型 Integer
    private Integer port;
    public void setPort(Integer port) {
        this.port = port;
    }

第二步：配置⽂件的 bean 标签设置 property 标签

		<!-- value:具体的值（基本类型 常用对象|日期  集合）-->
        <!-- 常用对象 String-->
        <property name="host" value="127.0.0.1"/>
        <!-- 基本类型Integer-->
        <property name="port" value="8080"/>

第三步：测试

在UserService类中写测试方法

public void test(){
        System.out.println("UserService Test...");
        //常用对象
        System.out.println(host);
        //基本类型
        System.out.println(port);
    }

再在测试类中调用

import com.svt.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter01 {
    public static void main(String[] args) {
        //获取Spring的上下文环境 BeanFactory也是可以的
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring.xml");

        UserService userService= (UserService) ac.getBean("userService");
        userService.test();

    }
}

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

1.3 集合类型和属性对象

第一步：属性字段提供set⽅法

//List集合
    private List<String> list;
    public void setList(List<String> list) {
        this.list = list;
    }
    //List输出
    public void printList(){
        list.forEach(v-> System.out.println(v));//jdk8提供
    }

    //Set集合
    private Set<String> sets;
    public void setSets(Set<String> sets) {
        this.sets = sets;
    }
    //Set输出
    public void printSet(){
        sets.forEach(v-> System.out.println(v));
    }

    //Map集合
    private Map<String,Object> map;
    public void setMap(Map<String, Object> map) {
        this.map = map;
    }
    //Map输出
    public void printMap(){
        map.forEach((k,v)-> System.out.println(k+"="+v));
    }

    //Properties属性对象
    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    //Properties输出
    public void printProperties(){
        properties.forEach((k,v)-> System.out.println(k+"="+v));
    }

第二步：配置⽂件的bean标签设置property标签

<!--        List集合-->
        <property name="list">
            <list>
                <value>江苏</value>
                <value>浙江</value>
                <value>上海</value>
            </list>
        </property>

        <!--        Set集合-->
        <property name="sets">
            <set>
                <value>江苏JS</value>
                <value>浙江ZJ</value>
                <value>上海SH</value>
            </set>
        </property>

        <!--        Map集合-->
        <property name="map">
            <map>
                <entry>
                    <key>
                        <value>周杰伦</value>
                    </key>
                    <value>晴天</value>
                </entry>
                <entry>
                    <key>
                        <value>林俊杰</value>
                    </key>
                    <value>美人鱼</value>
                </entry>
                <entry>
                    <key>
                        <value>陈奕迅</value>
                    </key>
                    <value>富士山下</value>
                </entry>
            </map>
        </property>

        <!--        Properties属性对象-->
        <property name="properties">
            <props>
                <prop key="js">江苏</prop>
                <prop key="zj">浙江</prop>
                <prop key="sh">上海</prop>
            </props>
        </property>

第三步：测试

与上面一样

public void test(){
        System.out.println("UserService Test...");
        //List集合类型
        printList();
        //Set集合类型
        printSet();
        //Map集合类型
        printMap();
        //Properties属性对象
        printProperties();
    }

在这里插入图片描述

2.构造器方法注入-种形式的注入

2.1 单个Bean对象作为参数

第一步：JavaBean对象

package com.svt.service;

import com.svt.dao.UserDao02;

/**
 * 构造器方法注入
 *  需要提供带参构造
 */
public class UserService02 {
    private UserDao02 userDao02;
    /* 构造器注入*/

    public UserService02(UserDao02 userDao02) {
        this.userDao02 = userDao02;
    }
    public void test(){
        System.out.println("UserService Test...");
    }
}

第二步：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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        构造器注入
            设置构造器所需要的参数
            通过constructor-arg标签设置构造器的参数
                name:属性名称
                ref:要注入的bean对象对应的bean标签的id属性值
    -->
    <bean id="userService02" class="com.svt.service.UserService02">
        <constructor-arg name="userDao02" ref="userDao02"></constructor-arg>
    </bean>

    <bean id="userDao02" class="com.svt.dao.UserDao02"></bean>

</beans>

第三步：测试

import com.svt.service.UserService02;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter02 {
    public static void main(String[] args) {
        //获取Spring的上下文环境 BeanFactory也是可以的
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring02.xml");

        UserService02 userService02= (UserService02) ac.getBean("userService02");
        userService02.test();

    }
}

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

2.2 多个Bean对象作为参数

第一步：JavaBean对象

package com.svt.service;

import com.svt.dao.UserDao;
import com.svt.dao.UserDao02;

/**
 * 构造器方法注入
 *  需要提供带参构造
 */
public class UserService02 {
    private UserDao02 userDao02;
    /* 构造器注入*/

    /*public UserService02(UserDao02 userDao02) {
        this.userDao02 = userDao02;
    }*/

    private UserDao userDao;

    public UserService02(UserDao02 userDao02, UserDao userDao) {
        this.userDao02 = userDao02;
        this.userDao = userDao;
    }

    public void test(){
        System.out.println("UserService Test...");
        userDao02.test();
        userDao.test();
    }
}

第二步：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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        构造器注入
            设置构造器所需要的参数
            通过constructor-arg标签设置构造器的参数
                name:属性名称
                ref:要注入的bean对象对应的bean标签的id属性值
                value:数据具体的值
                index:参数的位置（从0开始）一般不用 但是可以确定参数是哪个位置的
    -->
    <bean id="userService02" class="com.svt.service.UserService02">
        <constructor-arg name="userDao02" ref="userDao02"></constructor-arg>
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>

    </bean>

    <bean id="userDao02" class="com.svt.dao.UserDao02"></bean>
    <bean id="userDao" class="com.svt.dao.UserDao"></bean>

</beans>

如果在写完JavaBean对象而没有在配置文件中添加bean则会出现以下报错内容，像上面xml文件中一样添加 <constructor-arg name="userDao" ref="userDao"></constructor-arg>即可
在这里插入图片描述

第三步：测试

在UserService02中的test测试方法中新增了两行输出语句

public void test(){
        System.out.println("UserService Test...");
        userDao02.test();
        userDao.test();
    }

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

2.3 Bean对象和常⽤对象作为参数

第一步：加入常用对象String（举例）

	private UserDao02 userDao02;
    /* 构造器注入*/

    private UserDao userDao;
    
    private String user;

    public UserService02(UserDao02 userDao02, UserDao userDao, String user) {
        this.userDao02 = userDao02;
        this.userDao = userDao;
        this.user = user;
    }

第二步：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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        构造器注入
            设置构造器所需要的参数
            通过constructor-arg标签设置构造器的参数
                name:属性名称
                ref:要注入的bean对象对应的bean标签的id属性值
                value:数据具体的值
                index:参数的位置（从0开始）一般不用 但是可以确定参数是哪个位置的
    -->
    <bean id="userService02" class="com.svt.service.UserService02">
        <constructor-arg name="userDao02" ref="userDao02"></constructor-arg>
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
        <constructor-arg name="user" value="user" index=""></constructor-arg>

    </bean>

    <bean id="userDao02" class="com.svt.dao.UserDao02"></bean>
    <bean id="userDao" class="com.svt.dao.UserDao"></bean>

</beans>

在这里插入图片描述

第三步：测试

在UserService02中的test测试方法中新增了一行输出语句

public void test(){
        System.out.println("UserService Test...");
        userDao02.test();
        userDao.test();
        System.out.println(user);
    }

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

2.4 循环依赖问题

产生原因：Bean 通过构造器注⼊，之间彼此相互依赖对⽅导致 bean ⽆法实例化。比如一个IOC容器要去实例化A，但是A中有B的注入，于是IOC就先去找B实例化，此时B中又有A的注入，IOC又要去找A先进行初始化，这样一套下来IOC不知道是先找A还是B就会出现循环依赖的问题。

问题示例

  • 代码示例
public class AccountService {
    private AccountDao accountDao;

    public AccountService(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void test(){
        System.out.println("AccountService Test...");
        accountDao.test();
    }
}

public class AccountDao {
    private AccountService accountService;

    public AccountDao(AccountService accountService) {
        this.accountService = accountService;
    }

    public void test(){
        System.out.println("AccountDao Test...");
    }
}
  • 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
		https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    循环依赖问题-->
    <bean id="acountService" class="com.svt.service.AccountService">
        <constructor-arg name="accountDao" ref="accountDao"></constructor-arg>
    </bean>
    <bean id="accountDao" class="com.svt.dao.AccountDao">
        <constructor-arg name="accountService" ref="acountService"></constructor-arg>
    </bean>
</beans>

此时AccountDao 注入了AccountService ，而AccountService 也注入了AccountDao ，这就造成了循环依赖
在这里插入图片描述

问题解决

如果出现循环依赖 需要通过set注入解决，下面就依据上面的循环注入代码进行解决

  • 解决代码示例
public class AccountDao {
    private AccountService accountService;
    
    public void setAccountService(AccountService accountService) {
        this.accountService = accountService;
    }

    public void test(){
        System.out.println("AccountDao Test...");
    }
}

public class AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public void test(){
        System.out.println("AccountService Test...");
        accountDao.test();
    }
}
  • 解决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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--    如果出现循环依赖 需要通过set注入解决-->

    <bean id="accountService" class="com.svt.service.AccountService">
        <property name="accountDao" ref="accountDao"></property>
    </bean>
    <bean id="accountDao" class="com.svt.dao.AccountDao">
        <property name="accountService" ref="accountService"></property>
    </bean>
    <!--
        构造器必须等待构造器参数中的实例化实例化好后才会实例化本身
        set方法注入：先实例化对象，再找被注入的set进去，就不会造成循环依赖
    -->
</beans>

原因

  • 构造器注入：必须等待构造器参数中的实例化实例化好后才会实例化本身
  • set方法注入：先实例化对象，再找被注入的set进去，就不会造成循环依赖
    在这里插入图片描述

3.静态工厂注入（了解）

第一步：创建工厂类

new factory->new StaticFactory

package com.svt.factory;

import com.svt.dao.TypeDao;

//静态工厂
public class StaticFactory {
    //定义静态方法
    public static TypeDao createTypeDao(){
        return new TypeDao();
    }
}

第二步：创建dao实体类

package com.svt.dao;

public class TypeDao {
    public void test(){
        System.out.println("TypeDao Test...");
    }
}

第三步：创建TypeService，注入TypeDao

package com.svt.service;

import com.svt.dao.TypeDao;

public class TypeService {
    //注入TypeDao
    private TypeDao typeDao;

    public void setTypeDao(TypeDao typeDao) {
        this.typeDao = typeDao;
    }

    public void test(){
        System.out.println("TypeService Test...");
        typeDao.test();
    }
}

第四步：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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--    静态工厂-->
    <!--    定义bean对象-->
    <bean id="typeService" class="com.svt.service.TypeService">
        <property name="typeDao" ref="typeDao"></property>
    </bean>
<!--    静态工厂注入：通过静态构造实例化需要被注入的bean对象-->
    <bean id="typeDao" class="com.svt.factory.StaticFactory" factory-method="createTypeDao"></bean>
</beans>

第五步：测试


import com.svt.service.TypeService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Starter02 {
    public static void main(String[] args) {
        //获取Spring的上下文环境 BeanFactory也是可以的
        ApplicationContext ac=new ClassPathXmlApplicationContext("spring02.xml");

        TypeService typeService= (TypeService) ac.getBean("typeService");
        typeService.test();

    }
}

在这里插入图片描述
出现测试类中展现的内容则代表注入无误

4.实例化工厂注入（了解）

实例化工厂注入与静态工厂注入大致一样，有以下几点不同

4.1 定义实例化工厂，写非静态方法

静态工厂里写的是静态方法，实例化工厂里写的非静态方法

package com.svt.factory;

import com.svt.dao.TypeDao;

//定义实例化工厂
public class InstanceFactory {
    public TypeDao createTypeDao(){
        return new TypeDao();
    }
}

4.2 修改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
		https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--    定义bean对象-->
    <bean id="typeService" class="com.svt.service.TypeService">
        <property name="typeDao" ref="typeDao"></property>
    </bean>
    
<!--    实例化工厂注入：通过实例化工厂需要被注入的bean对象-->
    <bean id="instanceFactory" class="com.svt.factory.InstanceFactory"></bean>
    <bean id="typeDao" factory-bean="instanceFactory" factory-method="createTypeDao"></bean>
</beans>

其余与静态工厂一致，测试类实现结果也与静态工厂一致
静态工厂注入与实例化工厂注入本质上还是set注入，只是本来bean对象是通过构造器去实例化的，现在更换了以下，想要静态工厂注入就把实例化的方式变成静态工厂，实例化工厂同理，两者用的不多，理解即可

注入方式的选择

开发项⽬中set⽅式注⼊⾸选
使⽤构造注⼊可以在构建对象的同时⼀并完成依赖关系的建⽴，对象⼀建⽴则所有的⼀切也就准备好
了，但如果要建⽴的对象关系很多，使⽤构造器注⼊会在构建函数上留下⼀⻓串的参数,且不易记忆,这时使⽤Set注⼊会是个不错的选择。
使⽤Set注⼊可以有明确的名称，可以了解注⼊的对象会是什么，像setXXX()这样的名称会⽐记忆Constructor上某个参数的位置代表某个对象更好。

p名称空间的使用（了解）

spring2.5以后，为了简化setter方法属性注入，引用p名称空间的概念，可以将子元素，简化为元素属性配置。

第一步：属性字段提供set方法

package com.svt.service;

import com.svt.dao.UserDao;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * Set方法注入
 * 1.属性字段提供set方法
 * 2.在配置文件中通过property属性指定属性字段
 */
public class UserService03 {

    //手动实例化
    //private UserDao userDao=new UserDao();

    //业务逻辑对象JavaBean 提供set方法注入
    //在配置文件中还未告知set方法注入 所以userDao是空的
    //将这里bean对象实例化的过程交给IOC去做
    private UserDao userDao;
    //set方法
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }


    //常用对象String（日期类型）
    private String host;
    public void setHost(String host) {
        this.host = host;
    }

    public void test(){
        System.out.println("UserService Test...");
        //JavaBean对象
        userDao.test();

    }
}

第二步：在配置文件xml引入p名称空间

xmlns:p="http://www.springframework.org/schema/p"

<?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
		https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    p名称空间：简化set属性的注入-->
    <bean id="userDao" class="com.svt.dao.UserDao"></bean>
    <bean id="userService03" class="com.svt.service.UserService03"
          p:host="127.0.0.1"
          p:userDao-ref="userDao"
    >

    </bean>
	<!--
		p:属性名:="xxx 引入常量值
		p:属性名-ref;="xxx" 引入其他Bean对象的id属性值
	-->
</beans>
今年不养猪只除草
关注
  • 14
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
手动模拟实现Spring-IOC
yangsnow_rain_wind的专栏
05-07 1493
Spring框架太大,读源码包装太严重, 抽丝剥茧整理出主要思路,自己模拟一份Spring框架,该框架支持如下功能: DI,IOC,等基础功能; 主要类如下: FLBeanDefinition: 保存XML中Bean被解析后的基本信息, FLBeanWrapper: 包装实例化的Bean,以及被代理的bean FLDefaultListableBeanFactory,用来...
Spring之手动注入
猎户星座
07-26 1058
本文内容 主要介绍xml中依赖注入的配置 构造器注入的3种方式详解 set方法注入详解 注入容器中的其他bean的2种方式 其他常见类型注入详解 依赖回顾 通常情况下，系统中类和类之间是有依赖关系的，如果一个类对外提供的功能需要通过调用其他类的方法来实现的时候，说明这两个类之间存在依赖关系，如： publicclassUserService{ publicvoidinsert(UserModelmodel){ //插入...
Spring框架学习笔记（四）：手动实现 Spring 底层机制(初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP)
最新发布
2301_76144723的博客
05-21 969
手动实现 Spring 底层机制，初始化 IOC容器+依赖注入+BeanPostProcessor 机制+AOP
spring手动注入
arcai0755的博客
09-06 244
pojo—> Inform.hbm.xml <hibernate-mapping> <class name="com.ambow.pojo.Inform" table="inform" catalog="first_office" lazy="false"> <id name="id" type="integer"> ...
Spring系列之依赖注入---手动注入
azhou的代码园
04-23 1104
本文内容 主要介绍xml中依赖注入的配置 构造器注入的3种方式详解 set方法注入详解 注入容器中的其他bean的2种方式 其他常见类型注入详解 依赖回顾 通常情况下，系统中类和类之间是有依赖关系的，如果一个类对外提供的功能需要通过调用其他类的方法来实现的时候，说明这两个类之间存在依赖关系，如： publicclassUserService{ publicvoidinsert(UserModelmodel){ //插入...
Spring IOC 手动注入
理想主义的花终将盛开在浪漫主义的土壤里，我的热情永远不会熄灭在现实的平凡之中，我们终将上岸，阳光万里。
11-02 275
Spring IOC 注入 主动实例化 1.设置配置文件 <?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/s
Spring.Net IOC依赖注入原理流程解析
08-18
Spring.Net IOC依赖注入原理流程解析 本文将详细介绍Spring.Net IOC依赖注入原理流程解析，通过示例代码介绍了非常详细，对大家的学习或者工作具有一定的参考学习价值。 一、什么是IOC？ IOC（Inversion of ...
实验四_SpringIoC.rar
04-13
Spring框架是Java开发中不可或缺的一部分，它以其强大的依赖注入（Dependency Injection，简称DI）和控制反转（Inversion of Control，简称IoC）功能而闻名。在这个实验中，我们将深入理解并实践Spring IoC的核心...
Spring_IOC_.rar_spring ioc
09-23
在Spring框架中，IOC主要体现在两个方面：依赖注入（Dependency Injection，简称DI）和Bean工厂。依赖注入是IOC的核心，它允许我们不通过硬编码的方式来指定对象之间的依赖关系，而是通过配置文件或注解来声明这些...
SpringIoc示例代码
06-14
2. **依赖注入（DI）**：Spring IOC的主要功能之一就是依赖注入。有两种方式实现DI：构造器注入和setter注入。构造器注入是在Bean实例化时通过构造函数传递依赖，而setter注入则是通过调用setter方法设置依赖。在`...
手写一个SpringIoc容器
04-12
本项目"手写一个SpringIoc容器"旨在模仿Spring的IOC（Inversion of Control，控制反转）功能，帮助开发者深入理解Spring的工作原理，提升对依赖注入（Dependency Injection）模式的认识。 在实现自定义的Spring IOC...
手动实现Spring的IoC
weixin_41788024的博客
08-16 58
spring ioc di
spring手动注入bean
Elsa
04-27 4402
不通过spring管理的bean的相互依赖方式
Spring中注入的三种方式
王硕的专栏
04-19 183
Spring中注入的三种方式   Type1 接口注入   我们常常借助接口来将调用者与实现者分离。如： Public class ClassA{ private InterfaceB clzB; public init(){ Object obj=Class.forName(Config.BImplementation).newInstance(); clzB=(Int...
Spring02-注入依赖(手动)
hd_cash的博客
03-10 205
当一个类A作为类B的属性，如何实例化类A： 主动创建： public class catService { //注入方式1：new对象 catDao cd=new catDao(); } 非主动创建： public class catService { //注入方式2：参数传入 private catDao cd; public catService(catDao catDao){ this.cd=catDao; } } 对比第二种方式，并没有像
Spring系列第7篇：依赖注入之手动注入
KG_181的博客
05-04 524
constructor-arg用户指定构造器的参数 type：构造函数参数的完整类型，如：java.lang.String,int,double value：构造器参数的值，value只能用来给简单的类型设置值 案例 diByConstructorParamType.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns=“http://www.springframework.org/sc.
Spring框架中注入方式
风千里的博客
07-23 121
1：SET方式注入 定义：使用SET方法形式为成员变量赋值 语法：将需要的组件声明为成员变量并提供SET方法，在配置文件中使用property标签进行赋值 8种基本数据类型与string类型的注入 <property name="animalDao" ref="animalDaoImp"/> <property name="name" value=...
spring自动注入（手动装配）
qq_42820805的博客
06-14 1019
前言文本已收录至我的GitHub仓库，欢迎Star：https://github.com/bin392328206/six-finger种一棵树最好的时间是十年前，其次是现在我知道很多人...
spring框架的注入方式（转）
学而时习之
12-26 358
spring注入 bean spring注解 注解 spring xml spring xml 注入 spring配置 配置bean
深入理解Spring IoC容器与依赖注入
"Spring官方文档提供了对Spring框架核心技术的详细解释，主要集中在Inversion of Control (IoC) 容器及其相关概念上。文档涵盖了从容器的概述、bean的定义和实例化，到依赖注入的多种方式，以及配置元数据的不同形式...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今年不养猪只除草

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值