SpringIOC入门

2.Spring OC：

什么是SpringIoC?

控制反转ioc(inverse of controll ) 所谓控制反转就是把创建对象(bean),和维护对象(bean)的关系的权利从程序中转移到spring的容器(applicationContext.xml),而程序本身不再维护。之前开发中，直接new一个对象即可。学习spring之后需要实例对象时，从spring工厂（容器）中获得。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象。

主要内容：

SpringIoC的过程？

基础包扫描。读取配置文件，然后根据配置路径进行全包扫描，，最后将扫描到的类名加上全限定名之后加入到数组集合中

实例化所有带注解的类。遍历上一步的数组集合，判断类上的注解并实例化该类，以该类的类名为key，实例为value，放入哈希表中

依赖注入。遍历上一步的哈希表，获取类上所有Fields，遍历Fields，判断Fields上是否为@Autowired类型的注解，如果是的话就把Map中的实例赋值这个field

Url地址和方法映射。遍历第二步的哈希表，如果是Controller实例，获取Methods并遍历，判断方法上是否含有@RequestMapping注解，如果含有，则获取它的值，将@Controller的注解值拼接上@RequestMapping值组成key，当前method作为value，装入hanlerMap中

请求反射调用。(这一步已经属于MVC范畴)一个url请求过来，获取它的地址，拆分，获取Controller实例，获取Method实例，反射执行Method
 

为什么要用SpringMVC?

框架的作用一直都是用来简化编程的：
servlet只有doGet和doPost，一个servlet类只能处理一个url-pattern。
SpringMVC类里面可以通过RequestMapping处理很多请求，并且支持Rest风格的请求，如DELETE/PUT等；SpringMVC参数的映射可以直接封装成实体类。

 SpringMVC的流程

 流程图说明:

用户发送请求至 前端控制器DispatcherServlet。
前端控制器DispatcherServlet收到请求后调用处理器映射器HandlerMapping。
处理器映射器HandlerMapping根据请求的Url找到具体的处理器，生成处理器对象Handler及处理器拦截器HandlerIntercepter（如果有则生成）一并返回给前端控制器DispatcherServlet。
前端控制器DispatcherServlet通过处理器适配器HandlerAdapter调用处理器Controller。
执行处理器（Controller，也叫后端控制器）
处理器Controller执行完后返回ModelAndView。
处理器映射器HandlerAdapter将处理器Controller执行返回的结果ModelAndView返回给前端控制器DispatcherServlet。
前端控制器DispatcherServlet将ModelAnView传给视图解析器ViewResolver。
视图解析器ViewResolver解析后返回具体的视图View。
前端控制器DispatcherServlet对视图View进行渲染视图（即：将模型数据填充至视图中）
前端控制器DispatcherServlet响应用户。

 使用SpringIOC的步骤是什么？

1. 添加Spring Jar包
2. 创建Spring的配置文件
3. 在配置文件中创建组件
4. 增加组件依赖

案例：

jar包

 配置文件：

<?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">
    <!--把所有对象创建到spring的IOC容器中，并起上名字
    id：表示给对象起名字
    class：类的全类名
    -->
    <bean id="bookDao" class="com.su.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService" class="com.su.service.impl.BookServiceImpl">
        <!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
        类型属性使用ref引用-->
        <property name="name" value="张三"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

接口：

package com.su.dao;

public interface BookDao {
    public void insert();
}

 实现类：

package com.su.dao.impl;

import com.su.dao.BookDao;

public class BookDaoImpl implements BookDao {

    @Override
    public void insert() {
        System.out.println("BookDaoImpl...insert");
    }
}

测试：

package com.su.test;

import com.su.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test02 {
    @Test
    public void test02(){
        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        BookService factory= (BookService) context.getBean("BookService");
        System.out.println(factory);
    }
}

---

2、依赖注入（DI）

依赖：一个对象需要使用另一个对象

注入：通过setter方法进行另一个对象实例设置。

创建BookService接口和实现类，创建BookDao接口和实现类，将dao和service配置 xml文件

例如：

dao的接口和实现类为：

public interface BookDao {
  public void insert();
}


public class BookDaoImpl implements BookDao {

    @Override
    public void insert() {
        System.out.println("BookDaoImpl...save");
    }
}

service接口和实现类为：

public interface BookService {
   void save();
   public class BookServiceImpl implements  BookService{

       private BookDao bookDao;
       @Override
       public void save() {
           System.out.println("BookServiceImpl...save");
           bookDao.insert();
       }
   }
}

package com.su.service.impl;

import com.su.dao.BookDao;
import com.su.service.BookService;

public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    private  String name;

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

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

    @Override
    public void save() {
        System.out.println("BookServiceImpl...save");
        bookDao.insert();
    }


}

 配置文件：

<?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">
    <!--把所有对象创建到spring的IOC容器中，并起上名字
    id：表示给对象起名字
    class：类的全类名
    -->
    <bean id="bookDao" class="com.su.dao.impl.BookDaoImpl"></bean>
    <bean id="bookService" class="com.su.service.impl.BookServiceImpl">
        <!--spring的依赖注入：property表示BookServiceImpl的属性，常规属性使用value赋值，
        类型属性使用ref引用-->
        <property name="name" value="张三"/>
        <property name="bookDao" ref="bookDao"/>
    </bean>
</beans>

测试：

package com.su.servlet;

import com.su.service.BookService;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BookServlet {
    BookService bookService;
    @Test
    public void add() {
        System.out.println("BookServlet...add");
//1.获得IOC容器
        ClassPathXmlApplicationContext context=new
                ClassPathXmlApplicationContext("spring.xml");
//2.根据名字从容器中获取对象
        bookService= (BookService) context.getBean("bookService");
        bookService.save();
    }
}