JavaEE基于Web的简易计算器项目源码解析

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

简介：本项目展示了一个使用JavaEE平台开发的简易在线计算器应用，支持基本数学运算。它基于Struts2框架，JSTL标签库，以及JSP技术，并支持中英文国际化切换。通过本项目的源码，开发者可以学习如何构建Web应用，处理业务逻辑，并实现国际化。

1. JavaEE开发流程

JavaEE（Java Platform, Enterprise Edition）是一套用于开发企业级应用程序的规范集合，由Sun Microsystems公司推出。随着JavaEE的发展，它已经成为构建现代、多层次、基于组件的大型企业级应用的标准平台。

JavaEE开发流程概述

开发前的准备工作

在开始JavaEE开发之前，需要进行详细的项目规划和需求分析。这包括项目的目标、功能、性能要求以及预估的时间、成本等。接下来是搭建开发环境，包括安装Java开发工具包（JDK）、集成开发环境（IDE）如IntelliJ IDEA或Eclipse，以及配置数据库和应用服务器，如MySQL和Tomcat。

设计阶段

在项目规划和环境搭建完成后，进入设计阶段，主要是系统架构设计和数据库设计。系统架构设计决定了应用的架构模式，如MVC（Model-View-Controller）模式，并根据设计文档制定技术路线图。数据库设计则涵盖了概念设计、逻辑设计到物理设计，以及建立数据模型和数据表。

编码与开发

设计阶段完成后，团队将开始编码工作。编码阶段按照JavaEE的技术规范编写业务逻辑、控制层、数据访问层和表现层的代码。在编码过程中，还需要进行单元测试以确保每个模块的功能正确，并且进行代码的版本控制。

测试阶段

编码完成并通过单元测试后，进入集成测试和系统测试阶段。集成测试主要检查各个模块之间的接口是否正常，系统测试则对整个应用进行全面测试，确保功能与需求一致且无严重bug。性能测试也是必不可少的部分，确保应用在高负载下的稳定运行。

部署与维护

测试无误后，应用将进入部署阶段，将代码部署到生产环境中。此阶段可能需要对应用进行细微调整以满足实际运行环境的要求。应用部署成功后，还需进行持续的维护和优化，包括监控系统运行状态，及时更新修复bug，根据用户反馈不断优化应用性能和用户体验。

JavaEE开发流程的掌握对于任何希望从事企业级应用开发的开发者都是基础且必要的，它不仅能帮助开发者理解整个开发周期中的关键步骤，也能指导他们如何更有效地组织项目，提高开发质量和效率。

2.1 Struts2框架概述

2.1.1 Struts2的核心组件和工作原理

Struts2框架的核心组件包括Action、Interceptor（拦截器）、Result（结果类型）和ValueStack（值栈）。工作原理可从客户端的请求开始，详细解析如下：

1. 用户向服务器发起一个请求。
2. 请求到达Struts2的FilterDispatcher（或者是StrutsPrepareAndExecuteFilter，具体取决于你的Struts版本）。
3. FilterDispatcher会查找与请求匹配的Action，并通过请求的URI来确定。
4. 如果匹配到了Action，Struts2框架将实例化Action类，把请求参数通过ValueStack（值栈）传递给Action。
5. 在Action中处理业务逻辑后，会返回一个String类型的逻辑视图名。
6. 根据返回的逻辑视图名，框架查找对应的result配置，并将控制权交给Web层的组件，比如JSP页面，进行展示。

Struts2的Action类实际上是整个流程的中心，负责接收输入、处理业务逻辑和返回结果。

2.1.2 Struts2的配置和扩展机制

Struts2框架的配置主要通过XML文件或者注解实现。XML配置文件包括 struts.xml 和 struts.properties 等。配置文件的扩展机制允许开发者进行细致的控制，例如：

<action name="calculator" class="com.example.action.CalculatorAction">
    <result name="success">/pages/success.jsp</result>
    <result name="input">/pages/input.jsp</result>
</action>

在上面的例子中，我们定义了一个名为 calculator 的Action，当Action的处理结果为 success 时，将返回 success.jsp 页面；如果为 input ，则返回 input.jsp 页面。

Struts2的拦截器（Interceptor）是其扩展机制的另一个重要部分。拦截器可以看作是预处理和后处理的Action。通过自定义拦截器，可以实现权限验证、日志记录等横切关注点功能。

2.1.3 Struts2的生命周期管理

Struts2的生命周期从请求开始，到返回响应结束，大致分为以下步骤：

1. 请求到达Struts2的过滤器，开始生命周期。
2. 过滤器拦截请求，并根据配置创建Action实例。
3. 如果有拦截器，执行拦截器栈中的每个拦截器。
4. 执行Action中的业务逻辑。
5. Action执行后，返回一个结果字符串，Struts2根据结果字符串找到对应的result。
6. 结果配置定义如何处理返回的结果（例如跳转页面、返回数据等）。
7. 最后返回响应给客户端，完成生命周期。

Struts2的生命周期管理实际上是通过一个中心的 ActionInvocation 对象来实现，它负责调用拦截器和Action，并管理值栈。Struts2通过值栈管理Action与页面之间的数据传递。

2.2 Struts2在计算器项目中的实践

2.2.1 动作类（Action）的设计与实现

在计算器项目中，我们首先需要设计一个Action类，该类将负责接收用户的输入，执行计算，并返回结果。下面是一个简单的Action类实现：

package com.example.action;

import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.Preparable;

public class CalculatorAction extends ActionSupport implements Preparable {
    private String inputNumber1;
    private String inputNumber2;
    private String operation;
    private String result;

    @Override
    public void prepare() throws Exception {
        // 可以在这里进行输入数据的准备
    }

    public String execute() {
        // 执行计算逻辑
        // ...
        return SUCCESS;
    }

    // Getter和Setter方法
}

在 execute() 方法中，我们将根据用户输入的数字和运算符来执行实际的计算逻辑。计算完成后，将结果存储在 result 属性中，并返回 SUCCESS 字符串以指示Action执行成功。

2.2.2 结果类型和视图解析

在Struts2框架中，结果类型定义了Action返回结果之后如何渲染视图。结果类型可以是一个JSP页面，也可以是一个简单的响应消息。计算器项目中，我们可能会用到下面这样的配置：

<action name="calculator" class="com.example.action.CalculatorAction">
    <result name="success">/pages/result.jsp</result>
    <result name="input">/pages/error.jsp</result>
</action>

在上面的 struts.xml 配置文件中，当 CalculatorAction 执行成功后，返回 success 结果，用户将会被重定向到 result.jsp 页面；如果出现错误，返回 input 结果，用户将会被重定向到 error.jsp 页面。

2.2.3 表单验证和异常处理

为了确保用户输入的数据符合要求，Struts2提供了内建的表单验证机制。通过在Action类中使用 @Validate 注解或XML配置，可以指定哪些字段需要验证以及验证规则。

异常处理在Struts2中通常通过实现 ExceptionAware 接口，并通过定义全局异常处理器来完成。这样可以在异常发生时，给用户友好的错误信息，并记录错误日志。

public class GlobalExceptionMapper extends DefaultExceptionMapper {
    @Override
    public String getErrorResult(Exception e) {
        // 处理异常，返回错误页面
        return "error";
    }
}

在 struts.xml 中指定这个全局异常处理器：

<exception-mapping result="error" exception="java.lang.Throwable" />

通过这些配置，计算器项目的用户在执行计算时，如果输入数据有问题，或者出现系统级错误，都会被友好地引导至适当的页面。

3. JSTL标签库应用

JSTL（JavaServer Pages Standard Tag Library）为JSP页面提供了一种简便的方式进行标签化处理。与传统的JSP脚本相比，JSTL标签库能够提高代码的可读性和可维护性。它允许开发者通过XML风格的标签来替代传统的Java代码片段，从而简化页面逻辑和控制结构。本章将探讨如何在计算器项目中利用JSTL简化页面逻辑。

3.1 JSTL标签库基础

3.1.1 核心标签库的使用场景和效果

JSTL的核心标签库提供了一系列的标准标签，用于操作数据、遍历集合、条件判断、表达式计算等。使用核心标签库可以减少JSP页面中Java代码的使用，提高页面的可读性和维护性。核心标签库包含如下常用标签：

• <c:out> ：输出内容到页面。
• <c:set> ：设置变量的值。
• <c:if> ：条件输出。
• <c:choose> , <c:when> , <c:otherwise> ：类似Java中的 switch 语句。
• <c:forEach> ：遍历集合或数组。
• <c:forTokens> ：按照分隔符遍历字符串。

3.1.2 格式化标签库的应用

JSTL的格式化标签库（ fmt 标签库）主要用于数字、日期和消息的格式化，它可以简化国际化（i18n）和本地化（l10n）的处理。常用的标签有：

• <fmt:formatNumber> ：用于数字的格式化。
• <fmt:formatDate> ：用于日期和时间的格式化。
• <fmt:bundle> 和 <fmt:setBundle> ：用于消息资源包的处理。

3.1.3 SQL标签库和函数库的介绍

SQL标签库允许在JSP页面中执行数据库查询和更新操作，简化了数据访问层的实现。而函数库提供了一些辅助函数，用于处理字符串、数学运算、类型转换等。

• <sql:query> ：执行SQL查询。
• <sql:update> ：执行SQL更新操作。
• <fn:length> ：返回字符串长度。
• <fn:escapeXml> ：转义XML特殊字符。

3.2 JSTL标签在计算器设计中的应用实例

3.2.1 使用JSTL处理数据列表和分页

在计算器项目中，可能需要展示一系列数据或操作记录。使用JSTL的 <c:forEach> 标签可以轻松遍历数据集合，并渲染到HTML页面中。对于分页功能，可以通过 <c:set> 和 <c:if> 组合使用，控制页面元素的显示。

<c:forEach items="${list}" var="item" varStatus="status">
    <tr>
        <td>${item.id}</td>
        <td>${item.description}</td>
        <!-- 其他数据列 -->
    </tr>
</c:forEach>
<c:if test="${not empty list}">
    <c:set var="page" value="${param.page}" />
    <c:set var="totalPages" value="${fn:length(list)}" />
    <!-- 分页逻辑 -->
</c:if>

3.2.2 JSTL标签在表单处理中的应用

JSTL可以用于简化表单的验证和数据提交处理。利用 <c:if> 标签可以进行简单的表单验证，比如检查是否输入了必填字段。

<c:if test="${empty form.name}">
    <div class="error">Name is required.</div>
</c:if>
<c:if test="${empty form.email}">
    <div class="error">Email is required.</div>
</c:if>

3.2.3 条件逻辑和循环结构的实现

通过 <c:choose> , <c:when> , <c:otherwise> 组合，我们可以实现条件逻辑的处理。对于重复的结构，比如菜单、导航栏等，可以使用 <c:forEach> 标签。

<c:choose>
    <c:when test="${param.type == 'user'}">
        <!-- 用户相关的操作 -->
    </c:when>
    <c:when test="${param.type == 'admin'}">
        <!-- 管理员相关的操作 -->
    </c:when>
    <c:otherwise>
        <!-- 默认操作 -->
    </c:otherwise>
</c:choose>

<ul>
    <c:forEach items="${menuItems}" var="item">
        <li><a href="${item.url}">${item.title}</a></li>
    </c:forEach>
</ul>

JSTL标签库的使用，不仅简化了JSP页面的代码，也使得逻辑处理更加清晰和易于管理。在计算器项目中合理利用JSTL标签库，可以有效提升开发效率和页面的可维护性。

4.2 JSP页面设计与计算器界面实现

4.2.1 创建响应式计算器界面

响应式设计是现代Web开发中的一个关键概念，它保证了用户无论使用何种设备，都能获得一致的体验。在创建一个响应式计算器界面时，我们必须考虑不同屏幕尺寸和分辨率的适配性。这意味着我们需要使用灵活的布局和媒体查询来调整页面元素。

使用媒体查询来适配不同屏幕尺寸

媒体查询（Media Queries）是CSS3中提供的一个功能，允许我们根据不同的设备特性（如屏幕宽度、高度、分辨率等）应用不同的样式规则。以下是一个简单示例，展示如何使用媒体查询来适配不同屏幕尺寸：

/* 默认样式 */
.container {
    width: 100%;
    padding: 10px;
}

/* 针对平板的样式 */
@media (min-width: 768px) {
    .container {
        width: 700px;
    }
}

/* 针对桌面显示器的样式 */
@media (min-width: 992px) {
    .container {
        width: 800px;
    }
}

/* 针对大屏幕的样式 */
@media (min-width: 1200px) {
    .container {
        width: 900px;
    }
}

在上述代码中， .container 类定义了一个容器，在没有应用媒体查询的情况下，宽度为100%。当屏幕宽度达到768px、992px和1200px时，分别会应用不同的宽度样式，以达到更好的视觉效果。

利用弹性盒模型（Flexbox）进行布局

弹性盒模型（Flexbox）是CSS3中的另一个强大布局工具，它提供了一种更加灵活的方式来对齐和分布容器内的项目，无论它们的大小是否已知。对于计算器界面的设计，我们可以利用Flexbox轻松实现各种布局需求。

.container {
    display: flex;
    flex-wrap: wrap;
    justify-content: space-between;
}

在上面的CSS代码段中， .container 被设置为一个弹性容器，其子元素（按钮、显示屏等）将自动换行并均匀分布。

<div class="container">
    <input type="text" class="display" />
    <button class="button" value="1">1</button>
    <!-- 其他按钮和显示组件 -->
</div>

4.2.2 JSP与CSS/JavaScript的整合

为了使计算器界面具有动态交互和响应式特性，我们需要将CSS和JavaScript与JSP页面整合。整合的关键在于正确地引入CSS和JavaScript文件，以及使用JSP的表达式和标签嵌入动态内容。

在JSP页面中引入CSS和JavaScript文件

通常，我们在JSP页面的头部（ <head> 标签内）引入CSS文件，在页面底部（ <body> 标签后）引入JavaScript文件。

<!-- 在HTML头部引入CSS文件 -->
<link rel="stylesheet" type="text/css" href="style.css">

<!-- 在HTML内容之后引入JavaScript文件 -->
<script src="script.js"></script>

使用JSP表达式和标签输出动态内容

在JSP页面中，我们可以使用表达式（ ${} ）和标签（如 <jsp:include> ）来动态地引入和输出内容。

<!-- 动态包含一个部分页面 -->
<jsp:include page="header.jsp" />

<!-- 输出计算结果显示 -->
<div class="display">${result}</div>

4.2.3 交互式功能的实现与优化

计算器的交互式功能主要依赖于JavaScript来实现。我们需要处理用户的输入事件，并在页面上实时更新计算结果。

JavaScript事件处理

在JSP页面中，我们可以为计算器的按钮添加事件监听器，以响应用户的点击操作。

document.querySelector('.button').addEventListener('click', function() {
    // 更新显示结果
    updateDisplay(this.value);
});

结果更新优化

为了提升用户体验，更新计算结果时应尽量避免页面的重绘和重排。我们可以通过修改元素的 innerHTML 或 textContent 来仅更新结果，而不是替换整个元素。

function updateDisplay(value) {
    document.querySelector('.display').textContent += value;
}

结语

构建一个响应式的计算器用户界面不仅仅是关于显示效果的优化，更需要考虑用户交互的流畅度和逻辑的正确性。通过合理使用CSS媒体查询、弹性盒模型布局以及JavaScript事件处理，我们可以创造出既美观又实用的计算器Web应用。在下一章节中，我们将深入探讨网页版计算器的详细设计需求，并着手实现计算器的核心计算功能。

5. 网页版计算器设计

在前几章的基础之上，我们已经探讨了JavaEE开发流程、Struts2框架的使用、JSTL标签库的应用、JSP技术在用户界面构建中的作用，并且学习了如何实现国际化和处理Web应用的业务逻辑。现在，我们将进入实践环节，详细探讨如何设计并实现一个功能完整的网页版简易计算器。

5.1 计算器需求分析与设计

在开始编码之前，我们需要进行详细的需求分析和设计。我们将定义计算器的基本功能，设计用户界面，并构建系统的整体架构。

5.1.1 功能需求概述

计算器应该具备基本的数学运算功能，例如加、减、乘、除。此外，为了提高用户体验，我们还可以考虑实现括号运算、历史记录功能、清除和回退操作。在更高级的功能中，计算器可能还需要具备科学计算的能力，比如三角函数、对数运算等。

5.1.2 界面设计原则

界面设计需要简洁直观，易于操作。每个按钮都应当清晰标示其功能，并考虑到用户在不同设备上的使用习惯，实现响应式设计。此外，应该提供足够的提示信息，帮助用户理解如何使用计算器。

5.1.3 系统架构设计

系统架构设计应该考虑到可扩展性和可维护性。我们将采用MVC架构，分为模型（Model）、视图（View）和控制器（Controller）。模型负责业务逻辑和数据管理；视图是用户界面的展现；控制器则是用户和系统之间的交互点，处理用户的输入并调用模型进行计算，然后更新视图。

5.2 计算器功能模块开发

根据需求分析，我们将逐步开发计算器的各个功能模块。

5.2.1 核心计算功能的实现

核心计算功能是计算器的灵魂，我们将使用Java编写计算逻辑，并确保结果准确无误。下面是一个实现基本四则运算的Java代码示例：

public class Calculator {

    public double add(double number1, double number2) {
        return number1 + number2;
    }

    public double subtract(double number1, double number2) {
        return number1 - number2;
    }

    public double multiply(double number1, double number2) {
        return number1 * number2;
    }

    public double divide(double number1, double number2) {
        if (number2 == 0) {
            throw new IllegalArgumentException("Cannot divide by zero.");
        }
        return number1 / number2;
    }
}

在上述代码中，我们定义了一个 Calculator 类，实现了加、减、乘、除四个方法。注意，我们在除法方法中增加了对除数为零的异常处理，保证程序的健壮性。

5.2.2 错误处理和反馈机制

错误处理是提高用户体验的重要一环。对于用户的错误输入，例如非法的表达式，计算器应该能够给出清晰的错误提示，并提供重新输入的机会。此外，对于复杂的科学计算，计算器应当提示用户运算结果的范围，避免数值溢出的问题。

5.2.3 用户输入的验证和安全性设计

用户输入的验证是为了确保计算器接收到的数据是合法的，可以被正确处理。安全性设计则是指防止恶意用户通过特殊构造的输入来破坏计算器的功能。例如，我们可以在服务器端对用户输入进行过滤，避免注入攻击等安全问题。

在本章中，我们讨论了如何从需求分析到模块开发，一步步构建一个网页版计算器。在下一章节中，我们将继续深入探讨国际化实现方法，使得计算器可以支持多语言，满足更多用户的需求。

6. 国际化实现方法

国际化（Internationalization，通常简称为i18n）是软件开发中的一个重要概念，它允许应用程序适应不同的语言和地区设置，从而在不同文化和语言环境中使用。随着全球经济一体化的发展，越来越多的应用程序需要在多个地区和市场中运行，因此实现国际化成为了提高软件可访问性和扩展性的重要步骤。本章将深入探讨如何在JavaEE项目中实现国际化。

6.1 国际化基础概念与技术

6.1.1 语言资源文件的创建和管理

国际化的一个关键步骤是创建和管理语言资源文件，这些文件通常以键值对的形式存储翻译后的文本。JavaEE项目中通常会使用.properties文件作为资源文件，一个典型的文件如下所示：

# messages.properties (默认语言文件)
welcome.message=Welcome to the Calculator!
addition.text=Addition Result:
subtraction.text=Subtraction Result:
multiplication.text=Multiplication Result:
division.text=Division Result:

为了支持多种语言，需要为每种语言创建不同的资源文件，如英语的 messages_en.properties 和西班牙语的 messages_es.properties ：

# messages_en.properties (英语资源文件)
welcome.message=Welcome to the Calculator!
addition.text=Addition Result:
subtraction.text=Subtraction Result:
multiplication.text=Multiplication Result:
division.text=Division Result:

# messages_es.properties (西班牙语资源文件)
welcome.message=¡Bienvenido a la Calculadora!
addition.text=Resultado de la suma:
subtraction.text=Resultado de la resta:
multiplication.text=Resultado de la multiplicación:
division.text=Resultado de la división:

资源文件应该放置在项目的 src/main/resources 目录下，这样它们就可以被类加载器正确地识别和加载。

6.1.2 JSTL国际化标签的使用

JavaServer Pages Standard Tag Library (JSTL) 提供了一系列的国际化标签，可以简化国际化内容的显示。例如， fmt:formatDate 标签可以用来格式化日期和时间， fmt:bundle 和 fmt:message 可以用来显示不同语言的消息文本。下面是一个简单的例子：

<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
<body>
    <fmt:message bundle="messages" key="welcome.message"/>
    ...
</body>

在这个例子中， fmt:message 标签将从 messages.properties 文件中读取 welcome.message 的值，并根据当前用户的语言环境显示相应的文本。

6.1.3 国际化数据的处理和格式化

数据的显示和格式化也是国际化过程中需要考虑的重要方面。Java中的 java.text 包提供了 DateFormat 和 NumberFormat 类，它们可以用来格式化日期、时间和数字。

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Locale;

// ...

DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.SHORT, new Locale("es", "ES"));
String formattedDate = dateFormat.format(new Date());
System.out.println(formattedDate);

在上面的Java代码中， DateFormat.getDateInstance 方法创建了一个适合西班牙语环境的日期格式化器，并格式化了一个日期对象。

6.2 计算器项目的国际化实现

6.2.1 多语言界面的设计

在本项目的计算器界面中，我们需要实现一个多语言的用户界面。这通常涉及到创建一个语言选择器，允许用户选择他们想要使用的语言。然后，应用程序将根据选择的语言加载相应的资源文件，并用它来显示标签、消息和其他用户界面元素。

6.2.2 动态内容的国际化处理

对于动态生成的内容，比如计算结果，也需要进行国际化处理。这可以通过在后端逻辑中使用 java.text 包的类来实现，或者使用JSTL标签来格式化输出。

6.2.3 国际化测试与验证

在实现国际化之后，需要进行彻底的测试，以确保在所有支持的语言中应用程序的用户界面都能正确显示。这包括测试资源文件是否正确加载、内容是否正确翻译、日期和数字是否按照用户的语言环境正确格式化等。

国际化是一个复杂的过程，涉及到软件设计、开发和测试的多个方面。通过遵循本章的指导，开发者可以确保他们的JavaEE项目能够支持国际化，从而满足更广泛用户群的需求。

7. Web应用业务逻辑处理

Web应用的成功与否，很大程度上取决于其业务逻辑的处理。业务逻辑层是Web应用的核心，它负责处理用户请求，执行业务规则，协调数据层的操作，并将结果返回给Web层。本章将重点介绍如何在JavaEE架构下处理Web应用的业务逻辑，确保计算器的功能准确、高效。

7.1 业务逻辑层的构建

业务逻辑层通常位于MVC架构中的“模型”部分，是Web应用中最为复杂的层次之一。它需要与数据访问层（DAO）和表示层（Web层）进行交互，同时处理多种业务场景。

7.1.1 业务逻辑组件的设计原则

在设计业务逻辑组件时，需要遵循几个关键原则：
- 单一职责原则（SRP） ：每个组件只负责一项业务功能。
- 开放封闭原则 ：业务逻辑组件应当对扩展开放，对修改封闭。
- 依赖倒置原则 ：高层模块不应依赖于低层模块，两者都应依赖于抽象。

7.1.2 服务层的划分和实现

服务层通常由一系列的Service组件构成。每个Service组件应该提供一个或多个业务操作，并且这些操作应该是无状态的。Service组件之间通过接口进行通信，以降低组件间的耦合度。

在计算器项目中，我们可以定义一个 CalculatorService 接口，其中包含加、减、乘、除等操作的抽象方法。然后创建对应的实现类，如 SimpleCalculatorService 。

7.1.3 事务管理和安全性控制

在业务逻辑层中，事务管理是至关重要的。JavaEE通过EJB容器提供的声明式事务管理简化了事务控制。开发者只需要在方法上添加 @TransactionAttribute 注解即可。

安全性控制则是确保业务逻辑层安全访问的关键。在JavaEE中，我们可以利用容器管理的安全性控制，比如通过 @RolesAllowed 注解来控制方法访问权限。

7.2 计算器业务逻辑实例分析

让我们以计算器项目中的加法操作为例，来深入分析业务逻辑层的实现。

7.2.1 计算器业务逻辑的封装与实现

首先，定义 CalculatorService 接口，添加加法操作的声明：

public interface CalculatorService {
    double add(double a, double b);
}

然后，实现 SimpleCalculatorService 类：

@Stateless
public class SimpleCalculatorService implements CalculatorService {

    @TransactionAttribute(TransactionAttributeType.REQUIRED)
    public double add(double a, double b) {
        return a + b;
    }
}

7.2.2 业务逻辑与Web层的交互

在Web层，我们可以使用 @EJB 注解来注入 CalculatorService 的实现，并调用 add 方法：

@EJB
CalculatorService calculatorService;

public String performAddition(double a, double b) {
    double result = calculatorService.add(a, b);
    return "Result is: " + result;
}

7.2.3 性能优化和异常处理策略

在实现业务逻辑时，性能优化和异常处理是不容忽视的两个方面。

• 性能优化 ：通过方法调用缓存、避免不必要的计算和数据库访问等方式进行性能优化。
• 异常处理策略 ：在业务逻辑层定义并抛出自定义异常，Web层捕获这些异常并返回给用户。例如，如果加法操作的参数超过了预设的范围，我们可以抛出 IllegalArgumentException 。

以上是对Web应用业务逻辑处理的详细介绍，通过本章的学习，开发者应该能够构建出既高效又安全的业务逻辑层。在下一章，我们将深入源码结构，详细解读项目文件的组织和设计模式的应用。

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

简介：本项目展示了一个使用JavaEE平台开发的简易在线计算器应用，支持基本数学运算。它基于Struts2框架，JSTL标签库，以及JSP技术，并支持中英文国际化切换。通过本项目的源码，开发者可以学习如何构建Web应用，处理业务逻辑，并实现国际化。

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