使用Maven开发用户模块的CRUD（增删改查）

使用Maven开发用户模块的CRUD（增删改查）

< 使用Maven开发Web应用Archiva服务器的搭建步骤 >

C语言中文网推出辅导班啦，包括「C语言辅导班、C++辅导班、算法/数据结构辅导班」，全部都是一对一教学：一对一辅导 + 一对一答疑 + 布置作业 + 项目实践 + 永久学习。QQ在线，随时响应！

《 使用Maven开发Web应用详细步骤》教程中介绍了怎样实现一个简单的 Web 应用，讲述了创建 Web 应用、编写代码、在 pom.xml 中配置相关的构件、最后发布测试，接下来再介绍一个经典的实现了 CRUD 的用户 Web 管理应用。

创建 Web 工程和初始化数据库

首先，按照教程前面的指导创建一个 Web 工程，创建好工程后，下一步就是初始化数据库了。

这里用的是  MySQL 数据库。建议先安装好数据库，然后创建一个数据库，用如下脚本初始化表。

1. CREATE TABLE mvn_user(
2. ur_id int(11) NOT NULL AUTO_INCREMENT,
3. ur_user_name varchar(255) DEFAULT NULL,
4. ur_password varchar(255) DEFAULT NULL,
5. ur_age int(11) DEFAULT NULL,
6. ur_status varchar(255) DEFAULT NULL,
7. PRIMARY KEY (ur_id)
8. ) ENGINE=InnoDB AUTO_INCREMENT=15 DEFAULT CHARSET=utf8;
10. INSERT INTO mvn_user(ur_user_name,ur_password,ur_age,ur_status) VALUES ('zhangsan', '123', 11, 'Active');
11. INSERT INTO mvn_user(ur_user_name,ur_password,ur_age,ur_status) VALUES ('lisi', '123', 13, 'Inactive');
12. INSERT INTO mvn_user(ur_user_name,ur_password,ur_age,ur_status) VALUES ('wangwu', '123', 13, 'Active');

添加相关依赖

在整个 Demo 应用中，需要在创建 Web 工程后，额外添加 4 个依赖，分别是 jstl 依赖、MySQL 数据库驱动依赖、JUnit 4.7 依赖和 json-lib 依赖。它们的依赖配置文件如下：

2. javax.servlet
3. jstl
4. 1.2
7. mysql
8. mysql-connector-java
9. 5.1.34
12. junit
13. junit
14. 4.7
15. test
19. net.sf.json-lib
20. json-lib
21. 2.4
22. jdk15

添加注册代码

MvnUser.java（用户实体类）代码如下所示：

1. public class MvnUser {
2. private int urId;
3. private String urUserName;
4. private String urPassword;
5. private int urAge;
6. private String urStatus;
8. public int getUrId() {
9. return urId;
10. }
12. public void setUrId(int urId) {
13. this.urId = urId;
14. }
16. public String getUrUserName() {
17. return urUserName;
18. }
20. public void setUrUserName(String urUserName) {
21. this.urUserName = urUserName;
22. }
24. public String getUrPassword() {
25. return urPassword;
26. }
28. public void setUrPassword(String urPassword) {
29. this.urPassword = urPassword;
30. }
32. public int getUrAge() {
33. return urAge;
34. }
36. public void setUrAge(int urAge) {
37. this.urAge = urAge;
38. }
40. public String getUrStatus() {
41. return urStatus;
42. }
44. public void setUrStatus(String urStatus) {
45. this.urStatus = urStatus;
46. }
47. }

DBConnection.java（连接数据库的公共类）代码如下所示：

1. import java.io.InputStream;
2. import java.sql.Connection;
3. import java.sql.DriverManager;
4. import java.sql.ResultSet;
5. import java.sql.Statement;
6. import java.util.Properties;
8. /**
9. * 获取连接的一个工具类，继承Properties，实现如下封装：
10. * 1 读取db.properties文件
11. * 2 获取Connection连接的方法
12. * 3 关闭资源的方法
13. *
14. * @author Noble
15. * @version 1.0
16. */
17. public class DBConnection extends Properties {
18. private static DBConnection DB_CONN = null;
20. /**
21. * 构造器方法，被私有化，封装读取db.properties逻辑
22. *
23. */
24. private DBConnection() throws Exception {
25. InputStream in = DBConnection.class.getClassLoader().getResourceAsStream("db.properties");
26. this.load(in);
27. // 加载驱动类
28. Class.forName(this.getProperty("driverName"));
29. }
31. /**
32. * 单例模式实现，获取DBConnection实例的静态方法
33. *
34. * @return DBConnection DBConnection实例
35. * @throws Exception 初始化db.properties出现问题时，会抛异常
36. */
37. public static DBConnection getInstance() throws Exception {
38. if (DB_CONN == null) {
39. DB_CONN = new DBConnection();
40. }
41. return DB_CONN;
42. }
44. /**
45. * 基于驱动和db.properties中配置的连接数据库的信息，创建一个新连接返回
46. *
47. * @return Connection 创建的新连接对象
48. *
49. */
50. public Connection getConnection() {
51. Connection conn = null;
52. String url = this.getProperty("url");
53. String userName = this.getProperty("userName");
54. String password = this.getProperty("password");
55. //
56. try {
57. conn = DriverManager.getConnection(url, userName, password);
58. } catch (Exception e) {
59. throw new RuntimeException("数据库连接错误，请与管理员联系");
60. }
61. return conn;
62. }
64. /**
65. * 关闭操作数据库后的资源
66. *
67. * @param conn Connection对象
68. * @param stmt Statement或Statement的子类对象
69. * @param rs ResultSet对象
70. */
71. public void close(Connection conn, Statement stmt, ResultSet rs) {
72. try {
73. if (rs != null)
74. rs.close();
75. if (stmt != null)
76. stmt.close();
77. if (conn != null)
78. conn.close();
79. } catch (Exception e) {
80. e.printStackTrace();
81. }
82. }
83. }

MvnUserDAO.java（用户的 DAO 持久层类）代码如下所示：

1. /**import**/
2. /**
3. * MvnUser实体对象的持久层代码，封装了对MvnUser实体对象的CRUD方法
4. *
5. * @author Noble
6. * @version 1.0
7. */
8. public class MvnUserDAO {
9. /**
10. * 在数据库中，添加一个新的MvnUser对象
11. *
12. * @param user 需要添加的用户实体对象，该对象需要有用户名、密码、年龄和状态属性
13. *
14. * @return void
15. * @throws RuntimeException 添加失败或出现其它意外
16. */
17. public void addUser(MvnUser user) {
18. DBConnection dbConn = null;
19. Connection conn = null;
20. PreparedStatement pstmt = null;
21. try {
22. // 获取DBConnection实例
23. dbConn = DBConnection.getInstance();
24. String sql = "insert into mvn_user (ur_user_name,ur_password,ur_age,ur_status) values(?,?,?,?)";
25. // 获取连接对象
26. conn = dbConn.getConnection();
27. // 基于连接和sql，获取一个预处理Statement对象
28. pstmt = conn.prepareStatement(sql);
29. // 设置sql中占位符的值
30. pstmt.setString(1, user.getUrUserName());
31. pstmt.setString(2, user.getUrPassword());
32. pstmt.setInt(3, user.getUrAge());
33. pstmt.setString(4, user.getUrStatus());
34. // 执行预处理
35. pstmt.executeUpdate();
36. } catch (Exception e) {
37. throw new RuntimeException(e);
38. } finally {
39. // 关闭资源
40. if (dbConn != null)
41. dbConn.close(conn, pstmt, null);
42. }
43. }
45. /**
46. * 更新MvnUser对象。该对象中需要设置年龄、状态和id属性，属性和状态是要更新的新值，id为条件
47. *
48. * @param user 需要更新的MvnUser对象
49. *
50. * @return void
51. * @throws RuntimeException 更新失败或出现其它意外
52. */
53. public void update(MvnUser user) {
54. DBConnection dbConn = null;
55. Connection conn = null;
56. PreparedStatement pstmt = null;
57. try {
58. dbConn = DBConnection.getInstance();
59. String sql = "update mvn_user set ur_age=?,ur_status=? where ur_id=?";
60. conn = dbConn.getConnection();
61. pstmt = conn.prepareStatement(sql);
62. pstmt.setInt(1, user.getUrAge());
63. pstmt.setString(2, user.getUrStatus());
64. pstmt.setInt(3, user.getUrId());
66. pstmt.executeUpdate();
67. } catch (Exception e) {
68. throw new RuntimeException(e);
69. } finally {
70. if (dbConn != null)
71. dbConn.close(conn, pstmt, null);
72. }
73. }
75. /**
76. * 删除MvnUser对象，该对象中需要有要删除对象的id属性，id属性为删除条件
77. *
78. * @param user 要删除的MvnUser对象
79. *
80. * @return void
81. * @throws RuntimeException 删除失败或出现其它意外
82. */
83. public void deleteUser(MvnUser user) {
84. DBConnection dbConn = null;
85. Connection conn = null;
86. PreparedStatement pstmt = null;
87. try {
88. dbConn = DBConnection.getInstance();
89. String sql = "delete from mvn_user where ur_id=?";
90. conn = dbConn.getConnection();
91. pstmt = conn.prepareStatement(sql);
92. pstmt.setInt(1, user.getUrId());
94. pstmt.executeUpdate();
95. } catch (Exception e) {
96. throw new RuntimeException(e);
97. } finally {
98. if (dbConn != null)
99. dbConn.close(conn, pstmt, null);
100. }
101. }
103. /**
104. * 根据id查询对应的MvnUser对象
105. *
106. * @param id 要查询的MvnUser对象的id
107. * @return MvnUser id对应的MvnUser对象，如果没有对象，返回null
108. * @throws RuntimeException 出现意外情况
109. */
110. public MvnUser findUserById(int id) {
111. MvnUser user = null;
112. DBConnection dbConn = null;
113. Connection conn = null;
114. PreparedStatement pstmt = null;
115. ResultSet rs = null;
116. try {
117. dbConn = DBConnection.getInstance();
118. String sql = "select * from mvn_user where ur_id=?";
119. conn = dbConn.getConnection();
120. pstmt = conn.prepareStatement(sql);
121. pstmt.setInt(1, id);
123. rs = pstmt.executeQuery();
124. if (rs.next()) {
125. user = new MvnUser();
126. user.setUrAge(rs.getInt("ur_age"));
127. user.setUrId(rs.getInt("ur_id"));
128. user.setUrPassword(rs.getString("ur_password"));
129. user.setUrStatus(rs.getString("ur_status"));
130. user.setUrUserName(rs.getString("ur_user_name"));
131. }
132. } catch (Exception e) {
133. throw new RuntimeException(e);
134. } finally {
135. if (dbConn != null)
136. dbConn.close(conn, pstmt, rs);
137. }
138. return user;
139. }
141. /**
142. * 根据用户名查询对应的MvnUser对象
143. *
144. * @param userName 要查询的MvnUser对象的用户名
145. * @return MvnUser 用户对应的MvnUser对象，如果没有对象，返回null
146. * @throws RuntimeException 出现意外情况
147. */
148. public MvnUser findUserByUserName(String userName) {
149. MvnUser user = null;
150. DBConnection dbConn = null;
151. Connection conn = null;
152. PreparedStatement pstmt = null;
153. ResultSet rs = null;
154. try {
155. dbConn = DBConnection.getInstance();
156. String sql = "select * from mvn_user where ur_user_name=?";
157. conn = dbConn.getConnection();
158. pstmt = conn.prepareStatement(sql);
159. pstmt.setString(1, userName);
161. rs = pstmt.executeQuery();
162. if (rs.next()) {
163. user = new MvnUser();
164. user.setUrAge(rs.getInt("ur_age"));
165. user.setUrId(rs.getInt("ur_id"));
166. user.setUrPassword(rs.getString("ur_password"));
167. user.setUrStatus(rs.getString("ur_status"));
168. user.setUrUserName(rs.getString("ur_user_name"));
169. }
170. } catch (Exception e) {
171. throw new RuntimeException(e);
172. } finally {
173. if (dbConn != null)
174. dbConn.close(conn, pstmt, rs);
175. }
176. return user;
177. }
179. /**
180. * 查找数据库中所有的用户对象，以List集合的形式返回
181. *
182. * @return List 所有用户对象的集合
183. * @throws RuntimeException 出现意外情况
184. */
185. public List findUsers() {
186. List userList = null;
187. DBConnection dbConn = null;
188. Connection conn = null;
189. PreparedStatement pstmt = null;
190. ResultSet rs = null;
191. try {
192. dbConn = DBConnection.getInstance();
193. String sql = "select * from mvn_user order by ur_id";
194. conn = dbConn.getConnection();
195. pstmt = conn.prepareStatement(sql);
197. rs = pstmt.executeQuery();
198. if (rs != null) {
199. userList = new ArrayList>();
200. MvnUser user = null;
201. while (rs.next()) {
202. user = new MvnUser();
203. user.setUrAge(rs.getInt("ur_age"));
204. user.setUrId(rs.getInt("ur_id"));
205. user.setUrPassword(rs.getString("ur_password"));
206. user.setUrStatus(rs.getString("ur_status"));
207. user.setUrUserName(rs.getString("ur_user_name"));
209. userList.add(user);
210. }
211. }
212. } catch (Exception e) {
213. throw new RuntimeException(e);
214. } finally {
215. if (dbConn != null)
216. dbConn.close(conn, pstmt, rs);
217. }
218. return userList;
219. }
220. }

UserService.java（用户服务类）代码如下所示：

1. /**
2. * 对用CRUD操作的服务层，封装了CRUD在持久化前的必要业务逻辑
3. *
4. * @author Noble
5. * @version 1.0
6. */
7. public class UserService {
8. private MvnUserDAO userDAO = new MvnUserDAO();
10. /**
11. * 创建新的用户
12. *
13. * @param user 要创建的用户对象
14. * @return void
15. * @throws RuntimeException 当用户信息不全或用户名已经存在的时候，都会抛出异常
16. */
17. public void createUser(MvnUser user) {
18. // 验证基本的用户信息
19. if (user == null || user.getUrUserName() == null || user.getUrPassword() == null) {
20. throw new RuntimeException("用户信息不合法");
21. }
22. // 根据用户名查询用户对象
23. MvnUser u = userDAO.findUserByUserName(user.getUrUserName());
24. // 如果能查询到用户对象，说明用户已经存在，抛异常
25. if (u != null) {
26. throw new RuntimeException(user.getUrUserName() + " 用户已存在");
27. }
28. // 调用dao代码，添加一个新用户
29. userDAO.addUser(user);
30. }
32. /**
33. * 更新id对应用户的年龄和状态信息
34. *
35. * @param age 要更新用户的新年龄
36. * @param status 要更新用户的新状态
37. * @param id 要更新用户的id，这是更新的条件
38. *
39. * @return void
40. */
41. public void editUser(int age, String status, int id) {
42. MvnUser user = this.userDAO.findUserById(id);
43. user.setUrAge(age);
44. user.setUrStatus(status);
45. this.userDAO.update(user);
46. }
48. public void deleteUser(int id) {
49. MvnUser user = this.userDAO.findUserById(id);
50. this.userDAO.deleteUser(user);
51. }
53. public MvnUser searchUser(int id) {
54. MvnUser user = this.userDAO.findUserById(id);
55. return user;
56. }
58. public MvnUser searchUser(String userName) {
59. MvnUser user = this.userDAO.findUserByUserName(userName);
60. return user;
61. }
63. public List searchUsers() {
64. List userList = this.userDAO.findUsers();
65. return userList;
66. }
67. }

AddUser Servlet.java（添加用户Servlet）代码如下所示：

1. /** import **/
3. /**
4. * Servlet implementation class AddUserServlet
5. */
6. public class AddUserServlet extends HttpServlet {
7. private static final long serialVersionUID = 1L;
9. /**
10. * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse
11. * response)
12. */
13. protected void service(HttpServletRequest request, HttpServletResponse response)
14. throws ServletException, IOException {
15. // 获取要添加用户的信息
16. String userName = request.getParameter("userName");
17. String password = request.getParameter("password");
18. String ageStr = request.getParameter("age");
19. String status = request.getParameter("status");
20. int age = 0;
21. try {
22. // 将年龄字符串，转变成数字（数据库中需要数字类型）
23. age = Integer.parseInt(ageStr);
24. } catch (Exception e) {
25. }
26. // 封装成MvnUser对象
27. MvnUser user = new MvnUser();
28. user.setUrAge(age);
29. user.setUrPassword(password);
30. user.setUrStatus(status);
31. user.setUrUserName(userName);
33. UserService userService = new UserService();
34. String msg = "添加成功";
35. try {
36. // 调用service，创建用户
37. userService.createUser(user);
38. } catch (Exception e) {
39. e.printStackTrace();
40. msg = "添加失败：" + e.getMessage();
41. }
42. // 返回添加后的结果提示信息
43. response.setContentType("text/html;charset=UTF-8");
44. PrintWriter out = response.getWriter();
45. out.print(msg);
46. }
48. }

DeleteUserServlet.java（删除用户Servlet）代码如下所示：

1. /**import**/
2. /**
3. * Servlet implementation class DeleteUserServlet
4. */
5. public class DeleteUserServlet extends HttpServlet {
6. private static final long serialVersionUID = 1L;
8. /**
9. * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse
10. * response)
11. */
12. protected void service(HttpServletRequest request, HttpServletResponse response)
13. throws ServletException, IOException {
14. String idStr = request.getParameter("id");
15. int id = 0;
16. try {
17. id = Integer.parseInt(idStr);
18. } catch (Exception e) {
19. }
20. UserService userService = new UserService();
21. String msg = "删除成功";
22. try {
23. userService.deleteUser(id);
24. } catch (Exception e) {
25. e.printStackTrace();
26. msg = "删除失败:" + e.getMessage();
27. }
28. response.setContentType("text/html;charset=UTF-8");
29. PrintWriter out = response.getWriter();
30. out.print(msg);
31. out.flush();
32. out.close();
33. }
35. }

EditUserServlet.java（修改用户Servlet）代码如下所示：

1. /** import **/
2. /**
3. * Servlet implementation class EditUserServlet
4. */
5. public class EditUserServlet extends HttpServlet {
6. private static final long serialVersionUID = 1L;
8. protected void service(HttpServletRequest request, HttpServletResponse response)
9. throws ServletException, IOException {
10. String idStr = request.getParameter("id");
11. String status = request.getParameter("status");
12. String ageStr = request.getParameter("age");
14. int id = 0, age = 0;
15. try {
16. id = Integer.parseInt(idStr);
17. } catch (Exception e) {
18. }
19. try {
20. age = Integer.parseInt(ageStr);
21. } catch (Exception e) {
22. }
23. UserService userService = new UserService();
24. String msg = "修改成功";
25. try {
26. userService.editUser(age, status, id);
27. } catch (Exception e) {
28. e.printStackTrace();
29. msg = "修改失败:" + e.getMessage();
30. }
31. response.setContentType("text/html;charset=UTF-8");
32. PrintWriter out = response.getWriter();
33. out.print(msg);
34. out.flush();
35. out.close();
36. }
38. }

SearchUserServlet.java（根据用户 Id 或用户名查找用户 Servlet）代码如下所示：

1. /** import **/
2. /**
3. * Servlet implementation class SearchUserServlet
4. */
5. public class SearchUserServlet extends HttpServlet {
6. private static final long serialVersionUID = 1L;
8. protected void service(HttpServletRequest request, HttpServletResponse response)
9. throws ServletException, IOException {
10. // 获取查询的方式（根据id查询还是根据用户名查询）
11. String type = request.getParameter("type");
12. UserService userService = new UserService();
13. MvnUser user = null;
14. // 根据id查询
15. if ("byId".equals(type)) {
16. // 获取id
17. String idStr = request.getParameter("id");
18. int id = 0;
19. try {
20. id = Integer.parseInt(idStr);
21. } catch (Exception e) {
22. }
23. user = userService.searchUser(id);
24. } else {
25. // 根据用户名查询
26. String userName = request.getParameter("userName");
27. user = userService.searchUser(userName);
28. }
29. // 设置返回的响应为json响应
30. response.setContentType("text/json;charset=UTF-8");
31. PrintWriter out = response.getWriter();
32. // 将查询的用户对象，转变成json格式的字符串，写入响应返回
33. out.print(JSONObject.fromObject(user));
34. out.flush();
35. out.close();
36. }
38. }

SearchUsersServlet.java（查询所有用户Servlet）代码如下所示：

1. /** import **/
2. /**
3. * Servlet implementation class SearchUsersServlet
4. */
5. public class SearchUsersServlet extends HttpServlet {
6. private static final long serialVersionUID = 1L;
8. /**
9. * @see HttpServlet#service(HttpServletRequest request, HttpServletResponse
10. * response)
11. */
12. protected void service(HttpServletRequest request, HttpServletResponse response)
13. throws ServletException, IOException {
14. UserService userService = new UserService();
15. List userList = userService.searchUsers();
16. // 将查询出的用户集合，写于request属性中
17. request.setAttribute("userList", userList);
18. // 转向 userList.jsp页面
19. request.getRequestDispatcher("/userList.jsp").forward(request, response);
20. }
22. }

userList.jsp（显示用户列表 jsp）代码如下所示：

1. <%@page contentType="text/html" pageEncoding="UTF-8"%>
2. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
3. width="100%" border="1">
   items="${userList }" var="_user" varStatus="status">
   test="${status.index%2==0 }">
   bgcolor="#FFFFFF">
   bgcolor="#99FFFF">

   width="51" bgcolor="#CCCCCC"> align="center"> class="STYLE2">选择	width="111" bgcolor="#CCCCCC"> align="center"> 序号	width="137" bgcolor="#CCCCCC"> align="center"> 用户名	width="105" bgcolor="#CCCCCC"> align="center"> 年龄	width="101" bgcolor="#CCCCCC"> align="center"> 状态
   type="checkbox" name="checkbox" value="${_user.urId }">	${status.index+1 }	${_user.urUserName }	${_user.urAge }	${_user.urStatus }

index.jsp，进入首页（框架 jsp），代码如下所示：

1. <%@page contentType="text/html" pageEncoding="UTF-8"%>
2. <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
5. http-equiv="Content-Type" content="text/html; charset=utf-8">
13. id="LayerAdd">
14. name="addForm" name="addForm" id="addForm" method="post"
15. action="">
17. width="98%" border="0" align="center" cellpadding="0"
    cellspacing="0">

    colspan="2" align="center"> 添加新用户
    width="47%" align="right">用户名：	width="53%">name="userName" type="text" id="userName">
    align="right">密码：	name="password" type="password" id="password">
    align="right">年龄：	name="age" type="text" id="age">
    colspan="2">
    colspan="2" align="center"> type="button" name="Submit4" value="添加" onclick="toAdd()"> type="button" name="Submit5" value="关闭" onclick="toCloseAdd()">

id="LayerEdit">

name="editForm" id="editForm" method="post" action="">

type="hidden" name="id" id="id" />

width="98%" border="0" align="center" cellpadding="0"

cellspacing="0">

colspan="2" align="center"> 修改用户信息
width="47%" align="right">用户名：	width="53%"> name="userName" type="text" id="userName" readonly="readonly">
align="right">年龄：	name="age" type="text" id="age">
align="right">状态：	name="status" id="status"> value="Active">Active value="Inactive">Inactive value="Locked">Locked value="Deleted">Deleted
colspan="2">
colspan="2" align="center"> type="button" name="Submit4" value="修改" onclick="toEdit()"> type="button" name="Submit5" value="关闭" onclick="toCloseEdit()">

 

测试用户CRUD页面

width="539" border="1">

colspan="5" align="right"> type="button" name="Submit" value="新增" onclick="toShowAdd()"> type="submit" name="Submit2" value="修改" onclick="toShowEdit()"> type="button" name="Submit3" value="删除" onclick="toDelete()">

id="userListDiv">

 

db.properties，数据库信息配置文件，代码如下所示：

userName=root
password=root
url=jdbc:mysql://localhost:3306/mvn_db
driverName=com.mysql.jdbc.Driver

构建项目

代码写好了，接下来是在 pom.xml 中添加发布 Web 应用和同 Web 服务器相关的插件，这些在前面的简易 Web 案例中已提到，这里就直接贴出当前 Web 应用到的插件配置，代码如下：

4. org.mortbay.jetty
5. maven-jetty-plugin
6. 6.1.26
8. ${basedir}/src/main/webapp
12. org.apache.maven.plugins
13. maven-compiler-plugin
14. 2.0.2
16. 1.5
17. 1.5

测试

右击“工程”，选择 Run As→ Maven build… 命令，在 Goals 后面输入“jetty:run”目标，运行 jetty 服务器。在浏览器中输入“http://localhost:8080/MvnDemo03/index.jsp”进行运行测试。

转载于:https://www.cnblogs.com/buffercache/p/11544337.html