本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：SSM整合是指Spring、Struts和MyBatis三大Java框架的联合使用，是构建企业级Web应用的主流架构之一。该压缩包“ssm整合jar包（jdk1.8和spring4）.rar”专为使用JDK 1.8和Spring 4版本的开发者提供所需的依赖库。资源涵盖Spring MVC、Struts2、MyBatis等核心jar包，支持配置Spring上下文、MVC控制器、MyBatis持久层和数据源连接，适用于Maven或非Maven项目依赖管理，帮助开发者快速搭建SSM架构并部署运行。
ssm整合jar包（jdk1.8和spring4）.rar_jdk1.8 jar包_jdk1.8 spring jar_spri

1. Spring框架简介与核心配置

Spring作为Java企业级开发的主流框架，其核心IoC容器和AOP机制为构建松耦合、易维护的系统提供了强大支持。本章将介绍Spring的基本架构、Bean的生命周期管理以及基于XML和注解的配置方式，为后续整合其他框架打下理论基础。

1.1 Spring框架概述

Spring 是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架，广泛用于构建企业级Java应用。它通过解耦业务逻辑与系统服务，提高了代码的可测试性和可维护性。

1.1.1 Spring的核心模块结构

Spring框架由多个模块组成，主要包括：

模块名称 功能说明
Core Container (spring-core, spring-beans, spring-context) 提供IoC容器和Bean管理的核心功能
AOP (spring-aop) 提供面向切面编程支持
Data Access/Integration (spring-jdbc, spring-orm, spring-tx) 提供数据库访问和事务管理功能
Web (spring-web, spring-webmvc) 支持Web应用开发，包括MVC框架

1.1.2 IoC容器的基本原理

Spring的IoC容器负责对象的创建、装配和管理。通过配置文件或注解定义对象之间的依赖关系，容器在运行时自动注入依赖。

例如，使用XML配置方式定义一个Bean：

<bean id="userService" class="com.example.service.UserServiceImpl">
    <property name="userRepository" ref="userRepository"/>
</bean>

<bean id="userRepository" class="com.example.repository.UserRepositoryImpl"/>

上述配置中， userService 依赖于 userRepository ，IoC容器会自动完成依赖注入。

1.1.3 使用注解进行配置

从Spring 2.5开始，支持使用注解简化配置，如：

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
}

@Repository
public class UserRepositoryImpl implements UserRepository {
}

通过 @Service 、 @Repository 、 @Component 等注解，Spring可以自动扫描并注册Bean，减少XML配置的工作量。

小结 ：Spring框架通过IoC实现对象管理，通过AOP实现横切关注点的模块化。掌握其核心配置方式是构建SSM（Spring + Spring MVC + MyBatis）项目的基础。

2. Spring MVC Web层架构实现

Spring MVC 是 Spring 框架中用于构建 Web 应用的核心模块，基于经典的 MVC（Model-View-Controller）设计模式。它通过清晰的职责划分和强大的扩展能力，使得 Web 层开发更加结构化、模块化和可维护。本章将从 MVC 架构的基本原理入手，深入分析 Spring MVC 的核心组件和请求处理流程，并逐步讲解控制器、视图解析、数据绑定、验证机制以及 RESTful 接口开发等关键内容。

2.1 Spring MVC框架概述

2.1.1 MVC设计模式的基本原理

MVC（Model-View-Controller）是一种广泛应用于用户界面开发的设计模式，其核心理念是将数据模型（Model）、视图（View）和控制逻辑（Controller）进行解耦，使得各组件之间职责清晰、便于维护。

组件 职责描述
Model 负责数据的封装与业务逻辑的处理
View 负责数据的展示与用户交互
Controller 负责接收请求、调用 Model 并返回 View

MVC 的典型流程如下图所示：

graph TD
    A[用户请求] --> B(Controller)
    B --> C[调用 Model 处理数据]
    C --> D{返回结果}
    D -->|成功| E[渲染 View]
    D -->|失败| F[返回错误视图]
    E --> G[响应用户]
    F --> G

这种分层结构不仅提高了代码的可读性和可维护性，还增强了组件之间的复用性。

2.1.2 Spring MVC的核心组件与请求处理流程

Spring MVC 在 MVC 模式的基础上进行了封装和扩展，提供了丰富的组件支持 Web 层开发。其核心组件包括：

  • DispatcherServlet ：前端控制器，负责统一接收请求并协调其他组件。
  • HandlerMapping ：处理器映射器，负责根据请求 URL 找到对应的 Controller。
  • Controller ：处理请求的核心组件，返回 Model 和 View。
  • ViewResolver ：视图解析器，负责将逻辑视图名解析为实际视图对象。
  • ModelAndView ：封装模型数据和视图信息的对象。
  • HandlerAdapter ：适配器，用于调用 Controller 方法。
  • View ：视图接口，负责渲染数据并返回响应。

整个请求处理流程如下图所示：

sequenceDiagram
    participant Client
    participant DispatcherServlet
    participant HandlerMapping
    participant Controller
    participant ViewResolver
    participant View

    Client->>DispatcherServlet: 发送 HTTP 请求
    DispatcherServlet->>HandlerMapping: 查找处理器
    HandlerMapping-->>DispatcherServlet: 返回 Controller
    DispatcherServlet->>Controller: 调用 Controller
    Controller-->>DispatcherServlet: 返回 ModelAndView
    DispatcherServlet->>ViewResolver: 解析视图名
    ViewResolver-->>DispatcherServlet: 返回 View
    DispatcherServlet->>View: 渲染视图
    View-->>Client: 返回 HTML 响应

Spring MVC 通过这种组件化的结构，实现了高度可配置和可扩展的 Web 请求处理机制。

2.2 控制器与视图解析配置

2.2.1 @Controller与@RequestMapping注解的使用

在 Spring MVC 中，控制器是处理 HTTP 请求的核心组件。通常使用 @Controller 注解标记一个类为控制器类，并使用 @RequestMapping 注解定义请求的映射路径。

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/list")
    public String listUsers(Model model) {
        List<User> users = userService.findAll();
        model.addAttribute("users", users);
        return "userList";
    }
}

代码逐行解读：

  • @Controller ：将该类标记为 Spring MVC 的控制器类，Spring 会自动扫描并注册该类为 Bean。
  • @RequestMapping("/user") ：定义该控制器处理所有以 /user 开头的请求路径。
  • @RequestMapping("/list") ：定义该方法处理 /user/list 的 GET 请求。
  • Model model ：用于将数据传递给视图层。
  • return "userList" ：返回逻辑视图名称，由视图解析器解析为具体的视图文件（如 /WEB-INF/views/userList.jsp ）。

参数说明：

  • @RequestMapping 支持 method 属性指定请求方法（如 RequestMethod.GET 、 RequestMethod.POST ）。
  • 可以使用 @PathVariable 获取路径变量，如 /user/{id} 。
  • 支持 @RequestParam 获取查询参数，如 ?name=Tom 。

2.2.2 视图解析器配置与页面跳转机制

视图解析器（ ViewResolver ）负责将逻辑视图名称转换为实际的视图资源。常见的实现类包括 InternalResourceViewResolver （用于 JSP）和 ThymeleafViewResolver （用于 Thymeleaf 模板）。

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

配置说明：

  • prefix ：指定视图文件的前缀路径。
  • suffix ：指定视图文件的后缀格式。

例如，当控制器返回 "userList" 时，视图解析器会将其转换为 /WEB-INF/views/userList.jsp 。

2.3 数据绑定与验证机制

2.3.1 表单数据的自动绑定过程

Spring MVC 提供了强大的数据绑定功能，可以将 HTTP 请求中的参数自动绑定到 Java 对象中。

public class UserForm {
    private String username;
    private String email;
    // Getter and Setter
}

@RequestMapping("/save")
public String saveUser(@ModelAttribute("user") UserForm userForm) {
    userService.save(userForm);
    return "redirect:/user/list";
}

代码说明：

  • @ModelAttribute("user") ：将请求参数绑定到 UserForm 对象中。
  • redirect:/user/list ：重定向到 /user/list ，防止重复提交。

绑定流程如下： 

graph TD
    A[HTTP 请求参数] --> B[Spring MVC 框架]
    B --> C[调用 PropertyEditor 或 Converter]
    C --> D[自动转换为 Java 对象]
    D --> E[注入到 Controller 方法参数中]

2.3.2 使用Hibernate Validator进行数据校验

为了确保数据的合法性，Spring MVC 支持使用 Hibernate Validator 进行数据校验。

public class UserForm {
    @NotBlank(message = "用户名不能为空")
    private String username;

    @Email(message = "邮箱格式不正确")
    private String email;
    // Getter and Setter
}

@RequestMapping("/save")
public String saveUser(@Valid @ModelAttribute("user") UserForm userForm, BindingResult result) {
    if (result.hasErrors()) {
        return "userForm";
    }
    userService.save(userForm);
    return "redirect:/user/list";
}

代码说明：

  • @NotBlank ：校验字段不能为空。
  • @Email ：校验字段是否为合法邮箱格式。
  • BindingResult ：用于获取校验错误信息。

在视图中可通过 <form:errors> 标签显示错误信息：

<form:input path="username"/>
<form:errors path="username" cssClass="error"/>

2.4 RESTful风格接口开发

2.4.1 RESTful设计原则与Spring MVC的实现

RESTful 是一种基于 HTTP 协议的 Web 服务设计风格，强调资源的统一接口和无状态交互。Spring MVC 提供了对 RESTful 风格的全面支持。

@RestController
@RequestMapping("/api/users")
public class UserRestController {

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<Void> createUser(@RequestBody User user) {
        userService.save(user);
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }
}

代码说明：

  • @RestController ：结合 @Controller 和 @ResponseBody ，返回值直接写入 HTTP 响应体。
  • @GetMapping 、 @PostMapping ：限定请求方法类型。
  • @PathVariable ：获取 URL 中的路径参数。
  • @RequestBody ：将请求体反序列化为 Java 对象。

2.4.2 JSON数据的序列化与反序列化处理

Spring MVC 默认使用 Jackson 库进行 JSON 的序列化与反序列化。

@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new MappingJackson2HttpMessageConverter());
    }
}

配置说明：

  • MappingJackson2HttpMessageConverter ：用于处理 JSON 数据。
  • 可通过自定义 ObjectMapper 实现日期格式、缩进输出等定制化配置。

示例请求与响应：

请求： 

POST /api/users HTTP/1.1
Content-Type: application/json

{
    "username": "tom",
    "email": "tom@example.com"
}

响应： 

HTTP/1.1 201 Created
Content-Type: application/json

{
    "id": 1,
    "username": "tom",
    "email": "tom@example.com"
}

Spring MVC 通过这种机制，使得前后端分离开发更加高效和标准化。

3. Struts2框架集成与请求处理

Struts2 是 Java Web 开发中历史悠久且广泛应用的 MVC 框架之一，其设计目标是提供一种灵活、可扩展的请求处理机制。本章将深入探讨 Struts2 的核心架构、配置方式、请求处理流程，以及与 Spring 的集成机制，帮助开发者在实际项目中更好地应用 Struts2 框架。

3.1 Struts2框架基础与核心配置

Struts2 作为 MVC 模式的具体实现，其架构设计融合了 WebWork 和 Struts1 的优点，提供了更灵活的请求处理机制和更强大的插件体系。

3.1.1 Struts2的架构组成与请求生命周期

Struts2 的核心架构由以下几部分组成：

  • FilterDispatcher（或StrutsPrepareAndExecuteFilter） ：作为入口过滤器，负责接收 HTTP 请求并将其转发给 Action。
  • ActionMapper ：决定请求应该调用哪个 Action。
  • ActionProxy ：创建 Action 实例，并调用拦截器链。
  • 拦截器（Interceptor） ：在 Action 执行前后进行处理，如日志记录、权限校验等。
  • Result ：Action 执行完成后，根据返回值决定如何渲染视图。

请求生命周期如下：

graph TD
    A[HTTP Request] --> B[StrutsPrepareAndExecuteFilter]
    B --> C{ActionMapper}
    C --> D[ActionProxy]
    D --> E[拦截器链]
    E --> F[执行Action]
    F --> G[Result渲染视图]
    G --> H[HTTP Response]

这种结构使得 Struts2 具备高度可插拔性，开发者可以通过自定义拦截器、结果类型等来扩展其功能。

3.1.2 struts.xml配置文件的作用与结构

struts.xml 是 Struts2 的核心配置文件，用于定义 Action、Result、拦截器等组件。其基本结构如下：

<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.5//EN"
    "http://struts.apache.org/dtds/struts-2.5.dtd">
<struts>
    <constant name="struts.devMode" value="true" />
    <package name="default" extends="struts-default">
        <action name="hello" class="com.example.HelloAction">
            <result name="success">/hello.jsp</result>
        </action>
    </package>
</struts>

参数说明：

  • constant ：配置 Struts2 的全局常量，如开发模式、默认编码等。
  • package ：逻辑分组，继承 struts-default 以获得内置拦截器和结果类型。
  • action ：定义请求映射， name 对应 URL 中的 action 名称， class 指定对应的 Java 类。
  • result ：定义 Action 返回值对应的视图资源。

该配置文件通常位于 src/main/resources 目录下，是 Struts2 初始化时读取的主要配置文件。

3.2 Action与Result的定义与使用

Action 是 Struts2 中处理业务逻辑的核心组件，Result 则决定了请求处理完成后如何渲染视图。

3.2.1 Action类的编写与配置方式

一个基本的 Action 类如下：

package com.example;

import com.opensymphony.xwork2.ActionSupport;

public class HelloAction extends ActionSupport {
    private String message;

    public String execute() {
        message = "Hello from Struts2!";
        return SUCCESS;
    }

    public String getMessage() {
        return message;
    }
}

代码分析：

  • ActionSupport 是 Struts2 提供的基础类，封装了常用方法（如 getText() 、 addActionError() 等）。
  • execute() 方法是默认的入口方法，返回 SUCCESS 表示执行成功。
  • message 属性将通过 JSP 页面进行展示。

在 struts.xml 中的配置如下：

<action name="hello" class="com.example.HelloAction">
    <result name="success">/hello.jsp</result>
</action>

3.2.2 Result类型与页面跳转机制

Struts2 提供多种 Result 类型用于实现不同的页面跳转策略：

Result类型 描述
dispatcher 默认类型，使用 RequestDispatcher 转发请求（服务器端跳转）
redirect 重定向到指定 URL（客户端跳转）
chain 调用另一个 Action（Action 链）
freemarker 使用 FreeMarker 模板渲染视图
json 返回 JSON 格式数据

例如，使用 redirect 实现客户端跳转：

<action name="login" class="com.example.LoginAction">
    <result name="success" type="redirect">/profile.jsp</result>
</action>

3.3 Struts2与Spring的整合机制

在实际项目中，通常会使用 Spring 来管理对象生命周期，Struts2 可以与 Spring 整合，实现 Action 的依赖注入。

3.3.1 Struts2中集成Spring容器的原理

Struts2 通过插件 struts2-spring-plugin 实现与 Spring 的整合。该插件利用 SpringObjectFactory 替换了默认的 StrutsObjectFactory ，使得 Action、拦截器等组件可以从 Spring 容器中获取。

整合后的组件创建流程如下：

graph TD
    A[Struts2请求] --> B[SpringObjectFactory]
    B --> C{是否配置为Spring Bean?}
    C -->|是| D[从Spring容器获取实例]
    C -->|否| E[默认创建方式]

3.3.2 使用Spring管理Struts2的Action实例

要在 Spring 中管理 Struts2 的 Action 实例，需进行以下配置：

  1. 引入依赖： 
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-spring-plugin</artifactId>
    <version>2.5.30</version>
</dependency>
  1. Spring 配置文件中定义 Action Bean： 
<bean id="helloAction" class="com.example.HelloAction" scope="prototype">
    <property name="messageService" ref="messageService"/>
</bean>
  1. struts.xml 中使用 Spring Bean 名称作为 class 属性： 
<action name="hello" class="helloAction">
    <result name="success">/hello.jsp</result>
</action>

说明：

  • scope="prototype" 表示每次请求都创建一个新的 Action 实例。
  • messageService 是通过 Spring 注入的依赖，体现了 Struts2 与 Spring 的深度集成。

3.4 拦截器与异常处理

拦截器是 Struts2 的核心扩展机制之一，可用于日志记录、权限验证、事务控制等。异常处理机制则用于统一处理 Action 中抛出的异常。

3.4.1 自定义拦截器的开发与注册

开发一个自定义拦截器需要实现 Interceptor 接口：

package com.example.interceptor;

import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.Interceptor;

public class LoggingInterceptor implements Interceptor {

    @Override
    public void init() {
        // 初始化代码
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        System.out.println("Before Action: " + invocation.getAction().getClass().getName());
        String result = invocation.invoke();
        System.out.println("After Action");
        return result;
    }

    @Override
    public void destroy() {
        // 销毁代码
    }
}

注册拦截器：

在 struts.xml 中定义拦截器并应用到 Action：

<package name="default" extends="struts-default">
    <interceptors>
        <interceptor name="logging" class="com.example.interceptor.LoggingInterceptor"/>
    </interceptors>

    <action name="hello" class="helloAction">
        <interceptor-ref name="logging"/>
        <result name="success">/hello.jsp</result>
    </action>
</package>

3.4.2 全局异常处理机制的设计与实现

Struts2 支持全局异常处理，可以通过配置 global-exception-mappings 实现统一异常响应。

<package name="default" extends="struts-default">
    <global-exception-mappings>
        <exception-mapping exception="java.lang.Exception" result="error"/>
    </global-exception-mappings>

    <action name="hello" class="helloAction">
        <result name="success">/hello.jsp</result>
        <result name="error">/error.jsp</result>
    </action>
</package>

说明：

  • 当 Action 抛出 Exception 时，系统将跳转到 /error.jsp 页面。
  • 可以为不同异常配置不同的结果页面，实现精细化异常处理。

小结：
本章系统地介绍了 Struts2 框架的基础知识、核心配置、Action 与 Result 的使用方式、与 Spring 的整合机制，以及拦截器和异常处理的实现。通过本章内容，开发者可以掌握 Struts2 的请求处理流程和扩展机制，为后续整合 Spring 与 MyBatis 构建完整的 SSM 架构打下坚实基础。

4. MyBatis持久层框架配置与SQL映射

MyBatis 是一款优秀的持久层框架，其灵活性与高性能使其成为众多 Java 项目中数据库访问层的首选。它通过简单的 XML 或注解方式将 SQL 语句与 Java 对象进行映射，避免了繁琐的 JDBC 编码，同时又保留了对 SQL 的完全控制权。本章将从 MyBatis 的基本原理入手，深入讲解其配置流程、SQL 映射机制、接口绑定方式以及与 Spring 的整合实践，帮助读者全面掌握 MyBatis 的核心开发技能。

4.1 MyBatis基本原理与配置流程

4.1.1 ORM框架的基本思想与MyBatis优势

对象关系映射（ORM）是一种将数据库表结构映射为 Java 对象的编程技术。MyBatis 不像 Hibernate 那样完全封装 SQL 操作，而是提供了一种灵活的映射机制，开发者可以直接编写 SQL，并通过 XML 或注解将其与 Java 对象绑定。

MyBatis 的核心优势：

优势 说明
灵活性 允许开发者直接编写 SQL，适合复杂查询场景
性能高 减少框架封装带来的性能损耗
易于调试 SQL 显式可见，便于排查问题
轻量级 不依赖特定接口或继承体系

4.1.2 mybatis-config.xml配置文件详解

mybatis-config.xml 是 MyBatis 的全局配置文件，用于定义数据库连接、事务管理、类型别名、插件等。以下是一个典型配置示例：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 定义别名 -->
    <typeAliases>
        <typeAlias alias="User" type="com.example.model.User"/>
    </typeAliases>

    <!-- 配置环境 -->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 映射文件位置 -->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

配置文件解析：

  • <typeAliases> ：定义 Java 类型的别名，简化 XML 中的类型引用。
  • <environments> ：配置数据库连接环境，支持多环境切换（如开发、测试、生产）。
  • <transactionManager> ：指定事务管理器类型，如 JDBC 或 MANAGED。
  • <dataSource> ：配置数据库连接池， type="POOLED" 表示使用内置连接池。
  • <mappers> ：指定映射文件的位置，MyBatis 将根据这些文件加载 SQL 映射。

执行流程简图： 

graph TD
    A[mybatis-config.xml] --> B[加载配置]
    B --> C[创建SqlSessionFactory]
    C --> D[创建SqlSession]
    D --> E[执行SQL操作]
    E --> F[映射结果集到Java对象]

4.2 映射文件与动态SQL

4.2.1 Mapper XML文件的结构与标签使用

Mapper XML 文件用于定义 SQL 语句及其与 Java 对象的映射关系。一个典型的 UserMapper.xml 文件如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <!-- 查询用户 -->
    <select id="selectUser" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    </select>

    <!-- 插入用户 -->
    <insert id="insertUser">
        INSERT INTO user(name, age) VALUES(#{name}, #{age})
    </insert>

    <!-- 更新用户 -->
    <update id="updateUser">
        UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}
    </update>

    <!-- 删除用户 -->
    <delete id="deleteUser">
        DELETE FROM user WHERE id = #{id}
    </delete>
</mapper>

标签说明：

标签 作用
<select> 执行查询操作
<insert> 执行插入操作
<update> 执行更新操作
<delete> 执行删除操作
#{} 表示参数占位符，防止 SQL 注入

参数传递方式：

  • 单个参数： #{id}
  • 多个参数： #{name}, #{age}
  • 对象参数： #{user.name}, #{user.age}

4.2.2 动态SQL语句的构建技巧

MyBatis 提供了丰富的动态 SQL 标签，如 <if> 、 <choose> 、 <when> 、 <set> 、 <foreach> ，可以灵活构建 SQL 语句。

示例：动态查询
<select id="findUsers" resultType="User">
    SELECT * FROM user
    <where>
        <if test="name != null">
            AND name LIKE CONCAT('%', #{name}, '%')
        </if>
        <if test="age != null">
            AND age >= #{age}
        </if>
    </where>
</select>

逻辑分析：

  • <where> 标签会自动处理多余的 AND 或 OR 。
  • <if> 标签根据参数是否存在决定是否包含某段 SQL。
示例：批量插入
<insert id="batchInsert">
    INSERT INTO user(name, age) VALUES
    <foreach collection="users" item="user" separator=",">
        (#{user.name}, #{user.age})
    </foreach>
</insert>

逻辑分析：

  • <foreach> 遍历集合，生成多个 VALUES 子句。
  • collection 指定传入参数类型（如 List、Map）。
  • item 表示集合中的每一个元素。
  • separator 设置每次迭代之间的分隔符。

4.3 接口绑定与注解开发

4.3.1 使用@Mapper注解绑定接口与SQL

MyBatis 支持使用注解代替 XML 文件进行 SQL 映射。以下是一个使用注解的示例：

import org.apache.ibatis.annotations.*;
import java.util.List;

@Mapper
public interface UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User selectUser(Long id);

    @Insert("INSERT INTO user(name, age) VALUES(#{name}, #{age})")
    void insertUser(User user);

    @Update("UPDATE user SET name = #{name}, age = #{age} WHERE id = #{id}")
    void updateUser(User user);

    @Delete("DELETE FROM user WHERE id = #{id}")
    void deleteUser(Long id);

    @Select("SELECT * FROM user")
    List<User> getAllUsers();
}

注解说明：

注解 作用
@Select 执行查询
@Insert 执行插入
@Update 执行更新
@Delete 执行删除
@Mapper 标记该接口为 MyBatis Mapper 接口

4.3.2 注解方式实现CRUD操作

使用注解可以简化代码结构，避免编写 XML 文件。例如，实现一个用户查询接口：

@Select("SELECT * FROM user WHERE name LIKE CONCAT('%', #{name}, '%') AND age >= #{age}")
List<User> findUsers(@Param("name") String name, @Param("age") Integer age);

参数绑定技巧：

  • 当方法参数有多个时，必须使用 @Param 注解为每个参数命名。
  • 在 SQL 中通过 #{name} 、 #{age} 引用这些参数。

优势与适用场景：

优势 说明
简洁明了 无需维护 XML 文件，适合简单 SQL
适合小型项目 快速开发，减少配置复杂度
不适合复杂 SQL 动态 SQL 构建不如 XML 灵活

4.4 MyBatis与Spring整合实践

4.4.1 配置MyBatis-Spring整合模块

在 Spring 项目中整合 MyBatis，通常使用 mybatis-spring 模块。核心配置包括数据源、 SqlSessionFactoryBean 和 MapperScannerConfigurer 。

Spring 配置文件示例： 

<!-- 数据源配置 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<!-- SqlSessionFactoryBean -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

<!-- 自动扫描Mapper接口 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

整合流程说明：

  1. 配置数据源（如 MySQL）。
  2. 创建 SqlSessionFactoryBean ，加载 MyBatis 配置。
  3. 使用 MapperScannerConfigurer 扫描接口并生成代理类。

4.4.2 使用SqlSessionTemplate与MapperScannerConfigurer

SqlSessionTemplate：

SqlSessionTemplate 是线程安全的，推荐在 DAO 层使用。

@Repository
public class UserDao {
    @Autowired
    private SqlSessionTemplate sqlSession;

    public User selectUser(Long id) {
        return sqlSession.selectOne("com.example.mapper.UserMapper.selectUser", id);
    }
}

MapperScannerConfigurer：

自动将接口扫描为 Spring Bean，无需手动注入。

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User getUserById(Long id) {
        return userMapper.selectUser(id);
    }
}

整合流程图： 

graph TD
    A[Spring Context] --> B[加载数据源]
    B --> C[创建SqlSessionFactory]
    C --> D[加载Mapper接口]
    D --> E[自动生成Mapper代理]
    E --> F[注入Service层]

通过本章的学习，读者应能够熟练掌握 MyBatis 的基本配置、SQL 映射文件编写、动态 SQL 构建以及与 Spring 的整合方式，为后续整合 SSM 框架打下坚实基础。

5. JDK 1.8新特性支持（Lambda、Stream API）

Java 8 是 Java 语言发展历程中一次重大的更新，其引入的 Lambda 表达式、Stream API、新的日期时间 API 等特性，极大地提升了开发效率和代码的可读性。在 SSM（Spring + Spring MVC + MyBatis）项目中，合理使用这些新特性可以显著优化代码结构，提高程序性能和可维护性。本章将从 JDK 1.8 新特性概述入手，深入讲解函数式编程、接口默认方法、新日期时间 API 的使用，并结合 SSM 框架实际项目场景，展示 Lambda 和 Stream API 的实际应用。

5.1 JDK 1.8新特性概述

JDK 1.8 于 2014 年发布，标志着 Java 语言迈入函数式编程时代。其核心特性包括 Lambda 表达式、Stream API、接口默认方法、Optional 类以及新的日期时间 API。这些特性不仅简化了集合操作，也使得代码更具表达力和可维护性。

5.1.1 Lambda表达式的基本语法与应用场景

Lambda 表达式是一种简洁的函数式编程语法，用于替代匿名内部类，尤其适用于需要传递行为（函数）作为参数的场合。

基本语法格式：
(parameters) -> { statements; }
示例代码：
// 使用 Lambda 表达式遍历集合
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

代码逻辑分析：

  • names.forEach(...) ：对集合中的每个元素执行操作。
  • name -> System.out.println(name) ：Lambda 表达式，接收一个 name 参数，并打印它。
  • 省略了传统的匿名内部类写法，使代码更简洁。
Lambda 表达式的应用场景：
  • 集合遍历与处理 ：如 forEach 、 map 、 filter 等。
  • 线程任务定义 ：替代 new Runnable() 。
  • 事件监听器 ：如按钮点击事件处理。
  • 排序逻辑定义 ：如 Collections.sort(list, (o1, o2) -> o1.compareTo(o2)) 。

5.1.2 Stream API的链式调用与数据处理能力

Stream API 是 Java 8 中用于处理集合的函数式操作工具，支持过滤、映射、排序、归约等操作，其最大的特点是 链式调用 和 惰性求值 。

示例代码：
List<String> filteredNames = names.stream()
    .filter(name -> name.length() > 3)
    .map(String::toUpperCase)
    .sorted()
    .collect(Collectors.toList());

代码逻辑分析：

  • names.stream() ：将集合转换为流。
  • .filter(name -> name.length() > 3) ：保留长度大于3的字符串。
  • .map(String::toUpperCase) ：将每个字符串转为大写。
  • .sorted() ：按自然顺序排序。
  • .collect(Collectors.toList()) ：将结果收集为新的 List。
Stream API 常用方法：
方法名 作用说明
filter() 过滤符合条件的元素
map() 对每个元素进行转换
sorted() 排序
limit() 限制返回元素数量
skip() 跳过前n个元素
distinct() 去重
collect() 将流转换为其他形式（如 List）
forEach() 遍历每个元素并执行操作
reduce() 对元素进行归约操作
Stream API 的优势：
  • 声明式编程 ：代码更简洁，逻辑更清晰。
  • 并发处理 ：通过 parallelStream() 可轻松实现多线程处理。
  • 链式调用 ：代码结构更易读，流程清晰。

5.2 函数式编程与接口默认方法

Java 8 引入了函数式接口（Functional Interface）的概念，并通过 Lambda 表达式实现函数式编程范式，同时引入了接口默认方法（Default Methods）来增强接口的兼容性和扩展能力。

5.2.1 FunctionalInterface与方法引用

FunctionalInterface 示例：
@FunctionalInterface
public interface MathOperation {
    int operate(int a, int b);
}

使用 Lambda 表达式实现：

MathOperation add = (a, b) -> a + b;
System.out.println(add.operate(5, 3));  // 输出 8
方法引用（Method Reference）

方法引用是 Lambda 表达式的一种简化方式，语法为 类名::方法名 。

List<String> list = Arrays.asList("apple", "banana", "cherry");
list.forEach(System.out::println);  // 等价于 name -> System.out.println(name)

方法引用的四种形式：

类型 示例 说明
静态方法引用 ClassName::staticMethod 调用静态方法
实例方法引用 instance::instanceMethod 调用对象的方法
类的实例方法引用 ClassName::instanceMethod 调用某个类的实例方法
构造函数引用 ClassName::new 创建对象实例

5.2.2 默认方法与接口的多继承实现

Java 8 允许接口中定义默认方法（default method），解决接口升级带来的兼容性问题。

示例代码：
public interface Vehicle {
    default void start() {
        System.out.println("Vehicle started");
    }
}

public interface FourWheeler {
    default void start() {
        System.out.println("FourWheeler started");
    }
}

public class Car implements Vehicle, FourWheeler {
    @Override
    public void start() {
        Vehicle.super.start();  // 明确调用 Vehicle 的 start 方法
    }
}

代码逻辑分析：

  • default void start() ：接口中定义的默认方法。
  • Car 同时实现了两个接口，且两个接口都有 start() 方法，此时必须重写该方法以避免冲突。
  • Vehicle.super.start() ：调用指定接口的默认方法。
接口默认方法的优势：
  • 接口升级 ：无需修改所有实现类即可新增功能。
  • 多重继承 ：一个类可以实现多个接口并继承多个默认方法。
  • 行为共享 ：提供通用实现，减少重复代码。

5.3 新日期时间API的使用

Java 8 引入了全新的日期时间 API（ java.time 包），替代了 Date 和 Calendar ，解决了旧 API 中线程不安全、设计不合理等问题。

5.3.1 LocalDateTime与ZonedDateTime的时区处理

LocalDateTime 示例：
LocalDateTime now = LocalDateTime.now();
System.out.println("当前时间：" + now);
ZonedDateTime 示例：
ZoneId zone = ZoneId.of("Asia/Shanghai");
ZonedDateTime zonedNow = ZonedDateTime.now(zone);
System.out.println("带时区时间：" + zonedNow);

代码逻辑分析：

  • LocalDateTime.now() ：获取当前系统时间（不含时区信息）。
  • ZonedDateTime.now(zone) ：获取指定时区的时间。
  • ZoneId.of("Asia/Shanghai") ：通过时区 ID 获取时区对象。
时间格式化与解析：
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = now.format(formatter);
System.out.println("格式化后：" + formatted);

LocalDateTime parsed = LocalDateTime.parse("2024-04-05 12:30:45", formatter);
System.out.println("解析后：" + parsed);

5.3.2 Duration与Period的时间差计算

Duration 示例（时间差，精确到秒）：
LocalTime start = LocalTime.of(10, 0);
LocalTime end = LocalTime.of(12, 30);
Duration duration = Duration.between(start, end);
System.out.println("时间差（分钟）：" + duration.toMinutes());
Period 示例（日期差，精确到天）：
LocalDate startDate = LocalDate.of(2024, 1, 1);
LocalDate endDate = LocalDate.of(2024, 4, 5);
Period period = Period.between(startDate, endDate);
System.out.println("日期差（月）：" + period.getMonths());
日期时间 API 优势总结：
特性 优势说明
不可变性 所有类都是不可变的，线程安全
清晰设计 分离日期、时间、时区等概念，便于理解
更好的可读性 提供丰富的格式化和解析方法
支持时区处理 支持 ZoneId 和 ZonedDateTime 等类

5.4 在SSM项目中应用JDK 1.8特性

在 SSM 项目中，合理使用 JDK 1.8 特性可以显著提升代码质量与开发效率。以下将从 Controller 层和 Service 层两个角度展示实际应用场景。

5.4.1 Lambda表达式优化Controller层逻辑

在 Spring MVC 的 Controller 层，Lambda 表达式可用于简化回调逻辑、事件处理等场景。

示例：使用 Lambda 简化请求参数校验
@PostMapping("/users")
public ResponseEntity<?> createUser(@RequestBody User user) {
    List<String> errors = new ArrayList<>();
    validate(user, errors);
    if (!errors.isEmpty()) {
        return ResponseEntity.badRequest().body(errors);
    }
    return ResponseEntity.ok(userService.save(user));
}

private void validate(User user, List<String> errors) {
    Map<String, Predicate<User>> validators = new HashMap<>();
    validators.put("name", u -> u.getName() == null || u.getName().isEmpty());
    validators.put("email", u -> u.getEmail() == null || !u.getEmail().contains("@"));

    validators.forEach((field, predicate) -> {
        if (predicate.test(user)) {
            errors.add(field + " is invalid");
        }
    });
}

代码逻辑分析：

  • validators.forEach((field, predicate) -> { ... }) ：使用 Lambda 遍历校验规则。
  • predicate.test(user) ：判断是否满足条件。
  • 如果不满足，添加错误信息到 errors 列表中。

5.4.2 Stream API在Service层数据处理中的实践

在 Service 层，Stream API 可用于处理业务数据集合，如筛选、聚合、转换等操作。

示例：使用 Stream 处理用户订单数据
public class OrderService {

    public List<Order> getHighValueOrders(List<Order> orders) {
        return orders.stream()
            .filter(order -> order.getTotalPrice() > 1000)
            .sorted(Comparator.comparing(Order::getTotalPrice).reversed())
            .limit(10)
            .collect(Collectors.toList());
    }
}

代码逻辑分析：

  • filter(...) ：筛选订单总价大于1000的订单。
  • sorted(...) ：按总价倒序排序。
  • limit(10) ：取前10个订单。
  • collect(...) ：收集为新的列表。
效果展示：
操作 说明
filter 数据过滤，提高数据质量
map 数据转换，如将订单转为 DTO 对象
reduce 聚合计算，如总金额、平均值等
parallelStream 并行处理，提高大数据量下的性能

mermaid流程图：Stream API 数据处理流程图 

graph TD
    A[原始数据] --> B{filter 过滤}
    B --> C[map 转换]
    C --> D[sorted 排序]
    D --> E[limit 限制数量]
    E --> F[collect 收集结果]

本章从 JDK 1.8 的 Lambda 表达式、Stream API、新日期时间 API 等核心特性入手，结合 SSM 框架的实际应用场景，展示了这些新特性如何优化代码结构、提升开发效率与代码可读性。下一章将继续深入 SSM 框架整合配置流程，帮助开发者构建完整的 Java Web 项目结构。

6. SSM框架整合配置流程详解

SSM框架指的是 Spring、Spring MVC 和 MyBatis 的组合，是当前 Java Web 开发中广泛使用的框架组合。它们各自承担不同的职责：Spring 负责业务逻辑的管理与注入，Spring MVC 负责 Web 层的请求处理，MyBatis 负责数据库操作的映射与执行。本章将从环境搭建、配置文件设置到整合过程逐步展开，详细解析如何在实际项目中完成 SSM 框架的整合。

6.1 整合前的环境准备

在正式整合 SSM 框架之前，需要完成基础开发环境的搭建，并对框架之间的版本兼容性进行评估，以确保后续开发工作的顺利进行。

6.1.1 JDK、Tomcat、Maven等开发环境搭建

整合 SSM 框架前，需要搭建如下环境：

  • JDK 1.8 ：支持 Lambda 表达式和 Stream API，同时兼容 Spring 4 和 MyBatis 3。
  • Tomcat 8+ ：作为 Web 容器，支持 Servlet 3.0 以上版本。
  • Maven 3.x ：用于项目依赖管理和构建，方便引入 Spring、MyBatis、Spring MVC 等框架。
Maven 项目结构简要说明：
src/
├── main/
│   ├── java/               Java 源代码
│   ├── resources/            配置文件
│   └── webapp/               Web 资源文件（如 JSP、HTML、WEB-INF）
├── pom.xml                   Maven 依赖配置文件
pom.xml 中引入关键依赖：
<dependencies>
    <!-- Spring 核心 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.30.RELEASE</version>
    </dependency>

    <!-- Spring MVC -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.3.30.RELEASE</version>
    </dependency>

    <!-- MyBatis -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.6</version>
    </dependency>

    <!-- MyBatis 与 Spring 整合包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.1</version>
    </dependency>

    <!-- 数据库驱动（以 MySQL 为例） -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.46</version>
    </dependency>

    <!-- 连接池（如使用 Druid） -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.21</version>
    </dependency>
</dependencies>

逻辑说明 ：
1. Spring 4.3.30.RELEASE 是与 JDK 1.8 兼容性较好的版本。
2. MyBatis 3.4.6 提供稳定的 ORM 映射支持。
3. mybatis-spring 是整合 Spring 和 MyBatis 的关键依赖。
4. 数据库驱动根据实际数据库选择（如 MySQL、PostgreSQL）。

6.1.2 SSM框架版本兼容性分析（Spring 4 + JDK 1.8）

框架 推荐版本 兼容性说明
Spring 4.3.x 支持 JDK 1.8，提供完整的 AOP、IoC 支持
Spring MVC 4.3.x 与 Spring 保持一致版本
MyBatis 3.4.x 支持注解与 XML 映射，兼容 Spring 4
JDK 1.8 支持 Lambda、Stream、接口默认方法等新特性
Tomcat 8.x ~ 9.x 支持 Servlet 3.1，满足 Spring MVC 需求

参数说明 ：
- Spring 4 不再支持 JDK 1.5，最低要求为 JDK 1.6。
- MyBatis 3.4.x 对 Lambda 表达式支持较好，适合与 JDK 1.8 结合使用。
- Tomcat 8 是 Spring MVC 4 的推荐容器，支持异步请求处理。

6.2 web.xml与Spring上下文配置

整合 SSM 框架的核心配置文件是 web.xml 和 Spring 的配置文件。Spring 通过 ContextLoaderListener 加载核心上下文， DispatcherServlet 处理 Web 请求。

6.2.1 ContextLoaderListener与DispatcherServlet配置

在 web.xml 中配置如下内容：

<!-- Spring 上下文监听器 -->
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- 指定 Spring 配置文件路径 -->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

<!-- Spring MVC 的 DispatcherServlet -->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<!-- 映射所有请求 -->
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

逻辑分析 ：
1. ContextLoaderListener 用于加载 Spring 核心上下文，加载 applicationContext.xml 。
2. DispatcherServlet 是 Spring MVC 的核心控制器，加载 spring-mvc.xml 。
3. <url-pattern>/</url-pattern> 表示所有请求都由 Spring MVC 处理。
4. contextConfigLocation 参数用于指定配置文件路径，避免 Spring 默认加载 /WEB-INF/[servlet-name]-servlet.xml 。

6.2.2 Spring配置文件的加载顺序与路径设置

Spring 配置文件的加载顺序至关重要，确保核心 Bean 和事务管理器先于其他组件加载。

applicationContext.xml（Spring 核心配置）：
<!-- 数据源配置 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/testdb"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

<!-- MyBatis SqlSessionFactory -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="mapperLocations" value="classpath:mapper/*.xml"/>
</bean>

<!-- Mapper 扫描 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

<!-- 事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
spring-mvc.xml（Spring MVC 配置）：
<!-- 自动扫描 Controller -->
<context:component-scan base-package="com.example.controller"/>

<!-- 启用注解驱动 -->
<mvc:annotation-driven/>

<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

逻辑说明 ：
1. applicationContext.xml 负责加载数据源、事务管理器、MyBatis 映射器等核心组件。
2. spring-mvc.xml 专注于 Web 层配置，如 Controller 扫描、视图解析器等。
3. MapperScannerConfigurer 自动扫描接口并生成代理对象，实现与 XML 的映射绑定。

6.3 Spring与MyBatis整合配置

Spring 与 MyBatis 的整合是 SSM 框架整合的核心，主要涉及数据源配置、事务管理器设置以及 Mapper 接口与 XML 文件的映射。

6.3.1 数据源与事务管理器配置

使用 Druid 数据源配置示例：
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/testdb?useSSL=false"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <property name="initialSize" value="5"/>
    <property name="minIdle" value="5"/>
    <property name="maxActive" value="20"/>
    <property name="filters" value="stat,wall"/>
</bean>

参数说明 ：
- initialSize ：初始连接数
- minIdle ：最小空闲连接数
- maxActive ：最大连接数
- filters ：监控过滤器，用于性能监控和安全控制

事务管理器配置：
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

逻辑说明 ：
1. DataSourceTransactionManager 是 Spring 提供的基于 JDBC 的事务管理器。
2. <tx:annotation-driven/> 启用事务注解，支持 @Transactional 注解控制事务。

6.3.2 Mapper接口与XML文件的映射机制

接口定义：
@Mapper
public interface UserMapper {
    User selectById(Long id);
}
XML 映射文件（mapper/UserMapper.xml）：
<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectById" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

逻辑说明 ：
1. @Mapper 注解用于标记接口为 MyBatis Mapper。
2. XML 文件中 namespace 必须与接口的全限定名一致。
3. #{id} 表示动态参数占位符，防止 SQL 注入。

Mapper 扫描配置：
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

逻辑说明 ：
1. MapperScannerConfigurer 会自动扫描 basePackage 包下的所有 Mapper 接口。
2. 为每个接口生成代理类，并注册为 Spring Bean。

6.4 Spring与Struts2整合配置

虽然当前主流是 Spring MVC，但在某些遗留项目中仍需整合 Struts2。Spring 与 Struts2 的整合主要依赖于 Spring 插件和配置。

6.4.1 Spring管理Struts2的Action与Service

1. 引入 Struts2 和 Spring 插件依赖：
<!-- Struts2 核心 -->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-core</artifactId>
    <version>2.5.26</version>
</dependency>

<!-- Struts2 与 Spring 插件 -->
<dependency>
    <groupId>org.apache.struts</groupId>
    <artifactId>struts2-spring-plugin</artifactId>
    <version>2.5.26</version>
</dependency>
2. 在 struts.xml 中配置 Spring 管理的 Action：
<package name="default" extends="struts-default">
    <action name="userAction" class="com.example.action.UserAction">
        <result name="success">/user.jsp</result>
    </action>
</package>

说明 ：
- Struts2 会自动从 Spring 容器中查找名为 com.example.action.UserAction 的 Bean。
- 不需要在 struts.xml 中显式配置 Spring Bean。

3. 在 Spring 配置中定义 Action Bean：
<bean id="userAction" class="com.example.action.UserAction" scope="prototype">
    <property name="userService" ref="userService"/>
</bean>

说明 ：
- scope="prototype" 表示每次请求都会创建新的 Action 实例。
- userService 是 Spring 管理的 Service 层 Bean。

6.4.2 整合过程中常见问题与解决方案

问题描述 原因 解决方案
Action 无法注入 Spring Bean 未正确配置 Struts2 与 Spring 插件 确保 struts.xml 中 Action 的类名与 Spring Bean ID 一致
Struts2 启动失败 缺少依赖或版本不兼容 检查 Struts2 与 Spring 版本兼容性，确保 struts2-spring-plugin 版本一致
页面跳转失败 Result 配置错误或视图解析器缺失 检查 struts.xml 中 Result 配置，确保视图路径正确

mermaid 流程图：SSM 框架整合流程 

graph TD
    A[搭建 JDK、Tomcat、Maven 环境] --> B[创建 Maven 项目]
    B --> C[配置 pom.xml 引入 Spring、MyBatis、Spring MVC]
    C --> D[配置 web.xml 加载 Spring 上下文和 DispatcherServlet]
    D --> E[配置 applicationContext.xml 和 spring-mvc.xml]
    E --> F[配置数据源与事务管理器]
    F --> G[配置 Mapper 扫描与 XML 映射]
    G --> H[测试 Controller 与 Mapper 是否整合成功]

通过本章内容，开发者可以系统地掌握 SSM 框架的整合流程，包括环境准备、核心配置文件的设置、数据源与事务管理器的集成，以及与 Struts2 的可选整合方式。下一章将深入讲解数据源与数据库连接池的配置实践。

7. 数据源与数据库连接池配置

在SSM（Spring + Spring MVC + MyBatis）项目中，高效稳定的数据库连接管理是系统性能优化的关键环节。本章将深入探讨数据源的分类、连接池技术的原理，以及主流连接池（DBCP、C3P0、Druid）的配置与使用，并进一步介绍如何监控数据库连接状态、排查性能瓶颈，以及多数据源下的事务管理策略。

7.1 数据源的基本概念与分类

数据源（DataSource）是JDBC中用于获取数据库连接的标准接口，它屏蔽了底层连接的创建与管理逻辑，为应用提供统一的数据库访问入口。

7.1.1 JDBC数据源与JNDI数据源的区别

类型 来源 使用场景 优点 缺点
JDBC数据源 应用内部直接配置 单体应用、轻量级服务 简单易用 无连接池支持，性能较低
JNDI数据源 容器（如Tomcat、WebLogic）中配置 企业级应用、集群环境 连接复用，容器管理 配置复杂，依赖容器

7.1.2 连接池技术的基本原理与作用

连接池（Connection Pool）是一种预先创建并维护数据库连接的技术，避免每次请求都新建连接带来的性能开销。

连接池工作原理流程图： 

graph TD
    A[应用请求连接] --> B{连接池是否有可用连接?}
    B -->|有| C[分配连接]
    B -->|无| D[等待或新建连接]
    C --> E[使用连接执行SQL]
    E --> F[释放连接回池]

连接池的主要作用包括：

  • 提升数据库访问性能
  • 避免频繁建立和释放连接造成的资源浪费
  • 支持连接超时、空闲回收等高级特性

7.2 常见连接池实现与配置

目前主流的Java连接池包括：DBCP、C3P0、Druid，它们各有特点，适用于不同场景。

7.2.1 DBCP、C3P0、Druid的比较与使用

特性 DBCP C3P0 Druid
性能 一般 中等 高
配置方式 XML或代码 XML配置 XML、Java Config
监控功能 无 无 支持Web监控
维护状态 不再活跃 稳定 活跃
推荐使用场景 简单项目 传统项目 高并发、需监控项目

Druid配置示例： 

<!-- applicationContext.xml -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
    <property name="initialSize" value="5"/>
    <property name="minIdle" value="5"/>
    <property name="maxActive" value="20"/>
    <property name="maxWait" value="60000"/>
    <property name="validationQuery" value="SELECT 1 FROM DUAL"/>
    <property name="testWhileIdle" value="true"/>
    <property name="testOnBorrow" value="false"/>
    <property name="testOnReturn" value="false"/>
</bean>

参数说明：
- initialSize ：连接池初始化大小
- minIdle ：最小空闲连接数
- maxActive ：最大连接数
- maxWait ：最大等待时间（毫秒）
- validationQuery ：连接验证SQL

7.2.2 Spring中配置连接池的多种方式

Spring支持多种方式配置连接池，包括：

  • XML配置文件（如上示例）
  • Java Config方式（推荐用于Spring Boot）

Java Config方式配置Druid示例： 

@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("123456");
        dataSource.setInitialSize(5);
        dataSource.setMinIdle(5);
        dataSource.setMaxActive(20);
        dataSource.setMaxWait(60000);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestWhileIdle(true);
        return dataSource;
    }
}

下一节将继续介绍连接池的监控与调优方法，并结合Druid的监控面板进行实战演示。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：SSM整合是指Spring、Struts和MyBatis三大Java框架的联合使用，是构建企业级Web应用的主流架构之一。该压缩包“ssm整合jar包（jdk1.8和spring4）.rar”专为使用JDK 1.8和Spring 4版本的开发者提供所需的依赖库。资源涵盖Spring MVC、Struts2、MyBatis等核心jar包，支持配置Spring上下文、MVC控制器、MyBatis持久层和数据源连接，适用于Maven或非Maven项目依赖管理，帮助开发者快速搭建SSM架构并部署运行。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
亚马逊云科技技术品牌专区

更多推荐

入式C语言开发最佳实践——从代码规范到性能优化

嵌套中断和中断优先级的管理需要仔细斟酌，避免优先级反转和过长的中断延迟。嵌入式系统中的内存资源极为有限，动态内存分配（malloc/free）在大多数嵌入式项目中是被禁止或严格限制的。中间层是外设驱动层，封装了特定外设的操作接口，如UART发送接收、I2C读写、SPI数据传输等。从微控制器到物联网设备，从汽车电子到航空航天，C语言凭借其高效、底层的特性，在嵌入式开发中占据着不可替代的地位。本文将系

avatar 亚马逊云科技技术品牌专区

Redis Key 设计策略及反例

反例是某社交平台将完整URL作为Key（"https://.../long/path"），导致1亿Key多占用3GB内存。例如"user:1001:profile"明确表示用户ID为1001的资料，而反例如"u_p_1001"因缩写晦涩难懂。多业务线应通过前缀隔离，如"pay:tx_log"与"msg:inbox"。对于海量数据（如物联网设备日志），需在Key中嵌入分片标识，如"device:zo

avatar 亚马逊云科技技术品牌专区

第12章 未来演进《AGI 时代的 Harness Engineering》《使用Claude Code 从0到1手把手带你实现一个企业级 harness 平台》

本章将展望 Harness Engineering 的未来演进。随着 AI 技术的快速发展，特别是通用人工智能（AGI）的兴起，软件工程领域正在经历深刻的变革。本章将探讨 AGI 时代下 Harness Engineering 的发展方向和可能性。本章学习目标：AGI（Artificial General Intelligence，通用人工智能）是指具备人类级别智能水平的 AI 系统，能够理解、学

avatar 亚马逊云科技技术品牌专区