JavaEE（7）Spring概述、快速入门、IoC创建对象的方式

1. 概述

1. 简介
（1）历史：2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版
（2）理念：使现有的技术更加实用，本身就是一个大杂烩，整合现有的框架技术
（3）优点：Sping是一款轻量级的控制反转IOC与面向切面AOP的容器（框架）

1. Spring是一款开源免费的框架，容器
2. Spring是一款轻量级，非入侵式的框架
3. 控制反转IOC，面向切面AOP【重要】
4. 对事物的支持，对框架的支持

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

（2）每个Spring模块都可以单独存在，也可以与其他的一个或者多个模块联合实现，每个模块的功能如下

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

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

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

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

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

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

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

2. IoC基础

1. IoC理论推导：利用set方法。以前的所有东西都是由程序去进行创建，而现在是由我们自己控制创建对象，把主动权交给调用者，程序不用管怎么创建，怎么实现了，他只负责提供一个接口。这种思想，从本质上解决了问题，程序员不再去管理对象的创建，更多关注业务的实现，耦合性大大降低，这就是IoC的原型

2. IoC本质
（1）控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了

（2）IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从Ioc容器中取出需要的对象

2. 快速入门

1. 环境创建
（1）导入maven依赖

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

（2）编写一个Hello实体类

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("Hello," + name);
    }
}

（3）编写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">

    <!--bean就是java对象 , 由Spring创建和管理-->
    <!--id变量名  class类名-->
    <bean id="hello" class="com.nelws.domain.Hello">
        <!--property相当于给对象的属性设置一个值-->
        <property name="name" value="Spring"/>
    </bean>

</beans>

2. 测试

    @Test
    public void test01(){
        //解析beans.xml文件，生成响应的bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Hello hello = (Hello) context.getBean("hello");
        hello.show();  //Hello,Spring
    }

3. 思考
（1）Hello对象是由谁创建的？Hello对象是由Spring创建的
（2）Hello 对象的属性是怎么设置的？Hello对象的属性是由Spring容器设置的
（3）结论：这个过程就叫控制反转

• 控制：谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
• 反转：程序本身不创建对象 , 而变成被动的接收对象
• 依赖注入：就是利用set方法来进行注入的
• IOC是一种编程思想，由主动的编程变成被动的接收

3. IoC创建对象的方式

1. 通过无参构造来创建对象
（1）实体类

public class User {
    private String name;

    public User(){
        System.out.println("User无参构造执行了");
    }

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("name=" + name);
    }
}

（2）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">

    <bean class="com.newls.domain.User" id="user">
        <property name="name" value="老王"/>
    </bean>
</beans>

（3）测试

    @Test
    public void test01(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        在执行getBean的时候,user已经创建好了,通过无参构造
        User user = (User) context.getBean("user");
        user.show();  //User无参构造执行了
                      //name=老王
    }

2. 通过有参构造来创建对象
（1）实体类

public class User2 {
    private String name;

    public User2(String name) {
        this.name = name;
    }

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

    public void show(){
        System.out.println("name=" + name);

    }
}

（2）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">

    <!--方式1：根据index参数下标设置 【不推荐】-->
    <bean class="com.newls.domain.User2" id="user2">
        <constructor-arg index="0" value="EZ"/>
    </bean>

    <!--方式2：根据属性名来设置属性值  【推荐】-->
    <bean class="com.newls.domain.User2" id="user2">
        <constructor-arg name="name" value="VN"/>
    </bean>
</beans>

（3）测试

    @Test
    //方式1：根据index参数下标设置 【不推荐】
    public void test02(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
        User2 user2_1 = (User2) context.getBean("user2");
        user2_1.show();  //name=EZ
    }

    @Test
    //方式2：根据属性名来设置属性值  【推荐】
    public void test03(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
        User2 user2_2 = (User2) context.getBean("user2");
        user2_2.show();  //name=VN
    }