Java Web开发实战：SSM+MySQL+JSP项目整合包

语文乌托邦

1124人浏览 · 2025-09-06 13:58:42

语文乌托邦 · 2025-09-06 13:58:42 发布

简介：SSM+MySQL+JSP是构建企业级Java Web应用的主流技术栈，包含Spring、Spring MVC、MyBatis三大框架，并结合MySQL数据库和JSP动态页面技术。本项目整合包详细展示了从环境搭建、数据库设计到框架整合、前后端交互的完整开发流程。通过实际操作配置文件、实体类、Mapper接口、Service层、Controller层及JSP页面，帮助开发者掌握Web应用的构建流程，提升企业级项目开发能力。
SSM+MySQL+JSP

1. Java Web开发技术栈介绍

Java Web开发技术栈是构建企业级应用的核心工具集，涵盖了从前端展示到后端逻辑处理、数据持久化等全链路开发环节。本章将系统性地介绍SSM（Spring、Spring MVC、MyBatis）框架的基本作用及其在Java Web开发中的重要地位。

1.1 Java Web开发技术栈概述

Java Web开发技术栈通常包括以下关键组件：

Spring ：作为核心容器，提供依赖注入（DI）和面向切面编程（AOP）能力，提升代码的可维护性与解耦性。
Spring MVC ：基于MVC架构的Web框架，负责处理HTTP请求、业务逻辑调度和视图渲染。
MyBatis ：轻量级持久层框架，提供灵活的SQL映射与数据库交互能力，支持动态SQL和结果集映射。
MySQL ：广泛使用的开源关系型数据库，适合中大型Web应用的数据存储需求。
JSP（Java Server Pages） ：用于构建动态网页的技术，支持在HTML中嵌入Java代码，实现页面动态渲染。

这些技术相互协作，构成了Java Web开发的标准栈（SSM + MySQL + JSP），广泛应用于企业级应用开发中。

2. Spring框架核心功能（DI与AOP）

Spring 框架作为 Java 企业级开发中最重要的基础框架之一，其核心功能主要包括 依赖注入（DI） 和 面向切面编程（AOP） 。这两个功能构成了 Spring 框架的两大支柱，使得开发者能够构建松耦合、高内聚、易于测试和维护的应用系统。本章将深入探讨 Spring 的 DI 和 AOP 机制，分析其内部原理、使用方式和实际应用价值。

2.1 Spring框架概述

2.1.1 Spring框架的发展与优势

Spring 框架最早由 Rod Johnson 在 2003 年提出，旨在解决传统 J2EE 开发中复杂、笨重的依赖管理问题。随着版本的迭代，Spring 从最初的轻量级 IoC 容器逐步发展为一个完整的生态系统，涵盖了 Web 开发、数据访问、安全控制、消息处理等多个领域。

Spring 的主要优势包括：

优势	描述
轻量级	Spring 内核非常轻量，不依赖任何特定接口或类
解耦	通过 DI 实现组件之间的松耦合
易于测试	支持 POJO（Plain Old Java Object），便于单元测试
模块化	提供多个模块供开发者按需引入
可扩展性	支持与第三方框架如 Hibernate、MyBatis、Struts 等集成

Spring 的设计理念强调“不要重复发明轮子”，它本身并不提供所有功能，而是通过整合其他优秀开源框架来构建完整的开发体系。

2.1.2 Spring模块结构与核心容器

Spring 的模块化架构是其灵活性和可扩展性的关键。其核心模块包括：

Spring Core ：提供 IoC 容器的基础功能。
Spring Beans ：定义 Bean 的创建、配置和管理。
Spring Context ：建立在 Core 和 Beans 模块之上，提供对国际化、资源加载、事件传播的支持。
Spring Expression Language (SpEL) ：提供强大的表达式语言支持。

Spring 核心容器（IoC 容器） 主要由两个接口构成：

BeanFactory ：基础容器，提供基本的依赖注入功能。
ApplicationContext ： BeanFactory 的子接口，提供更多企业级功能，如 AOP、国际化、事件机制等。

这些模块构成了 Spring 的核心架构，为 DI 和 AOP 的实现提供了坚实的基础。

2.2 依赖注入（DI）详解

2.2.1 Bean的定义与配置方式

在 Spring 中， Bean 是由 IoC 容器管理的对象 。Spring 容器负责创建 Bean、管理其生命周期，并自动处理其依赖关系。

Bean 的定义可以通过以下几种方式进行：

XML 配置方式
Java 注解方式
Java Config（基于 Java 的配置类）

示例：XML 方式定义 Bean

<!-- applicationContext.xml -->
<bean id="userService" class="com.example.service.UserService">
    <property name="userRepository" ref="userRepository"/>
</bean>

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

逐行解读：

<bean> 标签定义一个 Bean。
id 属性是该 Bean 的唯一标识符。
class 指定该 Bean 对应的类。
<property> 表示属性注入， name 是目标类中的属性名， ref 引用另一个 Bean。

示例：Java 注解方式定义 Bean

@Component
public class UserRepository {
    // ...
}

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

参数说明：

@Component ：通用组件注解，被 Spring 自动扫描并注册为 Bean。
@Service ：专用于服务层的组件注解。
@Autowired ：自动注入依赖的注解。

示例：Java Config 方式定义 Bean

@Configuration
public class AppConfig {
    @Bean
    public UserRepository userRepository() {
        return new UserRepository();
    }

    @Bean
    public UserService userService() {
        return new UserService(userRepository());
    }
}

逻辑分析：

@Configuration ：声明该类为配置类。
@Bean ：每个方法返回一个 Bean 实例，方法名默认为 Bean 的 ID。
这种方式更符合面向对象的设计理念，且具有更高的可读性和可维护性。

2.2.2 构造器注入与Setter注入

DI 的注入方式主要包括两种：

构造器注入
Setter 注入

构造器注入示例（XML）：

<bean id="userService" class="com.example.service.UserService">
    <constructor-arg ref="userRepository"/>
</bean>

逻辑分析：

constructor-arg 用于构造器参数注入。
适用于不可变对象或强制依赖。

构造器注入示例（Java Config）：

@Bean
public UserService userService(UserRepository repo) {
    return new UserService(repo);
}

逻辑分析：

构造器注入在 Java Config 中更简洁，Spring 会自动匹配类型注入。

Setter 注入示例（XML）：

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

逻辑分析：

更加灵活，适合可选依赖。
但不利于不可变对象的构建。

Setter 注入示例（Java 注解）：

@Setter
public class UserService {
    private UserRepository userRepository;
}

逻辑分析：

Lombok 的 @Setter 自动生成 Setter 方法。
与 @Autowired 配合使用即可完成注入。

2.2.3 自动装配与注解驱动开发

Spring 支持 自动装配（Auto-wiring） 功能，即 Spring 容器自动识别和注入所需的依赖。

自动装配方式：

byName ：根据属性名匹配 Bean 名称。
byType ：根据属性类型匹配 Bean。
constructor ：根据构造器参数类型自动装配。
autodetect ：自动检测合适的装配方式（已弃用）。

示例：自动装配（XML）：

<bean id="userService" class="com.example.service.UserService" autowire="byType"/>

示例：自动装配（Java 注解）：

@Autowired
private UserRepository userRepository;

逻辑分析：

@Autowired 默认按类型自动装配。
可配合 @Qualifier 指定具体 Bean 名称解决类型冲突。

使用 `@ComponentScan` 自动扫描 Bean：

@Configuration
@ComponentScan("com.example")
public class AppConfig {
}

逻辑分析：

@ComponentScan 指定 Spring 自动扫描的包路径。
自动识别 @Component , @Service , @Repository 等注解类并注册为 Bean。

2.3 面向切面编程（AOP）

2.3.1 AOP的基本概念与术语

AOP（Aspect Oriented Programming） 是一种编程范式，旨在将横切关注点（如日志记录、安全控制、事务管理等）与业务逻辑分离，从而提高代码的模块化和复用性。

AOP 核心术语：

术语	含义
Aspect	切面，封装横切关注点的模块
Join Point	程序执行过程中的某个点，如方法调用
Pointcut	定义哪些 Join Point 会被切面处理
Advice	切面在特定 Join Point 上执行的动作
Target Object	被代理的目标对象
Weaving	将切面应用到目标对象并生成代理对象的过程

AOP 应用场景：

日志记录
性能监控
安全控制
事务管理
缓存处理

2.3.2 切面、通知与切入点的定义

示例：定义一个日志切面（Java 注解方式）

@Aspect
@Component
public class LoggingAspect {

    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("serviceMethods()")
    public void logAfter(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

逻辑分析：

@Aspect ：声明该类为切面类。
@Component ：注册为 Spring Bean。
@Pointcut ：定义切入点表达式，表示对 com.example.service 包下所有方法进行拦截。
@Before 和 @After ：分别表示前置通知和后置通知。

通知类型说明：

注解	含义
`@Before`	方法执行前执行
`@After`	方法执行后执行（无论是否异常）
`@AfterReturning`	方法正常返回后执行
`@AfterThrowing`	方法抛出异常后执行
`@Around`	环绕通知，可控制方法执行流程

2.3.3 基于注解和XML的AOP实现

示例：基于 XML 的 AOP 配置

<aop:config>
    <aop:aspect id="loggingAspect" ref="loggingAspectBean">
        <aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/>
        <aop:before method="logBefore" pointcut-ref="serviceMethods"/>
        <aop:after method="logAfter" pointcut-ref="serviceMethods"/>
    </aop:aspect>
</aop:config>

<bean id="loggingAspectBean" class="com.example.aspect.LoggingAspect"/>

逻辑分析：

<aop:config> ：AOP 配置根节点。
<aop:aspect> ：定义一个切面， ref 指向具体的 Bean。
<aop:pointcut> ：定义切入点。
<aop:before> 和 <aop:after> ：定义前置和后置通知。

示例：使用 `@Around` 实现性能监控

@Around("serviceMethods()")
public Object measurePerformance(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed(); // 执行目标方法
    long duration = System.currentTimeMillis() - start;
    System.out.println("Method " + joinPoint.getSignature().getName() + " took " + duration + " ms");
    return result;
}

逻辑分析：

@Around 是最强大的通知类型，允许控制目标方法的执行流程。
joinPoint.proceed() 表示执行目标方法。
可以在前后插入日志、异常处理、性能统计等逻辑。

AOP 底层原理流程图（mermaid）

graph TD
    A[应用程序调用目标方法] --> B{Spring AOP拦截}
    B --> C[创建代理对象]
    C --> D[执行前置通知]
    D --> E[执行目标方法]
    E --> F[执行后置通知]
    F --> G[返回结果或抛出异常]

流程图说明：

应用程序调用目标方法。
Spring AOP 拦截调用，并创建代理对象。
执行切面定义的前置通知。
执行目标方法。
执行后置通知。
返回结果或处理异常。

通过本章内容，我们深入了解了 Spring 框架的两大核心功能： 依赖注入（DI） 和 面向切面编程（AOP） 。DI 通过解耦对象之间的依赖关系，提升了代码的可测试性和可维护性；而 AOP 则通过将横切逻辑抽离，提高了代码的模块化程度和复用性。这两种机制共同构成了 Spring 框架的核心能力，是构建企业级 Java Web 应用不可或缺的基础。

3. Spring MVC MVC架构实现

3.1 Spring MVC概述

3.1.1 MVC设计模式的基本原理

MVC（Model-View-Controller）是一种广泛应用于现代Web应用开发的架构模式，其核心理念是将应用程序分为三个主要部分：

Model（模型） ：负责数据的封装和业务逻辑的处理，通常与数据库交互。
View（视图） ：负责数据的展示，用户通过视图与系统进行交互。
Controller（控制器） ：接收用户输入，协调模型与视图之间的数据流转。

这种设计模式的优势在于 职责分离 、 高内聚低耦合 ，使得系统更易于维护、扩展和测试。在Java Web开发中，Spring MVC正是基于MVC模式构建的Web框架。

3.1.2 Spring MVC的核心组件

Spring MVC 是 Spring 框架中用于构建 Web 应用的模块。其核心组件包括：

组件名称	职责说明
`DispatcherServlet`	前端控制器，负责接收所有HTTP请求，并协调整个请求处理流程
`HandlerMapping`	根据请求路径找到对应的Controller
`Controller`	处理具体的业务逻辑，返回模型和视图信息
`ViewResolver`	将逻辑视图名解析为实际的视图（如JSP）
`ModelAndView`	包含模型数据和视图信息的对象
`HandlerAdapter`	调用Controller并处理返回值
`LocaleResolver`	处理国际化
`ThemeResolver`	处理主题样式

Spring MVC 采用模块化设计，使得每个组件都可以灵活替换或扩展。例如，可以使用不同的 ViewResolver 来支持Thymeleaf、FreeMarker等模板引擎。

3.2 请求处理流程

3.2.1 DispatcherServlet的作用与配置

DispatcherServlet 是 Spring MVC 的核心，它是所有请求的入口。其主要作用如下：

接收客户端的 HTTP 请求。
将请求分发给对应的 Controller。
协调视图解析、模型数据封装等流程。

配置方式

在传统的 XML 配置方式中， DispatcherServlet 的配置通常在 web.xml 文件中完成：

<servlet>
    <servlet-name>spring-mvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring-mvc-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>spring-mvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

在这个配置中：

contextConfigLocation 指定 Spring MVC 的配置文件路径。
<url-pattern>/</url-pattern> 表示所有请求都将由 DispatcherServlet 处理。

逻辑分析

用户在浏览器输入 URL，请求发送到服务器。
Web 容器（如 Tomcat）将请求交给 DispatcherServlet 。
DispatcherServlet 根据配置的 HandlerMapping 找到对应的 Controller 。
Controller 处理请求并返回 ModelAndView 。
ViewResolver 解析视图名，返回实际视图对象。
DispatcherServlet 将模型数据渲染到视图并返回响应。

流程图展示

graph TD
    A[客户端请求] --> B[DispatcherServlet]
    B --> C[HandlerMapping]
    C --> D{是否存在匹配Controller?}
    D -->|是| E[调用Controller]
    D -->|否| F[返回404]
    E --> G[处理业务逻辑]
    G --> H[返回ModelAndView]
    H --> I[ViewResolver解析视图]
    I --> J[渲染视图并返回响应]
    J --> K[客户端收到响应]

3.2.2 HandlerMapping与Controller的协作

HandlerMapping 的作用是根据请求的 URL 找到对应的 Controller 方法。Spring MVC 提供了多种实现方式，如 BeanNameUrlHandlerMapping 、 SimpleUrlHandlerMapping 和 RequestMappingHandlerMapping 。

常见配置示例

<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>

Controller 示例代码

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String sayHello(Model model) {
        model.addAttribute("message", "Hello Spring MVC!");
        return "hello"; // 视图名
    }
}

代码分析：

@Controller ：将该类声明为 Spring MVC 的 Controller。
@RequestMapping("/hello") ：将 /hello 映射到该方法。
Model 参数：用于向视图传递数据。
return "hello" ：返回视图名称，由 ViewResolver 解析为实际的视图文件（如 /WEB-INF/views/hello.jsp ）。

3.2.3 视图解析器与响应处理

ViewResolver 是负责将逻辑视图名转换为实际视图资源的组件。常见的实现类包括：

InternalResourceViewResolver ：用于 JSP 视图。
ThymeleafViewResolver ：用于 Thymeleaf 模板。
FreeMarkerViewResolver ：用于 FreeMarker 模板。

配置 InternalResourceViewResolver 示例

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

参数说明：

prefix ：视图文件的前缀路径。
suffix ：视图文件的后缀。

响应处理逻辑

Controller 返回视图名 “hello”。
ViewResolver 拼接为 /WEB-INF/views/hello.jsp 。
Spring MVC 渲染该 JSP 页面，并将 Model 中的数据绑定到页面中。

JSP 页面示例（hello.jsp）

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

代码分析：

${message} ：EL 表达式，用于从 Model 中取出数据并显示。

3.3 数据绑定与验证

3.3.1 表单数据绑定机制

Spring MVC 提供了强大的表单数据绑定机制，可以将请求参数自动绑定到 Java 对象中。

示例代码

public class User {
    private String name;
    private int age;

    // Getters and Setters
}

@Controller
public class UserController {

    @RequestMapping("/user")
    public String showUser(User user, Model model) {
        model.addAttribute("user", user);
        return "userDetail";
    }
}

说明：

当用户访问 /user?name=Tom&age=25 时，Spring MVC 会自动将参数绑定到 User 对象中。
无需手动获取参数，代码更简洁。

JSP 页面显示用户信息（userDetail.jsp）

<h2>姓名：${user.name}</h2>
<h2>年龄：${user.age}</h2>

3.3.2 使用@Valid进行数据验证

Spring MVC 支持 JSR-303 规范的数据验证，使用 @Valid 注解可对表单数据进行校验。

示例代码

public class UserForm {

    @NotBlank(message = "姓名不能为空")
    private String name;

    @Min(value = 1, message = "年龄必须大于0")
    private int age;

    // Getters and Setters
}

@Controller
public class UserController {

    @RequestMapping("/submit")
    public String submitForm(@Valid UserForm userForm, BindingResult result, Model model) {
        if (result.hasErrors()) {
            return "form";
        }
        model.addAttribute("user", userForm);
        return "userDetail";
    }
}

代码分析：

@NotBlank 、 @Min ：数据校验注解。
BindingResult ：用于捕获校验错误信息。
若存在错误，返回表单页面；否则跳转到详情页面。

表单页面（form.jsp）

<form action="/submit" method="post">
    姓名：<input type="text" name="name"/><br/>
    年龄：<input type="number" name="age"/><br/>
    <input type="submit" value="提交"/>
</form>

3.3.3 错误消息处理与国际化支持

Spring MVC 支持错误消息的国际化处理，可以为不同语言环境显示不同的错误提示。

配置国际化消息源（message.properties）

# message.properties
NotBlank.userForm.name=姓名不能为空
Min.userForm.age=年龄必须大于0

配置 `MessageSource` Bean

<bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
    <property name="basename" value="classpath:messages"/>
    <property name="defaultEncoding" value="UTF-8"/>
</bean>

参数说明：

basename ：指定资源文件路径。
defaultEncoding ：设置默认编码格式，防止乱码。

在页面中显示错误信息

<form:form modelAttribute="userForm" method="post">
    姓名：<form:input path="name"/><form:errors path="name"/><br/>
    年龄：<form:input path="age"/><form:errors path="age"/><br/>
    <input type="submit" value="提交"/>
</form:form>

说明：

form:errors 标签会自动显示对应字段的错误信息。
Spring 会根据当前 Locale 读取对应的国际化资源。

本章深入讲解了 Spring MVC 的 MVC 架构实现，包括核心组件、请求处理流程、数据绑定及验证机制，并通过代码实例与流程图展示了其内部运作原理和实际应用场景。下一章将进入 MyBatis 框架的使用讲解。

4. MyBatis持久层框架使用

4.1 MyBatis简介与优势

4.1.1 ORM框架的对比与选择

在Java企业级开发中，持久层技术的选择直接影响系统的性能、开发效率和可维护性。ORM（对象关系映射）框架是当前主流的解决方案，常见的有Hibernate、JPA和MyBatis。虽然它们都能将Java对象与数据库表进行映射，但在设计理念和适用场景上各有侧重。

框架	特点	适用场景	性能
Hibernate	全自动ORM，支持多种数据库，内置缓存机制，学习成本高	快速原型开发、中小型项目	一般
JPA	标准化ORM接口，常与Hibernate实现结合使用	需要标准化持久化接口的项目	一般
MyBatis	半自动ORM，SQL由开发者编写，灵活度高，支持动态SQL	大型系统、高并发、复杂查询场景	高

MyBatis作为一款轻量级的持久层框架，其优势在于：

灵活的SQL控制 ：允许开发者直接编写SQL语句，便于性能优化。
解耦性好 ：通过Mapper接口与XML配置文件分离业务逻辑与数据访问。
轻量级 ：没有复杂的依赖，易于集成和维护。
动态SQL支持 ：通过 <if> 、 <choose> 、 <foreach> 等标签实现复杂查询逻辑。

在对性能和SQL优化有较高要求的项目中，MyBatis往往比全自动ORM框架更具优势。

4.1.2 MyBatis的工作原理与核心接口

MyBatis的核心机制围绕以下几个关键组件展开：

graph TD
    A[MyBatis工作流程] --> B[SqlSessionFactoryBuilder]
    B --> C[SqlSessionFactory]
    C --> D[SqlSession]
    D --> E[Mapper接口]
    E --> F[XML映射文件]
    F --> G[执行SQL语句]
    G --> H[结果映射到Java对象]

SqlSessionFactoryBuilder ：用于构建 SqlSessionFactory ，通常只在启动时使用一次。
SqlSessionFactory ：是一个工厂类，用于创建 SqlSession 实例。
SqlSession ：用于执行SQL语句、提交事务、获取Mapper接口的实现类。
Mapper接口 ：开发者定义的接口方法，与XML中的SQL语句绑定。
XML映射文件 ：存放SQL语句和结果映射规则的配置文件。

下面是一个简单的MyBatis使用流程代码示例：

// 1. 读取配置文件
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2. 构建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3. 获取SqlSession
try (SqlSession session = sqlSessionFactory.openSession()) {
    // 4. 获取Mapper接口
    UserMapper mapper = session.getMapper(UserMapper.class);
    // 5. 调用接口方法执行SQL
    User user = mapper.selectUserById(1);
    System.out.println(user.getName());
}

代码解析 ：

Resources.getResourceAsStream(resource) ：加载MyBatis的核心配置文件。
new SqlSessionFactoryBuilder().build(inputStream) ：构建一个线程安全的 SqlSessionFactory 。
session.getMapper(UserMapper.class) ：获取接口的实现类，MyBatis会动态代理该接口。
mapper.selectUserById(1) ：执行SQL查询，并将结果映射到 User 对象。

4.2 MyBatis配置与映射

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

MyBatis的全局配置文件 mybatis-config.xml 是整个框架的入口，用于配置环境、事务管理器、数据源、类型别名等。

<?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="password"/>
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="mapper/UserMapper.xml"/>
  </mappers>
</configuration>

参数说明 ：

<typeAliases> ：定义类型别名，简化XML中Java类的引用。
<environments> ：配置多个环境， default 指定默认环境。
<transactionManager> ：事务管理器类型，JDBC或MANAGED。
<dataSource> ：数据源配置， type="POOLED" 表示使用连接池。
<mappers> ：指定Mapper XML文件的位置。

4.2.2 Mapper XML文件的编写规范

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

<?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="selectUserById" resultType="User">
    SELECT * FROM users WHERE id = #{id}
  </select>
  <insert id="insertUser">
    INSERT INTO users (name, email)
    VALUES (#{name}, #{email})
  </insert>
</mapper>

参数说明 ：

namespace ：对应Mapper接口的全限定名。
id ：接口方法名，必须与Mapper接口方法名一致。
resultType ：返回结果的Java类型。
#{} ：MyBatis的占位符，用于防止SQL注入。

4.2.3 动态SQL的使用技巧

MyBatis的动态SQL功能使得开发者可以灵活构建查询条件，避免SQL拼接错误。

<select id="findUsersByCondition" parameterType="map" resultType="User">
  SELECT * FROM users
  <where>
    <if test="name != null">
      AND name LIKE CONCAT('%', #{name}, '%')
    </if>
    <if test="email != null">
      AND email = #{email}
    </if>
  </where>
</select>

代码逻辑分析 ：

<where> 标签自动处理AND或OR的开头问题。
<if> 标签根据条件判断是否添加该SQL片段。
CONCAT('%', #{name}, '%') ：实现模糊查询。

动态SQL还可以结合 <choose> 、 <when> 、 <otherwise> 、 <foreach> 等标签实现更复杂的查询逻辑。

4.3 MyBatis与Spring整合

4.3.1 整合MyBatis-Spring模块

为了简化MyBatis在Spring项目中的使用，MyBatis官方提供了 mybatis-spring 模块，实现了与Spring的无缝整合。

整合步骤 ：

添加Maven依赖：

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.7</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.3.20</version>
</dependency>

配置Spring的 applicationContext.xml ：

<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="password"/>
</bean>

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

<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.example.mapper"/>
</bean>

参数说明 ：

dataSource ：配置数据库连接。
sqlSessionFactory ：创建 SqlSessionFactory 。
mapperLocations ：指定Mapper XML文件路径。
MapperScannerConfigurer ：自动扫描Mapper接口并注册为Spring Bean。

4.3.2 Mapper接口的扫描与注入

通过 MapperScannerConfigurer 配置后，Spring会自动扫描指定包下的Mapper接口，并将其注册为Bean。开发者可以直接在Service层注入Mapper接口：

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

    public User getUserById(int id) {
        return userMapper.selectUserById(id);
    }
}

逻辑分析 ：

@Autowired 注解自动注入Mapper接口实例。
Spring通过动态代理创建Mapper实现类。
Service层调用Mapper方法时，底层由MyBatis执行SQL。

4.3.3 事务管理的配置与使用

在Spring中，MyBatis的事务管理通常通过声明式事务控制来实现。

配置事务管理器 ：

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

<tx:annotation-driven transaction-manager="transactionManager"/>

在Service中使用事务 ：

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    @Transactional
    public void addUserAndLog(User user) {
        userMapper.insertUser(user);
        // 模拟插入日志
        userMapper.insertLog(user.getId(), "User created");
    }
}

逻辑分析 ：

@Transactional 注解开启事务。
若插入用户或日志失败，整个事务将回滚。
Spring管理事务生命周期，开发者无需手动提交或回滚。

通过上述整合，MyBatis与Spring能够实现高度解耦、高效的持久层开发模式，是构建企业级Java Web应用的优选方案。

5. MySQL数据库设计与配置

MySQL 是 Java Web 开发中最常用的数据库之一，具有开源、性能高、部署简单、社区活跃等优势。在 SSM 框架体系中，MyBatis 作为持久层框架，与 MySQL 的配合尤为紧密。本章将从 MySQL 的基础入手，逐步深入到数据库设计、连接配置与性能优化等方面，帮助开发者构建高效、稳定、可扩展的数据库架构。

5.1 MySQL数据库基础

5.1.1 数据库选型与安装配置

在企业级应用中，数据库选型是系统设计的关键环节。MySQL 凭借其良好的性能、事务支持、跨平台能力以及丰富的生态工具，成为中小型项目和高并发系统的首选。

安装步骤（以 Linux 环境为例）：

# 1. 添加MySQL官方仓库
sudo apt-get install mysql-server

# 2. 安装过程中会提示设置root密码
# 3. 启动MySQL服务
sudo systemctl start mysql

# 4. 设置开机自启
sudo systemctl enable mysql

# 5. 登录MySQL
mysql -u root -p

安装后配置建议：

配置项	建议值	说明
max_connections	100~500	根据并发需求调整
innodb_buffer_pool_size	系统内存的50%-70%	提升InnoDB性能
character_set_server	utf8mb4	支持中文和表情符号
collation_server	utf8mb4_unicode_ci	排序规则

安装逻辑分析：

mysql-server 包含服务端和客户端。
安装过程中自动创建系统数据库和默认用户。
character_set_server=utf8mb4 是当前推荐的字符集，避免中文乱码问题。

5.1.2 数据类型与约束条件

合理选择数据类型可以提升性能并减少存储空间。同时，通过设置约束（如主键、外键、非空等）来保证数据完整性。

常用数据类型分类：

类型类别	数据类型	示例
数值型	INT, BIGINT, FLOAT, DECIMAL	用于存储数字
字符型	CHAR, VARCHAR, TEXT	存储字符串
日期时间	DATE, TIME, DATETIME, TIMESTAMP	存储日期时间
二进制	BLOB, BINARY	存储文件或加密数据

约束条件：

CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL UNIQUE,
    email VARCHAR(100),
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
    age INT CHECK (age >= 0)
);

逐行解释：

id INT PRIMARY KEY AUTO_INCREMENT ：主键且自动递增。
username VARCHAR(50) NOT NULL UNIQUE ：用户名不能为空且唯一。
created_at DATETIME DEFAULT CURRENT_TIMESTAMP ：默认值为当前时间。
age INT CHECK (age >= 0) ：限制年龄必须大于等于0。

5.2 数据库表结构设计

5.2.1 数据库规范化与反规范化策略

规范化设计旨在减少冗余，提高数据一致性；而反规范化则用于提升查询效率。

数据库范式简述：

范式	描述
第一范式 (1NF)	每个字段不可再分
第二范式 (2NF)	满足1NF，且非主键字段完全依赖主键
第三范式 (3NF)	满足2NF，且非主键字段不依赖其他非主键字段

规范化 vs 反规范化对比：

对比维度	规范化	反规范化
数据冗余	低	高
查询性能	低（多表连接）	高（单表查询）
更新性能	高（一致性好）	低（需更新多处）
使用场景	OLTP（事务处理）	OLAP（报表分析）

举例说明：

规范化设计：

-- 用户表
CREATE TABLE users (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

-- 订单表
CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_id INT,
    amount DECIMAL(10,2),
    FOREIGN KEY (user_id) REFERENCES users(id)
);

反规范化设计：

-- 合并用户信息到订单表
CREATE TABLE orders (
    id INT PRIMARY KEY,
    user_name VARCHAR(50),
    amount DECIMAL(10,2)
);

5.2.2 主键、外键与索引的合理使用

主键与外键设计原则：

主键用于唯一标识一条记录，建议使用自增整型。
外键用于维护表间关系，但频繁更新时可能影响性能。
在频繁查询字段上建立索引可大幅提升效率。

索引类型：

类型	说明
普通索引	提升查询速度
唯一索引	值必须唯一
主键索引	唯一且非空
全文索引	支持文本搜索
复合索引	多个字段组合索引

索引优化示例：

-- 为email字段添加唯一索引
ALTER TABLE users ADD UNIQUE (email);

-- 为name和age建立复合索引
ALTER TABLE users ADD INDEX idx_name_age (name, age);

索引注意事项：

不要为低基数字段（如性别）建立索引。
复合索引要遵循最左匹配原则。
避免过多索引导致写性能下降。

5.3 数据库连接与性能优化

5.3.1 JDBC连接配置与驱动加载

Java 通过 JDBC 连接 MySQL 数据库。SSM 框架中，通常使用 MyBatis 或 Spring JDBC 来管理连接。

JDBC 连接示例：

String url = "jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=UTC";
String user = "root";
String password = "123456";

Connection conn = DriverManager.getConnection(url, user, password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users");

代码解释：

useSSL=false ：关闭SSL连接（适用于测试环境）。
serverTimezone=UTC ：避免时区问题。
DriverManager.getConnection() ：建立数据库连接。
createStatement() ：创建SQL执行对象。

JDBC驱动配置（Maven）：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.30</version>
</dependency>

5.3.2 连接池技术（如Druid、C3P0）

频繁创建和销毁连接会带来性能损耗，使用连接池可有效提升效率。

Druid 连接池配置示例（Spring 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="filters" value="stat"/>
</bean>

配置说明：

参数	说明
url	数据库连接地址
initialSize	初始化连接数
minIdle	最小空闲连接
maxActive	最大连接数
filters	过滤器，如监控（stat）、日志（log4j）等

Druid 的监控功能：

通过 StatViewServlet 可以实时查看连接池状态、SQL执行情况等。

<servlet>
    <servlet-name>DruidStatView</servlet-name>
    <servlet-class>com.alibaba.druid.support.http.StatViewServlet</servlet-class>
    <init-param>
        <param-name>login-username</param-name>
        <param-value>admin</param-value>
    </init-param>
    <init-param>
        <param-name>login-password</param-name>
        <param-value>admin</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>DruidStatView</servlet-name>
    <url-pattern>/druid/*</url-pattern>
</servlet-mapping>

5.3.3 查询优化与执行计划分析

查询优化是数据库性能调优的重要环节。通过分析执行计划，可以发现索引缺失、表扫描等问题。

使用 `EXPLAIN` 分析查询：

EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';

执行计划输出字段解释：

字段	说明
id	查询的标识符
select_type	查询类型（SIMPLE, PRIMARY等）
table	涉及的表名
type	连接类型（ALL, index, range等）
possible_keys	可能使用的索引
key	实际使用的索引
rows	扫描的行数
Extra	额外信息（如Using filesort, Using temporary）

查询优化建议：

避免 SELECT * ，只查询需要字段。
使用 LIMIT 控制返回行数。
避免在 WHERE 中对字段进行函数操作。
对大表分页查询使用 LIMIT offset, size 注意性能。

示例优化：

-- 未优化
SELECT * FROM orders WHERE YEAR(create_time) = 2023;

-- 优化
SELECT * FROM orders WHERE create_time BETWEEN '2023-01-01' AND '2023-12-31';

总结

本章围绕 MySQL 数据库的安装配置、表结构设计、连接管理与性能优化进行了详细讲解。通过合理选择数据类型、使用主键与索引、配置连接池以及分析执行计划，可以显著提升数据库的稳定性和性能。在后续章节中，我们将进一步探讨如何将这些数据库设计与 MyBatis 和 Spring 进行整合，实现完整的数据持久化方案。

6. JSP动态网页开发技术

JSP（Java Server Pages）作为Java Web开发中最为传统的动态网页技术之一，虽然在现代前端框架（如Vue、React）盛行的背景下逐渐退居二线，但其在企业级Java Web项目中依然占据着不可忽视的地位。尤其在SSM（Spring + Spring MVC + MyBatis）框架整合中，JSP常用于实现动态页面展示、数据绑定与前端逻辑控制。本章将深入解析JSP的核心机制、语法结构、内置对象使用方式，以及如何通过EL表达式与JSTL标签库提升页面开发效率。

6.1 JSP技术概述

6.1.1 JSP与Servlet的关系

JSP本质上是Servlet的“变种”，是Java EE规范中对动态网页生成的一种封装形式。在JSP页面中，开发者可以混合使用HTML与Java代码，最终由JSP引擎将其编译为Servlet类，并由Servlet容器（如Tomcat）执行。

graph TD
    A[JSP文件] --> B{JSP引擎}
    B --> C[生成Servlet代码]
    C --> D[编译成.class文件]
    D --> E[由Tomcat加载执行]
    E --> F[输出HTML响应]

JSP与Servlet的关系总结如下：

对比项	JSP	Servlet
编写方式	HTML为主，嵌入Java代码	Java代码为主，输出HTML字符串
编译时机	首次请求时自动编译	手动编译或构建工具编译
使用场景	页面展示、前端渲染	业务逻辑处理、请求响应控制
可维护性	更适合前端人员编写	更适合后端人员编写

6.1.2 JSP的生命周期与执行过程

JSP的生命周期与Servlet类似，主要经历以下阶段：

翻译阶段（Translation） ：JSP被解析为Java代码（Servlet源码）。
编译阶段（Compilation） ：Java代码被编译为.class文件。
类加载阶段（Loading） ：Servlet类被加载到JVM中。
初始化阶段（Initialization） ：调用 jspInit() 方法。
执行阶段（Execution） ：调用 _jspService() 方法处理请求。
销毁阶段（Destroy） ：调用 jspDestroy() 方法释放资源。

示例：一个简单的JSP页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Hello JSP</title></head>
<body>
    <h1>当前时间：<%= new java.util.Date() %></h1>
</body>
</html>

逐行解读：

<%@ page ... %> ：这是JSP的指令标签，用于设置页面属性，如内容类型、字符编码、使用的语言等。
<%= ... %> ：这是表达式脚本，用于将Java表达式的值输出到HTML中。
new java.util.Date() ：创建一个日期对象，表示当前时间。

逻辑分析：
该JSP页面每次被访问时，都会调用 _jspService() 方法，内部执行 new Date() 并输出到HTML页面中。JSP引擎会将该页面编译为一个Servlet类，继承自 HttpJspBase ，并重写 _jspService() 方法。

6.2 JSP语法与内置对象

6.2.1 指令、脚本元素与动作标签

JSP语法主要包括三类元素：

指令（Directives） ：控制JSP页面的全局行为。
脚本元素（Scripting Elements） ：嵌入Java代码。
动作标签（Action Tags） ：实现页面跳转、包含、使用JavaBean等。

常见JSP指令：

指令	用途说明
`<%@ page %>`	设置页面属性，如contentType、import等
`<%@ include %>`	静态包含另一个页面内容
`<%@ taglib %>`	引入标签库，如JSTL

示例：使用include指令包含页脚

<%@ include file="footer.jsp" %>

该指令会在编译阶段将 footer.jsp 的内容合并到当前页面中，适用于静态内容复用。

脚本元素：

类型	语法	示例说明
声明（Declaration）	`<%! int count = 0; %>`	声明变量或方法，作用域为整个页面
表达式（Expression）	`<%= count++ %>`	输出表达式结果
脚本片段（Scriptlet）	`<% out.println("Hello"); %>`	插入任意Java代码

动作标签：

标签	功能说明
`<jsp:include>`	动态包含另一个页面
`<jsp:forward>`	请求转发
`<jsp:useBean>`	使用JavaBean对象

示例：使用进行页面跳转

<jsp:forward page="home.jsp" />

该标签会在运行时将请求转发到 home.jsp 页面，与Servlet中的 RequestDispatcher.forward() 类似。

6.2.2 内置对象（request、response、session等）

JSP提供了9个内置对象，可以直接在页面中使用，无需显式声明。

内置对象	类型	说明
request	`HttpServletRequest`	获取客户端请求数据
response	`HttpServletResponse`	设置响应内容
session	`HttpSession`	存储用户会话信息
application	`ServletContext`	应用级别的共享对象
pageContext	`PageContext`	页面上下文，获取其他对象
page	`Object`	当前JSP页面本身（this）
config	`ServletConfig`	获取Servlet配置信息
exception	`Throwable`	页面异常信息（需设置isErrorPage）
out	`JspWriter`	向客户端输出内容

示例：使用session对象保存用户信息

<%
    session.setAttribute("user", "张三");
%>
欢迎用户：<%= session.getAttribute("user") %>

逐行解读：

session.setAttribute("user", "张三") ：将用户信息存入会话。
<%= session.getAttribute("user") %> ：取出并显示用户信息。

6.3 EL表达式与JSTL标签库

6.3.1 EL表达式的基本语法与使用场景

EL（Expression Language）表达式用于简化JSP页面中对变量的访问，替代传统JSP脚本的 <%= ... %> 方式。

基本语法： ${变量名}

示例：使用EL表达式输出request域中的数据

<%
    request.setAttribute("message", "欢迎访问本网站");
%>
<p>${message}</p>

EL表达式支持以下操作：

操作类型	示例	说明
算术运算	`${5 + 3}`	支持 + - * / %
逻辑运算	`${true and false}`	支持 and、or、not
关系运算	`${age > 18}`	支持 >、<、==、!= 等
条件表达式	`${user != null ? user.name : "访客"}`	三元运算符支持

6.3.2 JSTL核心标签库（if、foreach等）

JSTL（JSP Standard Tag Library）是一组标准标签库，提供流程控制、迭代、URL处理等功能。

引入JSTL标签库：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

常用JSTL标签：

标签	用途说明
`<c:if>`	条件判断
`<c:choose>`	多条件分支
`<c:forEach>`	遍历集合或数组
`<c:set>`	设置变量值
`<c:url>`	生成带参数的URL

示例：使用遍历列表

<c:set var="names" value="${['张三', '李四', '王五']}" />
<ul>
    <c:forEach items="${names}" var="name">
        <li>${name}</li>
    </c:forEach>
</ul>

逐行解读：

<c:set> ：设置一个变量 names ，值为一个字符串数组。
<c:forEach> ：遍历数组，每次迭代将元素赋值给 var 指定的变量 name 。
${name} ：使用EL表达式输出当前元素。

表格：JSTL与JSP脚本对比

项目	JSP脚本方式	JSTL+EL方式
可读性	低，混杂HTML与Java代码	高，标签化、语义清晰
安全性	易出错，难以维护	结构清晰，易于调试
性能	相当	相当
推荐程度	不推荐	推荐使用

6.3.3 自定义标签的开发与应用

JSP允许开发者通过自定义标签（Custom Tag）扩展页面功能，提升代码复用性和可维护性。

步骤如下：

编写标签处理类（Tag Handler）

public class HelloTag extends SimpleTagSupport {
    @Override
    public void doTag() throws JspException, IOException {
        JspWriter out = getJspContext().getOut();
        out.println("Hello, 自定义标签！");
    }
}

配置TLD文件（Tag Library Descriptor）

<tag>
    <name>hello</name>
    <tag-class>com.example.HelloTag</tag-class>
    <body-content>empty</body-content>
</tag>

在JSP中使用自定义标签

<%@ taglib prefix="my" uri="/WEB-INF/tlds/mytags.tld" %>

<my:hello />

执行流程：

graph LR
    A[JSP页面使用自定义标签] --> B[容器查找TLD配置]
    B --> C[加载标签处理类]
    C --> D[调用doTag方法输出内容]
    D --> E[输出到浏览器]

优点：

提升代码复用性
实现业务逻辑与页面分离
支持标签库复用与共享

以上内容为 第六章：JSP动态网页开发技术 的完整章节内容，涵盖了JSP的核心原理、语法结构、内置对象、EL表达式、JSTL标签库以及自定义标签的开发与使用，符合由浅入深的递进式内容结构，满足IT行业从业者对技术细节与实际应用的需求。

7. SSM框架整合流程详解

7.1 整合前的准备工作

7.1.1 项目依赖管理（Maven或Gradle）

在整合SSM框架之前，首先需要完成项目的依赖管理配置。推荐使用 Maven 作为项目构建工具，其依赖管理清晰、易于维护。以下是一个典型的 pom.xml 文件中整合 SSM 所需的依赖配置：

<dependencies>
    <!-- Spring核心 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.20</version>
    </dependency>

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

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

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

    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.30</version>
    </dependency>

    <!-- 数据库连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.2.15</version>
    </dependency>

    <!-- JSP支持 -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

以上配置涵盖了 Spring、MyBatis、MySQL、Druid 连接池等基础依赖，是整合 SSM 的前提。

7.1.2 工程目录结构与模块划分

一个标准的 SSM 项目结构如下：

src/
├── main/
│   ├── java/
│   │   └── com.example.ssm/
│   │       ├── controller/    // 控制器层
│   │       ├── service/       // 业务逻辑层
│   │       ├── mapper/        // 数据访问层接口
│   │       └── model/         // 实体类
│   │
│   ├── resources/
│   │   ├── spring-config.xml     // Spring主配置
│   │   ├── spring-mvc.xml        // Spring MVC配置
│   │   └── mybatis-config.xml    // MyBatis配置
│   │
│   └── webapp/
│       ├── WEB-INF/
│       │   └── web.xml
│       └── jsp/
│           └── index.jsp

合理的模块划分有助于代码管理与后期维护，是构建可扩展企业级应用的基础。

7.2 核心配置文件整合

7.2.1 web.xml的基本配置

web.xml 是 Web 应用的核心配置文件，用于配置监听器、过滤器、Servlet 等内容。以下是整合 SSM 时的 web.xml 配置示例：

<web-app version="3.0" 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">

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

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

    <!-- 配置Spring MVC的DispatcherServlet -->
    <servlet>
        <servlet-name>dispatcher</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>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

7.2.2 Spring与Spring MVC的上下文配置

spring-config.xml 是 Spring 的主配置文件，主要用于配置数据源、事务管理器、MyBatis 整合等内容。

<!-- spring-config.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"
       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">

    <!-- 自动扫描业务层和DAO层 -->
    <context:component-scan base-package="com.example.ssm.service, com.example.ssm.mapper" />

    <!-- 引入数据库配置文件 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                <value>classpath:db.properties</value>
            </list>
        </property>
    </bean>

    <!-- 配置Druid数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driver}" />
    </bean>

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

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

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

</beans>

spring-mvc.xml 是 Spring MVC 的配置文件，主要用于配置视图解析器、静态资源处理、控制器扫描等：

<!-- spring-mvc.xml -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/mvc 
                           http://www.springframework.org/schema/mvc/spring-mvc.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">

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

    <!-- 自动扫描控制器 -->
    <context:component-scan base-package="com.example.ssm.controller" />

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

    <!-- 静态资源处理 -->
    <mvc:default-servlet-handler />

</beans>

7.2.3 MyBatis与Spring的整合配置

在 mybatis-config.xml 中可以配置别名、插件、缓存等全局设置，通常内容较少：

<!-- mybatis-config.xml -->
<configuration>
    <typeAliases>
        <package name="com.example.ssm.model" />
    </typeAliases>
</configuration>

此外，还需要在数据库配置文件 db.properties 中定义数据库连接信息：

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm_db?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=123456

（未完待续）

本文还有配套的精品资源，点击获取

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

更多推荐

AI重构项目开发全流程：效率革命与实践指南

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

K8s Pod 创建失败深度解析：从 IPAM 400 错误到子网资源耗尽

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

Cursor + GitOps：自动化运维新姿势

Cursor与GitOps的结合，并非简单的工具叠加，而是思维与工作流的深度融合。它将开发者从繁琐、重复的YAML编写中解放出来，更专注于架构设计与业务逻辑。拥抱这一“新姿势”，意味着以更高的抽象层次、更自然的交互方式，驾驭日益复杂的云原生系统，最终实现运维效率与系统可靠性的双重飞跃。

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

所有评论(0)

查看更多评论

语文乌托邦

@weixin_31163455

已为社区贡献33条内容

Java Web开发实战：SSM+MySQL+JSP项目整合包

语文乌托邦

1. Java Web开发技术栈介绍

1.1 Java Web开发技术栈概述

2. Spring框架核心功能（DI与AOP）

2.1 Spring框架概述

2.1.1 Spring框架的发展与优势

2.1.2 Spring模块结构与核心容器

2.2 依赖注入（DI）详解

2.2.1 Bean的定义与配置方式

示例：XML 方式定义 Bean

示例：Java 注解方式定义 Bean

示例：Java Config 方式定义 Bean

2.2.2 构造器注入与Setter注入

构造器注入示例（XML）：

构造器注入示例（Java Config）：

Setter 注入示例（XML）：

Setter 注入示例（Java 注解）：

2.2.3 自动装配与注解驱动开发

自动装配方式：

示例：自动装配（XML）：

示例：自动装配（Java 注解）：

使用 @ComponentScan 自动扫描 Bean：

2.3 面向切面编程（AOP）

2.3.1 AOP的基本概念与术语

AOP 核心术语：

AOP 应用场景：

2.3.2 切面、通知与切入点的定义

示例：定义一个日志切面（Java 注解方式）

通知类型说明：

2.3.3 基于注解和XML的AOP实现

示例：基于 XML 的 AOP 配置

示例：使用 @Around 实现性能监控

AOP 底层原理流程图（mermaid）

3. Spring MVC MVC架构实现

3.1 Spring MVC概述

3.1.1 MVC设计模式的基本原理

3.1.2 Spring MVC的核心组件

3.2 请求处理流程

3.2.1 DispatcherServlet的作用与配置

配置方式

逻辑分析

流程图展示

3.2.2 HandlerMapping与Controller的协作

常见配置示例

Controller 示例代码

代码分析：

3.2.3 视图解析器与响应处理

配置 InternalResourceViewResolver 示例

参数说明：

响应处理逻辑

JSP 页面示例（hello.jsp）

代码分析：

3.3 数据绑定与验证

3.3.1 表单数据绑定机制

示例代码

说明：

JSP 页面显示用户信息（userDetail.jsp）

3.3.2 使用@Valid进行数据验证

示例代码

代码分析：

表单页面（form.jsp）

3.3.3 错误消息处理与国际化支持

配置国际化消息源（message.properties）

配置 MessageSource Bean

参数说明：

在页面中显示错误信息

说明：

4. MyBatis持久层框架使用

4.1 MyBatis简介与优势

4.1.1 ORM框架的对比与选择

4.1.2 MyBatis的工作原理与核心接口

4.2 MyBatis配置与映射

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

4.2.2 Mapper XML文件的编写规范

4.2.3 动态SQL的使用技巧

4.3 MyBatis与Spring整合

4.3.1 整合MyBatis-Spring模块

4.3.2 Mapper接口的扫描与注入

4.3.3 事务管理的配置与使用

使用 `@ComponentScan` 自动扫描 Bean：

示例：使用 `@Around` 实现性能监控

配置 `MessageSource` Bean

使用 `EXPLAIN` 分析查询：