Servlet --- HttpServlet

本文主要是介绍Servlet --- HttpServlet，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Java打卡：第98天

javaWeb — Servlet

内容导航

- HttpServlet
- - 快捷创建Servlet
- HttpServletRequest
- - 请求的生命周期
  - 请求参数parameter
- 域属性 attribute

Java EE

Servlet

昨天已经分享了欢迎页面和一般Servlet的书写，GenericServlet；使用模板方法模式和适配器模式

其实系统已经定义好一个之前的实现的GenericServlet；可以直接使用import javax.servlet.GenericServlet;

可以看一下源码

public abstract class GenericServlet implements Servlet, ServletConfig,
        java.io.Serializable {

    private static final long serialVersionUID = 1L;

    private transient ServletConfig config;
            
            
 public void init(ServletConfig config) throws ServletException {
        this.config = config;
        this.init();
    }

    /**
     * A convenience method which can be overridden so that there's no need to
     * call <code>super.init(config)</code>.
     * <p>
     * Instead of overriding {@link #init(ServletConfig)}, simply override this
     * method and it will be called by
     * <code>GenericServlet.init(ServletConfig config)</code>. The
     * <code>ServletConfig</code> object can still be retrieved via
     * {@link #getServletConfig}.
     *
     * @exception ServletException
     *                if an exception occurs that interrupts the servlet's
     *                normal operation
     */
    public void init() throws ServletException {
        // NOOP by default
    }

实现的思路和之前写的是相同的，使用了模板方法模式

HttpServlet

这里假如有一个需求：验证请求方式；表单提交的方式为POST；如果直接通过地址栏访问则拦截

分析：要想拦截，那就要获得请求提交的方式method；这里的service方法中有Request类型的，这里的req变量没有getMethod方法；==但是Request下面的子接口HTTPrequest有；

所以这里使用下转型可以获得对象【java其实不支持真正的下转型，只有超类对象是由子类对象上转型得到，才可以进行下转型】因为通信支持的是Http协议，所以这里就可以想到method应该与Http相关。

package cfeng;

import java.io.IOException;

import javax.servlet.*;
import javax.servlet.http.*;


@SuppressWarnings("serial")
public class HttpServlet extends GenericServlet {
	@Override
	public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
		//这里使用下转型
		HttpServletRequest request = (HttpServletRequest) req;
		HttpServletResponse response = (HttpServletResponse) res;
		//获取提交的method
		String method = request.getMethod();
		//操作method  使用equals方法一般将常量放在前面，这里可以避免空指针异常
		if("POST".equals(method)) {
			doPost();
		}else if("GET".equals(method)) {
			doGET();
		}

	}

	public void doGET() 
        
		System.out.println("非法操作，不允许访问");
	}

	public void doPost() {
		System.out.println("合法操作，允许访问");
	}

}


12月 19, 2021 5:30:52 下午 org.apache.catalina.loader.WebappClassLoaderBase checkThreadLocalsForLeaks
警告: 在Java 9上运行时，需要在JVM命令行参数中添加“-add opens=Java.base/Java.lang=ALL-UNNAMED”，以启用线程本地内存泄漏检测。或者，可以通过禁用ThreadLocal内存泄漏检测来抑制此警告。
12月 19, 2021 5:30:52 下午 org.apache.catalina.core.StandardContext reload
信息: 已完成重新加载名为/proj1的上下文
合法操作，允许访问

这样我们就实现了对于请求的处理，可以识别是正常的请求或者非法的请求

那么就有疑问了，操作请求是很常见的一种操作，会比较频繁使用，系统是否实现了这个类呢？就像GenericServlet一样，答案是肯定的；

当需要对请求进行操作的时候，可以不继承GenericServlet，可以直接继承HttpServlet

//这里可以看一下HttpServlet的源码
public abstract class HttpServlet extends GenericServlet {

     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException
    {
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String msg = lStrings.getString("http.method_post_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }
    
     protected void service(HttpServletRequest req, HttpServletResponse resp)
        throws ServletException, IOException {

        String method = req.getMethod();   //获取提交method

        if (method.equals(METHOD_GET)) {   //判断method
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                // servlet doesn't support if-modified-since, no reason
                // to go through further expensive logic
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    // Invalid date header - proceed as if none was set
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    // If the servlet mod time is later, call doGet()
                    // Round down to the nearest second for a proper compare
                    // A ifModifiedSince of -1 will always be less
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req,resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req,resp);

        } else {
            //
            // Note that this means NO servlet supports whatever
            // method was requested, anywhere on this server.
            //

            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
         
          @Override   //这里重写自GenericServlet的方法
    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(lStrings.getString("http.non_http"));
        }
        service(request, response);
    }
    }

可以看到这里的实现方法和上面的思路基本是一致的，倒时候需要使用的时候就继承该类；并且重写doGet和doPost方法

所以之后实现的时候就不要再继承GenericServlet，而是直接继承HttpServlet；操作就是重写两个方法

package cfeng;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.*;


public class loginServlet extends HttpServlet {
	@Override
	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		super.doPost(req, resp);
		System.out.println("合法操作");
	}
	
	@Override
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
		super.doGet(req, resp);
		doPost(req,resp);  //既支持POST，也支持GET
	}
}

这样当表单POST提交的时候就会执行该方法

快捷创建Servlet

经过前面的分析，以后创建Servlet的时候，就不用再继承Servlet接口或者GenericServlet抽象类了，可以直接继承HttpServlet类

并且可以使用Eclipse快捷操作，直接new的时候就创建Servlet；而不是创建Class；这样的好处就是不用手动配置

Ctrl + N 新建输入Servlet；输入名称，next；选择url-pattern；next选择方法就可快捷创建Servlet

在这里插入图片描述

这样就可以直接创建一个Servlet类

package cfeng;

import java.io.IOException;
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 Some
 */
@WebServlet("/Some")
public class Some extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public Some() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		response.getWriter().append("Served at: ").append(request.getContextPath());
	}

	/**
	 * @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);
	}

}

像这样之后就可以访问了

package cfeng;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(description = "this is just a test class", urlPatterns = { "/TestServlet" })
public class TestServlet extends HttpServlet {
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("hello");
	}
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

注意：这里的Servlet配置没有再web.xml中配置，而是直接使用注解websocket配置，推荐使用这种方式，更加方便动态

@WebServlet(description = “this is just a test class”, urlPatterns = { “/TestServlet” })

在Servlet类的前面加上这个，和在web.xml中配置的效果相同

HttpServletRequest

HttpServletRequest是SUN指定的Servlet规范，表示请求，父接口是ServletRequest；HTTP请求协议的完整的内容都要封装request对象中；Tomcat对于该接口进行了实现；之前使用抓包工具抓取的请求内容就是封装在HttpServletRequest中；

这里比如

用HttpWatch来进行观察，当使用表单POST提交的请求的内容

POST /Test/TestServlet HTTP/1.1
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:35.0) Gecko/20100101 Firefox/35.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate
Referer: http://localhost:8080/Test/
Connection: keep-alive
Content-Type: application/x-www-form-urlencoded
Content-Length: 23

user=%E5%BC%A0%E4%B8%89

这里出现了请求的中文乱码问题，稍后会进行分析；HttpServletRequest就是将上面的内容封装起来，方便直接进行操作。

request = org.apache.catalina.connector.RequestFacade@57a3f54a

这个对象就是Tomcat调用的时候对于HttpServletRequest接口的实现使用的就是该实现类的对象

请求的生命周期

当请求到达服务器的时候Tomcat服务器就会解析这个请求，按照HTTP协议解析之后就会封装成一个HttpServletRequest对象，这样就初始化完成。请求对象是由服务器创建。

当服务器向客户端响应结束后，HttpServletRequest实例对象由服务器销毁

一次请求对应一个请求对象，也就是对应一个Request对象；另外的对应另外一个对象，与之前的请求对象没有任何关系，所以Request对象的生命周期很短暂

HTTP是无状态【数据】协议，不同的请求之间是没有关系的

请求参数parameter

HttpServletRequest的父接口ServletRequest中就有关于请求参数的方法比如

getParameter： Returns the value of a request parameter as a String, or null if the parameter does not exist.

这里的请求参数是指的是提交表单的时候提交的参数，比如表单中的name就是，value就是参数的值

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("hello");
		System.out.println("request = " + request);
		String user = request.getParameter("user");
		System.out.println("user = " + user);
	}
	

已完成重新加载名为/Test的上下文
hello
request = org.apache.catalina.connector.RequestFacade@6ed310ae
user = hh

getParameterNames 返回的就是一个name的枚举集合，和之前的config类中的获取初始化参数相同

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("hello");
		System.out.println("request = " + request);
		Enumeration<String> parameterNames = request.getParameterNames();
    	//遍历枚举类型
		while(parameterNames.hasMoreElements()) {
			String name = parameterNames.nextElement();
			System.out.println(request.getParameter(name));
		}
	}

还是可以输出，和上面的结果相同的

HttpServletRequest对于请求所携带的参数是以Map的形式接收的，并且这个Map的key是String，value是String[]类型的，为什么是数组类型，而不是String类型？

表单中的复选框的类型比如checkbox，这里的value有多个值

<form action="/login" method="get">
    爱好:
    <input type="checkbox" name="hobby" value="soccer"/>足球
    <input type="checkbox" name="hobby" value="basketball"/>篮球
    <br>
</form>

这里的复选框就有多个值，那么获取的时候如果是一个String类型，是不能正常执行的，这里是一个Map类型的

user=zhangsan&hobby=soccer&hobby=basketball&hobby=tennis
//上面是请求的请求报文
hello
request = org.apache.catalina.connector.RequestFacade@6ed310ae
user=zhangsan
hobby=soccer

这里看到普通的根据name获取的参数值就是hobby=soccer；就是使用getParameter输出的只是一个value

getParameter本质上等同于getParameterValues(“name”)[0];

所以这里要将所有的value给取出来就要使用Map;之后使用getParameterValues；如果没有复选框，就使用getParameter就可以了

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		System.out.println("hello");
		System.out.println("request = " + request);
		Map<String, String[]> map = request.getParameterMap();
		for (String key : map.keySet()) {//keySet就是Map的键的集合
			String[] values = request.getParameterValues(key);   //获取map的value集合
			System.out.print(key + " = ");
			for(String value : values) {
				System.out.print(value + " ");
			}
			System.out.print("\n");
		}
	}

user = zhangsan 
hobby = soccer basketball tennis

这样子就可以获取复选框这种有多个值的name

域属性 attribute

dispatcher 调度程序，分配器 wrapper 包装

之前分析config的时候就提到了初始化参数和域属性；那里的域属性是所有的Servlet共享，就是一个应用程序对应一个应用程序；complex

在HttpRequest中也有域属性空间，用来存放有名称的数据，该数据只是在当前的request的请求中可以进行访问；只要请求还存在，就可以访问域属性空间的数据；所以域属性的作用就是用来传递数据的

和之前的complex相同，直接get，set就可

ServletRequest的一个方法是getRequestDispatch方法就是获得一个请求的分配器；就是正常来说一个请求提交给一个Servlet，可能完成不了任务；这个时候就要通过dispatcher转发给其他的servlet处理

getRequestDispatcher (String path) 将一个当前Servlet的请求转发给另外一个path；path可对应一个servlet 得到一个对应终点路径的调度器
- forward： Forwards a request from a servlet to another resource (servlet, JSP file, or HTML file) on the server. [forward 向前、传递] 就是将当前路径的请求传递给另外一个resource
- include ： Includes the content of a resource (servlet, JSP page, HTML file) in the response. 包含一个相应的所有的内容

在其中一个请求没有结束的时候，被分配的Servlet就可以访问操作域属性；和Complex是相同的；比如remove，set和get

package cfeng;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(description = "just for testing", urlPatterns = { "/some" })
public class someServlet extends HttpServlet {
	
		protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
			System.out.println(this.getServletName());
			 String author = (String)request.getAttribute("author");
			System.out.println("author = " + author);
			System.out.println("addree = " + request.getAttribute("address"));
	}

这里就是被分配的类，配置的信息就是在webServlet注释中，不需要再xml中配置

package cfeng;

import java.io.IOException;
import java.util.Enumeration;
import java.util.Map;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(description = "this is just a test class", urlPatterns = { "/TestServlet" })
public class TestServlet extends HttpServlet {
	
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setAttribute("author", "Cfeng");
		request.setAttribute("address", "Peking");
		
		Map<String, String[]> map = request.getParameterMap();
		request.getRequestDispatcher("/some").forward(request, response);
	}
	
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);//这里POST提交的时候也会执行GET中的方法
	}

}

这样就和之前讲解的域属性是类似的，就是Servlet之间实现属性共享，可以设置，访问和删除；这是这里的域属性必须是请求有效区间。♉️

这篇关于Servlet --- HttpServlet的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

Java教程