spring 3.0 教程-杰瑞科技汇

Spring 3.0 核心教程

前言：为什么是 Spring 3.0？

Spring 3.0 是一个里程碑式的版本，它发布于 2009 年，至今仍然是许多遗留系统的基础，学习 Spring 3.0 有以下重要意义：

（图片来源网络，侵删）

理解核心思想：Spring 3.0 精炼了 Spring 的核心概念，如 IoC (控制反转) 和 AOP (面向切面编程)，是理解 Spring 框架原理的最佳起点。
维护遗留系统：许多仍在运行的企业级项目是基于 Spring 3.x 构建的，掌握它是进行维护和升级的必备技能。
平滑过渡：理解了 Spring 3.0，再学习 Spring 4.x 和 Spring 5.x 会非常容易，因为核心概念一脉相承。

重要提示：本教程基于 Java 5/6 和 Servlet 2.5/3.0 环境，对于新项目，强烈推荐使用最新版本的 Spring (如 6.x)，它支持 Java 17+、响应式编程等现代特性，本教程旨在帮助您理解 Spring 的“古典”和核心范式。

第一章：Spring 框架概述

1 什么是 Spring？

Spring 是一个开源的、轻量级的 控制反转 和 面向切面编程 的容器框架。

轻量级：Spring 本身很小，且非侵入式，你可以在项目中只使用它的一部分功能，而不会影响你的代码结构。
控制反转：这是一种设计思想，也称为 依赖注入，传统的 Java 程序中，对象由其自身来创建和管理它所依赖的对象，而在 Spring 中，对象的创建和依赖关系的管理由 Spring 容器来负责，对象只需要“被动接受”即可。
面向切面编程：它允许你将横切关注点（如日志、事务、安全）从业务逻辑中分离出来，进行模块化，这些关注点会以“切面”的形式织入到业务逻辑中。
容器：Spring 是一个容器，它负责创建、配置和管理对象（在 Spring 中称为 Bean），并管理它们之间的生命周期和依赖关系。

2 Spring 的核心模块

Spring 3.0 的核心由以下几个关键模块组成：

模块	描述
Core Container	核心容器，包括 `spring-core`, `spring-beans`, `spring-context`, `spring-expression`，这是 Spring 框架的基础，提供了 IoC 和 DI 的核心功能。
AOP	`spring-aop` 模块，提供了面向切面编程的实现。
Data Access/Integration	数据访问/集成层，包括 `spring-jdbc`, `spring-orm` (用于 Hibernate, JPA 等), `spring-oxm`, `spring-jms` 等。
Web	Web 层模块，包括 `spring-web`, `spring-webmvc` (用于构建 MVC 应用), `spring-websocket` 等。
Test	`spring-test` 模块，为 Spring 组件和 Spring MVC 应用提供了测试支持。

第二章：第一个 Spring 应用 (Hello World)

我们将创建一个简单的控制台应用来演示 Spring 的核心功能：依赖注入。

（图片来源网络，侵删）

1 环境准备

JDK 5+：Spring 3.0 需要 Java 5 或更高版本。
IDE：如 Eclipse 或 IntelliJ IDEA。
Spring 3.0 核心库：从 Maven 中央仓库下载 spring-core-3.2.18.RELEASE.jar, spring-beans-3.2.18.RELEASE.jar, spring-context-3.2.18.RELEASE.jar，或者，如果你使用 Maven，在 pom.xml 中添加依赖：
```
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>3.2.18.RELEASE</version>
    </dependency>
</dependencies>
```

2 创建 POJO (Plain Old Java Object)

创建一个简单的 Java 类，它不依赖于 Spring。

// Message.java
package com.example.hello;
public class Message {
    private String text;
    // 无参构造函数是 Spring 创建 Bean 时所必需的
    public Message() {
    }
    public String getText() {
        return text;
    }
    public void setText(String text) {
        this.text = text;
    }
}

3 创建 Service 类

这个类将依赖于 Message 对象。

// MessagePrinterService.java
package com.example.hello;
public class MessagePrinterService {
    // 1. 声明一个依赖
    private Message message;
    // 2. 提供一个 setter 方法，Spring 将通过这个方法注入依赖
    public void setMessage(Message message) {
        this.message = message;
    }
    public void printMessage() {
        System.out.println("Message from Spring: " + message.getText());
    }
}

4 配置 Spring Bean

Spring �要知道如何创建和管理你的对象，这通常通过 XML 配置文件来完成。

创建一个 applicationContext.xml 文件（放在 src/main/resources 目录下）：

<?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">
    <!-- 定义一个 id 为 "message" 的 Bean -->
    <!-- Spring 会调用 Message 的无参构造函数来创建这个对象 -->
    <bean id="message" class="com.example.hello.Message">
        <!-- 使用 <property> 标签注入属性值 -->
        <property name="text" value="Hello, Spring 3.0 World!"/>
    </bean>
    <!-- 定义一个 id 为 "messagePrinter" 的 Bean -->
    <bean id="messagePrinter" class="com.example.hello.MessagePrinterService">
        <!-- 使用依赖注入，将 id 为 "message" 的 Bean 注入到 messagePrinter 的 message 属性中 -->
        <!-- Spring 会调用 setMessage(message) 方法来完成注入 -->
        <property name="message" ref="message"/>
    </bean>
</beans>

配置说明：

<bean>：定义一个 Bean。id 是 Bean 在容器中的唯一标识，class 是 Bean 的全限定类名。
<property name="...">：用于注入属性。
- 如果注入的是基本类型或 String，使用 value 属性。
- 如果注入的是另一个 Bean，使用 ref 属性，引用另一个 Bean 的 id。

5 运行应用

创建一个主类来启动 Spring 容器并获取 Bean。

// MainApp.java
package com.example.hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
    public static void main(String[] args) {
        // 1. 创建 Spring 容器
        // ClassPathXmlApplicationContext 会从 classpath 下查找配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 2. 从容器中获取 Bean
        // getBean() 方法使用 Bean 的 id 和类型来获取实例
        MessagePrinterService printer = (MessagePrinterService) context.getBean("messagePrinter");
        // 3. 调用 Bean 的方法
        printer.printMessage();
    }
}

运行结果：

Message from Spring: Hello, Spring 3.0 World!

恭喜！你已经成功运行了你的第一个 Spring 应用，你看到了控制（对象的创建和配置）是如何从你的代码中“反转”到 Spring 配置文件中的。

第三章：核心概念深入

1 Spring 容器

Spring 容器是整个框架的核心，它负责实例化、配置和组装 Bean。

ApplicationContext：这是最常用的容器接口，它代表了 Spring IoC 容器，并负责实例化、配置和组装 Bean。
- ClassPathXmlApplicationContext：从类路径下的 XML 文件加载上下文。
- FileSystemXmlApplicationContext：从文件系统中的 XML 文件加载上下文。
- AnnotationConfigApplicationContext：从基于 Java 的配置类加载上下文（Spring 3.0 引入，但 XML 更主流）。

2 Bean 的作用域

通过 scope 属性可以定义 Bean 的生命周期和可见性。

作用域	描述
`singleton` (默认)	在整个 Spring 容器中，每个 Bean 定义只创建一个唯一的实例。
`prototype`	每次请求该 Bean 时，都会创建一个新的实例。
`request`	在一个 HTTP 请求内，一个 Bean 对象是有效的，仅适用于 Web 应用。
`session`	在一个 HTTP Session 内，一个 Bean 对象是有效的，仅适用于 Web 应用。

示例：

<bean id="user" class="com.example.User" scope="prototype"/>

3 Bean 的生命周期

Spring 容器管理 Bean 的完整生命周期：

实例化：调用 Bean 的构造函数。
设置属性：调用 setter 方法进行依赖注入。
BeanNameAware 接口：Bean 实现了 BeanNameAware，Spring 会调用 setBeanName() 方法，传入 Bean 的 ID。
BeanFactoryAware 接口：Bean 实现了 BeanFactoryAware，Spring 会调用 setBeanFactory() 方法，传入 BeanFactory 容器本身。
InitializingBean 接口：Bean 实现了 InitializingBean，Spring 会调用 afterPropertiesSet() 方法，完成自定义的初始化逻辑。
自定义初始化方法：如果配置了 init-method 属性，Spring 会调用该方法。
使用中：Bean 准备好，可以被应用程序使用了。
DisposableBean 接口：当容器关闭时，Bean 实现了 DisposableBean，Spring 会调用 destroy() 方法。
自定义销毁方法：如果配置了 destroy-method 属性，Spring 会调用该方法。

第四章：Spring MVC 入门

Web 应用是 Spring 最常见的应用场景，Spring MVC 是一个用于构建 Web 应用的强大框架。

1 环境准备

除了 Spring Core 依赖，你还需要 spring-webmvc。

Maven 依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>3.2.18.RELEASE</version>
</dependency>
<!-- Servlet API 依赖 -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<!-- JSP API 依赖 -->
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.2</version>
    <scope>provided</scope>
</dependency>

2 配置 `web.xml`

web.xml 是 Web 应用的部署描述符，用于配置 Spring MVC 的核心 DispatcherServlet。

<!-- web.xml -->
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
                             http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         version="3.0">
    <!-- 1. 配置 DispatcherServlet -->
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定 Spring 配置文件的位置，默认为 /WEB-INF/[servlet-name]-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3 配置 Spring MVC

创建 /WEB-INF/spring-mvc.xml 文件：

<!-- spring-mvc.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/mvc
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <!-- 启用注解驱动，这是 Spring MVC 的核心 -->
    <mvc:annotation-driven/>
    <!-- 扫描带有 @Controller 注解的类 -->
    <context:component-scan base-package="com.example.web.controller"/>
    <!-- 配置视图解析器，用于将逻辑视图名映射到实际的 JSP 文件 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/"/>
        <property name="suffix" value=".jsp"/>
    </bean>
</beans>

4 创建 Controller

Controller 负责处理用户的请求并返回响应。

// HelloController.java
package com.example.web.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller // 标记这是一个 Spring MVC 的控制器
public class HelloController {
    // @RequestMapping 注解将 HTTP 请求映射到处理方法上
    @RequestMapping("/hello")
    public String sayHello(Model model) {
        // 向模型中添加数据，key 为 "message"，value 为 "Hello from Spring MVC!"
        model.addAttribute("message", "Hello from Spring MVC!");
        // 返回逻辑视图名 "hello"
        // 视图解析器会将其解析为 /WEB-INF/views/hello.jsp
        return "hello";
    }
}

5 创建 JSP 视图

在 /WEB-INF/views/ 目录下创建 hello.jsp 文件。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>Hello Spring MVC</title>
</head>
<body>
    <h1>${message}</h1>
</body>
</html>

6 部署和运行

将项目打包成 WAR 文件并部署到 Tomcat 或其他 Servlet 容器中，启动服务器，在浏览器中访问： http://localhost:8080/your-project-name/hello

你应该能看到页面显示 "Hello from Spring MVC!"。

第五章：Spring 3.0 的新特性

Spring 3.0 带来了许多重要的改进，使其更加强大和易用。

表达式语言：引入了 Spring Expression Language (SpEL)，它是一种强大的表达式语言，可以在运行时查询和操作对象，在 XML 中直接调用方法：
```
<bean id="numberGuess" class="org.springframework.examples NumberGuess">
    <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>
</bean>
```
REST 支持：Spring MVC 大大增强了对 RESTful Web 服务的支持，引入了 @ResponseBody 和 @RequestBody 等注解，可以方便地将 HTTP 请求体直接绑定到 Java 对象，或将 Java 对象直接序列化为 HTTP 响应体。
类型安全的注解：引入了 @Component、@Service、@Repository 等注解，结合 <context:component-scan>，可以完全替代 XML 来定义 Bean，使配置更加简洁。
Java 5 特性支持：充分利用了 Java 5 的特性，如泛型、注解等，使 API 更加类型安全和现代化。

总结与后续学习

本教程涵盖了 Spring 3.0 的核心概念，包括 IoC/DI、Spring MVC 的基本使用，Spring 3.0 是一个非常成熟和稳定的版本，其核心思想至今仍是现代 Spring 的基石。

继续学习的方向：

数据访问：学习如何使用 Spring 的 JdbcTemplate 或 ORM 集成（如 Hibernate）来操作数据库。
事务管理：了解 Spring 声明式事务管理的强大功能。
AOP 实践：动手编写一个简单的切面，例如实现一个统一的日志记录功能。
迁移到新版本：在理解了 Spring 3.0 之后，尝试学习 Spring Boot，Spring Boot 极大地简化了 Spring 应用的创建和部署，它遵循“约定优于配置”的原则，让你能更专注于业务逻辑。

希望这份教程能帮助你顺利入门 Spring 3.0！

spring 3.0 教程

Spring 3.0 核心教程

前言：为什么是 Spring 3.0？

第一章：Spring 框架概述

1 什么是 Spring？

2 Spring 的核心模块

第二章：第一个 Spring 应用 (Hello World)

1 环境准备

2 创建 POJO (Plain Old Java Object)

3 创建 Service 类

4 配置 Spring Bean

5 运行应用

第三章：核心概念深入

1 Spring 容器

2 Bean 的作用域

3 Bean 的生命周期

第四章：Spring MVC 入门

1 环境准备

2 配置 web.xml

3 配置 Spring MVC

4 创建 Controller

5 创建 JSP 视图

6 部署和运行

第五章：Spring 3.0 的新特性

总结与后续学习

相关推荐

Java Socket编程实例具体怎么实现？

2 配置 `web.xml`