Java Web开发基础教程（PDF版）

芝士校园

于 2024-09-24 11:58:39 发布

阅读量1k

点赞数 16

本文链接：https://blog.csdn.net/weixin_42298254/article/details/142527067

版权

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

简介：Java Web开发是使用Java语言进行服务器端Web应用开发的编程分支。本PDF教程为初学者提供全面基础起点，包含Servlet和JSP核心，MVC设计模式，JDBC数据库连接，EJB企业级应用，JPA简化数据库操作，Spring框架，Struts和Hibernate框架，Tomcat和Jetty服务器，前端技术HTML/CSS/JavaScript，以及开发工具Eclipse/IntelliJ IDEA。教程还包括构建CRUD应用、用户注册登录等项目实践，旨在帮助初学者全面掌握Java Web开发技能。 Java Web开发（PDF版）

1. Java Web开发概述

Java Web开发是构建动态网站和网络应用的关键技术之一。自Java推出以来，Java Web领域迅速发展，涌现出了多种技术和框架，这些技术和框架构成了当今企业级应用开发的基石。本章旨在为读者提供Java Web开发的全景图，深入浅出地介绍Java Web开发的核心概念、历史背景以及它在现代IT行业中的应用。

1.1 Java Web开发的起源和演进

Java Web开发的历史可以追溯到1990年代中期，当Java作为一种平台无关的编程语言推出时，它就预示着将来的网络应用开发的变革。Sun Microsystems（现为Oracle Corporation的一部分）推出的Servlet API成为了Java Web应用的基石。随后，为了简化Web开发，JSP（Java Server Pages）技术应运而生，允许开发者在HTML页面中嵌入Java代码。

随着时间的推移，为了更好地解决业务需求和提升开发效率，各种框架如雨后春笋般涌现。从早期的Struts，到后来的Spring MVC、JSF以及各种ORM（对象关系映射）框架如Hibernate，Java Web开发逐渐演化为一个成熟、高效的体系。

1.2 Java Web开发的重要性

Java Web开发的重要性在于其平台独立性和强大的生态系统。Java运行在JVM（Java虚拟机）上，这意味着Java编写的Web应用可以在任何支持Java的操作系统上运行，而无需修改代码。此外，Java的标准化和规范化让Java Web开发成为企业级应用的首选。多样的开源库和框架提供了可重用的组件，使得开发者可以专注于业务逻辑的实现，而不必从零开始。

1.3 Java Web开发的关键技术

要掌握Java Web开发，就必须熟悉几个关键技术：Servlet、JSP、MVC（模型-视图-控制器）设计模式、JDBC（Java数据库连接），以及各种Java Web框架。Servlet是Java Web应用的核心组件，它处理来自客户端的请求，并生成响应。JSP则允许开发者将Java代码嵌入到HTML中，用于生成动态内容。MVC模式是一种组织代码的架构风格，它将应用分为模型（数据）、视图（UI）和控制器（流程控制）。JDBC是连接Java应用程序和数据库的标准API。现代Java Web框架如Spring和Hibernate提供了更加丰富的功能和更高级的抽象，简化了Web应用的开发过程。

本章只是对Java Web开发的一个简单介绍，它为接下来深入学习Servlet和JSP、MVC模式的实现、数据持久层开发以及企业级框架与工具奠定了基础。随着学习的深入，我们将会逐层深入到每项技术的细节中，探索Java Web开发的强大功能和无限可能。

2. Servlet和JSP基础

2.1 Servlet技术的原理和应用

2.1.1 Servlet的工作原理

Servlet是一种Java技术，用于扩展服务器的能力，是一种基于Java的服务器端应用程序，它响应客户端的请求，并返回响应。Servlet的作用类似于传统的CGI技术，但Servlet是运行在服务器端的程序，而不是独立运行的程序。

当Web服务器接收到客户端的请求时，会调用相应的Servlet进行处理。Servlet会根据请求信息生成响应，然后返回给客户端。Servlet的主要任务是生成动态内容，如HTML页面，这些页面会根据客户端的要求和服务器端的数据动态生成。

Servlet运行在Java的Servlet容器中，典型的Servlet容器包括Tomcat和Jetty。Servlet容器负责管理Servlet的生命周期，包括加载Servlet类、创建Servlet实例、调用Servlet的方法来响应请求等。

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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.setCharacterEncoding("UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>Hello, Servlet!</h1>");
        out.println("</body></html>");
    }
}

在上面的示例代码中， HelloServlet 类继承了 HttpServlet 类，并重写了 doGet 方法。当浏览器发送GET请求到服务器时， doGet 方法会被调用。这个方法生成了一个简单的HTML响应，然后返回给请求的客户端。

2.1.2 Servlet的生命周期和线程安全

Servlet的生命周期分为四个主要阶段：加载和实例化、初始化、服务请求、销毁。

加载和实例化 ：Web服务器启动时，根据web.xml文件中定义的Servlet映射信息，加载Servlet类并创建其实例。
初始化 ：通过调用Servlet的 init() 方法完成初始化。在此过程中，Servlet可以加载资源或进行一些初始化操作。
服务请求 ：当有客户端请求到达时，容器调用Servlet的 service() 方法，根据请求类型（GET或POST等）调用相应的 doGet() , doPost() , doPut() 等方法进行处理。
销毁：当Web服务器停止或重新加载时，容器调用 destroy() 方法销毁Servlet实例。

Servlet处理请求是多线程的，每个请求对应一个线程。因此，设计时需要考虑线程安全问题。线程安全的关键在于Servlet内部状态的管理和资源的同步访问。

public class ThreadSafeServlet extends HttpServlet {
    private final String message = "Hello from ThreadSafeServlet";

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>" + message + "</h1>");
    }
}

在上面的线程安全示例中， message 变量被定义为 final ，保证了其不可变性，因此是线程安全的。如果变量不是 final ，则需要考虑其他同步机制来保证线程安全。

2.1.3 Servlet的会话跟踪技术

在Web应用中，经常需要跟踪用户的状态，比如用户的登录信息、购物车内容等。为了管理这些信息，Servlet提供了会话跟踪技术。

Cookie ：Servlet可以通过设置Cookie将信息存储在客户端。当用户再次访问时，浏览器会发送回这些信息，允许Servlet识别用户。
URL重写 ：由于某些浏览器设置或安全策略可能禁用Cookie，URL重写作为一种备选方案，通过将状态信息附加在URL后面来传递给Servlet。
HttpSession ：HttpSession对象是Servlet中管理用户会话的主要方式。每个用户都会分配一个唯一的Session ID，服务器端会通过这个ID来管理会话信息。

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

public class SessionTrackingServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        HttpSession session = request.getSession(true);
        session.setAttribute("user", "JohnDoe");

        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>Welcome, " + session.getAttribute("user") + "!</h1>");
        out.println("</body></html>");
    }
}

在上述代码中，我们通过调用 request.getSession(true) 创建或获取一个会话对象，并将用户信息存储在会话中。用户再次请求时，可以使用相同的会话对象来获取之前存储的信息。

2.2 JSP页面的动态内容生成

2.2.1 JSP的基本语法和指令

JSP（JavaServer Pages）是用于简化Servlet的动态网页创建的技术。JSP页面是HTML文档，但可以包含嵌入式Java代码和JSP指令。JSP在服务器端被编译成Servlet，然后执行生成动态内容。

JSP指令 ：用于设置整个页面的属性，如页面依赖的Java包、缓冲区大小等。常见的JSP指令有 page , include , taglib 。
JSP脚本元素 ：包括声明、表达式和脚本段。声明允许在JSP页面中声明变量和方法。表达式允许插入动态内容到页面中。脚本段允许编写任何有效的Java代码。
JSP动作 ：动作标签用于创建和使用JavaBean，或者执行其他任务。常见的动作包括 useBean , setProperty , getProperty 等。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP示例</title>
</head>
<body>
<%! 
    // 声明部分
    public String getHelloMessage() {
        return "Hello from JSP!";
    }
%>
    <h1><%= getHelloMessage() %></h1>
</body>
</html>

在上面的JSP示例中， <%@ page %> 是一个指令，用于指定页面的内容类型、编码方式和使用的语言（Java）。 <%! %> 声明了公共方法 getHelloMessage ，然后在 <%= %> 表达式中调用该方法并输出结果。

2.2.2 JSP的内置对象和作用域

JSP页面有9个预定义的内置对象，它们可以直接在JSP页面上使用，而无需显式创建。这些对象包括 request , response , out , session , application , config , pageContext , page , exception 。

这些内置对象各自有不同的作用范围：

request ：请求范围，仅在当前请求中有效。
session ：会话范围，维持在用户与服务器之间的一系列请求和响应之间。
application ：应用范围，从服务器启动到服务器关闭期间都有效。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>JSP内置对象</title>
</head>
<body>
    <h1>Session信息：</h1>
    <%
        // 使用session内置对象存储用户信息
        session.setAttribute("user", "JohnDoe");
    %>
    <%= "当前用户：" + session.getAttribute("user") %>
</body>
</html>

在这个例子中，我们使用 session.setAttribute 在会话范围内存储用户信息，并使用 session.getAttribute 在页面中检索并显示当前用户。

2.2.3 JSP与Servlet的交互机制

JSP可以与Servlet配合使用，共同构建复杂的Web应用程序。JSP本质上是Servlet的一个替代或补充。当JSP文件被访问时，它首先被转换为Servlet，然后由容器编译并执行。

Servlet调用JSP ：Servlet可以生成动态内容，并使用 response.setContentType() 和 PrintWriter 输出这些内容。也可以将请求转发到JSP页面进行内容展示。
JSP调用Servlet ：在JSP页面中可以使用 <jsp:forward> 标签将请求转发到Servlet进行处理。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Servlet-JSP交互</title>
</head>
<body>
    <h1>这是一个JSP页面</h1>
    <% 
        // JSP调用Servlet
        RequestDispatcher dispatcher = request.getRequestDispatcher("HelloServlet");
        dispatcher.forward(request, response);
    %>
</body>
</html>

在这个例子中，JSP页面使用 RequestDispatcher 的 forward 方法将请求转发到名为 HelloServlet 的Servlet。随后，Servlet处理该请求并返回响应。

以上就是关于Servlet和JSP的基础知识。在下一篇文章中，我们将深入探讨MVC模式的实践和应用。

3. MVC模式的实践

3.1 MVC设计模式的介绍

3.1.1 MVC模式的组件和职责

MVC（Model-View-Controller）设计模式是一种广泛应用于软件开发中的架构模式，它将应用程序划分为三个主要组成部分，以实现关注点分离（Separation of Concerns）。

Model（模型） ：代表应用程序的数据结构，以及操作这些数据的业务逻辑。模型负责与数据库交互，并将业务逻辑封装起来，不包含任何与显示逻辑相关的内容。

View（视图） ：用于展示数据（Model）给用户。在Web应用中，它通常指的是JSP页面或HTML文档。视图负责接收用户的输入，展示模型的状态。

Controller（控制器） ：作为Model和View之间的协调者。控制器响应用户的输入，调用相应的模型来更新数据，并选择相应的视图来展示数据更新后的结果。

这种分离使得每个部分都相对独立，有助于提高代码的可维护性和可扩展性。开发人员可以专注于应用程序的特定部分，而不必担心其他部分的复杂性。

3.1.2 MVC模式的优势和应用场景

MVC模式的优势在于其清晰的架构和对大型应用程序的适应性。它不仅提高了代码的可维护性，还促进了团队合作，因为不同的开发者可以同时在不同的组件上工作。

该模式非常适合于需要频繁更新用户界面的Web应用程序。由于视图的独立性，可以根据用户需求进行定制和重设计，而不会影响到后端的业务逻辑和数据处理。这也使得单元测试和集成测试更加容易进行，因为可以单独对每个组件进行测试。

MVC模式在Java Web开发中被广泛采用，例如在Spring MVC框架和Struts 2框架中。它们都提供了实现MVC架构的基础设施，开发者只需根据框架提供的API和约定来实现具体的业务逻辑。

3.2 MVC框架的整合与应用

3.2.1 Spring MVC的架构和组件

Spring MVC是一个强大的、灵活的Web框架，它基于Spring框架的依赖注入（DI）和面向切面编程（AOP）能力。Spring MVC框架采用MVC架构，将Web层分成了几个部分：控制器（Controller）、视图解析器（View Resolver）、视图（View）和模型（Model）。

控制器（Controller） ：接收请求，并调用业务逻辑处理数据，然后选择视图。Spring MVC提供了多种注解，如 @RequestMapping 和 @GetMapping ，来简化请求映射到控制器方法的过程。

视图解析器（View Resolver） ：负责解析视图名称并返回对应的视图实例。Spring MVC支持多种视图技术，包括JSP、Thymeleaf等。

视图（View） ：负责渲染模型数据，最终呈现给用户。视图通过模型数据来显示内容，并且通常会返回一个HTML响应给浏览器。

模型（Model） ：包含应用的数据，可以在控制器和视图之间传递。Spring MVC提供了Model对象，允许将数据添加到模型中，并使这些数据在视图中可获取。

3.2.2 案例分析：实现一个简单的MVC应用

为了更好地理解Spring MVC的工作机制，让我们通过一个简单的例子来说明如何搭建一个MVC应用。这个应用将展示一个简单的用户列表。

步骤1：配置DispatcherServlet

首先，需要在 web.xml 中配置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>/WEB-INF/spring-dispatcher-servlet.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>

步骤2：创建Spring MVC的配置文件

在 spring-dispatcher-servlet.xml 文件中配置视图解析器和其他Spring MVC的组件。

<beans xmlns="***"
       xmlns:xsi="***"
       xmlns:context="***"
       xmlns:mvc="***"
       xsi:schemaLocation="
        ***
        ***
        ***
        ***
        ***
        ***">
    <context:component-scan base-package="com.example.mvc" />

    <mvc:annotation-driven />

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

</beans>

步骤3：创建Controller

创建一个控制器类，使用 @Controller 注解，编写方法来处理用户列表的展示逻辑。

@Controller
public class UserController {

    @Autowired
    private UserService userService;

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

步骤4：创建视图

在 /WEB-INF/views/ 目录下创建一个名为 userList.jsp 的JSP文件，用于展示用户列表。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>User List</title>
</head>
<body>
    <table>
        <tr>
            <th>ID</th>
            <th>Name</th>
            <th>Email</th>
        </tr>
        <c:forEach var="user" items="${users}">
            <tr>
                <td>${user.id}</td>
                <td>${user.name}</td>
                <td>${user.email}</td>
            </tr>
        </c:forEach>
    </table>
</body>
</html>

以上步骤演示了一个简单的MVC应用的实现。控制器处理HTTP请求，调用业务层的服务来获取数据，并将数据传递给视图层。然后视图层负责展示数据。这种分层的架构使得代码易于理解和维护。

通过这种实践，可以清晰地看到MVC模式在实际开发中的运用，以及Spring MVC框架是如何帮助开发者快速搭建这种架构的。

4. Java Web数据持久层开发

4.1 JDBC数据库编程的深入解析

Java Database Connectivity（JDBC）是一种Java API，允许应用程序执行SQL语句。它是连接Java应用程序和数据库之间的桥梁，通过提供一个基于标准SQL的公共接口来实现数据库独立操作。在本节中，我们将深入了解JDBC的核心API、连接池、SQL语句执行、事务处理以及数据访问对象（DAO）模式。

4.1.1 JDBC的核心API和连接池

JDBC的核心API由几个主要的接口和类组成：

DriverManager : 负责管理数据库驱动，可以通过它注册驱动或获取数据库连接。
Connection : 表示与数据库的连接，用于执行SQL语句并返回结果。
Statement : 用于执行静态SQL语句并返回它所生成结果的对象。
PreparedStatement : 是 Statement 的子接口，继承了 Statement 的所有功能。它可以通过预设的参数来执行SQL语句，可以防止SQL注入攻击。
ResultSet : 表示数据库查询操作结果的数据表，可以滚动和更新。

在实际生产环境中，连接池是实现JDBC数据库连接管理的一个重要工具。它通过维护一组活跃的数据库连接，来减少数据库连接的开销，提高应用性能。

示例代码如下：

// 使用连接池获取连接
DataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
dataSource.setUrl("jdbc:mysql://localhost:3306/mydatabase");
dataSource.setUsername("user");
dataSource.setPassword("password");
Connection connection = dataSource.getConnection();

// 使用完连接后，需要关闭连接
if (connection != null) {
    connection.close();
}

4.1.2 SQL语句的执行和事务处理

执行SQL语句是数据库操作中的重要环节。在JDBC中，可以通过 Statement 或 PreparedStatement 执行静态或预编译的SQL语句。

事务处理是确保数据库操作的完整性和一致性的重要机制。在JDBC中，可以通过设置 Connection 对象的事务模式来管理事务。

代码示例：

// 开启事务
connection.setAutoCommit(false);
try {
    // 执行多个数据库操作
    PreparedStatement pstmt = connection.prepareStatement("INSERT INTO users VALUES (?, ?)");
    for (User user : users) {
        pstmt.setString(1, user.getUsername());
        pstmt.setString(2, user.getPassword());
        pstmt.executeUpdate();
    }
    // 提交事务
    ***mit();
} catch (Exception e) {
    // 回滚事务
    connection.rollback();
    e.printStackTrace();
} finally {
    // 关闭连接
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

4.1.3 数据访问对象（DAO）模式

数据访问对象（DAO）模式是一种数据访问模式，它允许将数据访问逻辑与业务逻辑分离，从而使得数据访问逻辑可重用并易于测试。

DAO模式通常包括以下几个组件：

Entity : 数据模型，表示数据库中的一个实体。
DAO : 数据访问对象接口，定义了对实体进行CRUD操作的方法。
DAOImpl : 实现DAO接口的具体类，使用JDBC API或其他数据访问技术实现数据操作。

示例代码：

public interface UserDao {
    void insertUser(User user);
    void updateUser(User user);
    void deleteUser(int userId);
    User getUserById(int userId);
    List<User> getAllUsers();
}

public class UserDaoImpl implements UserDao {
    // 使用JDBC API实现数据操作
}

4.2 JPA对象关系映射技术

Java Persistence API（JPA）是一组Java持久化规范，它提供了对象关系映射（ORM）的能力，可以将Java对象映射到关系数据库表。在本节中，我们将探讨JPA的基本概念和架构以及实体和关系映射的配置，还包括JPA查询语言（JPQL）的应用。

4.2.1 JPA的基本概念和架构

JPA的基本概念包括：

实体（Entity） : 代表数据库中表的一个对象。
实体管理器（EntityManager） : 用于管理实体的生命周期，以及执行所有CRUD操作。
实体类（Entity Class） : Java类，对应数据库表中的记录。
持久化上下文（Persistence Context） : 实体和持久化数据之间的中间层。

JPA架构则包括：

持久化单元（Persistence Unit） : 一组持久化属性，定义了实体的数据源和一些其他的配置信息。
持久化提供者（Persistence Provider） : 实现了JPA规范的框架，例如Hibernate或EclipseLink。
对象/关系映射元数据（Object/Relational Mapping Metadata） : 描述Java类和数据库表之间的映射关系。

4.2.2 实体和关系映射的配置

实体通过 @Entity 注解定义，并且每个实体通常对应数据库中的一张表。实体类的属性与数据库表的列通过注解进行映射，例如 @Id 表示主键， @Column 表示列。

例如，一个用户实体可能如下定义：

import javax.persistence.*;

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;

    @Column(name = "username")
    private String username;

    @Column(name = "password")
    private String password;

    // Getters and setters
}

4.2.3 JPA查询语言（JPQL）的应用

JPA提供了自己的查询语言，称为JPA查询语言（JPQL），它是一种面向对象的查询语言，可以查询实体而不仅仅是数据库表。

示例：

// JPQL查询所有用户
String jpqlQuery = "SELECT u FROM User u";
List<User> users = entityManager.createQuery(jpqlQuery, User.class).getResultList();

JPQL除了查询实体外，还可以进行排序、分页等操作。

JPA通过配置文件或注解的方式，可以实现复杂的映射关系和查询优化。作为Java Web开发中数据持久层的一个重要技术，JPA因其提供的ORM能力和对OOP概念的强调，成为许多企业级应用开发的首选。

在深入理解了JDBC和JPA之后，开发人员能够有效地构建数据层逻辑，并且能够根据不同场景选择合适的技术来实现需求。JDBC提供了底层、灵活的数据库操作能力，而JPA提供了高层、面向对象的持久化解决方案。在接下来的章节中，我们将继续探索Java Web开发中企业级框架与工具的使用。

5. Java Web企业级框架与工具

5.1 EJB企业级组件开发

5.1.1 EJB的历史和重要性

EJB（Enterprise JavaBeans）是一种用于开发企业级应用程序的服务器端组件架构，它的发展可以追溯到1990年代末期。EJB规范的出现，旨在为开发可伸缩、安全、事务型的企业应用提供一套标准化的解决方案。EJB容器负责管理EJB组件的生命周期和提供企业级服务，如事务管理、安全性、并发和资源池管理。

5.1.2 无状态会话Bean和有状态会话Bean的开发

在EJB中，主要有两种类型的会话Bean：无状态会话Bean和有状态会话Bean。

无状态会话Bean（Stateless Session Beans） 是指没有会话状态的组件。每次方法调用都是独立的，无需维护客户端的状态。因此，它们可以很容易地进行负载均衡。下面是创建一个无状态会话Bean的简单代码示例：

java @Stateless public class MyServiceBean implements MyService { @Override public String sayHello(String name) { return "Hello " + name; } // 其他业务方法... }

有状态会话Bean（Stateful Session Beans） 用于保持客户端状态。这意味着客户端的每次调用都会发生在同一实例中，因此可以存储和维护状态信息。

一个有状态会话Bean的代码示例如下：

java @Stateful public class MyStatefulSessionBean implements MyStatefulService { private String state; @Override public String takeInput(String input) { state = input; return "Received: " + input; } @Override public String showState() { return state; } // 其他业务方法... }

5.1.3 消息驱动Bean和事务管理

消息驱动Bean（Message-Driven Beans） 是一种特殊类型的EJB，用于处理企业级消息服务（JMS）。它们不直接处理业务逻辑，而是监听消息队列或主题，并根据接收到的消息执行操作。

下面是消息驱动Bean的声明方式：

java @MessageDriven(activationConfig = { @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue") }) public class MyMessageDrivenBean implements MessageListener { @Override public void onMessage(Message message) { // 处理接收到的消息 } }

事务管理 是在EJB中管理业务事务的一种机制。EJB容器可以利用声明式事务控制来自动处理事务，也可以通过编程式事务控制来手动管理事务。

5.2 Spring框架在Java Web中的应用

5.2.1 Spring核心容器的依赖注入（DI）

Spring框架的核心是控制反转（IoC）容器，它管理着应用程序中的对象及其依赖关系。依赖注入（DI）是实现IoC的一种设计模式，它通过构造函数、工厂方法或属性将依赖关系注入到对象中。

依赖注入的类型包括：
构造器注入
设值注入
接口注入

下面是一个使用注解进行设值注入的例子：

java @Service public class MyService { private MyRepository repository; @Autowired public void setRepository(MyRepository repository) { this.repository = repository; } // 业务方法... }

5.2.2 Spring MVC高级配置和拦截器

Spring MVC是Spring框架中用于构建Web应用的模型-视图-控制器（MVC）框架。高级配置允许开发者自定义请求映射、数据绑定、视图解析等。

拦截器（Interceptors） 是一种用于拦截进入控制器的请求并进行处理的组件。它可以用来实现诸如日志记录、权限检查等横切关注点。

下面是一个简单的拦截器实现示例：

java public class MyInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { // 在请求处理之前进行调用（Controller方法调用之前） return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { // 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后） } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { // 在整个请求结束之后被调用，也就是在DispatcherServlet渲染了对应的视图之后执行（主要用于进行资源清理工作） } }

5.2.3 Spring的事务管理机制

Spring提供了对事务管理的强大支持，无论是本地事务还是分布式事务。开发者可以选择声明式事务管理或编程式事务管理。

声明式事务管理 是通过AOP实现，不侵入业务代码，通常通过注解 @Transactional 来配置事务的属性。

示例配置事务管理器：

java @Configuration @EnableTransactionManagement public class TransactionManagementConfig { @Bean public PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(dataSource()); } }

5.3 Struts和Hibernate框架介绍

5.3.1 Struts MVC框架的体系结构

Struts是Apache基金会下的一个开源MVC框架。它的核心是ActionServlet，负责接收HTTP请求并分发给相应的Action类。

体系结构 主要由以下几个部分构成：
Model（模型）：业务逻辑代码和数据模型。
View（视图）：JSP或其他模板技术。
Controller（控制器）：ActionServlet和Action类。

一个简单的Action映射示例：

xml <action name="login" class="com.example.LoginAction" method="execute"> <result name="success">/success.jsp</result> <result name="input">/login.jsp</result> </action>

5.3.2 Hibernate的配置和映射策略

Hibernate是一个对象关系映射（ORM）框架，它简化了数据持久化层的开发。通过使用注解或XML映射文件，开发者可以将Java对象映射到数据库表。

配置主要包含 hibernate.cfg.xml 文件中的数据库连接和Hibernate配置信息。

示例配置文件片段：

xml <hibernate-configuration> <session-factory> <property name="connection.url">jdbc:mysql://localhost:3306/mydb</property> <property name="connection.driver_class">com.mysql.jdbc.Driver</property> <property name="connection.username">root</property> <property name="connection.password">password</property>  </session-factory> </hibernate-configuration>