javaweb-Servlet&HTTP&Request-033

lidashent

已于 2022-07-13 09:38:33 修改

阅读量178

点赞数

分类专栏： javaweb 文章标签： java

于 2020-07-29 17:34:09 首次发布

本文链接：https://blog.csdn.net/lidashent/article/details/107601848

版权

javaweb 专栏收录该内容

92 篇文章 0 订阅

订阅专栏

文章目录

Servlet：

1. 概念
2. 步骤
3. 执行原理
4. 生命周期
5. Servlet3.0 注解配置
6. Servlet的体系结构
每次继承抽象方法需要重写五个，但是实际使用的就一个，
	Servlet -- 接口
		|
	GenericServlet -- 抽象类
	如果继承他，只需要写一个service方法就可以，把其他方法都做了默认的空实现，只给service()方法做了抽象（这意味着后来人可以根据需求重写方法，或者不重写，而不用像继承sevlet那样必须全部重写） 
		|
	HttpServlet  -- 抽象类
	对http的封装，自动根据表单的post，get方法进行网络传输，内部判断，是预写的servlet实现（http有七种请求方式，这里只是是使用了两种）
8. Servlet相关配置
	1. urlpartten:Servlet访问路径
		1. 一个Servlet可以定义多个访问路径 ： @WebServlet({"/d4","/dd4","/ddd4"})
		2. 路径定义规则：
			1. /xxx：路径匹配
			2. /xxx/xxx:多层路径，目录结构  另外/user/*随意也可以
			3. *.do：扩展名匹配  hehe.do

设定表单提交

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
    <form action="/test_http" method="post">
        <input name="username">
        <input type="checkbox" name="hobby" value="game" >游戏
        <input type="checkbox" name="hobby" value="study">学习
        <input type="submit" value="提交">
    </form>
<a href="/test_http">test</a>
</body>
</html>

get，post方法调用验证

@WebServlet("/test_http")
public class test_http extends HttpServlet {
//    浏览器直接请求，doget方式
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doget方式");
    }
//form
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("dopost方式");
    }
}

HTTP：

* 概念：Hyper Text Transfer Protocol 超文本传输协议
	* 传输协议：定义了，客户端和服务器端通信时，发送数据的格式
	* 特点：
		1. 基于TCP/IP的高级协议
		2. 默认端口号:80
		3. 基于请求/响应模型的:一次请求对应一次响应
		4. 无状态的：每次请求之间相互独立，不能交互数据

	* 历史版本：
		* 1.0：每一次请求响应都会建立新的连接
		* 1.1：复用连接

* 请求消息数据格式
	1. 请求行
		请求方式 请求url 请求协议/版本
		GET /login.html	HTTP/1.1

		* 请求方式：
			* HTTP协议有7中请求方式，常用的有2种
				* GET：
					1. 请求参数在请求行中，在url后。
					2. 请求的url长度有限制的
					3. 不太安全
				* POST：
					1. 请求参数在请求体中
					2. 请求的url长度没有限制的
					3. 相对安全
	2. 请求头：客户端浏览器告诉服务器一些信息
		请求头名称: 请求头值
		* 常见的请求头：
			1. User-Agent：浏览器告诉服务器，我访问你使用的浏览器版本信息
				* 可以在服务器端获取该头的信息，解决浏览器的兼容性问题

			2. Referer：http://localhost/login.html
				* 告诉服务器，我(当前请求)从哪里来？
					* 作用：
						1. 防盗链：判断链接的请求来处是否合法
						2. 统计工作：`代码内容，比如打广告，判断别人由此进入的用户来源平台，计算收益

`
3. 请求空行
空行，就是用于分割POST请求的请求头，和请求体的。
4. 请求体(正文)：
* 封装POST请求消息的请求参数的

	* 字符串格式：
		POST /login.html	HTTP/1.1
		Host: localhost
		User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:60.0) Gecko/20100101 Firefox/60.0
		Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
		Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
		Accept-Encoding: gzip, deflate
		Referer: http://localhost/login.html
		Connection: keep-alive
		Upgrade-Insecure-Requests: 1
		
		username=zhangsan	


* 响应消息数据格式

Request：

1. request对象和response对象的原理
	1. request和response对象是由服务器创建的。我们来使用它们
	2. request对象是来获取请求消息，response对象是来设置响应消息
	流程：浏览器发送数据，服务器创建request与response对象并将浏览器发送来得数据封装在request中，
	将程序员反馈的数据封装在response中，响应给浏览器

2. request对象继承体系结构：	
	ServletRequest		--	接口
		|	继承
	HttpServletRequest	-- 接口，子接口。
		|	实现
	org.apache.catalina.connector.RequestFacade 类(tomcat)创建，实现httpservletrequest方法，封装在tomcat中省去操作。

3. request功能：
	1. 获取请求消息数据
		1. 获取请求行数据
			* GET /day14/demo1?name=zhangsan HTTP/1.1
			* 方法：
				1. 获取请求方式 ：GET
					* String getMethod()  
				2. (*)获取虚拟目录：/day14重要，已标记
					* String getContextPath()
				3. 获取Servlet路径: /demo1
					* String getServletPath()
				4. 获取get方式请求参数：name=zhangsan，以后有更加高级的，不常用
				而且post是拿不到参数的
					* String getQueryString()
				6. (*)获取请求URI：/day14/demo1重要，已标记
					* String getRequestURI():		/day14/demo1
					* StringBuffer getRequestURL()  :http://localhost/day14/demo1

					* URL:统一资源定位符 ： http://localhost/day14/demo1	中华人民共和国
					* URI：统一资源标识符 : /day14/demo1					共和国，范围大精度低
				
				7. 获取协议及版本：HTTP/1.1
					* String getProtocol()

				8. 获取客户机的IP地址：
					* String getRemoteAddr()

@WebServlet("/test_http")
public class test_http extends HttpServlet {
//    浏览器直接请求，doget方式
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doget方式");

    }
//form
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("dopost方式");
        //        获得request请求方式
        String reqMethod = req.getMethod();
        System.out.println(reqMethod);
        //        获得虚拟目录
        String servletPath = req.getServletPath();
        System.out.println(servletPath);
        //        获得post的请求参数
        String queryString = req.getQueryString();
        System.out.println(queryString);
        //        获得资源路径的url
        String requestURI = req.getRequestURI();
        System.out.println(requestURI);
        //        获得资源路径的urL
        StringBuffer requestURL = req.getRequestURL();
        System.out.println(requestURL);
        //        获得协议与版本
        String reqProtocol = req.getProtocol();
        System.out.println(reqProtocol);
        //        获得客户机地址
        String remoteUser = req.getRemoteAddr();
        System.out.println(remoteUser);
        /*
        * dopost方式
POST
/test_http
null
/test_http
http://localhost:8080/test_http
HTTP/1.1
0:0:0:0:0:0:0:1*/
    }
}

获取请求头数据
* 方法：
* (*)String getHeader(String name):通过请求头的名称获取请求头的值
* Enumeration getHeaderNames():获取所有的请求头名称
* 同时部署两个项目，可以再次添加tomcat实现，注意端口号不要重复

 	3. 获取请求体数据:
 		* 请求体：只有POST请求方式，才有请求体，在请求体中封装了POST请求的请求参数
 		* 步骤：
 			1. 获取流对象
 				*  BufferedReader getReader()：获取字符输入流，只能操作字符数据
 				*  ServletInputStream getInputStream()：获取字节输入流，可以操作所有类型数据，比如图片，音乐等
 					* 在文件上传知识点后讲解

 			2. 再从流对象中拿数据
 		
 		
 2. 其他功能：
 对于上面的方法的优化
 方法是通用的，get,post都可以用，既然代码相同，那么可以进行简化，在doget中使用
 this.dopost(request,response);作用到两个请求方式上
 并不可以，究竟有什么用，为什么不起作用？post无法获得得到参数，get可以。
 存疑
 两个方法都存在，需要在另一个方法上写上这句话，这样只需要在一个方法中实现就可以了
 虽然有些道理很容易明白，但是实践的时候未必能得到预期的效果，因为实践的细节是需要亲自做的，这是日后应用的关键
 	1. 获取请求参数通用方式：不论get还是post请求方式都可以使用下列方法来获取请求参数
 		1. String getParameter(String name):根据参数名称获取参数值    username=zs&password=123请求参数
 		2. String[] getParameterValues(String name):根据参数名称获取参数值的数组  hobby=xx&hobby=game可以用于复选框
 		3. Enumeration<String> getParameterNames():获取所有请求的参数名称，枚举
 		4. Map<String,String[]> getParameterMap():获取所有参数的map集合。可以获得所有的数据

 System.out.println("请求体");
        System.out.println("使用传统方法获取参数");
        Enumeration<String> parameterNames = request.getParameterNames();
        while (parameterNames.hasMoreElements()) {
            String pName = parameterNames.nextElement();
            if ("username".equals(pName)) {
                System.out.println(pName+"->>>>"+request.getParameter(pName));
            }
            if ("hobby".equals(pName)) {
                String[] parameterValues = request.getParameterValues(pName);
                System.out.println(Arrays.toString(parameterValues));
            }
        }
        System.out.println("使用map实现遍历参数");
        Map<String, String[]> parameterMap = request.getParameterMap();
        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
        for (Map.Entry<String, String[]> entry : entries) {
            System.out.println("key--"+entry.getKey());
            for (String s : entry.getValue()) {
                System.out.println(s);
            }
        }

			* 中文乱码问题：
				* get方式：tomcat 8 已经将get方式乱码问题解决了
				* post方式：会乱码
					* 解决：在获取参数前，设置request的编码request.setCharacterEncoding("utf-8");
		
				
		2. 请求转发：一种在服务器内部的资源跳转方式
		用户申请a,a再申请b
		使用请求适配器代理转发
			1. 步骤：
				1. 通过request对象获取请求转发器对象：RequestDispatcher getRequestDispatcher(String path)
				2. 使用RequestDispatcher对象来进行转发：forward(ServletRequest request, ServletResponse response) 

			2. 特点：
				1. 浏览器地址栏路径不发生变化
				2. 只能转发到当前服务器内部资源中。
				3. 转发是一次请求，请求一次，访问多个资源


		4. 共享数据：
			* 域对象：一个有作用范围的对象，可以在范围内共享数据
			* request域：代表一次请求的范围，一般用于请求转发的多个资源中共享数据
			* 就是资源申请的作用范围，一次用户请求携带的资源，可以被多个java类访问，这是服务器内部数据共享
			* 方法：
				1. void setAttribute(String name,Object obj):存储数据
				2. Object getAttitude(String name):通过键获取值
				3. void removeAttribute(String name):通过键移除键值对

 System.out.println("使用map实现遍历参数");
        Map<String, String[]> parameterMap = request.getParameterMap();
        Set<Map.Entry<String, String[]>> entries = parameterMap.entrySet();
        for (Map.Entry<String, String[]> entry : entries) {
            System.out.println("key--"+entry.getKey());
            for (String s : entry.getValue()) {
                System.out.println(s);
            }
            request.setAttribute(entry.getKey(),entry.getValue());
        }
        System.out.println("获取属性");
        String[] hobby = (String[]) request.getAttribute("hobby");
        for (String s : hobby) {
            System.out.println(s);
        }

		5. 获取ServletContext：
			* ServletContext getServletContext()
			* req.XXX

方法使用

@WebServlet("/test_http")
public class test_http extends HttpServlet {
//    浏览器直接请求，doget方式
  @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("doget方式");
		this.doPost(req,resp);
    }
//form
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("dopost方式");
//        获得请求头数据

//        获得所有的请求头名称
       /* Enumeration<String> headerNames = req.getHeaderNames();
//        根据请求头获得对应的值
        while(headerNames.hasMoreElements()){
            String nextElement = headerNames.nextElement();
//            获得请求头对应的值
            String reqHeader = req.getHeader(nextElement);
            System.out.println(nextElement+"________"+reqHeader);
        }*/
//获得单个请求头的具体信息
/*        String reqHeader = req.getHeader("user-agent");
        System.out.println("使用的浏览器为"+reqHeader);
        // 防止盗链，得知链接从哪里过来。如果直接访问时空，需要点击链接才可以
//        可以设置虚拟目录，对虚拟目录进行判断盗链，因为项目的虚拟目录是随意设置的
//        以后可以使用response向页面输出
        String reqHeader1 = req.getHeader("referer");
        System.out.println(reqHeader1);
        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().write("地址是："+reqHeader1);*/
//获得请球体数据

//获得网页提交的数据，仅仅支持post方式提交，使用流方式实现
// 获得字节流
        /*BufferedReader reqReader = req.getReader();
//        读取数据
        String data_line=null;
        while((data_line=reqReader.readLine())!=null){
            System.out.println(data_line);
        }*/
        /*
        * user=123*/

//        this.doGet(req,resp);
        //使用其他功能获得url申请参数，优化
/*
//        根据参数名称获得参数值
        String reqParameter = req.getParameter("username");
        System.out.println(reqParameter);
//        获得所有请求的参数名称
        Enumeration<String> reqParameterNames = req.getParameterNames();
        System.out.println(reqParameterNames.toString());
//        接下来可根据参数名进行遍历，先获得参数名，然后再获得参数值

        System.out.println("使用map集合进行获得参数");
//        使用map对参数进行抓取
        Map<String, String[]> reqParameterMap = req.getParameterMap();
//        遍历,得到键集合
        Set<String> stringSet = reqParameterMap.keySet();
        for(String key_name:stringSet){
//            根据按键获得值
            String[] strings = reqParameterMap.get(key_name);
            System.out.println(strings);
//            遍历值
            for(String value:strings){
                System.out.println(value);
            }
        }
*/
//请求转发
      /*  RequestDispatcher reqRequestDispatcher = req.getRequestDispatcher("/head_easy");
        reqRequestDispatcher.forward(req,resp);*/
        //      各个servlet中共享数据
        req.setAttribute("name","你好");
//      简化为一行，书写
      req.getRequestDispatcher("/head_easy").forward(req,resp);

    }
}

配合共享数据使用

//使用注解可以更加简便。其中有默认参数，例如loadstarup
@WebServlet(urlPatterns = "/head_easy")
//可以更加简化，将url省略掉，使用value就可以，进一步value也不用写

案例

在这里插入图片描述

快捷键

双shift搜索方法
control alt t surround with 可自动包裹代码

封装工具类

对于客户端的请求参数，基于java面向对象的思想，很自然的想到将所有参数封装为一个对象，参数即其属性，十分方便调用
9. BeanUtils工具类，简化数据封装
将网页数据一次获取，map，然后自动封装成对象，简化操作
* 用于封装JavaBean的
1. JavaBean：标准的Java类
1. 要求：
1. 类必须被public修饰
2. 必须提供空参的构造器
3. 成员变量必须使用private修饰
4. 提供公共setter和getter方法
2. 功能：封装数据

		2. 概念：
			成员变量：
			属性：setter和getter方法截取后的产物，就是自动生成的方法
				例如：getUsername() --> Username--> username


		3. 方法：
			1. setProperty()    user,name="hehe",value="123"
			2. getProperty()
			3. populate(Object obj , Map map):将map集合的键值对信息，封装到对应的JavaBean对象中，对象，值

//    使用BeanUtils工具类，简化数据封装
        Map<String, String[]> reqParameterMap = req.getParameterMap();
        Set<String> stringSet = reqParameterMap.keySet();
        for(String key_name:stringSet){
//            根据按键获得值
            String[] strings = reqParameterMap.get(key_name);
//            System.out.println(strings);

//            遍历值
            for(String value:strings){
                System.out.println(value);
            }
        }
        User user = new User();
        try {
//            数据已经封装到user中

            BeanUtils.populate(user,reqParameterMap);

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }