黑马程序员技术交流社区

标题: 【厦门JavaEE就业1期-每日总结】Tomcat与Servlet入门 [打印本页]

作者: 厦门校区 时间: 2018-5-31 20:20
标题: 【厦门JavaEE就业1期-每日总结】Tomcat与Servlet入门
同学们，今天我们正式学习了JavaWeb后台程序，大家要分清前台、后台、数据库这样一种关系。

今日需要掌握的有：

了解HTTP协议，几种常见的状态码一定要熟知
从前台表单提交数据到后台Servlet，Servlet对请求的数据进行处理，再将结果响应给前台。这个过程的具体操作一定要熟知！

请同学们按照如上要求，总结今日所学。

作者: 磬辰 时间: 2018-5-31 21:02
林文辉
一个请求必定有一个响应
请求部分：
Get和Post提交方式的区别：
1.Get会在地址栏显示提交的参数，而POST不会
2.GET提交的数据有大小限制，POST没有大小限制。
3.超链接只有get,没有post
4.表单可以使用post和get。表单一般都是使用post方式提交
5.get没有请求体
请求头：

User-Agen:浏览器类型。不同浏览器下载文件使用的编码方式不一样，可以通过这个针对不同
的浏览器使用不同的编码转换。

Referer:网页来源

If-Modified-Since: 与Last-Modified 查找本地缓存
响应部分：
状态码：
200 响应成功
302 重定向
304 查找本地缓存
404 访问资源不存在
500 服务器内部错误。
响应头：
Last-Modified :与If-Modified-Since一起查找本地缓存
Content-Dispostion :文件下载的使用使用的一个头信息.
Location:重定向的跳转的路径.
Refresh:定时刷新/定时跳转.
Servlet:
1.运行在Tomcat上的一个java程序
2.getParameter() 获取参数，String类型
getParametersValue()，返回一个String类型数组
getParameterMap(),返回一个Map集合，获取表单中的所有数据，key为name。

作者: 光宇 时间: 2018-5-31 21:07
侯玉林
今天主要学习了,tomcat服务器的部署,http协议的意义,以及如何通过servlet技术实现动态操作页面.

作者: 许大炮 时间: 2018-5-31 21:14
许剑鸿 WebDay13

TOMCAT:Apache组织研发,免费的小型的服务器软件,支持Servlet/JSP的开发规范.
Tomcat的目录结构:
*** bin :tomcat的执行的文件.
* conf :tomcat的配置文件.
*** lib :tomcat运行的需要的jar包.
*** logs :tomcat的运行的日志文件.
* temp :tomcat产生临时文件存放的路径.
*** webapps :tomcat发布的web项目的路径.
* work :tomcat运行JSP的时候,JSP翻译成Servlet的代码存放的路径
发布web项目到tomcat中:
直接copy项目到webapps下/在server.xml中配置虚拟路径/配置tomcat的虚拟路径
*一般由开发软件直接发布web项目

HTTP:超文本传输协议（HTTP，HyperText Transfer Protocol) 作用:规定浏览器和服务器的数据交互的格式.
HTTP协议的特点是基于请求和响应的模型(请求和响应成对出现)
请求分为GET POST :
         * GET的提交的参数会显示到地址栏上,而POST不显示.
         * GET往往是有大小限制的,而POST没有大小的限制.
         * GET没有请求体,而POST有请求体.

Servlet:就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
用来处理从客户端浏览器发送的请求,并且可以对请求作出响应

编写一个Servlet:1,编写一个类实现Servlet接口
public class ServletDemo1 implements Servlet{
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
res.getWriter().println("Hello Servlet...");
String req.getParameter(标签名);
String[] req.getParameterValues(标签名);
Map<String,String[]> req.getParameterMap();
}
...
}
         2,将编写的类配置到服务器中(web.xml)
      
    <servlet>
    <servlet-name>test1</servlet-name>
    <servlet-class>com.itheima.a_servlet.ServletDemo1</servlet-class>
    </servlet>

    <servlet-mapping>
    <servlet-name>test1</servlet-name>
    <url-pattern>/ServletDemo1</url-pattern>
</servlet-mapping>

作者: 渣.. 时间: 2018-5-31 21:19
柯威龙
今天学习了WEB服务器.他的一个定义的话就是在硬件上需要一太配置很高的电脑.软件上就是需要在
电脑上安装一个服务器的的软件.这样的额一台电脑称之为WEB服务器
Servlet是一个类Tomcat是一个服务器.相当于Tomcat是一个容器的话,Servlet属于这个容器里面的.
Servlet是一个运行在服务器上面的一个小的java程序.是用来接收和响应从服务器到客户端,客户端到
服务器的.Servlet的请求和响应是因为其中有一个http的协议.用来规范服务器和客户端之间传输数据
当要用java制作一个Servlet的时候,需要在普通类上去实现Servlet.然后去配置文件.
Tomacat服务器的话分为两种架构.分为cs和bs.cs的话都是需要在PC端安装下载的.BS的话只需要浏览器
就可以打开了.

作者: seilye 时间: 2018-5-31 21:20
Tomcat:(服务器)
安装与配置环境,以及常见的错误等;
如何将Tomcat添加到eclipse中;

HTTP协议:
get和post差别;大小限制,响应体,
常见的请求头:user-Agent:浏览器类型;Referer:防盗链;If-modified-Since查找本地缓存
常见的响应头:Last-Modified查找本地缓存;Content-Dispostion:文件下载;Location重定向;Refresh:定时刷新跳转;
常见的状态码:200成功;302重定向;304查找本地缓存;404访问资源不存在;500服务器内部错误;

Servlet:运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
使用步骤: 1,编写一个java类实现Servlet接口.将servlet方法重写,
2,ServletRequest调用setCharacterEncoding方法将编码格式缓存UTF-8
3,调用getParameter,getParameterValues,getParameterMap等方法获取用户输入的值
4,将web.xml配置文件要写入: <servlet>
<servlet-name>任意名称</servlet-name>
<servlet-class>com.itheima.Demo01.ServletDemo01(java的class的全名)</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>任意名称(两个name要一样)</servlet-name>
<url-pattern>/postt(任意取名,前面要加/)</url-pattern>
</servlet-mapping>
5,将HTML文件中的表格中的action="/项目名/与web.xml的<url-pattern>一致"
6,将编写的这个类配置到服务器中.

作者: Yanmo_ 时间: 2018-5-31 21:22
颜琳琳
今天主要学习了Tomcat服务器只需会安装即可.
接着学了HTTP协议:该协议主要掌握其中的状态码:200:响应成功; 302:重定向; 304:查找本地缓存; 404:找不到资源; 500:服务器内部错误
Servlet:是一种运行在WEB服务器上的一种Java的小程序.使用的步骤: 1.创建一个java类来实现Servlet接口; 2.在web.html中配置Servlet标签.

  <servlet>
          <servlet-name>    </servlet-name>
    <servlet-class>     </servlet-class>
  </servlet>
  
  <servlet-mapping>
          <servlet-name>  </servlet-name>
          <url-pattern>  </url-pattern>
  </servlet-mapping>
从前台表单提交数据到后台Servlet,Servlet对请求的数据进行处理其中处理的方法有:
String getParameter(String name);用于接收一个名称对应一个值的数据;
String[] getParameterValues(String name);用于接收一个名称对应多个值的数据.
Map getParameterMap(); 用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值;然后再将结果响应给前台.

作者: 13163997058 时间: 2018-5-31 21:24
本帖最后由 13163997058 于 2018-6-2 12:39 编辑

王刘锁
今天是学的最艰难的一天了,上午被那个STS配置Tomcat给搞的头大也没弄好,还是中午牺牲午休时间给解决的,然后下午上课就有点犯困走神,这下下午的知识又没听懂,晚上去写案例一行代码都敲不出来!又浪费时间重新看了一遍视频,感觉亏了一个亿一样!代码勉勉强强敲了一遍,记录一下对今天知识的理解.
先说HTTP协议,用来规范浏览器和服务器的数据传递,特点是有请求必有响应,这么见名知意的名词不用多解释了.
现在使用的是1.1版本不会一次响应就断开一次它会在等待一段时间没有请求的时候断开连接!
再说协议的结构;请求部分有
1.请求行(提交方式--post和get的区别也很简单不多说, 提交路径协议版本),
2.请求头(key:value的格式,一个key对应一个或多个value,我们要记住几个User-Agent--浏览器类型
,Referer--网页来源,If-Modified-Since--查找本地缓存),
3.请求体(post的提交方式才有).
响应部分我们要记:
1,响应行:协议版本状态码(200-成功,302-重定向,304-查找本地缓存,404-资源不存在,500-服务器错误
这些能理解就理解不能理解就记住,见得多了就知道了,) 状态码描述
2,响应头(key:value格式一对一或对多):Last-Modified查找本地缓存和请求的那个一块使用.
Content=Dispostion--下载文件用的头信息,Location--重定向的跳转路径,Refresh--定时跳转或刷新.
下面是两个案例:
一,页面提交跳转;
网址栏内输入localhost:8080/web_01(项目名)/index.html,在html文件中编写代码一个提交表单,
表单的提交路径action属性赋值另外一个index2html的文件名当然两个文件在同一级,这样在提交的
时候就会跳转到index2.html页面上,我在写着个案例的时候就是不知道怎么样跳转,差点去设置一个提
交事件,没认真听课的下场.
二,获取登录界面提交的信息并打印控制台,向注册添加信息到数据库和登录验证信息属实这样的案例还
没有涉及,目前只能打印到控制台这么low的方式了!其实原理还是跳转,不过就是把路径改成/web_01/ServletDemo
也就是/表名/访问Servlet实现类的那种方式,说到这里就必须说一下Servlet是什么,它是一个Java小程序用来
接收客户端的请求信息并响应,那就可以知道它是运行在服务器上的了,它其实是一种动态页面开发技术,那我们使用它其实就是编写一个类去实现它,然后把这个类配置到服务器中,配置需要去web.xml文件中编写代码,代码的格式和原理也不多说了,
接下来我们要向获得数据就需要知道几个方法:用ServletRequest中的方法,这几个方法参数都是要获得的数据的name值.
String getParameter(String name);接收一个值文本框,单选框..
String[] getParameterValues(String name);接收多个值.多选框..
Map getParameterMap(); 接收所有的数据,key是数据对应的参数名,value是值
就记得这么多了,可能有一些小的知识点没听到或没记住,

作者: 咸鱼coder 时间: 2018-5-31 21:30
万冕

TomCat 是apache组织的开源小型免费服务器,能让别人通过本机IP来访问上传的网页

今天才知道我们的Java是写B/S的,不需要安装,只需要一个浏览器,就可以操作非常的方便,更新只需要通过服务器里更新,
客户端浏览器都不需要更新.

HTTP是超文本传输协议,请求和响应是成对出现的,且必须先有请求后有响应

请求的方式主要由GET和POST两种方式,GET的数据就出现在地址行里,且GET没有请求体,POST的数据在请求体里,且POST没有
大小限制,还有一些常见的错误,200(响应成功) 302(重定向) 304(读取本地缓存) 404(资源不存在/路径错误) 500(服务器内部错误/代码出错)

今天被请求数据卡了一下,请求数据就是前端已经将数据封装进了ServletRequest req对象里了,然后我们通过req.getParameter
方法获取里面的数据getParameter(单一值) getParameterValues(多个值) getParameterMap(获取所有数据);

作者: sts 时间: 2018-5-31 21:33
苏海斌
http协议
请求and响应
请求部分分为请求行请求头请求体
响应部分也是

请求行提交方式常用的GET和POST;
两者的区别是
1.GET的提交的参数会显示到地址栏,而POST不显示
2.GET往往有大小限制,POST没有
3.GET没有请求体而POST有请求体
请求头:(小重点)
User-Agent       :代表浏览器的类型---文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码
Referer          :代表的是网页的来源---防盗链
If-Modified-Since  :通常与响应中的头Last-Modified一起使用查找本地缓存

响应部分
响应行的状态码:
200 成功
302 重定向
304 查找本地缓存
404 找不到资源
500 服务器内部错误
响应头
Last-Modified    :与全球中的If-Modified-Since一起使用查找本地缓存
Content-Dispostion :文件下载的使用的一个头信息
Location          :重定向的跳转的路径
Refresh          :定时刷新/跳转

Servlet:是运行在web服务器上的一个小的Java程序
使用方法:
1.创建一个Java类实现Servlet接口
2.配置

作者: wpwing 时间: 2018-5-31 21:34
吴鹏

总结
--------------------------------------

协议:用来规定双方的责任和义务,需要遵守的规则;
http协议:用来规定浏览器与服务器之间()数据的传递需要遵守的规则;

特点:基于请求和相应的模型;必须得先有请求,然后再有相应;请求和相应必须成对出现;
默认端口号为80;
协议版本:
1.0 :每次相应后即刻关闭了链接;
1.1 :每次响应后不会立即关闭,当等待超过设定时间后才关闭,现在使用该版本协议;

http协议的详解:
抓包分析:GET方式：
* 请求部分:
GET /day09/demo1-http/demo2.html?name=aaa&age=23 HTTP/1.1 请求行:请求方式请求路径协议版本
Accept: text/html, application/xhtml+xml, */*
X-HttpWatch-RID: 59176-10011
Referer: http://localhost:8080/day09/demo1-http/demo1.html
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko
Accept-Encoding: gzip, deflate
Host: localhost:8080
DNT: 1
Connection: Keep-Alive

抓包分析:POST方式：
POST /day09/demo1-http/demo2.html HTTP/1.1 请求行:请求方式请求路径协议版本
Accept: text/html, application/xhtml+xml, */*
X-HttpWatch-RID: 59176-10031
Referer: http://localhost:8080/day09/demo1-http/demo1.html
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64; Trident/7.0; rv:11.0) like Gecko
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Host: localhost:8080
Content-Length: 15
DNT: 1
Connection: Keep-Alive
Cache-Control: no-cache

name=bbb&age=38

* 响应部分:
HTTP/1.1 200 OK
Server: Apache-Coyote/1.1
Accept-Ranges: bytes
ETag: W/"145-1461807615933"
Last-Modified: Thu, 28 Apr 2016 01:40:15 GMT
Content-Type: text/html
Content-Length: 145
Date: Thu, 28 Apr 2016 01:43:52 GMT

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Demo2.html</h1>
</body>
</html>

请求部分:

请求行:请求方式请求路径协议版本
请求头:一般都是key:value键值对的形式,一般情况下一个key对应一个一个value,也有一些事一个k对多个v;
请求体:只有POST方法才有请求体;

请求头
都是键值对的形式现实的,一般一个k对应一个v,也有一个k对应多个v;
user-Agent:代表浏览器的类型 --- 个别浏览器在处理某些代码时有区别,比如下载文件,IE使用URLEncoder进行编码,火狐使用Base64;
Referer:记录当前页面的来源---防盗链;
If-Modified-Since:通常与响应中的头Last-Modified一起查找本地缓存;
请求行
提交方式:提交方式有很多,常用的GET,POST
GET 提交的参数会显示到地址栏,POST不会,没有请求体;
POST 提交的大小没有限制,GET有限制;
提交路径:
协议版本:

请求体:
POST提交方式的提交的参数;

相应部分:

响应行:
协议版本  状态码  状态码的描述
状态码: 200 成功;
            302 重定向;
            304 查找本地缓存;
            404 访问资源不存在;
            500 服务器内部错误;

响应头:
都是键值对的形式现实的,一般一个k对应一个v,也有一个k对应多个v;
Last-Modified:与请求中的If-Modified-Since一起查找本地缓存;
Content-Dispostion:文件下载时候使用的一个头信息;
Location:重定向的一个跳转路径;
Referesh:定时刷新/定时跳转;
空行

响应体:
响应的页面内容的代码;
-------------------------------------------------

1 前台表单提交数据到后台Servlet
<form action="/self/ServletDemo2" method="post">
      姓名:<input type="text" name="name"><br />
      年龄:<input type="text" name="age"><br />
         <input type="submit"  value="提交"/><br>
</form>
上述代码为前端HTML表单的部分代码,其中为了实现表单数据提交的时候提交到我们所实现Servlet后重写方法的类,
action后面要填入该类的路径,并且不是全部的路径,而是/项目名称/实现类名称;这样,在我们填写完信息后,点击提交的时候,
数据才会传入实现后的类;

Servlet对请求的数据进行处理
首先,我们要先在实现类中接收传过来的数据,然后才能处理数据,处理数据的为服务器端,传入数据的为客户端,在这里的数据传输属于请求,因此,
我们获取数据就要使用req的方法,其中,我们常用的方法为 String req.getParameter(String name),如果是复选框的话,
使用String[] req.getParameterValues(String[] name);形如:
String name = req.getParameter("name");
int age  = Integer.parseInt(req.getParameter("age"));
要注意的是,传输的数据都是属于String类型,为了向上面代码里那样获得int类型的数据的话,要使用Integer.parseInt()方法;

我们还可以使用Map<String,String[]> map = req.getParameterMap();
这样会将前端代码中,name的值放进key,value的值放进value里,

将结果响应给前台
获得数值后,我们可以对其进行操作,在这边我就将其打印到前端,打印到前端属于服务器响应,因此我们可以使用
res.getWriter().println(String name)方法,将得到的数据打印到前端页面;代码实现:
      res.getWriter().println(name);
      res.getWriter().println(age);

作者: 偏离X 时间: 2018-5-31 21:35
郭明杰:

1 [软件架构]:主要分为C/S架构跟B/S架构,cs架构需要服务器跟客户端的支持,
优点是效果好速度快但是服务器端更新的话,客户端也要更新才能使用,bs架构则反之

2 [WEB的资源]:分为静态资源(HTML,CSS,JS...) 跟动态资源(PHP,ASP,Servlet,JSP...)

3 [服务器]:在一台配置很高的电脑上安装服务器软件,这台电脑就成为是WEB服务器
4 发布一个WEB工程到Tomcat 有三种方法我们主要用的方法就是把工程拷贝到webapps下
5 [HTTP]Http协议的作用是规范浏览器跟服务器之间的数据传递
5.1 数据传输:从浏览器发送到服务器(请求) ; 从服务器发送到浏览器(响应);
5.2 请求:一次请求必定有一次响应,
请求体: 就是post提交方式提交的参数,get方式提交没有请求体!!
5.3 响应: *响应行:(200 响应成功)(404 资源不存在)(302 重定向)(304 查找本地缓存)(500 服务器内部错误)
*响应头：键值对，一般一个key对应一个value,也有一个key对应多个value的
Last-Modified:与请求中的If-Modified-Since一次使用查找本地缓存
Content-Dispostion:文件下载的时候使用的一个头信息
Location: 重定向的跳转路径
Refresh: 定时刷新/定时跳转

6 [Servlet]: 就是一个运行在WEB服务器上的小程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
6.1 使用方法:1 写一个普通的javac类,实现servlet接口 2 去WEB-INF/web.xml中配置我们这个servlet

7 [使用SercletRequest接收参数]
String getParameter(String name) ----用于接收一个名称对应一个值的数据
String[] getParameterValues(String name) :---用于金额手一个名称对应多个值的数
据
* Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数
名称,Map的value是提交参数的值.
* Enumeration getParameterNames()---用于获取表单中提交的所有的参数的名称.

8 [解决Post提交中文乱码解决方式]:
请求乱码解决 :
get请求: String str = new String(request.getParameter("name").getBetys
("ISO-8859-1"),"UTF-8");
post:请求 request.setCharacterEncoding("utf-8");
响应乱码: response.setContentType("text/html;charset=utf-8");

作者: finfin12 时间: 2018-5-31 21:36
张育辉
Tomxat总结
一:目录结构
   bin tomcat的执行文件;
   conf tomcat的配置文件
   lib tomcat运行所需要的jar包
   logs tomcat运行的日志文件
   temp 产生的临时文件的存放路径
   wepapps  发布wep项目路径
   work 运行JSP时候,会编译成为servlet的代码存放路径

二:软件的架构
C/S 客服端和服务端的软件,都需要下载软件
B/S 浏览器端和服务器端的软件. 不需要安装到PC端,只需要有一个浏览器即可

三:http协议
1概述:是用来规定浏览器与服务器之前需要遵守的规则;是用于3w服务器传输超文本到本地浏览器的传送协议,
http是一个应用层协议,由请求和响应构成,是一个标准的客户端服务器模型,http是一个无状态的协议(同一个客户端这一次请求和上一次请求没有对应的关系);
默认端口号是80,可以省略不写,
2特点:基本的请求和响应的模型,
必须先有请求后有响应,请求和响应必须成对出现,
3协议的详解;
请求行-|
-|提交方式有很多,常用的get和post
-|两个区别:get提交的参数会显示到地址栏上,而post不显示
-|get有大小限制,而post没有大小限制;
-|get没有请求体,而post有请求体
请求头-|
-|都是键值对的形式显示的,一般一个key对应着一个值也有个别的一个key对应的多个值
-|User-Agent:代表浏览器的类型
-|Referer:代表网页的来源,-防盗链
-|if-Modified-since:通常与响应的头Last-Modified一起使用查找本地缓存

请求体-|
-|就是post提交方式的提交参数(注册的参数)
响应部分的状态码-|
-|200:成功
-|302:重定向
-|304:查找本地缓存
-|404:资源不存在
-|500:服务器内部错误
响应头-|
-|Last-Modified:与请求中的if-Modified-since一起使用查找本地缓存
-|Content-Dispostion:文件下载的使用的一个头信息
-|Location:重定向的跳转的路径
-|Refresh:定时刷新/定时跳转
响应体:显示浏览器的页面的内容.
servlet总结:
一:servlet就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
Servlet就是SUN公司提供的一个动态网页开发技术
用来处理从客户端浏览器发送的请求,并且可以对请求作出响应

作者: COLDER 时间: 2018-5-31 21:41
本帖最后由 COLDER 于 2018-10-18 19:16 编辑

Day13

今天的学习内容主要分为三部分:TomCat,Http,Servlet

TomCat
TomCat:由Apache(阿帕奇)组织研发,是免费的小型服务器软件,支持Servlet/JSP的开发规范.
服务器:硬件服务器和软件服务器;
硬件服务器:高配置的电脑.
软件服务器:在电脑上安装服务器软件.
软件服务器的架构:C/S(Client/Server,客户端/服务器端),B/S(Browser/Server,浏览器端/服务器端)
C/S和B/S的优缺点比较:
C/S架构,优点是软件展示效果酷炫,缺点是服务器端进行更新,客户端也要进行更新,较繁琐.
B/S架构,优点是只需要服务器端进行更新,浏览器端无序更新;缺点展示特效较差.
注意:对WEB资源中的动态资源的定义不是指图片或文字等的动态,而是指服务器端和浏览器端的数据进行请求和响应.
[发布一个Web项目到TomCat]
[为什么?] 我的理解是:因为将Web项目发布到TomCat上,就可以让别人使用你的IP地址来访问你的Web项目,也就是说你设计的Web项目可以
通过TomCat服务器来共享给别人,好比是未使用TomCat之前你玩的是单机游戏,使用TomCat之后你玩的单机游戏可以联网了.
[怎么做?] 首先安装TomCat,然后配置JAVA_HOME环境变量,将TomCat的运行环境添加到Eclipse中,在Servers中创建TomCat服务器.

Http
Http协议:用来规定浏览器端和服务器端的规则,作用是规范浏览器端和服务器端的数据传递.其包含请求和响应,特点为一次请求必定
会有一次响应,必须先有请求后有响应.其默认端口号为80.
Http协议的请求部分包含:请求行,请求头(User-Agent,Referer,If-Modified-Since),请求体(Post提交的参数)
请求行中提交方式有get和post方式,两者的区别get提交的参数会在浏览器地址栏上显示,post提交不会显示,get提交在内存
上有大小限制,post提交没有,get没有请求体,post有请求体
Http协议的响应部分包含:响应行,响应头(Last-Modified,Content-Dispostion,Location,Refresh),响应体
状态码:200(成功),302(重定向),304(查找本地资源),404(资源不存在),500(服务器内部错误)

Servlet
Servlet:运行在Web服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用Http协议.
使用Servlet:编写类来实现Servlet接口,并重写其方法,然后将类配置到TomCat服务器中.
使用Servlet来接收浏览器端表单传输的数据的方法有:
String getParameter(String name):接收单个name所对应的值
String[] getParameterValues(String name):接收单个name所对应的多个值
Map getParameterMap():接收所有的值

作者: 六道的骸6 时间: 2018-5-31 21:42
软件的架构
C/S架构的软件
Client/Server客户端和服务端的软件.都是需要在PC端安装的软件
优点:效果好,速度快(一部分代码写到了客户端)
缺点:服务器端更新,客户端都需要更新
B/S架构的软件
Browser/Server 浏览器端和服务器端的软件.无需安装只需浏览器即可
优点:服务器更新,客户端无需更新
缺点:效果一般,所有的代码运行都在服务器端,导致服务器压力过大
效果:HTML5,CSS3可以做出比较好的效果
服务器压力: 可以搭建服务器的集群而且还有AJAX技术服务器端的压力越来越少
WEB的资源
静态资源:
HTML,CSS,JS,图片
动态资源:
PHP,ASP,Servlet/JSP
服务器
硬件:配置很高的电脑
软件:必须在电脑上安装服务器软件,才可以成为WEB服务器
常见的服务器
Apche: 发布PHP
IIS: 发布ASP
WebSphere: IBM公司研发,收费大型服务器软件,支持EE的所有的开发规范
WebLogic: BEA公司研发,收费大型服务器软件,支持EE的所有的开发规范
Tomcat: Apache研发,免费小型服务器软件,支持Servlet/JSP的开发规范
JBoss:
WEB动态资源的目录结构
website
静态资源
WEB-INF
web.xml 必须的
classes(可有可无) 存放编译后的class文件
lib(可有可无)

TomCat的目录结构
bin:执行文件
conf:配置文件!!!
lib:运行需要的jar包
logs:运行的日志文件
temp:临时文件存放目录
webapps:web项目的路径!!!
work:运行JSP的时候,JSP被翻译成Servlet的代码存放的路径

WEB攻城发布到Tomcat的三种方法
1 直接将工程copy到Tomcat/webapps下
2 设置tomcat的虚拟路径(不推荐)
在tomcat/conf/server.xml文件中进行配置
<Host>标签下配置
<Context path="虚拟路径" docBase="真实路径"/>
</Host>
3 虚拟路径(官方推荐)
在tomcat/conf/Catalina/localhost/xxx.xml
配置<Context docBase="真实路径"/>
xxx作为虚拟路径的名称

STS发布WEB工程
Eclipse中创建WEB项目 html等文件写在WebContent下

Tomcat常见问题
1 没有配置JAVA_HOME环境变量
2 端口号冲突 1:将占用端口的应用结束(netstat -ano) 2:修改自身应用端口号(server.xml修改)

HTTP协议(超文本传输协议  )
协议:规定双方需要遵守的规则
HTTP协议:
用来规定浏览器与服务器之间需要遵守的规则
作用:
规范数据之间的传递
特点:
基于请求和响应的模型
必须先有请求后有响应必须成对出现
默认端口号是80
协议版本:
1.0:每次响应后即刻关闭了连接
1.1:现在使用.不是每次响应后挂断,等待很长时间后没有请求会挂断

HTTP抓包 httpwatchpro(安装后在IE工具类中)

HTTP协议的详解
请求部分
请求行
提交方式:提交方式有很多常用的是GET和POST
区别:GET提交参数会显示到地址栏并且有大小限制
         POST提交参数不会显示到地址栏,无大小限制
         GET没有请求体
提交路径
协议版本
请求头
一般都是key,value键值对的形式,一般情况下是一个key对应一个value,有时对应多个
(需要记)
User-Agent: 代表浏览器类型(主要解决乱码问题)
Referer: 代表网页来源---防盗链
IF-Modified-Since: 通常与响应中的头Last-Modified一起使用查找本地缓存
空行
请求体:POST提交方式提交的参数

响应部分
响应行
协议版本
状态码:
200(成功)
302(重定向)
304(查找本地缓存)
404(访问资源不存在)
500(服务器内部错误)
状态码描述
响应头:一般都是key,value键值对的形式,一般情况下是一个key对应一个value,有时对应多个
Last-Modified: 与请求中的IF-Modified-Since一起使用查找本地缓存
Content-Dispostion: 文件下载的时候使用的一个头信息
Location: 重定向的跳转路径
Refresh: 定时刷新/跳转
空行
响应体:显示到浏览器页面的内容

Servlet
概述
运行在WEB服务器上的小Java程序(接口),用来接收和响应从客户端发送过来的请求,通常使用HTTP协议
(动态网页开发技术)
作用
用来处理从客户端浏览器发送的请求,并对请求作出响应
使用
1 编写类实现Servlet接口
2 在web.xml文件中配置Servlet
name名称
class全路径

mapping映射
name名称
pattern访问路径

使用ServletRequest接收参数
String getParameter(String name); ---用于接收一个名称对应一个值的数据.
String[] getParameterValues(String name); ---用于接收一个名称对应多个值的数据.(复选框)
Map getParameterMap(); ---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
Enumeration getParameterNames() ---用于获取表单中提交的所有的参数的名称.(枚举基本不用)
执行流程
地址栏→xml配置文件→类→操作

用户提交测试
1 XML配置属性设置类的全类名
2 创建HTML文件添加表单 action为项目名/配置文件的虚拟路径名
3 在实现类中接收数据并打印

作者: 厦门黑马王子 时间: 2018-5-31 21:52
郑雪平

今天学习了tomcat, http协议和  servlet三大块内容.一开始先了解软件的架构,可分为两种:一.CB架构;二.sb架构.两者各有优缺点,第一种的优点是效果比较炫酷,速度比较快,缺点是需下载客户端,服务器端有更新客户端也需要跟着更新;第二种的优点是软件都安装在服务器端,只需安装一次,且维护方便,缺点是效果比较不酷炫,服务器端压力比较大,速度比较慢.
  tomcat主要学习怎么发布一个web项目到服务器的方式,共有三种:
   一、复制项目到webapps文件夹下.
   二、修改server.xml,配置<Context path=”” docBase=””/>
   三、在conf/Catalina/localhost/xxx.xml 配置<Context docBase=””/>
学习Http协议我们知道了它是一种超文本传输协议,是规范浏览器和服务器之间需要遵守的规则,它还分为请求和响应两种模式,先请求后才是响应,两者一定会成对出现,国际惯例默认的端口号是80端口;请求提交的方式主要使用的是GET和POST,两者的区别是post有请求体get没有,get的有大小限制post没有限制;响应部分响应行常见的状态码有200,302,304,404,500.
其代表的含义是:200-->响应成功,302-->重复定向,304-->查找本地缓存,404-->访问的资源不存在,500-->服务器内部错误.
servlet就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
Servlet的作用：
用来处理从客户端浏览器发送过来的请求,并且可以对请求作出响应

作者: Do1 时间: 2018-5-31 21:54
本帖最后由 Do1 于 2019-11-23 00:37 编辑

HTTP是一种超文本传输协议主要是用来规范不同浏览器不同服务器之间的数据传输,在浏览器内输入服务器的连接地址,后台就会显示请求和响应的协议演示,HTTP主要记住5种响应码200成功302重定向304查找本地缓存404资源不存在以及500服务器内部错误

浏览器与服务器之间的响应请求,有点类似于JAVA中的网络编程,底层有可能用的是UDP或者TCP加上I/O流来传输数据.

浏览器本质上是一个软件通过解析html语句来实现页面的显示,在浏览器输入框中输入想访问的地址后,浏览器内部会调用Socket套接字去向指定的IP地址指定端口,这个服务器端口必须是打开的也就是Tomcat服务器等等类似服务器,发送一个HTTP规范的访问请求,这个请求会是一个字节数组解析后的字符串长串上面有想访问的网页文件名等等一系列参数,java中的服务器收到这个字符长串后开始解析(解析的过程可能是首先判断用户发送过来的路径,然后服务器先去xml文件查找这个路径,如果有Servlet小程序的话一并加载),如果说解析到想要访问的文件名那么会将这个网页文件的内容复制加上一些参数使用HTTP的规范进行传输,通过I/O流发送给浏览器软件, 浏览器内部解析后会将超文本标记语言放到浏览器软件内进行解析显示给用户,再把其它内容显示到其它的位置 ,没查找到的话就发送给浏览器一个没找到的响应,HTTP报404错误

前面提到xml内的Servlet小程序被加载,当用户按下表单的提交按钮后,action内写了指定的文件名,服务器去找xml内对应的文件名,找到Servlet实现类所在的位置,这个Servlet实现类开启监听端口接受用户的请求,请求内容同样是将它再浏览器内的表单数据以字节数组的形式发送过来,内部通过I/O流进行解析后做出的响应,可以是发送给用户信息,或者打印在控制台上或者进行其它操作,比如连接数据库进行判断等非常方便.

表单校验程序的配置: 写一个类实现Servlet接口,实现service方法传入的参数有两个
                              ServletRequest req    接收
                              String  req.getParameter(String k);  k:表单元素指定名
                              Map<String,String[]>  req.getgetParameterMap(); 获取所有数据返回一个map集合

                              ServletResponse res 发送
                              res.getWriter().println(String a); 浏览器内写入a,并切换页面

我们使用时主要注意web文件的配置,以及字节数组解析之后的乱码问题.

作者: 名字被人注册了 时间: 2018-5-31 21:56
刘文峰
Tomcat是一个支持servlet/jsp的小型服务器.我们有三种方式可以将一个web工程发布到tomcat中:第一是直接将工程复制到tomcat安装路径下的webapps文件夹里;第二种是通过配置tomcat文件夹/conf/server.xml文件,在xml文件里的host标签下写一个标签 <Context path="/访问页面输入的路径" docBase="工程所在路径"/>;第三种是配置tomcat/conf/catalina/XXXX.xml文件,文件名为访问页面输入的路径,文件夹里同样写一个标签<Context docBase="工程所在路径"/>.

http协议是一个超文本传输协议,用于规范浏览器和服务器间的数据传输.http是基于请求和响应的模型,每一个请求都有一个响应,而且请求和响应必需是成对出现的.
请求的内容分为请求行,请求头,请求体(响应类似);请求行里有提交方式(get,post),提交路径和http协议版本号(现在使用1.1);get的提交方式会将参数显示在提交路径后面,比较不安全.请求头则是http协议规范数据的传递;请求体里写的是提交的参数(get方式提交没有请求体).
响应的内容同样分为三个部分:响应行里有协议版本,状态码和状态描述,
不同的状态码代表不同的意思:
200  成功
302    重定向
304  查找本地缓存
404  找不到指定文件(路径有错或文件不存在)
500  服务器内部错误(java代码有错)
响应头作用和请求体一样;响应体就是文件的代码;

Servlet用来接收客服端或浏览器发过来的请求并响应.我们可以创建一个类实现servlet接口并配置到服务器中,只要开启服务器就可以接收请求.如果要接收一个表单发过来的请求,我们可以将表单的提交路径(action属性)指向实现了servlet的类;重写接口里面的service(ServletRequest req, ServletResponse res)方法可以接收和响应请求.

作者: 一梦 时间: 2018-5-31 21:59
陈世彪:
今天学习了Tomcat与Servlet入门
Tomcat是Apache组织研发的小型服务器
发布一个web工程有三种方法
1.直接将工程copy到tomcat/webapps下.
2.tomcat/conf/server.xml文件中进行配置:
3.tomcat/conf/Catalina/localhost/xxx.xml
在web.xml中
<servlet>
  <servlet-name>ServletDemo2</servlet-name>
  <servlet-class>ServletDemo2</servlet-class>这是.java的全类名
  </servlet>
  <servlet-mapping>
  <servlet-name>ServletDemo2</servlet-name>需要和第一个<servlet-name>的名字一模一样
  <url-pattern>/ServletDemo2</url-pattern>名字是页面调用时的名字
  </servlet-mapping>

网页中的提交方法常用的是get和post
GET的提交的参数会显示到地址栏上,而POST不显示.
GET往往是有大小限制的,而POST没有大小的限制.
GET没有请求体,而POST有请求体.

页面响应的方法有
res.getWriter().print()
如果中文乱码
res.setContentType("text/html;charset=utf-8");

在使用ServletRequest接收参数时
常用的方法有
String getParameter(String name);---用于接收一个名称对应一个值的数据.
直接用System.out.println()就可以打印获得
String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
直接用System.out.println(Arrays.toString())就可以打印获得
Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
需要使用增强for获取他的所有键,然后键找值,再使用(Arrays.toString())就可以打印获得

作者: 滴滴eclipse启动 时间: 2018-5-31 22:00
江某人:
需要先把Tomcat放入eclipse
了解HTTP协议，几种常见的状态码:
THHP是超文本传输协议,是互联网上应用最为广泛的一种网络协议.所有的www文件都需要遵守这个协议
HTTP协议的作用：规范浏览器和服务器之间的数据传递.
 HTTP协议的特点
基于请求和响应的模型.
必须先有请求后有响应.
请求和响应必须成对出现.
默认的端口号是80.
 HTTP协议的版本:
1.0 :每次响应后即刻关闭了连接.
1.1 :现在使用.不是每次响应后挂断,等待长时间以后没有请求会挂断.
 请求部分
请求行:
       提交方式:
      提交方式有很多,常用的GET和POST:
      GET和POST的区别:
      GET的提交的参数会显示到地址栏上,而POST不显示.
         GET往往是有大小限制的,而POST没有大小的限制.
         GET没有请求体,而POST有请求体.
   请求头
都是键值对的形式显示的.一般一个key对应一个value,也有个别的是一个key对应多个value.
   User-Agent :代表浏览器的类型. --- 文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
   Referer :代表的是网页的来源. --- 防盗链.
   If-Modified-Since :通常与响应中的头Last-Modified一起使用查找本地缓存.
请求体
就是POST提交方式的提交的参数.
 响应部分
响应行:
   协议版本
   状态码：
      200 ：成功
      302 ：重定向
      304 ：查找本地缓存
      404 ：资源不存在
      500 ：服务器内部错误
状态码描述
响应头：键值对,一般一个key对应一个value,也有一个key对应多个value.
   Last-Modified:与请求中的If-Modified-Since一起使用查找本地缓存.
   Content-Dispostion :文件下载的使用使用的一个头信息.
   Location:重定向的跳转的路径.
   Refresh:定时刷新/定时跳转.

什么是Servlet:
  就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
  Servlet就是SUN公司提供的一个动态网页开发技术.
 Servlet的作用：
  用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
 使用Servlet：
  编写一个类实现Servlet接口.
  将编写的这个类配置到服务器中.
String getParameter(String name);---用于接收一个名称对应一个值的数据.
String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
Map getParameterMap();---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.

作者: 厦门陈强 时间: 2018-5-31 22:01
陈强
TomCat和Servlet的一天.
首先是通过TomCat去发布一个web项目.我们采用的是直接将项目复制到TomCat安装目录下的webapps路径下即可,然后根据localhost:端口号/项目名/HTML文件即可.发布一个项目的前提是,要在eclipse中去集成TomCat,只有集成成功后,服务器可以正常启动了,该在webapps目录下的项目才可以发布成功.
第二部是servlet的请求与响应.使用Servlet的基本步骤就是第一,编写一个类去实现Servlet接口,第二是将编写的这个类配置到服务器中即可.这里要注意导入Servlet包,并添加源代码的步骤.
首先在编写类的部分,实现Servlet接口的时候重写里面全部的方法,而我们要使用到的是service方法,在方法里面在根据是请求还是响应,去进行响应方法的调用.
然后配置方面,主要是根据以下的格式进行编写.
  <servlet>
   <servlet-name>xxxxx</servlet-name>
    
    <servlet-class>类对应的CLASS路径</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>xxxxx</servlet-name>
    
    <url-pattern>/xxxxx</url-pattern>
  </servlet-mapping>
这里编写的过程中要注意, <url-pattern>标签中最前面的/千万不能少,否则报错!!!
做了一个简单的响应的测试,就是在service中通过getWriter方法去输出一个语句,然后将该类配置到服务器中,配置完成后去访问<url-pattern>中的内容.
总结一下这个过程就是服务器通过<url-pattern>标签去找<servlet-mapping>标签中的<servlet-name>,然后该标签再去找到<servlet>标签中的<servlet-name>,最后在找到<servlet>中的<servlet-class>,这样子就找到了对应的类,然后将内容响应.
表单请求部分,其实都是一个道理.创建一个表单的HTML,表单的action提交路径应为项目路径/<url-pattern>的值,method我们一般设置为post,然后创建一个类去实现Servlet接口,在service方法中去获取表单中的一些信息.使用到的是paremeter等一系列的方法.都配置成功之后,就可以运行Tomcat服务器,然后去表单的HTML填写表单内的信息提交,服务器就会收到表单的请求信息了.
整个流程就是<form action="/项目名/url标签" method="post">------<url-pattern>----<servlet-mapping>中的<servlet-name>----<servlet>中的<servlet-name>----<servlet-class>-----java文件
获取整个表单信息的MAP集合方法还没敲,先把总结交了再好好敲~~~

作者: 小故事 时间: 2018-5-31 22:01
谢洪彬:
Tomcat 与 Servlet

Tomcat :是一个服务器,而且是免费的,他可以让我们做的网页放在服务器上,然后在网页上进行访问.
Tomcat 是用于对JAVA的操作.
Tomcat 分两类
1.BS  : 客户端和服务器
2.CS : 浏览器和服务器
项目发布到服务器的方式有三种:
1.直接拷贝到Tomcat 文件下Webapps文件下
2.对server配置文件进行修改(这里面涉及到一个path 和docBase  虚拟路径的配置)
3.在Tomcat 文件下localhost文件下自定义XML配置文件,文件名就相当于项目名(docBase  虚拟路径的配置);
Tomcat 一般都是在java程序中进行操作,但是前提需要把jia包配置好.

Servlet 是一个java接口,可以理解为服务器中用于响应的java程序
操作步奏:
1.定义一个类去实现Servlet 接口,并实现其中的抽象方法
2.对Web.XML文件进行配置
重写Servlet 接口中主要又以Servlet ()方法去实现请求和响应的功能

在进行请求把表单提交时提交时的数据打印在控制台是需要注意一下几点:
1.表单提交的路径为: /项目名称/  (Web.XML中标签为<url-pattern>的自定义元素 )
2.根据Servlet 标签中相同的name值,找到标签带有class中的值(里面存放的是全类名)找到对应的类
3.请求到的数据如果是中文需要根据是请求还是响应进行设置字符集

今天还学习了http
http是一种约束浏览器和服务器的
有一请求必有一响应
其中请求常用的分为Get和Post
Get和Post的区别:
1.Get没有方法体,而Post有方法体
2.Get有大小限制,而Post没有
3.Get数据显示在地址栏,而Post不显示

错误信息: 200 --- 成功
      302 ---重定向
304 ---加载缓存
404    ---没有找到资源(一般是路径不对)
500    ---服务器异常(一般是代码写错了)

作者: w849027724 时间: 2018-5-31 22:01
吴利君
今天学习了tmocat和简单的Servlet，可以进行简单的前后端交互，可以做一个简单的网页，可以说，今天是web学习的开始，今后编程都是这样，通过前端传递数据，然后后端进行数据接收，处理，然后交给前端进行显示给用户，中间如果你要实现特殊功能只要相应功能的工具类，jar包，然后进行代码实现就行。
首先，今天讲了HTTP这个协议，这个是一个很强大的数据传输协议，目前很多网站都是使用它进行数据传输，不过HTTP也存在安全问题，所以有它衍生的HTTPS会更加安全，HTTPS是进行SSL加密的HTTP，服务器通过数字证书进行身份认证，然后进行数据传输，很安全。
HTTP抓包有两种，get和post它最大的区别就是数据传输规则，一个是在响应行，一个是在响应体，然后是get传输有大小限制，毕竟get是通过响应行传输数据的。还有的时候它们解决乱码的方式也不一样，个人推荐是用post，安全，而且看着舒服。
HTTP的状态码有404,302,304等等，很强大，通过这个可以很清晰的知道自己的错误的大致情况，debug的时候很方便。
然后是Servlet，它是运行在服务器上面的小程序，主要用于接收浏览器传来的数据，然后给后台进行数据处理，然后在把数据放进request域或者session域等等，这样前端就获取数据进行显示。
它的使用也很简单，主要是前端路径写Servlet的xml里面的url然后通过servlet-class就能找到对应的Servlet，这样就Servlet就拿到数据，然后就可以在service层处理，然后dao层与数据库交互，这样就完成了特定功能，然后返回显示给前端。

作者: 李志勇 时间: 2018-5-31 22:02
李志勇:
Tomcat:
这个就没说的就是解压直接配置一下文件然后在servers窗口添加个服务器就可以使用的;
http协议 :
?规范浏览器和服务器之间的数据传递.
Servlet:
就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议
使用Servlet：
编写一个类实现Servlet接口.
将编写的这个类配置到服务器中.
现学是在实现Servlet接口中的public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {}这个方法请求端数据获得可以用以下方法ServletRequest req:
String getParameter(String name); ---用于接收一个名称对应一个值的数据.
String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
Map getParameterMap(); ---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value 是提交参数的值.
响应端ServletResponse res来响应

作者: Eclipse启动 时间: 2018-5-31 22:02
郑阳阳
几种常见的状态码:
200:成功
302:重定向
304:查找缓存
404:资源不存在,地址可能有误
500:服务器内部错误,可能是java代码有问题
从前台表单提交数据到后台Servlet，Servlet对请求的数据进行处理，再将结果响应给前台:
1:创建一个普通类实现Servlet,在service方法中编写代码,有两个参数ServletRequest和ServletResponse.
ServletRequest是请求,可以调用方法getParameter获取表单提交的数据返回字符串,
多个数据用getParameterValues返回字符串数组,getParameterMap可以接收所有提交的数据key为参数名,value为参数值
ServletResponse是响应,可以用getWriter在用print方法给浏览器返回数据.
2:配置web.xml文件
如果请求接收的数据为中文会出现乱码解决方法为:
请求乱码解决 : get请求: String str = new String(request.getParameter("name").getBetys("ISO-8859-1"),"UTF-8");
post: request.setCharacterEncoding("utf-8");
响应乱码:response.setContentType("text/html;charset=utf-8");

作者: chenyelong 时间: 2018-5-31 22:02
陈叶隆
1. http协议:
1.1 请求头: i)User-Agent :代表浏览器的类型. --- 文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
ii)  Referer :代表的是网页的来源. --- 防盗链.
iii) If-Modified-Since :通常与响应中的头Last-Modified一起使用查找本地缓存
1.2 响应行状态码:  200--成功
      302--重定向
        304--查找本地缓存
         404--资源不存在
500--服务器内部错误
1.3 响应头: i)Last-Modified :与请求中的If-Modified-Since一起使用查找本地缓存.
ii)Content-Dispostion :文件下载的使用使用的一个头信息.
iii)Location s:重定向的跳转的路径.
iv) Refresh :定时刷新/定时跳转.

2. servlet:
2.1 编写一个类Servlet:
[步骤一: 编写一个类 implements  Servlet接口]
public class Servlet1 implements Servlet{
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
res.getWriter().println("Hello Servlet...");
}
}
[步骤二:配置Servlet]
  <servlet>
   <servlet-name>test1</servlet-name>
   <servlet-class>com.itheima.a_servlet.Servlet1</servlet-class>
  </servlet>

  <servlet-mapping>
    <servlet-name>test1</servlet-name>
    <url-pattern>/ServletDemo1</url-pattern>
  </servlet-mapping>

2.2 获取servlet请求中的数据:
public class Servlet2 implements Servlet{
@Override
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
req.setCharacterEncoding("UTF-8");
String name = req.getParameter("name");
int age  = Integer.parseInt(req.getParameter("age"));
String[] hobbys = req.getParameterValues("hobby");
System.out.println(name);
System.out.println(age);
System.out.println(Arrays.toString(hobbys));

Map<String,String[]> map = req.getParameterMap();
// System.out.println(map);
for (String key : map.keySet()) {
String[] value = map.get(key);
System.out.println(key+"  "+Arrays.toString(value));
}
}

作者: q55w66 时间: 2018-5-31 22:03

服务器：
配置：软件(如Tomcat）+硬件(如高配电脑)
架构：C/S——客户端+服务器，端游 B/S——浏览器+服务器，页游

HTTP协议：
默认端口:80
基于请求和响应的模型，响应和请求必须成对存在

Tomcat：布置服务器的软件

Servlet：用来接收和响应从客户端发送过来的请求

作者: 沅瞻 时间: 2018-5-31 22:03
詹源
今天学习了前台表单提交数据到后台服务器.以及HTTP协议.

软件架构分为C/S,B/S.
C/S需要安装到PC,优点是B格高,代码写到客户端(速度快),缺点是服务器更新,下载的客户端也全部要更新.

B/S不需要安装,只需要有浏览器就可以.优点是服务器更新,客户端浏览器不需要更新,缺点是没B格.

什么是服务器:
硬件:高配置的电脑
软件:在电脑上安装服务器软件,这台电脑称为WEB服务器.

重点:前台表单提交数据给后台服务器,服务器处理数据后,进行响应.

HTTP协议:
HTTP是浏览器与服务器之间,数据传输必须遵循的一套规则

作用:规范数据传递

特点:基于请求与响应
   先有请求后有响应
   请求与响应成对出现.
   默认端口号 80

常见状态码:
200 成功
302 重定向
304 查找本地缓存
404 资源不存在
500 服务器内部错误

作者: LittleSky 时间: 2018-5-31 22:03
常小天
今天开始正式学习web阶段的重点内容。今天的学习内容是使用Tomcat发布工程以及编写servlet程序接收浏览器请求并做出响应。
使用Eclipse新建服务器，并将新建的工程添加进Tomcat服务器的操作这里就不说了，按部就班的来就可以，没啥好说的。这里重点说一说servlet的编写。Servlet是运行在服务器上的java程序。功能是接收客户端的请求并作出响应，遵循的是HTTP协议。HTTP规范了网络上客户端与服务器之间数据传输的格式，这使得现在网络上多种服务器多种客户端都能够顺利传输数据得以实现。要使用servlet，首先要编写一个java类实现Servlet接口，重写Service方法。Service方法要传入两个参数，ServletRequest和ServletResponse。前者将请求封装成了对象，有相应的方法去获得从客户端传入的数据；后者能将响应封装成对象，有相应的方法向客户端输出数据。具体的方法可查API。接下来的步骤同样很关键。我们要将写好的java类配置到我们的服务器中。配置的方法是在工程的web-INF目录下的web.xml文件中编写<servlet>标签和<servlet-mapping>标签，前者将我们写好的java类的类名与一个<servlet name>联系起来，后者将一个我们自行编写的虚拟路径与<servlet name>联系起来，前后两个<servlet name>的内容一致，以此将虚拟路径与java类连接起来，使得客户端可以通过虚拟路径调用java类程序。在此基础上，我们进一步将HTML页面也连接进来。在HTML文件中的表单提交路径中写入配置文件中的虚拟路径，便可以实现登录、注册等操作。

作者: 张述明 时间: 2018-5-31 23:31
张述明
今天学习的主要内容是servlet和Tomcat,http

Http:是浏览器和服务器之间的规范
基于请求和响应的模式
请求:浏览器向服务器发送数据
响应:服务器向浏览器传递数据

协议的详情
请求部分
请求头:键值对的形式
User-Agent:  代表浏览器的类型---
Referer :  代表的是网页的来源—作用 :防盗链
If-modified-since: 通常与响应的头Last-modified一起使用查找本地缓存

提交方式有get和post
二者的区别  get文件有大小限制,post没有
         get没有请求体i,post有请求体
         get提交的参数显示在地址栏,post不显示

请求体  是post 提交方式的提交参数

响应部分:协议版本
状态码 200 成功 302  重定向  304 查找本地缓存  404 资源不存在 500 服务器内部错误
   Last-modified  :与请求中If-modified-since一起使用查找本地缓存
   Content-dispostion :文件下载的使用的一个头信息
   Location :重定向的跳转的路径
   Referer :定时刷新/定时跳转
响应体:显示浏览器的页面的内容

Servlet :接受和响应从客户端发送过来的数据
Servlet使用:
1.写一个java类实现Servlet接口
2.编写web.xml配置文件

接收数据
rep.getParameter()用于接收一个名称对应一个值的数据
rep.getParameterValues() 用于接收一个名称对应多个值的数据
map.getparameterMap()  接收表单中的所有的数据  map的key是表单提交的参数名,称,map的value是提交参数的值.

Tomcat
c/s架构的软件客户端和服务器端
b/s  浏览器和服务器端的软件

作者: 追风筝的人哇 时间: 2018-5-31 23:40
康元中(5.31)
1服务器: 硬件服务器和软件服务器

Tomcat :
软件的架构
c/s架构的软件
  Client /Server 客户端和服务器软件,
  优点:
  缺点:
b/c 架构软件

学习tomcat 这个服务器
1项目发布到tomcat这个服务器上流程和注意点
项目存发布的路径是在webapps文件夹中,有三种方式发布项目
使用localhost:8080 浏览器登录,因为tomcat这个服务器占用8080这个端口号
一个服务器只能占用一个端口号
注意: WebContent 其实是和Day13 这个项目一样(同级)的只不过是将这个项目发布到WebContent
    WebContent 下如果是已index.html开头访问时可以这样写  访问地址:端口号/项目名Day13
诺不是index.html 则要写具体的html文件  这样写  访问地址:端口号/项目名Day13/demo.html
诺具体文件存在一个文件夹中且则应具体到该文件所在路径这样写端口号/项目名Day13/文件夹名/文件名
2使用servlet完成用户登录的案例
(1)servlet是运行在web服务器上的java程序,用接收和响应从客户端发来的请求
(2)使用Servlet：编写一个类实现Servlet接口. 将编写的这个类配置到服务器中.
      http协议的概念超文本传输协议/协议作用是规范浏览器和服务器的数据传输
http协议的特点:先请求后相应/一次请求必有一次响应/
请求:浏览器向服务器发数据
响应:服务器向浏览器写数据
      现在使用hhtp协议版本1.1
http协议抓包方式分为 GET  和POST
      记住: 提交方式很多常用get 和post
      get没有请求体.post有且提交的是参数
      GET的提交的参数会显示到地址栏上,而POST不显示.
         GET往往是有大小限制的,而POST没有大小的限制.
   ***请求头
      User-Agent代表浏览器的类型.文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
Referer :代表网页的来源
      f-Modified-since :通常与响应头Last-Modified一起查找本地缓存

   ** 响应行协议版本状态码状态码的描述
状态码: 202 成功
302 重定向
304查找本地缓存
404 资源不存在(查看路径是否正确)
500 服务器内部错误(一般会给代码提示)
响应头: key和value的形式对应(一对多/一对一)
      Content-Dispostion :文件下载的使用使用的一个头信息.
      Location :重定向的跳转的路径.
      Refresh:定时刷新/定时跳转

作者: AsusCoder 时间: 2018-6-1 03:59
一、Tomcat
1.使用Tomcat7.0：在8.0以后的版本，对编码作了优化，较少出现乱码问题。使用7.0是为了学习如何处理乱码问题。
2.解压即可使用。首先要设置环境变量JAVA_HOME.不然会出现Tomcat启动一闪而过，导致开启失败。
startup.bat:启动服务器
shutdown.bat:停止服务器
3.Tomcat载入Eclipse开发环境:
  Windows->Prepferences->Server->Runtime Environments
  显示Tomcat窗口栏:Window->showView->Servers;
4.项目加入Tomcat。Servers窗口中，对Tomcat7.0右键->add and remove...
当运行tomcat出现错误时，先移除项目，再运行。如果还是有错，是tomcat的错误。没有错，是项目的错误
5.tomcat解决乱码方式:
1)请求乱码:
  post请求:request.setCharacterEncoding("utf-8");
2)响应乱码：
  response.setContentType("text/html;charset=utf-8");
6.端口冲突问题:
1)将占用端口的应用结束:
  cmd->netstat -ano 查看进程所使用的端口
2)修改自身应用的端口号:
  修改tomcat/conf/server.xml中的端口号

HTTP协议:
1.协议规定了不同浏览器和不同软件服务器统一所要遵循的规则，规范浏览器和服务器之间的数据传递。
2.每次请求必须要得到回应，请求错误也会回应。1.1版本的协议增加了请求超时会挂断协议。
3.HTTP协议的内容形式:
1)使用高级浏览器(Goole,FireFox)抓包:
FireFox，按F12->网络选项卡->跳转到新的页面，会显示请求的协议;
2)协议内容:
(1)GET方式:
请求行:请求方式请求路径协议版本
请求头:请求头一般都是key.value键值对的形式，一般情况下一个key对应一个value.也有一些是一个key对应多个value
(2)POST方式:多了一个请求体

(3)响应部分:

响应头:键值对，一般一个key对应一个value,也有一个key对应多个value;
*Last-Modefied: 与请求中的IF-Modified-Since 一起使用查找本地缓存。
*Content-Dispistion:文件下载的使用的一个头信息
*Location       :重定向的跳转的路径
*Refresh          :定时刷新/定时跳转
*响应体:显示到浏览器页面的内容

Servlet部分:
1.概念理解:
Servlet只是一个运行在WEB服务器上的小的java程序，用来接收和响应从客户端发过来的请求，通常使用HTTP协议。
2.在web方面使用Servlet的具体步骤:
1).新建一个普通java类，实现Servlet接口，载入所有接口方法。把server()方法放到前面。
2).新建一个Servlet，良好的习惯是先到web.xml中配置servlet。理解一下web.xml运行原理就知道怎么配置了:
web.xml是web项目的核心配置。一旦写错，项目就无法运行。web.xml作为前端和后台服务器的中间件。或者说,作为form表单与Servlet联系的中间件。
当一个form表单做出提交的请求后，首先是转发到web.xml中，通过表单的action里面提供的servlet虚拟路径名,与<servlet-mapping>标签的设置的虚拟路径匹配，然后找到servlet-name相同的
得到servlet的路径。进而再把表单交给servlet处理。
因此，配置方式如下:
(1)在<web-app></web-app>之间加入<servlet ></servlet>和映射标签<servlet-mapping></servlet-mapping>。注意，两个是并列关系，不是包含
(2)在<servlet-mapping>标签中，添加两个标签:
<servlet-name>mytest</servlet-name>:名字随便取，但是要和<servlet>标签中的<servlet-name>标签名字一样。
<url-pattern>/aa</url-parttern>:虚拟路径名，随便取，但是要和前端form表单的action里面设置的虚拟路径名一样。
(3)在<servlet ></servlet>标签中。设置两个值
<servlet-name>mytest</servlet-name>:与<servlet-mapping>标签中的<servlet-name>名字一样。
<servlet-class>Servlet类所在的包路径名
(4)form表单中action属性写虚拟路径名的两个写法:
绝对路径名:/day0531/aa
相对路径名:aa
这两个写法都可以，推荐用绝对路径名。
3.request获取请求参数的常用方法：
注意，返回的都是String类型的数据,string->int:Integer.parseToInt()
String getParameter(String name):通过表单名字获取参数
String[] getParameterValues(String name); 通过表单名字获取多个值:比如下拉框，多选框
Map<String,String> getParameterMap():以【name:value】的键值对应封装在map集合。
Enumeration getParamterNames();用于获取所有的表单组件名字。

作者: 1748341437 时间: 2018-6-1 22:01
2018/5/29 林玮

今天学了一个Tomcat和servlet,还了解了http协议.

Tomcat是一个服务器,而服务器又有分很多种,主要分两大块,收费的和免费的,我们现在主要是用免费的,毕竟收费的我们又用不起.
今天还有一个重点就是xml,xml就是类似于hxml的一个可扩展标记语言,可以用来传输和储存数据,但这只是以前的用法现在虽然还有公司用但也已经很少了,现在主要用于配置文件.
还了解了一个http协议,它呢是一个超文本传输协议,主要用于规定浏览器与服务器之前需要遵守的规则.以前由于没有这个协议,导致各种浏览器与各种服务器的传输非常混乱,有了它就可以非常好的规范传输,所以说这是一项很伟大的发明.
就说到这吧,之前写了的没保存,有点心态崩,现在都有点忘了.

作者: 郑学馨 时间: 2018-6-1 22:26
郑学馨
tomcat是什么:tomcat是一种web服务器,它供Java开发者学习和

开发javaweb,
tomcat的有优点:支持全部jsp及servlet规范,技术先进,性能强

大
什么是web服务器:

什么是XML:可以与HTML进行比较学习
XML HTML
Extensible Markup Language  Hyper Text Merkup Language
中文名:可扩展标记型语言    超文本标记型语言
区别: 可以自定义标签          标签都是固定的
用途:显示数据,存储数据(主要) 显示数据

XML应用:A.不同的系统之间传输数据

*qq之间的数据传输

B.用来表示生活中有关系的数据

C.经常用在文件配置

*修改数据库的信息，不用修改源代码，修改配置文件

就可以
c/s:就是要下载软件安装包,每次更新都要重新下载安装包,优点

,响应较快,界面优化好
b/s:通过网页访问服务器,获取我们想要的资源,响应较慢
什么是http协议:是一种格式约束
什么是请求:通过客户端发送的数据信息,
什么是响应:服务器接收到客户端发送的信息,根据信息返回客户

想要的数据给客户
什么是servlet:是一个运用在web服务器上的小Java程序,

作者: Nevermo 时间: 2018-6-1 23:25
许煜
每日总结
Tomvat
  Java语言用于发布网站的服务器开源免费底层是使用java语言写的
发布方式 1 将web项目copy到tomcat/webapps下面
2 配置虚拟路径 tomcat/conf/server,xml文件配置
3 配置虚拟路径 tomcat/conf/catalina/localhost 创建xml文件进行配置conten.docbase
Servlet
http 协议 :浏览器和服务器共同遵守的协议
         基于请求和相应模型
Tomcat发布网站
配置tomcat环境 runtime
Servelet配置 <servlet-name>自定义
            <servlet-class>全类名
            <servlet-mapping>映射
            <servlet-name>与上面所自定义名字相同
      <url-pattern>访问路径
Servlet类 request 用post提交的请求体对象
      response 响应就是服务器通过response实现对网页的改变

作者: it小白001 时间: 2018-6-1 23:27
吴俊斌
HTTP协议的特点端口默认80,它是浏览器和服务器之间的一种规则,一个请求必有一个响应

提交方式有两种:get和post
  他们的区别是get会在地址栏显示,而且有大小限制,而post没有,也不会显示
  响应部分 200响应成功
         302重定向
         304查找本地缓存
         404访问资源不存在
         500服务器内部错误

Servlet:
  1.运行在Tomcat上的java程序,我们通常使用getparamter()获得一个参数,用getParameterValues()
获得所有参数里的内容,获得getParametermap()获得所有内容.

作者: 丶犯二 时间: 2018-6-2 00:57
@Override //ServletRequest req:请求的对象 ServletResponse res:响应的对象
public void service(ServletRequest req, ServletResponse res)
throws ServletException, IOException {
// TODO Auto-generated method stub
//setCharacterEncoding("编码字符集"):设置请求的编码字符集
req.setCharacterEncoding("utf-8");

//setContentType("???<这个参数不知道是啥玩意>,编码字符集"):设置响应的字符集和格式
res.setContentType("text/html;charset=UTF-8");

//getParameter(name属性):获取请求的参数
String parameter = req.getParameter("everything");

//将获取的参数打印在控制台上
System.out.println(parameter);

//将回响内容显示于网页
res.getWriter().println("持续五个月的慢性死亡");
}
昨天晚上的,不对前天晚上的最后十分钟真是激情澎湃,辉哥又让代码进化成完全体了,没现在这么烦杂.虽然我忘得差不多了额...

作者: ...ylq 时间: 2018-6-2 01:23
叶凌青
WEB服务器
硬件:其实就是一台配置很高的电脑.
软件:必须在一台电脑上安装服务器软件.这台电脑称为是WEB服务器.
Tomcat :Apache组织研发,免费的小型的服务器软件,支持Servlet/JSP的开发规范.
Client / Server 客户端和服务器端的软件. 都是需要在PC端安装的软件. 比如 QQ,迅雷,暴风...
优点:效果炫,一部分代码写到客户端(速度快).
缺点:服务器端更新,客户端都需要更新.

Browser / Server 浏览器端和服务器端的软件. 不需要安装到PC端,只需要有一个浏览器即可. 比如京东,网银,WEBQQ,WEB迅雷...
优点:服务器端更新,客户端浏览器不需要进行更新.
缺点:效果不炫,所有的代码运行都在服务器端,导致服务器压力过大.
效果：使用HTML5,CSS3可以做出很炫效果.
服务器端压力:搭建服务器的集群.而且还有AJAX技术.

website
|-----静态资源
|-----WEB-INF
|-----web.xml :必须的
|-----classes :可选的
|-----lib :可选的

Servlet的概述
就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
独立编写一个Servlet:
Servlet的作用:用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
编写一个类 implements Servlet接口.
将编写的这个类配置到服务器中.

作者: wahahaha 时间: 2018-6-2 08:45
林恒山
http协议:
这是一套规范浏览器和服务器之间数据传递的规则.
特点:
基于请求和响应的模型.也就是必须先请求后响应,请求和响应必须成对出现.默认的端口号是80.
http协议请求有三部分组成:
请求行:
1.提交方式,分为get和post请求.
get和post区别:a:get提交会在地址栏显示,post提交则是在请求体里面;b:get提交有大小限制,post提交没有大小限制;c:get没有请求体,post有请求体.
2.提交路径.
3协议版本,通常是1.1

请求头:键值对显示,一般情况下都是一个key对应一个value,也有个别的一个key对应多个value
User-Agent:浏览器类型
Referer:网页来源,防盗链
If-modified-Since:通常与响应中的Last-modified一起查找本地缓存.

请求体:get没有请求体,post提交参数的地方.

响应也是三部分:
响应行:
1:协议版本
2:状态码: 200成功 302重定向 304查找本地缓存 404资源不存在 500服务器内部错误
3状态码描述

响应头:键值对显示,一般情况下都是一个key对应一个value,也有个别的一个key对应多个value
Last-Modified:与请求中的If-modified-Since一起查找本地缓存
Content-Disposition:文件下载使用
Location:重定向跳转的路径
Refresh:刷新.

响应体:显示在浏览器的页面内容

Servlet:
编写一个类实现Servlet接口,并将这个类配置到web.xml

String getParameter(String name);接收浏览器name参数对应的值
String[] getParameterValues(String name);接收浏览器name参数对应的多个值
Map getParameterMap();可以接收上面2种方法的值

作者: 望蜀 时间: 2018-6-2 19:20
邵倩

C/S架构的软件: client/server 客户端和服务器端的软件,都是需要安装在PC端的软件 QQ 迅雷...
优缺点
B/S架构的软件: ......只要有一个浏览器即可
优缺点

服务器
软件服务器: 必须在一台电脑上安装服务器软件,这台电脑才能被称为web服务器  Apache IIS websphere  tomcat等
硬件服务器: 一台配置很高的电脑

web动态资源目录结构
导包直接导在WEB-INF下的lib里并且不用再build path
下载tomcat并安装
了解tomcat的目录结构
发布一个web项目到tomcat
推荐直接将项目copy到tomcat/webapps下: 把项目copy过来

使用tomcat集成eclipse

用servlet完成用户登录的案例

HTTP协议: 超文本传输协议服务器浏览器都有很多种
请求: 浏览器向服务器发送数据
响应: 服务器向浏览器传递数据
一次请求必定有一次响应
作用: 约束浏览器和服务器之间传输数据的格式
特点: 先有请求后有响应,请求和响应必须成对出现
版本: 现在使用的是1.1.不是每次响应后挂断,而是很长时间没有请求,才会挂断

http的请求部分:
请求行:
   1.提交方式:
      GET提交提交的参数会显示到地址栏上有大小限制没有请求体
      POST提交提交的参数不显示到地址栏, 没有大小限制,有请求体

   2.提交路径
   3.协议版本
请求头: 键值对形式显示,一般一个key对应一个value
请求体: 就是post提交方式提交的参数

响应部分:
响应行:
   1.协议版本
   2.状态码:
   200  成功
   302 重定向
   304 查找本地缓存
   404 资源不存在
   500 服务器内部出错 java代码出错
   3.状态码描述
响应头: 键值对,一般一个key对应一个value
响应体: 显示浏览器的页面内容

servlet 运行在web服务器的一个小的java类,用来接收和响应从客户端发送过来的请求,通常用HTTP协议
servlet是sun提供的动态网页开发技术
使用: 1.编写一个类实现servlet接口  导包  service方法 2.把它配置到服务器中(WEB-INF/web,xml)

作者: 5119 时间: 2018-6-2 21:31
游荣辉
总结
今天学了Tomcat这个东西就是可以把java代码在浏览器中打开,首先你要安装这个东西,然后配置一下环境就可以在Java ee中使用了
还学习了http协议:他是超文本传输协议,就是浏览器和服务器都要遵守这个协议,
现在使用的http的版本都是1.1版本
浏览器向服务器传输文件叫做请求
请求行(提交方式,提交路径,协议版本)
请求头(是以Map的形式出现的,一般都是一个key对应一个value,偶尔有一个key对应多个value)
请求体(get没有请求体,post有)
服务器向浏览器传输文件叫做响应
响应行(协议版本,状态码,状态描述)
   状态码有:200(正常) 302(重定向)    304(查找本地缓存) 404(找不到资源)  500(服务器内部错误)
响应头(是以Map的形式出现的,一般都是一个key对应一个value,偶尔有一个key对应多个value)
响应体(显示浏览器页面的内容)

还有servlet
servlet就是一个服务器上的小Java程序.
可以用来处理浏览器发出的请求,相应的做出响应
想要使用servler就必须实现servler接口,然后再配置到服务器中

配置的时候再web.xml下配置


  <servlet>
    
    <servlet-name>test1</servlet-name>
    
    <servlet-class>com.itheima.a_servlet.ServletDemo1</servlet-class>
  </servlet>

  
  <servlet-mapping>
    
    <servlet-name>test1</servlet-name>
    
    <url-pattern>/ServletDemo1</url-pattern>
  </servlet-mapping>

想要再Java中收到浏览器传输出来的数据就必须使用
.getparameter(String name) 接收一个名称对应一个值的数据.
.getparameterMap()接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
.getparameterValues()用于接收一个名称对应多个值的数据.

作者: 376091692 时间: 2018-6-4 17:28
凌辉:
学习了Tmocat服务器,用来存储数据,和浏览器互联访问用的;
http协议:
1.1 请求头: i)User-Agent :代表浏览器的类型. --- 文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
Referer :代表的是网页的来源. --- 防盗链.
Referer :代表的是网页的来源. --- 防盗链.
1.2 响应行状态码:  200--成功
                                    302--重定向
                              304--查找本地缓存
                              404--资源不存在
500--服务器内部错误
Servlet的作用:用来处理从客户端浏览器发送的请求,并且可以对请求作出响应

作者: avip0000 时间: 2018-6-4 17:53
白有旺
掌握在eclipse配置Tomcat服务器
Servlet连接请求和响应

要熟悉客户端到服务器的的流程关系

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2