Javaweb

未172

已于 2022-07-15 11:29:28 修改

阅读量627

点赞数

分类专栏：学习文章标签： java tomcat

于 2022-07-15 11:29:21 首次发布

本文链接：https://blog.csdn.net/yueliangzy/article/details/125800961

版权

学习专栏收录该内容

28 篇文章 0 订阅

订阅专栏

Javaweb

一、tomcat

tomcat是一种web服务器，提供jsp和servlet的支持。他是一种轻量级的Javaweb容器（服务器），也是当时应用最广的javaweb服务器（免费）。

1、javaweb：

javaweb是指所有通过java语言编写的可以通过浏览器访问的程序的总成，叫做javaweb。

2、端口号

mysql：3306

tomcat：8080

http默认的端口号：80

3、

部署方法：

只需要把 web 工程的目录拷贝到 Tomcat 的 webapps 目录下即可。如何访问 Tomcat 下的 web 工程。只需要在浏览器中输入访问地址格式如下： http://ip:port/工程名/目录下/文件名
找到 Tomcat 下的 conf 目录\Catalina\localhost\ 下,创建如下的配置文件。abc.xml 配置文件内容如下：

 <Context path="/abc" docBase="E:\book" />

访问这个工程的路径如下:http://ip:port/abc/ 就表示访问 E:\book 目录

创建WEB

1、首先先创建java普通的项目

2、右键，add-frame。。。，勾选第一项

3、在web-inf创建lib存放jar包，

src：存放自己编写的源代码

web目录主要用来存放web工程的资源文件

web-inf目录是一个受服务器保护的目录，浏览器无法直接访问到此目录的内容。

改成下面这个以后，热部署之后，在idea上改了之后，浏览器刷新，就能直接改上去。

二、Servlet

1、servlet是javaee规范之一。规范就是接口。

servlet是javaweb三大组件之一，三大组件分别是：servlet程序、filter过滤器，listener监听器。

servlet是运行在服务器上的一个java小程序。它可以接受客户端发送过来的请求，并相应数据给客户端。

2、实现servlet

写一个类实现servlet接口----》实现service方法，处理请求，并响应数据-----》到web。xml中去配置servlet的访问地址，

idea如何实现Servlet接口

project structure ---> Libraries ---> 点击加号+ ----> 找到安装tomcat的目录，再找lib下的servlet-api.jar 包

在 IDEA 创建WEB项目之后，打印出的日志中总是出现一行警告信息：

12-May-2018 15:52:30.692 警告 [RMI TCP Connection(3)-127.0.0.1] org.apache.tomcat.util.descriptor.web.WebXml.setVersion Unknown version string [4.0].Default version will be used.

原因：当前Tomcat8.5不支持Web4.0版本，那要么降低Web版本，要么提高Tomcat版本就好了。

查看子类快捷键-ctrl+H

3、Servlet-config介绍

servletconfig可以获得程序别名，可以获得servlet-name的值
获取初始化参数，在web.xml里面。
获取servletcontext对象。
servlet程序和servletconfig对象都是由tomcat负责创建的，我们负责使用。
servlet程序默认第一次访问就创建，servletconfig是每一个servlet程序创建的时候，就创建一个对应的servletconfig程序对象。

4、servletcontext

是一个接口哦

一个web工程，只有一个servletcontext实例。

servletcontext对象是一个域对象

servlet是在web工程部署启动的时候创建，在web工程停止的时候销毁。

----有四个作用。

1、获取 web.xml 中配置的上下文参数 context-param

2、获取当前的工程路径，格式: /工程路径

3、获取工程部署后在服务器硬盘上的绝对路径

4、像 Map 一样存取数据

http协议

1、协议：协议是指双方或者多方，互相约定好，大家都需要遵守的规则，叫做协议

2、http协议：就是指客户端和服务器之间通信的时候，发送的数据，需要遵守的规则，叫做http协议。

http协议的数据又叫做报文。

3、请求http协议的格式

客户端给服务器发送数据叫做请求。

4、请求的转发

请求转发是服务器受到请求之后，从一个资源跳转到另一个资源。

三、jqueue

text对于她接触到的内容都是文本。

attr() 可以设置和获取属性的值，不推荐操作 checked、readOnly、selected、disabled 等等 attr 方法还可以操作非标准的属性。比如自定义属性：abc,bbj ，会返回checked，啥的。

prop() 可以设置和获取属性的值,只推荐操作 checked、readOnly、selected、disabled 等等，不对的时候返回false。

appendTo() a.appendTo(b) 把 a 插入到 b 子元素末尾，成为最后一个子元素

prependTo() a.prependTo(b) 把 a 插到 b 所有子元素前面，成为第一个子元素

jquery事件操作

1、事件绑定

click() 它可以绑定单击事件，以及触发单击事件

mouseover() 鼠标移入事件 mouseout() 鼠标移出事件

bind() 可以给元素一次性绑定一个或多个事件。

one() 使用上跟 bind 一样。但是 one 方法绑定的事件只会响应一次。每一个事件之相应一次

unbind() 跟 bind 方法相反的操作，解除事件的绑定。

live() 也是用来绑定事件。它可以用来绑定选择器匹配的所有元素的事件。哪怕这个元素是后面动态创建出来的也有效。

2、什么是事件的冒泡？

事件的冒泡是指，父子元素同时监听同一个事件。当触发子元素的事件的时候，同一个事件也被传递到了父元素的事件里去响应。

3、javaScript 事件对象

事件对象，是封装有触发的事件信息的一个 javascript 对象。我们重点关心的是怎么拿到这个 javascript 的事件对象。以及使用。

如何获取呢 javascript 事件对象呢？

在给元素绑定事件的时候，在事件的 function( event ) 参数列表中添加一个参数，这个参数名，我们习惯取名为 event。这个 event 就是 javascript 传递参事件处理函数的事件对象。

5、书城项目

javaee三层架构：web层//、视图展现层===service业务层===dao持久层。

数据库：mysql、oracle、db2，sqlserver。。。。

从客户端发送-----web层获取请求参数，封装成bean对象-----调用service层处理业务---响应数据给客户端。-----service业务层-----调用持久层保存到数据库。-------dao持久层只负责跟数据库交互。CRUD操作。增删改查操作。

上面是要学习的东西。

create table t_user(id int primary key auto_increment,username varchar(20) not null unique,password varchar(32) not null,email varchar(200));

中间看不懂jdbc，所以过来看一下，jdbc。

诶呀，9月前还能学完不？

学完jdbc了。7/4

四、过滤器

1、Filter过滤器是javaweb的三大组件之一。三大组件分别是：servlet程序、listener监听器、filter过滤器

2、filter过滤器是javaee的规范，也就是接口

3、filter过滤器他的作用是：拦截请求，过滤响应

filter过滤器：来检查用户是否右登录

也就是检查权限，有权限，让程序默认执行，没有权限就让他跳到登录界面。不允许其访问。

% Object user = session.getAttribute("user"); // 如果等于 null，说明还没有登录 if (user == null) { request.getRequestDispatcher("/login.jsp").forward(request,response); return; }

FilterConfig 类

见名知义，它是 Filter 过滤器的配置文件类。 Tomcat 每次创建 Filter 的时候，也会同时创建一个 FilterConfig 类，这里包含了 Filter 配置文件的配置信息。

FilterConfig 类的作用是获取 filter 过滤器的配置内容

1、获取 Filter 的名称 filter-name 的内容

2、获取在 Filter 中配置的 init-param 初始化参数

3、获取 ServletContext 对象

6、Filter 的拦截路径

--精确匹配

/target.jsp

以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/target.jsp

--目录匹配

/admin/* 以上配置的路径，表示请求地址必须为：http://ip:port/工程路径/admin/*

--后缀名匹配

*.html 以上配置的路径，表示请求地址必须以.html 结尾才会拦截到

*.do 以上配置的路径，表示请求地址必须以.do 结尾才会拦截到

*.action 以上配置的路径，表示请求地址必须以.action 结尾才会拦截到

Filter 过滤器它只关心请求的地址是否匹配，不关心请求的资源是否存在！！

五、Cookie

1、def

cookie是服务器通知客户端保存键值对的一种技术。

客户端有了cookie之后，每次请求都发送给服务器

每一个cookie的大小不能超过4KB

2、如何创建


public class Cookie extends BaseServlet{
    protected void createCookie(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("key1","values1");
        //通知客户端保存Cookie
        resp.addCookie(cookie);
        resp.getWriter().write("cokkie创建成功");
    }

3、服务器如何获取Cookie

req.getCookies():Cookie[]

protected void getCookie(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        javax.servlet.http.Cookie[] s = req.getCookies();
        for(javax.servlet.http.Cookie c :s){
            resp.getWriter().write(c.getName()+","+c.getValue()+"<br/>");
        }
    }

4、如何修改cookie

cookie的数值不支持中文

protected void updateCookie(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        javax.servlet.http.Cookie cookie = new javax.servlet.http.Cookie("key1","values11value11");
        //通知客户端保存Cookie
        resp.addCookie(cookie);
        resp.getWriter().write("key1修改完成");
    }

方案2：

protected void updateCookie2(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        javax.servlet.http.Cookie cookie = CookieUtils.findCookie("key2", req.getCookies());
        if(cookie!=null){
            cookie.setValue("newvalue2");
            resp.addCookie(cookie);
            resp.getWriter().write("key2修改完成");
        }
    }

5、Cookie 生命控制

f Cookie 的生命控制指的是如何管理 Cookie 什么时候被销毁（删除）

setMaxAge()

正数，表示在指定的秒数后过期

负数，表示浏览器一关，Cookie 就会被删除（默认值是-1）

零，表示马上删除 Cooki

6、Cookie 有效路径

Path 的设置 Cookie 的 path 属性可以有效的过滤哪些 Cookie 可以发送给服务器。哪些不发。

path 属性是通过请求的地址来进行有效的过滤。

CookieA path=/工程路径 CookieB path=/工程路径/abc

请求地址如下： http://ip:port/工程路径/a.html

CookieA 发送

CookieB 不发送

http://ip:port/工程路径/abc/a.html

CookieA 发送

CookieB 发送

7、Cookie 练习---免输入用户名登录

六、jsp

jsp 的全换是 java server pages。Java 的服务器页面。

jsp 的主要作用是代替 Servlet 程序回传 html 页面的数据。

因为 Servlet 程序回传 html 页面数据是一件非常繁锁的事情。开发成本和维护成本都极高。

jsp本质上是servlet程序。

总结：通过翻译的 java 源代码我们就可以得到结果：jsp 就是 Servlet 程序。

1、jsp的三种语法

a、jsp头部的page指令

jsp的page指令可以修改jsp页面的一些重要属性，或者行为

i. language 属性表示 jsp 翻译后是什么语言文件。暂时只支持 java。

ii. contentType 属性表示 jsp 返回的数据类型是什么。也是源码中 response.setContentType()参数值

iii. pageEncoding 属性表示当前 jsp 页面文件本身的字符集。

iv. import 属性跟 java 源代码中一样。用于导包，导类。

========================两个属性是给 out 输出流使用=============================

v. autoFlush 属性设置当 out 输出流缓冲区满了之后，是否自动刷新冲级区。默认值是 true。

vi. buffer 属性设置 out 缓冲区的大小。默认是 8kb

vii. errorPage 属性设置当 jsp 页面运行时出错，自动跳转去的错误页面路径

viii. isErrorPage 属性设置当前 jsp 页面是否是错误信息页面。默认是 false。如果是 true 可以获取异常信息。

ix. session 属性设置访问当前 jsp 页面，是否会创建 HttpSession 对象。默认是 t

x. extends 属性设置 jsp 翻译出来的 java 类默

b)jsp 中的常用脚本

表达式脚本（常用

表达式脚本的格式是：<%=表达式%> 表达式脚本的作用是：的 jsp 页面上输出数据

表达式脚本的特点： 1、所有的表达式脚本都会被翻译到jspService() 方法中 2、表达式脚本都会被翻译成为 out.print()输出到页面上 3、由于表达式脚本翻译的内容都在jspService() 方法中,所以_jspService()方法中的对象都可以直接使用。 4、表达式脚本中的表达式不能以分号结束

iii. 代码脚本代码脚本的格式是： <% java 语句 %>

c)jsp 中的三种注

html 注释

html 注释会被翻译到 java 源代码中。在_jspService 方法里，以 out.writer 输出到客户

java 注释

<% // 单行 java 注释 /* 多行 java 注释 */ %>

. jsp 注释 <%-- 这是 jsp 注释 --%> jsp 注释可以注掉，jsp 页面中所有代码

2、jsp 九大内置对象

jsp 中的内置对象，是指 Tomcat 在翻译 jsp 页面成为 Servlet 源代码后，内部提供的九大对象，叫内置对象。

3.jsp 四大域对象

四个域对象分别是：

pageContext (PageContextImpl 类) 当前 jsp 页面范围内有效

request (HttpServletRequest 类)、一次请求内有效

session (HttpSession 类)、一个会话范围内有效（打开浏览器访问服务器，直到关闭浏览器）

application (ServletContext 类) 整个 web 工程范围内都有效（只要 web 工程不停止，数据都

域对象是可以像 Map 一样存取数据的对象。四个域对象功能一样。不同的是它们对数据的存取范围

虽然四个域对象都可以存取数据。

在使用上它们四个域在使用的时候，优先顺序分别是，他们从小到大的范围的顺序有优先顺序的

pageContext ====>>> request ====>>> session ====>>>application

4、jsp 中的 out 输出和 response.getWriter 输出的区别

response 中表示响应，我们经常用于设置返回给客户端的内容（输出

深入源码，浅出结论：在 jsp 页面中，可以统一使用 out.print()来进行输

<%@ include file=""%> 就是静态包含

<jsp:include page="">/jsp:include 这是动态包

<jsp:forward page="">/jsp:forward 是请求转发标签，它的功能就是请求转发

七、Listerner监听器

Listener 监听器它是 JavaWeb 的三大组件之一。JavaWeb 的三大组件分别是：Servlet 程序、Filter 过滤器、Listener 监听器。

Listener 它是 JavaEE 的规范，就是接口 3、监听器的作用是，监听某种事物的变化。然后通过回调函数，反馈给客户（程序）去做一些相应的处理

1、ServletContextListener

可以监听ServletCOntext对象的创建和销毁

ServletContext对象在web工程启动的时候创建，在 web工程停止的时候销毁。

监听到创建和销毁之后都会分别调用 ServletContextListener 监听器的方法反馈

public interface ServletContextListener extends EventListener {
/**
* 在 ServletContext 对象创建之后马上调用，做初始化
*/
public void contextInitialized(ServletContextEvent sce);
/**
* 在 ServletContext 对象销毁之后调用
*/
public void contextDestroyed(ServletContextEvent sce);

使用步骤如下： 1、编写一个类去实现 ServletContextListener 2、实现其两个回调方法 3、到 web.xml 中去配置监听器

public class MyServletContextListenerImpl implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("ServletContext 对象被创建了");
}
@Override
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("ServletContext 对象被销毁了");
}
}

<!--配置监听器-->
<listener>
<listener-class>com.atguigu.listener.MyServletContextListenerImpl</listener-class>
</listener>

八、EL表达式

EL 表达式的全称是：Expression Language。是表达式语言。 EL 表达式的什么作用：EL 表达式主要是代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出。因为 EL 表达式在输出数据的时候，要比 jsp 的表达式脚本要简洁很

<body>
<%
request.setAttribute("key","值");
%>
表达式脚本输出 key 的值是：
<%=request.getAttribute("key1")==null?"":request.getAttribute("key1")%><br/>
EL 表达式输出 key 的值是：${key1}
</body>

EL 表达式的格式是：${表达式} EL 表达式在输出 null 值的时候，输出的是空串。

jsp 表达式脚本输出 null 值的时候，输出的是 null 字符

当四个域中都有相同的 key 的数据的时候，EL 表达式会按照四个域的从小到大的顺序去进行搜索，找到就输出。

EL 获取四个特定域中的属性

pageScope ====== pageContext 域

requestScope ====== Request 域

sessionScope ====== Session 域

applicationScope ====== ServletContext 域

<%--
request.getScheme() 它可以获取请求的协议
request.getServerName() 获取请求的服务器 ip 或域名
request.getServerPort() 获取请求的服务器端口号
getContextPath() 获取当前工程路径
request.getMethod() 获取请求的方式（GET 或 POST）
request.getRemoteHost() 获取客户端的 ip 地址
session.getId() 获取会话的唯一标识
--%>

九、JSTL 标签库

而标签库则是为了替换代码脚本。这样使得整个 jsp 页面变得更佳简洁

JSTL 标签库的使用步骤

1、先导入 jstl 标签库的 jar 包。 taglibs-standard-impl-1.2.1.jar taglibs-standard-spec-1.2.1.jar

2、第二步，使用 taglib 指令引入标签库。

<%@ taglib prefix="c" uri="Oracle Java Technologies | Oracle" %>

g)core 核心库使用

i. （使用很少）

作用：set 标签可以往域中保存数据

<%--
i.<c:set />
作用：set 标签可以往域中保存数据
域对象.setAttribute(key,value);
scope 属性设置保存到哪个域
page 表示 PageContext 域（默认值）
request 表示 Request 域
session 表示 Session 域
application 表示 ServletContext 域
var 属性设置 key 是多少
value 属性设置值
--%>
保存之前：${ sessionScope.abc } <br>
<c:set scope="session" var="abc" value="abcValue"/>
保存之后：${ sessionScope.abc } <br>

if 标签用来做 if 判断

<%--
ii.<c:if />
if 标签用来做 if 判断。
test 属性表示判断的条件（使用 EL 表达式输出）
--%>
<c:if test="${ 12 == 12 }">
<h1>12 等于 12</h1>
</c:if>
<c:if test="${ 12 != 12 }">
<h1>12 不等于 12</h1>
</c:if>

标签作用：多路判断。跟 switch ... case .... default 非常接近

<%--
iii.<c:choose> <c:when> <c:otherwise>标签
作用：多路判断。跟 switch ... case .... default 非常接近
choose 标签开始选择判断
when 标签表示每一种判断情况
test 属性表示当前这种判断情况的值
otherwise 标签表示剩下的情况
<c:choose> <c:when> <c:otherwise>标签使用时需要注意的点：
1、标签里不能使用 html 注释，要使用 jsp 注释
2、when 标签的父标签一定要是 choose 标签
--%>
<%
request.setAttribute("height", 180);
%>
<c:choose>
<%-- 这是 html 注释 --%>
<c:when test="${ requestScope.height > 190 }">
<h2>小巨人</h2>
</c:when>
<c:when test="${ requestScope.height > 180 }">
<h2>很高</h2>
</c:when>
<c:when test="${ requestScope.height > 170 }">
<h2>还可以</h2>
</c:when>
<c:otherwise>
<c:choose>
<c:when test="${requestScope.height > 160}">
<h3>大于 160</h3>
</c:when>
<c:when test="${requestScope.height > 150}">
<h3>大于 150</h3>
</c:when>
<c:when test="${requestScope.height > 140}">
<h3>大于 140</h3>
</c:when>
<c:otherwise>
其他小于 140
</c:otherwise>
</c:choose>
</c:otherwise>
</c:choose>

<c:forEach />作用：遍历输出使用

<%--1.遍历 1 到 10，输出
begin 属性设置开始的索引
end 属性设置结束的索引
var 属性表示循环的变量(也是当前正在遍历到的数据)
for (int i = 1; i < 10; i++)
--%>
<table border="1">
<c:forEach begin="1" end="10" var="i">
<tr>
<td>第${i}行</td>
</tr>
</c:forEach>
</table>

<%-- 2.遍历 Object 数组
for (Object item: arr)
items 表示遍历的数据源（遍历的集合）
var 表示当前遍历到的数据
--%>
<%
request.setAttribute("arr", new String[]{"18610541354","18688886666","18699998888"});
%>
<c:forEach items="${ requestScope.arr }" var="item">
${ item } <br>
</c:forEach

<%
Map<String,Object> map = new HashMap<String, Object>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
// for ( Map.Entry<String,Object> entry : map.entrySet()) {
// }
request.setAttribute("map", map);
%>
<c:forEach items="${ requestScope.map }" var="entry">
<h1>${entry.key} = ${entry.value}</h1>
</c:forEach>

十、文件的上传和下载

1、要有一个form标签，method=post 请求

2、form 标签的 encType 属性值必须为 multipart/form-data

3、在 form 标签中使用 input type=file 添加上

4、编写服务器代码（Servlet 程序）接收，处理上传的数据。

encType=multipart/form-data 表示提交的数据，以多段（每一个表单项一个数据段）的形式进行拼接，然后以二进制流的形式发送给服务器。

1、commons-fileupload.jar 常用 API 介绍说明

commons-fileupload.jar 需要依赖 commons-io.jar 这个包，所以两个包我们都要引入

ServletFileUpload 类，用于解析上传的数据。 FileItem 类，表示每一个表单项。

boolean ServletFileUpload.isMultipartContent(HttpServletRequest request);
判断当前上传的数据格式是否是多段的格式。
public List<FileItem> parseRequest(HttpServletRequest request)
解析上传的数据
boolean FileItem.isFormField()
判断当前这个表单项，是否是普通的表单项。还是上传的文件类型。
true 表示普通类型的表单项
false 表示上传的文件类型
String FileItem.getFieldName()
获取表单项的 name 属性值
String FileItem.getString()
获取当前表单项的值。
String FileItem.getName();
获取上传的文件名
void FileItem.write( file );
将上传的文件写到 参数 file 所指向抽硬盘位置 。

2、文件下载

下载的常用 API 说明：
response.getOutputStream();
servletContext.getResourceAsStream();
servletContext.getMimeType();
response.setContentType();


response.setHeader("Content-Disposition", "attachment; fileName=1.jpg");
这个响应头告诉浏览器。这是需要下载的。而 attachment 表示附件，也就是下载的一个文件。fileName=后面，
表示下载的文件名

URLEncoder 解决 IE 和谷歌浏览器的 附件中
文名问题。
如果客户端浏览器是 IE 浏览器 或者 是谷歌浏览器。我们需要使用 URLEncoder 类先对中文名进行 UTF-8 的编码
操作。
因为 IE 浏览器和谷歌浏览器收到含有编码后的字符串后会以 UTF-8 字符集进行解码显示。
// 把中文名进行 UTF-8 编码操作。
String str = "attachment; fileName=" + URLEncoder.encode("中文.jpg", "UTF-8");
// 然后把编码后的字符串设置到响应头中
response.setHeader("Content-Disposition", str)

十一、Session

1、什么是Session（Cookie保存在客户端，Session保存在服务器端）

Session就是一个接口（HttpSession）

Session就是一个会话，他是用来维护一个客户端和服务器之间关联的一种技术。

每一个客户端都有自己的一个Session会话。

Session会话中，我们经常用来保护用户登录之后的信息。

2、如何创建Session和获取（id号，是否是新的）

如何创建和获取Session，他们的API是一样的。

request。getSession（）

第一次调用是：创建Session会话

之后调用都是：获取前面创建号的Session会话对象。

isNew（）：是不是新的Session会话。判断这个名字，不要用is开头

true：表示刚创建的。

false：表示获取之前创建的

每一个会话都有一个身份号码，也就是ID值，而且这个ID是唯一的。

getID（）：得到Session的会话ID值。

3、Session中数据的获取

protected void setAttribute(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        req.getSession().setAttribute("key1","values1");

    }

    /**
     * 获取session中的数据
     * @param req
     * @param resp
     * @throws IOException
     */
    protected void getAttribute(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        Object key1 = req.getSession().getAttribute("key1");
        resp.getWriter().write("从session中获取的key1的数据是："+key1);
    }

4、Session生命周期控制

public void setMaxInactiveInterval（interestinginterval）设置Session的超时时间，超过指定时长，Session就会被销毁。

public void getMaxInactiveInterval（interestinginterval）获取设置的超时时间

/**
     * 默认的生命时长
     * @param req
     * @param resp
     * @throws IOException
     */
    protected void defaultlife(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        int maxInactiveInterval = req.getSession().getMaxInactiveInterval();
        resp.getWriter().write("sessison的默认时长是"+maxInactiveInterval);
    }

Session的默认超时时长是30mins。

因为在 Tomcat 服务器的配置文件 web.xml中默认有以下的配置，

它就表示配置了当前 Tomcat 服务器下所有的 Session 超时配置默认时长为：30 分钟。

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

如果说。你希望你的 web 工程，默认的 Session 的超时时长为其他时长。你可以在你自己的 web.xml 配置文件中做以上相同的配置。就可以修改你的 web 工程所有 Seession 的默认超时时长。

<!--表示当前 web 工程。创建出来 的所有 Session 默认是 20 分钟 超时时长-->
<session-config>
<session-timeout>20</session-timeout>
</session-config>

如果你想只修改个别 Session 的超时时长。就可以使用上面的 API。

setMaxInactiveInterval(int interval)来进行单独的设置。

session.setMaxInactiveInterval(int interval)单独设置超时时长。

Session的超时指的是，客户端两次请求的最大间隔时长。

public void invalidate() 让当前 Session 会话马上超时无效。

/**
     * 马上销毁Session
     * @param req
     * @param resp
     * @throws IOException
     */
    protected void mas(HttpServletRequest req, HttpServletResponse resp) throws IOException {
        req.getSession().invalidate();
        resp.getWriter().write("销毁完了");
    }

5、浏览器与session之间的技术内幕

十二、JSON

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。

易于人阅读和编写。同时也易于机器解析和生成。

JSON 采用完全独立于语言的文本格式，而且很多语言都提供了对 json 的支持（包括 C, C++, C#, Java, JavaScript, Perl, Python 等）。

这样就使得 JSON 成为理想的数据交换格式。

json 是一种轻量级的数据交换格式。

轻量级指的是跟 xml 做比较。

数据交换指的是客户端和服务器之间业务数据的传递格式。

1、JSON在JAvaScript中使用

1、1json的定义

json是由键值对组成，并且是由花括号包围。每一个键由引号引起来，键和值之间使用冒号进行分隔。多组键值对之间进行都好进行分隔。

var jsonObj = {
"key1":12,
"key2":"abc",
"key3":true,
"key4":[11,"arr",false],
"key5":{
"key5_1" : 551,
"key5_2" : "key5_2_value"
},
"key6":[{
"key6_1_1":6611,
"key6_1_2":"key6_1_2_value"
},{
"key6_2_1":6621,
"key6_2_2":"key6_2_2_value"
}]
};

1、2 json 的访问

json 本身是一个对象。

json 中的的 key 我们可以理解为是对象中的一个属性。

json 中的 key 访问就跟访问对象的属性一样： json 对象.ke

1、3、json 的两个常用方法

json 的存在有两种形式。

一种是：对象的形式存在，我们叫它 json 对象。

一种是：字符串的形式存在，我们叫它 json 字符串。

一般我们要操作 json 中的数据的时候，需要 json 对象的格式。

一般我们要在客户端和服务器之间进行数据交换的时候，使用 json 字符串。

JSON.stringify() 把 json 对象转换成为 json 字符串

JSON.parse() 把 json 字符串转换成为 json 对象

// 把 json 对象转换成为 json 字符串
var jsonObjString = JSON.stringify(jsonObj); // 特别像 Java 中对象的 toString
alert(jsonObjString)
// 把 json 字符串。转换成为 json 对象
var jsonObj2 = JSON.parse(jsonObjString);
alert(jsonObj2.key1);// 12
alert(jsonObj2.key2);// abc

2、、JSON 在 java 中的使

.1、javaBean 和 json 的互转

@Test
public void test1(){
Person person = new Person(1,"国哥好帅!");
// 创建 Gson 对象实例
Gson gson = new Gson();
// toJson 方法可以把 java 对象转换成为 json 字符串
String personJsonString = gson.toJson(person);
System.out.println(personJsonString);
// fromJson 把 json 字符串转换回 Java 对象
// 第一个参数是 json 字符串
// 第二个参数是转换回去的 Java 对象类型
Person person1 = gson.fromJson(personJsonString, Person.class);
System.out.println(person1);
}

List 和 json 的互转

// 1.2.2、List 和 json 的互转
@Test
public void test2() {
List<Person> personList = new ArrayList<>();
personList.add(new Person(1, "国哥"));
personList.add(new Person(2, "康师傅"));
Gson gson = new Gson();
// 把 List 转换为 json 字符串
String personListJsonString = gson.toJson(personList);
System.out.println(personListJsonString);
List<Person> list = gson.fromJson(personListJsonString, new PersonListType().getType());
System.out.println(list);
Person person = list.get(0);
System.out.println(person);
}

map 和 json 的互转

// 1.2.3、map 和 json 的互转
@Test
public void test3(){
Map<Integer,Person> personMap = new HashMap<>();
personMap.put(1, new Person(1, "国哥好帅"));
personMap.put(2, new Person(2, "康师傅也好帅"));
Gson gson = new Gson();
// 把 map 集合转换成为 json 字符串
String personMapJsonString = gson.toJson(personMap);
System.out.println(personMapJsonString);
// Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
PersonMapType().getType());
Map<Integer,Person> personMap2 = gson.fromJson(personMapJsonString, new
TypeToken<HashMap<Integer,Person>>(){}.getType());
System.out.println(personMap2);
Person p = personMap2.get(1);
System.out.println(p);
}

十三、AJAX请求

ajax是一种创建交互式网页应用的网页开发技术。

ajax是一种浏览器通过js异步发起请求，局部更新页面的技术。

ajax请求的局部更新，浏览器地址栏不会发生变化，局部更新不会生气原来页面的内容。

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="pragma" content="no-cache" />
<meta http-equiv="cache-control" content="no-cache" />
<meta http-equiv="Expires" content="0" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript">
// 在这里使用 javaScript 语言发起 Ajax 请求，访问服务器 AjaxServlet 中 javaScriptAjax
function ajaxRequest() {
// 1、我们首先要创建 XMLHttpRequest
var xmlhttprequest = new XMLHttpRequest();
// 2、调用 open 方法设置请求参数
xmlhttprequest.open("GET","http://localhost:8080/16_json_ajax_i18n/ajaxServlet?action=javaScriptAj
ax",true)
// 4、在 send 方法前绑定 onreadystatechange 事件，处理请求完成后的操作。
xmlhttprequest.onreadystatechange = function(){
if (xmlhttprequest.readyState == 4 && xmlhttprequest.status == 200) {
var jsonObj = JSON.parse(xmlhttprequest.responseText);
// 把响应的数据显示在页面上
document.getElementById("div01").innerHTML = "编号：" + jsonObj.id + " , 姓名：" +
jsonObj.name;
}
}
// 3、调用 send 方法发送请求
xmlhttprequest.send();
}
</script>
</head>
<body>
<button οnclick="ajaxRequest()">ajax request</button>
<div id="div01">
</div>
</body>
</html>

局部更新：地址栏没有变，原来页面中的内容其他内容没有变化。

1、JQuery中的AJAX请求

ajax方法：

url：并表示请求的地址

type：表示请求的类型的GET或者POST请求

data：表示发送给服务器的数据

格式有两种：

一：name=value&name=value

二：{key:value}

success：请求成功，响应的回调函数

dataType：响应的数据类型

常用的数据类型有： text 表示纯文本 xml 表示 xml 数据 json 表示 json 对象

$.get 方法和$.post 方法
url 请求的 url 地址
data 发送的数据
callback 成功的回调函数
type 返回的数据类型
// ajax--get 请求
$("#getBtn").click(function(){
$.get("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryGet",function (data) {
$("#msg").html(" get 编号：" + data.id + " , 姓名：" + data.name);
},"json");
});
// ajax--post 请求
$("#postBtn").click(function(){
$.post("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryPost",function (data)
{
$("#msg").html(" post 编号：" + data.id + " , 姓名：" + data.name);
},"json");
})；

$.getJSON 方法
url 请求的 url 地址
data 发送给服务器的数据
callback 成功的回调函数
// ajax--getJson 请求
$("#getJSONBtn").click(function(){
$.getJSON("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQueryGetJSON",function
(data) {
$("#msg").html(" getJSON 编号：" + data.id + " , 姓名：" + data.name);
});
})

表单序列化 serialize()
serialize()可以把表单中所有表单项的内容都获取到，并以 name=value&name=value 的形式进行拼接。
// ajax 请求
$("#submit").click(function(){
// 把参数序列化
$.getJSON("http://localhost:8080/16_json_ajax_i18n/ajaxServlet","action=jQuerySerialize&" +
$("#form01").serialize(),function (data) {
$("#msg").html(" Serialize 编号：" + data.id + " , 姓名：" + data.name);
});
});