• JSP Servlet JDBC MySQL CRUD 示例教程

    在本教程中，我们将构建一个简单的用户管理Web 应用程序，它管理具有基本功能的用户集合：列表、插入、更新、删除（或 CURD 操作 - 创建、更新、读取和删除）。
    您可以从我的 GitHub 存储库下载本教程的源代码，本教程末尾提供了链接。
    顶级 JSP、Servlet 和 JDBC 教程：
    查看 使用 JSP、Servlet、JDBC 和 MySQL 构建 Todo 应用程序。 

    我们将在我们的用户管理Web 应用程序中开发以下简单的基本功能：

    1. 创建用户
    2. 更新用户
    3. 删除用户
    4. 检索用户
    5. 所有用户列表
    该应用程序看起来像这样：

     

    使用的工具和技术

    • JSP - 2.2 +
    • IDE - STS/Eclipse Neon.3
    • JDK - 1.8 或更高版本
    • Apache Tomcat - 8.5
    • JSTL - 1.2.1
    • 小服务程序 API - 2.5
    • MySQL - mysql-connector-java-8.0.13.jar

    开发步骤

    1. 创建 Eclipse 动态 Web 项目
    2. 添加依赖项
    3. 项目结构
    4. MySQL 数据库设置
    5. 创建一个 JavaBean - User.java
    6. 创建一个 UserDAO.java
    7. 创建一个 UserServlet.java
    8. 创建用户列表 JSP 页面 - user-list.jsp
    9. 创建用户表单 JSP 页面 - user-form.jsp
    10. 创建错误 JSP 页面
    11. 部署和测试应用程序演示

    类图

     这是我们将在本教程中开发的用户管理Web 应用程序 的类图 ：

    1. 创建一个 Eclipse 动态 Web 项目

    在 Eclipse 中创建一个新的动态 Web 项目：
    1. 在主菜单上选择 文件 > 新建 > 项目...。
    2. 在即将出现的向导中，选择 Web > Dynamic Web Project。
    3. 单击 下一步。
    4. 输入项目名称为“jsp-servlet-jdbc-mysql-example”；
    5. 确保目标运行时设置为具有当前支持的版本的 Apache Tomcat。 

    2.添加依赖

    将以下 jar 文件的最新版本添加到 lib 文件夹。
    • jsp-api.2.3.1.jar
    • servlet-api.2.3.jar
    • mysql-connector-java-8.0.13.jar
    • jstl-1.2.jar

    三、项目结构

    标准项目结构供您参考- 
     

    4. MySQL 数据库设置

    让我们在 MySQL 中创建一个名为“demo”的数据库。现在，使用下面的 DDL 脚本创建一个用户表： 
    1. CREATE DATABASE 'demo';
    2. USE demo;
    3.  
    4. create table users (
    5. 	id  int(3) NOT NULL AUTO_INCREMENT,
    6. 	name varchar(120) NOT NULL,
    7. 	email varchar(220) NOT NULL,
    8. 	country varchar(120),
    9. 	PRIMARY KEY (id)
    10. );
    11.

    您可以使用 MySQL 命令行客户端或 MySQL Workbench 工具来创建数据库。上面的 用户表如下所示：

    5.创建一个JavaBean——User.java

    让我们使用以下代码 创建一个User java 类来对数据库中的用户实体进行建模： 
    1. package net.javaguides.usermanagement.model;
    2.  
    3. /**
    4.  * User.java
    5.  * This is a model class represents a User entity
    6.  * @author Ramesh Fadatare
    7.  *
    8.  */
    9. public class User {
    10. 	protected int id;
    11. 	protected String name;
    12. 	protected String email;
    13. 	protected String country;
    14. 	
    15. 	public User() {
    16. 	}
    17. 	
    18. 	public User(String name, String email, String country) {
    19. 		super();
    20. 		this.name = name;
    21. 		this.email = email;
    22. 		this.country = country;
    23. 	}
    24.  
    25. 	public User(int id, String name, String email, String country) {
    26. 		super();
    27. 		this.id = id;
    28. 		this.name = name;
    29. 		this.email = email;
    30. 		this.country = country;
    31. 	}
    32.  
    33. 	public int getId() {
    34. 		return id;
    35. 	}
    36. 	public void setId(int id) {
    37. 		this.id = id;
    38. 	}
    39. 	public String getName() {
    40. 		return name;
    41. 	}
    42. 	public void setName(String name) {
    43. 		this.name = name;
    44. 	}
    45. 	public String getEmail() {
    46. 		return email;
    47. 	}
    48. 	public void setEmail(String email) {
    49. 		this.email = email;
    50. 	}
    51. 	public String getCountry() {
    52. 		return country;
    53. 	}
    54. 	public void setCountry(String country) {
    55. 		this.country = country;
    56. 	}
    57. }

    6.创建一个UserDAO.java

    让我们创建一个UserDAO类，它是一个数据访问层 (DAO) 类，它为数据库中的表用户 提供 CRUD（创建、读取、更新、删除）操作。这是UserDAO的完整源代码： 
    1. package net.javaguides.usermanagement.dao;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.DriverManager;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8. import java.util.ArrayList;
    9. import java.util.List;
    10.  
    11. import net.javaguides.usermanagement.model.User;
    12.  
    13. /**
    14.  * AbstractDAO.java This DAO class provides CRUD database operations for the
    15.  * table users in the database.
    16.  * 
    17.  * @author Ramesh Fadatare
    18.  *
    19.  */
    20. public class UserDAO {
    21. 	private String jdbcURL = "jdbc:mysql://localhost:3306/demo?useSSL=false";
    22. 	private String jdbcUsername = "root";
    23. 	private String jdbcPassword = "root";
    24.  
    25. 	private static final String INSERT_USERS_SQL = "INSERT INTO users" + "  (name, email, country) VALUES "
    26. 			+ " (?, ?, ?);";
    27.  
    28. 	private static final String SELECT_USER_BY_ID = "select id,name,email,country from users where id =?";
    29. 	private static final String SELECT_ALL_USERS = "select * from users";
    30. 	private static final String DELETE_USERS_SQL = "delete from users where id = ?;";
    31. 	private static final String UPDATE_USERS_SQL = "update users set name = ?,email= ?, country =? where id = ?;";
    32.  
    33. 	public UserDAO() {
    34. 	}
    35.  
    36. 	protected Connection getConnection() {
    37. 		Connection connection = null;
    38. 		try {
    39. 			Class.forName("com.mysql.jdbc.Driver");
    40. 			connection = DriverManager.getConnection(jdbcURL, jdbcUsername, jdbcPassword);
    41. 		} catch (SQLException e) {
    42. 			// TODO Auto-generated catch block
    43. 			e.printStackTrace();
    44. 		} catch (ClassNotFoundException e) {
    45. 			// TODO Auto-generated catch block
    46. 			e.printStackTrace();
    47. 		}
    48. 		return connection;
    49. 	}
    50.  
    51. 	public void insertUser(User user) throws SQLException {
    52. 		System.out.println(INSERT_USERS_SQL);
    53. 		// try-with-resource statement will auto close the connection.
    54. 		try (Connection connection = getConnection();
    55. 				PreparedStatement preparedStatement = connection.prepareStatement(INSERT_USERS_SQL)) {
    56. 			preparedStatement.setString(1, user.getName());
    57. 			preparedStatement.setString(2, user.getEmail());
    58. 			preparedStatement.setString(3, user.getCountry());
    59. 			System.out.println(preparedStatement);
    60. 			preparedStatement.executeUpdate();
    61. 		} catch (SQLException e) {
    62. 			printSQLException(e);
    63. 		}
    64. 	}
    65.  
    66. 	public User selectUser(int id) {
    67. 		User user = null;
    68. 		// Step 1: Establishing a Connection
    69. 		try (Connection connection = getConnection();
    70. 				// Step 2:Create a statement using connection object
    71. 				PreparedStatement preparedStatement = connection.prepareStatement(SELECT_USER_BY_ID);) {
    72. 			preparedStatement.setInt(1, id);
    73. 			System.out.println(preparedStatement);
    74. 			// Step 3: Execute the query or update query
    75. 			ResultSet rs = preparedStatement.executeQuery();
    76.  
    77. 			// Step 4: Process the ResultSet object.
    78. 			while (rs.next()) {
    79. 				String name = rs.getString("name");
    80. 				String email = rs.getString("email");
    81. 				String country = rs.getString("country");
    82. 				user = new User(id, name, email, country);
    83. 			}
    84. 		} catch (SQLException e) {
    85. 			printSQLException(e);
    86. 		}
    87. 		return user;
    88. 	}
    89.  
    90. 	public List selectAllUsers() {
    91.  
    92. 		// using try-with-resources to avoid closing resources (boiler plate code)
    93. 		List users = new ArrayList<>();
    94. 		// Step 1: Establishing a Connection
    95. 		try (Connection connection = getConnection();
    96.  
    97. 				// Step 2:Create a statement using connection object
    98. 			PreparedStatement preparedStatement = connection.prepareStatement(SELECT_ALL_USERS);) {
    99. 			System.out.println(preparedStatement);
    100. 			// Step 3: Execute the query or update query
    101. 			ResultSet rs = preparedStatement.executeQuery();
    102.  
    103. 			// Step 4: Process the ResultSet object.
    104. 			while (rs.next()) {
    105. 				int id = rs.getInt("id");
    106. 				String name = rs.getString("name");
    107. 				String email = rs.getString("email");
    108. 				String country = rs.getString("country");
    109. 				users.add(new User(id, name, email, country));
    110. 			}
    111. 		} catch (SQLException e) {
    112. 			printSQLException(e);
    113. 		}
    114. 		return users;
    115. 	}
    116.  
    117. 	public boolean deleteUser(int id) throws SQLException {
    118. 		boolean rowDeleted;
    119. 		try (Connection connection = getConnection();
    120. 				PreparedStatement statement = connection.prepareStatement(DELETE_USERS_SQL);) {
    121. 			statement.setInt(1, id);
    122. 			rowDeleted = statement.executeUpdate() > 0;
    123. 		}
    124. 		return rowDeleted;
    125. 	}
    126.  
    127. 	public boolean updateUser(User user) throws SQLException {
    128. 		boolean rowUpdated;
    129. 		try (Connection connection = getConnection();
    130. 				PreparedStatement statement = connection.prepareStatement(UPDATE_USERS_SQL);) {
    131. 			statement.setString(1, user.getName());
    132. 			statement.setString(2, user.getEmail());
    133. 			statement.setString(3, user.getCountry());
    134. 			statement.setInt(4, user.getId());
    135.  
    136. 			rowUpdated = statement.executeUpdate() > 0;
    137. 		}
    138. 		return rowUpdated;
    139. 	}
    140.  
    141. 	private void printSQLException(SQLException ex) {
    142. 		for (Throwable e : ex) {
    143. 			if (e instanceof SQLException) {
    144. 				e.printStackTrace(System.err);
    145. 				System.err.println("SQLState: " + ((SQLException) e).getSQLState());
    146. 				System.err.println("Error Code: " + ((SQLException) e).getErrorCode());
    147. 				System.err.println("Message: " + e.getMessage());
    148. 				Throwable t = ex.getCause();
    149. 				while (t != null) {
    150. 					System.out.println("Cause: " + t);
    151. 					t = t.getCause();
    152. 				}
    153. 			}
    154. 		}
    155. 	}
    156.  
    157. }

    7.创建一个UserServlet.java

    现在，让我们创建UserServlet作为页面控制器来处理来自客户端的所有请求。我们先来看代码： 
    1. package net.javaguides.usermanagement.web;
    2.  
    3. import java.io.IOException;
    4. import java.sql.SQLException;
    5. import java.util.List;
    6.  
    7. import javax.servlet.RequestDispatcher;
    8. import javax.servlet.ServletException;
    9. import javax.servlet.annotation.WebServlet;
    10. import javax.servlet.http.HttpServlet;
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13.  
    14. import net.javaguides.usermanagement.dao.UserDAO;
    15. import net.javaguides.usermanagement.model.User;
    16.  
    17. /**
    18.  * ControllerServlet.java
    19.  * This servlet acts as a page controller for the application, handling all
    20.  * requests from the user.
    21.  * @email Ramesh Fadatare
    22.  */
    23.  
    24. @WebServlet("/")
    25. public class UserServlet extends HttpServlet {
    26. 	private static final long serialVersionUID = 1L;
    27. 	private UserDAO userDAO;
    28. 	
    29. 	public void init() {
    30. 		userDAO = new UserDAO();
    31. 	}
    32.  
    33. 	protected void doPost(HttpServletRequest request, HttpServletResponse response)
    34. 			throws ServletException, IOException {
    35. 		doGet(request, response);
    36. 	}
    37.  
    38. 	protected void doGet(HttpServletRequest request, HttpServletResponse response)
    39. 			throws ServletException, IOException {
    40. 		String action = request.getServletPath();
    41.  
    42. 		try {
    43. 			switch (action) {
    44. 			case "/new":
    45. 				showNewForm(request, response);
    46. 				break;
    47. 			case "/insert":
    48. 				insertUser(request, response);
    49. 				break;
    50. 			case "/delete":
    51. 				deleteUser(request, response);
    52. 				break;
    53. 			case "/edit":
    54. 				showEditForm(request, response);
    55. 				break;
    56. 			case "/update":
    57. 				updateUser(request, response);
    58. 				break;
    59. 			default:
    60. 				listUser(request, response);
    61. 				break;
    62. 			}
    63. 		} catch (SQLException ex) {
    64. 			throw new ServletException(ex);
    65. 		}
    66. 	}
    67.  
    68. 	private void listUser(HttpServletRequest request, HttpServletResponse response)
    69. 			throws SQLException, IOException, ServletException {
    70. 		List listUser = userDAO.selectAllUsers();
    71. 		request.setAttribute("listUser", listUser);
    72. 		RequestDispatcher dispatcher = request.getRequestDispatcher("user-list.jsp");
    73. 		dispatcher.forward(request, response);
    74. 	}
    75.  
    76. 	private void showNewForm(HttpServletRequest request, HttpServletResponse response)
    77. 			throws ServletException, IOException {
    78. 		RequestDispatcher dispatcher = request.getRequestDispatcher("user-form.jsp");
    79. 		dispatcher.forward(request, response);
    80. 	}
    81.  
    82. 	private void showEditForm(HttpServletRequest request, HttpServletResponse response)
    83. 			throws SQLException, ServletException, IOException {
    84. 		int id = Integer.parseInt(request.getParameter("id"));
    85. 		User existingUser = userDAO.selectUser(id);
    86. 		RequestDispatcher dispatcher = request.getRequestDispatcher("user-form.jsp");
    87. 		request.setAttribute("user", existingUser);
    88. 		dispatcher.forward(request, response);
    89.  
    90. 	}
    91.  
    92. 	private void insertUser(HttpServletRequest request, HttpServletResponse response) 
    93. 			throws SQLException, IOException {
    94. 		String name = request.getParameter("name");
    95. 		String email = request.getParameter("email");
    96. 		String country = request.getParameter("country");
    97. 		User newUser = new User(name, email, country);
    98. 		userDAO.insertUser(newUser);
    99. 		response.sendRedirect("list");
    100. 	}
    101.  
    102. 	private void updateUser(HttpServletRequest request, HttpServletResponse response) 
    103. 			throws SQLException, IOException {
    104. 		int id = Integer.parseInt(request.getParameter("id"));
    105. 		String name = request.getParameter("name");
    106. 		String email = request.getParameter("email");
    107. 		String country = request.getParameter("country");
    108.  
    109. 		User book = new User(id, name, email, country);
    110. 		userDAO.updateUser(book);
    111. 		response.sendRedirect("list");
    112. 	}
    113.  
    114. 	private void deleteUser(HttpServletRequest request, HttpServletResponse response) 
    115. 			throws SQLException, IOException {
    116. 		int id = Integer.parseInt(request.getParameter("id"));
    117. 		userDAO.deleteUser(id);
    118. 		response.sendRedirect("list");
    119.  
    120. 	}
    121.  
    122. }

    8. 创建用户列表 JSP 页面 - user-list.jsp

    接下来，创建一个 JSP 页面来显示数据库中的所有用户。让我们在项目的WebContent目录下创建一个 list-user.jsp页面，代码如下： 
    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2. 	pageEncoding="UTF-8"%>
    3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    4. <html>
    5. <head>
    6. <title>User Management Applicationtitle>
    7. <link rel="stylesheet"
    8. 	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
    9. 	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
    10. 	crossorigin="anonymous">
    11. head>
    12. <body>
    13.  
    14. 	<header>
    15. 		<nav class="navbar navbar-expand-md navbar-dark"
    16. 			style="background-color: tomato">
    17. 			<div>
    18. 				<a href="https://www.javaguides.net" class="navbar-brand"> User
    19. 					Management App a>
    20. 			div>
    21.  
    22. 			<ul class="navbar-nav">
    23. 				<li><a href="<%=request.getContextPath()%>/list"
    24. 					class="nav-link">Usersa>li>
    25. 			ul>
    26. 		nav>
    27. 	header>
    28. 	<br>
    29.  
    30. 	<div class="row">
    31. 		
    32.  
    33. 		<div class="container">
    34. 			<h3 class="text-center">List of Usersh3>
    35. 			<hr>
    36. 			<div class="container text-left">
    37.  
    38. 				<a href="<%=request.getContextPath()%>/new" class="btn btn-success">Add
    39. 					New Usera>
    40. 			div>
    41. 			<br>
    42. 			<table class="table table-bordered">
    43. 				<thead>
    44. 					<tr>
    45. 						<th>IDth>
    46. 						<th>Nameth>
    47. 						<th>Emailth>
    48. 						<th>Countryth>
    49. 						<th>Actionsth>
    50. 					tr>
    51. 				thead>
    52. 				<tbody>
    53. 					
    54. 					<c:forEach var="user" items="${listUser}">
    55.  
    56. 						<tr>
    57. 							<td><c:out value="${user.id}" />td>
    58. 							<td><c:out value="${user.name}" />td>
    59. 							<td><c:out value="${user.email}" />td>
    60. 							<td><c:out value="${user.country}" />td>
    61. 							<td><a href="edit?id=">Edita>
    62. 								     <a
    63. 								href="delete?id=">Deletea>td>
    64. 						tr>
    65. 					c:forEach>
    66. 					
    67. 				tbody>
    68.  
    69. 			table>
    70. 		div>
    71. 	div>
    72. body>
    73. html>

    一旦您将在 tomcat 中部署以上 JSP 页面并在浏览器中打开，如下所示：

    9. 创建用户表单 JSP 页面 - user-form.jsp

    接下来，我们创建一个 JSP 页面来创建一个名为user-form.jsp的新用户。这是它的完整源代码： 
    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2. 	pageEncoding="UTF-8"%>
    3. <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
    4. <html>
    5. <head>
    6. <title>User Management Applicationtitle>
    7. <link rel="stylesheet"
    8. 	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
    9. 	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
    10. 	crossorigin="anonymous">
    11. head>
    12. <body>
    13.  
    14. 	<header>
    15. 		<nav class="navbar navbar-expand-md navbar-dark"
    16. 			style="background-color: tomato">
    17. 			<div>
    18. 				<a href="https://www.javaguides.net" class="navbar-brand"> User Management App a>
    19. 			div>
    20.  
    21. 			<ul class="navbar-nav">
    22. 				<li><a href="<%=request.getContextPath()%>/list"
    23. 					class="nav-link">Usersa>li>
    24. 			ul>
    25. 		nav>
    26. 	header>
    27. 	<br>
    28. 	<div class="container col-md-5">
    29. 		<div class="card">
    30. 			<div class="card-body">
    31. 				<c:if test="${user != null}">
    32. 					<form action="update" method="post">
    33. 				c:if>
    34. 				<c:if test="${user == null}">
    35. 					<form action="insert" method="post">
    36. 				c:if>
    37.  
    38. 				<caption>
    39. 					<h2>
    40. 						<c:if test="${user != null}">
    41.             			Edit User
    42.             		c:if>
    43. 						<c:if test="${user == null}">
    44.             			Add New User
    45.             		c:if>
    46. 					h2>
    47. 				caption>
    48.  
    49. 				<c:if test="${user != null}">
    50. 					<input type="hidden" name="id" value="" />
    51. 				c:if>
    52.  
    53. 				<fieldset class="form-group">
    54. 					<label>User Namelabel> <input type="text"
    55. 						value="" class="form-control"
    56. 						name="name" required="required">
    57. 				fieldset>
    58.  
    59. 				<fieldset class="form-group">
    60. 					<label>User Emaillabel> <input type="text"
    61. 						value="" class="form-control"
    62. 						name="email">
    63. 				fieldset>
    64.  
    65. 				<fieldset class="form-group">
    66. 					<label>User Countrylabel> <input type="text"
    67. 						value="" class="form-control"
    68. 						name="country">
    69. 				fieldset>
    70.  
    71. 				<button type="submit" class="btn btn-success">Savebutton>
    72. 				form>
    73. 			div>
    74. 		div>
    75. 	div>
    76. body>
    77. html>

    一旦您将在 tomcat 中部署以上 JSP 页面并在浏览器中打开，如下所示：
    上面的页面用于创建新用户和编辑同一用户的两种功能。编辑页面如下所示：

    10. 创建错误 JSP 页面

    这是Error.jsp页面 的代码，它只显示异常消息： 
    1. <%@ page language="java" contentType="text/html; charset=UTF-8"
    2.     pageEncoding="UTF-8" isErrorPage="true" %>
    3. html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
    4. 	"http://www.w3.org/TR/html4/loose.dtd">
    5. <html>
    6. <head>
    7. <title>Errortitle>
    8. head>
    9. <body>
    10. 	<center>
    11. 		<h1>Errorh1>
    12. 		<h2><%=exception.getMessage() %><br/> h2>
    13. 	center>	
    14. body>
    15. html>

    11. 部署和测试应用程序

    是时候看一下上述用户管理Web 应用程序的演示了。在 tomcat 服务器中部署这个 web 应用程序。 
    在 Web 浏览器中键入以下 URL 以访问用户管理应用程序：  http://localhost:8080/jsp-servlet-jdbc-mysql-crud-example/

    创建新用户

    编辑用户

    所有用户列表

    GitHub 存储库

    本教程（用户管理）的源代码可在我的 GitHub 存储库中获得， 网址为GitHub - RameshMF/jsp-servlet-jdbc-mysql-crud-tutorial: JSP Servlet JDBC MySQL CRUD Example Tutorial。
    附：中文乱码过滤器 
    1.  
    2. import java.io.IOException;
    3. import javax.servlet.Filter;
    4. import javax.servlet.FilterChain;
    5. import javax.servlet.FilterConfig;
    6. import javax.servlet.ServletException;
    7. import javax.servlet.ServletRequest;
    8. import javax.servlet.ServletResponse;
    9.  
    10. public class CharaterEncodingFilter implements Filter {
    11.  
    12.     public void init(FilterConfig filterConfig) throws ServletException {
    13.  
    14.     }
    15.  
    16.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    17.         request.setCharacterEncoding("utf-8");
    18.         response.setCharacterEncoding("utf-8");
    19.         //response.setContentType("text/html; charset=UTF-8");
    20.  
    21.         chain.doFilter(request, response);
    22.     }
    23.  
    24.     public void destroy() {
    25.     }
    26. }
    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.          xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    5. 		http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    6.          id="WebApp_ID" version="3.1">
    7.     <display-name>User Management Web Applicationdisplay-name>
    8.  
    9.     <error-page>
    10.         <exception-type>java.lang.Exceptionexception-type>
    11.         <location>/Error.jsplocation>
    12.     error-page>
    13.     <filter>
    14.         <filter-name>CharacterEncodingFilterfilter-name>
    15.         <filter-class>CharaterEncodingFilterfilter-class>
    16.     filter>
    17.     <filter-mapping>
    18.         <filter-name>CharacterEncodingFilterfilter-name>
    19.         <url-pattern>/*url-pattern>
    20.     filter-mapping>
    21. web-app>

  • 相关阅读:
    解决win11更新后，文件夹打不开的bug
    CSS 中的 : 和 :: 有什么区别？
    异地办公也能畅快、无限制远程访问公司内网的解决方案
    使用van-dialog二次封装微信小程序模态框
    细节炸裂！阿里大佬深入探究G1源码之YoungGC技术
    Docker的自定义镜像
    MyBatisPlus学习笔记
    【lwip】07-链路层收发以太网数据帧源码分析
    DP4361国产六通道立体声D/A音频转换器芯片替代CS4361
    【收藏系列】多线程的代码案例（单例模式 + 阻塞队列 + 定时器 + 线程池）
  • 原文地址：https://blog.csdn.net/allway2/article/details/126054911