您的位置：360文档中心› 使用MyEclipse开发Web项目并进行发布,运行,测试和调试

使用MyEclipse开发Web项目并进行发布,运行,测试和调试

合集下载
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

使⽤MyEclipse开发Web项⽬并进⾏发布,运⾏,测试和调试本⽂将介绍如何使⽤ MyEclipse 来开发Web 项⽬（包括HTML，JSP，Servlet，Filter和后台Java 类），并进⾏发布，运⾏，测试和调试。

本章将通过开发⼀个使⽤JDBC 进⾏登录验证的简单例⼦来给⼤家展⽰相关的操作过程。

那么哪些应⽤算是 Web 应⽤呢？简单说通过⽹络浏览器，例如IE，Firefox 等等上⽹看到的绝⼤多数⽹页，都属于Web 应⽤的范围，所以它的应⽤是⾮常的⼴的。

要想做好⼀个Web 应⽤，只掌握Java 是远远不够的，您还得深⼊了解HTML，CSS，JavaScript 甚⾄
AJAX，Flash，ActiveX 等技术。

俗话说的好：三分相貌七分妆。

⽤户第⼀印象看到的只能是看到的⽹页的样⼦和友好度，他是完全不懂所谓的.NET，PHP，JSP，ASP 还有什么ROR的，所以提⽰初学者多花些时间在Web 层的技术上。

创建Web 项⽬
本节内容将介绍如何创建⼀个 JSPHelloWorld 的Web 项⽬。

选择菜单File > New >Web Project，可以启动创建Web 项⽬的向导，如图8.3 所⽰。

在这个图的 Project Name 中输⼊JSPHelloWorld，然后选中J2EE Specification Level 下⾯的Java EE 5.0 单选钮，最后点击Finish 按钮就可以创建Web 项⽬了。

注意：选择哪个版本的J2EE Specification Level 取决于你使⽤的服务器，例Tomcat4，Weblogic 9 以下版本请选择J2EE 1.4，⽽Tomcat 5，JBoss 4，或者GlassFish 这样
的服务器可以选择 Java EE 5.0。

Java EE 5.0 可以直接使⽤ EL 表达式和JSTL。

2009-12-10 14:55:50 上传
图 8.3 新建Web Project 对话框
关于输⼊框的详细意义请参考下表：
选项描述
Project name项⽬的名称。

必须是有效的 Eclipse Java 项⽬名。

Location选中这个复选框来选择新项⽬的⽂件将存放到电脑上的其它位置
Directory 项⽬的默认存放位置是放在 MyEclipse 启动时候⼯作区⽬录下的。

当然可以选择位于⼯作区⽬录外的其它路径。

注意：不能选择位于⼯作区⼦⽬录下的另⼀⼦⽬录，因为Eclipse 禁⽌这种做法！
Source
folder
Java 源代码⽬录－将包含Java 包和.java ⽂件。

这些内容会被加⼊到项⽬的Java 构造路径中。

Web root folder 这个⽬录将包含 web 应⽤的内容，WEB-INF ⽬录以及对应的⼦⽬录。

如果这个输⼊框内容为空，那么项⽬的根⽬录（"/"）将会成为web 根⽬录。

Context root URL MyEclipse的发布⼯具会发布新Web项⽬时候所使⽤这个路径。

默认使⽤的值是项⽬的名字。

什么是上下⽂根⽬录？它是访问发布后的应⽤时所⽤的根路径，例如输⼊myapp后，将⽤地址http://localhost:8080/myapp 来访问这个项⽬. 你可以把这个输⼊框中的内容修改成全是⼩写字母的内容。

J2EE
J2EE
specification
指定J2EE 规范的版本。

需要检查服务器的⽂档来了解其所⽀持的版本。

Add JSTL 1.0 libraries 启⽤此选项来添加 Java Standard Template Library (Java 标准模版库1.0或者1.1 版本)的 JAR ⽂件到新项⽬的<web-root>/WEB-INF/lib ⽬录下。

表8.1 新建Web 项⽬的选项说明
创建HTML 页⾯
注意：在实际的开发中，⼀般使⽤的都是像Frontpage 或者DreamWeaver 这样的⼯具来创建，可视化的（所见即所得，WYSWYG）的来修改静态⽹页（HTML）。

因为MyEclipse的可视化⽹页编辑器功能是⽐较弱的。

因此本节内容仅供参考。

启动创建 HTML 页⾯的对话框有多种⽅式，这⾥只介绍两种：1. 选择菜单 File > New> Html(Advanced Template)；2. 选中Package Explorer 视图的WebRoot ⽬录，点击右键选择上下⽂菜单中的New > Html(Advanced Template)。

这时候将会弹出创建HTML页⾯的对话框，如下图所⽰：
图 8.4 新建HTML 页⾯向导
在这个对话框中的 File Name（⽂件名）框中输⼊login.html，Template to use:（要使⽤的模版）右侧的下拉框选中Default HTML template（默认HTML 模版，另⼀个是带表单的模版）。

最后点击Finish 按钮完成向导。

稍后MyEclipse 会⽤HTML 编辑器来打开刚创建的⽂件，如图8.5 所⽰。

在这⾥可以在页⾯设计器中可视化的修改⽹页内容，也可以点击格式⼯具栏上的按钮来可视化的修改⽹页的格式，还可以在源代码⾯板中直接修改HTML 源码。

Properties 视图则显⽰了当前选中元素的属性，可以快速的对⼀些关键的属性进⾏修改。

拖动设计器和源码标签之间的隔条可以对两个区域之间的⼤⼩进⾏调节，点击向上按钮可以最⼤化显⽰代码区，点击向下按钮则可以最⼤化显⽰设计区。

点击Preview 标签可以同时在IE 和Mozilla 浏览器中查看页⾯的显⽰效果。

点击 Palette（⼯具箱，确切说应该是叫组件⾯板）可以选择对应的⼀些常⽤的代码⽚段插⼊到当前页⾯中，例如超链接，图⽚，表单和表单元素等等。

HTML-Basic ⾥⾯列出常⽤的基本⽹页元素，⽽HTML-Form 下则列出了表单元素。

现在我们把它的内容修改成⼀个包含登录表单和客户端表单有效性验证的页⾯，然后点击⼯具栏上的保存按钮。

代码内容请参考清单8.1。

图 8.5 HTML 编辑器
1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
2. <html>
3. <head>
4. <title>登录</title>
5. <meta http-equiv="content-type" content="text/html; charset=GBK">
6. </head>
7. <script type="text/javascript">
8. // 验证输⼊不为空的脚本代码
9. function checkForm(form) {
10. if(ername.value == "") {
11. alert("⽤户名不能为空!");
12. ername.focus();
13. return false;
14. }
15. if(form.password.value == "") {
16. alert("密码不能为空!");
17. form.password.focus();
18. return false;
19. }
20. return true;
21. }
22. </script>
23. <body>
24. 请登录 <br>
25. <form action="login.aspx" method="post" οnsubmit="return
26. checkForm(this);">
27. ⽤户名：<input type="text" name="username"><br>
28. 密码：<input type="password" name="password"><br>
29. <input type="submit" value="登录" name="submit1">
30. <input type="reset" value="重置" name="reset1">
31. </form>
32. </body>
33. </html>
复制代码
清单 8.2 登录页⾯
⾄此，创建静态页⾯的过程就简要介绍完毕了。

在此先虚晃⼀枪，为什么表单的提交页⾯是login.aspx 呢？难道Java 也⽀持 嘛？答案请在创建Servlet中找。

创建JSP 页⾯
本节内容将会讲解创建JSP页⾯。

实际上JSP编辑器许多地⽅都是和上⽂介绍的HTML编辑器⾮常相似的。

因此本节内容将会简要介绍其过程。

启动创建 HTML 页⾯的对话框有多种⽅式，这⾥只介绍两种：1. 选择菜单 File > New> JSP(Advanced Template)；2. 选中Package Explorer 视图的WebRoot ⽬录，点击右键选择上下⽂菜单中的New > JSP(Advanced Template)。

这时候将会弹出创建JSP 页⾯的对话框，和图8.4 ⾮常相似。

只需要在这个对话框中的File Name（⽂件名）框中输⼊result.jsp，然后点击Finish 按钮即可创建这个JSP 页⾯。

注意：Template to use 右侧的模版下拉框中有很多JSP 模版可以使⽤，例如⽀持JSF，Struts 等等的模版，这样可以加快开发的速度。

稍后 MyEclipse 会⽤HTML 编辑器来打开刚创建的⽂件，界⾯已经操作⽅法和图8.5⾮常类似，不同的是Palette ⾥⾯多了很多JSP 特有的内容，⽽编辑器的代码视图呢，也⽀持⾃动查错（但是不⽀持⾃动修正错误）和代码编写提⽰功能，如下图所⽰：
图 8.6 JSP 编辑器的查错和编码提⽰
当你在变量后按下.之后，会弹出代码完成提⽰，另外还⽀持断点的设置等等。

因此使⽤MyEclipse 的JSP 编辑器可以⼤⼤减少开发⼈员出错的机会（在出现能查错的JSP 编辑器之前这是个⼤问题）。

现在我们将把这个页⾯的代码改写成如下清单所⽰内容：
1. <%@ page language=”java” pageEncoding=”GBK”%>
2. <html>
3. <head>
4. <title>登录结果</title>
5. <meta http-equiv=”pragma” content=”no-cache”>
6. <meta http-equiv=”cache-control” content=”no-cache”>
7. <meta http-equiv=”expires” content=”0”>
8. </head>
9. <body>
10. 您登录${message}了！
11. </body>
12. </html>
复制代码
清单 8.3 登录结果页⾯ result.jsp
在这个页⾯我们将使⽤JSP 2.0 ⾥⾯的EL 表达式来显⽰登录结果信息，${message}就是⼀段EL 表达式，它将从request 或者session ⾥⾯查找名为message 的属性，其实就是调⽤getAttribute(“message”)然后把⾥⾯的内容显⽰出来。

这个页⾯不包含其它复杂的代码，是因为JSP 页⾯⼀般来说是⽤作视图层的，专门⽤来显⽰数据⽤的，只能包含或者尽量少包含⼀些复杂的业务逻辑。

注意：EL 表达式不能在J2EE 1.4 的Web 项⽬中使⽤。

如果您打算在J2EE 1.4 的Web 项⽬中编写这个页⾯，对应的代码是把
1. 您登录${message}了！
复制代码
修改为：
1. <%
2. String message = (String)request.getAttribute("message");
3. if(message == null) message = "";
4. %>
5. 您登录<%=message%>了！
复制代码
即可。

然⽽有读者发现 Tomcat 5.5 中启⽤了Java EE 5 也⽆法使⽤EL 表达式，那么这种情况下的⼀种简单解决办法是⽤Tomcat 6.0。

不
过，Tomcat 5.5 下也有解决办法，第⼀种是设置整个项⽬使⽤el 表达式，需要在web.xml 中加上（控制⼀个项⽬）：
1. <jsp-config>
2. <jsp-property-group>
3. <el-ignored>false</el-ignored>
4. </jsp-property-group>
5. </jsp-config>
复制代码
第⼆种办法是设置某个jsp 页⾯使⽤el 表达式，需要在jsp 页⾯开头加上（控制单个页⾯）：
1. <%@ page isELIgnored="false"%>
复制代码
在 page 指令中的isELIgnored 属性⽤来指定是否忽略EL 表达式。

格式为：
1. <%@ page isELIgnored＝"true|false"%>
复制代码
如果设定为真，那么JSP 中的表达式被当成字符串处理。

⽐如下⾯这个表达式${2000 % 20}，在isELIgnored＝"true"时输出为${2000 % 20}，⽽isELIgnored＝"false"时输出为100。

Web 容器默认isELIgnored＝"false"，但是为什么个别Tomcat 5.5 不⽀持呢？这我就不得⽽知了。

⾄于有没有全局的设置办法？我想应该也是有的，但是我还没找到。

创建Servlet
启动创建Servlet 的对话框有多种⽅式，这⾥只介绍两种：1. 选择菜单 File > New >Servlet；2. 选中Package Explorer 视图的项⽬，点击右键选择上下⽂菜单中的New >Servlet。

这时候将会弹新建Servlet 类的对话框，如图8.7 所⽰。

在这个对话框中的Package（包）框中输⼊servlets，Name（类名）输⼊LoginServlet，然后点击Next 按钮可以进⼀步设置映射⽂件。

也可以点击Finish 按钮直接完成这个创建向导，不过此处将选择Next按钮来进⼊到下⼀步的设置页⾯。

2009-12-10 15:10:27 上传
图 8.7 新建Servlet 类对话框
在这⼀页中可以设置 Servlet 的⽗类（Superclass），以及修饰符(Modifiers)，添加接⼝（Interfaces），选择模版（Template to use）以及⼀些选项（Options）。

Options 中可以选择是否创建继承的⽅法（Inherited Methods），创建构造器（Constructors），初始化和销毁⽅法（init and destory）以及doGet，doPost，doPut，doDelete，getServletInfo等⽅法。

详细意义请参考Servlet 开发的书籍。

当点击 Next 按钮后，将会进⼊修改，设置web.xml 的向导页⾯，如图8.8 所⽰。

注意图中的红框，我们在这⾥在Servlet/JSP Mapping URL 右侧输⼊框中输⼊/login.aspx。

这个路径可以帮你理解⼀个概念，那就是其实Servlet 的后缀可以是任何形式的字符串，例
如.do，.php 等等。

最后点击Finish 按钮来完成创建Servlet 的过程。

注意：Servlet 的映射路径⼀定要以/开始，或者以*.do 的⽅式出现，⽽且不能输⼊/*.do。

2009-12-10 15:10:27 上传
图 8.8 修改，设置web.xml 中的映射信息
对话框关闭后，稍等⽚刻 web.xml 和新创建的LoginServlet.java，可以看到web.xml的内容已经被⾃动加⼊了新的Servlet 定义，如下所⽰：
1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5"
3. xmlns="/xml/ns/javaee"
4. xmlns:xsi="/2001/XMLSchema-instance"
5. xsi:schemaLocation="/xml/ns/javaee
6. /xml/ns/javaee/web-app_2_5.xsd">
7. <servlet>
8. <description>This is the description of my J2EE
9. component</description>
10. <display-name>This is the display name of my J2EE
11. component</display-name>
12. <servlet-name>LoginServlet</servlet-name>
13. <servlet-class>servlets.LoginServlet</servlet-class>
14. </servlet>
15. <servlet-mapping>
16. <servlet-name>LoginServlet</servlet-name>
17. <url-pattern>/login.aspx</url-pattern>
18. </servlet-mapping>
19. <welcome-file-list>
20. <welcome-file>index.jsp</welcome-file>
21. </welcome-file-list>
22. </web-app>
复制代码
创建Filter(过滤器)
实际开发中都需要开发⼀些很有⽤的过滤器，来解决中⽂表单提交问题啊，给请求和响应加⼊GZIP 压缩功能啊，⽤户权限控制啊，等等，然⽽遗憾的MyEclipse 不⽀持直接创建过滤器。

在这⾥只好⼿⼯创建⼀个解决Tomcat 表单提交中⽂问题的过滤器。

选择菜单 File > New > Class，来创建⼀个名为TomcatFormFilter 的类，包名为filters。

然后把类的代码修改为如下所⽰：
1. package filters;
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. import javax.servlet.http.HttpServletRequest;
10. import javax.servlet.http.HttpServletRequestWrapper;
11. public class TomcatFormFilter implements Filter {
12. /**
13. * Request.java
14. * 对 HttpServletRequestWrapper 进⾏扩充, 不影响原来的功能并能提供所
15. 有的HttpServletRequest
16. * 接⼝中的功能. 它可以统⼀的对 Tomcat 默认设置下的中⽂问题进⾏解决⽽只
17. 需要⽤新的Request 对象替换页⾯中的
18. * request 对象即可.
19. */
20. class Request extends HttpServletRequestWrapper
21. {
22. public Request(HttpServletRequest request) {
23. super(request);
24. }
25. /**
26. * 转换由表单读取的数据的内码.
27. * 从 ISO 字符转到 GBK.
28. */
29. public String toChi(String input) {
30. try {
31. byte[] bytes = input.getBytes("ISO8859-1");
32. return new String(bytes, "GBK");
33. }
34. catch (Exception ex) {
35. }
36. return null;
37. }
38. /**
39. * Return the HttpServletRequest holded by this object.
40. */
41. private HttpServletRequest getHttpServletRequest()
42. {
43. return (HttpServletRequest)super.getRequest();
44. }
45. /**
46. * 读取参数 -- 修正了中⽂问题.
47. */
48. public String getParameter(String name)
49. {
50. return
51. toChi(getHttpServletRequest().getParameter(name));
52. }
53. /**
54. * 读取参数列表- 修正了中⽂问题.
55. */
56. public String[] getParameterValues(String name)
57. {
58. String values[] =
59. getHttpServletRequest().getParameterValues(name);
60. if (values != null) {
61. for (int i = 0; i < values.length; i++) {
62. values[i] = toChi(values[i]);
63. }
64. }
65. return values;
66. }
67. }
68. public void destroy() {
69. }
70. public void doFilter(ServletRequest request, ServletResponse
71. response,
72. FilterChain chain) throws IOException, ServletException {
73. HttpServletRequest httpreq = (HttpServletRequest)request;
74. if(httpreq.getMethod().equals("POST")) {
75. request.setCharacterEncoding("GBK");
76. } else {
77. request = new Request(httpreq);
78. }
79. chain.doFilter(request, response);
80. }
81. public void init(FilterConfig filterConfig) throws
82. ServletException {
83. }
84. }
复制代码
清单 8.5 过滤器代码
然后修改 web.xml 加⼊Servlet 定义，修改后的代码清单如下所⽰：
1. <?xml version="1.0" encoding="UTF-8"?>
2. <web-app version="2.5" xmlns="/xml/ns/javaee"
3. xmlns:xsi="/2001/XMLSchema-instance"
4. xsi:schemaLocation="/xml/ns/javaee
5. /xml/ns/javaee/web-app_2_5.xsd">
6. <servlet>
7. <description>
8. This is the description of my J2EE component
9. </description>
10. <display-name>
11. This is the display name of my J2EE component
12. </display-name>
13. <servlet-name>LoginServlet</servlet-name>
14. <servlet-class>servlets.LoginServlet</servlet-class>
15. </servlet>
16. <filter>
17. <filter-name>TomcatFormFilter</filter-name>
18. <filter-class>filters.TomcatFormFilter</filter-class>
19. </filter>
20. <filter-mapping>
21. <filter-name>TomcatFormFilter</filter-name>
22. <url-pattern>/*</url-pattern>
23. </filter-mapping>
24. <servlet-mapping>
25. <servlet-name>LoginServlet</servlet-name>
26. <url-pattern>/login.aspx</url-pattern>
27. </servlet-mapping>
28. <welcome-file-list>
29. <welcome-file>index.jsp</welcome-file>
30. </welcome-file-list>
31. </web-app>
复制代码
清单 8.6 加⼊了过滤器的web.xml 内容
创建数据库访问层(DAO)
做 Web 应⽤⼀般来说不访问数据库是不太可能的，因此本节就介绍给应⽤加⼊数据库访问功能。

⾸先第⼀步是创建数据库表
第⼆步是要加⼊JDBC驱动类库
这⾥打算使⽤MySQL数据库，对于Web项⽬来说加⼊类库⽂件⾮常容易，只要把mysql-connector-java-3.1.11-bin.jar这个⽂件复制到WebRoot/WEB-INF/lib下，MyEclipse会⾃动把⽂件加⼊到项⽬的类路径中。

第三步需要创建⼀个实体类，来代表数据库中的Student 对象，这个类⽤来保存和传递来⾃数据库库的数据信息。

代码清单如下：
1. package entity;
2. /** 学⽣实体类*/
3. public class Student {
4. private int id;
5. private int age;
6. private String username;
7. private String password;
8. public int getId() {
9. return id;
10. }
11. public void setId(int id) {
12. this.id = id;
13. }
14. public int getAge() {
15. return age;
16. }
17. public void setAge(int age) {
18. this.age = age;
19. }
20. public String getUsername() {
21. return username;
22. }
23. public void setUsername(String username) {
24. ername = username;
25. }
26. public String getPassword() {
27. return password;
28. }
29. public void setPassword(String password) {
30. this.password = password;
31. }
32. }
复制代码
清单 8.7 Student 实体类
最后是创建⼀个数据库访问对象 ，其源码如下所⽰：
1. package dao;
2. import java.sql.SQLException;
3. import entity.Student;
4. /**
5. * 学⽣数据访问类
6. * @author BeanSoft@
7. * @version 0.1 2007-12-21
8. */
9. public class StudentDAO {
10. /**
11. * 根据⽤户名和密码找到⽤户对象。

12. * @param username ⽤户名
13. * @param password 密码
14. * @return 找到的⽤户对象，找不到返回null
15. */
16. public Student findStudent(String username, String password) {
17. try {
18. Class.forName("com.mysql.jdbc.Driver");
19. } catch (ClassNotFoundException e) {
20. e.printStackTrace();
21. }
22. java.sql.Connection conn = null;//数据库连接
23. java.sql.PreparedStatement pstmt = null;//数据库表达式
24. java.sql.ResultSet rs = null;//结果集
25. String sql = "select * from Student where username = ? and password
26. = ?";//SQL
27. try {
28. conn = java.sql.DriverManager.getConnection(
29. "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncodi
30. ng=GBK", "root", null);
31. pstmt = conn.prepareStatement(sql);
32. pstmt.setString(1, username);
33. pstmt.setString(2, password);
34. rs = pstmt.executeQuery();
35. if(rs !=null && rs.next()) {
36. // 读到数据，⽣成实体类
37. Student student = new Student();
38. student.setId(rs.getInt(1));
39. student.setUsername(rs.getString("username"));
40. student.setPassword(rs.getString("password"));
41. student.setAge(rs.getInt("age"));
42. return student;
43. }
44. } catch (SQLException e) {
45. e.printStackTrace();
46. } finally {
47. // 6. 释放资源，建议放在finally语句中确保都被关闭掉了
48. try {
49. rs.close();
50. } catch (SQLException e) {}
51. try {
52. pstmt.close();
53. } catch (SQLException e) {}
54. try {
55. conn.close();
56. } catch (SQLException e) {}
57. }
58. return null;
59. }
60. }
复制代码
清单 8.8 StudentDAO 数据访问类
⾄此数据访问层的开发已经完成，为什么要多写这么多代码呢？这是因为分层的设计能够便于多⼈合作开发，也便于单独测试每⼀层的功能。

当然，项⽬规模⼩的话把所有的代码都放到那个Servlet ⾥⾯就⾏了。

修改Servlet 调⽤后台类
现在我们可以修改 Servlet 来加⼊调⽤DAO 层代码然后判断登录的功能了，设置完登录状态后，会转向到/result.jsp。

修改后的Servlet 代码如下所⽰：
1. package servlets;
2. import java.io.IOException;
3. import javax.servlet.ServletException;
4. import javax.servlet.http.HttpServlet;
5. import javax.servlet.http.HttpServletRequest;
6. import javax.servlet.http.HttpServletResponse;
7. import dao.StudentDAO;
8. import entity.Student;
9. public class LoginServlet extends HttpServlet {
10. public void doPost(HttpServletRequest request, HttpServletResponse
11. response)
12. throws ServletException, IOException {
13. Student student = new StudentDAO().findStudent(
14. request.getParameter("username"),request.getParameter("password"));
15. if(student != null &&
16. student.getUsername().equals(request.getParameter("username")) &&
17. student.getPassword().equals(request.getParameter("password"))) {
18. request.setAttribute("message", "成功");
19. //保存登录⽤户到session中
20. request.getSession().setAttribute("student", student);
21. } else {
22. request.setAttribute("message", "失败");
23. }
24. //转向登录结果页⾯
25. request.getRequestDispatcher("/result.jsp").forward(request,
26. response);
27. }
28. }
复制代码
清单 8.9 Servlet 加⼊登录判断功能
⾄此，这个简单的登录⼩项⽬就开发完毕了。

图 8.9 在MyEclipse 中打开浏览器测试应⽤
在表单的⽤户名处输⼊数据库⾥存在的学⽣的名字，例如张三，再输⼊密码，然后点击提交，就可以显⽰登录的结果了。

如果只是修改了 JSP 页⾯，那么MyEclipse 会⾃动把JSP 更新到服务器上，但是如果是改了类⽂件或者⼀些配置⽂件，那么需要⼿⼯重新发布这个项⽬。

如何重新发布这个项⽬呢？我们可以在Servers 视图上选中所发布的项⽬，然后点击视图⼯具栏上的
2009-12-10 15:50:10 上传
来重新发布，或者在项⽬上点击右键选择菜单Redeploy，如图8.10 所⽰。

之后稍等⽚刻就可以完成重新发布的过程。

调试JSP 应⽤
MyEclipse可以对Web应⽤⾥⾯的类或者JSP页⾯，Servlet进⾏调试。

例如可以双击JSP编辑器的⾏⾸的隔条，来设置断点，然后以调试模式启动服务器。

例如下⾯是访问index.jsp时的调试透视图界⾯，我们可以修改变量值b为4（被修改过的值以本⼈允荆 缓蟮慊鱀ebug 视图的
Resume按钮来继续往下执⾏，就可以看到最终的执⾏结果是5。

如下图所⽰：
图 8.11 修改变量跟踪调试JSP 页⾯
这⾥⽤的 index.jsp 页⾯的源码清单如下所⽰：
1. <%
2. int a = 1;
3. int b = 2;
4. out.println(a + b);
5. %>
复制代码
清单 8.10 ⽤来调试的JSP 页⾯源码
使⽤调试器可以很⽅便的快速定位出现问题的地⽅，加快修改代码的速度。

向现有Web 项⽬添加Web 开发功能
如果拿到了⼀个其它开发⼯具例如 WTP，Netbeans，JBuilder 等所制作的Web 项⽬，⽽不是通过MyEclipse 所创建的Web 项⽬，那么MyEclipse 将会拒绝对它进⾏发布，调试等操作。

这种情况下可以从 MyEclipse 菜单栏选择MyEclipse > Project Capabilities >Add Web Project Capabilities ... 来启动MyEclipse Web Capabilities 向导，如下图⽰：
图 8.12 MyEclipse Web 项⽬向导
在这个对话框中选中 Web 项⽬的根⽬录，点击Web Root Directory 最右侧的Browse...按钮来选中，之后设置上下⽂访问路径（Web Context Root），并选择合适的Java EE 版本（J2EE Specification Level）后，点击Finish 按钮后就给当前项⽬加⼊了Web 开发功能了，之后就可以⽅便的对它进⾏发布等操作。

相关文档
最新文档