Spring(一)----SpringIOC的简单使用

IOC（DI）

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

解释：

Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。

采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。

1.导入依赖包

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.0.RELEASE</version>
    </dependency>

2.创建bean包

DemoA.java

package pro1029;

public class DemoA {
    private Integer id;
    private String name;
    private Character sex;
    private Integer age;
    private Double price;

    public DemoA(){

    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Character getSex() {
        return sex;
    }

    public void setSex(Character sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

    public Double getPrice() {
        return price;
    }

    public void setPrice(Double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "DemoA{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                ", price=" + price +
                '}';
    }
}

DemoB.java

package pro1029;

import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class DemoB {
    private List<String> list;
    private Set<String> set;
    private Map<String,Object> map;
    private String[] string;

    public DemoB(){

    }

    public List<String> getList() {
        return list;
    }

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

    public Set<String> getSet() {
        return set;
    }

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

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

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

    public String[] getString() {
        return string;
    }

    public void setString(String[] string) {
        this.string = string;
    }

    @Override
    public String toString() {
        return "DemoB{" +
                "list=" + list +
                ", set=" + set +
                ", map=" + map +
                ", string=" + Arrays.toString(string) +
                '}';
    }
}

DemoC.java

package pro1029;

import java.util.List;
import java.util.Set;

public class DemoC {
    private DemoB db;
    private List<DemoA> daList;
    private Set<DemoA> daSet;

    public Set<DemoA> getDaSet() {
        return daSet;
    }

    public void setDaSet(Set<DemoA> daSet) {
        this.daSet = daSet;
    }

    public DemoC() {
    }

    public DemoB getDb() {
        return db;
    }

    public void setDb(DemoB db) {
        this.db = db;
    }

    public List<DemoA> getDaList() {
        return daList;
    }

    public void setDaList(List<DemoA> daList) {
        this.daList = daList;
    }

    @Override
    public String toString() {
        return "DemoC{" +
                "db=" + db +
                ", daList=" + daList +
                ", daSet=" + daSet +
                '}';
    }
}

3.在resources下创建一个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" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
<!--
    DemoA da = new DemoA();
    da.setId(1);
    da.setName("zs");
    ...
-->
    <bean id="da" class="pro1029.DemoA"><!--id：对象名，class：对象的类型-->
        <property name="id" value="1"/><!--name：属性名 value：属性值-->
        <property name="name" value="张三"/>
        <property name="sex" value="男"/>
        <property name="price" value="8.47"/>
        <property name="age" value="23"/>
    </bean>

    <bean id="db" class="pro1029.DemoB">
        <property name="list">
            <list>
                <value>张三</value>
                <value>李四</value>
                <value>王麻子</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>北京</value>
                <value>西安</value>
                <value>上海</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="a" value="aaa"/>
                <entry key="b" value="bbb"/>
                <entry key="c" value="ccc"/>
            </map>
        </property>
        <property name="string">
            <array>
                <value>666</value>
                <value>666</value>
                <value>666</value>
            </array>
        </property>
    </bean>

    <bean id="dc" class="pro1029.DemoC">
        <!--
            name:属性名
            value：实际的值，书写的确切值
            ref：指向，执向哪个对象
        -->
        <property name="db" ref="db"><!--name：即第一个是属性名  第二个db是上面的那个db对象-->

        </property>
        <property name="daList">
            <list>
                <ref bean="da"/>
                <ref bean="da"/>
                <ref bean="da"/>
            </list>
        </property>
        <property name="daSet">
            <set>
                <ref bean="da"/>
            </set>
        </property>
    </bean>
</beans>

3.测试

/*
IOC:控制反转（Inversion of Control）
 */
public class Test {
    public static void main(String[] args) {
        //加载XML
        ApplicationContext bean = new ClassPathXmlApplicationContext("applicationContext.xml");//IOC容器
        //获取到IOC容器中的指定对象
        DemoA da =  bean.getBean("da",DemoA.class);
        System.out.println(da);
        System.out.println("----------------");
        DemoB db = bean.getBean("db",DemoB.class);
        System.out.println(db);
        System.out.println("-----------------");
        DemoC dc = bean.getBean("dc",DemoC.class);
        System.out.println(dc);
    }
}