Spring_1-控制反转(IOC)与依赖注入(DI)

最新推荐文章于 2024-08-15 18:07:41 发布

路灯下的篮球场

最新推荐文章于 2024-08-15 18:07:41 发布

阅读量292

点赞数

分类专栏： java框架文章标签： spring java ioc

本文链接：https://blog.csdn.net/reallllbj/article/details/105981884

版权

java框架专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章目录

spring_1　概述、IOC、DI

一、Spring 概述

1、spring 是什么

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 SpringMVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

2、spring 的优势

方便解耦，简化开发: 通过 Spring提供的 IoC容器，将对象间的依赖关系交由 Spring进行控制
AOP编程的支持: 面向切面的编程
声明式事务的支持: 通过声明式方式灵活的进行事务的管理
方便程序的测试: 可以用非容器依赖的编程方式进行几乎所有的测试工作
方便集成各种优秀框架: 提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz
等）的直接支持
降低 JavaEE API 的使用难度
Java 源码是经典学习范例

3、spring 的体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zxVhqm6h-1588857446878)(https://artzoick.github.io//post-images/spring/1.png)]

二、IOC 的概念和作用

1、什么是程序的耦合

在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。划分模块的一个准则就是高内聚低耦合。

耦合：简单来说就是程序间的依赖关系，在开发中我们应该尽量做到编译期不依赖，运行时才依赖。
解耦：降低程序间的依赖关系。可以通过读取配置文件来获取要创建的对象的全限定类名，并使用反射来创建对象，避免使用 new 关键字

2、控制反转-Inversion Of Control

之前创建对象的方式：
在业务层中调用持久层代码为private IAccountDao accountDao = new AccountDaoImpl();如果此时没有持久层实现类，编译将不能通过。这种编译期依赖关系应该被杜绝，耦合度过高。（获取对象主动new）

IOC方式：
对象的创建权反转(交给)给spring的IOC容器，从而实现了程序的解耦合。（获取对象通过IOC）这种方式是被动的，我们只需要列出一个清单，表明需要什么对象，IoC 就会帮我们创建好对象，当我们需要使用时，只需要向 IoC 容器获取即可。

三、使用 spring 的 IOC 解决程序耦合

1、入门案例

框架结构：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HO3cK9JG-1588857446916)(https://artzoick.github.io//post-images/spring/2.png)]

(0) 导入坐标

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.6.RELEASE</version>
        </dependency>
    </dependencies>

(1) 创建业务层接口和实现类

/**
 * 业务层接口
 */
public interface IAccountService {
    public void saveAccount();
}
/**
 * 业务层接口的实现类
 */
public class AccountServiceImpl implements IAccountService {

    private IAccountDao accountDao = new AccountDaoImpl(); //此处的依赖关系有待解决

    public void saveAccount(){
        accountDao.saveAccount();
    }
}

(2) 创建持久层接口和实现类

/**
 * 账户的持久层接口
 */
public interface IAccountDao {

    /**
     * 模拟保存账户
     */
    void saveAccount();
}
/**
 * 账户的持久层实现类
 */
public class AccountDaoImpl implements IAccountDao {

    /**
     * 模拟保存账户
     */
    public void saveAccount() {
        System.out.println("保存账户到数据库...");
    }
}

(3) 类路径下创建bean.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">

    <!--把对象的创建交给spring来管理-->
    <!--配置service-->
    <bean id="accountService" class="top.zoick.service.impl.AccountServiceImpl"></bean>
 	<!--配置一个accoutDao对象，sping会读取这个全限定类名，反射创建一个对象，并且存入spring的ioc核心容器中，通过id来把对象从容器中取出来-->
    <bean id="accountDao" class="top.zoick.dao.impl.AccountDaoImpl"></bean>
</beans>

bean 标签: 用于配置让 spring 创建对象，并且存入 ioc 容器之中
　　id 属性: 对象的唯一标识。
　　class 属性: 指定要创建对象的全限定类名

(4) 测试配置是否成功

/**
 * 模拟一个表现层，用于调用业务层
 */
public class Client {

    public static void main(String[] args) {

        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取Bean对象,两种方式均可以，第一种是强转，第二种是给字节码文件，让它自动转类型
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao adao = ac.getBean("accountDao",IAccountDao.class);


        System.out.println(as);
        System.out.println(adao);
        as.saveAccount();
    }

入门案例运行结果

2、Spring 基于 XML 的 IOC 细节

(1) 核心容器的两个接口引发出的问题：

ApplicationContext:　　单例对象适用　　　常用此接口
它在构建核心容器时，创建对象采取的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象。

BeanFactory: 　　　　多例对象使用
它在构建核心容器时，创建对象采取的策略是采用延迟加载的方式。也就是说，什么时候根据id获取对象了，什么时候才真正的创建对象。

(2) ApplicationContext 接口三个常用实现类

ClassPathXmlApplicationContext: 它可以加载类路径下的配置文件，要求配置文件必须在类路径下。不在的话，加载不了。(更常用)
FileSystemXmlApplicationContext: 它可以加载磁盘任意路径下的配置文件(必须有访问权限）
AnnotationConfigApplicationContext: 它是用于读取注解创建容器的，是明天的内容。

3、IOC 中 bean 标签

(1) bean标签

作用:
　　用于配置对象让 spring 来创建的。
　　默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
　　id: 给对象在容器中提供一个唯一标识。用于获取对象。
　　class: 指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
　　scope: 指定对象的作用范围。
　　　　singleton: 默认值，单例的(单个对象)。
　　　　prototype: 多例的（多个对象）。
　　　　request: 作用于web应用的请求范围
　　　　session: 作用于web应用的会话范围
　　　　global session: WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session。
　　init-method: 指定类中的初始化方法名称。
　　destroy-method: 指定类中销毁方法名称。

(2) bean 的作用范围和生命周期

bean对象的生命周期
单例对象 scope = "singleton"
　　　　出生：当容器创建时对象出生
　　　　活着：只要容器还在，对象一直活着
　　　　死亡：容器销毁，对象消亡
　　　　总结：单例对象的生命周期和容器相同

多例对象 scope = "prototype"

出生：当我们使用对象时spring框架为我们创建
　　　　活着：对象只要是在使用过程中就一直活着。
　　　　死亡：当对象长时间不用，且没有别的对象引用时，由Java的垃圾回收器回收

(3) 实例化（创建） Bean 的三种方式

<!--第一种方式：使用默认构造函数创建
            在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他的属性和标签时。
            采用的就是默认构造函数创建bean对象，此时如果类没有默认构造函数，则对象无法创建
    -->
    <bean id="accountService_1" class="top.zoick.service.impl.AccountServiceImpl"/>
<!--第二种方式:使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入Spring容器）
			先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
/**
 * 模拟一个工厂类（该类可能是存在于jar包中的，我们无法通过修改源码的方式来提供默认构造函数）
 *
 */
public class InstanceFactory {
    public IAccountService getAccountService() {
        return new AccountServiceImpl();
    }
}
    <bean id="instanceFactory" class="top.zoick.factory.InstanceFactory" />
    <bean id="accountService_2" factory-bean="instanceFactory" factory-method="getAccountService1"/>
<!--第三种方式：使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
			id 属性：指定 bean 的 id，用于从容器中获取
			class 属性：指定静态工厂的全限定类名
			factory-method 属性：指定生产对象的静态方法
-->
    <bean id="accountService_3" class="top.zoick.factory.StaticFactory" factory-method="getAccountService2"></bean>

4、spring 的依赖注入

(1) 依赖注入的概念

依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
程序在编写时，通过控制反转IOC，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。
ioc 解耦只是降低它们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件（bean）中
简单的说，就是让框架把持久层对象传入业务层，而不用自己去获取。

能注入的数据: 有三类
　　基本类型和String
　　其他bean类型（在配置文件中或者注解配置过的bean）
　　复杂类型/集合类型
注入的方式: 有三种
　　第一种：使用构造函数提供
　　第二种：使用set方法提供
　　第三种：使用注解提供

(2) 构造函数注入

构造注入指的是，通过类中的构造方法给成员变量赋值。这个赋值的操作并不是我们做的，而是通过配置的方式，让 Spring 框架来为我们注入。具体代码如下：

IAccountService的实现类AccountServiceImpl

public class AccountServiceImpl implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

    //构造函数注入
    public AccountServiceImpl(String name,Integer age,Date birthday){
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public AccountServiceImpl() {
        System.out.println("对象创建了");
    }

    @Override
    public void saveAccount(){
        System.out.println("service中的saveAccount方法执行了");
    }

}

bean.xml中

    <bean id="accountService" class="top.zoick.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰斯特"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>
    <!-- 配置一个日期对象 -->
<!--配置一个日期对象，sping会读取这个全限定类名，反射创建一个对象，并且存入spring的ioc核心容器中，通过id来把对象从容器中取出来-->
    <bean id="now" class="java.util.Date"></bean>

标签出现的位置：bean标签的内部
使用的标签:　constructor-arg
constructor-arg标签中的属性:
　　type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
　　index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
　　name：用于指定给构造函数中指定名称的参数赋值　　　　　　　　　　常用的
　　--------以上三个用于指定给构造函数中哪个参数赋值--------
　　value：用于提供基本类型和String类型的数据
　　ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现（配置）过的bean对象

优势：
　　在获取bean对象时，带参构造注入数据是必须的操作，否则对象无法创建成功。
弊端：
　　改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

(3) set 方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法。

IAccountService的实现类AccountServiceImpl

/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl2 implements IAccountService {

    //如果是经常变化的数据，并不适用于注入的方式
    private String name;
    private Integer age;
    private Date birthday;

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

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public void  saveAccount(){
        System.out.println("service中的saveAccount方法执行了。。。"+name+","+age+","+birthday);
    }


}

bean.xml中

    <bean id="accountService2" class="top.zoick.service.impl.AccountServiceImpl2">
        <property name="name" value="TEST" ></property>
        <property name="age" value="21"></property>
        <property name="birthday" ref="now"></property>
    </bean>
	<!-- 配置一个日期对象 -->
    <bean id="now" class="java.util.Date"></bean>

出现的位置：bean标签的内部
涉及的标签：property
property标签的属性:
　　name: 用于指定注入时所调用的set方法名称
　　value: 用于提供基本类型和String类型的数据
　　ref: 用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
优势：
　　创建对象时没有明确的限制，可以直接使用默认构造函数
弊端：
　　如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

(4) 复杂类型的注入

IAccountService的实现类AccountServiceImpl

public class AccountServiceImpl3 implements IAccountService {

    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }


    @Override
    public void  saveAccount(){
        System.out.println(Arrays.toString(myStrs));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
    
}

bean.xml中

    <bean id="accountService3" class="top.zoick.service.impl.AccountServiceImpl3">
        <property name="myStrs">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"/>
                <entry key="testB">
                    <value>BBB</value>
                </entry>
            </map>
        </property>
    </bean>

复杂类型的注入/集合类型的注入（标签没对上没事）
　　用于给List结构集合注入的标签：
　　　　list array set
　　用于个Map结构集合注入的标签:
　　　　map props
　　结构相同，标签可以互换

路灯下的篮球场

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring_1-控制反转(IOC)与依赖注入(DI)

文章目录spring_1　概述、IOC、DI一、Spring 概述1、spring 是什么2、spring 的优势3、spring 的体系结构二、IOC 的概念和作用1、什么是程序的耦合2、控制反转-Inversion Of Control三、使用 spring 的 IOC 解决程序耦合1、入门案例(0) 导入坐标(1) 创建业务层接口和实现类(2) 创建持久层接口和实现类(3) 类路径下创建be...
复制链接

扫一扫