Spring bean实例化，实例化bean的三种方式，依赖注入（DI配置） 详细步骤

已于 2022-03-01 14:09:48 修改
阅读量2.2k 收藏 9
点赞数 3
分类专栏： 后端冲鸭 文章标签： spring java 后端
于 2022-03-01 14:08:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52395816/article/details/123204399
版权

Bean的实例化

（与service层无关，换句话 与DI无关，主要讲解IoC创建bean的原理）

Spring创建bean时调用的是无参构造方法，而私有方法能被调用 因为底层用了反射。用构造方法来实例化对象。

对于Spring的报错，从下往上看

1 Bean是如何创建的【理解】

bean本质上就是对象，创建bean使用构造方法完成

2 实例化Bean的三种方式

2.1 构造方法方式【重点】
  • 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 ...");
    }
}
  • applicationContext.xml配置
<!--方式一：构造方法实例化bean-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
  • AppForInstanceBook测试类
public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        bookDao.save();
    }
}
  • 运行结果
    在这里插入图片描述

注意：**无参构造方法如果不存在，将抛出异常BeanCreationException**

2.2 静态工厂方式实例化bean【了解】

我们需要的是工厂里面的OrderDao对象===>配置工厂类名和方法名

  • OrderDao接口和OrderDaoImpl实现类
public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}
  • OrderDaoFatory工厂类
//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("static factory setup....");
        return new OrderDaoImpl();
    }
}
  • applicationContext.xml配置
<!--方式二：使用静态工厂实例化bean-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

在这里插入图片描述

  • AppForInstanceOrder测试类
public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        orderDao.save();
    }
}
  • 运行结果
    在这里插入图片描述
2.3 实例工厂方式【了解】

和静态工厂类似，多一个配置步骤 factory-bean="userFactory

  • UserDao接口和UserDaoImpl实现类
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
  • UserDaoFactory工厂类
//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
  • applicationContext.xml配置
<!--方式三：使用实例工厂实例化bean-->
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>

在这里插入图片描述

  • AppForInstanceUser测试类
public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}
  • 运行结果
    在这里插入图片描述
2.4 实现FactoryBean<T>方式【扩展,了解】
  • 定义UserDaoFactoryBean实现FactoryBean<UserDao>

UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。

//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    //代替原始实例工厂中创建对象的方法
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    public Class<?> getObjectType() {
        return UserDao.class;
    }
}
  • applicationContext.xml配置
<!--方式四：使用FactoryBean实例化bean-->
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。

代码
package com.itheima;

import com.itheima.dao.OrderDao;
import com.itheima.dao.UserDao;
import com.itheima.factory.OrderDaoFactory;
import com.itheima.factory.UserDaoFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceOrder {
    //使用工厂创建对象
    public static void main(String[] args) {
        //方法二  静态工厂
                //造对象不要直接new 用工厂的方式做适当的解耦
/*        OrderDao orderDao = OrderDaoFactory.getOrderDao();
        orderDao.save();*/
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        OrderDao orderDao =(OrderDao) ctx.getBean("orderDao");
        orderDao.save();

/*        //方法三    实例工厂  先找到工厂的对象，再用对象调用方法
        UserDaoFactory userDaoFactory = new UserDaoFactory();
        UserDao userDao = userDaoFactory.getUserDao();

        userDao.save();*/


        //Spring 的形式来运行
/*        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        userDao.save();*/
    }
}


<?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">

<!--1.导入Spring坐标spring-context，对应的版本号是5.2.10.RELEASE    -->
<!--2.配置bean      id随便起-->
<!--方式一   构造方法实例化bean    构造方法默认时无参构造，写不写均可-->
                <!--使用IoC   和   DI    -->
<!--    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        &lt;!&ndash;7.配置server与dao的关系    把dao放到server中&ndash;&gt;
        &lt;!&ndash;property代表当前bean的属性    name中 代表BookServiceImpl  private BookDao bookDao&ndash;&gt;
        &lt;!&ndash;关系绑定&ndash;&gt;
        <property name="bookDao" ref="bookDao" />
    </bean>-->

    <!--方式二：静态工厂实例化bean-->
            <!--这样造出来的对象时factory对象而不是到对象   需要进一步进缩小范围（factory中的dao对象）-getOrderDao() -->
    <bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>


    <!--方式三：实例工厂实例化bean  -->
        <!--工厂的bean造出来    -->
   <!-- <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
        &lt;!&ndash;静态工厂直接写class类名，实例化工厂不写class   &ndash;&gt;
    <bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>-->
        <!--方式三的变种   去掉了 <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>   的臃肿-->
    <!--方式四：使用FactoryBean实例bean    -->
        <!--id给个名称，class写定义新的UserFactoryBean       造非单例对象时，接口方法isSingleton  false -->
    <!--<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>-->



</beans>

依赖注入(DI配置)

1 依赖注入方式【重点】

1.1 依赖注入的两种方式

  • setter注入

    • 简单类型

    • 引用类型(很常用)

  • 构造方法注入

1.2 setter方式注入
问题导入

setter方式注入使用什么子标签？

引用类型

在这里插入图片描述

  • 标签中：使用ref

  • 完整代码：

    public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    //setter注入需要提供要注入对象的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

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

    <!--注入引用类型-->
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <!--property标签：设置注入属性-->
    <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
    <!--ref属性：设置注入引用类型bean的id或name-->
    <property name="bookDao" ref="bookDao"/>
</bean>

  • 测试

    public class AppForDISet {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}
简单类型

  • 简单类型包含：基本类型（int, char, long…）+ 特殊类型String
    在这里插入图片描述

  • 标签中：使用value

  • 完整代码

    public class BookDaoImpl implements BookDao {

    private int connectionNum;
    //setter注入需要提供要注入对象的set方法
    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

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

    <!--注入简单类型-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--property标签：设置注入属性-->
    <!--name属性：设置注入的属性名，实际是set方法对应的名称-->
    <!--value属性：设置注入简单类型数据值-->
    <property name="connectionNum" value="100"/>
</bean>
总结
#简单类型使用value，引用类型使用ref
1.3 构造方式注入
问题导入

构造方式注入使用什么子标签？

引用类型

在这里插入图片描述

  • 完整代码

    public class BookServiceImpl implements BookService{
    private BookDao bookDao;

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

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

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <constructor-arg name="bookDao" ref="bookDao"/>
</bean>

  • 测试

    public class AppForDIConstructor {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}
简单类型

在这里插入图片描述

  • 完整代码

    public class BookDaoImpl implements BookDao {

    private int connectionNum;
    private String databaseName;

    public BookDaoImpl(String databaseName, int connectionNum) {
        this.databaseName = databaseName;
        this.connectionNum = connectionNum;
    }

    public void save() {
        System.out.println("book dao save ..."+databaseName+","+connectionNum);
    }
}

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--根据构造方法参数名称注入-->
    <constructor-arg name="connectionNum" value="10"/>
    <constructor-arg name="databaseName" value="mysql"/>
</bean>

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <constructor-arg name="bookDao" ref="bookDao"/>
</bean>
参数适配【了解】

在这里插入图片描述

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
    <!--根据构造方法参数名称注入-->
    <!--<constructor-arg name="connectionNum" value="10"/>-->
    <!--<constructor-arg name="databaseName" value="mysql"/>-->

    <!--根据构造方法参数类型注入-->
    <!--<constructor-arg type="int" value="10"/>-->
    <!--<constructor-arg type="java.lang.String" value="mysql"/>-->

    <!--根据构造方法参数位置注入-->
    <!--<constructor-arg index="0" value="mysql"/>-->
    <!--<constructor-arg index="1" value="100"/>-->
</bean>
1.4 依赖注入方式选择
  1. 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
  2. 可选依赖使用setter注入进行，灵活性强
  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
  6. 自己开发的模块推荐使用setter注入
代码
BookDaoImpl

package com.itheima.dao.impl;
import com.itheima.dao.BookDao;
public class BookDaoImpl implements BookDao {
    private int connectionNum;
    private String databaseName;


    //注入一：set注入
/*    public void setConnectionNum(int connectionNum) {
        this.connectionNum = connectionNum;
    }

    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }*/

    //注入二：构造器注入
    public BookDaoImpl(int connectionNum, String databaseName) {
        this.connectionNum = connectionNum;
        this.databaseName = databaseName;
    }

    public void save() {
        System.out.println("book dao..."+ databaseName+","+connectionNum);
    }
}

BookServiceImpl

package com.itheima.service.impl;
import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;
import com.itheima.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    private UserDao userDao;
    
    //注入方法一：set注入
/*    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }*/
    //注入方法二：构造器注入
    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

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

AppForDISet

package com.itheima;
import com.itheima.service.BookService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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

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

        ctx.close();
    }
}

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">

        <!--注入一：set注入   -->
    <!--     <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" >
          <property name="connectionNum" value="10"/>
          <property name="databaseName" value="mySql"/>
       </bean>
     <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
            <property name="bookDao" ref="bookDao" />
        </bean>-->

    <!--注入二：构造器注入   标准书写  推荐使用。其他方法会存在问题-->
<!--    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>-->
    <!--注入二-1：进一步解耦，消除参数捆绑  与形参名不耦合了-->
<!--    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg type="int" value="10"/>
        <constructor-arg type="java.lang.String" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>-->
    <!--注入二-2：参数位置注入，消除二-1出现两个同类型的数据-->
    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg index="0" value="10"/>
        <constructor-arg index="1" value="MySql"/>
    </bean>
    <bean name="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
</beans>

2 依赖自动装配【理解】

问题导入

如何配置按照类型自动装配？

2.1 自动装配概念

  • IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配

  • 自动装配方式

    按类型（常用）

    按名称：

    按构造方法

    不启用自动装配

2.2 自动装配类型
依赖自动装配

配置中使用bean标签autowire属性设置自动装配的类型

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
依赖自动装配特征
  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效
<?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 name="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <bean name="bookService" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>-->
    <!--自动注入    -->
    <bean name="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <!--那边无论写了多少，set方法给够，这边一个autowire 结束-->
    <bean name="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
</beans>

3 集合注入-07’32

准备工作

在类中添加集合类型属性：添加get，set方法

public class BookDaoImpl implements BookDao {

    private int[] array;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

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

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}
3.1 注入数组类型数据
<property name="array">
    <array>
        <value>100</value>
        <value>200</value>
        <value>300</value>
    </array>
</property>
3.2 注入List类型数据
<property name="list">
    <list>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>chuanzhihui</value>
    </list>
</property>
3.3 注入Set类型数据
<property name="set">
    <set>
        <value>itcast</value>
        <value>itheima</value>
        <value>boxuegu</value>
        <value>boxuegu</value>
    </set>
</property>
3.4 注入Map类型数据
<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    </map>
</property>
3.5 注入Properties类型数据
<property name="properties">
    <props>
        <prop key="country">china</prop>
        <prop key="province">henan</prop>
        <prop key="city">kaifeng</prop>
    </props>
</property>

说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签

3.6 验证结果
public class AppForDICollection {
    public static void main( String[] args ) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

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

        bookDao.save();
    }
}

在这里插入图片描述

内容来自学习笔记

热爱代码的猿猿
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Spring依赖注入的三种方式实例详解
10-19
本篇将详细解释Spring中的三种依赖注入方式：接口注入、Setter方法注入和构造方法注入。 1. **接口注入**： 在Java中，接口注入通常通过实现一个特定的接口来完成，该接口提供了设置依赖的函数。然而，Spring框架...
bean的四种实例化方法
m0_52228992的博客
07-18 3937
这里是我对视频学习做的笔记，仅供学习刚刚开始学习，可能有很多地方都没有理解到位，努力大家有兴趣的话，可以去黑马程序员2022最新SSM框架教程_Spring+SpringMVC+Maven高级+SpringBoot+MyBatisPlus企业实用开发技术_哔哩哔哩_bilibili老师讲的非常好。httpshttpshttpshttpshttpshttpshttpshttps。...
配置bean的三种方式 及例子
qq_34894975的博客
09-09 1883
Spring基础15——通过工厂方法来配置bean 1、什么是工厂方法 这里的工厂方法指的是创建指定bean的方法。工厂方法又分为静态工厂方法和实例工厂方法。 2、静态工厂方法配置bean 调用静态工厂方法创建Bean是将对象创建的过程封装到静态方法中，不需要创建工厂实例就可以返回工厂创建的对象，就叫做静态工厂，当客户端需要对象时，只需要简单的调用静态方法，而不...
Spring Bean依赖注入-Spring入门（二）
最新发布
qq_40210639的博客
04-22 873
在Spring中，一切Java对象都被视为Bean，用于实现某个具体功能。Bean的依赖关系注入的过程，也称为Bean的装配过程。Bean的装配方式有3种：XML配置文件注解Java类Spring中常用的两种装配方式分别是基于XML的装配和基于注解的装配。
七、Bean的实例化方式
m0_58512767的博客
11-12 389
Bean的实例化方式
Spring实例化Bean的三种方法
unber的博客
08-09 3748
在面向对象的程序中，要想调用某个类的成员方法，就需要先实例化该类的对象。
spring学习之bean标签
qq_41941963的博客
10-03 207
bean 标签 作用： 用于配置对象让 spring 来创建的。 默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。 属性： id：给对象在容器中提供一个唯一标识。用于获取对象。 class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。 scope：指定对象的作用范围。 singleton :默认值，单例的. prototype :多例的. req...
spring四种依赖注入方式的详细介绍
08-31
第二种方式是构造器注入，适用于类有多个依赖或者希望在实例化时就完成所有依赖的注入。在`SpringAction`类中，我们不再提供setter方法，而是使用带参数的构造函数，将`SpringDao`和`User`作为构造参数。在XML配置...
深入解析Java的Spring框架中bean的依赖注入
09-03
这是DI的一种常见形式，它通过在构造函数中传递依赖对象来初始化实例。例如，在`TextEditor`类中，我们不再在构造函数内部创建`SpellChecker`实例，而是将其作为构造函数的参数传递。Spring容器会在创建`TextEditor`...
详析Spring中依赖注入的三种方式
09-01
本文将详细解析Spring中常用的三种依赖注入方式：set方法注入、构造函数注入和注解注入。 首先，我们来看set方法注入，也称为属性注入。这种方式通过setter方法将依赖对象注入到目标类中。例如，在`UserServiceImpl...
详解Spring 两种注入的方式（Set和构造）实例
08-31
在Spring框架中，依赖注入（Dependency Injection，简称DI）是一种重要的设计模式，它允许外部容器管理对象的依赖关系，而不是让对象自己去寻找或创建它们所依赖的对象。Spring提供了多种实现DI的方式，其中最常见的...
Spring系列-3 Bean实例化与依赖注入
Sheng_Q的博客
01-25 748
Spring管理着Bean对象的生命周期，包括实例化、属性设置、初始化、销毁等；其中实例化和属性设置过程中存在着依赖注入。 本文承接上文 [Spring系列-2 Bean的生命周期](https://blog.csdn.net/Sheng_Q?type=blog)，重点介绍Bean生命周期中的实例化与依赖注入过程，介绍原理时会结合Spring源码进行。
Spring中实例化bean的三种方法
08-10 107
在Spring中可以通过构造函数，静态工厂方法，bean实例的工厂方法这三种方法来实现一个bean的实例化。。我先将这个例子中相关的类代码贴上来，再针对每一种实例化的方法进行说明。 User.java package kevin; public class User { private String name; private int age; public String g...
Spring（三）：bean实例化
weixin_43162044的博客
10-27 278
先来看看第三个配置方式，第一个bean是配合第二个使用实际无意义，方法名不固定，每次都需要配置。OrderDao接口和OrderDaoImpl实现类。applicationContext.xml配置。applicationContext.xml配置。applicationContext.xml配置。applicationContext.xml配置。不适合交给容器进行管理的bean。UserDao接口和UserDaoImpl实现类。bean生命周期控制：在bean。bean生命周期：bean。
构造Bean的三种方法
sixteenccc的博客
08-06 1609
Spring JAVA Bean和Spring Bean bean:在计算术语中，称为软件中可以复用的组件 spring bean：由spring IOC容器创建并管理的java对象 JavaBean:在java应用中可以复用的对象，需要以下几个条件： 类的声明public修饰 需要有无参的构造方法 有一些私有的成员变量，要求小写字母打头，且有getter和setter方法 实现序列化接口,serializable接口 创造Bean的三种方法 方法一：构造器实例化Bean 如果bean标签中没有其
Bean的实例化过程
子衿_青青的博客
08-21 6607
一、Spring容器的容器启动阶段和Bean实例化阶段   1.1 容器启动阶段     容器启动阶段，主要是将利用某种工具（如XmlBeanDefinitionReader），将XML配置信息，映射为BeanDefinition，并将其注册到相应的BeanDefinitionRegistry。 1.2 Bean实例化阶段   本文主要探索此阶段，也就是上图Abstract...
Spring（2）：实例化Bean的三种方法
小蚯蚓的博客
10-24 168
实例化Bean一、实现功能二、准备1.Pom2.Spirng.xml模板三、通过三种实例化Bean方法以及别名方法1.构造方法实例化bean2.静态方法实例化bean3.实例方法实例化bean34.bean别名 一、实现功能 学习使用spring实例化bean，通过构造方法、静态方法和实例方法实例化Bean，同时学习Bean的别名方法 二、准备 1.Pom <dependency> ...
spring bean 实例化之后显式的指定调用自定义方法的几种方式
csdnmuyi的博客
05-05 1439
创建普通的类如下: @Data public class User { private Student student; @Autowired public void student(Student student) { System.out.println("User...为student赋值"); this.student = st...
bean初始化和结束就调用三种方法
chaoge321的博客
12-02 850
第一种使用注解 @PostConstruct @PreDestroy package com.seven; import javax.annotation.PostConstruct; import javax.annotation.PreDestroy; @Componment public class FirstInitDestory { @PostConstruc...
实验(训)目的与要求 1．了解Spring的概念和优点。 2．理解Spring中的Ioc和DI思想。 3．掌握ApplicationContext容器的使用。 4．掌握属性setter方法注入的实现。 5．熟悉Bean的作用域和生命周期。 6．掌握Bean的三种装配方式。实验(训)内容 1．使用Spring实现一个简单的入门程序。 2．使用Spring容器的setter方法注入实现依赖注入。 3．使用构造器对Bean进行实例化。 4．基于Annotation（注解）的装配方式程序实现。 5．基于XML的Bean的装配方式程序实现。 6．使用静态工厂方式实例化对Bean进行实例化。 7．使用实例工厂方式实例化对Bean进行实例化。帮我写实验心得
03-24
作为一个由 CSDN 开发的C知道，我很高兴能够帮助你回答这个问题。在这个实验中，你学习了Spring框架的概念和优点，理解了Ioc和DI思想，掌握了ApplicationContext容器的使用，属性setter方法注入的实现，Bean的作用域和生命周期，以及Bean的三种装配方式。 在实验中，你实现了一个简单的入门程序，使用Spring容器的setter方法注入实现依赖注入，使用构造器对Bean进行实例化，基于Annotation（注解）的装配方式程序实现，基于XML的Bean的装配方式程序实现，使用静态工厂方式实例化对Bean进行实例化，以及使用实例工厂方式实例化对Bean进行实例化。 通过这个实验，你深入了解了Spring框架的核心概念和实现方式，掌握了Spring的基本用法，对于以后的开发工作将会有很大的帮助。同时，你也学会了如何使用不同的装配方式来实现Bean的实例化和注入，这将有助于你更好地理解和应用Spring框架。 总之，这个实验让你收获颇丰，希望你能够继续努力学习，不断提升自己的技能和能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

热爱代码的猿猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值