[Spring] 02 IOC 控制反转

prtyaa 2023-12-27 15:22:59  64406

分类专栏：资讯

IOC: 控制反转 --帮助我们创建对象

IoC: Inversion of Control

控制反转

控制: 对对象生命周期的管理

反转(Inversion): 将管理对象生命周期的权利交给Spring

IOC就是由Spring去创建, 获取对象

[1]责任链

我们使用mvc进行开发的时候，数据在各层之间进行传递，数据在业务上构成一个链条，

这个链条称之为责任链。

[2]基于责任链开发的缺点

基于责任链开发模式，我们发现代码层和层之间相互调用，造成了层和层的耦合性太高了

写代码的时候讲究的原则--低耦合高内聚

如果耦合性太高,我们修改一个service后,可能多个controller都受到影响

[3] 解决的方案

Spring IOC : 控制反转

由spring帮忙我们创建对象

通过配置applicationContext.xml实现

如果以后需要修改名字,就只需要在xml中配置就好

贴士

ApplicationContext容器会在容器初始化时，采取的策略是立即加载(懒加载)的方式。会将其中的所有对象一次性装配好，以后用这些对象时只需要在内存中直接调用即可，优点是执行率高，缺点就是占用内存。

BeanFactory 容器采用延时加载，在调用容器中的对象（getBean（））才会装配该对象，虽然节省了资源占用但效率上大大降低。

[4]代码实现

A、导包

B、创建src下的java类

package com.lin.spring;

import com.sun.org.apache.xpath.internal.SourceTreeManager;

public class Student {

    public Student(){
        System.out.println("--对象创建");
    }

    public void eat(){
        System.out.println("Student.eat");
    }
}

C、书写applicationContext.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util.xsd">
    <!--Student stu = new Student()-->
   <bean id="stu" class="com.lin.spring.Student">
   </bean>
</beans>

D 解析调用对象

package com.lin.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        //解析xml文件
        ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext-dao.xml");
        //获得对象
        Student stu = (Student) app.getBean("stu");
        //调用方法
        stu.eat();
    }
}

Spring IOC的好处

实现了各层之间的解耦

IOC :控制反转

控制：就是指的的Spring创建对象的过程

反转：创建对象这个操作本身是程序员自己做的，现在反交给Spring IOC进行创建

IOC 创建对象-构造器

通常我们创建对象的的时候都是一下三种方式:

无参构造器创建
有参构造器创建
工厂模式创建

所以,spring中创建对象也主要是以上三种方式

applicationContext-dao.xml中配置

A、使用无参构造器

<bean id="stu2" class="com.lin.spring2.Student"></bean>

B、使用有参构造器

<!--【B】使用有参构造创建对象-->
    <!--
       Student  stu3=new Student(18,zs,男);
       注意
         [1]name属性和形参的名称保持一致的
         [2]形参的顺序不用和标签的顺序一致
         [3]我们使用name属性进行调用
            但是除了name属性还有index（从0）
            type ：数据类型
            建议三者都写上即可
    -->
    <bean id="stu3" class="com.lin.spring2.Student">
        <!--<constructor-arg name="a" value="18"></constructor-arg>
        <constructor-arg name="name" value="zs"></constructor-arg>
        <constructor-arg name="sex" value="男"></constructor-arg>-->
        <constructor-arg name="a" index="1" type="int" value="123"></constructor-arg>
        <constructor-arg name="b" index="0" type="java.lang.String" value="456"></constructor-arg>
    </bean>

C、使用工厂模式

设计模式：设计模式是为了解决某一类问题的产生

工厂模式就是批量生产对象的

 <!--【3】使用工厂模式创建对象-->
    <!-- Factory  factory=new Factory();-->
    <bean id="factory" class="com.lin.spring3.Factory"></bean>
    <!-- factory.getInstance("tea");-->
    <bean id="be" factory-bean="factory" factory-method="getInstance">
        <constructor-arg name="param" value="stu"></constructor-arg>
    </bean>
    <!--Factory.getInstance2('stu')-->
    <bean id="be2" class="com.lin.spring3.Factory" factory-method="getInstance2">
        <constructor-arg name="param" value="stu"></constructor-arg>
    </bean>

如果出现匹配多个的情况, 默认Spring使用最后的一个

<bean id="user" class="com.lin.pojo.User">
    <constructor-arg name="age" value="18" />
    <constructor-arg name="gender" value="男" />
    <constructor-arg name="name" value="张三" />
</bean>

<bean id="user2" class="com.lin.pojo.User">
    <constructor-arg index="0" value="李四" />
    <constructor-arg index="1" value="20" />
    <constructor-arg index="2" value="女" />
</bean>

<bean id="user3" class="com.lin.pojo.User">
    <constructor-arg type="java.lang.String" index="1" value="王五" />
    <constructor-arg type="java.lang.Integer" index="0" value="22" />
</bean>

Spring中的DI操作

通过上面的学习,我们可以清楚的知道spring在创建对象的时候有三种方式,但是没有写如何给创建的对象赋值,那如何给对象set属性值呢,这里就需要学习DI(依赖注入),Spring帮助创建对象的过程叫做IoC,创建对象时给对象中全局对象赋值叫做DI,所以认为IoC和DI是同一个事情.

白话解释:

DI就是给我们创建好的对象赋值的操作(全局才行)

DI注入的方式

value和ref的使用场景

value: 如果注入的属性类型是基本数据类型（包含String）使用value
ref:如果注入的属性类型是对象这个时候使用ref

有参构造,用的不多,因为不灵活满足不了开发需求

DI其他类型值的注入

A、基本类型（String）

B、对象类型

C、数组

D、List

E、set

F、Map

package com.bjsxt.spring4;

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

public class User {

    private   String []  arr;

    private List<String> li;

    private Set<String> se;

    private Map<String ,String> map;

    public User(String[] arr, List<String> li, Set<String> se, Map<String, String> map) {
        this.arr = arr;
        this.li = li;
        this.se = se;
        this.map = map;
    }

    public User(){}

    public String[] getArr() {
        return arr;
    }

    public void setArr(String[] arr) {
        this.arr = arr;
    }

    public List<String> getLi() {
        return li;
    }

    public void setLi(List<String> li) {
        this.li = li;
    }

    public Set<String> getSe() {
        return se;
    }

    public void setSe(Set<String> se) {
        this.se = se;
    }

    public Map<String, String> getMap() {
        return map;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "arr=" + Arrays.toString(arr) +
                ", li=" + li +
                ", se=" + se +
                ", map=" + map +
                '}';
    }
}

applicationContext.xml

 <bean id="us" class="com.lin.spring4.User">
数组
        <property name="arr">
            <array>
                 <value>A</value>
                 <value>B</value>
                 <value>C</value>
            </array>
        </property>
list集合
        <property name="li">
            <list>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </list>
        </property>
set集合
        <property name="se">
            <set>
                <value>A</value>
                <value>A</value>
                <value>B</value>
                <value>C</value>
            </set>
        </property>
map集合
        <property name="map">
            <map>
                <entry>
                    <key><value>A</value></key>
                    <value>1</value>
                </entry>
                <entry>
                    <key><value>B</value></key>
                    <value>1</value>
                </entry>
                <entry>
                    <key><value>C</value></key>
                    <value>1</value>
                </entry>
            </map>
        </property>
    </bean>

Spring(IOC)整合Mybatris 练习小剧场

Spring Bean实例的作用范围由配置项 scope限定.
singleton 使用该属性定义Bean时，IOC容器仅创建一个Bean实例，IOC容器每次返回的是同一个Bean实例。
prototype使用该属性定义Bean时，IOC容器可以创建多个Bean实例，每次返回的都是一个新的实例。
request使用该属性定义Bean时，IOC容器可以创建多个Bean实例，每次返回的都是一个新的实例。
global-session 该属性仅用于HTTP Session，同session作用域不同的是，所有的Session共享一个Bean实例。