Spring----01----概述&&配置详解

1. Spring框架

在这里插入图片描述

Spring框架的作用范围横跨项目的三层；
Spring是项目中对象的管家；
2003年由Rob Johnson创建。

2. Spring框架搭建

2.1 导入依赖

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

2.2 创建一个类

public class User {

    private Integer id;
    private String name;

    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;
    }
}

2.3 创建Spring配置文件

规范：Spring官方没有对配置文件的名字|位置规定规范，但是开发通常将配置文件放到/resource/applicationContsext.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">

    <!-- 配置spring容器需要管理的对象 -->
    <bean name="user" class="com.leo.domain.User"></bean>

</beans>

2.4 测试

public class App {
    public static void main(String[] args) {
        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user");
        System.out.println(user);
    }   
}

2.5 Spring简单原理

spring读取xml配置文件，读取配置文件中的诸多对象信息（完整类名）；
根据完整类名，获得Class字节码文件（Class.forName(类名)）；
通过反射技术，创建出对象（newInstance）；
创建出的对象会放入到一个Map结构中，其中name属性值作为键，对象作为值；
我们从spring容器中获得对象时，就可以根据键去取出值（对象）。
3. Spring进阶介绍

3.1 BeanFactory&ApplicationContext（概念）

上图是BeanFactory的继承关系图

在这里插入图片描述
上图是ApplicationContext的继承关系图

ApplicationContext是更加常用的容器类型；
BeanFactory是spring框架刚刚出现时，诞生的原始的容器类型；
ApplicationContext是spring框架后续随着发展诞生的拥有更多功能的容器类型；
ApplicationContext接口是BeanFactory接口的子类，ApplicationContext拥有BeanFactory的全部功能；
BeanFactory是只具备容器的基本功能；

ApplicationContext对容器功能进行了极大的丰满：

默认初始化所有的Singleton，也可以通过配置取消预初始化。
继承MessageSource，因此支持国际化；
资源访问，比如访问URL和文件；
事件机制；
同时加载多个配置文件；
以声明式方式启动并创建Spring容器。

3.2 IOC与DI

3.2.1 IOC

IOC:inverse of control fanzhaung控制。
理解：开发人员以前创建对象时，都是需要用到什么对象就去手动创建什么对象，如果对象中有依赖关系存在，就需要手动去维护依赖关系，例如：我们需要A对象，但A对象依赖于B对象，我们就需要先手动创建B对象，然后手动创建A对象，再把B对象注入到A对象中，总结说，就是整个对象的生命周期都是由开发人员手动维护的。
上面这段话可以理解为传统的控制方式，或者说正向的控制对象方式。
什么是反转控制呢？
将对象的创建以及依赖关系的注入全部交给程序帮我们完成，而不再是由我们自己去控制你程序完成，那么就可以称之为反转控制，反转的是对象的创建方式。

3.2.2 DI

DI：Dependency Injection 依赖注入
理解：将依赖的属性注入到对象的过程，即为依赖注入。
例如：Servlet依赖于Service，Service依赖于Dao等，我们将Service注入到Servlet的过程就是依赖注入，依赖注入的方式有两种，一种是set方法注入，还用一种是构造方法注入，这两种方式，Spring都支持。

3.2.3 IOC与DI之间的关系

我们要实现IOC设计必须要有DI技术的支持。

4.Spring配置详解

4.1 Spring创建对象方式

4.1.1 由Spring调用构造方法创建（使用最多）
```
<bean name="user" class="com.leo.domain.User">
  </bean>
```
4.1.2 使用静态工厂方法创建对象

工厂方法：
```
public class UserFactory {

  //创建User对象并返回
  public static User getUser1(){
      User u = new User();
      u.setName("jerry");
      u.setId(2);
      return  u;
  }
}
```
配置文件：

 <!-- 调用静态工厂方法创建User对象
            调用UserFactory对象的getUser1方法获得user2对象那个放入spring容器中
    -->
    <bean name="user2" class="com.leo.factory.UserFactory"  factory-method="getUser1"></bean>

测试：

public class App {

    public static void main(String[] args) {

        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user2");
        System.out.println(user);

    }

}

4.1.3 使用动态工厂方法创建对象

工厂方法：

     //创建User对象并返回 -> 动态工厂方法
    public User getUser2(){
        User u = new User();
        u.setName("jack");
        u.setId(3);
        return  u;
    }

xml配置：

    <!-- 调用动态工厂方法创建User对象 -->
    <bean name="userFactory" class="com.leo.factory.UserFactory"></bean>
    <!--
        调用userFactory对象的getUser2方法获得user3对象，交给容器管理
    -->
    <bean name="user3" factory-bean="userFactory" factory-method="getUser2"></bean>

测试：

public class App {

    public static void main(String[] args) {

        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        User user = (User) ac.getBean("user3");
        System.out.println(user);

    }
}

4.2 对象的作用域&生命周期

配置：

    <!-- 学习对象的作用域配置
            scope：对象的作用域配置
                singleton(默认值)：单例模式，单例模式对象再spring容器中只存在一个实例
                                    spring容器启动时会创建所有单例对象，spring容器关闭钱销毁所有单例对象
                                    spring管理的绝大多数对象，都应配置为singleton
                prototype：原型模式，非单例模式。每次获得对象都是一个全新（new）的对象。
                            所以原型对象是每次获得对象时，才会去创建对象，
                                spring容器不会保存原型对象，换句话说，原型对象一旦创建就与spring容器脱离了关系，
                                    spring只负责创建，不负责维护生命周期

                request：在web项目环境中，对象生命周期与request对象绑定，每次请求都会创建一个新的对象
                session：在web项目环境中，对象生命周期与httpSession对象绑定，每次会话都会创建一个新的对象
                globalsession：在web项目环境中，对象生命周期与全局Session对象绑定。

                init-method：指定初始化方法，当对象被创建后，会调用该属性指定的方法，可用于初始化资源
                destroy-method：指定销毁方法，当前对象被销毁前会调用该方法，可以用于释放资源
     -->
    <bean name="user4" class="com.leo.domain.User" scope="singleton"  destroy-method="destory" init-method="init"></bean>

测试：

    @Test
    public void fun1() {
        //1.创建spring容器
        ApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");
        //2.从spring容器中获得user对象
        //同一个User4只存在一个实例
        User user1 = (User) ac.getBean("user4");
        User user2 = (User) ac.getBean("user4");

        //true => 只有一个User4实例（singleton）
        //false => 每次从容器中获取的都是不同的对象（prototype）
        System.out.println(user1 == user2);
    }

      @Test
    public void fun2() {

        //1.创建spring容器 -> 创建所有singleton对象
        ClassPathXmlApplicationContext ac =
                new ClassPathXmlApplicationContext("applicationContsext.xml");

        //2.关闭spring容器 -> 销毁所有singleton对象
        ac.close();
    }