对于想了解Servlet笔记1的读者，本文将提供新的信息，我们将详细介绍servlet笔记百度网盘，并且为您提供关于Eclipse操作Servlet入门案例，创建类无法实现Servlet接口和继承Ht
对于想了解Servlet笔记1的读者，本文将提供新的信息，我们将详细介绍servlet笔记百度网盘，并且为您提供关于Eclipse操作Servlet入门案例，创建类无法实现Servlet接口和继承HttpServlet类、HTTP状态500-servlet fitTrackerServlet的Servlet.init（）抛出异常、Java Servlet(十一)：一个servlet被10个浏览器客户端访问时会创建几个servlet实例？、java Web 工程servlet中@WebServlet("/HelloServlet") 是怎么工作的的有价值信息。
本文目录一览：- Servlet笔记1（servlet笔记百度网盘）
- Eclipse操作Servlet入门案例，创建类无法实现Servlet接口和继承HttpServlet类
- HTTP状态500-servlet fitTrackerServlet的Servlet.init（）抛出异常
- Java Servlet(十一)：一个servlet被10个浏览器客户端访问时会创建几个servlet实例？
- java Web 工程servlet中@WebServlet("/HelloServlet") 是怎么工作的
Servlet笔记1（servlet笔记百度网盘）
1.Servlet的介绍：
jsp的本质就是一个Servet,当jsp页面部署在web容器中，web容器会将jsp编译成Servlet。并且jsp页面中的内容都在Servlet中的service()中进行执行，故我们也可以撇开jsp页面，直接操作Servlet,当把Servlet当做表现层来使用,即直接在Servlet中进行页面的开发，对于静态的html标签的内容，我们要使用输出流来输出，虽然这样可以达到效果，但是开发效率会很低，因为所有的html标签，都是用Servlet的输出流来输出的，极其繁琐。并且撇开了jsp页面，美工人员也无法参与到Servlet的开发中来。故自MVC规范出现后，Servlet仅仅作为控制器(Controller)使用，不再需要生成html标签内容。
2.jsp与Servlet的区别：
1.Servlet中没有内置对象，原来jsp中的内置对象都要由程序显示的创建
2.对于静态的HTML标签，Servlet都必须要用输出流来逐行输出
3.jsp/Servlet的生命周期
jsp的本质就是Servlet,jsp页面将被Web容器编译成对应的Servlet，当Servlet在容器中运行的时候，其实例的创建和销毁都不是程序员控制的，而是由Web容器控制
创建Servlet实例有两个时机：
1.客户端第一次请求某个Servlet时，系统创建该Servlet的实例，大部分的Servelt都是这种Servlet
2.Web应用启动时立即创建Servlet实例，即load-on-startup Servlet
每个Servlet的生命周期：
(1)创建Servlet实例
(2)Web容器调用Servlet的init()方法，对Servlet进行初始化
(3)Servlet初始化后，将一直存在与容器中，用于响应客户端的请求。如果客户端发送get请求，容器调用Servlet的doGet方法处理并响应请求；如果客户端发送post请求，容器调用Servlet的goPost方法处理并响应请求。或者统一用service()方法来处理响应用户请求。
(4)Web容器决定销毁Servlet时，先调用Servlet的destroy()方法，通常在关闭Web应用之时销毁Servlet
Servlet的生命周期图：
4.使用Servlet作为控制器
在标准的MVC模式中，Servlet是仅作为控制器(Controller)使用的，下面通过一个登录验证的例子来进行熟悉
登录页面：
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2018/1/4
Time: 16:46
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>登录页面</title>
</head>
<body>
<%
if(request.getAttribute("errMsg") != null){
out.println("<spancolor:red''>"+request.getAttribute("errMsg")+"</span><br/>");
}
%>
<form method="post" action="login">
用户名:<input type="text" name="username"><br>
密 码:<input type="password" name="psw"/><br>
<input type="submit" value="登录"/>
</form>
</body>
</html> 控制器Controller代码：
/**
* Description:servlet
* Author: Eleven
* Date: 2018/1/6 9:16
*/
@WebServlet(name = "login",urlPatterns = {"/login"})
public class LoginServlet extends HttpServlet{
//响应客户端请求的方法
public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String errMsg = "";
//Servlet本身不能输出响应到客户端，必须请求转发到视图jsp页面
RequestDispatcher rd;
//获取请求参数
String username = request.getParameter("username");
String psw = request.getParameter("psw");
//Servlet本身不处理任何业务逻辑，调用JavaBean处理用户请求
try{
DbDao dd = new DbDao("com.mysql.jdbc.Driver","jdbc:mysql://localhost:3306/test","root","123456");
String sql = "select password from user where username = ?";
ResultSet rs = dd.query(sql,username);
if(rs.next()){
//用户名和密码匹配
if(rs.getString("password").equals(psw)){
//将用户信息存在session中
HttpSession session = request.getSession();
session.setAttribute("username",username);
//请求转发
rd = request.getRequestDispatcher("/jsp/welcome.jsp");
rd.forward(request,response);
}else {
//用户名和密码不匹配
errMsg = "用户名和密码不匹配，请重新输入!";
}
}else{
//用户不存在
errMsg = "用户名不存在，请重新输入!";
}
}catch (Exception e){
e.printStackTrace();
}
if(errMsg != null && !errMsg.equals("")){
request.setAttribute("errMsg",errMsg);
rd = request.getRequestDispatcher("/jsp/login.jsp");
rd.forward(request,response);
}
}
}DbDao的代码：
/**
* Description:servlet
* Author: Eleven
* Date: 2018/1/6 9:27
*/
public class DbDao {
private Connection conn;
private String driver;
private String url;
private String name;
private String psw;
public DbDao() {
}
public DbDao( String driver, String url, String name, String psw) {
this.driver = driver;
this.url = url;
this.name = name;
this.psw = psw;
}
//获取数据库连接
public Connection getConnection() throws Exception{
if(conn == null){
//注册驱动
Class.forName(driver);
//获取连接
conn = DriverManager.getConnection(url,name,psw);
}
return conn;
}
//查询
public ResultSet query(String sql,Object... args) throws Exception{
//创建Statement
PreparedStatement pstmt = getConnection().prepareStatement(sql);
//设置参数
for(int i=0;i<args.length;i++){
pstmt.setObject(i+1,args[i]);
}
return pstmt.executeQuery();
}
//插入
public boolean insert(String sql,Object... args) throws Exception{
PreparedStatement pstmt = getConnection().prepareStatement(sql);
for(int i=0;i<args.length;i++){
pstmt.setObject(i+1,args[i]);
}
if(pstmt.executeUpdate() != 1){
return false;
}
return true;
}
//修改
public void modify(String sql,Object... args) throws Exception{
PreparedStatement pstmt = getConnection().prepareStatement(sql);
for(int i=0;i<args.length;i++){
pstmt.setObject(i+1,args[i]);
}
pstmt.executeUpdate();
pstmt.close();
}
//关闭数据库连接
public void closeConn() throws Exception{
if(conn != null && !conn.isClosed()){
conn.close();
}
}
public Connection getConn() {
return conn;
}
public void setConn(Connection conn) {
this.conn = conn;
}
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPsw() {
return psw;
}
public void setPsw(String psw) {
this.psw = psw;
}
}
Eclipse操作Servlet入门案例，创建类无法实现Servlet接口和继承HttpServlet类
问题描述：
从昨天下午到今天中午，这个问题被缠绕了良久。百度了很多，却都没有一言命中要害。
首先，还是基于对Web的理解。
第一：建立的是Dynamic Web Project；
第二：然后需要Web服务器，也就是Tomcat，没有集成工具Eclipse，发布Web工程有三种方式（自己查）；但是使用了Eclipse就得把Tomcat部署进去，即使Eclipse来操作Tomcat的了；
具体的配置步骤：window---->Preferences------>Server------->Runtime Environmemt----->add------>Tomcat版本------>选择你的Tomcat文件夹位置........（自己查）
问题：Eclipse找不到HttpServlet类是因为没有导入Servlet-api.jar包
解决方案一：
解决办法是：
打开Properties->java Bulid path->Libraries->Add Libraries->Server Runtime，选择tomcat服务器；
如果server Runtime里面是空的，是因为还没有添加服务器,添加运行时环境： Window->Preferences->Server->runtime Enviroment->add, 选择tomcat版本确定，这样工程中的 红色的浪线标记就不见了.
解决方案二：
重新导入即可。
在需要导入的工程上右键进入properties --> Java build path ，library选项卡中选择Add external jars，选择你所安装tomcat目录下lib文件中的Servlet-api.jar包。
问题：
Implicit super constructor Object() is undefined for default constructor. Must define an explicit constructor：
默认构造函数未定义隐式超类构造函数Object（）。 必须定义一个显式构造函数
解 决方案：
把java的类库加载进去，在工程上右键选择属性->Java Build Path的Libraries->Add Library选择JRE System Library->点击Next->选择Execution environment并选择版本或workspace default jre->点击Finish。
或者尝试：
右击项目--build path---configure Build path--libraries--双击JRE System library--Alternate JRE选择。
HTTP状态500-servlet fitTrackerServlet的Servlet.init（）抛出异常
这是我第一次使用Spring，并且正在关注PluralSight上的教程。运行第一个示例，我遇到标题中列出的错误。在我的控制台中，出现类似这些的错误。我正在使用较旧版本的依赖项来完成本课程。我已经确保紧跟本教程，所以不确定我是否在某个地方搞砸了或不赞成使用某些东西。我正在使用http：//
localhost：8080 / FitnessTracker /
greeting.html
SEVERE: Context initialization failedjava.lang.IllegalArgumentExceptionSEVERE: StandardWrapper.Throwablejava.lang.IllegalArgumentExceptionSEVERE: Allocate exception for servlet fitTrackerServletjava.lang.IllegalArgumentExceptionHelloController.java
package com.pluralsight.controller;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class HelloController { @RequestMapping(value = "/greeting") public String sayHello(Model model) { model.addAttribute("greeting", "Hello World"); return "hello"; }}servlet-config.xml
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"> <mvc:annotation-driven /> <context:component-scan base-package="com.pluralsight.controller" /> <beanp:prefix="/WEB-INF/jsp/" p:suffix=".jsp"/></beans>hello.jsp
<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>Insert title here</title></head><body> <h1>${greeting}</h1></body></html>web.xml
<?xml version="1.0" encoding="UTF-8"?><web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.5" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> <servlet> <servlet-name>fitTrackerServlet</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/config/servlet-config.xml</param-value> </init-param> </servlet> <servlet-mapping> <servlet-name>fitTrackerServlet</servlet-name> <url-pattern>*.html</url-pattern> </servlet-mapping> <display-name>Archetype Created Web Application</display-name></web-app>pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.pluralsight</groupId> <artifactId>FitnessTracker</artifactId> <packaging>war</packaging> <version>0.0.1-SNAPSHOT</version> <name>FitnessTracker Maven Webapp</name> <url>http://maven.apache.org</url> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>3.8.1</version> <scope>test</scope> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>3.2.0.RELEASE</version> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>servlet-api</artifactId> <version>2.5</version> <scope>provided</scope> </dependency> <dependency> <groupId>javax.servlet</groupId> <artifactId>jstl</artifactId> <version>1.2</version> <scope>provided</scope> </dependency> </dependencies> <build> <finalName>FitnessTracker</finalName> </build></project>答案1
小编典典我在同一个PluralSight教程中遇到了同样的问题。我同时安装了Java 1.7和Java 1.8。该项目显然引发了Java
1.8的异常。要纠正这种情况，您需要确保将Spring STS环境设置为使用Java 1.7。
- 右键单击该项目，然后选择“ 属性” 。
- 在“ 属性” 对话框中，选择“ Java编译器” 。
- 在对话框的底部，选择链接以配置 Installed JRE 。
- 添加一个指向JRE 1.7的定义，并将其选择为默认设置。
现在，PluralSight教程对我有用。我本人是Java和Spring MVC的初学者，所以我不确定这是否是解决问题的最佳方法。
Java Servlet(十一)：一个servlet被10个浏览器客户端访问时会创建几个servlet实例？
一般Servlet只初始化一次（只有一个实例）。对于更多的客户端请求，Server创建新的请求和响应对象，仍然激活此Servlet的service（）方法，将这两个对象作为参数传递给该方法。如此重复以上的循环，但无需再调用init（）方法。
原因：
出于性能的考虑：特别的对于门户网站而言，每一个Servlet在每一秒内的并发访问量都可以是成千上万的。在一个面向模块化开发的现在，常常一个点击操作就被定义为一个Servlet的实现，而如果Servlet的每一次被访问，都创建一个新的实例的话，服务器的可用资源消耗量将是一个相当重要的问题。
退一步，一般Servlet的访问是很快的，每一个实例被快速的创建，又被快速的回收，GC的回收速度也跟不上，频繁的内存操作也将可能带来次生的问题。
所以，Servlet的“单一实例化”是一个很重要的策略。
此时为了更好理解servlet，这里附上servlet、httpservlet代码：
Servlet源代码：
package javax.servlet;
import java.io.IOException;
// Referenced classes of package javax.servlet:
// ServletException, ServletConfig, ServletRequest, ServletResponse
public interface Servlet
{
public abstract void init(ServletConfig servletconfig)
throws ServletException;
public abstract ServletConfig getServletConfig();
public abstract void service(ServletRequest servletrequest, ServletResponse servletresponse)
throws ServletException, IOException;
public abstract String getServletInfo();
public abstract void destroy();
} HttpServlet源代码：
import java.io.IOException;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.text.MessageFormat;
import java.util.Enumeration;
import java.util.ResourceBundle;
import javax.servlet.*;
// Referenced classes of package javax.servlet.http:
// NoBodyResponse, HttpServletRequest, HttpServletResponse
public abstract class HttpServlet extends GenericServlet
implements Serializable
{
public HttpServlet()
{
}
protected void doGet(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_get_not_supported");
if(protocol.endsWith("1.1"))
resp.sendError(405, msg);
else
resp.sendError(400, msg);
}
protected long getLastModified(HttpServletRequest req)
{
return -1L;
}
protected void doHead(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
NoBodyResponse response = new NoBodyResponse(resp);
doGet(req, response);
response.setContentLength();
}
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_post_not_supported");
if(protocol.endsWith("1.1"))
resp.sendError(405, msg);
else
resp.sendError(400, msg);
}
protected void doPut(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_put_not_supported");
if(protocol.endsWith("1.1"))
resp.sendError(405, msg);
else
resp.sendError(400, msg);
}
protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String protocol = req.getProtocol();
String msg = lStrings.getString("http.method_delete_not_supported");
if(protocol.endsWith("1.1"))
resp.sendError(405, msg);
else
resp.sendError(400, msg);
}
private Method[] getAllDeclaredMethods(Class c)
{
if(c.equals(javax/servlet/http/HttpServlet))
return null;
Method parentMethods[] = getAllDeclaredMethods(c.getSuperclass());
Method thisMethods[] = c.getDeclaredMethods();
if(parentMethods != null && parentMethods.length > 0)
{
Method allMethods[] = new Method[parentMethods.length + thisMethods.length];
System.arraycopy(parentMethods, 0, allMethods, 0, parentMethods.length);
System.arraycopy(thisMethods, 0, allMethods, parentMethods.length, thisMethods.length);
thisMethods = allMethods;
}
return thisMethods;
}
protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
Method methods[] = getAllDeclaredMethods(getClass());
boolean ALLOW_GET = false;
boolean ALLOW_HEAD = false;
boolean ALLOW_POST = false;
boolean ALLOW_PUT = false;
boolean ALLOW_DELETE = false;
boolean ALLOW_TRACE = true;
boolean ALLOW_OPTIONS = true;
for(int i = 0; i < methods.length; i++)
{
Method m = methods[i];
if(m.getName().equals("doGet"))
{
ALLOW_GET = true;
ALLOW_HEAD = true;
}
if(m.getName().equals("doPost"))
ALLOW_POST = true;
if(m.getName().equals("doPut"))
ALLOW_PUT = true;
if(m.getName().equals("doDelete"))
ALLOW_DELETE = true;
}
String allow = null;
if(ALLOW_GET && allow == null)
allow = "GET";
if(ALLOW_HEAD)
if(allow == null)
allow = "HEAD";
else
allow = (new StringBuilder()).append(allow).append(", HEAD").toString();
if(ALLOW_POST)
if(allow == null)
allow = "POST";
else
allow = (new StringBuilder()).append(allow).append(", POST").toString();
if(ALLOW_PUT)
if(allow == null)
allow = "PUT";
else
allow = (new StringBuilder()).append(allow).append(", PUT").toString();
if(ALLOW_DELETE)
if(allow == null)
allow = "DELETE";
else
allow = (new StringBuilder()).append(allow).append(", DELETE").toString();
if(ALLOW_TRACE)
if(allow == null)
allow = "TRACE";
else
allow = (new StringBuilder()).append(allow).append(", TRACE").toString();
if(ALLOW_OPTIONS)
if(allow == null)
allow = "OPTIONS";
else
allow = (new StringBuilder()).append(allow).append(", OPTIONS").toString();
resp.setHeader("Allow", allow);
}
protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String CRLF = "\r\n";
String responseString = (new StringBuilder()).append("TRACE ").append(req.getRequestURI()).append(" ").append(req.getProtocol()).toString();
for(Enumeration reqHeaderEnum = req.getHeaderNames(); reqHeaderEnum.hasMoreElements();)
{
String headerName = (String)reqHeaderEnum.nextElement();
responseString = (new StringBuilder()).append(responseString).append(CRLF).append(headerName).append(": ").append(req.getHeader(headerName)).toString();
}
responseString = (new StringBuilder()).append(responseString).append(CRLF).toString();
int responseLength = responseString.length();
resp.setContentType("message/http");
resp.setContentLength(responseLength);
ServletOutputStream out = resp.getOutputStream();
out.print(responseString);
out.close();
}
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException
{
String method = req.getMethod();
if(method.equals("GET"))
{
long lastModified = getLastModified(req);
if(lastModified == -1L)
{
doGet(req, resp);
} else
{
long ifModifiedSince = req.getDateHeader("If-Modified-Since");
if(ifModifiedSince < (lastModified / 1000L) * 1000L)
{
maybeSetLastModified(resp, lastModified);
doGet(req, resp);
} else
{
resp.setStatus(304);
}
}
} else
if(method.equals("HEAD"))
{
long lastModified = getLastModified(req);
maybeSetLastModified(resp, lastModified);
doHead(req, resp);
} else
if(method.equals("POST"))
doPost(req, resp);
else
if(method.equals("PUT"))
doPut(req, resp);
else
if(method.equals("DELETE"))
doDelete(req, resp);
else
if(method.equals("OPTIONS"))
doOptions(req, resp);
else
if(method.equals("TRACE"))
{
doTrace(req, resp);
} else
{
String errMsg = lStrings.getString("http.method_not_implemented");
Object errArgs[] = new Object[1];
errArgs[0] = method;
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(501, errMsg);
}
}
private void maybeSetLastModified(HttpServletResponse resp, long lastModified)
{
if(resp.containsHeader("Last-Modified"))
return;
if(lastModified >= 0L)
resp.setDateHeader("Last-Modified", lastModified);
}
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException
{
HttpServletRequest request;
HttpServletResponse response;
try
{
request = (HttpServletRequest)req;
response = (HttpServletResponse)res;
}
catch(ClassCastException e)
{
throw new ServletException("non-HTTP request or response");
}
service(request, response);
}
private static final String METHOD_DELETE = "DELETE";
private static final String METHOD_HEAD = "HEAD";
private static final String METHOD_GET = "GET";
private static final String METHOD_OPTIONS = "OPTIONS";
private static final String METHOD_POST = "POST";
private static final String METHOD_PUT = "PUT";
private static final String METHOD_TRACE = "TRACE";
private static final String HEADER_IFMODSINCE = "If-Modified-Since";
private static final String HEADER_LASTMOD = "Last-Modified";
private static final String LSTRING_FILE = "javax.servlet.http.LocalStrings";
private static ResourceBundle lStrings = ResourceBundle.getBundle("javax.servlet.http.LocalStrings");
}
参考：《.init()方法成功完成后,Servlet可以接受请求.默认有多少个Servlet实例被创建》、《Java Servlet(二)：servlet配置及生命周期相关(jdk7+tomcat7+eclipse)》
java Web 工程servlet中@WebServlet("/HelloServlet") 是怎么工作的
编写好Servlet之后，接下来要告诉Web容器有关于这个Servlet的一些信息。在Servlet
3.0中，可以使用标注(Annotation)来告知容器哪些Servlet会提供服务以及额外信息。例如在HelloServlet.java中：
@WebServlet("/hello.view")
public class HelloServlet extends HttpServlet {
只要在Servlet上设置@WebServlet标注，容器就会自动读取当中的信息。上面的@WebServlet告诉容器，如果请求的URL是“/hello.view”，则由HelloServlet的实例提供服务。可以使用@WebServlet提供更多信息。
@WebServlet(
name="Hello",
urlPatterns={"/hello.view"},
loadOnStartup=1
)
public class HelloServlet extends HttpServlet {
上
面的@WebServlet告知容器，HelloServlet这个Servlet的名称是Hello，这是由name属性指定的，而如果客户端请求的
URL是/hello.view，则由具Hello名称的Servlet来处理，这是由urlPatterns属性来指定的。在Java
EE相关应用程序中使用标注时，可以记得的是，没有设置的属性通常会有默认值。例如，若没有设置@WebServlet的name属性，默认值会是
Servlet的类完整名称。
当应用程序启动后，事实上并没有创建所有的Servlet实例。容器会在首次请求需要某个Servlet服务时，才
将对应的Servlet类实例化、进行初始化操作，然后再处理请求。这意味着第一次请求该Servlet的客户端，必须等待Servlet类实例化、进行
初始动作所必须花费的时间，才真正得到请求的处理。
如果希望应用程序启动时，就先将Servlet类载入、实例化并做好初始化动作，则可以使用
loadOnStartup设置。设置大于0的值(默认值为-1)，表示启动应用程序后就要初始化Servlet(而不是实例化几个Servlet)。数
字代表了Servlet的初始顺序，容器必须保证有较小数字的Servlet先初始化，在使用标注的情况下，如果有多个Servlet在设置
loadOnStartup时使用了相同的数字，则容器实现厂商可以自行决定要如何载入哪个Servlet。补充添加：标注(Annotation)声明后，则不需要在Web.xml中再次声明servlet的相关信息了：
<servlet>
<servlet-name>HServlet</servlet-name><servlet-class>com.kim.demo.HelloServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HServlet</servlet-name>
<url-pattern>/HServlet</url-pattern>
</servlet-mapping>今天关于Servlet笔记1和servlet笔记百度网盘的分享就到这里，希望大家有所收获，若想了解更多关于Eclipse操作Servlet入门案例，创建类无法实现Servlet接口和继承HttpServlet类、HTTP状态500-servlet fitTrackerServlet的Servlet.init（）抛出异常、Java Servlet(十一)：一个servlet被10个浏览器客户端访问时会创建几个servlet实例？、java Web 工程servlet中@WebServlet("/HelloServlet") 是怎么工作的等相关知识，可以在本站进行查询。
本文标签：
