day01-Spring基本介绍

Spring基本介绍

1.官方资料和下载

1.1Spring5下载

直接访问 https://repo.spring.io/ui/native/release/org/springframework/spring/，选择相应版本即可

  1. 进入官网 https://spring.io/

  2. 进入Spring5

    image-20230114154612908

  3. 进入Spring5 的github

    image-20230114155025062

    也可以直接访问 https://github.com/spring-projects/spring-framework

  4. 在github仓库README.md文件往下拉，看到Access to Binaries，点击里面的链接

    image-20230114155157368

  5. 在新页面往下拉，看到如下标题，点击链接

    image-20230114155417977

  6. 点击Artifacts

    image-20230114155705939

  7. 在左边的弹窗中依次点击release-->org-->springframework-->spring

    image-20230114155939772 image-20230114160024529 image-20230114160137462

  8. 在右边的窗口点击复制url

    image-20230114160343453

  9. 在浏览器新页面访问该地址，在页面中即可选择你想要下载的版本，我这里选择下载5.3.8版本

    image-20230114160546687

  10. 点击对应版本，在新页面中选择第一个，点击即可下载

    image-20230114160711614

1.2Spring文档

  • 在线文档

    Spring Framework Documentation

  • 离线文档

    解压缩后，在\spring-framework-5.3.8\docs\reference目录下分别提供了spring介绍文档的html和pdf版本

    image-20230114162041806

  • 离线API

    在\spring-framework-5.3.8\docs\javadoc-api\index.html中可以查看Spring的API

    image-20230114162529682

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
  1. IOC [Inversion Of Control 反转控制]：

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

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

    image-20230114165338345

    传统的开发模式：（以连接到数据库为例说明）

    1. 程序员编写程序，在程序中读取数据库配置信息

    2. 创建对象（反射或者new）

      各种对象，如：Connection，PreparedStatement，ResultSet等等

    3. 使用对象完成任务

  • IOC的开发模式

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

    如，现在有几个类：EmpAction EmpService EmpDao Emp

    传统的方式是通过手动new创建对象，然后在程序中使用

    现在，可以把要使用到的对象先配置到一个文件中（xml或者注解，这里以xml配置为例），这个文件可以理解成一个“容器文件”。配置好后，当spring启动以后，它就可以直接在程序中来获取容器创建好的对象，并进行使用：

    1. Spring根据配置文件xml/注解，创建对象，并放入到容器中（类似ConcurrentHashMap），并且可以完成对象之间的依赖（对象之间的依赖关系也在xml配置或者注解中完成）

      依赖：即对象间的引用关系。例如有A，B两个类。A类中的某个属性是B类，通过容器创建的两个类的对象a，b，它们之间的依赖/引用关系，将会自动完成（当然，也需要配置）

    2. 当需要使用某个对象实例时，直接从容器中获取即可

    3. 这样程序员可以更加专注于使用对象完成相应的业务

      这样创建对象的方式就从 new ===> 注解/配置方式

    image-20230114172414071

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

  2. Spring最大的价值：通过配置，给程序员提供需要使用的 web层[Servlet(Action/Controller)]/Service/Dao/JavaBean等对象。这是Spring的核心价值所在，也是ioc的具体体现，实现解耦

    • 原先的开发模式，Servlet是tomcat创建的，然后Servlet中如果你要用什么对象实例（如Service），就new一个，在Service中你要使用什么实例（如Dao），也同样是通过new的方式来创建实例……以此类推

    • 当使用Spring以后，web层的Servlet，Service层，Dao层，Javabean[entity]中的所有对象，我们都可以在配置文件中配置（或者通过注解指定），并且指定好对象间的依赖关系，放入到容器中。当这个流程结束后，我们想在程序中使用哪个对象，都可以直接在容器中直接获取。

      image-20230114180851396

4.Spring快速入门

4.1需求说明

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

4.2完成步骤

  1. 下载spring 5 开发包

    详见1.1.1spring5下载

  2. 创建Java工程

    为了清晰spring5 的各个jar包的作用，这里使用Java工程

    image-20230114181539502 image-20230114181550153

  3. 新建一个lib文件夹，引入开发spring5的基本包

    commons-logging.jar包需要另外下载，不在spring5包中

    image-20230114181705111 image-20230114181741891

4.3代码实现

  1. 创建Javabean：Monster.java

    package com.li.bean;

/**
 * @author 李
 * @version 1.0]
 * Javabean / Entity
 */
public class Monster {
    private Integer monsterId;
    private String name;
    private String skill;

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

    public Monster(Integer monsterId, String name, String skill) {
        this.monsterId = monsterId;
        this.name = name;
        this.skill = skill;
    }

    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 + '\'' +
                '}';
    }
}

  2. 在src目录下创建配置文件：鼠标右击src目录--->new--->XML Configuration File--->Spring Config，我这里起名为beans.xml

    image-20230114183132160

  3. 创建好配置文件后，文件上方显示"Applilcation context not configured for this file"，点击右边的Create Spring facet

    image-20230114183652769

    在弹出的窗口中直接点击右下方的ok

    image-20230114183800448

    然后重新点击文件的Create Spring facet

    image-20230114183827076

    在新窗口选中beans.xml文件，然后点击ok，之后文件就不再提示了。

    image-20230114183935728

    image-20230114184039044

  4. 在beans.xml文件中配置monster对象

    <?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. 配置monster对象/javabean
        2. 在 beans标签中可以配置多个bean
        3. 一个bean就是一个Javabean对象
        4. class属性用于指定类的全路径->spring底层反射要用
        5. id属性表示该java对象在spring容器中的id（将来在程序中通过id在容器中获取相应对象，因此id是唯一的）
        6. <property name="monsterId" value="100"/> 用于给该对象的属性赋值，没有的话就是默认值
    -->
    <bean class="com.li.bean.Monster" id="monster01">
        <property name="monsterId" value="100"/>
        <property name="name" value="牛魔王"/>
        <property name="skill" value="芭蕉扇"/>
    </bean>

</beans>

  5. 创建测试类SpringBeanTest

    package com.li.test;

import com.li.bean.Monster;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

/**
 * @author 李
 * @version 1.0
 */
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.id=" + monster01.getMonsterId() +
                " monster01.name=" + monster01.getName() +
                " monster01.skill=" + monster01.getSkill());

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


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

    }
}
    image-20230114191641703

4.4注意事项和细节

类加载路径：

一个问题：为什么下面可以读取到beans.xml文件？或者说，读取的文件是src目录下的beans.xml吗？

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

我们可以在测试类中输出一下路径：

//验证类加载路径
@Test
public void classPath() {
    File file = new File(this.getClass().getResource("/").getPath());
    System.out.println("file=" + file);
}

可以看到类的加载路径并不在src目录，而是在一个out目录下：

image-20230114192634659

可以看到在out\production\spring目录下有一个beans.xml文件：

image-20230114192837205

当运行后，会将src目录下编译好的class文件放到out目录下。同时，将资源文件（这里指beans.xml）也放到out目录，读取的时候是按照out目录来读取的。

因此运行时，真正读取的配置文件不是在src目录下的beans.xml，而是在out目录下的beans.xml，只是两个文件是一样的。（类的加载路径）

回到之前的问题，为什么下面的语句，我们直接写“beans.xml”？

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

因为默认读取的是.....\out\production\spring目录，而一旦运行过后，在src目录下的beans.xml文件会被直接放在.....\out\production\spring目录下，因此可以直接读取到。

假如beans.xml文件是放到src下面的某个子文件夹，那么在语句中就要根据子文件夹的结构来进行修改。

4.5.spring容器的结构/机制

注意配置debugger，通过配置指定哪一些数据在debug的时候会展示，哪一些不展示

image-20230114203350623

1.如下，以4.3为例，打上断点，点击debug

image-20230114203724126

2.如图所示，ioc就是我们创建的容器对象，是一个”重量级对象“，因为它的内容很多。因此创建该对象比较耗费资源，所以通常情况下，我们应该只有一个这样的对象。

容器对象中有一个重要的属性：beanFactory对象，beanFactory对象有一个beanDefinitionMap属性，该属性的类型是ConcurrentHashMap集合，用于保存配置文件的对象信息（注意不是保存对象，而是保存对象信息）

在我们的配置文件中，通常会有很多的java对象，spring会把这些java对象的信息保存下来，以便将来spring重复创建对象时使用

image-20230115171620484

注意：这里的bean对象指的是任意Java对象，不仅仅是指Javabean！

4.5.1beanDefinitionMap保存Java对象的信息

3.点击展开beanDefinitionMap对象，可以看到一个table数组（ConcurrentHashMap$Node类型），初始的大小为512，Spring会将所有的Java对象的信息放到table中。

image-20230114210951927

4.在这个例子中，table数组的index=127位置以ConcurrentHashMap$Node类型保存了Monster01对象信息（Node是ConcurrentHashMap的内部类）

其中key=“monster01”就是beans.xml中配置的bean的id，value存放了很多数据，例如：monster01对象的信息（属性，属性值，类全路径，是否懒加载）

非懒加载：在使用前已经创建好对象；懒加载：使用到时再动态创建对象

image-20230115173208556

value的propertyValues就是记录beans.xml中配置的monster01对象的属性名和属性值。其中的elementData属性是一个Object类型的数组。点击展开elementData数组的一个元素，可以看到该元素记录了对象信息的name、value，即属性名称和属性值。

当spring再次创建对象时，就会到这里来获取对象的属性值

image-20230114211325108

4.5.2singletonObjects保存Java对象

5.此外beanFactory还有一个重要属性singletonObjects，singletonObjects也是一个ConcurrentHashMap集合，singleonObjects有一个table数组，类型是ConcurrentHashMap$Node.

image-20230114212935943

如下，在singleonObjects的table.index=217处存放了spring创建的monster对象

image-20230115174515056

4.5.3beanDefinitionNames记录配置文件的bean名称

6.beanFactory还有一个beanDefinitionNames属性，存放配置文件的bean-id，主要是为了方便快速查找。

image-20230115174731189

beanFactory的beanDefinitionMap用于保存Java对象的信息；

beanFactory的singletonObjects对象用于保存Java对象；

beanFactory的beanDefinitionNames用于记录配置文件的bean的名称（即Java对象的id）

4.5.4容器结构练习

如下在配置文件配置两个bean对象

image-20230115180812320

练习：查看容器注入了哪些bean对象，输出bean的id

根据5.1-5.3的分析，获取bean的id可以输出beanDefinitionNames的属性值。

package com.li.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.testng.annotations.Test;

import java.io.File;

/**
 * @author 李
 * @version 1.0
 */
public class SpringBeanTest {

    @Test
    public void getMonster() {
        //创建容器 ApplicationContext
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("beans.xml");

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

输出如下：

image-20230115180845213 image-20230115181032348 image-20230115181245010 image-20230115181431524
posted @ 2023-01-14 21:35  一刀一个小西瓜  阅读(300)  评论(3)  编辑  收藏  举报