j2ee开发实例中，有哪些关键环节或常见问题需要注意？

构建一个健壮的电商商品管理系统是体验J2EE核心技术的绝佳途径，本教程将手把手带你使用经典的J2EE组件栈（Servlet, JSP, JPA, EJB/CDI）开发一个具备增删改查（CRUD）、搜索和基本安全控制的后台管理系统，涵盖从环境搭建到部署的关键环节，我们专注于遵循最佳实践，确保应用的模块化、可维护性和性能。

开发环境与技术栈

• IDE: IntelliJ IDEA Ultimate 或 Eclipse IDE for Enterprise Java Developers
• JDK: Java SE 17 (LTS推荐)
• 应用服务器: WildFly 27+ 或 Jakarta EE 10 兼容服务器（如 GlassFish 7）
• 数据库: PostgreSQL 15+ 或 MySQL 8.0+
• 构建工具: Apache Maven 3.8+
• 关键技术:
  • Jakarta Servlet 6.0 / JSP 3.0: 处理Web请求与视图呈现
  • Jakarta Persistence API (JPA) 3.1: 对象关系映射(ORM)，使用Hibernate 6.2作为实现
  • Jakarta Enterprise Beans (EJB) 4.0 或 Contexts and Dependency Injection (CDI) 4.0: 业务逻辑封装与依赖注入（本教程将展示EJB Lite + CDI组合）
  • Jakarta Bean Validation 3.0: 数据模型验证
  • Jakarta Security 3.0 (或 JAAS): 身份认证与授权
  • JSTL 2.0: JSP标准标签库，简化视图层逻辑

项目结构 (Maven)

product-management-system
├── pom.xml
└── src
    ├── main
    │   ├── java
    │   │   └── com
    │   │       └── example
    │   │           └── ecommerce
    │   │               ├── model  // 实体类 (JPA)
    │   │               │   └── Product.java
    │   │               ├── dao  // 数据访问层 (Repository)
    │   │               │   └── ProductRepository.java
    │   │               ├── service // 业务逻辑层 (EJB)
    │   │               │   └── ProductService.java
    │   │               ├── web // Web层 (Servlets, Filters)
    │   │               │   ├── controller
    │   │               │   │   ├── ProductController.java (Servlet)
    │   │               │   │   └── AuthFilter.java (Servlet Filter)
    │   │               │   └── listener
    │   │               │       └── AppContextListener.java (ServletContextListener)
    │   │               └── security // 安全相关
    │   │                   └── SimpleLoginModule.java (可选，若用JAAS)
    │   ├── resources
    │   │   ├── META-INF
    │   │   │   ├── persistence.xml // JPA 配置
    │   │   │   └── beans.xml // CDI 激活 (需要空文件)
    │   │   └── application.properties // 可选，外部化配置
    │   └── webapp
    │       ├── WEB-INF
    │       │   ├── web.xml // Servlet 部署描述符 (可选，但推荐用于安全配置)
    │       │   ├── views // JSP 视图
    │       │   │   ├── product
    │       │   │   │   ├── list.jsp
    │       │   │   │   ├── form.jsp
    │       │   │   │   └── view.jsp
    │       │   │   └── login.jsp
    │       │   └── lib // JSTL等库
    │       ├── index.jsp // 重定向或首页
    │       └── resources // CSS, JS, Images
    └── test // 单元/集成测试

核心开发步骤详解

定义领域模型 (JPA Entity)

src/main/java/com/example/ecommerce/model/Product.java

package com.example.ecommerce.model;
import jakarta.persistence.;
import jakarta.validation.constraints.;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Entity
@Table(name = "products")
@NamedQuery(name = "Product.findAll", query = "SELECT p FROM Product p")
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    @NotBlank(message = "产品名称不能为空")
    @Size(min = 2, max = 100, message = "名称长度需在2-100字符之间")
    @Column(nullable = false, unique = true)
    private String name;
    @NotBlank(message = "描述不能为空")
    @Column(columnDefinition = "TEXT")
    private String description;
    @NotNull(message = "价格不能为空")
    @DecimalMin(value = "0.0", inclusive = false, message = "价格必须大于0")
    @Digits(integer = 10, fraction = 2, message = "价格格式无效")
    private BigDecimal price;
    @NotNull(message = "库存数量不能为空")
    @Min(value = 0, message = "库存不能为负数")
    private Integer stockQuantity;
    @Column(updatable = false)
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    // JPA 生命周期回调 - 持久化前设置创建时间
    @PrePersist
    protected void onCreate() {
        createdAt = LocalDateTime.now();
    }
    // JPA 生命周期回调 - 更新前设置更新时间
    @PreUpdate
    protected void onUpdate() {
        updatedAt = LocalDateTime.now();
    }
    // Getters and Setters (必须) ...
    // 省略构造函数 (JPA需要无参) ...
}

• 关键点： 使用@Entity标记为持久化对象，@Id定义主键。@Table指定表名。@NotBlank, @Size, @DecimalMin等来自Bean Validation，确保数据在进入业务层前有效。@PrePersist/@PreUpdate处理审计字段。

配置JPA (persistence.xml)

src/main/resources/META-INF/persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="3.1" xmlns="https://jakarta.ee/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="https://jakarta.ee/xml/ns/persistence https://jakarta.ee/xml/ns/persistence/persistence_3_1.xsd">
    <persistence-unit name="productPU" transaction-type="JTA">
        <description>Product Management Persistence Unit</description>
        <jta-data-source>java:jboss/datasources/ExampleDS</jta-data-source> <!-- 使用应用服务器配置的JNDI数据源 -->
        <class>com.example.ecommerce.model.Product</class>
        <properties>
            <!-- 使用Hibernate方言 (根据实际数据库调整) -->
            <property name="jakarta.persistence.jdbc.driver" value="org.postgresql.Driver"/> <!-- 仅在不使用JNDI时需显式指定 -->
            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/> <!-- 开发环境方便，生产环境请用validate或none -->
            <property name="hibernate.show_sql" value="true"/> <!-- 开发调试用 -->
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

• 关键点： transaction-type="JTA"声明使用容器管理的事务。<jta-data-source>引用应用服务器上配置的JNDI数据源（这是生产推荐方式）。hibernate.hbm2ddl.auto=update让Hibernate自动更新数据库模式（便于开发，生产务必禁用或改用Flyway/Liquibase）。

实现数据访问层 (Repository – EJB Stateless Session Bean)

src/main/java/com/example/ecommerce/dao/ProductRepository.java

package com.example.ecommerce.dao;
import com.example.ecommerce.model.Product;
import jakarta.ejb.Stateless;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import jakarta.persistence.TypedQuery;
import java.util.List;
import java.util.Optional;
@Stateless // 声明为无状态会话Bean，容器管理其生命周期、事务和并发
public class ProductRepository {
    @PersistenceContext(unitName = "productPU") // 容器注入EntityManager
    private EntityManager em;
    public Product save(Product product) {
        if (product.getId() == null) {
            em.persist(product); // 新增
            return product;
        } else {
            return em.merge(product); // 更新
        }
    }
    public Optional<Product> findById(Long id) {
        return Optional.ofNullable(em.find(Product.class, id));
    }
    public List<Product> findAll() {
        TypedQuery<Product> query = em.createNamedQuery("Product.findAll", Product.class);
        return query.getResultList();
    }
    public List<Product> searchByName(String keyword) {
        TypedQuery<Product> query = em.createQuery(
                "SELECT p FROM Product p WHERE LOWER(p.name) LIKE LOWER(:keyword)", Product.class);
        query.setParameter("keyword", "%" + keyword + "%");
        return query.getResultList();
    }
    public void deleteById(Long id) {
        Product product = findById(id).orElseThrow(() -> new IllegalArgumentException("无效的产品ID: " + id));
        em.remove(product);
    }
}

• 关键点： @Stateless使ProductRepository成为EJB，容器自动管理JTA事务（save, delete等方法默认在事务中执行）。@PersistenceContext由容器注入与当前事务关联的EntityManager，使用Optional处理可能为空的查询结果更安全。createNamedQuery利用实体类上定义的@NamedQuery。

实现业务逻辑层 (Service – EJB Stateless Session Bean)

src/main/java/com/example/ecommerce/service/ProductService.java

package com.example.ecommerce.service;
import com.example.ecommerce.dao.ProductRepository;
import com.example.ecommerce.model.Product;
import jakarta.ejb.Stateless;
import jakarta.inject.Inject;
import jakarta.validation.ConstraintViolation;
import jakarta.validation.ConstraintViolationException;
import jakarta.validation.Validator;
import java.util.List;
import java.util.Set;
@Stateless
public class ProductService {
    @Inject // CDI注入ProductRepository EJB
    private ProductRepository productRepository;
    @Inject // CDI注入Validator进行手动验证
    private Validator validator;
    public Product createProduct(Product product) {
        // 手动触发Bean Validation (JPA的persist/merge也会触发，这里展示手动方式)
        Set<ConstraintViolation<Product>> violations = validator.validate(product);
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
        return productRepository.save(product);
    }
    public Product updateProduct(Long id, Product productDetails) {
        Product existingProduct = productRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("产品不存在，ID: " + id));
        // 更新逻辑 (避免直接覆盖敏感字段如createdAt)
        existingProduct.setName(productDetails.getName());
        existingProduct.setDescription(productDetails.getDescription());
        existingProduct.setPrice(productDetails.getPrice());
        existingProduct.setStockQuantity(productDetails.getStockQuantity());
        // 再次验证
        Set<ConstraintViolation<Product>> violations = validator.validate(existingProduct);
        if (!violations.isEmpty()) {
            throw new ConstraintViolationException(violations);
        }
        return productRepository.save(existingProduct);
    }
    public List<Product> getAllProducts() {
        return productRepository.findAll();
    }
    public Product getProductById(Long id) {
        return productRepository.findById(id)
                .orElseThrow(() -> new IllegalArgumentException("产品不存在，ID: " + id));
    }
    public List<Product> searchProducts(String keyword) {
        return productRepository.searchByName(keyword);
    }
    public void deleteProduct(Long id) {
        productRepository.deleteById(id);
    }
}

• 关键点： @Inject（CDI）用于注入ProductRepository EJB和Validator。ProductService封装了更复杂的业务逻辑（如更新时避免覆盖审计字段、手动验证），它作为业务门面（Facade），为Web层提供清晰的服务接口,事务边界通常定义在Service层方法。

实现Web控制器 (Servlet)

src/main/java/com/example/ecommerce/web/controller/ProductController.java

package com.example.ecommerce.web.controller;
import com.example.ecommerce.model.Product;
import com.example.ecommerce.service.ProductService;
import jakarta.inject.Inject;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
@WebServlet(name = "ProductController", urlPatterns = {"/products", "/products/"})
public class ProductController extends HttpServlet {
    @Inject
    private ProductService productService;
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String pathInfo = request.getPathInfo();
        String action = (pathInfo == null || pathInfo.equals("/")) ? "list" : pathInfo.substring(1);
        try {
            switch (action) {
                case "new":
                    showNewForm(request, response);
                    break;
                case "edit":
                    showEditForm(request, response);
                    break;
                case "view":
                    viewProduct(request, response);
                    break;
                case "search":
                    searchProducts(request, response);
                    break;
                case "list":
                default:
                    listProducts(request, response);
                    break;
            }
        } catch (Exception ex) {
            request.setAttribute("errorMessage", "操作失败: " + ex.getMessage());
            request.getRequestDispatcher("/WEB-INF/views/error.jsp").forward(request, response);
        }
    }
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String pathInfo = request.getPathInfo();
        String action = (pathInfo == null || pathInfo.equals("/")) ? "create" : pathInfo.substring(1);
        try {
            switch (action) {
                case "create":
                    createProduct(request, response);
                    break;
                case "update":
                    updateProduct(request, response);
                    break;
                case "delete":
                    deleteProduct(request, response);
                    break;
            }
        } catch (Exception ex) {
            request.setAttribute("errorMessage", "操作失败: " + ex.getMessage());
            request.getRequestDispatcher("/WEB-INF/views/error.jsp").forward(request, response);
        }
    }
    private void listProducts(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Product> products = productService.getAllProducts();
        request.setAttribute("products", products);
        request.getRequestDispatcher("/WEB-INF/views/product/list.jsp").forward(request, response);
    }
    private void searchProducts(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String keyword = request.getParameter("keyword");
        List<Product> products = productService.searchProducts(keyword);
        request.setAttribute("products", products);
        request.setAttribute("searchKeyword", keyword);
        request.getRequestDispatcher("/WEB-INF/views/product/list.jsp").forward(request, response);
    }
    private void showNewForm(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        request.getRequestDispatcher("/WEB-INF/views/product/form.jsp").forward(request, response);
    }
    private void showEditForm(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Long id = Long.parseLong(request.getParameter("id"));
        Product product = productService.getProductById(id);
        request.setAttribute("product", product);
        request.getRequestDispatcher("/WEB-INF/views/product/form.jsp").forward(request, response);
    }
    private void viewProduct(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        Long id = Long.parseLong(request.getParameter("id"));
        Product product = productService.getProductById(id);
        request.setAttribute("product", product);
        request.getRequestDispatcher("/WEB-INF/views/product/view.jsp").forward(request, response);
    }
    private void createProduct(HttpServletRequest request, HttpServletResponse response) throws IOException {
        Product product = extractProductFromRequest(request);
        productService.createProduct(product);
        response.sendRedirect(request.getContextPath() + "/products?success=create");
    }
    private void updateProduct(HttpServletRequest request, HttpServletResponse response) throws IOException {
        Long id = Long.parseLong(request.getParameter("id"));
        Product productDetails = extractProductFromRequest(request);
        productService.updateProduct(id, productDetails);
        response.sendRedirect(request.getContextPath() + "/products?success=update");
    }
    private void deleteProduct(HttpServletRequest request, HttpServletResponse response) throws IOException {
        Long id = Long.parseLong(request.getParameter("id"));
        productService.deleteProduct(id);
        response.sendRedirect(request.getContextPath() + "/products?success=delete");
    }
    private Product extractProductFromRequest(HttpServletRequest request) {
        Product product = new Product();
        product.setName(request.getParameter("name"));
        product.setDescription(request.getParameter("description"));
        product.setPrice(new BigDecimal(request.getParameter("price")));
        product.setStockQuantity(Integer.parseInt(request.getParameter("stockQuantity")));
        return product;
    }
}

• 关键点： @WebServlet注解配置Servlet URL映射。@Inject注入ProductService。doGet处理页面展示请求（列表、表单、详情），doPost处理表单提交（创建、更新、删除），使用switch根据URL路径(pathInfo)或参数(action)路由到不同的内部方法，表单数据处理后使用response.sendRedirect进行PRG模式（Post-Redirect-Get）避免重复提交，异常统一捕获并转发到错误页面。extractProductFromRequest方法演示了简单的请求参数到对象的绑定（更复杂场景可用BeanUtils或框架）。

实现视图层 (JSP + JSTL)

/WEB-INF/views/product/list.jsp (核心片段)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="jakarta.tags.core" %>
<%@ taglib prefix="fmt" uri="jakarta.tags.fmt" %>
<!DOCTYPE html>
<html>
<head>产品列表</title>
    <!-- Bootstrap CSS 等样式引入 -->
</head>
<body>
    <div class="container">
        <h1>产品管理</h1>
        <!-- 搜索表单 -->
        <form action="${pageContext.request.contextPath}/products/search" method="get" class="mb-3">
            <div class="input-group">
                <input type="text" name="keyword" class="form-control" placeholder="搜索产品名称..." value="${param.keyword}">
                <button type="submit" class="btn btn-primary">搜索</button>
            </div>
        </form>
        <!-- 操作按钮 -->
        <a href="${pageContext.request.contextPath}/products/new" class="btn btn-success mb-3">添加新产品</a>
        <!-- 成功/错误消息 -->
        <c:if test="${not empty param.success}">
            <div class="alert alert-success alert-dismissible fade show">
                <c:choose>
                    <c:when test="${param.success eq 'create'}">产品添加成功！</c:when>
                    <c:when test="${param.success eq 'update'}">产品更新成功！</c:when>
                    <c:when test="${param.success eq 'delete'}">产品删除成功！</c:when>
                </c:choose>
                <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
            </div>
        </c:if>
        <!-- 产品表格 -->
        <table class="table table-striped table-hover">
            <thead>
                <tr>
                    <th>ID</th>
                    <th>产品名称</th>
                    <th>描述</th>
                    <th>价格</th>
                    <th>库存</th>
                    <th>操作</th>
                </tr>
            </thead>
            <tbody>
                <c:forEach var="product" items="${products}">
                    <tr>
                        <td>${product.id}</td>
                        <td>${product.name}</td>
                        <td>${fn:substring(product.description, 0, 50)}<c:if test="${fn:length(product.description) > 50}">...</c:if></td>
                        <td><fmt:formatNumber value="${product.price}" type="currency"/></td>
                        <td>${product.stockQuantity}</td>
                        <td>
                            <a href="${pageContext.request.contextPath}/products/view?id=${product.id}" class="btn btn-info btn-sm">查看</a>
                            <a href="${pageContext.request.contextPath}/products/edit?id=${product.id}" class="btn btn-warning btn-sm">编辑</a>
                            <form action="${pageContext.request.contextPath}/products/delete" method="post" style="display:inline;">
                                <input type="hidden" name="id" value="${product.id}">
                                <button type="submit" class="btn btn-danger btn-sm" onclick="return confirm('确定删除该产品吗？')">删除</button>
                            </form>
                        </td>
                    </tr>
                </c:forEach>
            </tbody>
        </table>
    </div>
    <!-- Bootstrap JS 等脚本引入 -->
</body>
</html>

• 关键点： 使用JSTL核心标签<c:forEach>遍历产品列表，<c:if>, <c:choose>/<c:when>处理条件逻辑和消息显示。<fmt:formatNumber>格式化货币。fn:substring(需引入fn标签库)截断长描述，表单使用${pageContext.request.contextPath}确保路径正确，删除操作使用JavaScript confirm进行二次确认，页面布局和样式采用Bootstrap框架（需引入相应CSS/JS）。form.jsp和view.jsp的实现逻辑类似，分别用于展示编辑/创建表单和产品详情。

实现基本安全控制 (Servlet Filter + web.xml / Jakarta Security)

方案A：使用Servlet Filter (简单认证)

src/main/java/com/example/ecommerce/web/AuthFilter.java

package com.example.ecommerce.web;
import jakarta.servlet.;
import jakarta.servlet.annotation.WebFilter;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;
import java.io.IOException;
@WebFilter(urlPatterns = {"/products/", "/products"}) // 保护所有产品管理相关URL
public class AuthFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        HttpSession session = httpRequest.getSession(false); // 不创建新session
        boolean isLoggedIn = (session != null && session.getAttribute("user") != null);
        boolean isLoginRequest = httpRequest.getRequestURI().endsWith("/login") || httpRequest.getRequestURI().endsWith("/login.jsp");
        boolean isStaticResource = httpRequest.getRequestURI().contains("/resources/");
        if (isLoggedIn || isLoginRequest || isStaticResource) {
            chain.doFilter(request, response); // 放行
        } else {
            // 重定向到登录页面，保存原始请求URL便于登录后跳转
            String originalUrl = httpRequest.getRequestURL().toString();
            String queryString = httpRequest.getQueryString();
            if (queryString != null) {
                originalUrl += "?" + queryString;
            }
            session = httpRequest.getSession();
            session.setAttribute("originalRequest", originalUrl);
            httpResponse.sendRedirect(httpRequest.getContextPath() + "/login.jsp");
        }
    }
    // init() and destroy() ...
}

/login.jsp (简化版表单)

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<form action="${pageContext.request.contextPath}/j_security_check" method="post"> <!-- 使用容器管理的j_security_check -->
    <input type="text" name="j_username" placeholder="用户名" required>
    <input type="password" name="j_password" placeholder="密码" required>
    <button type="submit">登录</button>
</form>

src/main/webapp/WEB-INF/web.xml (配置JAAS Realm和约束 – 片段)

<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
         version="6.0">
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>Protected Resources</web-resource-name>
            <url-pattern>/products/</url-pattern>
            <url-pattern>/products</url-pattern>
        </web-resource-collection>
        <auth-constraint>
            <role-name>admin</role-name> <!-- 应用服务器上配置的角色 -->
        </auth-constraint>
    </security-constraint>
    <login-config>
        <auth-method>FORM</auth-method>
        <form-login-config>
            <form-login-page>/login.jsp</form-login-page>
            <form-error-page>/login.jsp?error=true</form-error-page>
        </form-login-config>
    </login-config>
    <security-role>
        <role-name>admin</role-name>
    </security-role>
</web-app>

• 关键点 (Filter方案)： AuthFilter拦截受保护路径，检查Session中是否存在登录标识(user)，未登录用户重定向到登录页，登录表单提交到容器标准的j_security_check URL。web.xml配置声明哪些URL需要admin角色,以及FORM登录的页面。

方案B：使用Jakarta Security 3.0 (更现代，推荐)

• 定义身份存储（如数据库、LDAP）。
• 使用@BasicAuthenticationMechanismDefinition或@FormAuthenticationMechanismDefinition注解配置认证机制。
• 在ProductService方法或Servlet上使用@RolesAllowed("admin")注解进行细粒度方法级授权。
• 需要应用服务器支持Jakarta Security,配置更集中且类型安全。

部署与优化

1. 打包: 使用Maven命令 mvn clean package 生成WAR文件 (target/product-management-system.war)。
2. 部署: 将WAR文件复制到应用服务器（如WildFly）的 standalone/deployments/ 目录,服务器会自动部署。
3. 数据库连接池调优: 在应用服务器配置中（如WildFly的standalone.xml）调整所使用的数据源(ExampleDS)的连接池参数（max-pool-size, min-pool-size, idle-timeout-minutes等）,匹配生产负载。
4. JPA 二级缓存: 配置Hibernate二级缓存（如Ehcache, Infinispan）以提升频繁读取数据的性能，在persistence.xml中添加缓存相关属性。
5. JVM 调优: 根据服务器内存设置合适的JVM堆大小 (-Xms, -Xmx)，选择垃圾收集器（如G1GC）。
6. 静态资源缓存: 配置Web服务器或CDN对CSS、JS、图片等静态资源进行缓存。
7. 集群化 (可选): 对于高可用需求，配置应用服务器集群（如WildFly域模式）和分布式会话（在web.xml中添加<distributable/>标签）以及负载均衡器（如Nginx, HAProxy）。

总结与进阶思考

本实例展示了使用J2EE/Jakarta EE核心技术栈构建一个典型企业级Web应用的核心流程，我们实践了分层架构（Web层->Service层->DAO层->Model层）、容器管理的事务（EJB）、依赖注入（CDI）、ORM（JPA/Hibernate）、输入验证（Bean Validation）和基础安全（Filter/Jakarta Security）。

• 超越基础：
  • RESTful API: 使用JAX-RS (Jakarta RESTful Web Services) 替代Servlet,构建前后端分离的API。
  • 异步处理: 使用Servlet 3.1+的异步I/O或JMS/MDB处理耗时操作,提升吞吐量。
  • 更复杂业务逻辑: 在Service层实现涉及多个实体的事务性操作、业务规则引擎集成。
  • 前端框架集成: 将JSP视图替换为现代前端框架（如React, Vue.js, Angular）,通过API交互。
  • 微服务化: 将不同功能模块拆分为独立的微服务（使用MicroProfile或Spring Boot），部署在容器平台（如Kubernetes）。
  • 全面监控: 集成应用性能管理(APM)工具（如Jaeger, Prometheus+Grafana）和日志集中管理（ELK Stack）。

J2EE/Jakarta EE平台提供了构建稳健、可扩展企业应用的坚实基础，理解其核心组件（Servlet, JSP, EJB, JPA）的协作机制和最佳实践，是驾驭复杂企业级开发的关键，虽然现代开发中Spring Boot因其便利性非常流行，但掌握标准的Jakarta EE规范能让你更深刻地理解Java企业级开发的本质,并能在需要严格遵循标准或使用特定应用服务器时游刃有余。

你更倾向于使用哪种方式实现业务层？是传统的EJB还是更轻量的CDI Managed Bean？在实际项目中，你会如何处理复杂的跨实体事务？欢迎分享你的经验和见解！