JavaWeb学习笔记

1.Web应用程序

可以提供浏览器访问的程序

html/b.html多个web资源，这些web资源可以被外界访问，对外界提供服务。

我们能访问到的任何一个页面或则资源都是再某个计算机上。

URL请求服务

这个统一的web资源会被放在同一个文件夹下，web应用程序-->tomcat：服务器

一个web应用由多部份组成（静态web，动态web）

Html，css，js

Jsp,servlet

Java程序

Jar包

Properties配置文件

Web应用程序编写完后，想要提供外界访问：需要一个服务器来统一管理。

1.2静态web

.html,.htm。都是网页后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取

静态web一次请求过程

1.在页面上client发出一次请求

2.在web service接受请求

3.web service将index.html返回给client

缺点：页面无法动态更新，所有用户看到的都是同一个用户

轮播图：点击特效：伪动图技术：javascript（实际开发用使用最多）/VBScript

他无法与数据库交互（数据无法持久化，用户无法交互）

1.3动态web

页面会展示动态：web页面的展示效果因人而异。

缺点：

假如服务器的动态web资源出现错误。我们需要重新编写我们的后台程序，重新发布。（称为停机维护）

优点：

页面可以动态更新，所有用户看到的不是同一个页面

它可以与数据库交互（持久化：注册账户，商品，用户信息等）。

新手村：--魔鬼训练（分析原理，看源码）--》pk场

2.web服务器

2.1技术讲解

了解 ASP

（国内最早流行的）在html中嵌入了VB脚本，ASP+COM，在ＡＳＰ技术中写ｊａｖａ代码需要用<%这里面写java代码%>

PHP：

开发速度很快，功能很强大，跨平台，代码很简单。（大部分网站都用PHP）。劣势就是无法承载大访问量的情况，存在局限性。

JSP/Servlet：

sun公司主推的B/S架构（C/S，客户端和服务器，B/S浏览器和服务器）基于java语言的（所有的大公司或则一些开源的组件都是用java写的）

可以承载三高问题带来的影响（三高：高并发，高可用性，高性能）语法很像ASP。

2.2web服务器

服务器的作用：是一种被动的操作，用来处理一些用户的请求，给用户一些响应信息。

IIS（微软的）

ASP...windows中自带的

3.Tomcat

Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。

下载Tomc装or解压

2.了解配置文件及目录

3.这个东西的作用

3.1下载Tomcat

解压到当前文件夹。其中文件夹的作用：

bin//启动，关闭脚本等。

conf//配置

lib//依赖包，jar包

logs//日志

webapps//存放网站

work//工作目录

开启：在lib中使用start.bat打开Tomcat服务

关闭：使用shutdown进行关闭。

测试：就可以使用localhost：8080进行访问。

可能遇到的问题：

1.java环境变量没有配置

2.闪退问题：需要配置兼容性

3.乱码问题：配置文件中设置

3.2配置

1.服务器核心配置文件：server.xml

修改了配置文件后需要重启生效。

2.更改主机名

先在Tomcat配置文件中的<Host>//修改主机名.默认的主机名为localhost==本机ip

再到 C:\Windows\System32\drivers\etc\hosts

在最底下添加一个

127.0.0.1 主机名

1.主机名==2.主机名（保持一致）

一些常用的默认端口号：

tomcat的默认端口号为：8080

mysql：3306

http：80

https：443

默认网站应用存放的位置为：webapps

3.4发布一个web网站

将自己写的网站，放在服务器tomcat中，指定web应用的文件夹webapps下，就可以访问了。

网站应该有结构

--webapps:Tomcat服务器的web目录
    -ROOT
    -kuangstudy:网站的目录名
        -class:java程序
        -lib:web应用所依赖的jar包
        -web.xml：网站配置文件
    -index.xml默认页面
    -static
        -css
            -style.css
        -js
        -img
        ....

4.HTTP

超文本传输协议//超文本包括图片，音频，视频，定位，地图....

Https:安全的

端口443

4.1Http请求

请求是：client->server

Request Method: GET//请求类型
Status Code: 200 OK//请=状态码
Remote Address: 14.215.177.39:443//远程地址

响应：server->client

1.请求行

请求方式:get,post,head,put。

get：请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但是高效。

post：请求能够携带的参数没有限制，大小不限制，不会在浏览器的URL地址栏显示数据内容，安全。

2.消息头

Accept:告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式，GBK，UTF-8
Accept-Language：告诉浏览器，它的语言环境
Cache-Control:缓存数据
Connection：告诉浏览器，请求完成时是断开还是保持连接
HOST：主机...

4.2响应

1.响应体

Accept:告诉浏览器，它所支持的数据类型
Accept-Encoding：支持哪种编码格式，GBK，UTF-8
Accept-Language：告诉浏览器，它的语言环境
Cache-Control:缓存数据
Connection：告诉浏览器，请求完成时是断开还是保持连接
HOST：主机...
Refresh:告诉客户端多久刷新一次
Location：让网页重新定位

2.响应状态码（重点）

200：请求相应成功200

3xx：请求重定向

重定向：你重新到我给你的新位置

4xx：找不到资源404

资源不存在

5xx：服务器代码错误！500

502：网关错误

5.Maven

我为什么要学这个技术？

1.在javaweb开发中，需要使用大量的jar包，我们手动去导入

2.如何能够让一个东西自动帮我们导入和配置这些jar包

由此：Maven诞生了？（他只是一个架构管理工具）

5.1Maven项目架构管理工具

我们目前用它来就是为了方便我们导入jar包！

Maven的核心思想：约定大于配置

有约束就不要去违反

Maven会规定好你该如何去编写java代码，必须按照这个规范来

5.2下载Maven

Maven – Download Apache Maven

建议：电脑上的所有环境都放在一个文件夹下面。

5.3配置环境变量

在我们的系统环境变量中

配置如下：

M2_HOME maven目录下的bin目录

MAVEN_HOME maven的目录

在系统的path中配置MAVEN_HOME// %MAVEN_HOME%\bin

5.4修改镜像

镜像：加速我们的下载

5.5本地仓库

建立仓库：在本地的仓库

远程仓库。

现在自己的MAVEN目录下建立maven-repo

在找到配置文件中的<localRepository>刚才建立的目录路径<localRepository>

 <mirrors>
      <mirror>
         <id>nexus-aliyun</id>
         <mirrorOf>*</mirrorOf>
         <name>Nexus aliyun</name>                                                               <url>http://maven.aliyun.com/nexus/content/groups/public</url>
      </mirror> 
 </mirrors>

5.6在IDEA中使用MAVEN

1.创建一个mavenapp项目

2.com.liu

javaweb_maven01

5.7文件夹功能

第一种方式：右击文件夹-》Mark Directory as-》选择标记项目类型

5.8Tomcat配置

4.4

Tomcat启动的端口号

4.5

警告：没有一个artifacts。没有一个项目。我们必须要创建一个项目

4.6在这个选项卡下面添加一个artifacts。添加第一个

为什么会有警告问题：我们访问网站，需要指定一个文件夹名称。我们需要手工配置且是必须的

4.7

选写；不写默认路劲为localhost:8080,如果写了一个路径如text。则访问需要localhost:8080/text。

这个过程叫做虚拟映射路径

5.9 pom配置文件

pom.xml是maven的核心配置文件

maven由于约定大于配置。//我们之后可能会遇到我们写的配置文件无法被导出或则生效 的问题，解决方案：

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>

5.10解决遇到的问题

1.Maven3.6.2版本问题

IDEA查看日志在help选项卡中的show login in explorer//显示日志

2.Tomcat闪退

3.IDEA中每次都要重复配置Maven

4.Maven项目中Tomcat无法配置

6.Servlet

Servlet和JSP的工作模式

Servlet：负责业务逻辑处理

JSP：输出页面

转发：

• Servlet转发数据给JSP

• JSP转发数据给JSP

1.@WebServlet("/send/tt")路径问题

这里配置的路径，如果需要转发页面的话需要使用绝对路径而不是相对路径。

情况1：

req.getRequestDispatcher("Login.jsp").forward(req, resp);

这种情况下，访问/send/tt的时候，java会在/send/tt路径下寻找Login.jsp。会出现找不到Login.jsp文件的情况。

解决：写绝对路径

req.getRequestDispatcher("/Login.jsp").forward(req, resp);

解决找不到css文件：写根路径

<link href="//项目名称/css/xxx.css" rel="stylesheet">

如果这样写项目名称不够灵活，一般使用获取path路径替换项目名称

<% String path=request.getContextpath();%>
<link href="<%=path%>/css/xxx.css" rel="stylesheet">

Tomcat发布路径问题

tomcat的发布路径不会影响servlet的请求路径但是会影响servlet程序里面的资源路径。

6.1Servlet简介：

Servlet是html和web前端数据交互的一个中间件

编写一个类，实现Serblet接口

把开发好的java类部署到web服务器中

把实现了Servlet接口的java程序叫做，Servlet

对于客户请求Tomcat只会创建一次Servlet对象。

6.2HelloServlet

1.新建一个空MAVEN项目

File->New->project->Maven-Next-Finish

2.建立web项目

右击刚才创建的项目-New-Module->

 

Next-finish

此时的目录结构是这个样子的，到这里我们的基本项目已经创建好了。

现在我们需要配置Tomcat。

点击之后是这个样子的，然后点击左上角的“+”号添加部署方式，一定不要在Templates下面直接选

我们第一个hello sevlet就选择发布本地

然后是这个样子的

最后点击Deployment选择发布路径,HTTP可执行的是war包。

然后选择发布建立的web app项目名称的war exploded，我这里是sun2:war exploded，然后OK就完事

现在我们就直接启动Tomcat 就可以了。

我们的Hello Servlet就完成了

最后分析一下整个web App的工作流程

6.2.1页面请求路径问题

Tomcat的项目发布路径不会影响Servlet的请求接收，但是会影响JSP或前段请求的请求路径。所以一般会在请求路径前添加${pageContext.request.contextPath}

解决方案两种

第一种：

<%--这里的action路径不添加/表示相对路径--%>
<form action="helloform" method="post">
    <p>账号：<input type="text" name="name"></p>
    <p>密码：<input type="password" name="password"></p>
    <input type="submit" value="提交">
</form>

第二种

<%--添加${pageContext.request.contextPath}表示当前路径--%>
<%--<%=request.getContextPath()%>--%>
<form action="${pageContext.request.contextPath}/helloform" method="post">
    <p>账号：<input type="text" name="name"></p>
    <p>密码：<input type="password" name="password"></p>
    <input type="submit" value="提交">
</form>

6.2.2Servlet调用方法顺序问题

如果HttpServlet没有重写父类Servlet的service方法就会调用父类的方法。父类service会判断是什么方式触发了请求会根据不同的请求调用不同的方法来处理。

如果重写了service方法就会直接执行重写后的service方法。

6.2.3Servlet两种映射方式

1.web.xml配置方式

<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>com.liu.Servlet.Control.LoginControl</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>

2.注解方式

@WebServlet(urlPatterns = "/helloform")

参数urlPatterns映射路径

参数value和urlPattern效果一样

value属性：如果没有书写其他的属性，那么value属性这个单词可以省略不写。@WebServlet( "/helloform")

既然有注解方式为什么还要用xml配置呢？

如果这个Servlet类是第三方提供的class文件，我们就不能够修改这个class文件，只能使用xml配置方式使用这个class文件作为servlet程序。

6.2.4Servlet生命周期

• Servlet 初始化后调用 init () 方法。

• Servlet 调用 service() 方法来处理客户端的请求。

• Servlet 销毁前调用 destroy() 方法。

• 最后，Servlet 是由 JVM 的垃圾回收器进行垃圾回收的。

Servlet生命周期菜鸟教程：Servlet 生命周期 | 菜鸟教程

在浏览器中第一次访问会初始化这个servlet程序，之后的访问不会在重复调用init（）方法。

   public LoginControl(){
        System.out.println("LoginControl（）构造方法被调用");
    }
​
    @Override
    public void init() throws ServletException {
        System.out.println("init()初始化方法被调用");
    }
​
    @Override
    public void destroy() {
        System.out.println("destroy()方法被调用");
    }

LoginControl（）构造方法被调用 init()初始化方法被调用

6.2.5web.xml配置初始化参数

<servlet>
    <servlet-name>helloform</servlet-name>
    <servlet-class>com.liu.Servlet.Control.LoginControl</servlet-class>
    <init-param>
      <param-name>nick</param-name>
      <param-value>汤姆</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>helloform</servlet-name>
    <url-pattern>/helloform</url-pattern>
  </servlet-mapping>

配置了一个名为nick值为汤姆的参数值.

注：这种配置方式只能被该servlet读取，其他的都读取不到。

获取参数：

System.out.println(this.getInitParameter("nick"));

配置全局初始化参数：

<context-param>
  <param-name>url</param-name>
  <param-value>mysql:jdbc:///sys</param-value>
</context-param>

获取全局初始化参数：

System.out.println(getServletContext().getInitParameter("url"));

6.3ServletContext

servlet上下文

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，他代表当前的web应用。

6.3.1属性(attribute)

属性是在后台servlet中设置并获取的 ， 用方法setAttribute(name, o) 和 getAttribute(name)实现

1.共享数据

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext servletContext = this.getServletContext();
    String username="liulang";
    servletContext.setAttribute("username",username);//往username里面放一个值
  }

获取数据

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.setCharacterEncoding("utf-8");
    resp.setContentType("text/html");
    ServletContext servletContext = this.getServletContext();
    String username = (String) servletContext.getAttribute("username");//取出username里面的值
    resp.getWriter().write(username);
  }

HTTP content-type

Content-Type（内容类型），一般是指网页中存在的 Content-Type，用于定义网络文件的类型和网页的编码，决定浏览器将以什么形式、什么编码读取这个文件，这就是经常看到一些 PHP 网页点击的结果却是下载一个文件或一张图片的原因。

Content-Type 标头告诉客户端实际返回的内容的内容类型。

2.初始化页面参数

<!--设置初始化参数-->
  <context-param>
    <param-name>url</param-name>//名
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>//值
  </context-param>

3.请求转发

进行请求转发后，你在url上面的路径不会变，但是在方法里面处理完后，页面会调用到被转发的页面

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();//获取servlet上下文
    RequestDispatcher requestDispatcher = context.getRequestDispatcher("/get_context");//请求转发,传入需要转发的地址
    requestDispatcher.forward(req, resp);//调用forward实现请求转发，传入req,resp
  }

这里我请求的是fwd页面，而获取的内容确实init页面的内容，url地址栏也没有变为init页面但内容是init页面内容，这就是转发。

*请求转发和重定向的区别

转发:

转发过程是A想要访问C的内容，但是A又直接获取不到C的内容，他就向B发出请求，然后B没有C的内容，然后B就代替A去请求到了C的内容以后，再返回给A

重定向:

重定向是A向B发出一个请求，但是B没有A需要的内容，B告诉A，C的地址，然后A重新向C发出请求。

4.读取配置资源

Properties

Properties.load(资源路径);

classpath//类路径

在java目录下新建properties

在resources目录下新建properties

发现：都会被打包到同一个路径下：classes；我们成为类路径classpath.

6.4HttpServletRespose

web服务器接收到客户端的Http请求，针对这个请求，分别创建一个代表请求的HTTPServletRequest和HttpsServletResponse；

• 获取客户端请求过来的参数使用HTTPServletRequest

• 给客户端响应一些信息使用HTTPServletResponse

1、简单分类

负责向浏览器发送消息的方法

getOutputStream、getWriter

负责想浏览器发送响应头的方法

void setCharacterEndcoding(String var1)

vpod setContentLength(int var1)

void setContentLengthLong(long var1)

void setContentType(String var1)

2、常见应用

1.下载文件

步骤：获取下载文件的路径，获取下载文件的名称，设置想办法让浏览器能够支持我们下载需要的东西，获取下载文件的输入流，创建缓冲区，获取OutputStream对象，将fileOutputStream流写入到buffer缓冲区，使用OutputStream将缓冲区中的数据输出到客户端。

2.验证码功能

前端实现：jsp判断

后端实现：需要用到java的图片类，生成一个图片。

3.实现重定向

一个web资源收到客户端请求，会通知客户端去访问另外一个web资源，这个过程叫做重定向。

应用场景：用户登录

 @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        resp.setCharacterEncoding("utf-8");
//重定向路径
        resp.sendRedirect("/init");
    }

使用重定向对页面进行请求的时候我们可以看到url地址也发生了变化，而转发的地址栏不会发生变化

重定向的原理等同于resp.setHeader("Location","/init");resp.setStatus(302);

简单写一下登录：

1.这是index.jsp页面，有一个form表单.

<body>
<%--这里提交的路径，需要寻找到项目的路径--%>
<%--${pageContext.request.contextPath}代表当前项目--%>
<form action="${pageContext.request.contextPath}/login">
    <p>账号：<input type="text" name="username"></p>
    <p>密码：<input type="password" name="password"></p>
    <input type="submit">
</form>
</body>

2.在写一个java类实现表单登录后的重定向

@Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException, ServletException {
        resp.setCharacterEncoding("utf-8");
        System.out.println("进入该请求");
//        处理请求
//        getParameter获取参数
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println("username:"+username+"\npassword:"+password);
        //进行重定向
        resp.sendRedirect("/success.jsp");
    }

3.然后在写一个登录进去的页面success.jsp

<body>
<h1>登陆成功!</h1>
</body>

4.web.xml配置类

<servlet>
    <servlet-name>login</servlet-name>
    <servlet-class>com.liu.Servlet.Request_test</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>login</servlet-name>
    <url-pattern>/login</url-pattern>
  </servlet-mapping>

5.启动tomcat

点击提交跳转到success.jsp

我们在form表单中输入了账号和密码，可以在后端获取这两个参数

String username = req.getParameter("username");
String password = req.getParameter("password");
System.out.println("username:"+username+"\npassword:"+password);

6.5HttpServletRequest

HttpServletRequest代表客户端的请求，用户可以通过http协议访问服务器，http请求中的所有信息都会被封装到HttpServletRequest，通过HttpServletRequest的方法，我们可以获得客户端的所有信息。

1.获取前端传递的参数

 String username = req.getParameter("username");
    String password = req.getParameter("password");
    String[] hoopies = req.getParameterValues("hoppy");
//转发页面
this.getServletContext().getRequestDispatcher(req.getContextPath()+"/success.jsp").forward(req,resp);
//注意！注意！注意！req.getContextPath()+"/success.jsp")这里的斜杠代表当前目录。
//req.getContextPath()获取当前目录的路径

@Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    req.setCharacterEncoding("utf-8");
    String username = req.getParameter("username");
    String password = req.getParameter("password");
    String[] hoopies = req.getParameterValues("hoppy");
    System.out.println("=====================");
    System.out.println(username);
    System.out.println(password);
    System.out.println(Arrays.toString(hoopies));
    System.out.println("=====================");
    resp.setCharacterEncoding("utf-8");
    this.getServletContext().getRequestDispatcher("/success.jsp").forward(req,resp);
  }

2.请求转发

6.6setAttribute()

设置一个属性值可以多个Servlet程序共享。在JSP或Servlet程序都可以使用

设置一个Name属性，值可以死一个复杂对象

req.setAttribute("Name",对象);

获取属性：获取出来的属性是一个Object对象，如果自己是知道这个属性的类型，可以进行强制类型转换

Object name = req.getAttribute("Name");
//String name=String.valueOf(req.getAttribute("Name");)

7.Cookie、Session

7.1会话

一次会话相当于一个浏览器的的打开到结束有效！！！

会话：用户打开浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程称之为会话。

有状态会话：一个同学来过教室了，下次再来教室，我们知道这个同学曾经来过了。成为有状态会话。

你怎么能够证明你是三峡学院的学生。

你 三峡学院

1.发票 学校给的发票

2.学校登记 学校标记你入学了

一个网站怎样证明你来过了？

客户端 服务器

1.服务器给客户端一个信件，下次再访问待上信件就可以了

2.服务器登记你来过了，然后下来再来直接匹配你

7.2保存会话的两种技术

cookie：

• 客户端技术 （响应，请求）

 PrintWriter out = resp.getWriter();
        //getCookies返回一个数组说明cookie可以存在多个
        Cookie[] cookies = req.getCookies();
​
        if (cookies != null) {
​
            for (Cookie cookie : cookies) {
                if (cookie.getName().equals("LAST_TIME")) {
                    out.write("你上次访问本站的时间：" + cookie.getValue());
                }
​
            }
        } else {
            out.write("这是你第一次访问本站!");
​
        }
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd:hh:mm:ss");
        Cookie cookie = new Cookie("LAST_TIME", simpleDateFormat.format(new Date()));
        resp.addCookie(cookie);

如果用户第一次访问这个地址就创建一个cookie并提示它第一次访问本站。如果不是第一次访问本站就输出上一次访问的具体时间并更新最近一次访问时间。

• 一个cookie只能保存一个信息

• 一个web站点可以给浏览器发送多个cookie，每个站点最多存放20个，

• cookie存在大小限制为4kb

• 300个cookie浏览器上限

删除cookie

• 不设置有效期，关闭浏览器自动失效

• 设置有效期为0

• SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd:hh:mm:ss");
  Cookie cookie = new Cookie("LAST_TIME", simpleDateFormat.format(new Date()));
  cookie.setMaxAge(0);//设置有效期为0
  resp.addCookie(cookie);//响应回去后立马过期

session

• 服务器技术，利用这个技术，可以保存用户的会话信息，我们就可以把信息或则数据放在session中。

常见：网站登录后，下次在访问就不用在登录了。

7.4Session（重点）

什么是Session：

• 服务器会为每一个用户创建一个session

• 一个session独占一个浏览器，只要浏览器没有关闭， 这个session就存在

• 用户登录之后，整个网站他都可以访问。保存用户的信息，保存购物车的信息

//获取Session
HttpSession session = req.getSession();
//往Session里面存放一个属性
session.setAttribute("Stu",new Student("xiaosheng","男",22));
//获取sessionID
String id = session.getId();
if (session.isNew()){
    resp.getWriter().write("Session创建成功,id："+id);
}
else {
    resp.getWriter().write("Session已经存在了,id:"+id);
}

在第一个Servlet程序session中存放了一个Stu属性

HttpSession session = req.getSession();
Student name =(Student) session.getAttribute("Stu");
System.out.println(name);

在第二个Servlet程序中获取session的Stu属性

输出：Student{name='xiaosheng', sex='男', age=22}

注销Session

手动注销

//获取session
HttpSession session = req.getSession();
//移除session中指定的属性值
session.removeAttribute("Stu");
//注销session.这样session的ID就会消失，但是会立即重新创建一个SessionID
session.invalidate();

设置其自动失效时间

  <session-config>
<!--    设置1分钟后session自动失效，分钟为单位-->
    <session-timeout>1</session-timeout>
  </session-config>

Session的持久化

不仅session需要持久化，session里面的对象也需要持久化。

1.要完成session持久化，存放在session里面的对象必须要实现java.io.Serializable接口

class User implement Serializable

2.Tomcat提供了两个实现类：管理session的持久化

SessionManage

(1)StandardManager 会把session保存在tomcat的目录中 tomcat/work/Catalina/hostname/项目名/SESSION.ser

没有实现重启服务器我们依旧处于登录状态的原因：（1）User没有实现S俄日阿里咋办了接口（2）在IDEA中停止项目类似于电脑断电操作，StandardManager来不及持久化。也许需要正常停止Tomcat才能完成持久化。shutdown.bat

(2)PersistenManager

就算是没有正常关闭他也会完成持久化操作

session和cookie的区别：

• Cookie是把用户的数据写给用户的浏览器，客户端保存

• Session把用户的数据写到用户独占的Session中，服务端保存（保存重要的信息，减少服务器资源的浪费）

• Session 对象由服务创建

• cookie在浏览器和服务端之间来回传递

• cookie和session一一对应

• 服务端在创建session的时候，同时创建了一个cookie，响应里面就包含这个cookie

• sessionID（一串编码），cookieID（键值对，JSESSIONID->数字）

使用场景：

• 保存一个登录用户的信息；

• 购物车信息

• 在整个项目中经常会使用的数据存放在Session中

当调用req.getSesson,Session有可能会被创建。第一次调用getSession的话，Session会被创建，后续调用的话只要Session没有被删除就不会创建Session。

JSESSIONID=70CB2BD6D613F20BECD8D843208504C6

JSESSIONID=70CB2BD6D613F20BECD8D843208504C6

8.EL表达式

EL表达式格式:${属性名},EL表达式不仅可以获取属性还可以写一些算数运算和逻辑运算

EL表达式会从request中获取属性

如果JSP使用EL表达式无效在头部添加：

<--添加这句话防止禁用EL表达式-->
<%@page isELIgnored="false" %>

req.setAttribute("Stu",new Student("小明","男",20));
req.setAttribute("name","xiaomi");
Book book1 = new Book(1, "西游记", "吴承恩", 35.5);
Book book2 = new Book(2, "红楼梦", "曹雪芹", 35.5);
Book book3 = new Book(3, "三国演义", "罗贯中", 35.5);
Book book4 = new Book(5, "水浒传", "施耐庵", 35.5);
ArrayList<Book> books = new ArrayList<>();//new后面<>不写类型它会自己判断
books.add(book1);
books.add(book2);
books.add(book3);
books.add(book4);
req.setAttribute("Books",books);

获取属性：

${name}<br>
${Stu.name}<--${Stu.getName()}-->
${Books[0].getId()}

输出:xiaoming

小明 1

使用Stu.name最终还是调用的是Stu.getName()方法获取的name

EL表达式的优点

• 自动转换类型：EL得到某个数据时可以自动转换类型。对于类型的限制更加宽松，适应更广的数据类型。

• 有容错的能力：用EL表达式获取一个没有设置的值不会报错，但是Stu.没有的属性。这种情况会报错，因为它获取一个空指针，然后在空指针中去寻找属性会报错。

• 相比较在JSP中嵌入Java代码，EL更简单。

EL表达式获取param参数

${param.nick}

浏览器输出nick参数的值

EL表达式的缺陷：无法进行遍历、无法完成条件分支

9.JSTL

为了弥补EL表达式的这种缺陷，引入jstl标准标签库

分为:

• core 核心标签库 ：遍历c:forEach

• fmt 格式化标签库

• fn 函数标签库

• sql

• xml

使用jstl标签需要先导入依赖包：

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>
​

还需要导入一个标准库，在jsp头中添加

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<--添加这句话防止禁用EL表达式-->
<%@page isELIgnored="false" %>

使用jstl表达式来遍历books

<c:forEach items="${Books}" var="book">
    ${book.id},${book.name}，${book.author}，${book.pirce}<br>
</c:forEach>

输出格式：

---

1,西游记，吴承恩，35.5 2,红楼梦，曹雪芹，35.5 3,三国演义，罗贯中，35.5 5,水浒传，施耐庵，35.5

forEach属性：

step：步长；

begin：开始下标

end：结束下标

10Filter

如果过滤器全用xml配置，则是最上面的过滤器先执行，后结束。

如果是用注解方式的话则是

jstl单分支标签

<c:if test="${book.pirce>35}">贵</c:if>

jstl多分支标签

<c:choose>
    <c:when test="${book.pirce>35}">贵</c:when>
    <c:when test="${book.pirce<25}">便宜</c:when>
    <c:otherwise>一般般</c:otherwise>
</c:choose>

时间格式转换

<fmt:formatDate value="${Date}" pattern="yyyy年MM月dd日 hh时mm分ss秒"></fmt:formatDate>

c:set

<%--var是属性名，value是值,scope是作用域--%>
<c:set var="name" value="王五" scope="request"/>

11.AJAX

一、什么是Ajax？

• Ajax本质上是一个浏览器端的技术。

• 异步刷新技术，用来在当前页面内响应不同的请求内容。

• 相当于js修改页面文档结构，只不过数据变成动态的；之前js修改页面文档DOM是静态的，数据不可以随意修改。

基本格式：

 $.ajax({
                url: "/b_login",
                type: "post",
                data: $("#form1").serialize(),
                success: function (data) {
                    if (data === "success")
                        location.href = "/t_book";
                    else if (data === "no")
                        alert("没有找到该账号");
                    else if (data === "error")
                        alert("密码错误");
                    else
                        alert("操作失败")
                },
                error: function () {
                    alert("ajax执行失败");
                }
            })

属性:

• url,请求路径，想那个路径发出请求

• type：请求方式，post，get

• dataType:返回数据的预期类型

• data：携带数据

• success：ajax执行成功的代码

• error：ajax执行失败的代码

12.监听器

事件处理：发生了某个事件Event，然后我们就执行相应的处理，Handler。

interface ServletContextListener{
    ServletContextCreate();//应用程序创建
        ServletContextDestory();//应用程序停止
}

interface HttpSessionListener{
    HttpSessionCreate()//session被创建
    HttpSessionDestory()//session销毁
}

interface ServletRequestListener{
    void requestDestoryed(ServletRequestEvent sre){}
    void requestInitialized(servletRequestEvent sre){}
}

1.监听 创建 销毁

2.监听 属性的创建 销毁

application.setAttributer("xxx",obj);

3.感知型监听器

监听自己（任何对象）有没有被加入到session