我是灼灼,一只初学Java的大一金渐层。
向往余秀华和狄兰·托马斯的疯狂,时常沉溺于将情感以诗相寄;追逐过王尔德、王小波的文字,后陷于毛姆和斯蒂芬·金不可自拔;热爱文学的浪潮,白日梦到底却总在现实里清醒;艳羡平静又极度渴盼奔跑的力量。
欢迎与我交流鸭· QQ:1517526827;
个人博客:https://blog.csdn.net/weixin_52777510?spm=1001.2101.3001.5343
Servlet 学习笔记
内容来自菜鸟教程:Servlet部分~
Servlet 为创建基于 web 的应用程序提供了基于组件、独立于平台的方法,可以不受 CGI 程序的性能限制。Servlet 有权限访问所有的 Java API,包括访问企业级数据库的 JDBC API。
使用 Java Servlet 可以开发基于 web 的应用程序。
文章目录
Servlet 简介
Servlet 是什么?
Java Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。
使用 Servlet可以收集来自网页表单的用户输入,呈现来自数据库或者其他源的记录,还可以动态创建网页。
Java Servlet 通常情况下与使用 CGI(Common Gateway Interface,公共网关接口)实现的程序可以达到异曲同工的效果。但是相比于 CGI,Servlet 有几点优势:
- 性能明显更好。
- Servlet 在 Web 服务器的地址空间内执行。这样它没有必要再创建一个单独的进程来处理每个客户端请求。
- Servlet 是独立于平台的,因为它们是用 Java 编写的。
- 服务器上的 Java 安全管理器执行了一系列限制,以保护服务器计算机上的资源。因此Servlet 是可信的。
- Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。
Servlet 架构
Servlet 在 Web 应用程序中的位置:
Servlet 执行以下主要任务:
- 读取客户端(浏览器)发送的显式的数据。这包括网页上的 HTML 表单,或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
- 读取客户端(浏览器)发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
- 处理数据并生成结果。这个过程可能需要访问数据库,执行 RMI 或 CORBA 调用,调用 Web 服务,或者直接计算得出对应的响应。
- 发送显式的数据(即文档)到客户端(浏览器)。该文档的格式可以是多种多样的,包括文本文件(HTML 或 XML)、二进制文件(GIF 图像)、Excel 等。
- 发送隐式的 HTTP 响应到客户端(浏览器)。这包括告诉浏览器或其他客户端被返回的文档类型(例如 HTML),设置 cookies 和缓存参数,以及其他类似的任务。
Servlet 包
Java Servlet 是运行在带有支持 Java Servlet 规范的解释器的 web 服务器上的 Java 类。
Servlet 可以使用 javax.servlet 和 javax.servlet.http 包创建,它是 Java 企业版的标准组成部分。
Java 企业版是支持大型开发项目的 Java 类库的扩展版本。
这些类实现 Java Servlet 和 JSP 规范。
Java Servlet 就像任何其他的 Java 类一样已经被创建和编译。在安装 Servlet 包并把它们添加到计算机上的 Classpath 类路径中之后,就可以通过 JDK 的 Java 编译器或任何其他编译器来编译 Servlet。
Servlet 环境设置(已完成)
详细内容见:https://www.runoob.com/servlet/servlet-environment-setup.html或https://www.runoob.com/jsp/eclipse-jsp.html
开发环境是开发、测试、运行Servlet 的地方。
需要使用 Java 编译器 javac 编译 Servlet,在编译 Servlet 应用程序后,将它部署在配置的环境中以便测试和运行。
开发环境设置包括以下步骤:
设置 Java 开发工具包(Java Development Kit)
设置 Web 应用服务器:Tomcat
在市场上有许多 Web 应用服务器支持 Servlet。
Apache Tomcat 是一款 Java Servlet 和 JavaServer Pages 技术的开源软件实现,可以作为测试 Servlet 的独立服务器,而且可以集成到 Apache Web 应用服务器。
设置 CLASSPATH
Servlet 生命周期
Servlet 生命周期可被定义为从创建直到毁灭的整个过程。以下是 Servlet 遵循的过程:
- Servlet 初始化后调用 init () 方法。
- Servlet 调用 service() 方法来处理客户端的请求。
- Servlet 销毁前调用 destroy() 方法。
- 最后,Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。
init() 方法
init 方法被设计成只调用一次。它在第一次创建 Servlet 时被调用,在后续每次用户请求时不再调用。因此,它是用于一次性初始化,就像 Applet 的 init 方法一样。
Servlet 创建于用户第一次调用对应于该 Servlet 的 URL 时,但是也可以指定 Servlet 在服务器第一次启动时被加载。
当用户调用一个 Servlet 时,就会创建一个 Servlet 实例,每一个用户请求都会产生一个新的线程,适当的时候移交给 doGet 或 doPost 方法。init() 方法简单地创建或加载一些数据,这些数据将被用于 Servlet 的整个生命周期。
init 方法的定义:
public void init() throws ServletException {
// 初始化代码...
}
service() 方法
service() 方法是执行实际任务的主要方法。Servlet 容器(即 Web 服务器)调用 service() 方法来处理来自客户端(浏览器)的请求,并把格式化的响应写回给客户端。
每次服务器接收到一个 Servlet 请求时,服务器会产生一个新的线程并调用服务。service() 方法检查 HTTP 请求类型(GET、POST、PUT、DELETE 等),并在适当的时候调用 doGet、doPost、doPut,doDelete 等方法。
该方法的特征:
public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException{
}
service() 方法由容器调用,service 方法在适当的时候调用 doGet、doPost、doPut、doDelete 等方法。所以不需要对 service() 方法做任何动作,只需要根据来自客户端的请求类型来重写 doGet() 或 doPost() 即可。
doGet() 和 doPost() 方法是每次服务请求中最常用的方法。
doGet() 方法
GET 请求来自于一个 URL 的正常请求,或者来自于一个未指定 METHOD 的 HTML 表单,它由 doGet() 方法处理。
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {
// Servlet 代码
}
doPost() 方法
POST 请求来自于一个特别指定了 METHOD 为 POST 的 HTML 表单,它由 doPost() 方法处理。
public void doPost(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {
// Servlet 代码
}
destroy() 方法
destroy() 方法只会被调用一次,在 Servlet 生命周期结束时被调用。destroy() 方法可以让 Servlet 关闭数据库连接、停止后台线程、把 Cookie 列表或点击计数器写入到磁盘,并执行其他类似的清理活动。
在调用 destroy() 方法之后,servlet 对象被标记为垃圾回收。destroy 方法定义:
public void destroy() {
// 终止化代码...
}
架构图
下图显示了一个典型的 Servlet 生命周期方案:
- 第一个到达服务器的 HTTP 请求被委派到 Servlet 容器。
- Servlet 容器在调用 service() 方法之前加载 Servlet。
- 然后 Servlet 容器处理由多个线程产生的多个请求,每个线程执行一个单一的 Servlet 实例的 service() 方法。
Servlet 实例
Servlet 是服务 HTTP 请求并实现 javax.servlet.Servlet 接口的 Java 类。Web 应用程序开发人员通常编写 Servlet 来扩展 javax.servlet.http.HttpServlet,并实现 Servlet 接口的抽象类专门用来处理 HTTP 请求。
Servlet 输出 Hello World 的示例源代码:
// 导入必需的 java 库
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
// 扩展 HttpServlet 类
public class HelloWorld extends HttpServlet {
private String message;
public void init() throws ServletException
{
// 执行必需的初始化
message = "Hello World";
}
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
{
// 设置响应内容类型
response.setContentType("text/html");
// 实际的逻辑是在这里
PrintWriter out = response.getWriter();
out.println("<h1>" + message + "</h1>");
}
public void destroy()
{
// 什么也不做
}
}
编译 Servlet
把上面的代码写在 HelloWorld.java 文件中,把这个文件放在 C:\ServletDevel(在 Windows 上)或 /usr/ServletDevel(在 UNIX 上)中,还需要把这些目录添加到 CLASSPATH 中。
假设环境已经正确地设置,进入 ServletDevel 目录,并编译 HelloWorld.java:
$ javac HelloWorld.java
如果 Servlet 依赖于任何其他库,必须在 CLASSPATH 中包含那些 JAR 文件。
编译会在同一目录下生成 HelloWorld.class 文件。
Servlet 部署
默认情况下,Servlet 应用程序位于路径 <Tomcat-installation-directory>
/webapps/ROOT 下,且类文件放在 <Tomcat-installation-directory>
/webapps/ROOT/WEB-INF/classes 中。
如果有一个完全合格的类名称 com.myorg.MyServlet,那么这个 Servlet 类必须位于 WEB-INF/classes/com/myorg/MyServlet.class 中。
把 HelloWorld.class 复制到 <Tomcat-installation-directory>
/webapps/ROOT/WEB-INF/classes 中,并在位于 <Tomcat-installation-directory>
/webapps/ROOT/WEB-INF/ 的 web.xml 文件中创建以下条目:
<web-app>
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/HelloWorld</url-pattern>
</servlet-mapping>
</web-app>
上面的条目要被创建在 web.xml 文件中的 <web-app>...</web-app>
标签内。在该文件中可能已经有各种可用的条目,但不要在意。
使用 <Tomcat-installation-directory>
\bin\startup.bat(在 Windows 上)或 /bin/startup.sh(在 Linux/Solaris 等上)启动 tomcat 服务器,最后在浏览器的地址栏中输入 http://localhost:8080/HelloWorld。会看到下面的结果:
Servlet 异常处理
当一个 Servlet 抛出一个异常时,Web 容器在使用了 exception-type 元素的 web.xml 中搜索与抛出异常类型相匹配的配置。
必须在 web.xml 中使用 error-page 元素来指定对特定异常 或 HTTP 状态码 作出相应的 Servlet 调用。
web.xml 配置
假设有一个 ErrorHandler 的 Servlet在任何已定义的异常或错误出现时被调用。
在 web.xml 中创建的项:
<!-- servlet 定义 -->
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>ErrorHandler</servlet-class>
</servlet>
<!-- servlet 映射 -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/ErrorHandler</url-pattern>
</servlet-mapping>
<!-- error-code 相关的错误页面 -->
<error-page>
<error-code>404</error-code>
<location>/ErrorHandler</location>
</error-page>
<error-page>
<error-code>403</error-code>
<location>/ErrorHandler</location>
</error-page>
<!-- exception-type 相关的错误页面 -->
<error-page>
<exception-type>
javax.servlet.ServletException
</exception-type >
<location>/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.io.IOException</exception-type >
<location>/ErrorHandler</location>
</error-page>
如果想对所有的异常有一个通用的错误处理程序,那么应定义下面的 error-page,而不为每个异常定义单独的 error-page 元素:
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>
关于上面的 web.xml 异常处理要注意的点:
- Servlet ErrorHandler 与其他的 Servlet 的定义方式一样,且在 web.xml 中进行配置。
- 如果有错误状态代码出现,不管为 404(Not Found 未找到)或 403(Forbidden 禁止),则会调用 ErrorHandler 的 Servlet。
- 如果 Web 应用程序抛出 ServletException 或 IOException,那么 Web 容器会调用 ErrorHandler 的 Servlet。
- 可以定义不同的错误处理程序来处理不同类型的错误或异常。
请求属性 - 错误/异常
错误处理的 Servlet 可以访问的请求属性列表,用来分析错误/异常的性质:
序号 | 属性 & 描述 |
---|---|
1 | javax.servlet.error.status_code 该属性给出状态码,状态码可被存储,并在存储为 java.lang.Integer 数据类型后可被分析。 |
2 | javax.servlet.error.exception_type 该属性给出异常类型的信息,异常类型可被存储,并在存储为 java.lang.Class 数据类型后可被分析。 |
3 | javax.servlet.error.message 该属性给出确切错误消息的信息,信息可被存储,并在存储为 java.lang.String 数据类型后可被分析。 |
4 | javax.servlet.error.request_uri 该属性给出有关 URL 调用 Servlet 的信息,信息可被存储,并在存储为 java.lang.String 数据类型后可被分析。 |
5 | javax.servlet.error.exception 该属性给出异常产生的信息,信息可被存储,并在存储为 java.lang.Throwable 数据类型后可被分析。 |
6 | javax.servlet.error.servlet_name 该属性给出 Servlet 的名称,名称可被存储,并在存储为 java.lang.String 数据类型后可被分析。 |
Servlet 应对任何定义的错误或异常发生时的错误处理程序
//导入必需的 java 库
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
//扩展 HttpServlet 类
public class ErrorHandler extends HttpServlet {
// 处理 GET 方法请求的方法
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
Throwable throwable = (Throwable)
request.getAttribute("javax.servlet.error.exception");
Integer statusCode = (Integer)
request.getAttribute("javax.servlet.error.status_code");
String servletName = (String)
request.getAttribute("javax.servlet.error.servlet_name");
if (servletName == null){
servletName = "Unknown";
}
String requestUri = (String)
request.getAttribute("javax.servlet.error.request_uri");
if (requestUri == null){
requestUri = "Unknown";
}
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String title = "菜鸟教程 Error/Exception 信息";
String docType = "<!DOCTYPE html>\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n");
out.println("<h1>菜鸟教程异常信息实例演示</h1>");
if (throwable == null && statusCode == null){
out.println("<h2>错误信息丢失</h2>");
out.println("请返回 <a href=\"" +
response.encodeURL("http://localhost:8080/") +
"\">主页</a>。");
}else if (statusCode != null) {
out.println("错误代码 : " + statusCode);
}else{
out.println("<h2>错误信息</h2>");
out.println("Servlet Name : " + servletName +
"</br></br>");
out.println("异常类型 : " +
throwable.getClass( ).getName( ) +
"</br></br>");
out.println("请求 URI: " + requestUri +
"<br><br>");
out.println("异常信息: " +
throwable.getMessage( ));
}
out.println("</body>");
out.println("</html>");
}
// 处理 POST 方法请求的方法
public void doPost(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
doGet(request, response);
}
}
以通常的方式编译 ErrorHandler.java,把类文件放入<Tomcat-installation-directory>
/webapps/ROOT/WEB-INF/classes 中。
在 web.xml 文件中添加配置来处理异常:
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>ErrorHandler</servlet-name>
<servlet-class>com.runoob.test.ErrorHandler</servlet-class>
</servlet>
<!-- servlet mappings -->
<servlet-mapping>
<servlet-name>ErrorHandler</servlet-name>
<url-pattern>/TomcatTest/ErrorHandler</url-pattern>
</servlet-mapping>
<error-page>
<error-code>404</error-code>
<location>/TomcatTest/ErrorHandler</location>
</error-page>
<error-page>
<exception-type>java.lang.Throwable</exception-type >
<location>/ErrorHandler</location>
</error-page>
</web-app>
使用一个会产生异常的 Servlet,或者输入一个错误的 URL,这将触发 Web 容器调用 ErrorHandler 的 Servlet,并显示适当的消息。如果输入了一个错误的 URL(如:http://localhost:8080/TomcatTest/UnKonwPage),将显示下面的结果:
Servlet 数据库访问
创建测试数据
在 MySQL 中创建 RUNOOB 数据库,创建 websites 数据表,表结构如下:
CREATE TABLE `websites` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` char(20) NOT NULL DEFAULT '' COMMENT '站点名称',
`url` varchar(255) NOT NULL DEFAULT '',
`alexa` int(11) NOT NULL DEFAULT '0' COMMENT 'Alexa 排名',
`country` char(10) NOT NULL DEFAULT '' COMMENT '国家',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
插入一些数据:
INSERT INTO `websites` VALUES ('1', 'Google', 'https://www.google.cm/', '1', 'USA'), ('2', '淘宝', 'https://www.taobao.com/', '13', 'CN'), ('3', '菜鸟教程', 'http://www.runoob.com', '5892', ''), ('4', '微博', 'http://weibo.com/', '20', 'CN'), ('5', 'Facebook', 'https://www.facebook.com/', '3', 'USA');
数据表显示如下:
访问数据库
使用 Servlet 访问数据库:
package com.runoob.test;
import java.io.IOException;
import java.io.PrintWriter;
import java.sql.*;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class DatabaseAccess
*/
@WebServlet("/DatabaseAccess")
public class DatabaseAccess extends HttpServlet {
private static final long serialVersionUID = 1L;
// JDBC 驱动名及数据库 URL
static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB";//最后是数据库的名称,连接的是本地的数据库
// 数据库的用户名与密码,根据自己的数据库设置
static final String USER = "root";
static final String PASS = "123456";
/**
* @see HttpServlet#HttpServlet()
*/
public DatabaseAccess() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//大部分内容和DBUtil一致
Connection conn = null;
Statement stmt = null;
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String title = "Servlet Mysql 测试 - 菜鸟教程";
String docType = "<!DOCTYPE html>\n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n");
try{
// 注册 JDBC 驱动器
Class.forName("com.mysql.jdbc.Driver");
// 打开一个连接
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// 执行 SQL 查询
stmt = conn.createStatement();
String sql;
sql = "SELECT id, name, url FROM websites";
ResultSet rs = stmt.executeQuery(sql);
// 展开结果集数据库
while(rs.next()){
// 通过字段检索
int id = rs.getInt("id");
String name = rs.getString("name");
String url = rs.getString("url");
// 输出数据
out.println("ID: " + id);
out.println(", 站点名称: " + name);
out.println(", 站点 URL: " + url);
out.println("<br />");
}
out.println("</body></html>");
// 完成后关闭
rs.close();
stmt.close();
conn.close();
} catch(SQLException se) {
// 处理 JDBC 错误
se.printStackTrace();
} catch(Exception e) {
// 处理 Class.forName 错误
e.printStackTrace();
}finally{
// 最后是用于关闭资源的块
try{
if(stmt!=null)
stmt.close();
}catch(SQLException se2){
}
try{
if(conn!=null)
conn.close();
}catch(SQLException se){
se.printStackTrace();
}
}
}
/**
* @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// TODO Auto-generated method stub
doGet(request, response);
}
}
编译上面的 Servlet,并在 web.xml 文件中创建以下条目:
....
<servlet>
<servlet-name>DatabaseAccess</servlet-name>
<servlet-class>com.runoob.test.DatabaseAccess</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>DatabaseAccess</servlet-name>
<url-pattern>/TomcatTest/DatabaseAccess</url-pattern>
</servlet-mapping>
....
调用这个 Servlet,输入链接:http://localhost:8080/TomcatTest/DatabaseAccess,(注意这个url的后面的部分)将显示以下响应结果:
new:
Servlet 文件上传
**注意:**Servlet3.0 已经内置了文件上传这一特性,开发者不再需要将 Commons FileUpload 组件导入到工程中去。
Servlet 处理日期
Servlet 网页重定向
当文档移动到新的位置,我们需要向客户端发送这个新位置时,我们需要用到网页重定向。当然,也可能是为了负载均衡,或者只是为了简单的随机,这些情况都有可能用到网页重定向。
Servlet 点击计数器(核心与JSP差不多)
网页点击计数器
使用 Servlet 来计算点击量是非常简单,因为一个 Servlet 的生命周期是由它运行所在的容器控制的。
实现一个简单的基于 Servlet 生命周期的网页点击计数器需要采取的步骤:
- 在 init() 方法中初始化一个全局变量。
- 每次调用 doGet() 或 doPost() 方法时,都增加全局变量。
- 如果需要,可以使用一个数据库表来存储全局变量的值在 destroy() 中。在下次初始化 Servlet 时,该值可在 init() 方法内被读取。这一步是可选的。
- 如果只想对一个 session 会话计数一次页面点击,那么请使用 isNew() 方法来检查该 session 会话是否已点击过相同页面。这一步是可选的。
- 可以通过显示全局计数器的值,来在网站上展示页面的总点击量。这一步是可选的。
假设 Web 容器将无法重新启动。如果是重新启动或 Servlet 被销毁,计数器将被重置。
实现一个简单的网页点击计数器:
package com.runoob.test;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class PageHitCounter
*/
@WebServlet("/PageHitCounter")
public class PageHitCounter extends HttpServlet {
private static final long serialVersionUID = 1L;
private int hitCount; //定义点击量
public void init()
{
// 重置点击计数器
hitCount = 0;
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/html;charset=UTF-8");
// 增加 hitCount
hitCount++;
PrintWriter out = response.getWriter();//读取字符数据
String title = "总点击量";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<h2 align=\"center\">" + hitCount + "</h2>\n" +
"</body></html>");
}
public void destroy()
{
// 这一步是可选的,如果需要,可以把 hitCount 的值写入到数据库
}
}
编译上面的 Servlet,并在 web.xml 文件中创建以下条目:
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>PageHitCounter</servlet-name>
<servlet-class>com.runoob.test.PageHitCounter</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>PageHitCounter</servlet-name>
<url-pattern>/TomcatTest/PageHitCounter</url-pattern>
</servlet-mapping>
</web-app>
通过访问 http://localhost:8080/TomcatTest/PageHitCounter 来调用这个 Servlet。将会在每次页面刷新时,把计数器的值增加 1。
网站点击计数器
在 Servlet 中,可以使用过滤器统计总点击量。
以下是实现一个简单的基于过滤器生命周期的网站点击计数器需要采取的步骤:
- 在过滤器的 init() 方法中初始化一个全局变量。
- 每次调用 doFilter 方法时,都增加全局变量。
- 如果需要,可以在过滤器的 destroy() 中使用一个数据库表来存储全局变量的值。在下次初始化过滤器时,该值可在 init() 方法内被读取, 这一步是可选的。
假设 Web 容器将无法重新启动。如果是重新启动或 Servlet 被销毁,点击计数器将被重置。
实现一个简单的网站点击计数器:
// 导入必需的 java 库
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
public class SiteHitCounter implements Filter{
private int hitCount;
public void init(FilterConfig config) //过滤器配置初始化
throws ServletException{
// 重置点击计数器
hitCount = 0;
}
public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)throws java.io.IOException, ServletException {
// 把计数器的值增加 1
hitCount++;
// 输出计数器
System.out.println("网站访问统计:"+ hitCount );
// 把请求传回到过滤器链
chain.doFilter(request,response);
}
public void destroy()
{
// 这一步是可选的,如果需要,可以把 hitCount 的值写入到数据库
}
}
编译上面的 Servlet,并在 web.xml 文件中创建以下条目:
....
<filter>
<filter-name>SiteHitCounter</filter-name>
<filter-class>SiteHitCounter</filter-class>
</filter>
<filter-mapping>
<filter-name>SiteHitCounter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
....
访问网站的任意页面,比如 http://localhost:8080/。将会在每次任意页面被点击时,把计数器的值增加 1,它会在日志中显示以下消息:
网站访问统计: 1
网站访问统计: 2
网站访问统计: 3
网站访问统计: 4
网站访问统计: 5
..................
Servlet 自动刷新页面(核心与jsp一致)
刷新网页的最简单的方式是使用响应对象的方法 setIntHeader()。方法的定义:
public void setIntHeader(String header, int headerValue)
此方法把头信息 “Refresh” 连同一个表示时间间隔的整数值(以秒为单位)发送回浏览器。
Servlet 使用 setIntHeader() 方法来设置 Refresh 头信息,实现自动刷新页面:
package com.runoob.test;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Calendar;
import java.util.GregorianCalendar;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet implementation class Refresh
*/
@WebServlet("/Refresh")
public class Refresh extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 设置刷新自动加载的事件间隔为 5 秒
response.setIntHeader("Refresh", 5);
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
// 获取当前的时间
Calendar calendar = new GregorianCalendar();
String am_pm;
int hour = calendar.get(Calendar.HOUR);
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
if(calendar.get(Calendar.AM_PM) == 0)
am_pm = "AM";
else
am_pm = "PM";
String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
PrintWriter out = response.getWriter();
String title = "使用 Servlet 自动刷新页面";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n"+
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<p>当前时间是:" + CT + "</p>\n");
}
}
编译上面的 Servlet,并在 web.xml 文件中创建以下条目:
<?xml version="1.0" encoding="UTF-8"?>
<web-app>
<servlet>
<servlet-name>Refresh</servlet-name>
<servlet-class>com.runoob.test.Refresh</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Refresh</servlet-name>
<url-pattern>/TomcatTest/Refresh</url-pattern>
</servlet-mapping>
</web-app>
通过访问 http://localhost:8080/TomcatTest/Refresh 来调用这个 Servlet。将会每隔 5 秒钟显示一次当前系统时间。运行该 Servlet,等待查看结果。
Servlet 发送电子邮件(改写jsp发送电子邮件的代码)
发送一封简单的电子邮件
// 文件名 SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 收件人的电子邮件 ID
String to = "abcd@gmail.com";
// 发件人的电子邮件 ID
String from = "web@gmail.com";
// 假设您是从本地主机发送电子邮件
String host = "localhost";
// 获取系统的属性
Properties properties = System.getProperties();
// 设置邮件服务器
properties.setProperty("mail.smtp.host", host);
// 获取默认的 Session 对象
Session session = Session.getDefaultInstance(properties);
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try{
// 创建一个默认的 MimeMessage 对象
MimeMessage message = new MimeMessage(session);
// 设置 From: header field of the header.
message.setFrom(new InternetAddress(from));
// 设置 To: header field of the header.
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
// 设置 Subject: header field
message.setSubject("This is the Subject Line!");
// 现在设置实际消息
message.setText("This is actual message");
// 发送消息
Transport.send(message);
String title = "发送电子邮件";
String res = "成功发送消息...";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<p align=\"center\">" + res + "</p>\n" +
"</body></html>");
}catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
编译上面的 Servlet,并在 web.xml 文件中创建以下条目:
....
<servlet>
<servlet-name>SendEmail</servlet-name>
<servlet-class>SendEmail</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SendEmail</servlet-name>
<url-pattern>/SendEmail</url-pattern>
</servlet-mapping>
....
通过访问 URL http://localhost:8080/SendEmail 来调用这个 Servlet。这将会发送一封电子邮件到给定的电子邮件 ID abcd@gmail.com,并将显示响应。
发送一封 HTML 电子邮件
// 文件名 SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet{
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException
{
// 收件人的电子邮件 ID
String to = "abcd@gmail.com";
// 发件人的电子邮件 ID
String from = "web@gmail.com";
// 假设您是从本地主机发送电子邮件
String host = "localhost";
// 获取系统的属性
Properties properties = System.getProperties();
// 设置邮件服务器
properties.setProperty("mail.smtp.host", host);
// 获取默认的 Session 对象
Session session = Session.getDefaultInstance(properties);
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try{
// 创建一个默认的 MimeMessage 对象
MimeMessage message = new MimeMessage(session);
// 设置 From: header field of the header.
message.setFrom(new InternetAddress(from));
// 设置 To: header field of the header.
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
// 设置 Subject: header field
message.setSubject("This is the Subject Line!");
// 设置实际的 HTML 消息,内容大小不限
message.setContent("<h1>This is actual message</h1>",
"text/html" );
// 发送消息
Transport.send(message);
String title = "发送电子邮件";
String res = "成功发送消息...";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<p align=\"center\">" + res + "</p>\n" +
"</body></html>");
}catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
编译并运行上面的 Servlet ,在给定的电子邮件 ID 上发送 HTML 消息。
在电子邮件中发送附件
// 文件名 SendEmail.java
import java.io.*;
import java.util.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
public class SendEmail extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 收件人的电子邮件 ID
String to = "abcd@gmail.com";
// 发件人的电子邮件 ID
String from = "web@gmail.com";
// 假设您是从本地主机发送电子邮件
String host = "localhost";
// 获取系统的属性
Properties properties = System.getProperties();
// 设置邮件服务器
properties.setProperty("mail.smtp.host", host);
// 获取默认的 Session 对象
Session session = Session.getDefaultInstance(properties);
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
try{
// 创建一个默认的 MimeMessage 对象
MimeMessage message = new MimeMessage(session);
// 设置 From: header field of the header.
message.setFrom(new InternetAddress(from));
// 设置 To: header field of the header.
message.addRecipient(Message.RecipientType.TO,
new InternetAddress(to));
// 设置 Subject: header field
message.setSubject("This is the Subject Line!");
// 创建消息部分
BodyPart messageBodyPart = new MimeBodyPart();
// 填写消息
messageBodyPart.setText("This is message body");
// 创建一个多部分消息
Multipart multipart = new MimeMultipart();
// 设置文本消息部分
multipart.addBodyPart(messageBodyPart);
// 第二部分是附件
messageBodyPart = new MimeBodyPart();
String filename = "file.txt";
DataSource source = new FileDataSource(filename);
messageBodyPart.setDataHandler(new DataHandler(source));
messageBodyPart.setFileName(filename);
multipart.addBodyPart(messageBodyPart);
// 发送完整的消息部分
message.setContent(multipart );
// 发送消息
Transport.send(message);
String title = "发送电子邮件";
String res = "成功发送电子邮件...";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<p align=\"center\">" + res + "</p>\n" +
"</body></html>");
}catch (MessagingException mex) {
mex.printStackTrace();
}
}
}
编译并运行上面的 Servlet ,在给定的电子邮件 ID 上发送带有文件附件的消息。
Servlet 包
涉及到 WEB-INF 子目录的 Web 应用程序结构是所有的 Java web 应用程序的标准,并由 Servlet API 规范指定。给定一个顶级目录名 myapp,目录结构如下所示:
/myapp
/images
/WEB-INF
/classes
/lib
WEB-INF 子目录中包含应用程序的部署描述符,名为 web.xml。
所有的 HTML 文件都位于顶级目录 myapp 下。
对于 admin 用户,ROOT 目录是 myApp 的父目录。
创建包中的 Servlet
WEB-INF/classes 目录包含了所有的 Servlet 类和其他类文件,类文件所在的目录结构与他们的包名称匹配。
Servlet 调试
测试/调试 Servlet 始终是开发使用过程中的难点。Servlet 往往涉及大量的客户端/服务器交互,可能会出现错误但又难以重现。
System.out.println()
System.out.println() 是作为一个标记来使用的,用来测试一段特定的代码是否被执行。也可以打印出变量的值,此外,
- 由于 System 对象是核心 Java 对象的一部分,它可以在不需要安装任何额外类的情况下被用于任何地方。这包括 Servlet、JSP、RMI、EJB’s、普通的 Beans 和类,以及独立的应用程序。
- 与在断点处停止不同,写入到 System.out 不会干扰到应用程序的正常执行流程,这使得它在时序是至关重要的时候显得尤为有价值。
下面是使用 System.out.println() 的语法:
System.out.println("Debugging message");
通过上面的语法生成的所有消息将被记录在 Web 服务器日志文件中。
消息日志
使用适当的日志记录方法来记录所有调试、警告和错误消息是非常好的想法,推荐使用 log4J 来记录所有的消息。
Servlet API 还提供了一个简单的输出信息的方式,使用 log() 方法,如下:
// 导入必需的 java 库
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ContextLog extends HttpServlet {
public void doGet(HttpServletRequest request,HttpServletResponse response) throws ServletException,java.io.IOException {
String par = request.getParameter("par1");
// 调用两个 ServletContext.log 方法
ServletContext context = getServletContext( );
if (par == null || par.equals(""))
// 通过 Throwable 参数记录版本
context.log("No message received:",new IllegalStateException("Missing parameter"));
else
context.log("Here is the visitor's message: " + par);
response.setContentType("text/html;charset=UTF-8");
java.io.PrintWriter out = response.getWriter( );
String title = "Context Log";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + title + "</h1>\n" +
"<h2 align=\"center\">Messages sent</h2>\n" +
"</body></html>");
} //doGet
}
ServletContext 把它的文本消息记录到 Servlet 容器的日志文件中。对于 Tomcat,这些日志可以在 <Tomcat-installation-directory>
/logs 目录中找到。
这些日志文件对新出现的错误或问题的频率给出指示。建议在通常不会发生的异常的 catch 子句中使用 log() 函数。
使用 JDB 调试器
使用调试 applet 或应用程序的 jdb 命令来调试 Servlet。
为了调试一个 Servlet,可以调试 sun.servlet.http.HttpServer,然后把它看成是 HttpServer 执行 Servlet 来响应浏览器端的 HTTP 请求。这与调试 applet 小程序非常相似。与调试 applet 不同的是,实际被调试的程序是 sun.applet.AppletViewer。
大多数调试器会自动隐藏如何调试 applet 的细节。同样的,对于 servlet,必须帮调试器执行以下操作:
- 设置调试器的类路径 classpath,以便它可以找到 sun.servlet.http.Http-Server 和相关的类。
- 设置调试器的类路径 classpath,以便它可以找到 servlet 和支持的类,通常是在 server_root/servlets 和 server_root/classes 中。
通常不希望 server_root/servlets 在 classpath 中,因为它会禁用 servlet 的重新加载。但是这种包含规则对于调试是非常有用的。它允许调试器在 HttpServer 中的自定义 Servlet 加载器加载 Servlet 之前在 Servlet 中设置断点。
如果已经设置了正确的类路径 classpath,就可以开始调试 sun.servlet.http.HttpServer。可以在想要调试的 Servlet 代码中设置断点,然后通过 Web 浏览器使用给定的 Servlet(http://localhost:8080/servlet/ServletToDebug)向 HttpServer 发出请求,会看到程序执行到断点处会停止。
使用注释
代码中的注释有助于以各种方式进行调试。注释可用于调试过程的很多其他方式中。
该 Servlet 使用 Java 注释和单行注释(//…),多行注释(/* …*/)可用于暂时移除部分 Java 代码。如果 bug 消失,仔细看看被注释的代码并找出问题所在。
客户端和服务器端头信息
当一个 Servlet 并没有像预期那样时,查看原始的 HTTP 请求和响应是非常有用的。如果熟悉 HTTP 结构,可以阅读请求和响应,看看这些头信息究竟是什么。
重要的调试技巧
下面列出了一些 Servlet 调试的技巧:
-
注意,server_root/classes 不会重载,而 server_root/servlets 可能会。
-
要求浏览器显示它所显示的页面的原始内容。这有助于识别格式的问题。它通常是"视图"菜单下的一个选项。
-
通过强制执行完全重新加载页面来确保浏览器还没有缓存前一个请求的输出。
在 Netscape Navigator 中,请使用 Shift-Reload,在 Internet Explorer 中,请使用 Shift-Refresh。
-
确认 servlet 的 init() 方法接受一个 ServletConfig 参数,并调用 super.init(config)。
Servlet 国际化
三个重要术语:
- **国际化(i18n):**这意味着一个网站提供了不同版本的翻译成访问者的语言或国籍的内容。
- **本地化(l10n):**这意味着向网站添加资源,以使其适应特定的地理或文化区域,例如网站翻译成印地文(Hindi)。
- 区域设置(locale):这是一个特殊的文化或地理区域。它通常指语言符号后跟一个下划线和一个国家符号。例如 “en_US” 表示针对 US 的英语区域设置。
当建立一个全球性的网站时有一些注意事项。
Servlet 可以根据请求者的区域设置拾取相应版本的网站,并根据当地的语言、文化和需求提供相应的网站版本。 request 对象中返回 Locale 对象的方法:
java.util.Locale request.getLocale()
检测区域设置
下面列出了重要的区域设置方法,可以使用它们来检测请求者的地理位置、语言和区域设置。下面所有的方法都显示了请求者浏览器中设置的国家名称和语言名称。
序号 | 方法 & 描述 |
---|---|
1 | String getCountry() 该方法以 2 个大写字母形式的 ISO 3166 格式返回该区域设置的国家/地区代码。 |
2 | String getDisplayCountry() 该方法返回适合向用户显示的区域设置的国家的名称。 |
3 | String getLanguage() 该方法以小写字母形式的 ISO 639 格式返回该区域设置的语言代码。 |
4 | String getDisplayLanguage() 该方法返回适合向用户显示的区域设置的语言的名称。 |
5 | String getISO3Country() 该方法返回该区域设置的国家的三个字母缩写。 |
6 | String getISO3Language() 该方法返回该区域设置的语言的三个字母的缩写。 |
显示某个请求的语言和相关的国家:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class GetLocale extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 获取客户端的区域设置
Locale locale = request.getLocale();
//获取语言
String language = locale.getLanguage();
//获取国家
String country = locale.getCountry();
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
String title = "检测区域设置";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + language + "</h1>\n" +
"<h2 align=\"center\">" + country + "</h2>\n" +
"</body></html>");
}
}
语言设置
Servlet 可以输出以西欧语言(如英语、西班牙语、德语、法语、意大利语、荷兰语等)编写的页面。为了能正确显示所有的字符,设置 Content-Language 头非常重要。
使用 HTML 实体显示所有的特殊字符也非常重要,例如,“ñ” 表示 “ñ”,"¡" 表示 “¡”,如下:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
public class DisplaySpanish extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
// 设置西班牙语言代码
response.setHeader("Content-Language", "es");
String title = "En Español";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1>" + "En Español:" + "</h1>\n" +
"<h1>" + "¡Hola Mundo!" + "</h1>\n" +
"</body></html>");
}
}
特定于区域设置的日期
可以使用 java.text.DateFormat 类及其静态方法 getDateTimeInstance() 来格式化特定于区域设置的日期和时间。
格式化特定于某个给定的区域设置的日期:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.DateFormat;
import java.util.Date;
public class DateLocale extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
// 获取客户端的区域设置
Locale locale = request.getLocale( );
String date = DateFormat.getDateTimeInstance(
DateFormat.FULL,
DateFormat.SHORT,
locale).format(new Date( ));
String title = "特定于区域设置的日期";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + date + "</h1>\n" +
"</body></html>");
}
}
特定于区域设置的货币
可以使用 java.text.NumberFormat 类及其静态方法 getCurrencyInstance() 来格式化数字(比如 long 类型或 double 类型)为特定于区域设置的货币。
格式化特定于某个给定的区域设置的货币:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class CurrencyLocale extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
// 获取客户端的区域设置
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
String formattedCurr = nft.format(1000000);
String title = "特定于区域设置的货币";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + formattedCurr + "</h1>\n" +
"</body></html>");
}
}
特定于区域设置的百分比
可以使用 java.text.NumberFormat 类及其静态方法 getPercentInstance() 来格式化特定于区域设置的百分比。
格式化特定于某个给定的区域设置的百分比:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.Locale;
import java.text.NumberFormat;
import java.util.Date;
public class PercentageLocale extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException
{
// 设置响应内容类型
response.setContentType("text/html;charset=UTF-8");
PrintWriter out = response.getWriter();
// 获取客户端的区域设置
Locale locale = request.getLocale( );
NumberFormat nft = NumberFormat.getPercentInstance(locale);
String formattedPerc = nft.format(0.51);
String title = "特定于区域设置的百分比";
String docType = "<!DOCTYPE html> \n";
out.println(docType +
"<html>\n" +
"<head><title>" + title + "</title></head>\n" +
"<body bgcolor=\"#f0f0f0\">\n" +
"<h1 align=\"center\">" + formattedPerc + "</h1>\n" +
"</body></html>");
}
}
Servlet 有用的资源
Java Servlet 有用的网站
- Sun’s Site on Servlets - Sun 的官方网站上关于 Servlet 的相关资料。
- JSP Engine - Tomcat - Apache Tomcat 是一个开源软件,实现了对 Java Servlet 和 JSP(JavaServer Pages)技术的支持。
- MySQL Connector/J - MySQL Connector/J 是 MySQL 官方 JDBC 驱动程序。
- The JavaTM Tutorials - 该 Java 教程是为那些想用 Java 编程语言创建应用程序的编程人员提供的实用指南。
- JavaTM 2 SDK, Standard Edition - JavaTM 2 SDK, Standard Edition 的官网。
- Free Java Download - 为桌面计算机下载 Java!
- Sun Developer Network - Sun Microsystem 的官方网站,上面列出了所有的 API 文档,最新的 Java 技术、书籍和其他资源。
如果对你有帮助的话不要忘记一键三连噢~
谢谢鸭~
初次编写于2021/2/24日;