Spring框架01

一 Spring的概要

1.1 简介

Spring，春天的意思，意指给软件行业带来春天。2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

1.2 优点

1. Spring是一个开源的轻量级的应用开发框架，其目的是
       用于简化企业级应用程序开发，降低侵入性;
2. Spring提供的IOC和AOP功能，可以将组建的耦合度降至最低，即解耦，便于系统日后的维护和升级
3. 提供了对持久层、事务的支持
4. 提供了MVC框架思想的实现，用于开发企业级应用。
5. 也可以与第三方框架和技术整合应用，可以自由选择采用哪种技术进行开发

一句话概括：Spring是一个轻量级的[控制反转](https://so.csdn.net/so/search?q=控制反转&spm=1001.2101.3001.7020)(IoC)和面向切面(AOP)的容器（框架）。

1.3 Spring的发展历程

1997 年 IBM提出了EJB 的思想

1998 年，SUN制定开发标准规范 EJB1.0

1999 年，EJB1.1 发布

2001 年，EJB2.0 发布

2003 年，EJB2.1 发布

2006 年，EJB3.0 发布

Rod Johnson （罗德·约翰逊，Spring 之父）

Expert One-to-One J2EE Development without EJB(2004)

阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形）

2017年9月份发布了Spring的最新版本Spring 5.0通用版

1.4 模块

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

1. 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

2. Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

3. Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。

4. Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

5. Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

6. Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

7. Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.5 拓展 Spring Boot与Spring Cloud

• Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;

• Spring Cloud是基于Spring Boot实现的；

• Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；

• Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。

• SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

二 Spring IOC

2.1 IOC简介

IoC（Inverse Of Control）控制反转：即，把创建对象的权利交给框架，也就是指将对象的创建、对象的初始化、对象的存储、对象的管理交给了Spring容器。IOC本质是一种设计思想。

IoC 是一种通过描述来生成或者获取对象的技术，对于Java初学者 更多时候所熟悉的是使用 new 关键字来创建对象，而在spring中则不是，它是通过描述（XML或注解）来创建对象。

在 Spring 中把每一个需要管理的对象称之为 Spring Bean（简称为Bean），而Spring中管理这些 Bean 的容器，被我们称之为 Spring IoC 容器（简称 IoC容器）

在此之前，当需要对象时，通常是利用new关键字创建一个对象：

/* 创建一个User对象——这里使用new对象的方式造成了程序之间的耦合性提升 */
User u = new User();

但由于new对象，会提高类和类之间的依赖关系，即代码之间的耦合性。

而现在我们可以将对象的创建交给框架来做：

// 获取Spring IoC容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
// 从spring的IoC容器中获取User对象
private User user = (User)ctx.getBean("user");

将需要的POJO提前在配置文件（XML或注解）中进行描述，Spring会根据配置文件将其中所描述生成 IoC容器并装配Bean，在需要使用时，再次获取即可

这样一来，当需要对象时不用自己创建，而是通过框架获取即可，不用硬编码去new对象，自然就降低类和类之间的依赖关系，也就是耦合性。 

2.2 入门案例

在Spring中允许我们通过XML或注解方式装配Bean，下面先来介绍Spring中通过XML方法如何装配Bean。

扩展：

idea里的project 相当于 eclipse里的 workspace

idea里的module 相当于eclipse里的project 为了迎合现在的模块形式开发。

module可以称之为模块或者是子项目，依赖于父项目(project) . 开发时一般都是开发的module，因此父项目的src可以删掉

隐藏不想看到的文件或者文件夹

File—>settings—>Editor—>File Types—>ignored Files and Folders —->点击+号， 输入想要隐藏的内容，回车

2.2.1 创建module

先创建父工程spring-demo，然后再创建module，命名spring-ioc1

<dependencies>
   <!-- 添加commons-logging依赖 -->
   <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.3</version>
   </dependency>
   <!-- 添加junit依赖 -->
   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
   </dependency>
   <!-- 添加spring的依赖 -->
   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.10.RELEASE</version>
   </dependency>
</dependencies>

导入后保存pom文件，项目如图所示：

spring-core：Spring的核心工具包 

 这个jar 文件包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。
外部依赖Commons-Logging， Log4J。 

spring-beans：Spring IOC的基础实现，包含访问配置文件、创建和管理bean等。 

 这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 及spring-beans.jar 文件就可以了。
外部依赖spring-core，cglib-nodep.jar。 

spring-context：在基础IOC功能上提供扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。 

这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。

外部依赖spring-core.jar，spring-beans.jar，spring-aop.jar，commons-collections.jar，aopalliance.jar。

 spring-expression：Spring表达式语言 

spring-aop：Spring的面向切面编程，提供AOP（面向切面编程）的实现 

这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。

外部依赖spring-core.jar，spring-beans.jar，cglib-nodep.jar，aopalliance.jar

附：aopalliance.jar：这个包是AOP联盟的API包，里面包含了针对面向切面的接口。通常Spring等其它具备动态织入功能的框架依赖此包。

cglib-nodep.jar：这个包是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。 当然这些实际的功能是asm所提供的，asm又是什么？Java字节码操控框架。cglib就是封装了asm，简化了asm的操作，实现了在运行期动态生成新的class。 实际上CGlib为spring aop提供了底层的一种实现;为hibernate使用cglib动态生成VO/PO (接口层对象)。

2.2.2 编写实体类

package com.sldl.pojo;

public class User {
    private String username;

    public User() {
    }

    public User(String username) {
        this.username = username;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

2.2.3 编写核心配置文件

在src/main/resources目录下 ,创建Spring的核心配置文件， 这里我们命名为beans.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">
</beans>

2.2.4 配置Bean

在 beans.xml 文件中添加如下配置：将User类作为Bean装配到Spring IoC容器中

<?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的配置文件里，注册User类的bean配置，
    此时User类的对象就是Spring容器帮助我们创建对象，默认调用无参构造器-->
    <bean id="u1" class="com.sldl.pojo.User"></bean>
</beans>

2.2.5 测试

package com.sldl.test;

import com.sldl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCTest {
    @Test
    public void test1(){
        //先获取SpringIOC的容器，因为核心配置文件在resources里，即根目录下，因此直接写文件名即可
        ApplicationContext ctx =
                new ClassPathXmlApplicationContext("beans.xml");

        //使用容器的getBean方法，从容器中获取User类型的对象
        User user = (User)ctx.getBean("u1");

        //因为SpringIOC容器使用无参构造器创建的对象，因此属性值为null
        System.out.println(user);
    }
}

运行结果：

2.2.6 Spring小结

 

1）在程序运行后，Spring会到配置文件中读取 Bean 配置信息，根据配置信息生产 Spring IoC容器对象

2）Spring IoC 容器根据读取到的Bean配置信息，到硬盘上加载相应的 Class 字节码文件，根据反射创建 Bean 实例。

3）Spring会将创建的Bean存储到 Spring 容器中，也就是所谓的 Bean Pool（Bean池，底层是一个Map）中

4） 根据 Spring 提供的 getBean 方法获取Bean实例并应用到我们的应用程序中。

思考：

User 对象是谁创建的 ? 【User对象是由Spring创建的】

User 对象的属性是怎么设置的 ? 【User 对象的属性是由Spring容器设置的】

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象

练习：定义一个cn.huac.pojo.UserInfo类，并将UserInfo作为 Bean 装配到 Spring IoC容器中，在程序中通过 getBean 方法获取 UserInfo 实例，并输出到控制台。

2.2.7 扩展1

下面列出了BeanFactory接口的几个常用方法，可以在程序中试一试。

/* 根据bean的名称，返回指定bean的一个实例（如果有） */
Object getBean(String name) throws BeansException;

/* 根据Bean的类型（也可以是父类或父接口，可以创建一个Person接口，让User实现），返回唯一匹配给定对象类型的bean实例（如果有） */
<T> T getBean(Class<T> requiredType) throws BeansException;

/* 检索这个Bean工厂是否包含一个给定名称的bean实例  */
boolean containsBean(String name);

/* 获取Bean的类型  */
Class<?> getType(String name) throws NoSuchBeanDefinitionException;

/* 根据Bean的名称，检索当前Bean是不是单例，如果是则返回true */
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

/* 根据Bean的名称，检索当前Bean是不是多例，如果是则返回true */
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

package cn.huac.test;

import cn.huac.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCTests {
    @Test
    public void testIOC(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) applicationContext.getBean("user");
        System.out.println(user);
        User user2 = applicationContext.getBean(User.class);
        System.out.println(user2);
        boolean b1 = applicationContext.containsBean("user");
        boolean b2 = applicationContext.containsBean("userInfo");
        System.out.println(b1 + ", " + b2);
        Class cls = applicationContext.getType("user");
        System.out.println(cls);
        boolean singleton = applicationContext.isSingleton("user");
        boolean prototype = applicationContext.isPrototype("user");
        System.out.println(singleton + ", " + prototype);
    }
}

2.2.8 扩展2

<?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">
   <import resource="beans.xml"></import>
   <import resource="beans2.xml"></import>
   <import resource="beans3.xml"></import>
</beans>

每个<bean>元素配置一个由Spring IoC容器所管理的应用程序对象。在Spring框架的术语中，一个<bean>元素代表一个Bean。id属性指定bean的唯一名称，class属性指定bean的完全限定类名。

import导入 这个import，一般用于团队开发；

可以将多个配置文件，导入合并为一个；

applicationContext.xml

项目多人开发，多个人复制不同的类开发，不同的类需要注册不同的bean中，我们就可以利用import将所有人的beans.xml合并成一个总的！