WEB应用程序开发--Spring框架初步搭建与介绍

Spring 是什么?

Spring 是于 2003 年兴起的一个轻量级的,IOC 和 AOP 的 Java 开发框架，它是为了简化企业级应用开发而生的。

Spring 优点

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

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

3.IOC
即 Inversion of Control，缩写为 IOC，就是由 Spring IoC 容器管理对象，而非传统实现中由程序代码直接操控.

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

5.一站式框架
Spring 本身也提供了数据访问功能和 web 功能,以及可以很好的管理其他框架

Spring 体系结构

Core Container(核心容器):
Beans: 管理 Beans
Core: Spring 核心
Context: 配置文件
ExpressionLanguage: SpEL 表达式
AOP(切面编程)
AOP 框架: Aspects
Data Access(数据库整合):
JDBC, ORM, OXM, JMS, Transaction
Web(MVC Web 开发):
Web, Servlet, Portlet, Struts
Test(Junit 整合)

如何搭建Spring框架

第一步: 导入jar包地址

依赖6个jar

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

第二步: 创建实体类

package com.qn.spring.model;

import java.util.List;

public class User {
    private String name;
    private Integer age;
    
    public void User(){
        System.out.println("无参构造方法");
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = 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;
    }

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

第三部: 创建Spring配置文件

Spring Bean 管理
基于 xml 配置方式
bean 配置需要 spring 管理的类
request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext环境
session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 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: 类的地址(全类名)
    name: 对象别名,通过name也可以获取对象
    scope: 范围,作用域
        singleton: 单例的 整个应用程序只创建一次,多次获取时同一个,在spring容器启动时就创建
        prototype: 原型的(多例) 每次获取时,会创建一个新的对象

   <bean id="user" name="user1" class="com.qn.spring.model.User" scope="singleton"></bean>
</beans>

Xml 配置方式依赖注入【DI：Dependency Injection】
指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设置给该对象。
实现 IOC 需要 DI 做支持
注入的方式：

1. set 方法注入 2.构造方法注入

第四部: 测试Spring

public class Test1 {
    /*
         ApplicationContext是spring的一个底层定义的接口,定义了一些规范
         ClassPathXmlApplicationContext() 是spring中一个具体落地实现的类(创建并管理对象)
         spring思想: IOC  把生成对象的控制权 反转给 spring框架
                          在程序中需要对象的时候,直接从spring容器中获取即可(依赖注入)
       */
    public static void main(String[] args) {
        ApplicationContext app= new ClassPathXmlApplicationContext("spring.xml");
        User user1=app.getBean("user1",User.class);
        System.out.println(user1);
    }
}

传递有参方法

<bean id="user1" class="com.qn.spring.model.User">
        <constructor-arg type="java.lang.String" name="name" value="张三"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
    </bean>

传递数列元素

<bean id="user" class="com.qn.spring.model.User">
        <property name="name" value="jim"></property>
        <property name="age" value="30"></property>
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>
    </bean>

IOC(控制反转)

读作“反转控制”(Inverse of Control)更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。
IOC 容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由 ioc 容器进行管理，不需要我们再去手动通过 new 的方式去创建对象，由 ioc 容器直接帮我们组装好，当我们需要使用的时候直接从 ioc 容器中直接获取就可以了。
正控：若要使用某个对象，需要自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了 Spring 框架

目的:降低耦合度
底层实现方式: 解析 xml/扫描注解标签 + 工厂模式 + 反射机