使用Struts+Spring+Hibernate构建jpetstore实战项目

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

简介：Struts、Spring和Hibernate是Java Web开发中常用的三大框架。本课程将以jpetstore项目为例，详细讲解如何集成这三个框架构建一个完整的MVC架构Web应用程序。涵盖从配置文件管理、实体类设计、数据操作抽象，到服务层逻辑处理以及前端视图展示的完整流程。通过本课程的学习，学员将深入理解框架的协同工作原理，并能够熟练地在实际项目中应用。

1. MVC架构实现

1.1 MVC设计模式概述

MVC（Model-View-Controller，模型-视图-控制器）是一种软件架构模式，主要用于将数据访问层（模型）、用户界面层（视图）和控制逻辑层（控制器）分离，以提高系统的可维护性和可扩展性。在Web应用开发中，这种模式尤其重要，因为它能够将业务逻辑、页面渲染和用户输入分离，使得代码更加模块化和易于管理。

1.2 MVC架构的优点

MVC架构的实现为开发者带来了以下优势： - 低耦合性 ：模型、视图和控制器各自独立，减少了不同组件间的依赖。 - 高重用性和可维护性 ：各个组件分工明确，可以独立修改和重用。 - 灵活性和可扩展性 ：通过添加新的视图和控制器可以轻松扩展应用。

1.3 MVC架构实现的基本步骤

实现MVC架构的基本步骤如下： 1. 定义模型 ：创建与业务数据和业务逻辑对应的类，例如用户、订单等。 2. 设计视图 ：设计用户界面，展示模型数据，并接收用户的输入。 3. 编写控制器 ：控制器接收用户的请求，调用模型层完成业务逻辑处理，并选择视图显示结果。

下面是一个简化的示例代码，展示了如何在Java中实现一个简单的MVC结构：

// Model
public class User {
    private String name;
    private String email;

    // Getters and setters...
}

// View
public class UserView {
    public void printUserInfo(String name, String email) {
        System.out.println("User: " + name + ", Email: " + email);
    }
}

// Controller
public class UserController {
    private User model;
    private UserView view;

    public UserController(User model, UserView view) {
        this.model = model;
        this.view = view;
    }

    public void setUserName(String name) {
        model.setName(name);
    }

    public String getUserName() {
        return model.getName();
    }

    public void setUserEmail(String email) {
        model.setEmail(email);
    }

    public String getUserEmail() {
        return model.getEmail();
    }

    public void updateView() {
        view.printUserInfo(model.getName(), model.getEmail());
    }
}

// Main
public class Main {
    public static void main(String[] args) {
        User model = retrieveUserFromDatabase();
        UserView view = new UserView();
        UserController controller = new UserController(model, view);

        controller.updateView();
        controller.setUserName("John Doe");
        controller.setUserEmail("***");
        controller.updateView();
    }

    private static User retrieveUserFromDatabase() {
        // Mock data retrieval from a database
        User u = new User();
        u.setName("John Doe");
        u.setEmail("***");
        return u;
    }
}

在上述代码中， User 类代表了模型， UserView 类代表了视图，而 UserController 类则是控制器，负责控制数据流向并更新视图。这样，我们就用一个简单的例子说明了MVC架构的实现。

在接下来的章节中，我们将深入探讨MVC架构在实际应用中的详细实现，以及与流行框架Struts、Spring和Hibernate的集成。

2. Struts框架应用

2.1 Struts的基本原理与配置

2.1.1 Struts工作流程解析

Struts框架作为MVC模式的一个实现，它将Web层的业务逻辑、数据展示、控制逻辑分离，使得Web应用开发更加模块化和易于管理。Struts的工作流程大致可以分为以下步骤：

1. 用户通过浏览器发送请求到服务器。
2. 服务器上的Struts框架接收到请求，并根据配置文件中的映射关系将请求转发给相应的Action组件。
3. Action组件处理业务逻辑，包括调用服务层组件、访问数据库等。
4. Action组件处理完毕后，会根据执行结果选择返回对应的视图（JSP页面或其他视图技术）。
5. 用户浏览器接收到返回的视图，展示给用户。

下面是一个简单的Struts配置文件 struts.xml 示例：

<struts>
    <package name="default" extends="struts-default">
        <action name="login" class="com.example.LoginAction" method="execute">
            <result name="success">/login_success.jsp</result>
            <result name="input">/login.jsp</result>
            <result name="error">/login_error.jsp</result>
        </action>
    </package>
</struts>

2.1.2 Struts核心配置文件分析

在上述的配置文件中，我们可以看到几个关键组件：

• <action> ：定义了一个请求与处理该请求的Action类之间的映射关系。
• <result> ：定义了一个逻辑结果名称与页面视图之间的映射关系。

这里的核心是 struts.xml 文件，它作为Struts框架的配置中心，负责定义了所有的Action映射和结果视图。它还支持插件配置、拦截器定义、全局异常处理等多种高级特性。

在深入分析时，要注意Struts配置文件的命名空间（ <package> 标签定义），它有助于组织不同模块的Action，还可以通过继承（ extends 属性）来共享公共配置，从而简化配置管理工作。

2.2 Struts的表单处理与验证

2.2.1 表单数据提交与处理

表单处理是Struts2框架中的一个基本功能，其核心是ActionForm类。在Struts2中，ActionForm已经不是必须的，因为Struts2直接使用POJO来接收表单数据，这种设计更符合POJO原则，简化了开发。

当表单提交时，Struts2会自动创建一个Action类的实例，并使用值栈（ValueStack）技术将HTTP请求中的参数值填充到Action类的属性中。这个过程中涉及到了类型转换、数据验证等操作。

下面是一个简单的Action类示例：

public class LoginAction extends ActionSupport {
    private String username;
    private String password;

    // getter and setter methods

    public String execute() {
        // 处理登录逻辑，返回逻辑视图名称
        return SUCCESS;
    }
}

在上述示例中， execute() 方法被Struts2框架调用以处理请求。Struts2还提供了注解的方式来处理表单数据，这使得代码更简洁、直观。

2.2.2 输入验证框架的使用与扩展

Struts2的输入验证是通过 validate() 方法实现的，该方法由ActionSupport类提供，并且可以被继承并重写以自定义验证逻辑。

public class LoginAction extends ActionSupport {
    private String username;
    private String password;

    // getter and setter methods

    public void validate() {
        if (username == null || username.trim().isEmpty()) {
            addFieldError("username", "用户名不能为空");
        }
        if (password == null || password.trim().isEmpty()) {
            addFieldError("password", "密码不能为空");
        }
    }
}

在 validate() 方法中，如果输入不符合条件，可以调用 addFieldError() 方法来添加错误信息。Struts2框架会自动将错误信息包装并传递给视图页面，通常这些错误信息会展示给用户。

此外，Struts2还支持通过XML配置文件来进行验证，这样可以将验证逻辑与Action类代码分离，增加了灵活性。

2.3 Struts与JSP/Servlet集成

2.3.1 JSP标签库的应用

Struts2框架提供了丰富的自定义标签库，这些标签可以方便地在JSP页面中使用。使用标签库可以简化JSP代码，提高代码的可读性和可维护性。

下面是一个使用Struts2标签库的简单示例：

<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
<head>
    <title>Login Page</title>
</head>
<body>
    <s:form action="login">
        <s:textfield name="username" label="Username"/>
        <s:password name="password" label="Password"/>
        <s:submit value="Login"/>
    </s:form>
</body>
</html>

上述代码段展示了如何在JSP页面中使用Struts2的表单标签、文本框标签和密码框标签。这些标签背后都是Struts2的ActionContext、ValueStack等组件在工作。

2.3.2 Servlet在Struts中的角色

Struts2框架本身也是基于Servlet API构建的，因此它与Servlet技术有着紧密的联系。在Struts2中，Servlet主要扮演着请求分发的角色。

当一个HTTP请求到达服务器时，Struts2的Servlet过滤器（FilterDispatcher）会接管该请求，并根据 struts.xml 配置文件中的定义将请求转发给对应的Action处理。处理完毕后，Action返回一个逻辑视图名称，Struts2的Servlet过滤器根据这个名称再将请求转发给正确的JSP页面或其他资源。

在复杂的Web应用中，Struts2可以与其他Servlet组件协同工作，例如使用过滤器（Filters）进行安全检查，使用监听器（Listeners）进行初始化配置等。

总结来说，Struts2框架与JSP和Servlet的集成，使得开发者可以集中精力处理业务逻辑，而不需要过多地关注底层的请求处理和页面渲染细节。

3. Spring框架应用

3.1 Spring核心概念与依赖注入

3.1.1 Spring容器与Bean生命周期

Spring容器的核心作用

Spring容器是Spring框架的基础，它负责实例化、配置以及管理应用程序中所有bean的生命周期。容器通过读取配置元数据来获取关于要创建对象的指令，这些配置元数据可以通过XML文件、Java注解或者Java配置类来指定。

Spring容器主要分为两种类型： BeanFactory 和 ApplicationContext 。其中， BeanFactory 是Spring框架中最低层的容器，提供基本的DI支持。而 ApplicationContext 接口是 BeanFactory 的子接口，增加了企业应用所需的更多配置特性，例如事件传播、资源加载和透明的AOP支持。

Bean的生命周期控制

Spring的Bean生命周期从容器创建bean实例开始，直到它被销毁。这个周期包括以下主要阶段：

1. 实例化Bean ：根据配置元数据创建bean实例。
2. 属性赋值 ：使用依赖注入为bean的属性赋值。
3. BeanNameAware/BeanFactoryAware接口 ：如果Bean实现了 BeanNameAware 或 BeanFactoryAware 接口，容器会调用 setBeanName 或 setBeanFactory 方法，传递bean的ID或容器自身。
4. BeanPostProcessor接口 ：在bean初始化前后，Spring允许通过 BeanPostProcessor 接口对bean进行额外处理，比如增强或修改。
5. InitializingBean接口与init-method ：如果bean实现了 InitializingBean 接口，会调用 afterPropertiesSet 方法；或者如果配置了 init-method 属性，会调用指定的方法进行初始化。
6. 使用Bean ：Bean可供应用程序使用，执行其业务逻辑。
7. DisposableBean接口与destroy-method ：当bean不再使用时，容器会销毁bean。销毁前，如果bean实现了 DisposableBean 接口，则调用 destroy 方法；或者如果配置了 destroy-method 属性，会调用指定的方法进行清理工作。
8. 销毁Bean ：完成清理工作后，bean实例被销毁。

3.1.2 依赖注入的实现原理

依赖注入的概念

依赖注入（Dependency Injection，简称DI）是控制反转（Inversion of Control，简称IoC）的一种实现方式。其核心思想是将对象间的依赖关系从代码中抽离出来，由容器在运行期来决定对象的实例化及其依赖关系。这样做的好处是可以降低组件之间的耦合度，提高系统的可配置性和可测试性。

依赖注入的方式

在Spring框架中，依赖注入主要有三种方式：

1. 构造器注入（Constructor-based DI） ：
2. 使用构造函数来为bean的属性赋值。
3. 适用于强制依赖（即必须提供的依赖）。

public class MyService {
    private MyDao myDao;
    // 构造器注入
    public MyService(MyDao myDao) {
        this.myDao = myDao;
    }
}

1. setter注入（Setter-based DI） ：
2. 使用setter方法来为bean的属性赋值。
3. 适用于可选依赖（即不是必须提供的依赖）。

public class MyService {
    private MyDao myDao;
    // setter注入
    public void setMyDao(MyDao myDao) {
        this.myDao = myDao;
    }
}

1. 注解注入（Annotation-based DI） ：
2. 使用注解（例如@Autowired, @Resource, @Inject）来指定依赖的bean。
3. 适用于配置简化。

@Component
public class MyService {
    @Autowired
    private MyDao myDao;
}

依赖注入的实现原理

Spring通过Java的反射机制来实现依赖注入。容器在创建bean实例后，会根据配置的信息来检查这些bean需要哪些依赖，然后在相应的实例中注入这些依赖。

依赖注入的实现步骤如下：

1. 配置元数据解析 ：容器从XML、注解或Java配置类中读取配置元数据，如bean的定义、依赖关系等。
2. Bean的创建 ：容器根据配置信息创建bean实例。
3. 依赖查找与注入 ：容器使用Java反射机制查找bean的依赖，并通过构造器、setter方法或注解来注入依赖。
4. 依赖提供者（Provider） ：在某些情况下，依赖的提供者可能是一个实现了 BeanFactory 接口的bean，这样容器可以使用依赖提供者的getBean方法来获取依赖。
5. 生命周期回调 ：在注入依赖之后，如果bean实现了相关的生命周期接口（如 InitializingBean , DisposableBean ）或定义了回调方法（如 init-method , destroy-method ），容器会调用这些方法来完成初始化或清理工作。

依赖注入极大地提高了应用程序的灵活性和可测试性，它降低了组件之间的耦合度，让开发者能够更专注于业务逻辑的实现。在实际开发中，合理地使用依赖注入可以使代码结构更加清晰，便于维护和扩展。

4. Hibernate框架应用

4.1 ORM与数据库交互基础

4.1.1 ORM的概念与优势

ORM（Object Relational Mapping，对象关系映射）是一种程序设计技术，用于实现面向对象的编程语言与关系型数据库之间的相互转换。ORM框架能够把一个数据表映射成一个Java类，表中的每一列映射成类的一个属性，而表中的每一行记录则映射成该类的一个对象实例。这种技术把对象和关系数据之间的转换工作交由框架自动处理，大大简化了数据库操作的代码。

ORM的优势体现在以下几个方面：

1. 提高开发效率： 通过对象的方式操作数据库，避免了手动编写大量的SQL语句，提升开发效率。
2. 代码更易于维护： 与数据库相关的操作都封装在对象的操作中，使得代码更加清晰，易于维护。
3. 面向对象： ORM允许开发者以面向对象的方式进行思考，而不是传统的面向过程，这有助于构建更为复杂和灵活的系统。
4. 减少数据库交互错误： 自动的类型转换和持久化操作减少了因手动编写SQL造成的错误。

4.1.2 Hibernate的配置与映射

Hibernate 是一个成熟的ORM框架，它提供了丰富的API来操作关系型数据库。在使用Hibernate之前，必须进行相应的配置，包括数据库连接信息、Hibernate的会话工厂等。而对象与数据库表之间的映射，则通过XML映射文件或者注解的方式来实现。

Hibernate配置主要步骤包括：

1. 引入Hibernate依赖： 在项目的pom.xml文件中添加Hibernate的核心库以及数据库连接池（如c3p0）等。 xml <dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.4.12.Final</version> </dependency>

2. 配置Hibernate.properties文件： 设置数据库连接的相关配置项，如数据库URL、用户名、密码、驱动等。 properties hibernate.connection.driver_class=com.mysql.cj.jdbc.Driver hibernate.connection.url=jdbc:mysql://localhost:3306/yourdb hibernate.connection.username=root hibernate.connection.password=yourpassword hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

3. 映射文件配置： 创建映射文件（通常以.hbm.xml结尾），或者使用注解，定义Java类与数据库表之间的映射关系。例如，创建一个Customer类和对应的customer.hbm.xml映射文件。

java @Entity @Table(name = "customers") public class Customer { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; // getters and setters }

xml <hibernate-mapping> <class name="com.example.model.Customer" table="customers"> <id name="id" column="id" type="long"> <generator class="native"/> </id> <property name="name" column="name" type="string"/> <property name="email" column="email" type="string"/> </class> </hibernate-mapping>

1. 创建会话工厂： 在Java代码中创建一个SessionFactory实例，它用于创建会话（Session）实例，以便执行数据库操作。

java Configuration configuration = new Configuration(); configuration.configure("hibernate.cfg.xml"); ServiceRegistry serviceRegistry = new StandardServiceRegistryBuilder() .applySettings(configuration.getProperties()).build(); SessionFactory sessionFactory = configuration.buildSessionFactory(serviceRegistry);

通过以上配置，Hibernate框架就可以使用对象来操作数据库，从而简化数据持久化操作。接下来，将深入介绍实体类和映射文件的编写以及优化。

5. jpetstore项目的深度实践

5.1 项目配置文件管理

5.1.1 配置文件的作用与结构

在任何Java Web项目中，配置文件起着至关重要的作用。它们通常包含控制项目行为的参数和设置，这些设置包括数据库连接信息、服务器配置、应用安全设置以及第三方服务的集成配置等。在jpetstore项目中，配置文件允许开发者和系统管理员快速调整应用的运行参数，无需修改代码。

配置文件一般以XML, JSON, 或者properties文件的格式存储。例如，jpetstore使用properties文件来管理环境变量和Spring容器的Bean定义。配置文件的结构通常分为几个部分：

• 核心配置：定义了应用的基本配置，如数据库连接信息、邮件服务器配置等。
• 开发/测试/生产环境配置：每个环境的特定配置，如日志级别、外部服务的URL等。
• 应用安全配置：包括用户认证和授权的配置，加密密钥等。
• 第三方服务配置：为集成的服务如支付网关、消息队列等提供的配置信息。

5.1.2 环境分离与多环境配置

为确保应用的灵活性和可维护性，jpetstore项目采用了环境分离的策略。这意味着开发、测试和生产环境都有自己的配置文件，这些文件被放在不同的目录下，以避免相互干扰。

为了实现环境分离，项目采用了一种常见的做法：创建环境特定的属性文件，并在启动时通过系统变量或命令行参数指定哪个属性文件应该被加载。例如，在Spring Boot项目中，可以在 application.properties 文件中使用 spring.profiles.active 属性来指定激活的环境配置：

# application.properties
spring.profiles.active=dev

对于J2EE项目，可以通过在服务器配置或构建脚本中设置系统属性来指定激活的环境配置文件。下面是一个在Tomcat中设置环境变量的例子：

# 在catalina.sh中添加
CATALINA_OPTS="$CATALINA_OPTS -Dspring.profiles.active=dev"

这样，当应用启动时，它将根据指定的配置文件加载相应的设置，使得应用可以在不同的环境中运行而不需要重新编译或修改代码。

5.1.3 环境配置文件实例

以下是jpetstore项目的一个环境配置文件示例，展示了一个典型的 application-dev.properties 文件的内容：

# application-dev.properties
# 数据库配置
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/jpetstore_dev?useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=secret

# 日志级别
***.springframework.web=***
***.example.jpetstore=DEBUG

# 应用端口配置
server.port=8080

# 第三方服务配置（例如邮件服务器）
spring.mail.host=***
spring.mail.port=587
spring.mail.username=your-***
spring.mail.password=your-password
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true

这个文件包含了一些基本的配置项，以适应开发环境的需求。注意，所有的敏感信息，如数据库密码、邮件服务器密码等，都应该被妥善保护，并且在生产环境中通过安全的方式配置。

5.2 DAO接口与实现

5.2.1 DAO模式的应用与实现

数据访问对象（DAO）模式是一种用来实现数据访问层的一种设计模式。它的核心思想是将数据访问逻辑与业务逻辑分离，这样可以使业务逻辑更清晰，同时使数据访问逻辑更易于重用和测试。

在jpetstore项目中，DAO模式的使用遵循以下原则：

• 接口定义 ：定义一个DAO接口，描述对数据模型的操作。
• 接口实现 ：实现该接口，具体实现数据访问逻辑。
• 依赖注入 ：通过Spring的依赖注入机制将实现类注入到服务层。

5.2.2 Spring与Hibernate的整合实践

在jpetstore项目中，整合Spring与Hibernate是一个关键步骤。整合后的框架将利用Spring的IoC容器和Hibernate的ORM功能来实现数据访问层。

配置Hibernate

首先，需要在Spring配置文件中配置数据源和Hibernate会话工厂（SessionFactory）：

<!-- applicationContext.xml -->
<bean id="dataSource" class="***mons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName" value="${jdbc.driverClassName}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="packagesToScan" value="com.example.jpetstore.model"/>
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">${hibernate.dialect}</prop>
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
            <!-- 其他Hibernate配置 -->
        </props>
    </property>
</bean>

定义DAO接口和实现

接下来，定义一个DAO接口以及它的实现类。实现类使用Hibernate的Session来操作数据库：

public interface AccountDAO {
    Account getAccountByUsername(String username);
    void insertAccount(Account account);
    // 其他CRUD方法...
}

@Repository
public class AccountDAOImpl implements AccountDAO {
    @Autowired
    private SessionFactory sessionFactory;

    @Override
    public Account getAccountByUsername(String username) {
        Session session = sessionFactory.getCurrentSession();
        return (Account) session.get(Account.class, username);
    }

    @Override
    public void insertAccount(Account account) {
        Session session = sessionFactory.getCurrentSession();
        session.saveOrUpdate(account);
    }
    // 实现其他CRUD方法...
}

事务管理

为了保证数据的一致性，jpetstore项目使用Spring的声明式事务管理。在服务层的方法上添加 @Transactional 注解：

@Service
public class AccountService {
    @Autowired
    private AccountDAO accountDAO;

    @Transactional
    public void registerAccount(Account account) {
        accountDAO.insertAccount(account);
        // 注册过程中的其他逻辑...
    }
}

通过这种方式，Spring框架在调用服务层方法时自动开启事务，并在方法执行完成后根据执行结果来提交或回滚事务。

整合Spring与Hibernate的实践，不仅提高了开发效率，还增强了代码的可测试性和可维护性。接下来，我们将进一步深入探讨Service层和Action类的实现，以及如何将请求映射到具体的业务逻辑。

6. 前端展示与异常处理

6.1 视图展示技术

在Web开发中，视图层是用户与系统交互的界面，它负责展示数据和接收用户的输入。在MVC模式中，视图主要由JSP、Freemarker等模板引擎负责渲染。

6.1.1 JSP与Freemarker的整合应用

JSP（Java Server Pages）是Java EE技术中用于构建动态网页的标准技术之一。而Freemarker则是一个模板引擎，它用于生成文本输出，通常与MVC模式中的视图层相结合。在大型项目中，往往将两者结合起来使用，以发挥各自的优势。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>商品列表</title>
</head>
<body>
    <h1>商品列表</h1>
    <%-- 引入Freemarker标签 --%>
    <%@ taglib prefix="fm" uri="***" %>
    <fm:import template="/WEB-INF/tags/header.ftl"/>
    <table>
        <tr>
            <th>商品ID</th>
            <th>商品名称</th>
            <th>商品价格</th>
        </tr>
        <%
            // 假设有一个商品列表
            List<Product> productList = (List<Product>)request.getAttribute("productList");
            for(Product product : productList) {
        %>
        <tr>
            <td><%= product.getId() %></td>
            <td><%= product.getName() %></td>
            <td><%= product.getPrice() %></td>
        </tr>
        <%
            }
        %>
    </table>
    <fm:import template="/WEB-INF/tags/footer.ftl"/>
</body>
</html>

上例中，我们使用了JSP来编写基本的HTML结构，同时通过Freemarker标签 <fm:import> 引入了Freemarker模板作为页面的一部分。这样，既能利用JSP的强大功能，又能享受Freemarker模板引擎在模板设计上的优势。

6.1.2 UI组件库的选择与集成

为了提供更好的用户界面体验，通常会选择一个成熟的UI组件库，如Bootstrap、Material Design等，并与视图层进行集成。

<!-- 引入Bootstrap CSS -->
<link rel="stylesheet" href="***">

<!-- 页面内容 -->
<div class="container mt-5">
    <div class="row">
        <div class="col-md-12">
            <h2>商品列表</h2>
            <!-- 使用Bootstrap表格组件 -->
            <table class="table table-striped">
                <thead>
                    <tr>
                        <th>商品ID</th>
                        <th>商品名称</th>
                        <th>商品价格</th>
                    </tr>
                </thead>
                <tbody>
                    <%
                        List<Product> productList = (List<Product>) request.getAttribute("productList");
                        for(Product product : productList) {
                    %>
                    <tr>
                        <td><%= product.getId() %></td>
                        <td><%= product.getName() %></td>
                        <td><%= product.getPrice() %></td>
                    </tr>
                    <%
                        }
                    %>
                </tbody>
            </table>
        </div>
    </div>
</div>

<!-- 引入Bootstrap JavaScript和依赖 -->
<script src="***"></script>
<script src="***"></script>
<script src="***"></script>

这里，我们使用了Bootstrap来美化表格，提供了响应式设计，提升了用户的交互体验。通过引入Bootstrap的CSS和JavaScript文件，能够在前端展示中快速实现丰富的界面效果。

6.2 异常处理与工具类

良好的异常处理机制对于保持程序的健壮性和提供友好的用户体验至关重要。在Java Web开发中，异常处理通常涉及到错误页面的展示、异常的捕获和记录等。

6.2.1 异常处理机制与策略

异常处理通常需要在web.xml中配置，定义错误页面以及自定义错误码，以及在代码中使用try-catch块来捕获和处理异常。

<!-- web.xml中定义错误页面 -->
<error-page>
    <exception-type>java.lang.Throwable</exception-type>
    <location>/error.jsp</location>
</error-page>

<!-- 自定义错误码 -->
<error-page>
    <error-code>404</error-code>
    <location>/not_found.jsp</location>
</error-page>

在Java代码中，我们可能会编写类似的异常处理逻辑：

try {
    // 正常逻辑代码
} catch (SomeBusinessException e) {
    // 业务异常处理
    request.setAttribute("errorMessage", e.getMessage());
    request.getRequestDispatcher("/error.jsp").forward(request, response);
} catch (Exception e) {
    // 其他异常处理
    request.setAttribute("errorMessage", "发生未知错误，请联系管理员");
    request.getRequestDispatcher("/error.jsp").forward(request, response);
} finally {
    // 资源释放等
}

6.2.2 公用工具类的设计与实现

在Java中，工具类（Utility class）是非常常见的设计模式，它可以提供静态方法或常量，以便在整个项目中重用。

public class StringUtils {
    public static String formatCurrency(double amount) {
        return String.format("%.2f", amount);
    }
    public static boolean isBlank(String str) {
        return str == null || str.trim().isEmpty();
    }
    // 更多工具方法...
}

工具类通常遵循以下原则： - 所有方法都应该是静态的（static）。 - 类不应该被实例化，通常将其构造函数设为私有（private）。 - 根据功能将方法进行适当的分组。

通过合理设计工具类，可以减少重复代码，提高代码的可维护性和可读性。

本章节介绍了前端展示技术，包括JSP与Freemarker的整合以及UI组件库的选择与集成。同时，我们探讨了异常处理的机制和策略，并强调了工具类在代码优化中的重要性。这些知识能够帮助开发者构建出既美观又稳定的Web应用。

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

简介：Struts、Spring和Hibernate是Java Web开发中常用的三大框架。本课程将以jpetstore项目为例，详细讲解如何集成这三个框架构建一个完整的MVC架构Web应用程序。涵盖从配置文件管理、实体类设计、数据操作抽象，到服务层逻辑处理以及前端视图展示的完整流程。通过本课程的学习，学员将深入理解框架的协同工作原理，并能够熟练地在实际项目中应用。

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