基于Java的CRM客户关系管理系统毕业设计项目-CSDN博客

本文链接：https://blog.csdn.net/weixin_42611177/article/details/151368014

简介：CRM客户关系管理系统是现代企业优化客户交互的重要工具，本项目使用Java语言开发，采用JSP、Servlet和MySQL数据库构建，具备员工管理、薪资管理和客户信息管理等功能。项目包含完整的源码和SQL脚本，支持CRUD操作，适合学习者进行实践操作与系统调试。通过本项目，学生可深入掌握Java Web开发技术、数据库设计与业务逻辑实现，提升实际编程能力，为职业发展奠定基础。
CRM客户关系管理系统

1. CRM系统概述与功能介绍

CRM（Customer Relationship Management，客户关系管理系统）是一种用于管理企业与客户之间互动关系的信息化系统。随着企业对客户资源重视程度的提升，CRM系统从最初的联系人管理逐步发展为涵盖销售、服务、营销等多维度的综合管理平台。其发展历程可分为三个阶段：初期的接触管理、中期的流程自动化以及当前的智能化整合阶段。

在功能架构上，CRM系统通常包括客户信息管理、销售机会跟踪、客户服务支持、市场营销自动化等核心模块。这些模块协同工作，帮助企业实现客户数据集中管理、业务流程标准化以及客户体验优化。在企业运营中，CRM系统不仅提升了客户满意度和忠诚度，还显著增强了销售转化率与运营效率。

对于本毕业设计而言，CRM系统将围绕中小企业的实际需求进行架构设计，采用前后端分离的思想，结合Java Web技术实现系统的可扩展性与可维护性。系统整体架构包括前端展示层（JSP）、业务控制层（Servlet）、服务逻辑层（Java Bean）与数据持久层（MySQL），形成一个结构清晰、模块化强的企业级应用系统。

2. Java语言在Web开发中的应用

Java 语言自诞生以来，凭借其跨平台性、安全性、稳定性以及丰富的生态体系，逐渐成为企业级 Web 开发的主流语言之一。在现代 Web 应用系统中，Java 不仅承担着后端业务逻辑的处理任务，还通过其强大的框架支持和模块化设计能力，支撑起复杂的系统架构。本章将围绕 Java 在 Web 开发中的核心技术栈、在 CRM 系统中的角色定位，以及开发环境的搭建与配置三个方面展开深入探讨。

2.1 Java Web开发的基本技术栈

Java Web 开发涉及的技术栈较为广泛，主要包括 Java EE 技术体系、MVC 设计模式的应用以及相关的框架支持。这些技术共同构成了 Java Web 开发的基础架构，支撑着从请求处理到业务逻辑再到数据持久化的完整流程。

2.1.1 Java EE技术概述

Java EE（Enterprise Edition）是 Java 平台的一个版本，专为构建企业级应用而设计。它提供了一系列标准化的 API 和服务，支持 Web 服务、分布式计算、安全性和事务管理等关键功能。

Java EE 核心组件包括：

组件名称	功能说明
Servlet	处理 HTTP 请求和响应，负责控制层逻辑
JSP	动态生成 HTML 页面，用于视图展示
EJB（Enterprise JavaBeans）	用于实现业务逻辑，支持事务和安全控制
JPA（Java Persistence API）	对象关系映射（ORM），简化数据库操作
JMS（Java Message Service）	实现消息队列和异步通信
JDBC（Java Database Connectivity）	提供数据库连接和操作接口

Java EE 8 之后，社区将其交由 Eclipse 基金会维护，并更名为 Jakarta EE。尽管名称有所变化，但其核心理念和功能保持一致。

示例：使用 Servlet 输出“Hello World”

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<h1>Hello, World!</h1>");
    }
}

逻辑分析：

HttpServlet 是一个抽象类，提供了 HTTP 协议的处理方法。
doGet 方法用于处理 HTTP GET 请求。
setContentType("text/html") 设置响应内容类型为 HTML。
PrintWriter 用于向客户端输出 HTML 内容。

参数说明：

HttpServletRequest request ：封装客户端的请求信息。
HttpServletResponse response ：用于向客户端发送响应数据。

技术演进：

Java EE 5 ：引入注解简化部署描述符配置。
Java EE 6 ：引入 Web Profile，轻量化 Java EE。
Java EE 7/8 ：支持 WebSocket、JSON-B 等现代 Web 特性。
Jakarta EE 9+ ：包名从 javax 改为 jakarta ，以适应开源社区管理。

2.1.2 MVC设计模式在Java Web中的实现

MVC（Model-View-Controller）是一种经典的软件架构设计模式，广泛应用于 Web 应用开发中。它将应用程序划分为三个核心组件：

Model（模型） ：负责数据的处理与持久化。
View（视图） ：负责数据的展示。
Controller（控制器） ：接收用户输入，协调模型和视图之间的交互。

Java Web 中的 MVC 实现方式：

层级	技术实现
Controller	Servlet、Spring MVC 的 `@Controller`
Model	JavaBean、EJB、JPA 实体
View	JSP、Thymeleaf、Freemarker

示例：基于 Servlet 和 JSP 的 MVC 实现

// Controller: UserServlet.java
@WebServlet("/user")
public class UserServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String name = "张三";
        request.setAttribute("username", name);
        request.getRequestDispatcher("/user.jsp").forward(request, response);
    }
}

<%-- View: user.jsp --%>
<html>
<head><title>用户信息</title></head>
<body>
    <h2>欢迎你，${username}</h2>
</body>
</html>

流程图（mermaid）：

graph TD
    A[用户请求 /user] --> B[UserServlet 接收请求]
    B --> C[设置 request 属性 username]
    C --> D[转发请求到 user.jsp]
    D --> E[user.jsp 显示欢迎信息]

代码逻辑分析：

@WebServlet("/user") 注解将该 Servlet 映射到 /user 路径。
request.setAttribute("username", name) 将用户名存入请求域。
getRequestDispatcher("/user.jsp").forward() 将请求转发至 JSP 页面。
JSP 中使用 EL 表达式 ${username} 显示用户名。

优势与演进：

松耦合 ：各组件职责清晰，便于维护与扩展。
可测试性 ：Controller 与 Model 可独立测试。
Spring MVC 的整合 ：Spring 框架提供更高级的 MVC 支持，如自动绑定、异常处理、视图解析器等。

2.2 Java在CRM系统中的角色定位

Java 在 CRM 系统中扮演着核心角色，不仅承担着后端业务逻辑的处理，还在系统架构设计中提供可扩展性和可维护性的保障。

2.2.1 后端业务逻辑处理

CRM 系统的业务逻辑通常包括客户信息管理、销售机会追踪、服务工单处理等。Java 通过其面向对象的特性，可以将这些业务逻辑抽象为类和接口，提升代码的复用性和可维护性。

示例：客户信息管理的 Service 层

public class CustomerService {
    private CustomerDAO customerDAO;

    public CustomerService() {
        this.customerDAO = new CustomerDAO(); // 数据访问层
    }

    public List<Customer> getAllCustomers() {
        return customerDAO.findAll();
    }

    public Customer getCustomerById(int id) {
        return customerDAO.findById(id);
    }

    public boolean addCustomer(Customer customer) {
        return customerDAO.save(customer);
    }
}

代码逻辑分析：

CustomerService 类封装了客户管理的业务方法。
CustomerDAO 是数据访问对象（DAO），负责与数据库交互。
findAll() 和 findById() 方法分别用于查询所有客户和按 ID 查询客户。
save() 方法用于保存新客户信息。

参数说明：

Customer 是一个 JavaBean，封装了客户的基本信息（如姓名、电话、地址等）。

优势：

分层设计 ：业务逻辑与数据访问分离，便于维护。
可测试性 ：Service 层可以通过 Mock DAO 进行单元测试。
可扩展性 ：后续可引入 Spring 框架进行依赖注入和事务管理。

2.2.2 系统架构的可扩展性设计

在 CRM 系统中，随着业务的增长，系统的架构需要具备良好的可扩展性。Java 提供了多种机制来支持系统的横向与纵向扩展。

扩展策略：

扩展方向	技术手段
横向扩展	微服务架构（Spring Boot + Spring Cloud）
纵向扩展	模块化设计（Maven 多模块项目）
高可用	负载均衡（Nginx）、服务注册与发现（Eureka）
异步处理	消息队列（RabbitMQ、Kafka）

示例：使用 Spring Boot 构建微服务模块

@RestController
@RequestMapping("/api/customers")
public class CustomerController {

    @Autowired
    private CustomerService customerService;

    @GetMapping
    public List<Customer> getAllCustomers() {
        return customerService.getAllCustomers();
    }

    @PostMapping
    public boolean addCustomer(@RequestBody Customer customer) {
        return customerService.addCustomer(customer);
    }
}

逻辑分析：

@RestController 将该类定义为 REST 控制器。
@RequestMapping 设置请求路径前缀。
@Autowired 注解用于自动注入 CustomerService 实例。
@GetMapping 和 @PostMapping 分别处理 GET 和 POST 请求。

优势：

模块化部署 ：每个服务可独立部署与扩展。
弹性伸缩 ：可根据业务负载动态调整服务实例。
容错处理 ：服务间通信支持熔断、降级机制。

2.3 Java开发环境搭建与配置

一个良好的开发环境是 Java Web 项目顺利进行的基础。本节将介绍 JDK、Tomcat、Eclipse 的配置方法，以及 Maven 作为依赖管理工具的使用。

2.3.1 JDK、Tomcat、Eclipse配置说明

JDK 安装与配置

下载 JDK（推荐使用 OpenJDK 17 或更高版本）。
安装完成后，配置环境变量：
- JAVA_HOME : 指向 JDK 安装目录。
- PATH : 添加 %JAVA_HOME%\bin 。
验证安装：
bash java -version javac -version

Tomcat 配置

下载 Apache Tomcat（推荐 9.x 或 10.x）。
解压并配置环境变量：
- CATALINA_HOME : 指向 Tomcat 根目录。
启动 Tomcat：
bash cd %CATALINA_HOME%\bin startup.bat
访问 http://localhost:8080 验证是否启动成功。

Eclipse 配置

下载并安装 Eclipse IDE for Java EE Developers。
安装完成后，配置 Tomcat Server：
- 打开 Eclipse，点击 Window > Show View > Servers 。
- 右键添加新的 Server，选择 Apache Tomcat 版本。
将 Web 项目部署到 Server 上，点击运行即可启动服务。

表格：开发环境配置一览

工具	版本建议	配置说明
JDK	17+	设置 JAVA_HOME 和 PATH
Tomcat	9.x 或 10.x	设置 CATALINA_HOME
Eclipse	2022-12+	安装 Java EE 插件，配置 Tomcat 服务器

2.3.2 Maven依赖管理工具的使用

Maven 是一个项目管理工具，支持项目构建、依赖管理和项目信息管理。

示例： `pom.xml` 配置 Spring Boot 项目

<project xmlns="http://maven.apache.org/POM/4.0.0" ...>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.crm</groupId>
    <artifactId>crm-system</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>17</source>
                    <target>17</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

逻辑分析：

<dependencies> 标签定义了项目所需的依赖项。
spring-boot-starter-web 提供 Web 功能支持。
mysql-connector-java 用于连接 MySQL 数据库。
<plugin> 配置了 Java 17 的编译选项。

优势：

依赖管理 ：自动下载和管理第三方库。
标准化构建 ：统一项目结构和构建流程。
插件扩展 ：支持代码质量检查、打包部署等插件。

本章系统地介绍了 Java 在 Web 开发中的技术栈、在 CRM 系统中的角色定位，以及开发环境的搭建与配置方法。通过本章内容的学习，读者应能够掌握 Java Web 开发的基本流程，理解 MVC 架构的设计思想，并具备搭建完整开发环境的能力。

3. JSP动态页面生成技术

JSP（JavaServer Pages）是一种基于Java的动态网页开发技术，广泛应用于企业级Web应用开发中，尤其是在与Servlet配合构建MVC架构的应用场景下。在CRM系统中，JSP承担着前端展示与用户交互的关键角色，负责将后端逻辑处理后的数据以动态HTML形式呈现给用户。本章将从JSP的基础语法和运行机制出发，深入探讨其在CRM系统中的实际应用方式，并结合代码实例说明如何实现JSP与后端Servlet之间的高效协作。

3.1 JSP基础语法与运行机制

3.1.1 JSP的生命周期与执行流程

JSP本质上是一种Servlet的变体，其生命周期与Servlet高度一致，主要包括以下几个阶段：

翻译阶段（Translation） ：当JSP第一次被请求时，Web容器（如Tomcat）会将 .jsp 文件翻译成一个Java Servlet源文件（ .java ）。
编译阶段（Compilation） ：容器将生成的 .java 文件编译为 .class 字节码文件。
加载与初始化阶段（Loading and Initialization） ：JVM加载该Servlet类并调用 jspInit() 方法进行初始化。
执行阶段（Execution） ：调用 _jspService() 方法处理客户端请求，生成HTML响应。
销毁阶段（Destroy） ：容器调用 jspDestroy() 方法释放资源。

JSP生命周期图示如下：

graph TD
    A[客户端请求JSP页面] --> B{JSP是否已存在Servlet?}
    B -->|否| C[翻译为Servlet]
    C --> D[编译为.class]
    D --> E[加载并初始化]
    E --> F[_jspService()处理请求]
    B -->|是| F
    F --> G[生成HTML响应]
    G --> H[客户端显示页面]

代码示例：JSP基本页面结构

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP示例</title>
</head>
<body>
    <h1>欢迎访问CRM系统</h1>
    <%
        String name = request.getParameter("name");
        if (name != null && !name.isEmpty()) {
    %>
        <p>你好，<%= name %>！</p>
    <%
        } else {
    %>
        <p>请输入你的名字。</p>
    <%
        }
    %>
</body>
</html>

代码逻辑分析：

<%@ page ... %> 是JSP的页面指令，定义页面类型、字符编码和使用的语言。
<% ... %> 是JSP脚本元素，允许嵌入Java代码。
<%= ... %> 是表达式元素，用于输出Java表达式的结果。
该页面接收 name 参数，若存在则显示欢迎语，否则提示输入。

3.1.2 常用JSP内置对象介绍

JSP提供了一系列内置对象（Implicit Objects），这些对象无需声明即可直接使用。它们封装了Web应用中常见的请求、响应、会话等信息，便于开发者快速访问。

内置对象	类型	描述
`request`	`HttpServletRequest`	封装客户端的请求信息
`response`	`HttpServletResponse`	用于向客户端发送响应
`out`	`JspWriter`	用于向客户端输出HTML内容
`session`	`HttpSession`	存储用户会话信息
`application`	`ServletContext`	代表整个Web应用的上下文信息
`config`	`ServletConfig`	获取JSP的初始化参数
`pageContext`	`PageContext`	提供对JSP页面所有对象和命名空间的访问
`page`	`Object`	指向当前JSP页面本身（即this）
`exception`	`Throwable`	处理JSP页面中发生的异常（仅在错误页面中可用）

示例代码：使用 `session` 对象存储用户信息

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%
    session.setAttribute("user", "张三");
%>
<html>
<head><title>Session示例</title></head>
<body>
    <h2>当前用户：<%= session.getAttribute("user") %></h2>
</body>
</html>

参数说明与逻辑分析：

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

3.2 JSP在CRM系统前端展示中的应用

3.2.1 动态数据绑定与页面跳转

在CRM系统中，前端页面需要根据不同的业务逻辑动态展示数据，如客户列表、员工信息、订单状态等。JSP通过结合Java代码和HTML标签，实现动态数据绑定与页面跳转。

示例：从员工列表跳转到详情页

员工列表页（employeeList.jsp）

<%@ page import="java.util.List, com.crm.model.Employee" %>
<%
    List<Employee> employees = (List<Employee>) request.getAttribute("employees");
%>
<table border="1">
    <tr><th>ID</th><th>姓名</th><th>职位</th><th>操作</th></tr>
    <% for (Employee emp : employees) { %>
    <tr>
        <td><%= emp.getId() %></td>
        <td><%= emp.getName() %></td>
        <td><%= emp.getPosition() %></td>
        <td><a href="employeeDetail.jsp?id=<%= emp.getId() %>">查看详情</a></td>
    </tr>
    <% } %>
</table>

员工详情页（employeeDetail.jsp）

<%
    String id = request.getParameter("id");
    // 模拟数据库查询
    Employee emp = EmployeeDAO.findById(id);
%>
<h2>员工详情</h2>
<p>ID: <%= emp.getId() %></p>
<p>姓名: <%= emp.getName() %></p>
<p>职位: <%= emp.getPosition() %></p>

逻辑分析：

列表页通过 request.getAttribute("employees") 获取员工集合。
每个员工记录生成一个超链接，传递员工ID到详情页。
详情页通过 request.getParameter("id") 获取ID并模拟查询展示。

3.2.2 使用JSTL和EL表达式简化开发

JSTL（JSP标准标签库）与EL（Expression Language）表达式是JSP中用于替代Java脚本、提升可读性和可维护性的利器。

示例：使用JSTL遍历员工列表

首先需在JSP头部引入JSTL核心标签库：

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

然后在页面中使用：

<table border="1">
    <tr><th>ID</th><th>姓名</th><th>职位</th></tr>
    <c:forEach items="${employees}" var="emp">
        <tr>
            <td>${emp.id}</td>
            <td>${emp.name}</td>
            <td>${emp.position}</td>
        </tr>
    </c:forEach>
</table>

参数说明：

items="${employees}" ：指定遍历的数据源。
var="emp" ：定义当前遍历项的变量名。
${emp.id} ：使用EL表达式获取属性值。

3.3 JSP页面与后端交互设计

3.3.1 表单提交与数据接收

在CRM系统中，用户常通过表单提交数据，如员工信息录入、客户添加等。JSP页面负责表单展示，Servlet处理提交数据。

示例：员工信息录入表单（addEmployee.jsp）

<form action="AddEmployeeServlet" method="post">
    姓名：<input type="text" name="name"><br>
    职位：<input type="text" name="position"><br>
    部门：<input type="text" name="department"><br>
    <input type="submit" value="提交">
</form>

对应Servlet处理类（AddEmployeeServlet.java）

@WebServlet("/AddEmployeeServlet")
public class AddEmployeeServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.setCharacterEncoding("UTF-8");
        String name = request.getParameter("name");
        String position = request.getParameter("position");
        String department = request.getParameter("department");

        // 模拟保存到数据库
        EmployeeDAO.save(new Employee(name, position, department));

        response.sendRedirect("employeeList.jsp");
    }
}

逻辑分析：

表单使用 POST 方法提交至 AddEmployeeServlet 。
Servlet通过 request.getParameter() 获取表单数据。
数据处理完成后重定向至员工列表页。

3.3.2 页面数据的动态加载与异步请求

在现代Web开发中，异步加载（AJAX）是提升用户体验的重要手段。在CRM系统中，JSP页面可以结合JavaScript和Servlet实现动态数据加载。

示例：使用AJAX加载客户信息

前端页面（customer.jsp）

<script>
    function loadCustomer(id) {
        var xhr = new XMLHttpRequest();
        xhr.onreadystatechange = function() {
            if (xhr.readyState == 4 && xhr.status == 200) {
                document.getElementById("customerInfo").innerHTML = xhr.responseText;
            }
        };
        xhr.open("GET", "CustomerServlet?id=" + id, true);
        xhr.send();
    }
</script>

<button onclick="loadCustomer(1)">加载客户1信息</button>
<div id="customerInfo"></div>

后端Servlet（CustomerServlet.java）

@WebServlet("/CustomerServlet")
public class CustomerServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String id = request.getParameter("id");
        Customer customer = CustomerDAO.findById(id);
        response.setContentType("text/html;charset=UTF-8");
        response.getWriter().write("<p>ID: " + customer.getId() + "</p>");
        response.getWriter().write("<p>名称: " + customer.getName() + "</p>");
    }
}

逻辑分析：

用户点击按钮后，JavaScript发起AJAX请求。
Servlet根据ID查询客户信息，并将HTML片段返回。
前端页面通过 innerHTML 动态更新内容。

小结与后续章节关联

本章系统讲解了JSP在CRM系统中的应用方式，包括其生命周期、内置对象、页面动态展示、表单交互及异步加载技术。通过代码示例，展示了如何在实际开发中结合JSP与Servlet完成前后端交互。下一章将深入探讨Servlet的请求处理机制与业务逻辑实现，进一步完善CRM系统的后端处理能力。

4. Servlet请求处理与业务逻辑实现

Servlet作为Java Web开发中的核心组件之一，承担着处理HTTP请求、业务逻辑处理和响应生成的职责。在CRM系统的开发中，Servlet不仅负责接收来自客户端的请求，还需完成数据的验证、处理与转发，以及与JSP页面的协同工作。本章将深入剖析Servlet的基本原理、生命周期、线程安全机制，以及其在CRM系统中的实际应用，包括请求分发、权限控制、与JSP协作等内容。

4.1 Servlet的基本原理与配置

4.1.1 Servlet生命周期与线程安全

Servlet是运行在Web服务器上的Java类，用于处理HTTP请求。它具有明确的生命周期，主要包括三个阶段：加载与初始化、服务请求、销毁。

初始化阶段（init） ：当Servlet第一次被请求时，Servlet容器（如Tomcat）会调用 init(ServletConfig) 方法进行初始化。此阶段通常用于加载配置文件、连接数据库等操作。
服务阶段（service） ：每当有HTTP请求到达Servlet时，容器会调用 service(HttpServletRequest, HttpServletResponse) 方法，根据请求类型（GET、POST等）调用相应的 doGet() 或 doPost() 方法。
销毁阶段（destroy） ：当服务器关闭或Servlet被卸载时，调用 destroy() 方法释放资源。

由于Servlet默认是单例的，多个线程共享同一个Servlet实例，因此必须注意线程安全问题。例如，如果在Servlet中使用了类成员变量来保存请求相关的数据，就可能导致线程间数据混乱。解决方案包括：

使用局部变量代替成员变量
使用 HttpSession 对象保存用户状态
使用线程安全的数据结构或同步机制（如 synchronized 关键字）

代码示例：Servlet线程安全问题演示

@WebServlet("/counter")
public class CounterServlet extends HttpServlet {
    private int count = 0;  // 共享变量，存在线程安全问题

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        count++;
        response.getWriter().write("访问次数：" + count);
    }
}

逻辑分析与参数说明：

count 是类成员变量，多个线程同时访问会引发数据竞争。
每次请求都会递增 count ，但并发访问时可能导致计数错误。
为解决该问题，可使用 synchronized 方法或使用 AtomicInteger 。

优化后的线程安全版本：

@WebServlet("/counter")
public class CounterServlet extends HttpServlet {
    private AtomicInteger count = new AtomicInteger(0);  // 线程安全的原子整型

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        int current = count.incrementAndGet();
        response.getWriter().write("访问次数：" + current);
    }
}

4.1.2 web.xml配置文件详解

虽然现代Java Web项目中常使用注解（如 @WebServlet ）进行Servlet配置，但 web.xml 文件依然是传统项目中不可或缺的配置方式。该文件位于 WEB-INF 目录下，用于定义Servlet、过滤器、监听器等核心组件。

典型配置示例：

<servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.crm.servlet.LoginServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/login</url-pattern>
</servlet-mapping>

参数说明：

<servlet> ：定义一个Servlet，指定其名称和类路径。
<servlet-mapping> ：将Servlet与URL路径绑定，客户端通过该路径访问Servlet。
可配置初始化参数 <init-param> ，用于传递配置信息。

使用场景分析：

在CRM系统中，某些Servlet可能需要在初始化阶段加载特定的配置参数，例如数据库连接信息或系统路径。例如：

<servlet>
    <servlet-name>InitServlet</servlet-name>
    <servlet-class>com.crm.servlet.InitServlet</servlet-class>
    <init-param>
        <param-name>adminEmail</param-name>
        <param-value>admin@crm.com</param-value>
    </init-param>
</servlet>

在Servlet中可通过 getServletConfig().getInitParameter("adminEmail") 获取该参数。

4.2 CRM系统中的请求分发与处理机制

4.2.1 请求路径映射与控制器设计

在CRM系统中，为了提高代码的可维护性和可扩展性，通常会采用“控制器+服务层+DAO层”的结构，而Servlet则作为前端控制器（Front Controller）来统一处理所有请求。

请求分发流程图（Mermaid）：

graph TD
    A[客户端请求] --> B(Servlet控制器)
    B --> C{请求路径解析}
    C -->|/login| D[调用LoginService]
    C -->|/dashboard| E[调用DashboardService]
    C -->|其他路径| F[返回404错误]
    D --> G[返回响应或跳转JSP]
    E --> G
    F --> G

控制器示例代码：

@WebServlet("*.do")
public class DispatcherServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        String path = request.getServletPath();
        switch (path) {
            case "/login.do":
                new LoginController().handle(request, response);
                break;
            case "/dashboard.do":
                new DashboardController().handle(request, response);
                break;
            default:
                response.sendError(HttpServletResponse.SC_NOT_FOUND);
        }
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
        doGet(request, response);
    }
}

逻辑分析与参数说明：

使用通配符 *.do 匹配所有以 .do 结尾的请求路径。
根据路径调用不同的控制器处理逻辑，避免多个Servlet的重复定义。
控制器解耦后，便于后期扩展和维护。

4.2.2 使用Filter实现权限控制

在CRM系统中，权限控制是关键环节。通过Filter可以实现对请求的统一拦截，判断用户是否已登录、是否有权限访问特定资源。

Filter执行流程图（Mermaid）：

graph LR
    A[请求到达Filter] --> B{是否已登录?}
    B -->|是| C[放行请求]
    B -->|否| D[重定向到登录页]

Filter示例代码：

@WebFilter("/*")
public class AuthFilter implements Filter {
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        HttpServletResponse res = (HttpServletResponse) response;

        String uri = req.getRequestURI();

        // 白名单路径无需登录
        if (uri.endsWith("login.jsp") || uri.contains("/login.do")) {
            chain.doFilter(request, response);
            return;
        }

        // 判断是否登录
        HttpSession session = req.getSession(false);
        if (session != null && session.getAttribute("user") != null) {
            chain.doFilter(request, response);
        } else {
            res.sendRedirect("login.jsp");
        }
    }
}

逻辑分析与参数说明：

@WebFilter("/*") 表示拦截所有请求。
使用 request.getRequestURI() 获取当前请求路径。
通过 session.getAttribute("user") 判断是否已登录。
白名单机制确保登录页面和登录接口不受拦截。

4.3 Servlet与JSP的协作模式

4.3.1 数据流转与页面跳转控制

Servlet与JSP的协作是Java Web开发中常见的模式。Servlet负责处理业务逻辑并准备数据，然后通过请求转发或重定向将结果传递给JSP页面进行展示。

Servlet转发数据给JSP的流程图（Mermaid）：

graph TD
    A[Servlet处理请求] --> B[准备数据]
    B --> C[将数据存入request或session]
    C --> D[请求转发至JSP]
    D --> E[JSP渲染页面并返回]

示例代码：

@WebServlet("/user/list")
public class UserListServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<User> userList = UserService.getAllUsers();  // 获取用户列表
        request.setAttribute("users", userList);  // 将数据存入request
        request.getRequestDispatcher("/userList.jsp").forward(request, response);  // 转发至JSP
    }
}

逻辑分析与参数说明：

request.setAttribute("users", userList) 将用户列表存入请求对象。
getRequestDispatcher("/userList.jsp").forward() 实现页面转发。
JSP页面可通过EL表达式 ${users} 访问该数据。

4.3.2 错误处理与日志记录

在CRM系统中，良好的错误处理机制和日志记录是保障系统稳定性的关键。Servlet可以通过捕获异常、记录日志并返回友好的错误页面，提升用户体验。

日志记录与错误处理流程图（Mermaid）：

graph TD
    A[Servlet处理请求] --> B{是否发生异常?}
    B -->|是| C[记录日志]
    C --> D[转发至错误页面]
    B -->|否| E[正常返回响应]

代码示例：

@WebServlet("/editUser")
public class EditUserServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        try {
            String userId = request.getParameter("id");
            User user = UserService.getUserById(userId);
            request.setAttribute("user", user);
            request.getRequestDispatcher("/editUser.jsp").forward(request, response);
        } catch (Exception e) {
            // 记录日志
            Logger logger = Logger.getLogger(EditUserServlet.class.getName());
            logger.log(Level.SEVERE, "编辑用户失败", e);
            // 转发错误信息
            request.setAttribute("errorMsg", "无法加载用户信息，请稍后再试。");
            request.getRequestDispatcher("/error.jsp").forward(request, response);
        }
    }
}

逻辑分析与参数说明：

使用 try-catch 块捕获可能出现的异常。
使用 java.util.logging.Logger 记录错误日志。
设置错误信息并转发至统一的错误页面 error.jsp 。

错误页面（error.jsp）示例：

<%@ page contentType="text/html;charset=UTF-8" %>
<html>
<head>
    <title>错误页面</title>
</head>
<body>
    <h2>系统发生错误</h2>
    <p>${errorMsg}</p>
</body>
</html>

本章通过深入分析Servlet的基本原理、生命周期、配置方式、请求分发机制、权限控制实现、与JSP的协作模式等内容，全面展示了Servlet在CRM系统中的核心作用。通过合理的架构设计和代码实现，可以有效提升系统的稳定性、可维护性与用户体验。

5. MySQL数据库设计与管理

数据库是CRM系统的核心数据支撑，MySQL作为开源关系型数据库的代表，广泛应用于中小型系统的数据存储与管理中。本章将围绕MySQL在CRM系统中的作用、数据库设计规范以及连接与访问方式展开深入分析，帮助开发者构建高效、安全且易于维护的数据库架构。

5.1 MySQL数据库在CRM系统中的作用

MySQL在CRM系统中扮演着核心数据存储与处理的角色。其优势在于开源、轻量、易部署，并支持高并发访问与事务处理。

5.1.1 数据存储与关系管理

在CRM系统中，客户、联系人、订单、员工、权限等数据之间存在复杂的关联关系。MySQL通过 表结构设计 与 外键约束 实现数据的规范化管理。

例如，员工表（ employee ）与部门表（ department ）之间的关系可以通过外键进行绑定：

CREATE TABLE department (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100) NOT NULL
);

CREATE TABLE employee (
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(100),
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES department(id)
);

department_id 作为外键，指向 department.id ，保证数据完整性。
外键约束防止插入无效的部门ID，也避免了“孤儿”数据的存在。

此外，通过索引优化查询效率，尤其在频繁访问的字段（如客户ID、订单编号等）上创建索引，可显著提升查询速度。

5.1.2 数据安全与事务控制

CRM系统涉及大量敏感数据，如客户信息、交易记录、员工权限等。MySQL提供多种机制保障数据安全：

事务控制（Transaction Control）

MySQL支持事务（Transaction），确保多条SQL语句要么全部执行成功，要么全部回滚。这对于订单创建、客户信息修改等操作至关重要。

START TRANSACTION;

-- 插入客户信息
INSERT INTO customer (name, email) VALUES ('张三', 'zhangsan@example.com');

-- 插入订单信息
INSERT INTO order (customer_id, product_id) VALUES (LAST_INSERT_ID(), 1001);

-- 提交事务
COMMIT;

START TRANSACTION 开启事务。
若任何一步出错，使用 ROLLBACK 回滚整个事务。
COMMIT 提交事务，确保数据一致性。

数据权限管理

MySQL通过用户权限管理机制，限制不同角色对数据库的访问级别。例如：

-- 创建只读用户
CREATE USER 'readonly_user'@'%' IDENTIFIED BY 'password';
GRANT SELECT ON crm_db.* TO 'readonly_user'@'%';

GRANT SELECT 仅授予查询权限，防止误删或误改数据。
在CRM系统中，可以为不同用户组分配不同权限，如销售员仅能查看客户信息，管理员可进行增删改操作。

5.2 数据库表结构设计规范

良好的数据库设计是系统稳定性和扩展性的基础。CRM系统中数据模型复杂，设计时应遵循一定的规范。

5.2.1 表命名与字段设计原则

命名规范

表名使用小写字母，多个单词用下划线连接（如 customer_order ）。
主键字段 统一使用 id 。
逻辑删除字段 使用 is_deleted 或 status 。

表名	说明
customer	客户信息表
contact	客户联系人表
employee	员工信息表
department	部门信息表
role	角色权限表

字段设计原则

所有字段尽量设置为 NOT NULL ，除非明确允许为空。
使用合适的数据类型：
客户ID、员工ID使用 INT 或 BIGINT 。
姓名、地址使用 VARCHAR ，长度根据实际需求设置。
创建时间、更新时间使用 DATETIME 或 TIMESTAMP 。
添加字段注释，便于后期维护：

CREATE TABLE customer (
    id INT PRIMARY KEY AUTO_INCREMENT COMMENT '客户ID',
    name VARCHAR(100) NOT NULL COMMENT '客户名称',
    phone VARCHAR(20) COMMENT '联系电话',
    created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间'
);

5.2.2 外键约束与索引优化

外键约束

外键确保表间数据一致性，避免出现“脏数据”。例如客户订单表中，必须确保客户ID存在：

ALTER TABLE orders
ADD CONSTRAINT fk_customer
FOREIGN KEY (customer_id) REFERENCES customer(id);

索引优化

索引是提升查询效率的重要手段，但在频繁更新的字段上建立索引会影响性能。常见策略如下：

主键自动建立聚簇索引 。
对频繁查询字段建立 非聚簇索引 ，如 customer.email 。
对组合查询字段使用 联合索引 ，如 (customer_id, product_id) 。
避免对频繁更新字段建立索引。

示例：为 email 字段添加索引

CREATE INDEX idx_email ON customer(email);

5.3 数据库连接与访问方式

在Java Web项目中，CRM系统通常通过JDBC与MySQL数据库进行交互。为了提高性能与资源利用率，还需引入连接池技术。

5.3.1 JDBC连接MySQL数据库

JDBC（Java Database Connectivity）是Java连接数据库的标准接口。以下是一个使用JDBC连接MySQL并执行查询的示例：

import java.sql.*;

public class DBConnection {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/crm_db?useSSL=false&serverTimezone=UTC";
        String user = "root";
        String password = "123456";

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

            while (rs.next()) {
                System.out.println("客户ID: " + rs.getInt("id") + ", 名称: " + rs.getString("name"));
            }

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

代码解读与逻辑分析：

url ：连接地址，包含主机、端口、数据库名及参数（如时区）。
DriverManager.getConnection() ：建立数据库连接。
Statement ：用于执行SQL语句。
ResultSet ：保存查询结果集。
使用 try-with-resources 自动关闭资源，防止内存泄漏。

参数说明：

参数	说明
useSSL=false	禁用SSL加密连接，用于本地开发
serverTimezone=UTC	设置服务器时区，避免时区差异问题

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

频繁创建与关闭数据库连接会消耗大量资源，影响系统性能。使用连接池技术可以复用连接，提高访问效率。

使用 Druid 连接池的配置示例：

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.InputStream;
import java.sql.Connection;
import java.util.Properties;

public class DruidUtil {
    private static DataSource dataSource;

    static {
        try {
            Properties props = new Properties();
            InputStream in = DruidUtil.class.getClassLoader().getResourceAsStream("druid.properties");
            props.load(in);
            dataSource = DruidDataSourceFactory.createDataSource(props);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws Exception {
        return dataSource.getConnection();
    }
}

druid.properties 配置文件内容：

url=jdbc:mysql://localhost:3306/crm_db?useSSL=false&serverTimezone=UTC
username=root
password=123456
driverClassName=com.mysql.cj.jdbc.Driver
initialSize=5
minIdle=5
maxActive=20
maxWait=60000

使用流程图（Mermaid格式）：

graph TD
A[获取连接] --> B{连接池是否空}
B -- 是 --> C[创建新连接]
B -- 否 --> D[复用已有连接]
C --> E[加入连接池]
D --> F[执行SQL]
F --> G[释放连接回池]

代码逻辑分析：

使用 DruidDataSourceFactory 根据配置文件创建连接池。
getConnection() 方法从池中获取连接。
配置参数控制连接池大小与超时时间，优化系统资源使用。
使用连接池后，系统响应速度提升，资源利用率更高。

小结

本章详细阐述了MySQL数据库在CRM系统中的关键作用，包括数据存储、关系管理、事务控制、安全性保障等。同时，我们深入讲解了数据库设计的规范，如表命名、字段类型选择、外键与索引设计。最后，结合Java项目，演示了JDBC连接MySQL数据库的方式，并引入了Druid连接池技术，以提高数据库访问性能和资源利用率。

这些内容为CRM系统的数据库架构打下坚实基础，也为后续的SQL操作、模块开发提供了良好的支撑。

6. SQL文件初始化与数据操作

在现代Web应用中，数据库是系统的核心组成部分之一，负责数据的持久化、查询、更新等关键操作。对于CRM系统而言，数据库不仅存储客户、员工、订单等核心数据，还承担着业务逻辑的支撑任务。SQL文件作为数据库初始化和数据操作的基础工具，在系统部署和开发调试过程中发挥着不可替代的作用。

本章将深入探讨SQL脚本的编写与执行机制，介绍数据库操作在系统中的集成方式，并重点分析SQL注入攻击的防护策略。通过本章内容，读者将掌握如何高效、安全地完成数据库的初始化与数据操作，为系统的稳定运行打下坚实基础。

6.1 SQL脚本的编写与执行

SQL脚本是用于操作数据库的一系列SQL语句集合，通常以 .sql 为扩展名。它们在系统部署时用于初始化数据库结构和测试数据，是系统快速搭建和数据准备的重要手段。

6.1.1 初始化数据库表结构

在CRM系统中，数据库表结构的设计直接决定了系统的可扩展性与数据一致性。通常，初始化SQL脚本中包含多个 CREATE TABLE 语句，用于创建表及其约束条件。

以下是一个典型的数据库初始化SQL脚本示例，用于创建CRM系统中的客户信息表：

-- 创建客户信息表
CREATE TABLE IF NOT EXISTS customers (
    customer_id INT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE,
    phone VARCHAR(20),
    address TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

代码逻辑分析：

CREATE TABLE IF NOT EXISTS customers ：如果表不存在则创建，避免重复执行导致错误。
customer_id INT AUTO_INCREMENT PRIMARY KEY ：设置自增主键，确保每条记录唯一。
name VARCHAR(100) NOT NULL ：客户名称为必填字段。
email VARCHAR(100) UNIQUE ：邮箱地址唯一，防止重复注册。
phone VARCHAR(20) ：电话字段，长度适中。
address TEXT ：地址字段，适用于较长文本。
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ：记录创建时间，默认为当前时间。
ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ：使用InnoDB引擎和utf8mb4字符集，支持中文和表情符号。

6.1.2 插入测试数据与约束设置

为了验证系统的数据操作逻辑，初始化脚本中通常还包含插入测试数据的语句。例如：

-- 插入测试客户数据
INSERT INTO customers (name, email, phone, address)
VALUES
    ('张三', 'zhangsan@example.com', '13800001111', '北京市朝阳区'),
    ('李四', 'lisi@example.com', '13900002222', '上海市浦东新区'),
    ('王五', 'wangwu@example.com', '13700003333', '广州市天河区');

代码逻辑分析：

使用 INSERT INTO 语句批量插入测试数据。
每条记录对应一个客户，包含姓名、邮箱、电话和地址字段。
不指定 customer_id 和 created_at 字段，由数据库自动填充。

此外，为确保数据完整性，还可以在脚本中添加外键约束：

-- 创建订单表并添加外键
CREATE TABLE orders (
    order_id INT AUTO_INCREMENT PRIMARY KEY,
    customer_id INT,
    product_name VARCHAR(100),
    amount DECIMAL(10,2),
    order_date DATE,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

约束说明：

FOREIGN KEY (customer_id) REFERENCES customers(customer_id) ：确保订单表中的客户ID必须存在于客户表中，防止出现无效引用。

6.2 数据库操作在系统中的集成

SQL脚本虽然在初始化阶段非常有用，但在实际系统运行中，数据操作通常通过Java代码与数据库进行交互。CRM系统通常使用JDBC或ORM框架（如MyBatis、Hibernate）来完成数据库操作。

6.2.1 数据查询与展示

数据查询是CRM系统中最常见的操作之一。例如，查询客户列表并展示在前端页面上。

以下是一个使用JDBC进行数据查询的Java代码示例：

public List<Customer> getAllCustomers() {
    List<Customer> customers = new ArrayList<>();
    String sql = "SELECT * FROM customers";

    try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
         Statement stmt = conn.createStatement();
         ResultSet rs = stmt.executeQuery(sql)) {

        while (rs.next()) {
            Customer customer = new Customer();
            customer.setId(rs.getInt("customer_id"));
            customer.setName(rs.getString("name"));
            customer.setEmail(rs.getString("email"));
            customer.setPhone(rs.getString("phone"));
            customer.setAddress(rs.getString("address"));
            customer.setCreatedAt(rs.getTimestamp("created_at"));
            customers.add(customer);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }

    return customers;
}

代码逻辑分析：

使用 DriverManager.getConnection() 获取数据库连接。
执行 SELECT * FROM customers 查询所有客户数据。
遍历 ResultSet ，将每条记录映射为 Customer 对象。
使用 try-with-resources 确保资源自动关闭，避免内存泄漏。

6.2.2 数据更新与事务处理

在CRM系统中，数据更新操作通常涉及多个表的修改，因此需要使用事务来确保数据一致性。

以下是一个使用事务处理的Java代码示例：

public boolean updateCustomerAndOrder(int customerId, String newEmail, String newProduct) {
    String updateCustomerSql = "UPDATE customers SET email = ? WHERE customer_id = ?";
    String updateOrderSql = "UPDATE orders SET product_name = ? WHERE customer_id = ?";

    try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD)) {
        conn.setAutoCommit(false); // 开启事务

        try (PreparedStatement ps1 = conn.prepareStatement(updateCustomerSql)) {
            ps1.setString(1, newEmail);
            ps1.setInt(2, customerId);
            ps1.executeUpdate();
        }

        try (PreparedStatement ps2 = conn.prepareStatement(updateOrderSql)) {
            ps2.setString(1, newProduct);
            ps2.setInt(2, customerId);
            ps2.executeUpdate();
        }

        conn.commit(); // 提交事务
        return true;
    } catch (SQLException e) {
        e.printStackTrace();
        try {
            if (conn != null) conn.rollback(); // 回滚事务
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        return false;
    }
}

代码逻辑分析：

使用 conn.setAutoCommit(false) 开启事务。
分别执行两个更新操作：客户信息更新和订单信息更新。
如果任一操作失败，调用 conn.rollback() 回滚整个事务。
成功则调用 conn.commit() 提交事务。

6.3 SQL注入防护与安全编码

SQL注入是Web应用中最常见的安全漏洞之一，攻击者通过构造恶意输入绕过正常查询逻辑，甚至获取数据库权限。因此，SQL注入防护是系统安全设计的重要组成部分。

6.3.1 使用预编译语句防止攻击

使用预编译语句（PreparedStatement）是防止SQL注入的核心手段。相比字符串拼接方式，预编译可以将用户输入视为参数，而非可执行SQL代码。

以下是一个使用 PreparedStatement 的安全查询示例：

public Customer getCustomerByEmail(String email) {
    String sql = "SELECT * FROM customers WHERE email = ?";
    try (Connection conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
         PreparedStatement ps = conn.prepareStatement(sql)) {

        ps.setString(1, email);
        ResultSet rs = ps.executeQuery();

        if (rs.next()) {
            Customer customer = new Customer();
            customer.setId(rs.getInt("customer_id"));
            customer.setName(rs.getString("name"));
            customer.setEmail(rs.getString("email"));
            customer.setPhone(rs.getString("phone"));
            customer.setAddress(rs.getString("address"));
            customer.setCreatedAt(rs.getTimestamp("created_at"));
            return customer;
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return null;
}

安全性分析：

使用 PreparedStatement 替代 Statement ，防止SQL注入。
ps.setString(1, email) 将用户输入作为参数传递，而非直接拼接到SQL语句中。

6.3.2 参数校验与输入过滤

除了使用预编译语句外，还应对用户输入进行严格的校验与过滤，进一步提升安全性。

以下是一个输入校验的Java工具类示例：

public class InputValidator {
    public static boolean isValidEmail(String email) {
        String emailRegex = "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
        return email != null && email.matches(emailRegex);
    }

    public static String sanitizeInput(String input) {
        if (input == null) return null;
        return input.replaceAll("[';]", ""); // 过滤单引号和分号
    }
}

代码逻辑分析：

isValidEmail() ：使用正则表达式验证邮箱格式。
sanitizeInput() ：对输入字符串进行清理，过滤特殊字符，防止注入攻击。

本章小结（仅作为总结，不计入内容要求）

本章系统性地介绍了SQL文件在CRM系统中的作用，包括数据库初始化、数据操作集成以及SQL注入防护等内容。通过编写结构清晰的SQL脚本、集成Java代码实现高效查询与更新操作，并采用预编译语句与输入校验相结合的方式，保障了系统的安全性与稳定性。这些内容为后续模块开发提供了坚实的技术支撑。

7. 员工信息管理模块设计与实现

员工信息管理模块是CRM系统中基础且核心的功能之一，主要用于维护企业员工的基本信息、权限配置和状态管理。该模块的实现不仅关系到系统的可用性，也对后续权限控制、用户行为日志等模块产生深远影响。

7.1 模块功能需求与业务流程

7.1.1 员工信息的增删改查功能

员工信息模块的核心功能包括：新增员工、查看员工列表、编辑员工信息以及删除员工记录。这些功能需要通过前端界面与后端逻辑协同完成。

新增员工 ：填写员工基础信息（如姓名、账号、密码、所属部门、角色权限等），提交后将信息写入数据库。
查看员工 ：根据权限展示所有或部分员工信息，支持分页、搜索和筛选。
编辑员工 ：支持对员工信息进行修改，如调整角色、更新联系方式等。
删除员工 ：逻辑删除或物理删除员工记录，通常采用逻辑删除以保留历史数据。

7.1.2 权限分配与状态管理

系统需支持为员工分配不同角色权限（如管理员、销售、客服等），并实现员工状态的管理，如“在职”、“离职”、“停用”等。

权限分配 ：通过角色绑定权限，实现基于RBAC（基于角色的访问控制）的权限模型。
状态管理 ：员工状态直接影响其能否登录系统，后端需在登录验证时进行判断。

7.2 后端代码实现与数据库交互

7.2.1 DAO模式的设计与实现

在Java Web系统中，DAO（Data Access Object）模式用于封装对数据库的访问操作。以下是一个员工信息DAO接口的示例：

public interface EmployeeDAO {
    // 新增员工
    int insert(Employee employee);
    // 查询所有员工
    List<Employee> selectAll();
    // 根据ID查询员工
    Employee selectById(int id);
    // 更新员工信息
    int update(Employee employee);
    // 删除员工（逻辑删除）
    int deleteById(int id);
}

对应的实现类中，使用JDBC进行数据库操作：

public class EmployeeDAOImpl implements EmployeeDAO {
    private Connection connection;

    public EmployeeDAOImpl(Connection connection) {
        this.connection = connection;
    }

    @Override
    public int insert(Employee employee) {
        String sql = "INSERT INTO employees (name, username, password, department_id, role_id, status) VALUES (?, ?, ?, ?, ?, ?)";
        try (PreparedStatement stmt = connection.prepareStatement(sql)) {
            stmt.setString(1, employee.getName());
            stmt.setString(2, employee.getUsername());
            stmt.setString(3, employee.getPassword());
            stmt.setInt(4, employee.getDepartmentId());
            stmt.setInt(5, employee.getRoleId());
            stmt.setString(6, employee.getStatus());
            return stmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
    // 其他方法省略
}

7.2.2 使用Service层封装业务逻辑

Service层用于封装业务逻辑，调用DAO层实现具体操作。例如：

public class EmployeeService {
    private EmployeeDAO employeeDAO;

    public EmployeeService(EmployeeDAO employeeDAO) {
        this.employeeDAO = employeeDAO;
    }

    public boolean addEmployee(Employee employee) {
        return employeeDAO.insert(employee) > 0;
    }

    public List<Employee> getAllEmployees() {
        return employeeDAO.selectAll();
    }

    public boolean updateEmployee(Employee employee) {
        return employeeDAO.update(employee) > 0;
    }

    public boolean deleteEmployee(int id) {
        return employeeDAO.deleteById(id) > 0;
    }
}

7.3 前端页面展示与用户交互

7.3.1 页面布局与数据绑定

使用JSP和JSTL实现员工列表页面的展示。页面结构如下：

<table class="table table-bordered">
    <thead>
        <tr>
            <th>ID</th>
            <th>姓名</th>
            <th>用户名</th>
            <th>部门</th>
            <th>角色</th>
            <th>状态</th>
            <th>操作</th>
        </tr>
    </thead>
    <tbody>
        <c:forEach var="emp" items="${employeeList}">
            <tr>
                <td>${emp.id}</td>
                <td>${emp.name}</td>
                <td>${emp.username}</td>
                <td>${emp.departmentName}</td>
                <td>${emp.roleName}</td>
                <td>${emp.status}</td>
                <td>
                    <a href="editEmployee?id=${emp.id}">编辑</a> |
                    <a href="deleteEmployee?id=${emp.id}" onclick="return confirm('确定删除？')">删除</a>
                </td>
            </tr>
        </c:forEach>
    </tbody>
</table>

页面通过Servlet从数据库查询员工列表，并将数据以 request.setAttribute("employeeList", list) 方式传入JSP页面。

7.3.2 表单验证与错误提示机制

在员工信息添加或编辑页面中，前端使用JavaScript进行基本的表单校验，防止用户提交空值或格式错误数据：

<script>
function validateForm() {
    let name = document.forms["employeeForm"]["name"].value;
    let username = document.forms["employeeForm"]["username"].value;
    if (name == "" || username == "") {
        alert("姓名和用户名不能为空");
        return false;
    }
    return true;
}
</script>

<form name="employeeForm" onsubmit="return validateForm()" method="post">
    姓名：<input type="text" name="name"><br>
    用户名：<input type="text" name="username"><br>
    密码：<input type="password" name="password"><br>
    部门：
    <select name="departmentId">
        <!-- 从数据库获取部门列表并填充 -->
    </select><br>
    <input type="submit" value="提交">
</form>

后端Servlet在接收数据后，也会进行二次校验，防止绕过前端验证的情况，同时将错误信息通过request.setAttribute(“error”, “错误信息”)返回页面显示。