Spring framework之配置文件实现IoC控制反转

发布时间:2024年01月22日

Spring framework的第一大部分就是core container 核心容器,用于管理对象,其中有个IoC容器。

我们先来了解一下什么是IoC:?

? ? 代码现状是:在业务层实现类中,我们需要new出数据层的一个具体的实现类对象才能实现数据层对应的方法。但当我们需要更换成实现了同一个数据层接口的另一个实现类时,因为new出来实现类不一样了,所以后面的代码肯定也要改。就是下面这种情况。

?

解决办法:在使用对象的时候,在程序中不要主动用new创造对象,转换为由外部提供对象。

这就是IoC(Inversion of Control)控制反转:就是把对象的创建控制权由程序转移到了外部。目的是为了解耦。

Spring提供了一个容器,IoC容器来充当IoC思想中的“外部” 。IoC容器负责对象的创建,初始化等一系列工作,被创建或被管理的对象在IoC容器中统称为bean。

这时还有一个问题,上面我们仅仅是完成了在外部创建对象的工作,当我们运行service时,如果IoC容器只提供给我们service的对象是不能到达效果的,因为service层的运行是需要依靠dao层的,所以IoC容器应该把这俩个对象都传给我们,并建立依赖。

其实这个建立依赖的工作,IoC容器是可以帮我们做的。如果我们需要的多个对象,IoC容器中都有,IoC容器就是帮我们建立依赖并传给我们,这个就叫做依赖注入DI。

DI(Dependency Injection)依赖注入:在容器中建立起多个bean之间的依赖关系的过程。

下面让我们开始使用配置文件来运行Spring:

? 第一步,先导入spring对应的依赖包

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

第二步,创建需要的配置文件,这个文件在导完上面的依赖包才会有。

?给该配置文件起名叫applicationContext.xml??

下面我们就可以创造我们需要的bean了:用bean标签创建

<?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" name="dao bookDao2" class="org.example.dao.impl.bookDaoImpl" scope="prototype"/>


    <bean id="bookService" class="org.example.service.impl.bookServiceImpl"/>
</beans>

id属性给bean起名字? ???class属性给bean定义类型? ??

?一个bean的id属性只能有一个且不能重复,但name属性可以给该bean起多个别名,不能重复
name属性与id属性具有相同功能,都可以被用来获取该bean 。name中的多个别名之间可以用逗号,分号或者空格分隔。name属性不需要时可以省略。

到这我们完成了dao层和service层对象的创建,我们还需要对这俩个对象建立依赖:因为是service层依赖dao层,所以创建依赖的过程应写在service的bean中。

dao层代码:

public class bookDaoImpl implements bookDao {

    public bookDaoImpl() {
        System.out.println("bookDaoImpl被new");
    }


    @Override
    public void save() {
        System.out.println("bookDao....");
    }
}

我们需要先在service层代码中声明对应的set方法。

public class bookServiceImpl implements bookService{

    //5.删除业务层中使用new方式创建的对象
    //bookDao bookDao=new bookDaoImpl();
    bookDao bookDao;
    

    @Override
    public void save() {
        bookDao.save();
        System.out.println("bookService....");
    }

    public void setBookDao(bookDao bookDao) {
        this.bookDao = bookDao;
    }
}

然后在配置文件中添加下面的标签

<bean id="bookService" class="org.example.service.impl.bookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
    </bean>

? ?property标签是配置当前bean的属性;? ?name属性为bookService类中的bookDao属性,ref为为bookDaoImpl配置的bean的id值。
最后我们就可以在main方法中获取我们的bean并执行其中的save方法了

public class beanConstruction {
    public static void main(String[] args) {
        //3.获取IoC容器
        ApplicationContext act=new ClassPathXmlApplicationContext("applicationContext.xml");

        //4.获取bean
        bookDao bookDao = (bookDao) act.getBean("bookDao");
        bookService bookService = (bookService) act.getBean("bookService");

        bookService.save();
}

获取IoC容器方法中的参数为我们前面写的Spring配置文件的名。

getBean()方法的参数为配置文件中bean标签的id属性值或者name属性值。另外因为该方法的返回值为Object类型,所以我们需要强转一下类型。

下面让我们来了解一下Spring是怎么创建对象的:Spring创建对象有3种方式

? 第一种(默认):调用该对象无参的构造方法。通过上面的例子,就可以反映出Spring是通过无参的构造方法创建对象的。

? 第二种:使用静态工厂实例化bean:

先创建一个静态工厂,通过一个静态方法返回我们需要的对象。

package org.example.factory;

import org.example.dao.bookDao;
import org.example.dao.impl.bookDaoImpl;

public class bookDaoFactory {
    public static bookDao getBookDao(){
        return new bookDaoImpl();
    }
}

?配置文件中的bean标签就应该这样写:

<bean id="bookMapper" class="org.example.factory.bookDaoFactory" factory-method="getBookDao"/>

如果不写factory-method属性 该bean创建的是factory工厂的对象,但我们需要的是工厂中的方法所返回的对象,所以我们需要用factory-method指明运用工厂中的哪个方法来返回对象

? 第三种:使用实例化工厂:注意该类中返回所需对象的方法不是静态方法。

package org.example.factory;

import org.example.dao.bookDao;
import org.example.dao.impl.bookDaoImpl;

public class bookDaoFactory2 {
    public bookDao getBookDao(){
        return new bookDaoImpl();
    }
}

因为该工厂不是静态工厂,所以要先创建该工厂的bean

    <bean id="bookFactory" class="org.example.factory.bookDaoFactory2"/>
    <bean id="bookDao3" factory-method="getBookDao" factory-bean="bookFactory"/>

factory-bean 属性是工厂实例bean 然后调用该工厂的factory-method方法。

因为这种方式我们需要创建工厂bean,且工厂bean仅仅是配合其他bean使用的,没别的作用了,所以后续对该方式进行了改良:

package org.example.factory;

import org.example.dao.bookDao;
import org.example.dao.impl.bookDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class bookDaoFactoryBean implements FactoryBean<bookDao> {
    //代替原实例工厂中创建对象的方法
    @Override
    public bookDao getObject() throws Exception {
        return new bookDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return bookDao.class;
    }

    //该方法用于改变由该实例工厂创建出来的对象是否为单例
    //返回值为true时为单例,为false时不是单例
    //该方法一般不用重写
    @Override
    public boolean isSingleton() {
        return true;
    }
}

其中的方法都是实现了FactoryBean接口后重写的方法。

配置文件中的写法:

<bean id="bookDao4" class="org.example.factory.bookDaoFactoryBean"/>

文章来源:https://blog.csdn.net/hguhbh/article/details/135750734
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。