了解Spring框架

---

一、Spring框架概述

1. Spring是轻量级的开源的JavaEE框架。
2. Spring可以解决企业应用开发的复杂性。
3. Spring有两个核心部分:IoC和Aop。
   (1)IoC:控制反转，把创建对象过程交给Spring进行管理。
   (2)Aop:面向切面，不修改源代码进行功能增强。
4. Spring特点
   (1）方便解耦，简化开发。
   (2)Aop编程支持
   (3）方便程序测试
   (4）方便和其他框架进行整合
   (5）方便进行事务操作
   (6）降低API开发难度

二、IoC本质（Inverse of Control，控制反转）

1. IoC 是指在程序开发中，实例的创建不再由调用者管理，而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系，而不是由程序代码直接控制，因此，控制权由程序代码转移到了 Spring 容器中，控制权发生了反转，这就是 Spring 的 IoC 思想。

2. 控制反转loC(Inversion of Control)，是一种设计思想，DlI(依赖注入)是实现loC的一种方法，也有人认为DI只是loC的另一种说法。没有loC的程序中，我们使用面向对象编程，对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方。

3. 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

4. 控制反转是一种通过描述(XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器，其实现方法是依赖注入(Dependency Injection,DI)。

5. 依赖注入：就是利用set方法来进行注入的。

6. 对象由Spring来创建，管理，装配！

三、第一个简单的Spring程序

1.导入jar包依赖

步骤：

• 新建一个maven仓库
• pom.xml中写入：

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

    </dependencies>

• 环境配置完成

2.User和Administrator实体类

User.java

package com.gaolang.pojo;

public class User {
    private String name;

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

    public User() {
    }

    public String getName() {
        return name;
    }

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

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

Administrator.java

package com.gaolang.pojo;

public class Administrator {
    private User user;


    public Administrator() {
    }

    public Administrator(User user) {
        this.user = user;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    @Override
    public String toString() {
        return "Administrator{" +
                "user=" + user +
                '}';
    }
}

3.配置元数据

beans.xml写在resource文件中

<?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">


    <!--	id属性是标识单个bean定义的字符串。
            class属性定义Bean的类型，并使用完全限定的类名。
     -->
     
     <!-- 由 Spring容器创建该类的实例对象 -->
    <!--配置User对象创建-->
    <bean id="user" class="com.gaolang.pojo.User">
        <property name="name" value="高朗"/>
    </bean>

    <!--
    ref元素指的是另一个bean定义的名称。
    value元素是指具体的值，基本数据类型或String类型
    -->

    <!--配置Administrator对象创建-->
    <bean id="admin" class="com.gaolang.pojo.Administrator">
        <property name="user" ref="user"/>
    </bean>
</beans>

4.测试类

import com.gaolang.pojo.Administrator;
import com.gaolang.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    public static void main(String[] args) {
        //获取ApplicationContext：拿到Spring的容器
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        User user = (User) context.getBean("user");
        System.out.println(user.toString());

        Administrator admin = (Administrator) context.getBean("admin");
        System.out.println(admin.toString());
    }
}

运行结果：

User{name='高朗'}
Administrator{user=User{name='高朗'}}

Process finished with exit code 0

四、IoC创建对象的方式

1. 默认：使用无参构造创建对象。上面的程序采用的默认，如果我们把实体类中有有参构造没有无参构造的话，运行程序会报错，解决方式：加上无参构造或去掉有参构造（程序默认是有无参构造的），或者采用有参构造创建对象。使用set方法注入属性的值，如果没有set方法也会报错。

2. 如果我们使用有参构造：使用有参构造注入属性的值。
   （1）通过下标赋值：

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg index="0" value="7500000"/>
    <constructor-arg index="1" value="42"/>
</bean>

上面的程序：

    <!--无参构造-->
    <bean id="user" class="com.gaolang.pojo.User">
        <property name="name" value="高朗"/>
    </bean>
    
    <!--有参构造-->
    <bean id="user2" class="com.gaolang.pojo.User">
        <constructor-arg index="0" value="高朗"/>
    </bean>

（2）通过类型赋值：

<bean id="exampleBean" class="examples.ExampleBean">
    <constructor-arg type="int" value="7500000"/>
    <constructor-arg type="java.lang.String" value="42"/>
</bean>

上面的程序：

    <!--类型赋值-->
    <bean id="user3" class="com.gaolang.pojo.User">
        <constructor-arg type="java.lang.String" value="高朗"/>
    </bean>

（3）通过参数名设置：

    <bean id="user" class="com.gaolang.pojo.User">
        <constructor-arg name="name" value="高朗"/>
    </bean>

    <bean id="admin" class="com.gaolang.pojo.Administrator">
        <constructor-arg name="user" ref="user"/>
    </bean>

3. 总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！
   以上面的程序为例：

• 在Administrator类的无参构造中加入System.out.println("Administrator无参构造被调用了");
• 采用无参构造IoC创建对象
• 测试类只调用user对象

• Administrator类也被调用了。