Servlet，javaweb的基础之一。

主要作用是处理浏览器的请求。

1. 接受请求 ServletRequest
2. 处理请求 编码
3. 响应请求 ServetResponse

Servlet接口：

public interface Servlet {    
  //生命周期方法，初始化，在Servlet对象创建后执行，仅执行一次    
  void init(ServletConfig var1) throws ServletException;   
  //获取Servlet配置信息    
  ServletConfig getServletConfig();   
  //生命周期方法，请求，处理，响应    
  void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;   
  //获取Servlet信息    
  String getServletInfo();   
  //生命周期方法，对象销毁前执行，仅执行一次   
  void destroy();
}

GenericServlet抽象类：

public abstract class GenericServlet implements Servlet, ServletConfig, Serializable {   
  //Servlet配置    
  private transient ServletConfig config;    
  //获取指定name初始参数value   
  public String getInitParameter(String name) {   
    return this.getServletConfig().getInitParameter(name);   
  }    
  //获取Servlet配置 
  public ServletConfig getServletConfig() {     
    return this.config;    
  }   
  //获取Servlet上下文    
  public ServletContext getServletContext() {     
    return this.getServletConfig().getServletContext();  
  }   
  //初始化，由Tomcat注入Servlet配置信息
  public void init(ServletConfig config) throws ServletException {    
    this.config = config;     
    //调用本类方法    
    this.init();  
  }    
  //重点方法，自定义Servlet类写此方法，而不是上一方法   
  public void init() throws ServletException {    }     
  //获取Servlet名称    
  public String getServletName() {       
    return this.config.getServletName();   
  }
}

HttpServlet对象

public abstract class HttpServlet extends GenericServlet {    
  public void service(ServletRequest req, ServletResponse res) throws ServletException,     IOException {  
    HttpServletRequest request;     
    HttpServletResponse response;       
    try {           
      //将请求和响应参数强制转为Http类型的请求和响应参数    
      request = (HttpServletRequest)req;        
      response = (HttpServletResponse)res;     
    } catch (ClassCastException var6) {     
      throw new ServletException(lStrings.getString("http.non_http"));    
    }        
    //调用本类的方法     
    this.service(request, response);   
  }   
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {  
  //获取请求的方法类型，调用相应的本类方法     
  String method = req.getMethod();  
  long lastModified;   
  if (method.equals("GET")) {   
    lastModified = this.getLastModified(req);    
    if (lastModified == -1L) {           
      //doGet方法           
      this.doGet(req, resp);       
    } else {          
      long ifModifiedSince;    
      try {                
        ifModifiedSince = req.getDateHeader("If-Modified-Since");      
      } catch (IllegalArgumentException var9) {      
        ifModifiedSince = -1L;        
      }              
      if (ifModifiedSince < lastModified / 1000L * 1000L) {       
        this.maybeSetLastModified(resp, lastModified);     
        this.doGet(req, resp);       
      } else {              
        resp.setStatus(304);    
      }       
    }       
  } else if (method.equals("HEAD")) {         
    lastModified = this.getLastModified(req);    
    this.maybeSetLastModified(resp, lastModified);    
    this.doHead(req, resp);    
  } else if (method.equals("POST")) {   
    //doGet方法         
    this.doPost(req, resp);     
  } else if (method.equals("PUT")) {  
    this.doPut(req, resp);     
  } else if (method.equals("DELETE")) {    
    this.doDelete(req, resp);      
  } else if (method.equals("OPTIONS")) {   
    this.doOptions(req, resp);   
  } else if (method.equals("TRACE")) {         
    this.doTrace(req, resp);       
  } else {          
    String errMsg = lStrings.getString("http.method_not_implemented");        
    Object[] errArgs = new Object[]{method};     
    errMsg = MessageFormat.format(errMsg, errArgs);  
    resp.sendError(501, errMsg);       
  }     
}   
//继承类重写的是此方法    
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 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); 
  }  
}

自定义Servlet

@WebServlet(urlPatterns = {"/getmsg"},     
            //初始化参数设置     
            initParams = {@WebInitParam(name = "name1",value = "a",description = ""),    
@WebInitParam(name = "name2",value = "b",description = "")})
public class MyServlet extends HttpServlet{    
    @Override    
    public  void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { 
        //请求和响应编码设置       
        req.setCharacterEncoding("utf-8");   
        resp.setContentType("text/html;charset=UTF-8");      
        //打印Servlet的pattern     
        System.out.println(req.getHttpServletMapping().getPattern());  
        //打印请求URL      
        System.out.println(req.getRequestURL().toString());  
        //打印初始化参数       
        resp.getWriter().print(getServletConfig().getInitParameter("name1"));       
        //响应       
        resp.getWriter().print("response"); 
    }    
    @Override   
    public void init() throws ServletException {      
      	System.out.println(getServletConfig().getServletName());
    }
}

重点：

1. 一般自定义Servlet继承HttpServlet即可，一般重写其中的init()、doGet()、doPost()方法；
2. Servet是非线程安全的；
3. @WebServlet中参数：loadOnStartUp默认-1，Servlet在第一次请求时才会创建，修改为非负值时为加载时创建并初始化，0优先级最高；
4. 路径通配符：* ，*只能在首或者尾，不能在中间，例：/*(匹配所有请求) 、*.do(匹配do结尾的请求)、/servlet/* (匹配/servlet/后的所有请求)，在请求优先级中，具体的urlPattern优先于通配符的；
5. 需重写doGet或者doPost或者其他的方法中的一个或多个，否则浏览器报405错误；
6. urlPattern必须以"/"开头；
7. “/"请求默认的DefaultServlet，另默认index.html、index.htm、index.jsp;
8. Servlet是单例模式，只在创建时加载一次；
9. 编码设置：req.setCharacterEncoding("utf-8");resp.setContentType("text/html;charset=UTF-8");

Servlet案例：

抽象AbsServlet类，对请求URL地址处理调用不同的方法，并做转发和重定向定义。

//自定义抽象类，对请求路径中的方法调用不同的方法
//调用方法后根据返回String值作不同的处理：转发、重定向
public abstract class AbsServlet extends HttpServlet {  
  @Override 
  public void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {     
    //获取请求URL路径    
    StringBuffer requestURL = req.getRequestURL();     
    //获取最后/之后的方法名称   
    String methodName=requestURL.substring(requestURL.lastIndexOf("/")+1);     
    //反射调用相应的方法      
    Method method = null;      
    String result = null;     
    try {             
      method = this.getClass().getMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);      
      result = (String)method.invoke(this, req, resp);      
    } catch (Exception e) {  
      e.printStackTrace();     
    }        
    //针对返回值做转发和重定向处理       
    if(result.contains(":")){        
      int indexOf = result.indexOf(":");       
      String first = result.substring(0, indexOf);        
      String path = result.substring(indexOf + 1);          
      if("forward".equals(first)){           
        //转发             
        req.getRequestDispatcher(path).forward(req,resp);  
      }else if ("redirect".equals(first)){      
        //重定向              
        resp.sendRedirect(req.getContextPath()+path);    
      }else{           
        throw new RuntimeException("当前操作不支持");   
      }      
    }
    //空符符跳到主页   
    else if("".equals(result) || result.trim().isEmpty()){          
      resp.sendRedirect(req.getContextPath()+"/index.jsp");     
    }else {         
      req.getRequestDispatcher(result).forward(req,resp);     
    }  
  }
}

//所有请求urlPattern均需声明
@WebServlet(urlPatterns = {"/getCount/add","/getCount/delete","/getCount/select"})
public class BServlet extends AbsServlet {   
      public String add(HttpServletRequest req,HttpServletResponse resp) throws ServletException, IOException { 
        //转发，地址不变，同一次请求    
        // return "forward:/getCound/delete";     
        //重定向，地址发生改变，不同的请求    
        // return "redirect:/getCount/select"; 
        //重定向主页      
        return "";   
      }    
    public String delete(HttpServletRequest req,HttpServletResponse resp){  
      try {        
        resp.getWriter().print("delete");     
      } catch (IOException e) {     
        e.printStackTrace();        }     
      //重定向delete.html文件     
      return “delete.html”; 
    }   
    public String select(HttpServletRequest req,HttpServletResponse resp){  
      try {           
        resp.getWriter().print("select");  
      } catch (IOException e) {     
        e.printStackTrace();   
      }      
      return null;  
    }
}

关于转发和重定向：

1.转发：req.getRequestDispatcher("/xxx").forward(req,resp);

转发，是请求请发，浏览器发出一次请求后，将请求的参数（rep,resp）转发到另一个请求，因此参数是共享的；

方法在服务器端内部将请求转发给另外一个资源，浏览器只知道发出了请求并得到了响应结果，并不知道在服务器程序内部发生了转发行为，因此URL地址是不会发生改变。

一个转发行为实际上浏览器只有一次请求。

转发的URL是相对当前web目录的根目录。

2.重定向：resp.sendRedirect("/xxx");

重定向，是响应方式，实际上是当前请求告诉浏览器去请求另一个路径，以重定向前后浏览器实际上是发生了两次请求，两次请求不共享参数，浏览器URL地址会发生改变。

重定向中的URL是相对于整个站点。