java会话技术详解 javaweb会话

JavaWeb（中）

目录

• JavaWeb（中）

• Cookie和Session

• 1、会话
• 2、保存会话的两种技术
• Cookie
• Session(重点)

• JSP

• 原理
• JSP的基础语法
• 指令

• <%@ page ...%>
• <%@include ...%>

• JSP九大内置对象
• JSP标签 JSTL表达式

• JavaBean
• MVC三层架构
• 过滤器
• 监听器
• 过滤器、监听器常见应用
• JDBC复习
• JDBC 事务

Cookie和Session

1、会话

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

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

一个网站，怎么证明你来过？

1. 服务端给客户端一个 信件，客户端下次访问服务端带上信件就可以了； cookie
2. 服务器登记你来过了，下次你来的时候我来匹配你； session

2、保存会话的两种技术

cookie

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

session

• 服务器技术，利用这个技术，可以保存用户的会话信息？ 我们可以把信息或者数据放在Session中！

常见例子：网站登录之后，你下次不用再登录了，第二次访问直接就上去了！

你真的了解Cookie和Session吗？

Cookie

package com.szg.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;

public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // 告诉我你来的时间，然后把这个时间封装成为一个令牌，你下次带着这个令牌过来，我就知道你来过了

        //解决中文乱码的初步代码
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        //根据弹幕提供的进一步代码
        resp.setContentType("text/html");

        PrintWriter out = resp.getWriter();
        //服务器充客户端获取
        Cookie[] cookies = req.getCookies();

        //判断cookie是否存在
        //这里狂神写的不对，因为一定会有cookie 浏览器本身就会生成几个浏览器，所以肯定不会出现“这是你第一次访问本站” 
        //设为检测键值对是否存在有可能就解决了这个问题
        if(cookies!=null){
            out.write("你上次访问的时间是：");
            for(int i=0;i<cookies.length;i++){
                Cookie cookie = cookies[i];
                if(cookie.getName().equals("lastLoginTime")){
                    //获取cokie的值 强转类型
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date =new Date(lastLoginTime);
                    //“过期”的函数 不建议使用
                    out.write(date.toLocaleString());
                }
            }
        }
        else{
            out.write("这是你第一次访问本站");
        }
        //服务给客户端一个cookie 转为string类型
        // 必须转为string类型 可在后面加一个空的字符串 不然报错
        Cookie cookie =new Cookie("lastLoginTime",System.currentTimeMillis()+"");
        resp.addCookie(cookie);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

edge浏览器的也可以查看cookie的地方：（忽略一个错单词

响应cookie就是下一次请求cookie的值

然后发现每次关掉浏览器都会清空自己上一次的 lastLoginTime 所以 可以设置一个有效期，来保证这一天这个cookie都有效。

。。。
cookie.setMaxAge(24*60*60);// 设置一天的有效期
resp.addCookie(cookie);//添加cookie
。。。

1. 从请求中拿到cookie信息
2. 服务器响应给客户端cookie

常用函数

Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie
cookie.setMaxAge(24*60*60); //设置cookie的有效期
resp.addCookie(cookie); //响应给客户端一个cookie

cookie 一般会保存在本地的 用户目录下 appdata文件夹内；

一个网站cookie是否存在上限?

• 一个Cookie只能保存一个信息；
• 一个web站点可以给浏览器发送多个cookie，最多存放20个cookie；
• Cookie大小有限制4kb；
• 300个cookie浏览器上限

删除Cookie的方法

• 不设置有效期，关闭浏览器，自动失效；
• 设置有效期时间为 0 ；

遇到中文乱码时 多一种思路：

// 利用先编码 需要用时再解码
URLEncoder.encode("秦疆","utf-8")
URLDecoder.decode(cookie.getValue(),"UTF-8")

Session(重点)

什么是Session：

• 服务器会给每一个用户（浏览器）创建一个Session对象；
• 一个Ses sion独占一个浏览器，只要浏览器没有关闭，这个Session就存在；
• 用户登录之后，整个网站它都可以访问！–> 保存用户的信息；保存购物车的信息……

SessionDemo01

package com.szg.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //解决乱码问题
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        //得到Session
        HttpSession session = req.getSession();
        //给Session中存东西
        //第二个值类型为Object 即所有类型都可以 不局限于string 实体对象都可以
        session.setAttribute("name","SZG");
        //获取Session的ID
        String sessionId = session.getId();

        //判断Session是不是新创建

        //一般情况下 打开浏览器会跳转到 localhost:8080/ 这个时候是创建了session 再进入demo1 所以会提示 已经创建过了
        //所以如果再tomcat中将url改为  localhost:8080/s1 这个时候打开浏览器直接进入到demo1会提示  创建成功

        if (session.isNew()){
            resp.getWriter().write("session创建成功,ID:"+sessionId);
        }else {
            resp.getWriter().write("session以及在服务器中存在了,ID:"+sessionId);
        }

        //Session创建的时候做了什么事情；
        // 相当于建了一个cookie
//        Cookie cookie = new Cookie("JSESSIONID",sessionId);
//        resp.addCookie(cookie);

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

SessionDemo02

package com.szg.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

//先运行demo1 输出SZG
//先运行demo2 输出null
//session 和 servletcontext 有点类似，都可以用于共享数据 起到“云”的作用
//不同的浏览器的session不同
public class SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //解决乱码问题
        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");

        //得到Session 并输出id
        HttpSession session = req.getSession();
        String id = (String) session.getAttribute("name");
        System.out.println(id);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

SessionDemo03

package com.szg.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
//手动注销Session.到那时会立马生成一个新的所以session一定存在
//先运行demo3 在运行demo1 会出现“session创建成功”
public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        session.invalidate();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

自动注销 在web.xml配置

<!--设置Session默认的失效时间-->
<session-config>
    <!--15分钟后Session自动失效，以分钟为单位-->
    <session-timeout>15</session-timeout>
</session-config>

Session和cookie的区别：（结合前面的链接

• Cookie是把用户的数据写给用户的浏览器，浏览器保存 （可以保存多个）
• Session把用户的数据写到用户独占Session中，服务器端保存 （保存重要的信息，减少服务器资源的浪费）
• Session对象由服务创建；

Session使用场景：

• 保存一个登录用户的信息；
• 购物车信息；
• 在整个网站中经常会使用的数据，我们将它保存在Session中；

JSP

原理

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！运行在服务端的语言。

最大的特点：

• 写JSP就像在写HTML
• 区别：

• HTML只给用户提供静态的数据
• JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

JSP到底怎么执行的?

• 代码层面没有任何问题，就是jsp文件
• 服务器内部工作
  tomcat中有一个work目录,服务器存放目录，存放了很多网站，里面存有xxx_jsp.java 文件；
  IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录，与上面作用相同

因为发现页面都转成了java文件，所以：

• 浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet！
• JSP最终也会被转换成为一个Java类！

通过查看xxx_jsp.java代码，JSP 本质上就是一个Servlet

//初始化
public void _jspInit() {}
//销毁
public void _jspDestroy(){} 
//JSPService 内部有判断提交类型的源码 如get和post
public void _jspService(HttpServletRequest request,HttpServletResponse response){}

// 发现了内部的一些对象
final javax.servlet.jsp.PageContext pageContext;  //页面上下文
javax.servlet.http.HttpSession session = null;    //session
final javax.servlet.ServletContext application;   //applicationContext
final javax.servlet.ServletConfig config;         //config
javax.servlet.jsp.JspWriter out = null;           //out
final java.lang.Object page = this;               //page：当前
HttpServletRequest request                        //请求
HttpServletResponse response                      //响应

//输出页面前增加的代码 就是try里的内容 后面紧接着就是java语言输出html语句了
//在jsp中利用语法的特定格式也可以 利用上面的对象书写 java 语句 
response.setContentType("text/html");       //设置响应的页面类型 才能够被识别
pageContext = _jspxFactory.getPageContext(this, request, response,
       null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut(); //输出对象 后面用于输出语句
_jspx_out = out;

流程图：

在JSP页面中；

• 只要是 JAVA代码就会原封不动的输出；
• 如果是HTML代码，就会被转换为：out.write("\r\n"); 输出到前端

W3chool：

• 就像其他普通的网页一样，您的浏览器发送一个HTTP请求给服务器。
• Web服务器识别出这是一个对JSP网页的请求，并且将该请求传递给JSP引擎。通过使用URL或者.jsp文件来完成。
• JSP引擎从磁盘中载入JSP文件，然后将它们转化为servlet。这种转化只是简单地将所有模板文本改用println()语句，并且将所有的JSP元素转化成Java代码。
• JSP引擎将servlet编译成可执行类，并且将原始请求传递给servlet引擎。
• Web服务器的某组件将会调用servlet引擎，然后载入并执行servlet类。在执行过程中，servlet产生HTML格式的输出并将其内嵌于HTTP response中上交给Web服务器。
• Web服务器以静态HTML网页的形式将HTTP response返回到您的浏览器中。
• 最终，Web浏览器处理HTTP response中动态产生的HTML网页，就好像在处理静态网页一样。

一般情况下，JSP引擎会检查JSP文件对应的servlet是否已经存在，并且检查JSP文件的修改日期是否早于servlet。如果JSP文件的修改日期早于对应的servlet，那么容器就可以确定JSP文件没有被修改过并且servlet有效。这使得整个流程与其他脚本语言（比如PHP）相比要高效快捷一些。

总的来说，JSP网页就是用另一种方式来编写servlet而不用成为Java编程高手。除了解释阶段外，JSP网页几乎可以被当成一个普通的servlet来对待。

JSP的基础语法

JSP 作为java技术的一种应用，它拥有一些自己扩充的语法（了解，知道即可！），Java所有语法都支持！

需要创建一个新的工程，这一次没有使用javaweb的模板，直接创建了一个空白的Maven工程。然后再右键工程选择Add framefork Support添加web application

这种创建方式比较先进，不用我们再优化结构、更改web.xml文件了。

当然，我们还要pom.xml中导入依赖，这一次导入的有点多,耐心等待多刷新

<dependencies>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp.jstl/jstl-api -->
    <dependency>
        <groupId>javax.servlet.jsp.jstl</groupId>
        <artifactId>jstl-api</artifactId>
        <version>1.2</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-impl -->
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-impl</artifactId>
        <version>1.2.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

JSP表达式

作用：用来将程序的输出，输出到客户端
格式：<%= 变量或者表达式%>

在index.jsp中插入下面的语句即可输出时间

<%-- 这是注释 --%>
<%= new java.util.Date()%>
<%-- 在页面的开头可以导入java包--%>
<%@ page import="java.util.*" %>

因为没有java文件，所以不用写servlet映射，然后配置tomcat ，运行出结果

当更改了代码想要重新运行时，

点击重新运行后选择第二个即可不用重启就更改了页面（此创建工程方法所特有的，老创建方法没有。需要自己打开浏览器哈 注意如果只重写了jsp可以通过这个方式

Jsp脚本片段

<%
int sum = 0;
for (int i = 1; i <=100 ; i++) {
    sum+=i;
}
out.println("<h1>Sum="+sum+"</h1>");
int x = 10;
out.println(x);
%>

<%-- 在代码嵌入HTML元素 输出五遍helloword 很乱吧 --%>

<%  for (int i = 0; i < 5; i++) { %>
<h1>Hello,World  <%=i%> </h1>
<% } %>

Jsp声明

<%!//JSP 声明语句用于声明一个或多个变量、方法，以供后面的 Java 代码使用。
    static {
    System.out.println("Loading Servlet!");
}
private int globalVar = 0;
public void kuang(){
    System.out.println("进入了方法Kuang！");
}
%>

JSP声明：会被编译到 JSP生成Java的类 中！ 而jsp脚本和jsp表达式，则会被生成到_jspService方法中！

在JSP，嵌入Java代码即可！

JSP的注释，不会在客户端显示，HTML就会！

指令

<%@ page …%>

例子：自定义500错误的页面

创建一个新的jsp文件，再创建一个文件夹error然后在文件夹中创建一个500.jsp 定义该页面

当然自定义的页面就根据需要用文字和图片制作就行

jsp2.jsp 代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%-- 如果有错误，跳转到自定义的500页面 --%>
<%-- 必须保证在idea中不爆红，打开页面爆500错误才能够跳转到自定义的500页面--%>
<%@ page errorPage="error/500.jsp"%>

<html>
<head>
    <title>Title</title>
</head>
<body>
<% int x =1/0 %>
</body>
</html>

500.jsp 代码

<%@ page contentType="text/html;charset=UTF-8" language="java" isErrorPage="true"%>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%-- 如果tomcat中配置了项目路径，就需要加上项目路径或者直接写 ${pageContext.request.contextPath}/ 我的就出来了--%>
<%--有的弹幕说把jpg改成瓶就行了，有的说把狂神代码的两个点去掉一个点就行了。。有的说重启idea就行了的--%>

<img src="${pageContext.request.contextPath}/img/IMG_0627.jpg" alt="500">
<h1>自定义500错误</h1>
</body>
</html>

写的代码绝对没有问题，但是就是不自动跳转到 自定义的错误页面，很难受。。

也可以在web.xml 中直接配置一旦出现500错误就跳转的页面：

<error-page>
    <error-code>500</error-code>
    <location>/error/500.jsp</location>
</error-page>

加上上面这句话之后，就可以自动跳转到 自定义的错误页面了

<%@include …%>

创建一个新文件夹common，一般用来存放整个网站各个页面的共同部分，在新文件夹中创建两个jsp分别表示页面头部和页面尾部。

在 主体页面 中 使用两种方法，实现将头部和尾部的实现效果 塞进来

直接看 jsp3_jsp.java 的源代码

<%--@include file  会将两个页面合二为一 头部和尾部的包含的代码会提取到主体页面中--%>
<%-- 要注意因为直接将代码塞进了主体页面，当头部和主体和尾部三者出现重名的变量时，就会报错，--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>

<hr>

<%--JSP标签
    jsp:include：page 拼接页面，本质还是三个，只是一种引用的作用，代码不会直接塞到主体页面中
    --%>
<jsp:include page="/common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="/common/footer.jsp"/>

JSP九大内置对象

• PageContext 存东西
• Request 存东西
• Response
• Session 存东西
• Application 【SerlvetContext】 存东西
• config 【SerlvetConfig】
• out
• page ，不用了解
• exception

pageContext.setAttribute("name1","秦疆1号"); //保存的数据只在一个页面中有效
request.setAttribute("name2","秦疆2号"); //保存的数据只在一次请求中有效，请求转发会携带这个数据
session.setAttribute("name3","秦疆3号"); //保存的数据只在一次会话中有效，从打开浏览器到关闭浏览器
application.setAttribute("name4","秦疆4号");  //保存的数据只在服务器中有效，从打开服务器到关闭服务器

建一个新的jsp ：pageConetxtDemo01

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<% //！！注意每个之前的区别！！
    pageContext.setAttribute("name1","szg1号"); //保存的数据只在 一个页面 中有效
    request.setAttribute("name2","szg2号"); //保存的数据只在 一次请求 中有效，请求转发会携带这个数据
    session.setAttribute("name3","szg3号"); //保存的数据只在 一次会话 中有效，从打开 浏览器 到关闭浏览器
    application.setAttribute("name4","szg4号");  //保存的数据只在 服务器 中有效，从打开 服务器 到关闭服务器

%>
<%-- jsp 中 使用el表达式输出 ${}
el表达式无法正常显示的在上面加<%@ page isELIgnored=false>低版本的默认为true  -- 来自弹幕
--%>
<h1>取出的值为</h1>
<h2>${name1}</h2>
<h2>${name2}</h2>
<h2>${name3}</h2>
<h2>${name4}</h2>
<%--下面这句话没有任何反应 因为name5根本不存在！！！--%>
<h2>${name5}</h2>

<%//搜索顺序是先是范围最小的page对象，其次是request对象、session对象，最后是application对象，这个方法的返回值是第一个符合要求的Java对象的值。
    //从底层到高层
    //下面 演示了 java代码中获取 页面中page对象 通过 键 搜索
    String name1=(String)pageContext.findAttribute("name1");
    String name2=(String)pageContext.findAttribute("name2");
    String name3=(String)pageContext.findAttribute("name3");
    String name4=(String)pageContext.findAttribute("name4");
    String name5=(String)pageContext.findAttribute("name5"); //不存在
%>
<%--页面直接输出 null --%>
<h2><%=name5%>></h2>

</body>
</html>

在applicatoin中就可与获取最外层的信息，在视频中，狂神举了 三个客户端都要在服务器端的库中取东西、以及统计在线人数的例子。

其实servletContext和application 是一样的，就相当于一个类创建了两个不同名称的变量
在 servlet中ServletContext就是application对象。
两者的区别就是application用在jsp中，servletContext用在servlet中。

再新建一个jsp文件： pageContextDemo02

<h1>取出的值为</h1>
<h2>${name1}</h2>
<h2>${name2}</h2>
<h2>${name3}</h2>
<h2>${name4}</h2>

重启服务器，当首先进入demo02.jsp 发现一个值也没有，因为demo01没有打开过，无法载入值。

所以打开demo01，然后再打开demo02，发现只取出来了 “szg3号” 和 “szg4号”

JVM:双亲委派机制

• 双亲委派机制是指当一个类加载器收到一个类加载请求时，该类加载器首先会把请求委派给父类加载器。 不断重复直到最上面一层，运用最后一个找到的
• 就是防止用户自定义了java的核心类库，比如 java.lang.String 就算自己写了一个jar包并导入，最后运行还是调用java自带的string

页面转发的两种实现方式

• pageContext.forward("/index.jsp") 在jsp中实现页面跳转
• request.getRequestDispatcher("/index.jsp").forward(request,response); 在后端servlet实现转发

关于作用域的一点说明举例子

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！

session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；

application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据；

JSP标签 JSTL表达式

记得导入前面提到的依赖jar包

EL表达式： ${ } 的常用作用：

• 获取数据
• 执行运算
• 获取web开发的常用对象
• jsp:include 之前已经讲过了就是拼接页面
• jsp:forward page="" 转发页面

<%--在同一个request域中，共享request对象的属性 等价于request.getRequestDispatcher --%>
<jsp:forward page="index.jsp">
    <%--在转发湿还可以携带参数--%>
    <jsp:param name="name" value="szg"/>
    <jsp:param name="age" value="19"/>
</jsp:forward>

<%--在index.jsp中，可以通过函数获得转发所带过去的值 ！！！--%>

<%=request.getParameter("name")%>
<%=request.getParameter("age")%>

JSTL表达式

JSTL标签库的使用就是为了弥补HTML标签的不足；它自定义许多标签，可以供我们使用，标签的功能和Java代码一样！

下面的这几个标签都不做掌握的要求，可以在菜鸟教程查看了解

格式化标签

SQL标签

XML 标签

核心标签 （掌握部分）

JSTL标签库使用步骤

• 在jsp开头引入对应的 taglib 可以在菜鸟教程中复制所需要的JSTL的引入代码
• 使用其中的方法
• 在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

好像按照步骤弄完之后，运行网页会出现500的错误，狂神最后找出修补的方法，就是将jstl的jar包和standard的jar包复制粘贴到tomcat的lib目录下。。

弹幕有的人说他们没有复制包，仍然可以运行有可能和tomcat的版本有关。。。哎。。。

试用c:if c:out 两个标签

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--记得导入包，--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<html>
<head>
    <title>Title</title>
</head>
<body>
<form action="core.jsp" method="get">
    <%-- value 用的el表达式 ：从param对象里面获取userName属性的值， --%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
</form>
<%--判断如果提交的用户名是管理员，则登录成功--%>
<%--使用的c:if 判断标签--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="管理员欢迎您！"/>
</c:if>

<%--相当于输出。 后面记得加上自闭合标签--%>
<c:out value="${isAdmin}"/>
</body>
</html>

试用c:choose c:when 标签

<body>
<%--定义了一个变量score，值为85--%>
<c:set var="score" value="55"/>
<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when>
    <c:when test="${score>=80}">
        你的成绩为一般
    </c:when>
    <c:when test="${score>=70}">
        你的成绩为良好
    </c:when>
    <c:when test="${score<=60}">
        你的成绩为不及格
    </c:when>
</c:choose>
</body>

试用c:forEach标签 将来会常用。。。

<% //java 语言的容器
    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    people.add(4,"田六");
    request.setAttribute("list",people);
%>
<%--
var ： 每一次遍历出来的变量
items ： 要遍历的对象
--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/> <br>
</c:forEach>
<hr>
<c:forEach var="people" items="${list}" begin="1" end="3" step="1" >
    <c:out value="${people}"/> <br>
</c:forEach>

JavaBean

JavaBean - 廖雪峰的官方网站 (liaoxuefeng.com)

我感觉就是一种规范。。。。

连接数据库，不知道怎么下载数据库可以看之前的视频。。。（我也记有笔记）用户名root 密码123456 有可能需要调整时区和驱动，自己百度。

实体类

JavaBean有特定的写法：

• 必须要有一个无参构造
• 属性必须私有化
• 必须有对应的get/set方法；

一般用来和数据库的字段做映射 ORM；

ORM ：对象关系映射

• 表—>类
• 字段–>属性
• 行记录---->对象

首先在idea，java文件夹中新建一个包com.szg.pojo,在包中新建people类。

{先写好变量名，然后alt+insert 选择getter and setter，然后 shift+⬇ 将窗口里的方法全选}

再然后alt+insert 选择constructor，然后 shift+⬇ 将窗口里的变量全选，记得手写补上一个无参构造}

同样步骤找到快捷重写tostring的方法，

在数据库中也新建一个jdbc的数据库，在里面新建一张people的表；id 姓名，年龄 地址，设id为主键且自增，其他的都设为非空。

刷新不出来的情况是不是创建完表没有点击右下角的保存？？还出不来就刷新重新连接。

上面创建的实体类people往往与表结构一一对应

下面代码中，上四句和下四句完全等价

<%
    People people =new People();
    people.setId(1);
    people.setName("szg");
    people.getAge();
%>
<%--在jsp中，不通过java代码实现类的实例化--%>
<jsp:useBean id="people"class="com.szg.pojo.People"scope="page"/>
<jsp:setProperty name="people" property="id"value="1"/>
<jsp:setProperty name="people" property="name" value="szg"/>
<jsp:getProperty name="people" property="age"/>

MVC三层架构

经典MVC模式中，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。

MVC指MVC模式的某种框架，它强制性地使应用程序的输入、处理和输出分开。使用MVC应用程序被分成三个核心部件：模型、视图、控制器。它们各自处理自己的任务。最典型的MVC就是JSP + servlet + javabean的模式。

老的MVC模式：用户直接访问控制层，控制层就可以直接操作数据库；

servlet–CRUD–>数据库
弊端：程序十分臃肿，不利于维护

servlet的代码中存在：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！

程序猿调用
↑
JDBC （实现该接口）
↑
Mysql Oracle SqlServer …（不同厂商的各种数据库）

新的MVC三层架构模式：

Model

• 业务处理 ：业务逻辑（Service）
• 数据持久层：CRUD （Dao - 数据持久化对象）

View

• 展示数据
• 提供链接发起Servlet请求 （a，form，img…）

Controller （Servlet）

• 接收用户的请求 ：（req：请求参数、Session信息….）
• 交给业务层处理对应的代码
• 控制视图的跳转

登陆的流程 :登录—>接收用户的登录请求—>处理用户的请求（获取用户登录的参数，username，password）---->交给业务层处理登录业务（判断用户名密码是否正确：事务）—>Dao层查询用户名和密码是否正确–>数据库

过滤器

比如 Shiro安全框架技术就是用Filter来实现的

Filter：过滤器 ，卡在web服务器和servlet之间，用来过滤网站的数据；

用处举例：

• 处理中文乱码
• 处理骂人的词语
• 登录验证….等等

创建一个新工程，不导入javaweb的模板，然后在工程名称上右键添加Frameworksupport然后选择webapplication。然后pom导入依赖

<dependencies>
    <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>4.0.1</version>
        <scope>provided</scope>
    </dependency>

    <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/javax.servlet.jsp-api -->
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>javax.servlet.jsp-api</artifactId>
        <version>2.3.3</version>
        <scope>provided</scope>
    </dependency>
    <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-impl -->
    <dependency>
        <groupId>org.apache.taglibs</groupId>
        <artifactId>taglibs-standard-impl</artifactId>
        <version>1.2.5</version>
        <scope>runtime</scope>
    </dependency>
    <!--复制的最新版本的-->
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.26</version>
    </dependency>
</dependencies>

然后建包创建文件，这个时候要注意 implements Filter idea自动补全会有很多的Filter版本，一定一定要选择javax.servlet版本的

导入后按照提示重写三个方法。。。。。。

在CharacterEncodingFilter.java 中写

public class CharacterEncodingFilter implements Filter {
    //初始化：web服务器启动，就以及初始化了，随时等待过滤对象出现！
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化");
    }
    //Chain : 链
          /*
          1. 过滤中的所有代码，在过滤特定请求的时候都会执行
          2. 必须要让过滤器继续同行
              chain.doFilter(request,response);
           */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");

        System.out.println("CharacterEncodingFilter执行前....");
        chain.doFilter(request,response); //让我们的请求继续走，如果不写，程序到这里就被拦截停止！
        System.out.println("CharacterEncodingFilter执行后....");
    }
    //销毁：web服务器关闭的时候，过滤器会销毁
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");
    }
}

在showservlet.java中写

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    resp.getWriter().write("你好");

}

在web.xml中添加如下：

<servlet>
    <servlet-name>showservlet</servlet-name>
    <servlet-class>com.szg.filter.showSerlvet</servlet-class>
</servlet>
<!--这个就会经过过滤器-->
<servlet-mapping>
    <servlet-name>showservlet</servlet-name>
    <url-pattern>/servlet</url-pattern>
</servlet-mapping>
<!--这个路径就不会经过过滤器-->
<servlet-mapping>
    <servlet-name>showservlet</servlet-name>
    <url-pattern>/show</url-pattern>
</servlet-mapping>

<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>com.szg.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <!--只要是 /servlet的任何请求，都会经过这个过滤器-->
    <url-pattern>/servlet/*</url-pattern>
    <!--任何请求，都会经过这个过滤器-->
    <!--<url-pattern>/*</url-pattern>-->
</filter-mapping>

克服了不支持java5版本的错误之后，成功运行，达到了预期的效果。

监听器

有许多许多种监听器，往往是根据需求而确定采取那种监听器

下面例子是一个关于session监听器的例子

OnlineCountListener.java文件

//通过统计网站的session数目统计当前网站的在线人数
public class OnlineCountListener implements HttpSessionListener {
    //创建session监听：
    //一旦创建Session就会触发一次这个事件！
    public void sessionCreated(HttpSessionEvent se) {
        //获取的是Servlet容器对象,相当于tomcat容器了.
        ServletContext ctx = se.getSession().getServletContext();
        //System.out.println(se.getSession().getId());
        int session_sum=0;
        if(ctx.getAttribute("OnlineCount")==null){
            session_sum=1;
        }
        else{
            session_sum=(int)ctx.getAttribute("OnlineCount")+1;
        }
        //狂神使用 Integer 也是可以的
        //int是基本数据类型Integer是int的一个包装类(wrapper)，他是类不是基本数据类型,他的内部其实包含一个int型的数据那为什么要用Integer呢，主要是因为面向对象的思想，
        //这里直接从转化为了int类型
        ctx.setAttribute("OnlineCount",session_sum);

    }
    //手动销毁session监听
    //一旦销毁Session就会触发一次这个事件！
    //应该也有自动销毁，就比如设置有效期
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

        int session_sum=0;
        if(ctx.getAttribute("OnlineCount")==null){
            System.out.println("error");
        }
        else{
            session_sum=(int)ctx.getAttribute("OnlineCount")-1;
        }
        //狂神使用 Integer（int） 其实已经过时了  在idea中会被画横线
        //int是基本数据类型Integer是int的一个包装类(wrapper)，他是类不是基本数据类型,他的内部其实包含一个int型的数据那为什么要用Integer呢，主要是因为面向对象的思想，
        //这里直接从转化为了int类型
        ctx.setAttribute("OnlineCount",session_sum);

    }
}

web.xml文件 注册监听器

<listener>
    <listener-class>com.szg.listener.OnlineCountListener</listener-class>
</listener>

在index.jsp中写一句代码：

使用application也是可以的，两者等价

<h1>当前有 <span style="color: red"><%= application.getAttribute("OnlineCount")
 %> </span>人在线</h1>

 <h1>当前有 <span style="color: red"><%=this.getServletConfig().getServletContext().getAttribute("OnlineCount")
 %> </span>人在线</h1>

session过期时间：web.xml

<session-config>
    <session-timeout>100</session-timeout>
</session-config>

一开始有可能浏览器可能会创建多个会话，我的是3个，重新部署项目如下图，选择Redeploy就可以了

同时开不同的浏览器可以查看效果：

在edge和谷歌两个浏览器上同时访问就会出现如图所示

关掉一个之后在线人数不会减少是因为之关闭了浏览器没有手动销毁，只能等他们自己到达保质期。

过滤器、监听器常见应用

监听器：GUI编程中经常使用；

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("中秋节快乐");  //新建一个窗体
        Panel panel = new Panel(null); //面板
        frame.setLayout(null); //设置窗体的布局
        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255)); //设置背景颜色
        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,255,0)); //设置背景颜色
        frame.add(panel);
        frame.setVisible(true);//可见
        //有swing那味了
        //监听事件，监听关闭事件
        frame.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
                System.out.println("123");//点击关闭就会输出
            }
        });
    }
}

过滤器：用户登录的使用；

用户登录之后才能进入主页！用户注销后就不能进入主页了！

1. 用户登录之后，向Sesison中放入用户的数据
2. 进入主页的时候要判断用户是否已经登录；要求：在过滤器中实现！

• 在web目录下创建sys文件夹，然后在里面创建一个success.jsp 写登陆成功的页面

<body>
<%
    //加上这段话之后，就不能够通过直接敲网址进入这个页面了
    Object UserSession = request.getSession().getAttribute(constant.USER_SESSION);
    if(UserSession==null){
        response.sendRedirect("/Login.jsp");
    }
%>
<h1>登陆成功页面</h1>
<%-- 通过servlet注册的映射 转到 LogoutServlet.java文件 进行后台的一些处理 --%>
<h2><a href="/servlet/logout">注销</a></h2>
</body>

<%--                分界线                   --%>

<body>
<h1>error！</h1>
<a href="/Login.jsp">返回</a>
</body>

• 在web目录下创建error.jsp 写错误页面

注意 不要和success一样建立在sys文件夹中！！ 后面使用过滤器会导致不断重定向而页面崩溃！！！一定要注意！！！

注销或者未登录的情况下不允许进入sys目录 --来自弹幕

<body>
<h1>error！</h1>
<a href="/Login.jsp">返回</a>
</body>

• 在com.szg包中创建servlet文件夹，然后在里面创建一个LoginServlet.java 进行处理

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取前端 的参数
        String username = req.getParameter("username");
        if(username.equals("admin")){
            req.getSession().setAttribute("USER_SESSION",req.getSession().getId());
            resp.sendRedirect("/sys/success.jsp");
        }
        else{
            resp.sendRedirect("/error.jsp");
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

• 在servlet文件夹中创建一个LogoutServlet.java 进行处理

public class LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object user_session = req.getSession().getAttribute(constant.USER_SESSION);
        if(user_session!=null){
            req.getSession().removeAttribute(constant.USER_SESSION);
        } resp.sendRedirect("/Login.jsp"); //记得带斜杠
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

• 在web目录下创建Login.jsp文件，写登录页面

<body>
<h1>登陆界面</h1>
<form action="servlet/login" method="post">
    <input type="text" name="username">
    <input type="submit">
    </form>
</body>

• 注册servlet 注意请求路径要求必须是/servlet/login

<servlet>
    <servlet-name>hello_login</servlet-name>
    <servlet-class>com.szg.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>hello_login</servlet-name>
    <url-pattern>/servlet/login</url-pattern>
</servlet-mapping>

<servlet>
    <servlet-name>logout</servlet-name>
    <servlet-class>com.szg.servlet.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>logout</servlet-name>
    <url-pattern>/servlet/logout</url-pattern>
</servlet-mapping>

• 写一个util包，里面建一个constant.java文件，里面定义一个常量，如果是一个大工程，当频繁地使用一个变量的时候可以设置成为一个常量，这样可以更加方便维护。

//定义了一个常变量
public final static String  USER_SESSION="USER_SESSION";
//在其他的java文件使用时，就可以直接写 constant.USER_SESSION  在上面的代码中有一些地方就使用了。

！！！至此，不使用过滤器的版本就完成了！！反正我运行没有问题了（

• 创建一个过滤器

public class SysFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //强转为子类是可以的
        HttpServletRequest request=(HttpServletRequest) servletRequest;
        HttpServletResponse response=(HttpServletResponse) servletResponse; 
        System.out.println("经过了一次过滤器");
        if(request.getSession().getAttribute(constant.USER_SESSION)==null){
            response.sendRedirect("/error.jsp");
        }
        filterChain.doFilter(request,response);
    }
}

• xml中注册一下 对sys目录下的所有文件进行过滤

<filter>
    <filter-name>SysFilter</filter-name>
    <filter-class>com.szg.filter.SysFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SysFilter</filter-name>
    <url-pattern>/sys/*</url-pattern>
</filter-mapping>

JDBC复习

神魔是JDBC？ ： java连接上了数据库！

需要jar包的支持：

• java.sql
• javax.sql
• mysql-conneter-java… 连接驱动（必须要导入）

实验环境搭建

首先在sqlyog中创建一张表：

CREATE TABLE users(
    id INT PRIMARY KEY,
    `name` VARCHAR(40),
    `password` VARCHAR(40),
    email VARCHAR(60),
    birthday DATE
);
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(1,'张三','123456','[e-mail]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','[e-mail]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','[e-mail]','2000-01-01');

SELECT	* FROM users;

在IDEA中，新建一个工程Maven的空白模板，然后在pom.xml 中导入依赖

<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

我又回来了。。。导入8.0的以来之后后面的加载驱动加载不出来。。 导入5.1的吧。。有点慢刷新一下

<!--mysql的驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

然后在IDEA中连接数据库，将jdbc打上勾加载出来。可以在左上角的放大镜处搜索database出来。（

IDEA连接数据库出现的时区问题：Server returns invalid timezone. Go to ‘Advanced’ tab and set ‘serverTimezone’ property manually解决办法 - 梦想家小崔 - 博客园 (cnblogs.com)

注意下面的六个步骤：

public class test_jdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        //useSSL=false 解决 Mysql在高版本需要指明是否进行SSL连接。
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url="jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";

        //1.加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接数据库,代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);

        //3.向数据库发送SQL的对象Statement,PreparedStatement : CRUD
        // 不安全可能会发生sql注入
        Statement statement = connection.createStatement();

        //4.直接编写SQL
        String sql1 = "select * from users";
        String sql2 = "delete from user where id=3";
        //5.执行查询SQL，返回一个 ResultSet  ： 结果集    z:受影响的行数
        ResultSet rs = statement.executeQuery(sql1);
        int z=statement.executeUpdate(sql2);
        //循环 输出结果集
        while (rs.next()){
            System.out.println("id="+rs.getObject("id"));
            System.out.println("name="+rs.getObject("name"));
            System.out.println("password="+rs.getObject("password"));
            System.out.println("email="+rs.getObject("email"));
            System.out.println("birthday="+rs.getObject("birthday"));
        }

        //6.关闭连接，释放资源（一定要做） 先开后关
        rs.close();
        statement.close();
        connection.close();
    }
}

写完代码之后，点击main所在一行的左边的绿色三角形运行。

预编译sql：

public class test_jdbc2 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        String url="jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";
        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写SQL 使用问号作为占位符  后面需要自己填充
        String sql = "insert into  users(id, name, password, email, birthday) values (?,?,?,?,?);";
        //4.预编译 尽量对应好数据类型  插入的数据比如主键要保证唯一，原表里不存在
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,4);//给第一个占位符？ 的值赋值为1；
        preparedStatement.setString(2,"szg");
        preparedStatement.setString(3,"123456");
        preparedStatement.setString(4,"[e-mail]");
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));
        //5.执行SQL
        int z = preparedStatement.executeUpdate();
        if (z>0){
            System.out.println("插入成功");
        }
        preparedStatement.close();
        connection.close();
    }
}

JDBC 事务

事务：要么都成功，要么都失败

ACID原则：原子性 一致性 持久性 隔离性 ）保证数据安全性

开启事务
事务提交 commit() 事务一旦提交就不可修改
事务回滚 rollback()
关闭事务

非常经典的例子就是银行用户之间转钱

junit测试：加上junit依赖包之后，不需要依赖main主函数即可随时运行测试一个函数方法。

依赖包：

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

import org.junit.Test;
//当包import不出来时，刷新一下maven
public class test_jdbc3 {
    @Test
    public void test(){
        System.out.println("测试");
    }
}

此时test函数可以直接运行，输出“测试”而不需要通过main启动

先创建一个表：

CREATE TABLE account(
`id` INT PRIMARY KEY AUTO_INCREMENT,
`name` VARCHAR(10),
`money` FLOAT
);
INSERT INTO account(`name`,`money`) VALUES('A',1000);
INSERT INTO account(`name`,`money`) VALUES('B',1000);
INSERT INTO account(`name`,`money`) VALUES('C',1000);

public class test_jdbc3 {
    @Test
    public void test() {
        String url = "jdbc:mysql://localhost:3306/jdbc?useSSL=false&useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";

        Connection connection = null;

        try {
            Class.forName("com.mysql.jdbc.Driver");
             connection = DriverManager.getConnection(url, username, password);

            //通知数据库开启事务,false 自动提交关闭 开启了手动提交
            connection.setAutoCommit(false);
            String sql = "update account set money = money-100 where name ='A'";
            connection.prepareStatement(sql).executeUpdate();
            //制造错误 如果遇到错误就会中途停止 转账失败
            //int i = 1/0;
            String sql2 = "update account set money = money+100 where name = 'B'";
            connection.prepareStatement(sql2).executeUpdate();
            connection.commit();//以上两条SQL都执行成功了，就提交事务！
            System.out.println("success");

        } catch (Exception e) { //套娃快乐
            try {
                //如果出现异常，就通知数据库回滚事务
                assert connection != null;
                connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            try {
                assert connection != null;
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}