Spring框架学习笔记（一）：Spring基本介绍(包含容器底层结构)

1 官方资料

1.1 官网

https://spring.io/

1.2 进入 Spring5

下拉 projects, 进入 Spring Framework

进入 Spring5 的 github

1.3 在maven项目中导入依赖

<dependencies>
    <!--加入spring开发的基本包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>
    <!--加入spring开发切面编程需要的包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

1.4 官方文档

在线文档 : https://docs.spring.io/spring-framework/docs/current/reference/html/

离线文档 : spring-framework-5.3.8\docs\reference\html\index.html

离 线API:spring-framework-5.3.8/docs/javadoc-api/index.html

2 Spring核心内容

上图说明：

（1）Spring 核心学习内容 IOC 、 AOP, jdbcTemplate, 声明式事务

（2）IOC: 控制反转 , 可以管理 java 对象

（3）AOP : 切面编程

（4）JDBCTemplate : 是 spring 提供一套访问数据库的技术

（5）声明式事务 : 基于 ioc/aop 实现事务管理

（6）IOC, AOP 是重点和难点

3 Spring的几个重要概念

（1）Spring 可以整合其他的框架(Spring 是管理框架的框架)

（2）Spring 有两个核心的概念: IOC 和 AOP

（3）IOC（Inversion Of Control 反转控制）

传统的开发模式[JdbcUtils / 反射]

程序------>环境（程序读取环境配置，然后自己创建对象.）

解读：程序员编写程序, 在程序中读取配置信息；创建对象, new 或者反射方式；使用对象完成任务

IOC 的开发模式 [EmpAction EmpService EmpDao Emp]

程序<-----容器（容器创建好对象，程序直接使用.）

解读：

1 、 Spring 根据配置文件 xml/ 注解创建对象，并放入到容器 (ConcurrentHashMap) 中 , 并且可以完成对象之间的依赖

2 、当需要使用某个对象实例的时候 , 就直接从容器中获取即可

3 、程序员可以更加关注如何使用对象完成相应的业务

4. DI—Dependency Injection 依赖注入，可以理解成是 IOC 的另外叫法 .

5. Spring 最大的价值，通过配置，给程序提供需要使用的

web 层 [Servlet (Action/Controller) ]/Service/Dao/[JavaBean/entity] 对象 ,

这个是核心价值所在，也是 ioc 的具体体现 , 实现解耦.

4 Spring快速入门

4.1 需求说明

通过 Spring 的方式( 配置文件) ，获取 JavaBean: Monster 的对象，并给该对象属性赋值，输出该对象信息.

4.2 实现步骤

（1）创建一个maven项目，在pom.xml文件中导入以下依赖

<dependencies>
    <!--加入spring开发的基本包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.8</version>
    </dependency>
    <!--加入spring开发切面编程需要的包-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.3.8</version>
    </dependency>
</dependencies>

（2）创建 Moster 的javabean/entity，无参构造器一定要写

public class Monster {
    private Integer monsterId;
    private String name;
    private String skill;

    //全参构造器
    public Monster(Integer monsterId, String name, String skill) {
        this.monsterId = monsterId;
        this.name = name;
        this.skill = skill;
    }


    //无参构造器一定要写，Spring反射创建对象时，需要使用
    public Monster() {
    }

    public Integer getMonsterId() {
        return monsterId;
    }

    public void setMonsterId(Integer monsterId) {
        this.monsterId = monsterId;
    }

    public String getName() {
        return name;
    }

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

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    @Override
    public String toString() {
        return "Monster{" +
                "monsterId=" + monsterId +
                ", name='" + name + '\'' +
                ", skill='" + skill + '\'' +
                '}';
    }
}

（3）新建一个容器配置文件：鼠标右键目录名 --> new --> XML Configuration --> Spring Config，然后给配置文件取个名字，这里取beans(对于Maven项目XML文件通常在 src/main/resources 目录)

点击创建 Spring facet ,然后点击确定

（4）在xml文件中配置Moster对象，在beans标签加入以下配置

注意：将class属性值修改为指定类的全路径

<!--
        1. 配置monster对象/javabean
        2. 在beans中可以配置多个bean
        3. 一个bean表示就是一个java对象
        4. class属性是用于指定类的全路径->spring底层使用反射创建
        5. id属性表示该java对象在spring容器中的id, 通过id可以获取到对象
        6. <property name="monsterId" value="100"> 用于给该对象的属性赋值
-->
<bean class="com.spring.bean.Monster" id="monster01">
    <property name="monsterId" value="100"/>
    <property name="name" value="牛魔王"/>
    <property name="skill" value="芭蕉扇"/>
</bean>

<bean class="com.spring.bean.Monster" id="monster02">
    <property name="monsterId" value="1001"/>
    <property name="name" value="牛魔王~"/>
    <property name="skill" value="芭蕉扇~"/>
</bean>

（5）新建一个测试类来获取容器中的对象

public class SpringBeanTest {

    @Test
    public void getMonster(){

        //1. 创建容器 ApplicationContext
        //2. 该容器和容器配置文件关联
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

        //3. 通过getBean获取对应的对象
        //   默认返回的是Object , 但是运行类型Monster
        //Object monster01 = ioc.getBean("monster01");
        Monster monster01 = (Monster) ioc.getBean("monster01");

        //4. 输出
        System.out.println("monster01=" + monster01 + " 运行类型=" + monster01.getClass());
        System.out.println("monster01=" + monster01 + "属性name=" + monster01.getName() +
                " monserid=" + monster01.getMonsterId());


        //5. 也可以在获取的时候，直接指定Class类型, 可以再次获取
        Monster monster011 = ioc.getBean("monster01", Monster.class);
        System.out.println("monster011=" + monster011);
        System.out.println("monster011.name=" + monster011.getName());


        //6. 查看容器注入了哪些bean对象,会输出bean的id
        System.out.println("================================");
        String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println("beanDefinitionName=" + beanDefinitionName);
        }
        System.out.println("================================");

        System.out.println("ok~~~");
    }
}

运行结果：

4.3 注意事项

（1）该代码为什么读取到beans.xml文件

ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");

该代码通过类路径加载配置文件，可通过以下方式输出类加载路径

File f = new File(this.getClass().getResource("/").getPath());
System.out.println(f);

maven项目的类加载路径是：target\classes

（2）debug 看看 spring 容器结构/机制

（3）当调用getBean(),方法获取对象时，会去beanDefinitionMap中去查找，如果发生该bean是单例的，就会返回 singletonobject 中初始化好了的对象，如果不是，就会动态的通过反射机制返回一个临时创建的对象

5 实现简单的基于XML配置的Spring

5.1 需求说明

（1）自己写一个简单的 Spring 容器, 通过读取 beans.xml，获取第 1 个 JavaBean: Monster 的

对象，并给该的对象属性赋值，放入到容器中, 输出该对象信息

（2）也就是说，不使用 Spring 原生框架，我们自己简单模拟实现

5.2 思路分析

（1）使用xml的解析技术-Dom4j
（2）读取beans.xml
（3）解析得到monster对象的id,classpath,属性
（4）使用反射，创建对象
（5）放入到ioc容器(hashmap)
（6）提供一个getBean方法

5.3 实现步骤

（1）在maven项目中添加dom4j依赖

第一种方式：如果导入低版本(1.6.1)，需要如下两个依赖

<dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
</dependency>
<dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.1</version>
</dependency>

第二种方式：如果导入高版本(2.0.0)，需要如下一个依赖

<dependency>
    <groupId>org.dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>2.0.0</version>
</dependency>

（2）实现容器类 WwjApplicationContext,java

注意：项目系统目录不能有中文，或者会找不到XML文件

package com.spring.wwjApplicationContext;

import com.spring.bean.Monster;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 1. 这个程序用于实现Spring的一个简单容器机制
 * 2. 这里实现如何将beans.xml文件进行解析，并生成对象,放入容器中
 * 3. 提供一个方法 getBean(id) 返回对应的对象
 */
public class WwjApplicationContext {

    private ConcurrentHashMap<String, Object> singletonObjects =
            new ConcurrentHashMap<>();


    //构造器
    //接收一个容器的配置文件 比如 beans.xml, 该文件默认在resources
    public WwjApplicationContext(String iocBeanXmlFile) throws Exception {

        //1. 得到类加载路径
//        String path = this.getClass().getClassLoader().getPath();
        String path = this.getClass().getResource("/").getPath();

        //2. 创建 Saxreader
        SAXReader saxReader = new SAXReader();

        //3. 得到Document对象
        Document document =
                saxReader.read(new File(path + iocBeanXmlFile));

        //4. 得到rootDocument
        Element rootElement = document.getRootElement();

        //5. 得到第一个bean-monster01
        Element bean = (Element) rootElement.elements("bean").get(0);

        //6. 获取到第一个bean-monster01的相关属性
        String id = bean.attributeValue("id");
        String classFullPath = bean.attributeValue("class");
        List<Element> property = bean.elements("property");
        //遍历
        Integer monsterId =
                Integer.parseInt(property.get(0).attributeValue("value"));

        String name = property.get(1).attributeValue("value");
        String skill = property.get(2).attributeValue("value");

        //7. 使用反射创建对象.=> 回顾反射机制
        Class<?> aClass = Class.forName(classFullPath);
        //这里o对象就是Monster对象
        Monster o = (Monster) aClass.newInstance();
        //给o对象赋值
        o.setMonsterId(monsterId);
        o.setName(name);
        o.setSkill(skill);

        //8. 将创建好的对象放入到singletonObjects
        singletonObjects.put(id, o);

    }

    public Object getBean(String id) {
        return singletonObjects.get(id);
    }
}

（3）创建main类测试

package com.spring;

import com.spring.bean.Monster;
import com.spring.wwjApplicationContext.WwjApplicationContext;

public class AppMain {
    public static void main(String[] args) throws Exception {
        WwjApplicationContext ioc = new WwjApplicationContext("beans.xml");
        Monster monster01 = (Monster)ioc.getBean("monster01");
        System.out.println("monster01 = " + monster01);
    }
}

运行结果：