Servlet&JSP

Servlet&JSP

一.  Web应用的演变

1.      规律

a)      由单机程序向网络程序发展

b)      由C/S往B/S发展

2.      CS和BS的区别

a)      Client Server(客户端服务器程序，客户端由程序员开发，用户与要安装)

b)      Browser Server(浏览器服务器程序，不需要单独开发及安装)

二.  Servle介绍

一种用来扩展Web服务器功能的组件规范。

1.      服务器如何给浏览器返回网页

a)        返回静态网页

百度百科、新闻

内容不变，任何人看都一样

服务器保存一个HTML，访问时直接返回。

b)        返回动态网页

微博，关注的人不一样，看到的事情不一样、淘宝

每个人看的内容有差别

服务器保存一个组件，用它来拼一个动态网页

在java项目中，这个组件就是Servlet

组件:满足规范的对象。

术语:可以处理HTTP协议

2.      Servlet具备的特征

a)        Servlet是存储在服务器上的

b)        它可以拼动态资源(网页、图片等

c)        Servlet满足sun规范

3.      什么是Servlet

是sun推出的用来在服务器端处理HTTP协议的组件

三.  服务器

1.      名称

a)        Java服务器

b)        WEB服务器

c)        java Web服务器

d)        Servlet容器    

2.      本质

a)      是一个软件，能够运行java项目的软件

b)      和浏览器相对应、平级关系

c)      举例

Tomcat、Jboss、WebLogic、Websphere        

四.  如何使用tomcat

1.      单独使用(系统上线时候)(*

a)      配置JAVA_HOME，tomcat依赖于java，使用个人笔记本同学需配置

b)      下载及安装，在apache官网下载，服务器有资料。

c)      启动tomcat，

-Linux:打开/tomcat/bin.输入./startup.sh

                            给目录加权限:chmod+x *sh

-windpw:打开/tomcat/bin ,双击startup.bat

http://localhost:8000

d)      关闭tomcat

linux: 打开/tomcat/bin.输入./shutdown.sh

 

2.      用eclipse管理tomcat(开发时测试时候用)

a)      具体可自行百度。

b)      配置失败需要重新配置:

window->preference->server->runtime->remove

c)      Eclipse项目中的servers也要删掉

五.  Servlet开发步骤

MyEclipse比Eclipse多了些插件

1.      创建web项目

WEB项目有标准的WEB目录:

webapp/WEB-INF/web.xml

2.      导入jar包

用maven关键字javaee

            在搜索结果中选择javaee-api.jar

使用tomcat内置的javaee包

            点击项目bulidPath。

            properties->targetedruntimes ->勾选

部署的时候，测试代码就会抛掉。

3.      Servlet

继承与HttpServlet

间接是吸纳了servlet接口(sun的规范)

4.      配置web.xml

<servlet-name></servlet-name>

这个别名只能在此文件中使用

<servlet-mapping>

     <servlet-name>time</servlet-name>

            <url-pattern></url-pattern>

</servlet-mapping>

         //给这个Servlet注册一个访问路径(网名)

         //url需要以斜线开头

        

5.      部署

表示已经部署Synchronized-->部署就是拷贝

6.      访问Servlet

http://localhost:8000/Serlvet1/ts

补充:

端口被占用问题

 

//jQuery动画

1.      $obj.show(执行时间,回调函数)

2.      animate(偏移位置,执行时间,回调函数)

 

//HTTP协议

启动tomcat的时候，localhost是本机地址，如果其他机器只要连接了同一个局域网，直接拿连接到此处IP地址，就可以使用共享tomcat了。

 

如果不遵守HTTP协议就要自己去写一个协议。

hypertext Transfer Protocol

超文本传输协议，应用层协议，定义了web服务器之间如何通信以及通信的数据格式

 

客户端访问服务器:

1.      建立连接

2.      打包，发送请求

3.      打包，发送响应

4.      关闭连接

一次请求一次连接，一次请求连接完之后立马断开。

 

请求数据:

1.      请求行

2.      消息头

3.      实体内容

 

响应数据包组成:

1.      状态行

2.      消息头

3.      实体内容

 

 

1.      什么是HTTP协议

a)        就是一个规范(w3c)

b)        规定了:浏览器和服务器如何通信及数据格式

2.      如何通信

a)        建立连接

b)        发送请求

c)        接收响应

d)        关闭连接

3.      数据格式

a)        请求数据(浏览器向服务器发送的数据)

                        i.             请求行:请求的基本信息

                      ii.             消息头:请求数据的描述信息

                     iii.             实体内容:请求的业务数据

b)        响应数据(服务器向浏览器发送的数据)

                        i.             状态行:响应的基本信息

                      ii.             消息头:响应数据的描述信息

                     iii.             实体内容:响应的业务数据

4.      对开发的要求

a)        不需要管的地方

                        i.             通信的过程已经由浏览器和服务器熟悉拿了

                      ii.             请求数据的组装由浏览器实现了

                     iii.             响应数据的组装由服务器实现了

b)        需要处理的地方

                        i.             请求的业务数据由开发者提供

                      ii.             响应的业务数据由开发者提供

>统一使用request处理请求数据，使用response处理响应数据

//1.使用request读取请求数据

              //1.1读取请求行

              System.out.println("请求方式:"+req.getMethod());

              System.out.println("访问路径:"+req.getServletPath());

              System.out.println("协议类型:"+req.getProtocol());

              //1.2读取消息头

              //getHeaderNames()返回key的迭代器

              //该迭代器是比Iterator更古老的迭代器

              Enumeratione =req.getHeaderNames();

              while(e.hasMoreElements()){

                     Stringkey = (String)e.nextElement();

                     Stringvalue =req.getHeader(key);

                     System.out.println(key+":"+value);

              }

              //1.3读取实体内容

              //本案例浏览器没有向服务器传递任何业务数据

              //所以实体内容为空

              //2.使用response写出响应数据

              //2.1写状态行:由服务器自动写

              //告诉浏览器给它输出的是什么格式的内容

              //2.2写消息头:

              res.setContentType("text/html;charset=utf-8");

              //该流指向浏览器

              PrintWriterout =res.getWriter();

              Stringnow = new SimpleDateFormat( "HH:mm:ss").format(new Date());

              //2.3写实体内容:

              out.println("<p>"+now+"</p>");

              out.close();

//单选多选上增加value，可获取。

 

//Servlet运行的详细步骤

1.      浏览器依据IP建立与容器的连接

2.      浏览器请求数据打包

3.      容器解析请求数据包，封装对象

4.      容器依据路径找到Servlet创建对象

5.      容器调用Servlet对象的service方法

6.      容器将相应打包发给浏览器

7.      浏览器取出结果，生成页面

 

通信组件:由浏览器和服务器开发的用来进行数据交互的组件

 

//请求方式

浏览器向服务器传递数据的方式

GET 请求指定资源

POST 向指定的资源提交所需要处理的数据

HEAD 要求响应与响应的GET一样，但没有响应体

PUT  上传指定资源

DELETE 删除指定资源

 

1.      浏览器向服务器发送数据的方式

请求方式包括很多种方式，需要掌握的是GET和POST

2.      GET和POST方式的区别

a)        get

                        i.             采用路径传参

                      ii.             参数在传递过程中可见(地址栏)，隐私性差

                     iii.             传参能力有限，只能传少量参数

                     iv.             所有默认的请求都是get请求

b)        post

                        i.             采用实体内容传参，参数在传递过程中不可见

                      ii.             隐私性好

                     iii.             实体内容专门用来传参，大小不受限制

                     iv.             在form上加一句话,method=”post”

3.      如何选择请求方式

a)        一般查询时使用GET请求，因为查询条件一般比较少

b)        一般保存时使用POST请求，因为保存的数据一般较多

 

request解决乱码的三种方法

1.      get/post 让Servlet接收乱码，然后采用iso将乱码字符串还原为byte，再采用utf-8将byte转换成String

a)        优点:万能  缺点:麻烦

 //处理请求乱码

              byte[]bs =code.getBytes("ISO8859-1");

        code = new String(bs,"utf-8");

2.      get

修改tomcat配置文件，在server.xml第65行，增加

URIEncoding=”utf-8”;

优点:简单        缺点:只对get有效

3.      post

在使用request接收参数前加req.setCharacterEncoding(“utf-8”);

优点:简单  缺点:只对post有效

 

 

response:

res.setCharacterEncoding(“utf-8”);

 

 

补充；

1.      什么是javaBean

a)        满足如下规范的类

                        i.             有package

                      ii.             有默认构造器(无参构造器)

                     iii.             实现序列化接口

                     iv.             有get/set方法(不一定)

不满足的话，一般会在出现大批量并发事件的时候会出问题。

         这一个实体类的话一般会有默认无参构造

//封装类型比基本数据类型多了一个null

 

//HTTP协议

相对web项目的一个架构

绝对路径和相对路径的问题。

//tomcat启动直接挂掉的原因是因为代码写错了，映射路径可能有问题。

 

1.      重定向经典的使用场景，解决互联网上两个网站之间的跳转问题。

2.      重定向扩展的使用场景，解决一个项目中两个独立的组件之间的问题

1.      重定向一般的使用规律:通常在增加、修改、删除后重定向到查询。

302状态码的含义就是告诉浏览器要找别人。

 

//Servlet容器如何请求资源路径

EmpManager

         src

                   main

                            java

                            resource

                            webapp

         target

                   classes

java代码在编译的时候就保存到classes中。

工具栏 projectàBuild Automatically

java代码保存时候自动编译为class文件

1.部署的时候，把src下的webapp先部署到服务器中。

2.还需要改名，webapp部署之后，就会把webapp名字改掉，改为项目名。

EmpManager。

3.再次把classes拷贝到WEB-INF下面，就有了java代码。

平时所说的路径就是tomcat的相对路径。都是相对于tomcat来说的

访问路径都是指tomcat内部署资源的访问路径。

 

静态资源(html/css/js/IMG)的路径

资源在tomcat内存储的位置

 

动态资源(Servlet)路径

在web.xml中声明的访问路径

 

应该将路径理解为资源的名称，而不是位置。

 

//获取访问路径

//项目名

System.out.println(req.getContextPath());

//Servlet路径

System.out.println(req.getServletPath());

//项目名+Servlet 绝对路径

System.out.println(req.getRequestURI());

//完整的URL

System.out.println(req.getRequestURL());

 

//如果不给浏览器写响应信息，则服务器在响应时实体内容为空

//但状态行、消息头有值。此时，浏览器看到的是空白。

 

//URI和URL的区别

1.     侠义的理解(java项目)

a)       URI是绝对路径，而URL是完整路径

b)       URL包含了URI

2.      广义的理解(Web项目)             (*)

a)        URI是资源的名字

b)        URL是资源的真名

c)        URI包含了URL

因为真名只有一个，名字可以有多个。

 

//Servlet访问路径的配置方案

Servlet的url只能对应一个请求，所以会导致多写很多Servlet。

1.     精确匹配(/hello)

a)       只有这一个路径访问Servlet

b)       此Servlet只能处理一个请求

2.     通配符(/*)

a)       所有的路径都可以访问此Servlet

b)       此Servlet能处理所有请求

3.     后缀(*.abc)

a)       所有以abc为后缀的路径都可以访问此Servlet

b)       此Servlet能处理多个请求

 

<servlet-mapping>

     <servlet-name>hello</servlet-name>

     <!-- 精确匹配 -->

     <!--<url-pattern>/hello</url-pattern> -->

     <!-- 通配符匹配 -->

     <!--<url-pattern>/*</url-pattern> -->

     <!-- 后缀匹配 :不以/开头-->

     <url-pattern>*.yannis</url-pattern>

</servlet-mapping>

4.     用一个Servlet处理多个请求的方案

a)       先写规范，规定每个请求的访问路径是什么

假设:/findEmp    /addEmp

 

 

 

b)       只有一个MainServlet

void service(){

       String path = req.getServletPath();

       if(path.equals(“findEmp”){

       //查询员工

}else if(path.equals(“addEmp”)){

       //保存员工

}else{

       //抛异常

}

}

 

c)       web.xml

<url-pattern>

       /*

</url-pattern>

d)      用户只有写入findEmp和addEmp的路径才可以访问Servlet。

一般不会让用户写这些网址，会有一个类似的主页面会给出链接。

//通配符和后缀的典型应用场景

通配符适合使用一个Servlet处理所有请求

写一个MainServlet，配置web.xml路径为/*

 

后缀:比较灵活，一个Servlet处理一个模块的请求

EmpServlet  *.emp

DeptServlet  *.dept

 

 

//Servlet的生命周期

tomcat

特点:

1.     默认情况下首次访问Servlet时tomcat会实例化它

2.     可以修改为启动tomcat时就实例化Servlet

3.     因为tomcat只启动/关闭一次，所以第1.2.4步只执行一次，所以某个类型的的Servlet是单例(单个实例)的。单例省内存。

 

<servlet-name>hi</servlet-name>

<servlet-class>web.HiServlet</servlet-class>

//启动tomcat时第一个实例化此Servlet,在启动tomcat的时候就实例化

<load-on-startup>1</load-on-startup>

 

//Servlet生命周期

生命周期相关方法的调用顺序

 

//ServletConfig

配置文件，解耦合。

ServletConfig可以读取web.xml中的数据，传到Servlet

一个ServletConfig对应一个Servlet

 

//ServletContext

放在Servlet配置的外面。
ServletContext可以读取web.xml中的数据，传到Servlet

1个ServletContext对应多个Servlet

1.     开发时某些Servlet需要预置参数

2.     可以自定义配置文件，自定义工具来读取

3.     也可以使用web.xml做配置文件，并使用config或context来读取。

 

区别；

1.     config和Servlet是1对1的关系

tomcat在创建Servlet前会给它创建一个config

如果数据只有这一个Servlet使用，那么将其存入config

2.     context和Servlet是1对多的关系

tomcat在启动时会创建一个context

如果数据是多个Servlet共用，那么将其存入context

 

//调用init()方法时会传入config

tomcat创建Servlet前先创建config

tomcat创建 config读取web.xml

//重定向经典案例

解决互联网上2个网站之间的跳转问题

类似于百度。

可以在两个Servlet之间跳转，比如删除之后要执行查询Servlet

//tomcat部署代码(wtpwebapps)

//Servlet生命周期

//config和context

config和context从web.xml中读取。

或者写配置文件或者工具类

//context一般使用在分页查询中。

一.  context的特殊用法

a)        使用场景

                        i.             之前使用config和context读取的都是web.xml中配置的常量

                      ii.             有时候我们需要存取的可能是变量

                     iii.             context支持存取变量，而config不行，给多个Servlet共用

b)        案例

                        i.             给软件做一个统计流量(访问量)的功能

                      ii.             流量是一个变量，无论访问哪个Servlet，流量+1

//工作中一般会写一个InitServlet来初始化init()，在tomcat启动时，设置context中count=0;

<servlet-class>web.HiServlet</servlet-class>

<load-on-startup>1</load-on-startup>

//tomcat已启动就调用这个Servlet。

//InitServlet

public class InitServlet extends HttpServlet {

 

       /**

        * version 1.0

        */

       private static final long serialVersionUID = 1L;

      

       /**

        * 一般web项目中都有一个InitServlet，仅仅是在tomcat启动时初始化一些数据

        */

       @Override

       public void init(ServletConfig config)throws ServletException {

              super.init(config);

              //向context中存一个变量count=0，给其他Servlet使用。

              ServletContextctx = getServletContext();

              ctx.setAttribute("count", 0);

       }

}

 

//web.xml

<servlet>

             <servlet-name>init</servlet-name>

             <servlet-class>web.InitServlet</servlet-class>

             <load-on-startup>1</load-on-startup>

      </servlet>

      <servlet-mapping>

                    <servlet-name>init</servlet-name>

                    <url-pattern>/init</url-pattern>

 </servlet-mapping> 

//登录Servlet

//1.接收传入的账号密码

              System.out.println("接收账号密码");

              //2.验证账号密码是否正确

              System.out.println("验证账号密码");

              //3.判断当前在线人数是否达到上限

              ServletConfigconfig = getServletConfig();

              StringmaxOnline =config.getInitParameter("maxOnline");

              System.out.println(maxOnline);

              //4.进入游戏/或排队

              System.out.println("进入游戏...");

              //统计网站流量

              ServletContextctx = getServletContext();

              Integercount = (Integer)ctx.getAttribute("count");

              ctx.setAttribute("count", ++count);

              System.out.println(count);

 

二.  Servlet线程安全问题

1.      什么时候会出现线程安全问题

a)        多人同时修改同一份数据时有此问题

b)        局部变量存储在栈里，每个线程有自己的栈帧，没有问题。

c)        成员变量存储在堆里，所有线程共享这个数据，可能有问题。

>多个人同时修改成员变量时会出问题

//黑盒测试，同时点一个功能，看是否会出现并发问题。

//有测试工具可以模拟测试，这就是常说的白盒测试

2.      如何解决线程安全问题

a)        加锁

 public class DemoServlet extends HttpServlet {

       private Doublesalary = 2000.0;

       @Override

       protected voidservice(HttpServletRequest req, HttpServletResponseres)throws ServletException,IOException {

              synchronized (this) {

                     salary += 1000;

                     // 模拟网络延迟

                     try {

                            Thread.sleep(8000);

                     }catch (InterruptedExceptione) {

                            e.printStackTrace();

                     }

                     // 将结果输出给浏览器

                     res.setContentType("text/html;charset=utf-8");

                     PrintWriterout =res.getWriter();

                     out.println(salary);

                     out.close();

              }

       }

}

 

 

//

voidservice(

       ServletRequest req,ServletResponse res

){}

newServletRequestImpl

newServletResponseImpl

区分是否处理HTTP，为了防止以后HTTP需要换为其他协议不便于修改，这样设计后期如果换协议的时候就方便了很多。

//多态为了方便

 

 

//Ctrl+T 看一个类的大纲，找子类

Ctrl+Shift+T

可以搜索jar包或类

Ctrl+o   Outline的快捷键

 

 

 

//实际上Servlet调用的非HTTP的service,之后tomcat会调用HttpServletRequest实现类，HttpServletRequest实现类,tomcat的jar包中就提供了HTTP的实现类。转型之后调用黄色的service，之后在调用doGet()或者是doPost()方法。

一.  JSP&Servlet

如何编写JSP

JSP可以包含:

1.      HTML(html,css,js)

2.      注释

3.      java代码

4.      指令

5.      隐含对象

二.  JSP中的注释

<!-- --> <%-- --%>

三.  JSP页面中的java代码

1.      JSP表达式

a)        语法规则<%= %>

b)        合法内容:变量、变量加运算符组合的表达式、有返回值的方法

c)        转换成Servlet规则:在service()方法中用out.print语句输出该变量、表达式、方法的值

<p>Thesquare root of 5 is <%=Math.sqrt(5)%>c

out.write(“<p>Thesquare root of 5 is”);

out.print(Math.sqrt(5));

out.write(“<p>”);

2.      JSP小脚本

<%

%>

合法内容:能够写在方法里的java代码片段都可以作为小脚本

<%

   String name =request.getParameter(“name”);

   if((name!=null)&&!name.equals(“”)){

%>

<p>Your name is <%=name></p>

<%

}

%}

转换为service代码

String name = request.getParameter(“name”);\

   if((name!=null)&&!name.equals(“”)){

            out.write(“<p>Yourname is”);

            out.print(name);

            out.write(“</p>”);

}

3.      JSP声明

语法规则:

<%!  %>

合法内容:成员属性或成员方法的声明

转译成Servlet时的规则:成为JSP页面转译的Servlet类中成员属性或成员方法。

JSP:

<%!

   public StringgetResult(){}

%>

将代码插入Servlet类中如下:

public class Index_JSP extends JSPBase{

   public StringgetResult(){

                    

}

                   publicvoid service(){

}

}

可以在页面中的任何位置编写

作用:控制页面中可变内容的产生

四.  JSP页面中的指令

语法规则:<%@指令名属性=值%>

常用指令

         page:

         作用:用于导包，设置页面属性

         <%@pageimport=”java.util.*,java.sql.*”  %>

         <%设置response.setContentType()方法的参数-->

         <%@pagecontentType=”image/gif”%>

<%--设置容器读取该文件时的解码-->

<%@pagepageEncoding=”UTF-8”%>

         include:

         作用:在JSP页面转换成Servlet时，能够将其他文件包含进来，可以包含JSP文件也可以是静态的HTML文件，通过该语句能方便的在每个JSP页面中包含导航栏、版权声明、logo等

         语法:<%@includefile = “url”%>

         例如:

         <%@includefile=”header.html”%>

         <%@includefile=”footer.html”%>

         taglib:

         作用:控制JSP在转译成Servlet类时生成的内容。

//JSP页面中的隐含对象

由tomcat创建，自动生成的。

//tomcat已经把线程安全问题处理完成，用到线程安全的地方不是很多。

//Servlet开发动态网页不方便产生了JSP

<!-- --> 注释html

<%-- --%>注释一切

//JSP本质就是Servlet

tomcat会把JSP翻译为Servlet，然后调用Servlet传入request和response，然后做出一个响应。

//pageEncoding

//JSP写contextType来自于Servlet的contentType，默认值为text/html，默认编码和PageEncoding一致

 

JSP翻译为Servlet

1.      tomcat创建一个java文件

2.      翻译为Servlet，脚本不动，声明变量，write标签,print表达式

3.      将java文件编译为class

//pageContext是管理者。

对象名固定

他们可以在JSP上直接使用

 

 

一.  开发模式

1.      Model 1

a)        使用一个组件(Servlet/JSP)

b)        缺点：java和html高耦合度在一起

2.      Model 2(MVC)

a)        使用两个组件协同处理请求

b)        优点：将java和html代码解耦

JSP - - - VIEW

DAO - - - MODEL

Serlvet - - - CONTROLLER

MVC是经典的设计模式，是代码的分层思想;

M(Model):业务层

V(View):视图层，用来显示数据

C(Controller):控制层，用来处理请求，衔接业务和视图

它可以降低代码之间的耦合度，便于团队开发及维护

 

MVC模式是要通过web.xml访问Servlet

 

//转发和重定向

1.      它们的相同点

a)        都是用来解决web组件之间的跳转问题

b)        web组件:Servlet/JSP

2.      它们的区别

使用场景的区别:

什么时候用转发、什么时候用重定向?

//具体的区别

1)      转发的特点

a)        一次请求

b)        地址不变

c)        两个页面可以共用一个request，可以通过request共享数据

d)        只能转发到项目内部的资源

2)      重定向的特点(多用于delete)

a)        两次请求

b)        地址发生改变

c)        两个页面使用两个request，不能通过request共享数据

d)        可以重定向到项目之外的资源

1.      它们的一般使用场景

a)        一般查询从查询Servlet转发到查询JSP

b)        一般增加、修改、删除Servlet后重定向到查询Servlet

 

MVC

model

view

controller

 

//转发和重定向

转发后浏览器地址是不会改变

重定向的浏览器地址是改变的

private IntegercourseId;

       private Stringname;

       private Integer days;

public Integer getId() {

              returncourseId;

       }

       public void setId(Integer courseId) {

              this.courseId =courseId;

       }

实际上EL从后台取到的是get和set方法中的名字，而不是私有属性。

 

//EL同时可以前台提交的数据

//有多套标签库，用哪个导入哪个

<c:foreachvar=”xxx” items=”list”></c:foreach>

 

 

//cookie和session简介

1.     浏览器和服务器是多对一的关系

2.     业务:登录时记录账号，后续的页面显示此账号

3.     使用如下对象存储账号

a)       request:多个请求之间共用账号，不能用request

b)       config:多个Servlet之间共用账号不能用config

c)       context:多个浏览器传入多个账号，互相影响，不能用context

4.     cookie和session才能解决此类问题。

a)       多个对象中的数据可以在多个请求之间共用

b)       在此对象中的数据可以在多个Servlet之间共用

c)       此对象按照浏览器存储数据，将数据彼此分开，互不影响。

1.     cookie和session的区别

a)       cookie:存储在浏览器上，服务器压力小，但容易被篡改

b)       session:存储在服务器上，服务器压力大，但不能被篡改

2.     如何选择

a)       重要的数据存在session中

b)       不重要的数据存在cookie中

//首次访问服务器会创建cookie，传给浏览器，当浏览器再次请求的时候，会自动带上cookie

 

//如何修改Cookie

1.     获取客户端发送的所有Cookie

2.     request.getCookies();

if(name.euqals(11)){}

Cookie生存时间

浏览器一关闭Cookie就没了。

但是浏览器会缓存。

seconds>0浏览器设置

seconds=0 删除Cookie

seconds<0将Cookie保存在内存中

 

//存Cookie

protected voidservice(HttpServletRequest req, HttpServletResponseres) throws ServletException,IOException {

              //接收参数

              Stringcode = req.getParameter("code");

              //将账号存入cookie

              //每个cookie只能保存一份数据，必须是字符串

              Cookiec1 = new Cookie("code",code);

              //修改cookie生存时间，将其存在硬盘上

              不需要通过登录存值，可以获取

              c1.setMaxAge(60000);//单位为S

              //将cookie绑定到response上，在响应时，服务器会自动将其发送给浏览器

              res.addCookie(c1);

       }

//取Cookie

protected voidservice(HttpServletRequest req, HttpServletResponseres) throws ServletException,IOException {

              //获取cookie

              Cookie[]cookies =req.getCookies();

              if(cookies !=null){

                     res.setContentType("utf-8");

                     PrintWriterout =res.getWriter();

                     for(Cookiec : cookies){

                            out.println(c.getName()+","+c.getValue());

                     }

                     out.close();

              }

       }

 

//Cookie编码

Cookie只能保存合法的ASCII字符，如果想要保存中文，需要将中文转换为合法的ASCII字符，即编码

 

cookie学习要点

-如何创建获取cookie

-cookie的生存时间

-如何在cookie中存储中文

-cookie对哪些路径生效

 

在main/login下创建的cookie，只对/main及其下级有效

 

//多次输出cookie会出现

类名@1542

类名@7851

每一个类实例化多次它的hascode是不同的。

 

//Cookie的限制

cookie只能保存少量数据，大约4KB

cookie个数是有限制的

cookie只能保存字符串

 

<%@pagepageEncoding="utf-8"%>

<imgsrc="images/logo.png"alt="logo"class="left"/>

<!-- EL默认从4个隐含对象中取值，分别是 page、request、session、application，不包括

cookie，并且cookie不是隐含对象，若使用EL从cookie中取值，语法如下

cookie.参数名.value，其中单词cookie和value固定，参数名有变化 -->

<span>欢迎您，${cookie.adminCode.value }</span>

<a href="#">[退出]</a>

//首次访问服务器时它会自动给浏览器创建一个session

//响应时服务器将SID存入cookie并发送给浏览器

//再次访问时浏览器会将SID发送给服务器

//session

1.     总结

a)       session是服务器自动创建的对象

b)       SID通过cookie自动传递

 

//session存值

protected voidservice(HttpServletRequest req, HttpServletResponseres) throws ServletException,IOException {

              Stringcode = req.getParameter("code");

              //每个浏览器首次访问服务器时，服务器都会给它创建一个session

              //并将session存入request(地址)

              HttpSessionsession =req.getSession();

              //session对象存储在服务器内存里

              //所以session中可以保存任意类型的数据

              session.setAttribute("code",code);

              //由于本次访问创建了新的session，所以服务器在响应时会自动的将SID存入cookie，并将cookie发送

              //给浏览器

             

}

 

//获取session

       protected voidservice(HttpServletRequest req, HttpServletResponseres) throws ServletException,IOException {

             

              //获取session，此session是登录时服务器创建的，在此请求中浏览器通过cookie发送了

              //SID，服务器依据SID找到了那么session。

              HttpSessionsession =req.getSession();

              Stringcode = (String)session.getAttribute("code");

              res.setContentType("text/html;charset=utf-8");

              PrintWriterout =res.getWriter();

              out.println(code);

              out.close();

       }

//Session.invalidate();

销毁session，退出或者注销的时候会销毁session。

 

//Session超时

web服务器缺省的超时时间限制:一般是30分钟。

<!-- 修改Session的超时时间，该时间默认值是30分钟，当tomcat检测到该用户超过这个时间没有做任何动作时

  将它的session销毁 -->

  <session-config>

     <session-timeout>30</session-timeout>

  </session-config>

 

//URL重写

浏览器急用Cookie。

可以通过URL重写这样的方式来发送SessionId

 

总结:

1.     如何获取session，如何存储数据

2.     如何销毁session

3.     session的超时如何设置

4.     cookie被禁用时如何使用session。

 

//Filter

 

 

 

 

//listener(了解)