【01】Spring--IOC/DI

【01】Spring笔记–IOC/DI

一、Spring框架简介

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

二、Spring的体系结构

---

三、Spring IOC和DI

1-控制反转

简单说就是创建对象由以前的程序员自己new 构造方法来调用，变成了交由Spring创建对象

（Inversion Of Control ）

---

2-基于xml的IOC环境搭建

1. 使用idea创建一个普通的java项目
2. 在pom.xml添加如下依赖：

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

3. 在resource目录下创建一个bean.xml（任意名称，但不要中文）。配置以管理各种类的依赖关系
4. 创建一个User实体类

/**
 * @author a_apple
 * @create 2020-01-12 19:49
 */
public class User {
    //这些属性为演示依赖注入，无实际意义
    
    //基本类型字段
    private String name;
    private Integer age;
    //非基本类型
    private Date bir;
    
    //集合、数组类型
    private String[] strs;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties props;
    
    public User(){}

    public User(String name, Integer age, Date bir) {
        this.name = name;
        this.age = age;
        this.bir = bir;
    }

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

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

    public void setBir(Date bir) {
        this.bir = bir;
    }

    public void setStrs(String[] strs) {
        this.strs = strs;
    }

    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 setProps(Properties props) {
        this.props = props;
    }
    
	//打印name,age,bir
     public void method1(){
        System.out.println("["+name+","+age+","+bir);
    }
    //打印数组，集合类型
    public void method2(){
        System.out.println(Arrays.asList(strs));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(props);
    }
    
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", bir=" + bir +
                '}';
    }
}

5. 在bean.xml(自己创建的)添加如下

<bean id="user" class="com.domain.User"></bean>
<!-- 此时还没有注入属性值，调用的是默认的无参构造方法。没有则报错-->

• id：是获取该对象的唯一标识

• class：是该类的路径

5. 创建一个Demo，用于获取User对象，执行方法method()1,method()2

public class Demo2 {

    public static void main(String[] args) {
        testBesic();
    }

    //基本类型注入
    public static void testBesic(){
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象。在创建对象的时候就通过xml文件注入了属性值
        User user = (User)ac.getBean("user");
        user.method1();
        user.method2();
    }

}

结果：

method1:[null,null,null]
method2:
null
null
null
null
null

---

3-依赖注入：

它是 spring 框架核心 ioc 的具体实现。 我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。 ioc 解耦只是降低他们的依赖关系，但不会消除。简单地说就是拿到的对象的属性，已经被注入好相关值了，直接使用即可。

可以注入的类型：3类

• 基本类型和String

• 其他bean类型（在配置文件中或者注解配置过的bean）

• 复杂类型、集合类型

注入的方式：3种

• 使用构造函数提供（xml配置
• 使用set方法提供
• 使用注解提供

---

一、构造函数提供：

1. 修改bean.xml中的<bean id="user"...>标签内容为
2. 再配置一个日期对象，因为无法直接向Date注入value值（属于其他bean类型

<!--配置一个日期对象-->
<bean id="now" class="java.util.Date"></bean>

<bean id="user" class="com.domain.User">
        <constructor-arg name="name" value="李白"></constructor-arg>
        <constructor-arg name="age" value="12"></constructor-arg>
        <constructor-arg name="bir" ref="now"></constructor-arg>
</bean>

2. 再运行Demo,结果如下：

method1:[李白,12,Sun Jan 12 20:28:39 CST 2020]
method2:
null
null
null
null
null

(此时name,age,bir都有了属性，数组集合还没有)

标签：

* 使用的标签：constructor-arg
* 标签出现的位置：
* bean标签的内部标签中的属性:        
	* type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型        
	* index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从e开始        
	* name：用于指定给构造函数中指定名称的参数赋值 
        
-----=======================以上三个用于指定给构造函数中哪个参数赋值----------------------- 
        
        
	* value：用于提供基本类型和String类型的数据        
	* ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中出现过的bean对象
* 优势：    
	在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
* 弊端：   
	改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供。

---

二、set方法提供

要求：

1. 实体类的属性要提供Setter()方法

2. 需要在<bean>标签里面使用到<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 http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

    <!--<bean id="user" class="com.domain.User"></bean>-->
    
    <!--<bean id="user" class="com.domain.User">
        <constructor-arg name="name" value="李白"></constructor-arg>
        <constructor-arg name="age" value="12"></constructor-arg>
        <constructor-arg name="bir" ref="now"></constructor-arg>
    </bean>-->

    <bean id="user" class="com.domain.User">
        <property name="name" value="李白"></property>
        <property name="age" value="19"></property>
        <property name="bir" ref="now"></property>

        <property name="strs">
            <array>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </array>
        </property>

        <property name="list">
            <list>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </list>
        </property>

        <property name="set">
            <set>
                <value>eee</value>
                <value>ddd</value>
                <value>uuu</value>
            </set>
        </property>

        <property name="map">
            <!--交换props-->
            <map>
                <entry key="key1" value="vA"></entry>
                <entry key="key2" value="v2"></entry>
                <entry key="key3" value="v3"></entry>
                <entry key="key4">
                    <value>v4</value>
                </entry>
            </map>
        </property>

        <property name="props">
            <props>
                <prop key="A">hhhh</prop>
                <prop key="bb">hhh</prop>
                <prop key="ccc">hh</prop>
                <prop key="dddd">h</prop>
            </props>
        </property>
    </bean>
</beans>

运行结果：

method1:[李白,19,Sun Jan 12 20:40:27 CST 2020]
method2:
[111, 222, 333]
[aaa, bbb, ccc]
[eee, ddd, uuu]
{key1=vA, key2=v2, key3=v3, key4=v4}
{A=hhhh, dddd=h, bb=hhh, ccc=hh}

标签：

* set方法注入           （更常用的方式
        * 涉及的标签：property
        * 出现的位置：bean标签的内部

        * 标签的属性
            name：用于指定注入时所调用的set方法名称
            value：用于提供基本类型和String类型的数据
            ref：用于指定其他的bean类型数据。它指的就是在spring的Toc核心容器中出现过的bean对象

        * 优势：
            创建对象时没有明确的限制，可以直接使用默认构造函数
        * 弊端：
            如果有某个成员必须有值，则获取对象是有可能set方法没有执行。

---

三、注解注入

见Spring-注解