一 Spring简介

1.1 为什么需要spring？

在软件设计中 ，有一种模式叫做 MVC 。称之为 Model 模型 View 视图 Controller 控制器。

但是我们的javaweb项目并没有完全实现mvc中所有的内容。因为我们没有事件驱动。

而javaweb在发展的时候 ，其实为玩 Model 1 、Model 1 二代 、Model 2

Model1 时期整个请求的流程：

Model 1 二代时期整个请求的流程：

Model2 时期整个请求的流程：

servlet负责 获取请求、处理业务、调用DAO、共享数据、选择视图

JAVAWeb由Model2 演变成 三层架构 ：

在原始的三层架构中 ，我们都是使用正转进行操作的，例如：

当我们需要使用某一个类的对象时，直接通过new去创建该类的对象，这种操作就称之为 正转操作。

但是正转操作是一种高耦合（多个类之间关联比较密切，会出现如果一个类修改，会导致一系列的类都需要进行修改）的表现。以前java代码都是比较笨重的，称为诟病的就是因为都在进行正转操作。

此时我们试想一下，如果StudentServiceImpl这个类升级了，换成了StudentServiceImpl2，此时我们需要去所有使用StudentServiceImpl的地方将其换成StudentServiceImpl2。

所以正转操作不是很好，我们可以使用 工厂模式 来解决这个问题。

例如： People Man Women 都使用到了 Food这个类

我们如果直接正转操作使用 food 此时将来如果food变成food2 此时改起来不好改，所以我们使用简单工厂模式。

还有一个核心问题没有解决，当我们将工厂中的food换成food2的时候 ，此时并没有实现一个效果，所有的类都改完成， 而是全部报错

原因在于 工厂此时返回值为 Food2 而我们接受的类型为Food，此时类型不匹配。这个问题怎么解决？

可以创建一个接口，我们使用接口类型去接收实现类对象-----接口多态。

我们就解决了正转的问题；创建对象的时候不再是直接new对象 ----控制正转

而是将创建对象的操作放到工厂中，需要使用对象的时候去工厂中获取----控制反转 IoC

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。使用对象的时候不再是直接new，而是将创建对象的权利交给框架中的核心容器，需要使用对象的时候直接从容器中获取。

IoC的思想早就出现了，但是没有一个具体的实现，大家都是各自根据这个思想去写代码(自己去创建工厂)。

后来有一个大师 Rod Johnson（Spring Framework创始人，著名作者。 Rod在悉尼大学不仅获得了计算机学位，同时还获得了音乐学位。更令人吃惊的是在回到软件开发领域之前，他还获得了音乐学的博士学位。），写了一个框架，将IoC思想具体的实现了，这个框架后来起了个名字叫做 Spring。（因为在这之前 大家都是用hibernate这个框架，这个框架中文名字叫做冬眠，并且这个框架比较笨重，耦合比较高。Rod Johnson写的框架就是用来解决类似于hibernate高耦合的问题 ，所以他将自己框架的名字命名为 Spring 告诉全世界 冬天过去了 春天来了）

1.2 spring产品

spring的官方网站：https://spring.io/

我们可以看到spring有很多产品 spring已经变成了一个生态圈。但是我们平时还是需要将spring理解成Spring Framework

我们看一下spring-framework组成

Test： spring自带的单元测试

Core Container： 核心容器。这是IoC思想的关键，Spring负责创建对象 并且存放到 核心容器中。

AOP：面向切面编程

Web：与javaweb相关的组件

Data Access ： 与数据库操作/JDBC操作相关组件

1.3 spring项目的构建

A 创建maven工程

B 在maven工程中添加spring的pom依赖

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

C src/main下创建一个文件夹 sources 并且将文件夹的格式改成resources root 。在里面添加spring的配置文件

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

D 创建一个测试类 测试spring的使用。

二 Spring的IoC操作

2.1 传统的正转操作

@Test
public  void test1() throws Exception{
     People people = new People();
     people.eat();
 }

public class People {
    public  void  eat(){
        System.out.println("人类都要吃饭");
    }
}

2.2 通过spring核心容器获取

A 在xml中配置当前类的信息（告诉spring 有哪些类的对象 需要spring核心容器去管理）

<bean   id="p1"  class="com.aaa.test.People"></bean>

B 使用spring的工厂去获取对应的bean 。 BeanFactory

@Test
public  void test1(){

    ClassPathResource resource = new ClassPathResource("application.xml");
    BeanFactory factory = new XmlBeanFactory(resource);

    People p1 = (People) factory.getBean("p1");
    p1.eat();

}

原理思考：

2.3 ApplicationContext获取bean

@Test
public void test2() {
    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    People p1 = (People) context.getBean("p1");
    p1.eat();
}

面试题： ApplicationContext 和 BeanFactory的区别？

BeanFactory：是Spring里面最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；

ApplicationContext：应用上下文，继承BeanFactory接口，它是Spring的一各更高级的容器，提供了更多的有用的功能；

1) 国际化（MessageSource）

2) 访问资源，如URL和文件（ResourceLoader）

3) 载入多个（有继承关系）上下文 ，使得每一个上下文都专注于一个特定的层次，比如应用的web层

4) 消息发送、响应机制（ApplicationEventPublisher）

5) AOP

并且二者之间对bean的初始化时机（创建对象的时机）是不一样的。

BeanFactory是遵循懒加载模式创建对象，也就是说BeanFactory被创建的时候并没有初始化bean，只有getBean的时候才去创建对象。

ApplicationContext是遵循饿汉模式创建对象，因为ApplicationContext对象被创建的时候，同时会初始化bean。

我们可以通过lazy-init设置成懒加载模式。

2.4 getBean()的三种方式

A 通过 id 或者 name的值获取bean

Object p1 = context.getBean("p1");

B 通过类型去获取

People bean = context.getBean(People.class);

确保bean的类型是唯一的 不然会报错：org.springframework.beans.factory.NoUniqueBeanDefinitionException

C 通过 id + 类型去获取

People bean = context.getBean("p1",People.class);

2.5 bean的属性配置

id ： 当前bean的唯一标识符

class：配置类的全限定名

name：配置当前bean的名字，并且可以配置多个。以前使用的比较多，在spring3之前 name可以使用符号例如 ： /stu 而id不可以。

后来id也可以添加符号例如/ 所以通常使用id比较多。

lazy-init ： 配置bean的初始化时机 是否是懒加载。设置成true代表懒加载。还可以全局设定在beans标签中设定default-lazy-init="true"

scope：作用域 默认是 singleton单例的 prototype多例的 request请求 session会话 global session 全局会话

ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

People bean1 = context.getBean("p1",People.class);
People bean2 = context.getBean("p1",People.class);

System.out.println(bean1 == bean2);//true

有的类 对象被创建的时候需要调用初始化函数，对象被回收的时候需要调用销毁函数。现在对象时由spring核心容器去管理的。

所以这些函数的调用应该由spring负责。我们只需要通过配置告诉spring初始化函数是谁，销毁函数是谁。bean的生命周期函数

init-method：

destroy-method：

<bean id="p1" name="aa  bb  cc"  class="com.aaa.test.People" lazy-init="true"  scope="singleton" init-method="hehe" destroy-method="haha"></bean>

@Test
public void test2() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
    People bean1 = context.getBean("p1",People.class);
    context.close();
}

注意，此时scope不能是多例的 否则销毁函数不会调用

三 DI依赖注入

3.1 对象关系----依赖关系

面向对象设计 对象间关系：依赖、关联、聚合和组合。

关联关系： 例如 人类和电脑类

某个对象会长期的持有另一个对象的引用，而二者的关联往往也是相互的。

public class People {

        int   id;
        String  name;
        String  nickname;
        String  address;

        Computer   c;

}

public class Computer {
    int  id;
    String  name;
    String  cpu;
}

@Test
public  void  test1(){
    People people = new People();
    people.id = 20;
    people.name = "张三0";
    
    people.c.name = "外星人";
}

依赖关系： Servlet 和service

所谓依赖就是某个对象的功能依赖于另外的某个对象，而被依赖的对象只是作为一种工具在使用，而并不持有对它的引用。

public class StudentServlet {

    StudentService  service;
    
    
}

3.2 依赖注入---DI Dependency Injection

当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

依赖注入有两种：设值注入、构造注入

所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。

在我们开发中会出现对象依赖的情况 ，例如 StudentServlet 依赖于 StudentService。在以前的时候我们都是直接在Servlet中new业务层Service对象，这是一个正转操作，会有高耦合。我们使用Spring框架，要遵循IoC，让对象的创建都交给Spring的核心容器。此时所有的对象都是Spring管理，也就是说 StudentServlet 是Spring 管理的，StudentService也是Spring管理的。

通过依赖注入 我们在类中需要使用另一个类的对象时，完全不需要自己创建了，而是让spring去帮我们创建并注入

IoC是一种思想，在在Spring中 DI 是这个思想的具体实现方式。

3.3 依赖注入的两种方式

A set方法注入

public class StudentServlet {

    StudentService  haha;

    public void setHaha(StudentService haha) {
        this.haha = haha;
    }


    @Override
    public String toString() {
        return "StudentServlet{" +
                "haha=" + haha +
                '}';
    }
}

public class StudentService {


}

xml配置DI依赖注入的关系

<bean  id="servlet"  class="com.aaa.test1.StudentServlet">
    <property name="haha"  ref="hehe"  ></property>
</bean>
<bean id="hehe" class="com.aaa.test1.StudentService"></bean>

调用代码：

@Test
public  void  test1(){

    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

    Object servlet = context.getBean("servlet");

    System.out.println(servlet);

}

B 构造函数注入

public class StudentServlet {

    StudentService  haha;

    public StudentServlet(StudentService haha) {
        this.haha = haha;
    }

    @Override
    public String toString() {
        return "StudentServlet{" +
                "haha=" + haha +
                '}';
    }
}

<bean  id="servlet"  class="com.aaa.test1.StudentServlet">
    <constructor-arg  name="haha"  ref="hehe" ></constructor-arg>
</bean>

<bean id="hehe" class="com.aaa.test1.StudentService"></bean>

3.4 依赖注入的底层思考

反射是框架的灵魂

@Test
public  void test2() throws  Exception{

    /*
    <bean  id="servlet"  class="com.aaa.test1.StudentServlet">
         <property  name="haha"  ref="hehe" ></property>
    </bean>

     <bean id="hehe" class="com.aaa.test1.StudentService"></bean>
     */

    Class<?> aClass = Class.forName("com.aaa.test1.StudentServlet");
    Object o = aClass.newInstance();

    BeanInfo beanInfo = Introspector.getBeanInfo(aClass);

    PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors();

    for (PropertyDescriptor p:descriptors) {
        if(p.getName().equals("haha")){

            Method writeMethod = p.getWriteMethod();
            writeMethod.invoke( o , Class.forName("com.aaa.test1.StudentService").newInstance()  );
        }
    }

    System.out.println(o);
}

3.5 注入值的形式

A 注入对象

<bean  id="servlet"  class="com.aaa.test1.StudentServlet">
    <property name="haha"  ref="hehe"  ></property>
</bean>

<bean id="hehe" class="com.aaa.test1.StudentService"></bean>

注意 注入对象的时候 使用的是 ref

B 注入简单值

注意 注入对象的时候 使用的是 value

<bean  id="dao"  class="com.aaa.test1.BaseDAO">
    <property name="className" value="com.mysql.jdbc.Driver"></property>
    <property name="url"       value="jdbc:mysql:///test"></property>
    <property name="username"  value="root"></property>
    <property name="password"  value="root"></property>
</bean>

public class BaseDAO {


    private  String   className;
    private  String   url;
    private  String   username;
    private  String   password;


    public void setClassName(String className) {
        this.className = className;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }


    @Override
    public String toString() {
        return "BaseDAO{" +
                "className='" + className + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

代码调用

@Test
public  void  test3(){

    ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");

    Object servlet = context.getBean("dao");

    System.out.println(servlet);

}

C 注入集合框架

public class People {

    List<String>          tels;
    Map<String,Object>    friends;

    public void setTels(List<String> tels) {
        this.tels = tels;
    }

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

    @Override
    public String toString() {
        return "People{" +
                "tels=" + tels+"friends:"+ friends +
                '}';
    }
}

<bean id="p1" class="com.aaa.test1.People">

    <property name="tels">
        <list>
             <value>15966663333</value>
             <value>15166333333</value>
             <value>18966663333</value>
             <value>15933336666</value>
        </list>
    </property>
    
    <property name="friends">
        <map>
           <entry key="f1" value="张三"></entry>
           <entry key="f2" value="李四"></entry>
           <entry key="f3" value="王五"></entry>
           <entry key="f4" value="赵六"></entry>
        </map>
    </property>

</bean>

3.6 自动注入的形式

<bean id="haha" class="com.aaa.test1.StudentServlet">
    <property name="haha"   ref="hehe"></property>
</bean>

<bean id="hehe" class="com.aaa.test1.StudentService"></bean>

这是我们以前注入的形式 ，是手动维护类和类之间的依赖关系，此时没有问题。但是不优秀，因为在一个项目中会有很多的类需要关系的维护，我们都是通过 propertity进行手动操作很麻烦，而是配置文件会很庞大。

所以spring提供了一套自动注入的形式

xml形式：

public class StudentServlet {

    StudentService  hehe;

    public void setHehe(StudentService hehe) {
        this.hehe = hehe;
    }

    @Override
    public String toString() {
        return "StudentServlet{" +
                "haha=" + hehe +
                '}';
    }
}

<bean id="haha" class="com.aaa.test1.StudentServlet" autowire="byName"></bean>

<bean id="hehe" class="com.aaa.test1.StudentService"></bean>

autowire自动注入，此时设定的是byName按照名字去注入，此时在servlet中有一个成员变量名字是hehe，所以就会去所有的bean中找id为hehe的bean，找到了则注入。没找到则抛异常。

<bean id="haha" class="com.aaa.test1.StudentServlet" autowire="byType"></bean>

<bean id="heihei" class="com.aaa.test1.StudentService"></bean>

autowire自动注入，此时设定的是byType按照类型去注入，此时servlet中成员变量的类型为 com.aaa.test1.StudentService, 所以就会去所有的bean中找class为com.aaa.test1.StudentService，找到了则注入，没有就抛异常，找到多个也抛异常。

注解形式：

A 配置当前spring需要管理哪些bean（类）

B 配置哪些依赖需要spring帮忙注入

第一步： 开启注解扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd" >

       <!--注解配置-->
       <context:annotation-config></context:annotation-config>
       <!--注解包扫描-->
       <context:component-scan base-package="com.aaa.test1"  ></context:component-scan>

</beans>

第二步：通过注解 @Component 配置 哪些类需要spring管理

@Component("haha")
/*<bean  id="haha"  class="com.aaa.test1.StudentServlet" />*/
public class StudentServlet {

    StudentService  hehe;

    @Override
    public String toString() {
        return "StudentServlet{" +
                "haha=" + hehe +
                '}';
    }
}

@Component("heihei")
public class StudentService {

}

第三步：通过注解@AutoWired注解告诉spring需要进行依赖注入

@Autowired
StudentService  hehe;

3.7 @Autowired 和 @Resource的注入原则/装配顺序

@Autowired：

当自动注入bean的时候 首先根据类型去匹配

如果一个都匹配不到，则查看是否配置(required = true) 如果没有配置或者配置的是true，就代表必须注入，此时则抛出异常。

如果配置的是false，代表不是必须注入，此时如果找不到没救不注入。（注意：如果设定为false，又没有注入成功 ，在使用当前成员变量的时候 会出现空指针异常。）

如果正常匹配到一个 ，则按照类型正常注入。

如果匹配到多个bean的类型都是同一类型。则根据当前变量的名字匹配对应的bean的名字。如果匹配到 则进行注入。

如果匹配不到 则 抛出异常

如果配置了@Qualifier("heihei") 则根据@Qualifier("heihei")的名字匹配对应的bean

@Resource

import javax.annotation.Resource;

是我们JDK自带的一个注解

a. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常

b. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常

c. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常

d. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配(名字没有一样的)，则回退为一个原始类(相当于按照类型取查找一个实现类，如果按照类型取查找的实现类有多个 则抛出异常)

3.8 注解配置的语义化注解

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
    String value() default "";
}

我们需要在控制层添加 @Controller

在业务层添加 @Service

在数据持久层添加@Repository

在其他的地方都是用@Component