spring之IOC控制反转

什么是IOC？

（1）控制反转，就是把对象创建和对象之间的调用过程，交给spring管理
（2）使用IOC的目的：为了降低耦合度

控制反转（IOC）的底层原理

1.xml解析、工厂模式、反射
xml---》io流-->读取到内存--〉sax、dom4j--》document---〉node---》放到某个对象中
2.注解
注解--〉反射--》获取class对象--〉getAnnotaion

工厂模式：

IOC模式：

IOC接口（BeanFactory）

1.IOC思想基于IOC容器完成，IOC的容器底层就是对象工厂。
2.Spring提供IOC容器实现两种方式：
1）BeanFactory IOC容器基本实现，是Spring内部接口，不提供开发使用。
加载配置文件的时候不会创建对象，只有在使用对象的时候，才会去创建对象
2）ApplicatoinContext BeanFacotry接口的子接口，提供更多强大的功能，一般由开发人员使用。
加载配置文件的时候会把这个配置文件中的对象进行创建

IOCBean管理

1.什么是bean管理
1）spring创建对象
2）spring注入属性
2.Bean管理操作有两种方式
1）基于xml配置文件实现

<!--    配置user对象创建-->
    <bean id="user" class="com.qingmu.User"> </bean>

• 1)在Spring配置文件中，使用bean标签，标签里面的添加对应的属性，就可以实现对象创建
• 2）在bean标签中有很多属性，介绍常用的属性：
  id属性：唯一标识
  class属性：类全路径
• 3）创建对象的时候，默认也是执行无参数构造方法。
  2）基于注解实现
• 1）DI：依赖注入，就是注入属性
  第一种注入方式：setter注入
  a.创建类，创建setter方法

public class Book {

    private String bname;

    private String bauthor;

    public void setBauthor(String bauthor) {
        this.bauthor = bauthor;
    }

    public void setBname(String bname) {
        this.bname = bname;
    }


    public String getBname() {
        return bname;
    }
}

b.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">

    <bean id="book" class="com.qingmu.Book">
<!--        使用property完成属性注入
            name：类里面属性的名称
            value：类里面注入的值
-->
        <property name="bname" value="易筋经"></property>
        <property name="bauthor" value="达摩老祖"></property>
    </bean>
</beans>

c.test方法

    @Test
    public void testBook(){

        ClassPathXmlApplicationContext orderContext = new ClassPathXmlApplicationContext("Book.xml");

        Book book = orderContext.getBean("book",Book.class);

        String bauthor = book.getBauthor();
        String name = book.getBname();

        System.out.println(bauthor);
        System.out.println(name);
    }

第二种注入方式：有参构造注入
a.创建类，创建setter方法

public class Order {

    private String name;

    private String address;

    public Order(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public String getAddress() {
        return address;
    }


    public String getName() {
        return name;
    }
}

b.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">

    <bean id="order" class="com.qingmu.Order">
        <constructor-arg name="name" value="dianao"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>
</beans>

c.test方法

    @Test
    public void testOrder(){

        ClassPathXmlApplicationContext orderContext = new ClassPathXmlApplicationContext("Order.xml");

        Order order = orderContext.getBean("order",Order.class);

        String bauthor = order.getAddress();
        String name = order.getName();

        System.out.println(bauthor);
        System.out.println(name);
    }

第三种注入方式：p名称空间注入
第一步：添加p名称空间: xmlns:p="http://www.springframework.org/schema/p"

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="book" class="com.qingmu.Book" p:bname="九阳神功" p:bauthor="无名氏">
        <!--底层还是使用的是setter注入-->
    </bean>
</beans>

第四种：xml中null值和其他类型的数据的注入

<?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="book" class="com.qingmu.Book">
<!--        使用property完成属性注入
            name：类里面属性的名称
            value：类里面注入的值
-->
        <property name="bname" >
            <null></null>
        </property>
<!--        特殊字符进行转义
            1.把<>进行转义
            2.把带特殊字符的内容写到CDATA中
-->
        <property name="bauthor" >
            <value><![CDATA[<<南京>>]]]></value>
        </property>
    </bean>
</beans>

注入属性----外部bean

public interface UserDao {

    public void update();

}


public class UserDaoImpl implements UserDao{

    public void update() {
        System.out.println("userDaoImpl...");
    }
}



public class UserService {

    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
        System.out.println("service add....");

//        UserDao userDao = new UserDaoImpl();
        userDao.update();
    }
}


<?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="userService" class="com.qingmu.service.UserService">
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.qingmu.dao.UserDaoImpl"></bean>
</beans>



    @Test
    public void testService(){

        ClassPathXmlApplicationContext orderContext = new ClassPathXmlApplicationContext("UserService.xml");

        UserService order = orderContext.getBean("userService", UserService.class);

        order.add();
    }

注入属性----内部bean
注入属性----级联