黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】Servlet [打印本页]
作者: 厦门校区 时间: 2018-6-2 12:40
标题: 【厦门JavaEE就业1期-每日总结】Servlet
同学们，今天我们就正式学习Servlet的使用了，今天需要掌握的就是如下三个案例，通过敲案例掌握重要知识点。
今日需要掌握的有：
- 通过登录案例，掌握基本的Servlet的使用，从前台接收数据，处理数据，并将结果响应给前台
- 通过设置时间跳转页面案例，掌握如何设置响应头信息
- 通过记录网站登录成功案例，掌握一个重要对象ServletContext的使用，重点掌握存取数据API和生命周期
- 处理乱码问题：请求乱码（get/post），响应乱码
请同学们按照如上要求，总结今日所学。
作者: Yanmo_ 时间: 2018-6-2 19:54
颜琳琳:
今日学习了Servlet的生命周期:Servlet的生命周期是在用户第一次访问servlet后创建servlet实例,然后调用innt方法,然后每执行一次就调用一次service方法,最后在服务器正常关闭和在服务器中移除项目时servlet实例会被销毁,那么destroy方法就被执行了.(注:若要让innt在页面加载时就执行,那么就要在web.xml中进配置servlet在<Servlet-class>标签下使用<load-on-startup>2</load-on-startup> 传入一个正整数,然后传入的整数越小,被创建的优先级就越高)
通过登录案例学习了:浏览器向服务器数据,使用getParameter方法服务器来接收出来的参数,之后将其封装到一个实体类中,最后将其发送会给浏览器.
通过定时跳转的页面学习到了响应头的信息中的Refresh直接定时跳转,使用setHeader()方法来实现,直接获取的格式如下 : setHeader(“Refresh”,”跳转的时间;url=”跳转的绝对路径”);
通过重定向来实现: 先获取重定向的编码: 获取的方法setStatus(302), 之后在使用setHeader(“Location”,”相对路径”),然后创建要跳转的html页面,在此页面中编写代码其中要注意要编写一个<meta http-equiv="Refresh" content="跳转的时间;url=跳转的绝对路径"/>
最后通过学习了域对象SetvletContext其中的获取数据的作用来获取数据,ServletContext中的方法有setAttribute()设置数据,getAttribute()获取数据,removeAttribute()移除数据.
请求乱码解决 :
get:
Stringstr=newString(request.getParameter("name").getBetys("ISO-8859-1"),"UTF-8");
post:
request.setCharacterEncoding("utf-8");
响应乱码: response.setContentType("text/html;charset=utf-8");
作者: conan75 时间: 2018-6-2 20:19
今天对动态页面设计Servlet(HttpServlet)进行了进一步的学习,,这里比较重要的是Servlet的生命周期:通常情况下,Servlet是在第一个用户第一次访问页面时,服务器内部自动创建Servlet对象,并调用其中的init方法,而后用户的每一次请求(包括第一次请求)都会导致Servlet对象调用service方法(根据请求方式的不同调用不同的doXXX方法),最后随着服务器的关闭,或者项目的移除,Servlet对象会调用destroy方法进行销毁
在页面跳转中,主要有两个方法:
1.刷新跳转:该方法中主要涉及到响应头参数的设置问题,通过响应对象调用sethandler()方法,里面参数是Refresh
2.重定向,重定向方法首先得先对状态码进行设置setStatus,然后通过响应对象调用sethandler()方法,里面参数是Location,也有试了用sendRedirect方法,也能实现该功能,就是不知道这两种方法的区别
最后是对域对象ServletContext,它的生命周期较为简单,就是在服务器启动时,服务器会为每一个项目都创建一个ServletContext对象,项目中的每一个类都可以获得该对象(也就是说它的作用域是所在的项目),在服务器关闭时或者项目移除销毁.重开服务器后,值会恢复初始状态......
作者: 六道的骸6 时间: 2018-6-2 21:08
本帖最后由 六道的骸6 于 2018-6-3 10:05 编辑
张裕
Servlet
Servlet的实现关系
Servlet:接口 → GenericServlet: 通用的Servlet → HttpServlet: Http的Servlet
用户登录操作顺序
1 创建User表
2 创建User实体类
3 在WEB_INF的lib文件夹里 导包 c3p0,mysql,DButils
4 创建UserDao,UserServlce,UserServlet, html页面
5 接收数据→处理业务→查询数据库→返回查询结果到用户
Servlet的生命周期
(重点)
生命周期:一个对象从创建到销毁的过程
Servlet生命周期:从创建到销毁的过程
创建时间: 客户第一次访问Servlet时创建Servlet实例(只创建一次)
销毁时间: 当项目从服务器中移除的时候,或者关闭服务器的时候
用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例
那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法
在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost)
当Servlet从服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行
Servlet的相关配置
1 在服务器启动时自动创建Servlet,在web.xml中的<servlet></servlet>标签中配置:
<load-on-startup>?</load-on-startup> --- 传入正整数(从2开始,1已经被占用),整数越小,被创建的优先级就越高.
2 Url-patten的配置(三种方式)
1.完全路径匹配 ：以 / 开始 例如:/ServletDemo4
2.目录匹配 ：以 / 开始 需要以 * 结束. 例如: /* /aaa/*
3.扩展名匹配 ：不能以 / 开始 以 * 开始的. 例如: *.do *.action
!!!错误的写法 ： /*.do
匹配优先级: 完全路径匹配 > 目录匹配 > 扩展名匹配
开发中的路径编写
相对路径: 需要找位置的相对关系 不能以 / 开始 ../
绝对路径: 不需要找位置的相对关系 可以以 / 开始
写法1(带协议) http://IP地址:端口号/项目名/虚拟路径名
写法2 /项目名/虚拟路径名
绝对路径中分为客户端路径和服务器端路径
客户端路径一定要加项目名
服务器端路径不需要加项目名
五秒跳转
使用Http协议中的Refresh头信息来进行页面跳转
response中设置响应头
addHeader(String name,String value); --- 针对一个key对应多个value的响应头.(一个key有多个value)
addDateHeader(String name,long date);
addIntHeader(String name,int value);
setHeader(String name,String value);(重点) --- 针对一个key对应一个value的响应头.(一个key只有一个value 后面的会覆盖前面的)
setDateHeader(String name,long date);
setIntHeader(String name,int value);
使用JS控制读秒的效果
1 setStatus 设置重定向状态码
2 setHeader 设置头 "Location","路径" 跳转到HTML页面
3 在HTML中设置meta标签 定义5秒跳转
4 设置读秒效果
记录登录人数
ServletContext对象: 用来存储数据, 存的数据在范围内有作用,称为域对象
setAttribute 存储数据
getAttribute 获取数据
removeAttribute 移除数据
操作步骤
1 初始化记录次数变量 存入到ServletCOntext
2 登录成功后 次数+1
3 跳转到另一个类 获取登录成功次数
ServletConfig:获得Servlet的配置信息(了解)
String getServletName(); ---获得Servlet在web.xml中配置的name的值
String getInitParameter(String name); ---获得Servlet的初始化参数的
Enumeration getInitParameterNames(); ---获得所有Servlet的初始化参数的名称
ServletContext(重点):是一个域对象
作用范围:整个web工程
创建:服务器启动的时候,tomcat服务器为每个web项目创建一个单独ServletContext对象
销毁:服务器关闭的时候,或者项目从服务器中移除的时候
作用:
1.用来获得全局初始化参数
2.用来获得文件的MIME的类型
3.作为域对象存取数据
4.用来读取web项目下的文件
作者: Eclipse启动 时间: 2018-6-2 21:28
本帖最后由 Eclipse启动 于 2018-6-3 09:35 编辑
郑阳阳
设置响应头信息:
使用响应对象调用setHeader方法传入两参数,第一个参数为响应头的Key,第二个参数是修改完的参数,
能把原本的参数替换掉,定时跳转setHeader("Refresh","需要多少秒跳转;url=/项目名/配置文件上url的参数").
ServletContext的使用:
ServletContext是一个域对象,可以作用于整个项目.
设置全局函数,重写init方法,调用getAsyncContext()获取AsyncContext对象调用
setAttribute存储数据,getAttribute是取出数据,removeAttribute是删除数据
Servlet的生命周期:
第一次访问会创建Servlet,创建的时候会调用init方法,访问调用service方法,项目被移除出服务器或正常关闭服务器会调用destroy方法
重复访问不会重复创建Servlet对象,只会重复调用service方法.
处理乱码:
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");
作者: 磬辰 时间: 2018-6-2 21:31
林文辉
三层架构：
1.主要分为Dao(数据)层，Service(业务逻辑)层，web(界面)层。
2.把各个模块分开主要是为了降低耦合度。每个模块自己做自己的事
3.主要是一个思想，高内聚低耦合。这样的好处有很多，比如你有需求变化之类的
，你只需在在对应的层里修改就行了，就不需要把整个项目改一遍。
用户登录功能实现：
1.表单form action属性中写入要跳转到的Servlet
2.request.getParameter()获取表单中的参数。
3.将参数封装到实体类中，调用业务层，业务层调用数据层，通过DBUtils查询数据
库中的数据，并返回一个实体类
4.如果为空，返回登录失败，否则返回登录成功，通过response.getWirter().println()返回。
Servlet的生命周期：
1.第一次访问Servlet时，服务器就会创建一个Servlet实例，Init方法就会被调用。
2.重复访问也只会重复执行Service方法。不会重复的创建Servlet实例。
3.在Service中根据不同的请求方式，会调用不同的doxx方法。
4.Serlvet在服务器中被移除，或者关闭服务器时，Servlet实例就会被销毁，destroy方法就会执行
Servlet的配置方式：
1.完全路径匹配， 如/demo1,/aaa/bbb
2.目录匹配 如/* /aaa/bb*
3.扩展名匹配： 如*.do或者*.jsp
匹配优先级：完全路径匹配>目录匹配>扩展名匹配
实现5秒跳转案例：
1.可以通过Refresh实现定时跳转，通过设置程序头信息。
response.setHeader("Refresh", "5;url=/jsp/index.html");
2.可以通过js实现读秒跳转效果
response.setHeader("Location", request.getContextPath()+"/jsp/success.jsp");
在success.jsp中
<meta http-equiv="Refresh" content="5;url=${ pageContext.request.contextPath }/jsp/index.jsp">
再通过js
var time=5;
window.onload=function(){
setInterval(function(){
time--;
document.getElementById("s1").innerHTML=time;
},1000);
}
记录网站登录成功的人数：
1.在init()方法中初始化count=0,再存入setAttribute().域中
2.每次向Servlet发出请求时，Servlet里就读取一次getAttribute(),返回到客户端，再
将count++存入Servlet中
作者: 5119 时间: 2018-6-2 21:33
游荣辉
总结
今天学习了Servlet:
Servlet的生命周期(就是Servlet从创建到销毁的过程):用户第一次访问的时候,服务器会创建一个Servlet的实例,然后init的方法就会
执行,每一次访问服务器Servlet中的service就会执行一次,当服务器关闭时或者Servlet从服务器中移除是就会调用Servlet中的destroy方法消除
Servlet默认是在第一次访问的时候创建的.现在让Servlet在服务器启动的时候创建好.进行对Servlet的配置:
在web.xml中在<servlet></servlet>标签中配置:
<load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高.
现在已经不使用实现Servlet,而是继承他的实现类HttpSevlet,因为实现一个接口就要重写他的所有方法,而继承只要重写你想要的方法就可以了
ServletContex(域对象)的作用
1.用来获得全局初始化参数.
2.用来获得文件的MIME的类型.
*3.作为域对象存取数据.(他的作用范围是整个web项目,服务器启动的时候就会创建一个域对象,他会随着服务器的关闭或者项目的移除而销毁)
*4.用来读取web项目下的文件.(现在不知道)
作者: finfin12 时间: 2018-6-2 21:34
张育辉
servlet总结:
一:servlet就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
Servlet就是SUN公司提供的一个动态网页开发技术
用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
二:生命周期是一个对象从创建到销毁的过程
原理:用户第一次访问servlet时候,服务会创建一个servlet实例,那么servlet中的init()方法会执行;
任何一次请求服务器都会创建一个新的线程去访问servlet()的方法,当servlet服务器中移除掉或者关闭掉
那么servlet的实例就会被销毁掉,destroy()方法就会执行;
三:ServletContext对象
1,什么是ServletContext对象
存数据的区域就是域对象,
ServletContext代表是一个web应用的环境（上下文）对象，ServletContext对象
内部封装是该web应用的信息，ServletContext对象一个web应用只有一个(一个项目只有一个域对象,所有的类共享)
2,servlrtContext生命周期是项目发布启动的时候创建,项目移除或服务器关闭销毁
域对象的通用的方法：
setAtrribute(String name,Object obj);设置
getAttribute(String name);获取
removeAttribute(String name);移除
作者: Do1 时间: 2018-6-2 21:39
本帖最后由 Do1 于 2019-10-14 03:00 编辑
今天学习了使用HttpServlet获取表单数据,实现客户端访问远程MySql并由服务器返回结果的过程,还有一个新的概念叫做ServletContext域对象,这个对象可以用来获得全局初始化参数或者用来获得文件的MIME的类型,还有Servlet的生命周期,为了不防止过分的浪费资源所以只有在用户访问的时候才会去开线程调用service方法,当Servlet被移除掉或者关闭服务器的时候实例就会销毁,销毁调用destroy方法
servlet配置引入了一个新的概念,就是方法的优先级 <load-on-startup>2</load-on-startup>,其中的数字代表优先级.
作者: 偏离X 时间: 2018-6-2 21:42
郭明杰
继承HttpServlet 比实现Servlet 的好处是不需要重写其他没有用到的方法
用户登录操作顺序
1 创建User表 并存入数据
2 创建User实体类
3 导包 c3p0,mysql,DButils(WEB_INF-->lib)
4 创建UserDao,UserServlce,UserServlet等页面
5 接收数据→处理业务→查询数据库→返回查询结果到用户
Servlet的生命周期
客户第一次访问Servlet时创建Servlet实例(只创建一次),执行Servlet中的init
方法
任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法
当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么
destroy方法就会执行.
* <load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级
就越高.
url-pattern配置方式共有三种:
1.完全路径匹配 ：以 / 开始 例如: /ServletDemo4
, /aaa/ServletDemo5 , /aaa/bbb/ServletDemo6
2.目录匹配 ：以 / 开始 需要以 * 结束. 例如: /* ,/aaa/*
,/aaa/bbb/*
3.扩展名匹配 ：不能以 / 开始 以 * 开始的. 例如: *.do , *.action
使用Http协议中的Refresh头信息可以实现页面的跳转
作者: 渣.. 时间: 2018-6-2 21:45
柯威龙
今天学习了servlet,主要学习了网站后台实现的案例.在学习案例中有学习了如何跳转.一种是使用响应
的Refresh方法直接在代码中实现,另一种是使用重定向,需要在代码中和html中做准备.案例把之前所学
的部分知识点融合.然后还学习了生命周期.生命周期就是从创建到销毁.servlet,的销毁也就是当项目移除
或者正常关闭服务器.servlet是单例,生命周期有三种方法,init()是客户默认第一次访问,destory是当服务器
关闭或者项目移除时启用.
作者: 李志勇 时间: 2018-6-2 21:45
李志勇:
Servlet:
就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议
登入页面流程:
创建包和类-----引入jar包----引入login页面-----编写Servlett->Service->Dao
Servlet的生命周期:
Servlet默认是在第一次访问的时候创建的.现在让Servlet在服务器启动的时候创建好.进行对Servlet的配置:
在web.xml中在<servlet></servlet>标签中配置:
<load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高.1是被默认占有;
response中设置响应头:
Refresh在响应头中是用来设置定时页面跳转;
--- 针对一个key对应一个value的响应头.
setHeader(String name,String value);
setDateHeader(String name,long date);
setIntHeader(String name,int value);
ServletContext:
这种对象称为域对象 可以用来存取数据 ;
this.getServletContext().setAttribute("count", count);获得域对象并把数据存入其中;
this.getServletContext().getAttribute("count");获得域对象并把数据取出;
作者: wpwing 时间: 2018-6-2 21:48
吴鹏
总结
----------------------------------
一 通过登录案例，掌握基本的Servlet的使用，从前台接收数据，处理数据，并将结果响应给前台
三层架构要掌握,即界面层,业务层,数据访问层,还有实体类,用来封装从表单获得的数据;
界面层用来接收表单的数据,以及调用业务层的方法对请求做出响应;
业务层创建方法,用来联系界面层和数据访问层;
数据访问层只与数据库打交道,增删改查;
将数据封装成实体类发生在界面层,实体类的创建要根据使用的表格的字段;
接收数据是,使用request.getParameter(String name)方法,参数为表格中需要获得的值的name属性值;
将数据接收完毕后,通过创建实体类,使用set方法,将数据封装成一个实体类对象;
创捷业务层对象,调用业务层的方法,此方法传入参数为封装好的实体类对象,然后,我们到业务层,创建数据访问层对象,将
数据访问层和界面层通过业务层创建的方法联系起来,中间传递的参数为封装好的实体类,业务层创建好的方法是有返回值的;
通过方法传递,最终将封装好的对象传入数据访问层,在数据访问层中,使用QueryRunner核心类,根据实际需求,编写sql语句,返回
与数据库操作过的对象;
返回后会直接返回到界面层中(因为方法传递时候,全部都是有返回值),根据实际需求,判断传过来的对象,将结果响应到浏览器;
----------------------------------
二 通过设置时间跳转页面案例，掌握如何设置响应头信息
response.setStatus();此方法为设置响应头的状态,
response.setHeader();此方法为设置对应响应头状态的响应头内容
如我们要设置登陆成功后跳转,可以设置响应头状态为302,对应的key值为"Refresh";代码如下:
response.setStatus(302);
response.setHeader("Location","要跳转的地址");也可以:
response.set("Refresh","要跳转的地址");
在上面中,在要跳转的地址前面用分号隔开,填入数字,可以实现经过一定时间(数字,单位秒)后,再跳转;
---------------------------------
三 通过记录网站登录成功案例，掌握一个重要对象ServletContext的使用，重点掌握存取数据API和生命周期
生命周期:
与生命周期相关的方法:init(),service(),destory()
首先,当客户端第一次发送请求到服务器时,会创建一个Servlet,并且,当有init()方法时,会调用init()方法进行全局变量的初始化;
此后,每当发送一次请求时,都会调用一次service()方法进行响应;而当服务器停止或者项目移除时,会调用destory()方法,将Servlet
销毁,由Java的垃圾回收回收掉释放的资源;
ServletContext:是一个域对象,作用范围是整个项目,当项目被加载时,即会创建该域对象,项目被移除或服务器关闭时,被销毁;
该域对象可通过方法进行赋值和取值:
常用的方法:
getAttribute(String name);
从ServletContext中获取指定name属性值的数据,获取的都是Object类型,有需要是要强转;
setAttribute(String name,Object object);
向ServletContext中存入指定name属性值的数据;
removeAttribute(String name);
向ServletContext中移除指定name属性值的数据;
------------------------------------
四 处理乱码问题：请求乱码（get/post），响应乱码
请求乱码解决办法:
在doGet或doPost的方法内第一行写入
request.setCharacterEncoding("UTF-8");
响应乱码解决办法:
在doGet或doPost的方法内第一行写入
response.setContentType("text/html;charset=UTF-8");
含义是,将响应中的文本内容当作html内容来识别,字符编码设置为UTF-8
作者: 光宇 时间: 2018-6-2 21:53
侯玉林
今天讲了servlet .登录页面验证,隔5秒页面跳转,登录人数记录
作者: 滴滴eclipse启动 时间: 2018-6-2 21:55
江某人:
先有数据库User表 根据表来创建实体类
User:实体类
UserDao:操作数据库,对User的所有操作都写在这里
UserService:业务层,每个方法都是一个业务
UserServlet:(1)接收数据(2)调用Service处理业务(3)完成跳转
Servlet:用来接收和响应从客户端发送过来的请求,通常使用HTTP协议
登入页面流程:创建包和类-----引入jar包----引入login页面-----编写Servlet->Service->Dao
Servlet的生命周期:l 用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
response中设置响应头:
Refresh在响应头中是用来设置定时页面跳转;
--- 针对一个key对应一个value的响应头.
暂时只用到:setIntHeader(String name,int value);
ServletContext:
这种对象称为域对象 可以用来存取数据 ;
this.getServletContext().setAttribute("count", count);获得域对象并把数据存入其中;
this.getServletContext().getAttribute("count");获得域对象并把数据取出;
作者: 厦门黑马王子 时间: 2018-6-2 21:56
郑雪平
今天主要都是在学习如何使用Servlet完成用户登录的案例.首先第一步要创建数据库和表文件;接下来第二步是创建包和类,并分别让类实现Servlet 接口,编写一个类来继承HttpServlet;第三步是引入相对应的JAR包,总共是需要引入三个,分别为:1.mysql数据库驱动包;2.c3p0连接池的jar包;3.dbutils的包;第四步是引入之前写好的相应的页面;第五步是写一个DAO类.还有关于一个对象的生命周期,就是一个对象从创建到销毁的过程.在编写代码中关于路径的编写可分为两种,一种是相对路径,另一种是绝对路径.
作者: 许大炮 时间: 2018-6-2 21:57
许剑鸿 webDay14
继续深入学习Servlet
Servlet的生命周期(面试常用的问题): init service destory
* 生命周期:就是一个对象从创建到销毁的过程.
* Servlet生命周期:Servlet从创建到销毁的过程.
* 何时创建:用户第一次访问Servlet创建Servlet的实例
* 何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
通过登录并跳转页面掌握Servlet的使用
获取前台数据 : getParameter("name");getParameterValues();getParaMap();
后台响应:response.getWriter().print() 将信息打印至页面上
跳转:通过设置响应头跳转一定时间后跳转页面 response.setHeader("Refresh","5;url=/........")
设置重定向直接跳转页面 response.setStatus(302) response.setHeader("Location","/.......")
request.setCharacterEncoding("UTF-8");从前台获取数据得到乱码解决方法
response.setContentType("text/html;charset=UTF-8");从后台向前台响应出乱码解决方法
ServletContext:ServletContext是一个域对象.
* 作用范围:整个web工程.
* 创建:服务器启动的时候,tomcat服务器为每个web项目创建一个单独ServletContext对象.
* 销毁:服务器关闭的时候,或者项目从服务器中移除的时候.
作用:
* 1.用来获得全局初始化参数.
* 2.用来获得文件的MIME的类型.
* 3.作为域对象存取数据.(今日掌握)
* 4.用来读取web项目下的文件.
作者: doudou0606 时间: 2018-6-2 21:57
施炎生
一，Servlet生命周期:Servlet从创建到销毁的过程.
1. 何时创建:用户第一次访问Servlet创建Servlet的实例
2.何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
二，网站登录写法
1.创建数据库中的User表
2.创建User实体类
3.导包：C3P0,mysql-connection,DBUtils
4.创建UserDao,UserService,UserServlet,HTML页面
5.UserServlet:接收数据--调用service处理业务--判断是否存在这个user
调用UserDao完成：select * from user where username=? and password=?
得到一个数据库中查询到的User对象，返回给UserServlet。
三，ServletContext是一个域对象.
1.作用：作为域对象存取数据；用来读取web项目下的文件。
2.作用范围:整个web工程.
3. 创建:服务器启动的时候,tomcat服务器为每个web项目创建一个单独ServletContext对象.
4. 销毁:服务器关闭的时候,或者项目从服务器中移除的时候.
四，网站登录Bug解决方法：
1.the import cannot be resolved ：先移除再重新导jar包（右键项目->build path -> Config build path -> Libraries-> remove后，重新导入。）
2.点击登录页面不跳转，控制台报错：C3P0配置文件中表的路径url写错，创建的表不是在所写路径里。
作者: lnongge 时间: 2018-6-2 21:57
16weisong
今天主要学习了servlet的生命周期,servletContext对象和实现用户登录注册,统计网站访问人数,其中Servlet生命周期和ServletContext对象是重点,只需要实现最后一个案例就能掌握今天学的内容
作者: 一梦 时间: 2018-6-2 22:00
陈世彪:
今天学习了Servlet
登录案例中,要先创建数据库,再使用
request.getParameter("username")获取网页提交回来的信息
QueryRunner queryRunner=new QueryRunner();
获取数据库,用select查找数据库中是否有获取的信息
如果有就页面响应
response.getWriter().println("登录成功")
如果没有的话就页面响应
response.getWriter().println("登录失败")
通过时间设置跳转时,使用
setHreader("Refresh","时间;要跳转的页面的地址")
也可以使用response.setStatus(302);重定义
直接重定义跳转到需要显示的页面response.setHeader("Location","地址");
ServletContext中使用
this.getServletContext().getAttribute("count")获取数据
this.getServletContext().setAttribute("count"count)设置数据
对象ServletContext,它的项目类每个都可以获得他的对象,在服务器关闭和自动移除时会销毁
get:
Stringstr=newString(request.getParameter("name").getBetys("ISO-8859-1"),"UTF-8");
post:
request.setCharacterEncoding("utf-8");
响应乱码:
response.setContentType("text/html;charset=utf-8");
作者: 13163997058 时间: 2018-6-2 22:01
本帖最后由 13163997058 于 2018-6-3 09:58 编辑
王刘锁
先来说案例.用户登录成功后五秒跳转和在界面打印第几个登录的,本来想把这两个效果放在一
个界面,想了好久没想出来办法!这个五秒跳转的案例是用写一个html文件用js来完成的,而打印
登录人数是直接响应页面打印,两个不挨边,真是伤脑筋!这个问题用jsp可以完成!!,案例并不难,只要注意一些该修改和设
置的地方就可以了,首先我们先把中文乱码问题给解决了,一开始我就是响应的页面打印中文结
果是????,后来想起老师发过一个处理乱码的文档!这种响应的乱码问题的解决用响应response
来解决方法是response.setContentType("text/html;charset=utf-8");固定格式记住即可,然
后用请求对象request.getParameter("name属性值");来获取用户输入的信息并封装成一个User
类对象,把这个User对象传入UserDao中的login方法来用User对象的用户信息去数据库中查找记
录,返回的是一个新的User对象,然后我们再判断这个返回的User对象是否为null,不为null说明
查到了记录用户真实存在这时就可以做登录成功的操作,登录成功我们要响应一个页面,并在五
秒后跳转,response.sendRedirect("/web_02/Sucess.html");这个是响应的页面,在这个html文
件中我们要完成五秒倒计时跳转的功能,那我们要记住必须在<head>标签内定义一个新的标签
<meta http-equiv="Refresh" content="5,url=/web_02/index.html" />并且着个标签有着两
个属性Refresh响应头:5-该时间秒后跳转,url是要跳转到哪去,然后在<script>标签内定义一个
time=5,定义页面加载时间定时改变time,在改变time的方法里让time自减后写入显示time的
<span>标签.具体代码如下,因为忘的差不多了所以写出来记一下!!
<script type="text/javascript">
var time = 5;
window.onload = function() {
setInterval('changeTime()', 1000);
}
function changeTime() {
time--;
document.getElementById("s1").innerHTML = time
}
</script> 到这里这个案例基本完成了,当然最费脑的还是找bug了!关于统计登录成功人数的
只要记住Servlet的方法getServletContext()获取ServletContext对象后.再记住
setAttribute("count",count);和getAttribute("count");这两个方法基本就可以搞定!!
还有就是ServletContext的生命周期,它是在服务器启动的时候Tomcat为每一个项目单独创建的
一个域对象,所以它在整个项目有效并在服务器关闭或移除的时候销毁!!!
再来一些小知识点:
1,Servlet的生命周期:第一次去访问它的时候服务器会自动创建它的对象并执行其init方法,这
个动作只会做一次除非把服务器关闭或移除了才会销毁这时会执行destroy方法,也就是说无论
访问多少次Servlet都只在第一次访问执行上述动作,另外每一次访问都会执行其service方法在
该方法内根据请求方式调用不同doxxx方法,
2,设置响应头信息Refresh:addHeader和setHeader这里重点记set就可以.
setHeade(Stringname,Stringvalue);setDateHeader(String name,long date);
setIntHeader(String name,int value);这种是一个key对应一个value的头信息!!
作者: 1748341437 时间: 2018-6-2 22:01
2018/6/2 林玮
今天继续学习了Servlet,重点分为了两个:一,Servlet的生命周期.二ServletContext.
Servlet的生命周期是在以后的面试中也会出现的问题,然后Servlet的生命周期到底是多少呢?就是从它的创建到销毁的过程,就是它的生命周期,就跟人是一样的,从出生到死亡.那又是何时Servlet才被创建,何时被销毁的呢?它的创建是随着用户的访问,服务器会创建一个Servlet的,然后又随着用户的访问完毕而销毁的.
url-pattem的配置有三种:
1.完全路径匹配:/XXX/...(主要应用第一个)
2.目录匹配:/XXX/.../*
3.扩展名匹配:*.XXX
还有一个路径,对于路径的编写还是很有讲究的,相对路径不能以/开头,绝对路径呢又必须以/开头.(如果在路径中写./那就是当前目录../就是上一级目录)
还讲了一个response,在今天的案例中很多都用到了他,有两个个方法我们要区别一下,就是addHeader(X,X);他一个key可以对应多个value,还有就是setHeader(X,X);他就是我们平常用的一key一value,然后为什么说区别一下呢,因为我们以后是只有后者,不用前者的.所以平时在运用的时候不要弄混了.
最后就是ServletContext了,它是一个域对象,相当于在服务器中开辟了一个新的空间,是随着服务器的启动而创建,服务器的关闭而销毁的,可以用来储存数据,在要用的时候从这个空间中拿就好了,用一个东西来比喻的话那他就相当于一个百宝箱.
作者: chenyelong 时间: 2018-6-2 22:04
陈叶隆
A.一些知识点:
i)绝对路径中分为客户端路径和服务器端路径:
客户端路径一定要加工程名. /day09/ServletDemo6
服务器端路径不需要加工程名. /ServletDemo6
ii) ServletContext对象存取数据,存的数据都是有一定的作用范围的.这种对象称为是域对象
iii)在web.xml中在<servlet></servlet>标签中配置:
<load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高.
B.注意点:
1. 用户登录的案例中:
i).解决向页面输出中文的乱码问题
response.setContentType("text/html;charset=UTF-8");
ii).接收表单提交的参数.
String username = request.getParameter("username");
String password = request.getParameter("password");
iii).封装到实体对象中.
User user = new User();
user.setUsername(username);
user.setPassword(password);
iv).调用业务层处理数据.
UserService userService = new UserService();
User existUser = userService.login(user);
2.登陆成功,5秒后跳转页面的案例
i)response.setHeader("Refresh", "5;url=/day09/demo5-refresh/index.html");
ii)response.setStatus(302);
response.setHeader("Location", "/day09/demo5-refresh/success.html");
<meta http-equiv="Refresh" content="5;url=/day09/demo5-refresh/index.html"/>
3.记录网站登陆成功人数的案例
int count = (int) this.getServletContext().getAttribute("count");
count++;
this.getServletContext().setAttribute("count", count);
作者: 沅瞻 时间: 2018-6-2 22:05
詹源
Servlet是一个运行在WEB服务器上的小的JAVA程序.用来接收,响应客户端发送的请求
Servlet是SUN公司提供的动态网页开发技术
String getParameter(String name) 接收一个名称对应一个值的数据
String [] getParameterValues(String name) 接收一个名称对应多个值的数据
Map getParameteMap(). 接收表单所有数据,是表单提交的参数名称
Enumeration getParameterNames() 用于获取表单中提交的所有的参数名称
Servlet接收响应客户端请求的步骤
一 创建包和类
二 引入jar包
三 引入login页面
四 编写Servelt--Service--DAO
Servlet生命周期:
生命周期:就是一个对象从创建到销毁的过程.
Servlet生命周期:Servlet从创建到销毁的过程.
* 何时创建:用户第一次访问Servlet创建Servlet的实例
* 何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
作者: 张述明 时间: 2018-6-2 22:47
张述明
今天对sevlet 进行一步的学习,其中比较重要的是sevlet 的生命周期,sevletContext域对象,作用是整个项目
另一个是登入界面的理解 用户在登入界面进行操作,传入用户名和密码,在服务器的Servlet中接收数据,并封装成对象,调用UserService类中的login方法,userservice作为一个业务处理层,相当于一个中间站,userService在调用SERvletDao中的login方法,接收到userservice的数据的Servletdao解决数据库的增删该查的操作,再见对象返回给userService,在返回给servlet,在作出响应
下面是今天的主要的知识点
Servlet 的实现的关系
Servlet-接口
|
GenericServlet
|
HttpSverlet
编写一个类继承HttpServlet,重写doget和doPost方法
配置
1.数据库和表
先有数据库User表-根据表来创建实体类
User 实体类
UserDao 对User表的所有操作 数据库
UserService 业务层----每个方法都是一个业务
UserServlet 1.接收数据 2.调用Service处理业务 3.完成跳转
创建包和类
引入jar包 {mysql C3P0 dbutils}
引入login的页面
编写SERvlet-service-DAO
Servlet 总结
1. Servlet的生命周期(重点)
:Servlet创建到销毁的过程
Service 每次访问都执行
Init 是Servlet被构造的时候,init方法被执行.
客户第一次访问Servlet的时候创建Servlet实例
被移除或者关闭服务器时消除
Destroy 被移除或者关闭服务器时消除
Servlet url-pattem的配置(了解)
三种 :
1. 完全路径匹配 :以/开始 eg:/servlet4
2. 目录匹配 以/开始需要以*结束. Eg:/*
3. 扩展名匹配 不能/开始 以*开始 eg:*.do
错误 /*.do
完全>目录>扩展名
开发中的路径的编写
相对路径:看你的位置的相对关系,不能以/开始
绝对路径:不需要找位置相对关系,以/开始
分成客户端路径和服务器端路径
客户端路径一定要加工程名
服务端路径不要要加工程名
登入成功后5秒钟跳转另一个页面案例
[使用http中的refresh]
Response中的设置响应头
addHeader(String name ,String value); 针对一个key对应多个value的响应头
addDateHeader(String name , long data);
addintHeader(String name , int data);
setHeader(String name ,String value); 针对一个key对应一个value的响应头
setDateHeader(String name , long data);
setIntHeader(String name , int data);
<解决页面中文乱码>
Response.setContentType("text/html;charset=utf-8")
登录成功后记录登录的成功的次数:需求和分析
案例 记录网站的登入成功的人数
[ServletContext 对象] 存的数据有一定的范围的,这种对象称为域对象. 服务器启动就创建ServletContext空间
用来存取数据 setAtribute(String name,Object object)
获取ServletContext中的数据 :getAtribute(String name);
移除ServletContext中的数据 : remove Atribute(String name);
作者: 小故事 时间: 2018-6-2 22:49
谢洪彬:
今天又学习了Servlet,不过相对与昨天用类去实现Servlet接口,并重写期中所有的方法来说,今天则是使用类去继承HttpServlet,这样就可以不用去实现左右的方法,需要那个就重写那个方法就好了.
Servlet的生命周期:
里面常用的三个方法:
Servlet();
Init();
Destroy();
执行顺序:
用户第一次访问Servlet的时候,会创建一个Init();并执行一次Servlet();
之后每一次请求都会执行一次Servlet();,当关闭服务器或者或者Servlet被销毁的时候就会执行Destroy();
注:Init();在服务器没有关闭时只会执行一次
今天还学习了作用域,ServletConnext,他的作用主要是用于储存数据,就比如今天的记录用户登录个数的案例,通过响应对象调用这个放在在调用set或get方法去设置数据,获取数据
这个作用域的范围在于整个Web项目;
今天学习了一个解决乱码的问题,根据请求或者响应调用不同的方法,今天的这个是响应的setContType(text/html;charset(UTF-8));
还学习了跳转页面的方法
setHeader():
第一种使用传入的参数是Refresh 这个是可以设置固定时间跳转制定页面
第二种使用传入的参数是Location 这个是立即跳转制定页面,不够在使用前需要调用setstatus()设置重定向状态302
作者: sts 时间: 2018-6-2 22:53
举报!!!第二行第一个innt打错了,是init
作者: 厦门陈强 时间: 2018-6-2 23:09
陈强
Servlet的一天---复杂的一天
首先是在昨天的基础上,让类去继承HttpServlet,而不是继承Servlet接口,这样子在重新方法的时候,只要重写需要使用到方法,而不用全部的方法都重写.
同时也方便了去配置web.xml.
然后就是今天中的复杂的东西----三个案例
第一个是用户登录案例
1\创建数据库和表
2\创建包和实体类
3\导入相关的包---mysql\c3p0\dbutils
4\再去编写相关类的代码
Servlet----service----dao
----接收注册页面提交传过来的数据----将数据封装成对象----再调用查询的方法去判定用户是否存在----等到结果后返回对象----根据返回的对象去做出相应的响应即可
虽然逻辑理清楚,但是这中间还是有很多需要注意的,可能路径写错了,或者是配置文件写错误掉,都有可能会导致异常出现.
第二个是计秒后跳转页面案例
第一种就是设置固定的秒数后跳转到指定的页面.这个相对就简单点,只要设置重定向,然后再设置一个Refresh和多少秒后跳转的一个路径就可以,
第二种就相对比较复杂,要配置文件中去设置一个优先级,然后再去重新创建一个HTML作为计秒跳转的页面,这个时候去定义function来改变秒数.这样才能设置秒数可变的实现.
还有一个队登录的次数进行统计的案例,虽然可以勉强完成,但是还没完全理解透,就先不总结了.
作者: 名字被人注册了 时间: 2018-6-2 23:29
刘文峰
使用servlet:创建一个普通类继承HttpServlet类就可以使用servlet接口的方法(因为httpServlet继承了Servlet接口的实现类);HttpServlet req是请求变量,可以接收并处理前台发送过来的数据,HttpServlet resp是响应变量,可以将结果相应给前台.
设置定时跳转页面: 设置响应头的方法 setHeader(“响应头的参数”) . 设置响应头参数refresh(定时跳转)或location(重定向)可以实现页面定时跳转:
Refresh参数实现页面跳转:resp.setHeader(“refresh”,”秒数;url=跳转页面的路径”)
Location参数实现页面跳转:先设置重定向状态码setStatus(302);然后设置响应头参数resp.setHeader(“location”,”跳转页面的路径”);在跳转的html文件里可以设置页面加载事件,使页面定时后过一定的时间跳转到另一个页面(需在html文件的head标签里定义标签<meta http-equiv="Refresh" content="5;url=跳转页面路径" />),还能通过js设置动态的秒数倒计时.
ServletContext是域对象,在Servlet初始化时服务器会初始化这个对象,一个工程只有一个域对象,可以存储数据,存储的数据整个工程都可以使用;getServletContext() 设置域对象 ;getServletContext() 获得域对象; setAttribute() 获得域对象后可以设置域对象的值; getAttribute() 获得域对象的值.
Servlet的生命周期;主要体现在init() service() destroy()三个方法上;第一次访问Servlet时创建Servlet实例,此时会执行init()方法,该方法之会执行一次;service()方法在用户访问时执行,每次访问都会执行一次该方法;destroy()方法在关闭服务器或从服务器移除该工程时执行.
作者: Nevermo 时间: 2018-6-3 00:01
本帖最后由 Nevermo 于 2018-6-4 00:04 编辑
许煜
Servlet总结
每次在html页面跳转路径如果指向servlet的子类页面时 在底层tomcat会创建一个servlet的实例化对象并调用service()和init()来初始化servlet的成员变量,在这里service() 有点类似于jquery里面的入口函数$(document).ready(function(){ });doget 和dopost 的底层均是service .servelet的生命周期要从某个页面触发事件路径指向servelet开始,到项目结束或者服务器关闭时结束. tomcat第一次会创建servlet实例化对象,在servlet被销毁之前,接下来的每次访问都不会再init新对象,而是创建新的子线程访问.而servlecomtextt就像是servlet的一个数据类型为Map<object,object>成员变量,属性和属性值形成一组键值对,在tomcat实例化对象的时候就存在,通过this.getservletcomtext()调用,这样也就能合理解释为什么servletcomtext的生命周期和servlet的实例化对象同步且作用域为一个web项目(每个项目启动时,tomcat会为每个项目创建一个单独的servlet对象).页面跳转通过sethead(refresh,value)设置表头 refresh表示隔多久刷新,然后通过新的url实现刷新时跳转 .redirect底层是通过302状态码重定向实现跳转页面
提交表单->servlet调用事务<- -事务(方法集)<---方法
|
实现验证 跳转 记数等各种功能
作者: sts 时间: 2018-6-3 00:26
苏海斌
Servlet的生命周期
Servlet的生命周期就是一个对象从创建到销毁的过程,当用户第一次访问Servlet的时候服务器会创建一个Servlet的实例,
并且Servlet中init方法就会执行,而在任何一次的请求时,服务器都会创建一个新的线程访问Servlet中的service的方法;
当项目从服务器中移除或关闭服务器的时候,Servlet实例就会销毁,那么destroy方法就会执行;
在对Servlet的配置中,在web.xml中在<servlet></servlet>标签中,
<load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高
在url-pattern配置方式有三种:
即完全路径匹配(以/开始),目录匹配(以/开始以*结束),扩展名匹配(以*开始,注意:不能以/开始)
优先级:完全路径匹配>目录匹配>扩展名匹配
(注:客户端路径一定要加工程名.服务器端路径不需要加工程名.)
ServletContext域对象(重点)
作用:
1.用来获得全局初始化参数.
2.用来获得文件的MIME的类型.
3.作为域对象存取数据时,作用范围是整个web工程
在服务器启动的时候,tomcat服务器为每个web项目创建一个单独ServletContext对象
在服务器关闭或在项目从服务器中移除的时候销毁.
4.用来读取web项目下的文件.
作者: it小白001 时间: 2018-6-3 00:52
吴俊斌
登入案例:
前期导包 mysql,c3p0,dbutils,还有一个c2p0的配置信息,一般出错都是配置信息问题,要看清了改一般改个
路径地址和登入账号和密码就行了
创建了一个servlet服务类,一个实体类,一个查询类就行了,业务类暂时感觉不到用处就不写了,实体类就是
根据表中的类创建的,再填上set,get方法还可以给过有参的构造.查询类定义一个有参(实体类对象)的查询方法,
通过实体类的get方法获得数据,然后在去数据库查询得到结果封装成实体类,返回实体类.最后创建一个子现象类httpservlet,通过dopost或doget方法的request.getparameter()获得数据,创建一个实体类,将获得的数据用set
对实体类赋值,在创建一个查询类对象,调用查询方法将实体类传过去就行了,得到结果在判断是否为空,为空登入失败
不为空就是登入成功. 一般出错都在html提交路径上,最好用绝对路径"/项目名/servlet的配置信息中的路径"
跳转页面:
就是在登入页面,先重定向下setstatus(302),在跳转setHeader("location","跳转时间;url=跳转的路径") 如果是页面直接在头标签<meta http-equiv="Refresh" content="跳转的时间;url=跳转的绝对路径"/>
记录网站登录成功案例
这个我们就要用到SetvletContext它是一个项目的一个文本域,可将它理解一个txt文件夹,项目所有类都可以使用它,这时我们现在第一个setvlet服务类里的init方法中get它定义一个变量用来记录登入的次数.再登入成功里跳转到
计数的页面,连接一次就变量++.输出变量就好了.
作者: LittleSky 时间: 2018-6-3 00:56
常小天
今天进一步学习servlet的内容。今天学习的知识可以通过今天的案例来一步步理解和掌握。今天的案例可以归总为一个，就是用户登录案例。在这个案例中，最先的一步是用户从浏览器访问服务器的一个HTML首页，这个首页是之前写好的，也没有什么新的知识点，就不用说了。通过首页的超链接切换到登录页面。这里要提一句的是用户访问的过程中每一步都是一个完整的请求与响应的过程。在登录页面输入登录信息后点击登录，也就是一个提交按钮。这时浏览器就会向服务器发出一个请求，也就是将录入的登录信息发送到一个指定好的存在于服务器的servlet程序。最原始的，当服务器开启后的第一个请求发送给servlet程序后，servlet对象创建，执行初始化程序，每一次用户的请求都会引发服务器访问一次servlet中的service方法，这里提一句，第一次请求，也就是触发servlet对象创建的请求也同样会触发service方法的调用。Service方法接着调用doxxx方法来对请求做出响应。Service方法会在服务器开启的时段内被多次访问，直到服务器关闭或者servlet被从服务器中移除，destroy方法执行，这个servlet对象就会被销毁。这就是servlet的生命周期。这里有一些点需要展开。一是servlet对象的创建可以通过在配置文件中添加load-on-startup标签，设置它的创建优先级，以达到在服务器开启的时候就创建servlet对象的目的。二是服务器对请求的响应不是一步到位的。当请求被传入servlet对象后，servlet会将信息抽取并封装到一个提前写好的类的对象中，在创建一个service对象（业务层类，包含了各种处理不同业务的方法），调用service对象的方法，本例中就是登陆方法，并将之前封装好的含有传入登录信息的对象作为参数传入。到这儿还没完，service对象只是业务层的对象，它没有具体的处理业务的方法步骤，在他的内部要创建一个DAO对象，各种具体的操作步骤都在DAO的方法中，业务层就是制定不同的业务方法，在每个方法中通过DAO对象调用一种或多种DAO方法来实现这个业务，打个比方，就是DAO中存放着各种最基础的小工具，service业务层对象就好比一个个业务员，他们拿着DAO中的各种工具来干活，不同的业务员采取不同组合的工具来完成不同的业务。最后将完成的结果返回给servlet，由servlet对结果进行判断并进一步做出相应的响应。当然这几个java类都要通过web.xml来配置进服务器。这之后说一说登录案例的优化。第一个方面就是等待5秒后跳转。这里使用的是setHeader方法，这个方法是servlet的方法，所以救助this关键字来调用，通过修改响应头的refresh的内容达成等待并跳转的目的。第二个方面是统计登陆成功的人数。这里要用到域对象。服务器为每一个工程都开辟了一块区域来保存一些全局变量，这就是域对象。ServletContext同样是servlet的方法，借助this来调用。在servlet的初始化方法中创建一个统计变量，设为0，并添加进域对象，当判断登录成功后，在调用方法获得域对象并得到该变量，自增，再赋给自身。并跳转至新的页面，在该页面在调用方法获得域对象再获得该变量，输出其值，这个值就是到目前为止登录成功的人数。
作者: AsusCoder 时间: 2018-6-3 00:58
webDay02_Servlet总结:
一、Servlet的生命周期
Servlet默认用户第一次访问时创建Servlet实例，然后调用init()方法，后面用户每次访问都会执行service()方法。当服务器关闭，或者web项目移除的时候，会调用destroy()方法。
1).init():初始化参数使用。
2).service()方法:用户访问会执行。来接收参数和作出响应，一次请求一次响应。
3).destory()方法:销毁对象。当Servlet被销毁前，可以方法里面执行一些保存数据的操作。
4).构造函数调用优先级大于init()。因为当构造函数执行完毕，才会产生一个Servlet单例对象。
5).Servlet默认用户第一次访问时创建实例，如果想让Serlvet在服务器启动时创建好，要在web.xml中的<servlet>标签中加上标签<load-on-startup>4</load-on-startup> 数字越小表示优先级越高。
二.web工程引入jar包的方法
今天在敲案例的时候，启动tomcat报出500:ClassNoFind，提示DBUtils的类QueryRunner无法找到。
原因:从web项目中导入jar包的方式错误。
解决:在web工程的WebContent->WEB-INF下有一个lib文件夹。将jar包复制进去就可以了。
与java工程不同的是，javaSE工程是创建一个文件夹lib，复制jar包。右键对jar包build path。
三、路径名配置:
1.绝对路径:
绝对路径以/号开始:
1).服务器的绝对路径名不需要加上工程路径名。如:<url-pattern>aa</url-pattern>表示/day0602/aa这个路径
2).客户端的绝对路径要加工程路径名:如，<form action = "/day0621/aa">:
2.相对路径:不以/号开始的都叫相对路径。
3.默认情况下路径:
前端:WebContent:这个等于工程名:/day0622/
服务器:/aa表示的时:/day0622/aa这个路径名
4.开发中的路径的编写:
相对路径:都是需要找位置相对关系
./: 当前路径
../:上一级路径
使用跳转的原则是把页面跳到WebContent文件夹中
四、web项目的包路径构建:
今天在学习登录案例的时候，最大的收获是学习构建package包路径名字。如何给java类进行合理的分类，使项目结构更清晰，对项目本身很重要。在今天的登录案例中。包的路径有以下分类和作用:
com.web.Bean:存放实体类javaBean,用来对应数据库的表:User.java用户类放在这里
com.web.dao:数据库连接:专门用来操作数据库的。UserDao.java:专门操作数据库的类放在这里
com.web.service:连接Servlet和数据库操作DAO之间的服务:UserService类放在这里，当Servlet将用户对象User传给它时，它会调用数据库操作UserDAO.并将操作结果告诉UserServlet;
com.web.servlet:存放Servlet类
com.web.utils:存放数据库连接的工具类
以后会经常使用这个分类的。
登录案例在逻辑上比较简单。
五、关于三案例合一:登录验证，跳转成功倒计时，登录成功后显示人数的总结
1.跳转的两个方法:
1).重定向:
resp.setStatus(302);
resp.setHeader("Location", "/day0602/loginSuccess.html");
2).定时刷新:
response.setHeader("Refresh", "0;url=/day0602/loginSuccess.html");
显示登录人数，今天的案例是从Servlet中直接打印。当跳转到成功页面以后，要用<meta http-equiv="Refresh" content="5;url=/day0602/CountServlet"/>中打印出来。
3)域对象存取数据:
（1）存:在初始化函数中:this.getServletContext().setAttribute("count",0);
(2) 取：Integer i = (Integer) this.getServletContext().getAttribute("count");
再存: etServletContext().setAttribute("count", ++i);
作者: 追风筝的人哇 时间: 2018-6-3 08:39
康元中
同学们，今天我们就正式学习Servlet的使用了，今天需要掌握的就是如下三个案例，通过敲案例掌握重要知识点。
今日需要掌握的有：
通过登录案例，掌握基本的Servlet的使用，从前台接收数据，处理数据，并将结果响应给前台
通过设置时间跳转页面案例，掌握如何设置响应头信息
通过记录网站登录成功案例，掌握一个重要对象ServletContext的使用，重点掌握存取数据API和生命周期
处理乱码问题：请求乱码（get/post），响应乱码
首先要知道Servlet 是一个在tomcat上的java程序;他可以对前端传来数据进行请求和响应;
前天是写了一个类去实现Servlet接口,这样这个类就得重写该接口的所有方法很不好,所以给了优化吧,
所以就今天学习了HttpServelet这是有关协议的Servelte,他的父类是根GenericServlet()并且它的父类实现了Servlet接口
1 首先掌握登录的一个案例
案例的步骤如下: 将用到的相关的jar放置lib中tomcat自动可以完成导包操作, 有三个包分别是:C3P0 的jar包
DBUtils的jar包 和jdbc的jar包. 然后将c3p0.的配置文件html放置项目的src下这是固定格式记住就好
首先要明白三层架构的编程思想.a: 界面层 b 业务逻辑层 c 数据访问层;
拷贝一个首页页面和登录的页面到WebContent下做好准备工作;
创建一个User类,就是要用这个user类的对象来传参数,注意里面的成成员变量要和数据库中字段的名一样,
创建一个UserServlet类继承httpServelte 重写了doget和dopost方法然后可以使用request.getParameter
获取客户端传来的值然后将值通过set方法封装到user对象中 然后创建UserService调用方法来获取处理完
的值. UserService 就是想当于业务逻辑层,对界面层传来的数据进行处理和响应以及数据访问层提供数据的响应..
关系还是有点乱大概是那个意思,创建UserDao 这个类就是对数据的操作,将我们传user对象中的值拿去到
数据库中进行匹对,将匹配值进行封装到Javabean中.在UserServlet中登录成功与否判断
登录成功后可以进行 页面的跳转和客户端访问的一个计数.
a;通过 response.setHeader("Refresh", "5;url=/day/demo3-login/index.html")完成登录成功后5秒
后的页面跳转
b:另外一种是登录成功后跳转到一个一面上然后五秒后再进行页面跳转
页面的跳转就要用到 响应行的 状态码配合setHeand的使用
response.setStatus(302);
response.setHeader("Location","/day/sucess.html");
解决向页面输出中文的乱码问题 response.setContentType("text/html;charset=UTF-8");
c: 客户端访问的一个计数就要知道什么是域对象,就是服务器为每个工程开辟一块区域来包存全局变量,
这些变量在其他类中都能被使用.在servlet的初始化方法中创建一个统计变量且设为0;
通过getServletContext和setAttribute进行存值当登录成功就取值 然后计数变量自增
在接着存值. 这个值就目前止登录成功的人数。
作者: rkko 时间: 2018-6-3 08:44
杜石苇
Servlet 运行在服务端的Java小程序，是sun公司提供一套规范（接口），用来处理客户端请求、响应给浏览器的动态资源。但servlet的实质就是java代码，通过java的API 动态的向客户端输出内容
Servlet接口中的方法
1）init(ServletConfig config)
何时执行：servlet对象创建的时候执行
ServletConfig ： 代表的是该servlet对象的配置信息
2）service（ServletRequest request,ServletResponse response）
何时执行：每次请求都会执行
ServletRequest ：代表请求 认为ServletRequest 内部封装的是 http请求的信息
ServletResponse ：代表响应 认为要封装的是响应的信息
3）destroy()
何时执行：servlet销毁的时候执行
Servlet的生命周期
1）Servlet何时创建
默认第一次访问servlet时创建该对象
2）Servlet何时销毁
服务器关闭servlet就销毁了
3）每次访问必然执行的方法
service(ServletRequest req, ServletResponse res)方法
是ServletContext对象是个域对象,里面可以存放变量只要访问该服务器的任何用户都可以来存取变量
作者: wahahaha 时间: 2018-6-3 09:05
林恒山
Servlet接口被通用的servlet的genericServlet类实
现,HttpServlet类继承Generic类.前台form表单传来的数
据通过doPost()或者doGet()处理.
Servlet的生命周期:Servlet的创建到销毁的过程.
创建:用户第一次访问Servlet创建Servlet的实例.
销毁:服务器正常关闭或者项目从服务器移除.
用户第一次访问Servlet,服务器创建Servlet实例并且执行
init(),init只会在创建Servlet时执行一次.每次用户请求
后,service()都会执行一次,查看请求是get或者post..,回
去执行对应的doXxx()方法.
通过在web.xml配置<load-on-startup>2</load-on-
startup>,可以让init()在服务器启动的时候就加载.
url-pattern配置方式有3种:
1.完全路径匹配:一/开始
2.目录匹配:以/开始,以*结束
3.扩展名匹配:不能以/开始,以*开始
三种配置方式执行的顺序:
完全路径匹配 > 目录匹配 > 扩展名匹配
相对路径:找相对位置,不能以/开始
本级路径 ./(可以不写) 上一级目录../
绝对路径:以/开始.分为
客户端路径:一定要加工程名
服务器路径:不需要加工程名
添加表头信息:
addHeader(String name,String value);针对一个key对
应多个value的响应头
addDateHeader(String name,long date);
addIntHeader(String name,int value);
setHeader(String name,String value);针对一个key对
应一个value的响应头,这种情况的使用的比较多
setDateHeader(String name,long date);
setIntHeader(String name,int value);
response.setHeader("Refresh", "5;url=/day09/demo5
-refresh/index.html");5秒之后跳转到index.html
ServletContext对象存取数据.
setAttribute(String name,Object obj)往
ServletContext对象存入数据
getAttribute(String name)从ServletContext
对象获取数据.
removeAttribute(String name)从
ServletContext对象移除数据.
// 初始化一个变量count的值为0.
int count = 0;
// 将这个值存入到ServletContext中.
this.getServletContext().setAttribute("count",
count);
这是往ServletContext对象存放参数为count字符串,值为
count整形的值.
这2句放在init().
int count = (int) this.getServletContext
().getAttribute("count");
count++;
this.getServletContext().setAttribute("count",
count);
这样是往ServletContext对象获取数据,进行操作后存放到
ServletContext里面.
ServletContext作用:
作为域对象存取数据;
作用范围:整个web工程.
创建:服务器启动的时候.
销毁:服务器关闭或者项目从服务器移除
读取web项目下的文件.
作者: 林荣彬 时间: 2018-6-3 09:20
林荣彬
今天主要学习了Servlet登录页面的操作,设置时间跳转和记录登录成功次数的案例;
UserDao:对User表的所有操作;(增删改查)
UserService:业务---每个方法都是一个业务
UserServlet:1.接收数据2.调用service处理业务3.完成跳转.
用户登录操作顺序
1 创建User表
2 创建User实体类
3 在WEB_INF的lib文件夹里 导包c3p0,mysql,DButils
4 创建UserDao,UserServlce,UserServlet, html页面
5 接收数据→处理业务→查询数据库→返回查询结果到用户
生命周期:就是一个对象从创建到销毁的过程.
Servlet生命周期:Servlet从创建到销毁的过程.
何时创建:用户第一次访问Servlet创建Servlet的实例
何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销
毁,那么destroy方法就会执行.
Servlet默认是在第一次访问的时候创建的.现在让Servlet在服务器启动的时候创建好.进行对Servlet的配置:
在web.xml中在<servlet></servlet>标签中配置:
<load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高.
ServletContext 域对象:
功能:1.获得全局初始化参数2.用来获得文件的MIME的类
型;3.作为域对象存取数据4.用来读取web项目下的文件.
作用范围:整个web工程.
创建:服务器启动时创建,tomcat服务器为每个web项目创建一个单独ServletContext对象;
销毁:服务器关闭的时候.或者项目从服务器移除的时候;
响应乱码:
response.setContentType("text/html;charset=utf-8");
作者: COLDER 时间: 2018-6-3 10:08
本帖最后由 COLDER 于 2018-10-18 19:33 编辑
Day13
HttpServlet间接实现Servlet,可以重写service方法
一个类继承HttpServlet,重写doGet,doPost方法
doGet:如果是get请求,就执行doGet();
doPost:如果是post请求,就执行doPost();
Servlet底层的Service方法实现是通过将传入的request和response参数强转为httprequest和httpresponse参数,
再调用service方法传入这两个参数,然后判断方法名为get还是post,再去调用doget()或者是dopost(),
所以service方法底层代码实现其实通过doget和dopost方法来实现.
注册案例:
创建数据库数据表---创建实体类---创建Dao(执行sql语句)---创建service(接收参数---处理业务---跳转页面)---创建servlet(extends httpservlet,编写get)---导包---编写注册页面
Servlet生命周期:Servlet从创建到销毁的过程.
用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中的init方法就会执行.
任何一次请求服务器都会创建一个新的线程访问Servlet中的Service的方法.
在service方法内部根据请求的方式的不同调用doXXX的方法
(get请求调用doget,post请求调用dopost).当Servlet中服务器中移除掉,或者关闭服务器,
Servelet的实例被销毁,那么destroy方法就会执行.
Servlet配置
<load-on-startup>优先级</load-on-startup>优先级不能为1.
url-pattern配置方式:完全路径匹配,目录匹配,扩展名匹配,优先级:完全路径>目录>扩展名.
完全路径匹配:以/开始
目录匹配:以/开始,以*结束
扩展名匹配:以*开始
绝对路径以/开始,相对路径不以/开始,
绝对路径:客户端路径,服务器端路径
客户端路径一定要加工程名,服务器端路径不需要加工程名.
建议使用绝对路径
登录成功5秒后跳转案例:responce设置响应头,利用refresh属性来跳转到新页面
记录登录成功人数案例:在注册案例的基础上使用ServletContext对象(域对象),调用set/get Attribute方法来存取数据.
作者: hpb199567 时间: 2018-6-3 10:15
何平波
Servlet
快速配置Servlet文件,在包里新建Servlet,一键生成类文件加web.xml.
案例一,模拟用户登录跳转页面提示成功或失败
1.写一个类继承HttpServlet
2.创建数据库和表
3.创建User实体类,创建UserDao(用户登录案例代码),UserService(登录案例的Service代码),UsweServlet(登录案例的Servlet代码),html页面
4.引入jar包 c3p0.jar Dbutils.jar jdbc.jar
5.UserServlet(action转到这个类里)接收数据,调用service处理业务,--判断是否存在
6.setContentType("text/html;charset=UTF-8");解决乱码
User ------实体类
UserDao--对User表的所有操作
UserService--业务--每个方法都是一个业务
UserServlet--接收数据,调用service处理业务,完成跳转
总结
Servlet的生命周期
概念:就是一个对象从创建到销毁的过程.
2.Servlet生命周期,Servlet从创建到销毁
案例二 模拟用户登录定时页面跳转
结合模拟用户登录跳转页面提示成功或失败
在第五步的步骤里写入一行代码就可以实现该功能
//5秒跳转 //url路径是跳转的页面的路径
response.setHeader("Refresh", "5;url=/Demo/zc.html");
setHeader 设置响应头
作者: 李思贤126 时间: 2018-6-3 15:51
李思贤:今天学习了页面的登录 ,生命周期,定时跳转, 登录数记录;
一:页面登录:
在servlet中 1接收从登录页面传来的数据
2封装对象 封装成一个user对象
3调用业务层 调用UserService中login方法(自己写),调用UserDao中查询,
返回一个对象
4跳转:判断对象是否存在,跳转
二:Servlet生命周期:
创建init执行:用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.
Service执行:任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.
关闭Destroy执行:当项目从服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
三:跳转计时的那个(5,4,3,2,1):是先跳转到一个界面
response.setStatus(302);
response.setHeader("Location", "/Day0602/Test-login/success.html");
再读秒,调到首页
<meta http-equiv="Refresh" content="5;/Day0602/Test-login" />
<script type="text/javascript">
var time = 5;
window.onload = function() {
setInterval('timechange()', 1000);
}
function timechange() {
time--;
document.getElementById("s1").innerHTML = time;
}
<body>
<h1>登录成功</h1>
<h3>
页面将在<span id="s1">5</span>秒回跳转
</h3
</body>
四:记录成功登陆人数
首先要了解ServletContext的用法;
在web.xml中设置 <load-on-startup>3</load-on-startup>
在Servlet中重写
@Override
public void init() throws ServletException {
int count = 0;
this.getServletContext().setAttribute("count", count);
}
.........
if (existUser == null) {
response.getWriter().println("用户名或密码错误");
} else {
int count = (int) this.getServletContext()
.getAttribute("count");
count++;
this.getServletContext().setAttribute("count", count);
response.getWriter().println("登录成功");
response.getWriter().println("5秒钟后跳转");
response.setHeader("Refresh", "5;url=/Day0602/countDemo1");
在跳转页面countDemo1中在页面上打印:
int count = (int)this.getServletContext().getAttribute("count");
response.getWriter().println("你是第"+count+"位登录成功得人");
作者: q55w66 时间: 2018-6-3 21:38
王清松
生命周期
创建
Servlet第一次被访问时，TomCat帮忙完成Servlet实例的创建
创建时会调用方法void init(ServletConfig config)
接收请求
任何一次请求，服务器都会创建一个新的线程调用方法
void service(ServletRequest req, ServletResponse res)
销毁
服务器关闭时或项目从服务器移除时销毁
销毁时会调用方法void destroy()
相关配置
启动时创建Servlet
Servlet默认在第一次被访问时创建实例，可能会使第一位用户等待一段时间，所以可以在服务器启动时创建
1.找到web.xml配置文件
2.找到<Servlet></Servlet>标签
3.添加<load-on-startup>2</load-on-startup>标签(数字越小，创建优先级越高)
底层实现
1.通过反射,用Class xxx=Class.Forname(xxx)拿到字节码文件
2.xxx.newInstance()动态创建实例(调用无参构造,如果该类没有无参构造则抛出异常)
url-pattern配置方式
完全路径匹配
以 / 开始
/MyWeb/fathersday
目录匹配
以 / 开始，以 * 结束
/MyWeb/*
/*
扩展名匹配
不能以 / 开始，以 * 开始
*.action
*.do
优先级：完全路径匹配>目录匹配>扩展名匹配
路径
相对路径
绝对路径
以/开头
第一个/默认代表根路径，即项目路径(MyWeb)
将编写的这个servlet配置到服务器中
配置web.xml文件
<!-- 配置Servlet -->
<servlet>
<!-- Servlet名称 -->
<servlet-name>Test</servlet-name>
<!-- Servlet全路径 -->
<servlet-class>com.father.ServletDemo01</servlet-class>
</servlet>
<!-- Servlet映射-->
<servlet-mapping>
<servlet-name>Test</servlet-name>
<!-- Servlet访问路径 -->
<url-pattern>/Test</url-pattern>
</servlet-mapping>
在网页中访问localhost:(端口号)/(Web项目名称)/Test即可访问类com.father.ServletDemo01，并执行里面得Service方法
GenericServlet类
(通用servlet)
ServletConfig getServletConfig()
Returns this servlet's ServletConfig object.
ServletContext getServletContext()
Returns a reference to the ServletContext in which this servlet is running.
HttpServlet类
(Http协议使用的servlet)
void doGet(HttpServletRequest req, HttpServletResponse resp)——处理HTTP的GET请求
void doPost(HttpServletRequest req, HttpServletResponse resp) ——处理HTTP的POST请求
ServletConfig对象
用于获得Servlet的配置信息
String getInitParameter(String name)
Returns a String containing the value of the named initialization parameter, or null if the parameter does not exist. 获得servlet初始化参数
Enumeration getInitParameterNames()
Returns the names of the servlet's initialization parameters as an Enumeration of String objects, or an empty Enumeration if the servlet has no initialization parameters. 获得servlet所有初始化参数名称
String getServletName()
Returns the name of this servlet instance.
ServletContext对象
作用
获得全局初始化参数
获得文件MIME的类型
作为域对象存取数据
用来读取web项目下的文件
ServletContext对象作为域对象存取数据
作用范围：整个Web工程
创建，Tomcat为每个web项目创建一个单独ServletContext对象
销毁，服务器关闭或者项目移除时
作者: ...ylq 时间: 2018-6-4 00:32
叶凌青
Servlet的概述
就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
独立编写一个Servlet:
Servlet的作用:用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
编写一个类 implements Servlet接口.
将编写的这个类配置到服务器中.
Servlet的关系
Servlet :接口（Implementing Classes:
FacesServlet, GenericServlet, HttpServlet
）
|
|
GenericServlet:通用的Servlet（Implemented Interfaces:
java.io.Serializable, Servlet, ServletConfig
）
|
|
HttpServlet（Implemented Interfaces:
java.io.Serializable, Servlet, ServletConfig
）
编写一个类继承HttpServlet，重写doGet和doPost方法.
配置
Servlet的生命周期
生命周期:就是一个对象从创建到销毁的过程.
Servlet生命周期:Servlet从创建到销毁的过程.
何时创建:用户第一次访问Servlet创建Servlet的实例
何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
描述概述：用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线
程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或
者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
作者: 望蜀 时间: 2018-6-4 16:42
邵倩
Servlet 接口
|
GenericServlet :
|
HttpServlet : 编写一个类 继承httpservlet,重写doGet和doPost,配置
案例 登录 :在登录页面输入账户密码,在后台拿到数据,在数据库中查询用户名密码是否匹配 若匹配则登录成功
实现步骤:
在数据库中创建user表 有用户名密码等字段
创建 user 实体类 属性与表中字段一一对应
导包 c3p0 mysql驱动包 DBUTILS 不用build path
引入login的页面
创建 UserServlet(接收数据 把数据封装到实体类 创建UserService对象 调用userService的login(User user)方法 ,根据login方法的返回值来提示是否登录成功),
UserService(login(User user)方法: 创建UserDao对象 调用userDao的login(User user)方法) ,
UserDao(login(User user)方法: 创建QueryRunner对象 编写查询的sql语句 调用queryRunner的query()方法 )
Servlet生命周期
用户第一次访问servlet的时候,服务器创建一个servlet实例,那么servlet中init方法就会执行,
每次请求服务器都会创建一个新的线程访问servlet中的service方法,
在service方法内部根据请求方式的不同,调用doxxx的方法.
当servlet中服务器中移除掉,或者关闭服务器,servlet的实例就会被销毁,那么destroy方法就会执行.
response中设置响应头:
setHeader(String name,String value) --- 一个key对应一个value的响应头
使用JS控制读秒效果
<script type="text/javascript">
var time = 5;
window.onload = function(){
setInterval('changeTime()',1000);
}
function changeTime(){
time--;
document.getElementById("s1").innerHTML = time;
}
</script>
servletContext是一个域对象
作用范围:整个web工程
创建:服务器启动的时候 tomcat服务器为每个web项目创建一个单独servletContext对象
销毁:服务器关闭时 或者项目从服务器中移除的时候
作者: 376091692 时间: 2018-6-4 17:32
凌辉:
生命周期:就是一个对象从创建到销毁的过程.
Servlet生命周期:Servlet从创建到销毁的过程.
何时创建:用户第一次访问Servlet创建Servlet的实例
何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
Servlet默认是在第一次访问的时候创建的.现在让Servlet在服务器启动的时候创建好.进行对Servlet的配置:
在web.xml中在<servlet></servlet>标签中配置:
* <load-on-startup>2</load-on-startup> --- 传入正整数,整数越小,被创建的优先级就越高.
url-pattern配置方式共有三种:
1.完全路径匹配 ：以 / 开始 例如: /ServletDemo4 , /aaa/ServletDemo5 , /aaa/bbb/ServletDemo6
2.目录匹配 ：以 / 开始 需要以 * 结束. 例如: /* ,/aaa/* ,/aaa/bbb/*
3.扩展名匹配 ：不能以 / 开始 以 * 开始的. 例如: *.do , *.action
***** 错误的写法 ： /*.do
作者: Do1 时间: 2018-6-4 22:12
本帖最后由 Do1 于 2019-11-23 00:36 编辑
Servlet是一个单例工具,里面主要用到的是request response 提取响应 这两个东西里面包装好了线程 网络 以及IO流 挺好用的
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |