Spring框架（一）

Spring框架（一）
Spring简介

 学习目标
1. Spring框架设计思想
2. 基础操作，思考操作与思想间的联系
3. 熟悉应用操作的同时，体会思想
Spring家族

 Spring体系结构

 Spring核心概念

 当前代码编写存在的问题
- 主要痛点：耦合度偏高
- 解决方案：使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
程序的耦合
- 耦合：程序间的依赖关系
1. 类之间的依赖
2. 方法间的依赖
- 解耦：降低程序间的依赖关系
注意：编译期不依赖，运行期依赖。
- 解耦思路：
  step1. 使用反射来创建对象，而避免使用new关键字
  step2. 通过读取配置文件来获取要创建的对象全限定类名
工厂模式解耦

创建Bean对象的工厂
- Bean：可重用组件
- JavaBean用Java语言编写的可重用组件
JavaBean>实体类
- 作用：创建service和dao对象
1. 需要一个配置文件来配置我们的service和dao，配置内容：唯一标识=全限定类名(key=value)
2. 通过读取配置文件（.xml或.properties）中的配置内容，反射创建对象
```
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class BeanFactory {
    //定义一个Properties对象
    private static Properties props;

    //定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
    private static Map<String,Object> beans;

    //使用静态代码块为Properties对象赋值
    static {
        try {
            //实例化对象
            props = new Properties();
            //获取properties文件的流对象
            InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            props.load(in);
            //实例化容器
            beans = new HashMap<String,Object>();
            //取出配置文件中所有的Key
            Enumeration keys = props.keys();
            //遍历枚举
            while (keys.hasMoreElements()){
                //取出每个Key
                String key = keys.nextElement().toString();
                //根据key获取value
                String beanPath = props.getProperty(key);
                //反射创建对象
                Object value = Class.forName(beanPath).newInstance();
                //把key和value存入容器中
                beans.put(key,value);
            }
        }catch(Exception e){
            throw new ExceptionInInitializerError("初始化properties失败！");
        }
    }

    /**
     * 根据bean的名称获取对象
     * @param beanName
     * @return
     */
    public static Object getBean(String beanName){
        return beans.get(beanName);
    }

    /**
     * 根据Bean的名称获取bean对象
     * @param beanName
     * @return

    public static Object getBean(String beanName){
        Object bean = null;
        try {
            String beanPath = props.getProperty(beanName);
//            System.out.println(beanPath);
            bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
        }catch (Exception e){
            e.printStackTrace();
        }
        return bean;
    }*/
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
```
核心概念

IOC

降低程序间的耦合（依赖关系）
- IOC（Inversion of Control）控制反转：
  使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部（将new对象的权力交给Spring，直接从Spring中获取对象使用）。
- Spring技术对IOC思想进行了实现
1. Spring提供了一个容器，称为IOC容器，用来充当IOC思想中的“外部”。
2. IOC容器负责对象的创建，初始化等一系列工作，被创建或被管理的对象在IOC容器中统称为Bean。
  作用：获取spring容器的Ioc核心容器，并根据id获取对象
ApplicationContext的三个常用实现类
- ClassPathXmlApplicationContext:可以加载类路径下的配置文件，要求配置文件必须在类路径下。（常用）
- FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件(必须拥有放文权限)
- AnnotationConfigApplicationContext：当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
核心容器的两个接口引发出的问题
- ApplicationContext：单例对象适用
在构建核心容器时，创建对象采用的策略是采用立即加载的方式，即为只要一读取完配置文件马上就创建配置文件中配置的对象
- BeanFactory：多例对象适用
在构建核心容器时，创建对象采用的策略时采用延迟加载的方式，即为什么时候根据id获取对象了，什么时候才真正的创建对象

DI
- DI（Dependency Injection）依赖注入：
  在容器中建立bean与bean之间的依赖关系的整个过程。
- 目标：充分解耦
1. 使用IOC容器管理bean（IOC）
2. 在IOC容器内将有依赖关系的bean进行关系绑定（DI）
- 最终效果：
  使用对象时不仅可以直接从IOC容器中获取，并且获取到bean已经绑定了所有的依赖关系
IOC和DI入门案例

 IOC入门案例

> 标签中id属性和class属性的作用

思路分析
1. 管理什么(Service和Dao)
2. 如何将被管理的对象告知IOC容器(配置文件)
3. 被管理的对象交给IOC容器，如何获取到IOC容器(接口)
4. IOC容器得到后，如何从容器中获取bean(接口方法)
5. 使用Spring导入哪些坐标(pom.xml)
实现步骤

step1. 导入Spring坐标
step2. 定义Spring管理的类(接口)
step3. 创建Spring配置文件，配置对应类作为Spring管理的bean对象
step4. 初始化IOC容器(Spring核心容器/Spring容器)，通过容器获取bean对象

代码实现

step1.
```
<dependencies>
    
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.2.10.RELEASEversion>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
```
step2.
- BookDao接口和BookDaoImpl实现类
```
public interface BookDao {
    public void save();
}

public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
1
2
3
4
5
6
7
8
9
```
- BookService接口和BookServiceImpl实现类
```
public interface BookService {
    public void save();
}

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8
9
10
11
```
- step3.
- 定义applicationContext.xml配置文件并配置BookServiceImpl
```
<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="bookService" class="com.itheima.service.impl.BookServiceImpl">bean>

beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
```
注意事项：bean定义时id属性在同一个上下文中(IOC容器中)不能重复
- step4.
```
public class App {
    public static void main(String[] args) {
        //1.创建IoC容器对象，加载spring核心配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2 从IOC容器中获取Bean对象(BookService对象)
        BookService bookService= (BookService)ctx.getBean("bookService");
        //3 调用Bean对象(BookService对象)的方法
        bookService.save();
    }
}
1
2
3
4
5
6
7
8
9
10
```
DI入门案例

标签中name属性和ref属性的作用

DI思路分析
1. 基于IOC管理bean
2. Service中使用new形式创建的Dao对象是否保留(否)
3. Service中需要的Dao对象如何进行到Service中(提供方法)
4. Service与Dao间的关系如何描述(配置)
实现步骤

step1. 删除使用new的形式创建对象的代码
step2.提供依赖对象对应的setter方法
step3.配置Service与Dao之间的关系

代码实现
- step1.
```
public class BookServiceImpl implements BookService {
    private BookDao bookDao;  //【第一步】删除使用new的形式创建对象的代码
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
```
- step2.
```
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //【第二步】提供依赖对象对应的setter方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}
1
2
3
4
5
6
7
8
9
10
11
```
- step3.
在applicationContext.xml中配置
```
<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.itheima.dao.impl.BookDaoImpl"/>

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
        
        <property name="bookDao" ref="bookDao"/>
    bean>
beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
```
Bean的基础配置
- 在标签上如何配置别名
- Bean的默认作用范围，修改方法
Bean基础配置

 Bean别名配置

* 注意事项获取bean无论是通过id还是bean获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException

NoSuchBeanDefinitionException:No bean named ‘bookeServiceImpl’ available

Bean作用范围配置

提示：scope的取值不仅仅只有singleton和prototype，还有request、session、application、websocket，表示创建出的对象放置在web容器(tomcat)对应位置

 Bean的实例化

spring对bean的管理细节
1. 创建bean的三种方式
2. bean对象的作用范围
3. bean对象的生命周期
Bean创建方法

Bean本质为对象，创建Bean使用构造方法。

实例化Bean的三种方式

构造方法方式
使用默认构造函数创建
- 在spring的配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
- 采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则对象无法创建。
- BookDaoImpl实现类
```
public class BookDaoImpl implements BookDao {
    public BookDaoImpl() {
        System.out.println("book dao constructor is running ....");
    }
    public void save() {
        System.out.println("book dao save ...");
    }
}
1
2
3
4
5
6
7
8
```
- applicationContext.xml配置
```
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
1
2
3
```
- AppForInstanceBook测试类
```
public class AppForInstanceBook {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");

        bookDao.save();
    }
}
1
2
3
4
5
6
7
8
9
```
静态工厂方式
- 使用工厂中的静态方法创建对象（使用某个类中的静态方法创建对象，并存入spring容器)
- OrderDao接口和OrderDaoImpl实现类
```
public interface OrderDao {
    public void save();
}
public class OrderDaoImpl implements OrderDao {
    public void save() {
        System.out.println("order dao save ...");
    }
}
1
2
3
4
5
6
7
8
```
- OrderDaoFatory工厂类
```
//静态工厂创建对象
public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        System.out.println("factory setup....");
        return new OrderDaoImpl();
    }
}
1
2
3
4
5
6
7
```
- applicationContext.xml配置
```
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
1
2
```
- AppForInstanceOrder测试类
```
public class AppForInstanceOrder {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}
1
2
3
4
5
6
7
8
9
```
实例工厂方式
- 使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）
- - UserDao接口和UserDaoImpl实现类
```
public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    public void save() {
        System.out.println("user dao save ...");
    }
}
1
2
3
4
5
6
7
8
```
- - UserDaoFactory工厂类
```
//实例工厂创建对象
public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}
1
2
3
4
5
6
```
- - applicationContext.xml配置
```
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>

<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
1
2
3
4
```
- - AppForInstanceUser测试类
```
public class AppForInstanceUser {
    public static void main(String[] args) {
        //        //创建实例工厂对象
        //        UserDaoFactory userDaoFactory = new UserDaoFactory();
        //        //通过实例工厂对象创建对象
        //        UserDao userDao = userDaoFactory.getUserDao();
        //        userDao.save();
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) ctx.getBean("userDao");
        userDao.save();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
```
bean的作用范围调整

bean标签的scope属性：
- 作用：用于指定bean的作用范围
- 取值：常用的就是单例的和多例的
singleton：单例的（默认值）
prototype：多例的
request：作用于web应用的请求范围
session：作用于web应用的会话范围
global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境时，它就是session

Bean的生命周期
- 多例的Bean能够配置并执行销毁的方法
- 如何执行Bean销毁的方法
生命周期相关概念介绍
- 生命周期：从创建到消亡的完整过程
- Bean生命周期：Bean从创建到销毁的完整过程
- Bean生命周期控制：在Bean创建后到销毁前做一些事情
Bean销毁时机
- 容器关闭前触发Bean的销毁
- 关闭容器方式：
1. 手工关闭容器：
- ConfigurableApplicationContext接口close()操作
- 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机：ConfigurableApplicationContext接口registerShutdownHook()操作
依赖注入(DI配置) Dependency Injection
- 概念：对程序间依赖关系的维护
依赖注入方式

依赖注入的两种方式
- setter注入：简单类型、引用类型
- 构造器注入：简单类型、引入类型
setter方式注入
- setter方式注入使用的子标签：
- 配置中使用property标签ref属性注入引用类型对象
- 在Bean中定义引用类型属性并提供可访问的set方法
- 配置中使用property标签value属性注入简单类型数据
- 标签：property
- 位置：bean标签的内部
- 标签的属性
  - name：用于指定注入时所调用的set方法名称
  - value：用于提供基本类型和String类型的数据
  - ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
- 优势：
  创建对象时没有明确的限制，可以直接使用默认构造函数
- 劣势：
  如果有某个成员必须有值，则获取对象是有可能setter方法没有执行。
引用类型

简单类型

构造方式注入
- 构造方式注入使用的子标签：
- 在Bean中定义引用类型属性并提供可访问的构造方法
- 配置中使用constructor-arg标签ref属性注入引用类型对象
- 在Bean中定义引用类型属性并提供可访问的set方法
- 配置中使用constructor-arg标签value属性注入简单类型数据
- 标签:constructor-arg
- 位置：bean标签的内部
- 标签中的属性
  - type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
  - index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值。索引的位置是从0开始
  - name：用于指定给构造函数中指定名称的参数赋值常用的
    以上三个用于指定给构造函数中哪个参数赋值
  - value：用于提供基本类型和String类型的数据
  - ref：用于指定其他的bean类型数据。它指的就是在spring的Ioc核心容器中出现过的bean对象
- 优势：
  在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。
- 劣势：
  改变了bean对象的实例化方式，使我们在创建对象时，即使用不到这些数据，也必须提供。
引用类型

简单类型

 复杂类型/集合类型的注入
- 用于给List结构集合注入的标签：list array set
- 用于个Map结构集合注入的标签:map props
结构相同，标签可以互换

 依赖注入方式选择
- 强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现
- 可选依赖使用setter注入进行，灵活性强
- Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨
- 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入
- 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入
- 自己开发的模块主要使用setter注入
依赖自动装配

 自动装配
- 概念：IOC容器根据Bean所依赖的资源在容器中自动寻找并注入到Bean中的过程
- 自动装配方式：
  .按类型
按名称
按构造方法
不启用自动装配

自动装配类型

依赖自动装配

配置中使用bean标签autowire属性设置自动装配的类型
```
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
1
2
```
依赖自动装配特征
1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效
集合注入

注入数组类型数据
```
<property name="array">
    <array>
        <value>100value>
        <value>200value>
        <value>300value>
    array>
property>
1
2
3
4
5
6
7
```
注入List类型数据
```
<property name="list">
    <list>
        <value>itcastvalue>
        <value>itheimavalue>
        <value>boxueguvalue>
        <value>chuanzhihuivalue>
    list>
property>
1
2
3
4
5
6
7
8
```
注入Set类型数据
```
<property name="set">
    <set>
        <value>itcastvalue>
        <value>itheimavalue>
        <value>boxueguvalue>
        <value>boxueguvalue>
    set>
property>
1
2
3
4
5
6
7
8
```
注入Map类型数据
```
<property name="map">
    <map>
        <entry key="country" value="china"/>
        <entry key="province" value="henan"/>
        <entry key="city" value="kaifeng"/>
    map>
property>
1
2
3
4
5
6
7
```
注入Properties类型数据
```
<property name="properties">
    <props>
        <prop key="country">chinaprop>
        <prop key="province">henanprop>
        <prop key="city">kaifengprop>
    props>
property>
1
2
3
4
5
6
7
```
说明：property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写、、、、标签

 单例与多例（补充）

单例模式
- 概念：一个类有且仅有一个实例，并且自行实例化向整个系统提供。
多例模式（反面模式）
- 概念：指存在一个类有多个相同实例，而且该实例都是该类本身。
- 特点：
  - 多例类可以有多个实例。
  - 多例类必须自己创建、管理自己的实例，并向外界提供自己的实例。
单例模式与多例模式说明
1. 单例模式和多例模式属于对象模式。
2. 单例模式的对象在整个系统中只有一份，而多例模式可以有多个实例类。
3. 它们都不对外提供构造方法，即构造方法都为私有。
相关阅读:
第六届“强网杯”全国网络安全挑战赛-青少年专项赛
 程序员在工作之余如何保障收入？兼职才是硬道理！
Spring Boot框架
 Redis内存回收
 鸿鹄工程项目管理系统 Spring Cloud+Spring Boot+Mybatis+Vue+ElementUI+前后端分离构建工程项目管理系统项目背景
 weserver发布地图服务
 Day20_网络编程(软件结构,网络编程三要素,UDP网络编程,TCP网络编程)
P1093 [NOIP2007 普及组] 奖学金
 Java中如何清空一个HashSet对象呢？
第八章、定制new和delete
原文地址：https://blog.csdn.net/Williams10/article/details/126021514

Spring简介

学习目标

Spring家族

Spring体系结构

Spring核心概念

当前代码编写存在的问题

程序的耦合

工厂模式解耦

创建Bean对象的工厂

核心概念

IOC

ApplicationContext的三个常用实现类

核心容器的两个接口引发出的问题

DI

IOC和DI入门案例

IOC入门案例

思路分析

实现步骤

代码实现

DI入门案例

DI思路分析

实现步骤

代码实现

Bean的基础配置

Bean基础配置

Bean别名配置

Bean作用范围配置

Bean的实例化

spring对bean的管理细节

Bean创建方法

实例化Bean的三种方式

构造方法方式

静态工厂方式

实例工厂方式

bean的作用范围调整

bean标签的scope属性：

Bean的生命周期

生命周期相关概念介绍

Bean销毁时机

依赖注入(DI配置) Dependency Injection

依赖注入方式

依赖注入的两种方式

setter方式注入

引用类型

简单类型

构造方式注入

引用类型

简单类型

复杂类型/集合类型的注入

依赖注入方式选择

依赖自动装配

自动装配

自动装配类型

依赖自动装配

依赖自动装配特征

集合注入

注入数组类型数据

注入List类型数据

注入Set类型数据

注入Map类型数据

注入Properties类型数据

单例与多例（补充）

单例模式

多例模式（反面模式）

单例模式与多例模式说明