Spring(一)控制反转和依赖注入

此篇主要讲解第一部分IOC和DI

概念

1. IOC（Inversion of Control）控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。通俗的讲就是“将new对象的权利交给Spring，我们从Spring中获取对象使用即可”

1.2)-Spring技术对IoC思想进行了实现

• Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的“外部”
• IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean

2)DI（Dependency Injection）依赖注入

• 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入。

• 目标：充分解耦

  • 使用IoC容器管理bean（IOC)
  • 在IoC容器内将有依赖关系的bean进行关系绑定（DI）

• 最终效果

  • 使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系

一,IOC实现步骤

1. 【第一步】导入Spring坐标

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.12</version>
    </dependency>

2.【第二步】定义Spring管理的类（接口）

3. 【第三步】创建Spring配置文件，配置对应类作为Spring管理的bean对象

<?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标签：
        bean标签的作用： 创建制定类的对象并且存储到spring的容器中
        class: 指定你创建的对象所属的类的类全名
        id: 该对象在容器中的唯一标识
        -->
    <bean id="bookService" class="com.xxxxx.service.impl.xxxxximpl"/>


</beans>

	==注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复==

4.【第四步】初始化IOC容器（Spring核心容器/Spring容器），通过容器获取Bean对象

public class AppTest {

    //测试：从spring的容器中获取对象
    @Test
    public void  testGetBean(){
        //        //1.创建spring的容器,读取配置文件 ,   ApplicationContext  是spring的容器的根接口。
        //ClassPathXmlApplicationContext这个容器特点：根据类路径去读取配置文件的。
        ClassPathXmlApplicationContext  context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //2. 通过id从spring的容器中查找对象
        //BookService bookService = (BookService) context.getBean("bookService");

        //从容器中获取对象的时候，告诉容器对象的类型即可
        BookService bookService = context.getBean("bookService", BookService.class);
        bookService.save();

        //3。关闭容器(以后不需要关闭的)
        context.close();
    }
}

二,DI实现步骤

【第一步】删除使用new的形式创建对象的代码

public class BookServiceImpl implements BookService {
    //【第一步】删除使用new的形式创建对象的代码，解除对象之间的耦合度
    private BookDao bookDao;

    //实现业务方法
    @Override
    public void save() {
        System.out.println("业务层：调用添加书籍的方法");
        bookDao.save();
    }
}

【第二步】提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {

    //service需要依赖Dao
    private BookDao bookDao ;

    @Override
    public void save() {
        bookDao.save();
        System.out.println("service：添加书本..");
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

【第三步】配置service与dao之间的关系(在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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <bean id="bookDao" class="com.xxxxx.dao.impl.BookDaoImpl"/>

    <!--
        di依赖注入的步骤：
            1. 给对象的成员变量生成setter的方法，因为spring认为一个对象是否有指定的属性是取决于你是否有setter方法
            2. 在bean标签里面使用property的标签设置属性，
            
    -->    

    <bean id="bookService" class="com.xxxx.service.impl.BookServiceImpl">
        <!--name属性名， ref 引导指定对象的id-->
        <property name="bookDao"  ref="bookDao"/>
    </bean>

</beans>

Bean基础配置

实例化Bean的三种方法
1. 通过构造方法创建

public class BookDaoImpl implements BookDao {

    public BookDaoImpl() {
        System.out.println("构造方法被调用了.....");
    }

    @Override
    public void save() {
        System.out.println("BookDao保存书籍...");
    }
}

applicationContext.xml配置

  <bean id="bookDao" class="com.ixxxxx.dao.impl.BookDaoImpl"/>

    2. 通过静态工厂方法创建

public class BookFactoryBean { 
   //静态的工厂方法    
   public static BookDao getBookDao(){ 
          return new BookDaoImpl();  
            }}

applicationContext.xml配置

` <bean id="bookDao2" class="com.xxxxx.factory.BookFactoryBean" factory-method="getBookDao"/>`

    3. 通过实例工厂方法创建

public class BookFactoryBean {


    //实例的工厂方法(非静态)
    public  BookDao getBookDaoInstance(){

        return new BookDaoImpl();
    }
}

applicationContext.xml配置

 <bean id="factoryBean" class="com.xxxxx.factory.BookFactoryBean"/>

    <bean id="bookDao3" factory-bean="factoryBean" factory-method="getBookDaoInstance"/>

最后用测试类测一测

public class AppTest {

    //目标：从spring的容器中获取一个对象
    @Test
    public void test01(){
        //1. 创建spring的容器，并且加载配置文件  , spring的容器有一个根接口ApplicationContext
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2  从容器中根据id获取对应的对象
      //  BookDao bookDao = context.getBean("bookDao", BookDao.class);
//        BookDao bookDao = context.getBean("bookDao2", BookDao.class);
        BookDao bookDao = context.getBean("bookDao3", BookDao.class);
        bookDao.save();
    }
}