Spring6 -（03）Spring 入门程序

1. Spring 框架下载（了解即可）

官网地址：https://spring.io/

Project -> Spring Framework

打开 Spring 官网后，可以看到 Spring Framework，以及通过 Spring Framework 衍生的其它框架：

点击 Github 图标

点击 Spring Framework Artifacts

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fedfJItp-1679731608258)(null)]

点击 Spring 仓库地址

Arifactory -> Arifacts -> release -> org ->SpringFramework

继续在springframework目录下找下图的spring，点开之后你会看到很多不同的版本

选择对应的版本，点击链接下载

点击spring-5.3.9-dist.zip下载spring框架

2. Spring 框架目录

将下载的zip包解压：

docs：spring框架的API帮助文档

libs：spring框架的jar文件（用spring框架就是用这些jar包）

schema：spring框架的XML配置文件相关的约束文件

3. Spring 框架jar包

打开libs目录，会看到很多jar包：

spring-core-5.3.9.jar：字节码（这个是支撑程序运行的jar包）

spring-core-5.3.9-javadoc.jar：代码中的注释

spring-core-5.3.9-sources.jar：源码

各种jar包的具体作用：

JAR文件	描述
spring-aop-5.3.9.jar	这个jar 文件包含在应用中使用Spring 的AOP 特性时所需的类
spring-aspects-5.3.9.jar	提供对AspectJ的支持，以便可以方便的将面向切面的功能集成进IDE中
spring-beans-5.3.9.jar	这个jar 文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion ofControl / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 及spring-beans.jar 文件就可以了。
spring-context-5.3.9.jar	这个jar 文件为Spring 核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。
spring-context-indexer-5.3.9.jar	虽然类路径扫描非常快，但是Spring内部存在大量的类，添加此依赖，可以通过在编译时创建候选对象的静态列表来提高大型应用程序的启动性能。
spring-context-support-5.3.9.jar	用来提供Spring上下文的一些扩展模块,例如实现邮件服务、视图解析、缓存、定时任务调度等
spring-core-5.3.9.jar	Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。
spring-expression-5.3.9.jar	Spring表达式语言。
spring-instrument-5.3.9.jar	Spring3.0对服务器的代理接口。
spring-jcl-5.3.9.jar	Spring的日志模块。JCL，全称为"Jakarta Commons Logging"，也可称为"Apache Commons Logging"。
spring-jdbc-5.3.9.jar	Spring对JDBC的支持。
spring-jms-5.3.9.jar	这个jar包提供了对JMS 1.0.2/1.1的支持类。JMS是Java消息服务。属于JavaEE规范之一。
spring-messaging-5.3.9.jar	为集成messaging api和消息协议提供支持
spring-orm-5.3.9.jar	Spring集成ORM框架的支持，比如集成hibernate，mybatis等。
spring-oxm-5.3.9.jar	为主流O/X Mapping组件提供了统一层抽象和封装，OXM是Object Xml Mapping。对象和XML之间的相互转换。
spring-r2dbc-5.3.9.jar	Reactive Relational Database Connectivity (关系型数据库的响应式连接) 的缩写。这个jar文件是Spring对r2dbc的支持。
spring-test-5.3.9.jar	对Junit等测试框架的简单封装。
spring-tx-5.3.9.jar	为JDBC、Hibernate、JDO、JPA、Beans等提供的一致的声明式和编程式事务管理支持。
spring-web-5.3.9.jar	Spring集成MVC框架的支持，比如集成Struts等。
spring-webflux-5.3.9.jar	WebFlux是 Spring5 添加的新模块，用于 web 的开发，功能和 SpringMVC 类似的，Webflux 使用当前一种比较流程响应式编程出现的框架。
spring-webmvc-5.3.9.jar	SpringMVC框架的类库
spring-websocket-5.3.9.jar	Spring集成WebSocket框架时使用

注意：

如果你只是想用Spring的IoC功能，仅需要引入：spring-context即可。将这个jar包添加到classpath当中。

如果采用maven只需要引入context的依赖即可。

<dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.2</version></dependency>
</dependencies>

4. 第一个 Spring 程序

4.1 环境准备

1.创建工程spring6

2.设置JDK版本17，编译器版本17

File -> Project Structure

3.设置IDEA的Maven：关联自己的maven

File -> Settings -> Build,Execution,Deployment -> Build Tools -> Maven

4.在空的工程spring6中创建第一个模块：spring6-001-first

4.2 添加 Spring 依赖

添加spring context的依赖，pom.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><groupId>com.julissa</groupId><artifactId>spring6-001-first</artifactId><version>1.0-SNAPSHOT</version><packaging>jar</packaging><properties><maven.compiler.source>17</maven.compiler.source><maven.compiler.target>17</maven.compiler.target><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties><dependencies><!--spring context依赖--><!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了--><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>6.0.2</version></dependency></dependencies>
</project>

注意：打包方式jar。

当加入spring context的依赖之后，会关联引入其他依赖：

spring aop：面向切面编程

spring beans：IoC核心

spring core：spring的核心工具包

spring jcl：spring的日志包

spring expression：spring表达式

4.3 添加 junit 依赖

添加junit的依赖，pom.xml配置如下

<!--junit-->
<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13.2</version><scope>test</scope>
</dependency>

4.4 定义 Bean 类

创建一个Bean类 User

package com.julissa.spring6.bean;/*** * bean 封装用户信息* @author Julissa */
public class User {
}

4.5 编写 Spring 配置文件

编写spring的配置文件：beans.xml。该文件放在类的根路径下resources目录中。（配置文件名称可随意命名，如：springs.xml）

配置文件中进行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"><!-- 配置Bean，这样Spring才可以帮助我们管理这个对象 --><bean id="userBean" class="com.julissa.spring6.bean.User"/>
</beans>

bean的id和class属性：

• id属性：代表对象的唯一标识，不可以重复，可以看做一个人的身份证号。
• class属性：用来指定要创建的java对象的类名，这个类名必须是全限定类名（带包名）。

4.6 编写测试程序

package com.julissa.spring6;import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestUser {@Testpublic void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）// 这行代码只要执行，就相当于启动Spring容器，解析Spring.xml文件，并且实例化所有的bean对象，放到Spring容器当中ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");// 根据id获取bean对象Object userBean = applicationContext.getBean("userBean");System.out.println(userBean);}
}

ApplicationContext 翻译为 应用上下文，其实就是Spring容器
ApplicationContext 其实是一个接口
ApplicationContext 有很多实现类，其中有一个ClassPathXmlApplicationContext
ClassPathXmlApplicationContext 专门从类路径下加载Spring配置文件的Spring上下文对象

4.7 运行测试程序

5. 第一个 Spring 程序详细剖析

Spring配置文件 beans.xml

<!-- 配置Bean，这样Spring才可以帮助我们管理这个对象 -->
<bean id="userBean" class="com.julissa.spring6.bean.User"/>

测试类 TestUser.java

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）// 这行代码只要执行，就相当于启动Spring容器，解析Spring.xml文件，并且实例化所有的bean对象，放到Spring容器当中ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");// 根据id获取bean对象Object userBean = applicationContext.getBean("userBean");System.out.println(userBean);
}

5.1 问题1：id重复

问题：Bean的id可以重复吗

5.1.1 验证过程

1.创建一个Bean类，Student

package com.julissa.spring6.bean;/*** Bean 封装学生信息*/
public class Student {
}

2.配置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 id="userBean" class="com.julissa.spring6.bean.User"/><bean id="userBean" class="com.julissa.spring6.bean.Student"/>
</beans>

3.运行测试程序

5.1.2 验证结论

通过测试得出：在spring的配置文件中id是不能重名。

5.2 问题2：底层创建对象原理

问题：底层是怎么创建对象的，是通过反射机制调用无参数构造方法吗？

5.2.1 验证过程

1.在User类中添加无参数构造方法

package com.julissa.spring6.bean;/**** bean 封装用户信息* @author Julissa*/
public class User {/*** 无参构造方法*/public User() {System.out.println("User的无参数构造方法执行");}
}

2.运行测试程序

通过测试得知：创建对象时确实调用了无参数构造方法。

3.如果提供一个有参数构造方法，不提供无参数构造方法会怎样呢？

package com.julissa.spring6.bean;/**** bean 封装用户信息* @author Julissa*/
public class User {/***  有参构造方法* @param name 用户姓名*/public User(String name) {System.out.println("User的有参数构造方法执行");}
}

4.运行测试程序

通过测试得知：spring是通过调用类的无参数构造方法来创建对象的，所以要想让spring给你创建对象，必须保证无参数构造方法是存在的。

5.2.2 验证结论

Srping通过反射机制，调用类的无参构造方法来实例化对象

Spring是如何创建对象的呢？原理是什么？

// dom4j解析beans.xml文件，从中获取class的全限定类名
// 通过反射机制调用无参数构造方法创建对象
Class clazz = Class.forName("com.powernode.spring6.bean.User");
Object obj = clazz.newInstance();

5.3 问题3：对象的存储

问题：把创建好的对象存储到一个什么样的数据结构当中了呢？

Spring把创建好的对象存储到一个Map中

5.4 问题4：配置文件名

问题：spring配置文件的名字必须叫做beans.xml吗？

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

通过以上的java代码可以看出，这个spring配置文件名字是我们负责提供的，显然spring配置文件的名字是随意的。

5.5 问题5：配置文件个数

问题：像这样的beans.xml文件可以有多个吗？

5.5.1 验证过程

1.再创建一个spring配置文件，起名：spring.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 id="studentBean" class="com.julissa.spring6.bean.Student"/>
</beans>

2.编写测试类

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");// 根据id获取bean对象Object studentBean = applicationContext.getBean("studentBean");System.out.println(studentBean);
}

3.运行测试程序

5.5.2 验证结论

通过测试得知，spring的配置文件可以有多个，在ClassPathXmlApplicationContext构造方法的参数上传递文件路径即可

这是为什么呢？通过源码可以看到：

5.6 问题6：管理第三方类

问题：在配置文件中配置的类必须是自定义的吗，可以使用JDK中的类吗？例如：java.util.Date

5.6.1 验证过程

1.在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 id="userBean" class="com.julissa.spring6.bean.User"/><bean id="studentBean" class="com.julissa.spring6.bean.Student"/><bean id="dateBean" class="java.util.Date"/>
</beans>

2.编写测试程序

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");// 根据id获取bean对象Object dateBean = applicationContext.getBean("dateBean");System.out.println(dateBean);
}

3.运行测试程序

5.6.2 验证结果

通过测试得知，在spring配置文件中配置的bean可以任意类，只要这个类不是抽象的，并且提供了无参数构造方法。

5.7 问题7：id不存在

问题：getBean()方法调用时，如果指定的id不存在会怎样？

5.7.1 验证过程

1.编程测试程序，指定一个不存在的id

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");// 根据id获取bean对象Object notBean = applicationContext.getBean("notBean");System.out.println(notBean);
}

2.执行测试程序

5.7.2 验证结论

通过测试得知，当id不存在的时候，会出现异常。

5.8 问题8：对象类型

问题：getBean()方法返回的类型是Object，如果访问子类的特有属性和方法时，还需要向下转型，有其它办法可以解决这个问题吗？

User user = applicationContext.getBean("userBean", User.class);

5.9 问题9：配置文件加载

问题：ClassPathXmlApplicationContext是从类路径中加载配置文件，如果没有在类路径当中，又应该如何加载配置文件呢？

5.9.1 验证过程

1.将spring.xml剪切到e盘根目录

<?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 id="studentBean" class="com.julissa.spring6.bean.Student"/>
</beans>

2.编写测试程序

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）ApplicationContext applicationContext = new FileSystemXmlApplicationContext("e:/spring.xml");// 根据id获取bean对象Object studentBean = applicationContext.getBean("studentBean");System.out.println(studentBean);
}

3.运行测试程序

5.9.2 验证结论

没有在类路径中的话，需要使用FileSystemXmlApplicationContext类进行加载配置文件。

这种方式较少用。一般都是将配置文件放到类路径当中，这样可移植性更强。

5.10 问题10：BeanFactory

ApplicationContext的超级父接口BeanFactory

@Test
public void testFirst(){// 初始化Spring容器上下文（解析beans.xml文件，创建所有的bean对象）BeanFactory beanFactory = new ClassPathXmlApplicationContext("beans.xml");// 根据id获取bean对象Object userBean = beanFactory.getBean("userBean");System.out.println(userBean);
}

BeanFactory 翻译为Bean工厂，就是能够生产bean对象的一个工厂对象

BeanFactory是Spring容器的超级接口。ApplicationContext是BeanFactory的子接口。

Spring底层的IoC容器实际上实现了：工厂模式

Spring底层的IoC是怎样实现的？XML解析+工厂模式+反射机制