Spring框架的概述和搭建

Spring是什么？

Spring是于2003年新起的一个轻量级（非侵入式）的IOC和AOP的Java开发框架，它的出现就是为了简化企业级应用开发而生的。

Spring的特点

1. 轻量级的
2. 非侵入式的
3. IOC
4. AOP
5. 一站式框架

轻量级的

Spring框架使用的jar包都比较小，一般在1M以下或者几百kb。Spring核心功能的所需的jar包一般总共都是在3M左右。Spring框架运行占用的资源少，但运行效率高。

Spring的jar包小，运行时消耗内存小，

非侵入式的

在编写一些业务代码的时候是不需要继承spring特定的类，是通过配置完成依赖注入后就可以使用，此时，Spring就没有侵入到我们业务类的代码里。

框架的代码是不会侵入到我们的业务代码中去，是分开的。

IOC

IOC即为Inversion of Control（控制反转），缩写为IOC，就是由Spring IOC容器管理对象，而非传统实现中由程序代码直接操控。

将谁的控制权 反转 给谁
以前在写代码的时候，就是哪儿需要就在当地new一个对象

控制反转就是在使用Spring框架的时候，我们就不需要自己来new这个对象，Spring框架会帮我们创建好对象，那里需要就直接注入这个对象就可以了。
这个就是把控制生成对象的权利反转给Spring框架，由Spring框架生成并管理对象。

AOP

通过 Spring 提供的 AOP 功能，方便进行面向切面（Aspect Oriented Programming）的编程，许多不容易用传统 OOP 实现的功能可以通过 AOP 轻松应付在 Spring 中，开发人员可以从 繁杂的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。

举例：
在我们之前编写代码的时候，我们最开始写了一个saveStudent（）{ }的方法。
现在我们想要给之前写好的代码里加入一个新的功能，那么我们现在就要改写之前写好的代码，将它改为saveStudent（）{ saveLog（）； }
而我们现在使用Spring框架AOP的思想的时候，就可以帮我们动态的代理调用，而不需要再修改原代码。就比如我们现在saveStudent的方法中要调用saveLog的方法，我们就直接告诉框架在执行saveStudent的方法时，再执行一个saveLog这个方法，就这样我们就不需要再在源代码中做修改了

但是像这些方法我们就必须有一个要求，就是和我们要求的业务代码本身就不是很大的关联。

一站式

一站式就是一条龙的针对服务

Spring 本身也提供了数据访问功能和 web 功能，以及可以很好的管理其他框架。

它就是一个后端管理架构的框架，集基础容器，数据访问（jdbc、事务管理），web（Servlet），AOP为一身的一站式框架

Spring的体系结构

在Spring的体系当中已经合成了20多个的，这些模块又分为以下的模块当中去。

▶核心容器（Core Container）
● Beans: 管理 Beans
● Core: Spring 核心
● Context: 配置文件
● ExpressionLanguage: SpEL 表达式
▶ 数据访问/集成（Data Access/Integration）层
● JDBC, ORM, OXM, JMS, Transaction
▶ Web层
● Web, Servlet, Portlet, Struts
▶ AOP（Aspect Oriented Programming）面向切面 模块
▶ 植入（Instrumentation）模块
▶ 消息传输（Messaging）
▶ 测试（Test）模块

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

Spring Hello Word的搭建

在Maven中导入Spring的核心基础jar包

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

我这采用了5.2.2的版本，在导入这个jar包的时候，就会将Core Container（核心容器）中的四个对应jar包导入进来
在spring的context的jar包中是依赖了四个jar包

创建一个类

创建一个类，用来测试展示说明问题

package com.demo.spring.model;

public class User {

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

编写Spring的配置文件

Spring配置由容器必须管理的至少一个或多个Bean定义组成的。是基于xml的配置元数据将这些bean配置为顶级< beans/ >元素中的< bean/ >元素

<?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就会对其进行管理（生成对象，存储）
        由Spring框架生成的这个对象就称为一个bean(特值Spring框架创建的对象，它会添加额外的功能)
    -->

    <!--
    id:就是起个名字
    class:全类名地址
    就是通过id这个键，获得class的这个对象
    -->
    <bean id="user" class="com.demo.spring.model.User">

    </bean>
</beans>

测试Spring

package com.demo.spring.test;

import com.demo.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {

        //ApplicationContext是Spring的一个底层定义的接口，定义了一些接口
        //这个接口最终都会继承与BeanFactory
        //ClassPathXmlApplicationContext()是Spring中的一个具体落地实现的类,它就会创建并管理类
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        //现在是测试代码，所以就要启动ClassPathXmlApplicationContext，
        // 如果是web程序的话，就不用书写的，直接就可以启动的

        //通过applicationContext拿到配置文件中的bean
        Object user = applicationContext.getBean("user");
        //它的返回值是一个Object的类型，因为它并不知道这个的结果，也没有任何说明，所以他的返回结果是Object
        User user1 = (User) applicationContext.getBean("user");
        //用使用这个User接受的话，就要强制向下转型来使用的
        User user2 = applicationContext.getBean("user", User.class);
        //这里通过反射的方式也可以直接转换为所对应的接受属性

        System.out.println(user);
        System.out.println(user1);
        System.out.println(user2);

        //Spring的思想：IOC 就是把生成对象的控制权反转给Spring的框架
        //在程序中需要对象的时候，直接从Spring容器中直接获取即可(也就是依赖输入)
    }
}

所拿到的对象都是同一个的

这就已经算成功的搭建了一个在Spring框架下的Hello Word模板

Spring的IOC

IOC就是控制反转
读作“反转控制”（Inverse of Control）更好的理解，它不是什么技术，它只是一种设计的思想，就是将原本的在程序中手动创建对象的控制权，交又Spring的这个框架来具体实现。

IOC容器是具有依赖注入功能的容器，负责对象的实例化，对象的初始化，对象和对象之间依赖关系配置，对象的销毁，对外提供对象的查找等操作，棋对象的整个生命周期都是又容器所控制的。

我们需要的使用的对象都是又IOC容器进行管理的，不在需要我们手动的通过new的方式创建所需要的对象，而是由IOC容器直接帮我们组装好，当我们在什么地方需要的话直接就从IOC容器中直接获取就可以了。

正控：就是在要使用某个对象时，就需要我们自己的去负责所要的对象创建

反控：就是在要使用某个对象的时候。只需要从Spring的容器中获取拿到所需要使用的对象，并不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring这个框架。

下一篇：>>> Spring Bean的管理（IOC 依赖注入）