Javaweb：servlet、cookie、session、jsp、JavaBean、MVC、Fillter过滤器、监听器、JDBC复习

Servlet

Servlet简介

Servlet就是sun公司开发动态web的一门技术
Sun在这些API中提供一个接口叫作：Servlet，如果你想开发一个Servlet程序，只需要完成两个步骤
- 编写一个类，实现Servlet接口
- 把开发好的Java类部署到Web服务器中
把实现了Servlet接口的Java程序叫作，Servlet

HelloServlet

Servlet接口在Sun公司有两个默认的实现类：HttpServlet、GenericServlet

构建一个普通Maven项目，删掉里面的src目录，以后的学习就在这个项目里面建立Moudel；这个空的工程就Maven的主工程
关于Maven父子工程的理解：

父项目中会有：

<modules>
    <module>servlet-01</module>
</modules>

子项目中会有：

  <parent>
    <artifactId>javaweb-02-servlet</artifactId>
    <groupId>com.li</groupId>
    <version>1.0-SNAPSHOT</version>
  </parent>

父项目中的java子项目可以直接使用

Maven环境优化
1. 修改web.xml为最新的
2. 将maven的结构搭建完整

编写一个Servlet程序

编写一个普通类
实现Servlet接口,这里我们直接继承HttpServlet

public class HelloServlet extends HttpServlet {
    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // ServletOutputStream outputStream = resp.getOutputStream();

        PrintWriter writer = resp.getWriter(); //响应流
        writer.print("Hello,Servlet");
    }

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

编写Servlet的映射

为什么需要映射？我们写的是Java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给它一个浏览器能够访问的路径；

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.li.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--    Servlet的请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

配置Tomcat

启动测试

Servlet原理

Servlet是由Web服务器调用，web服务器在收到浏览器请求之后，

这里可以去看其他的视频学习

Mapping

一个Servlet可以指定一个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

一个Servlet可以指定多个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello1</url-pattern>
</servlet-mapping>
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello2</url-pattern>
</servlet-mapping>

一个Servlet可以指定通用映射路径


<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello/*</url-pattern>
</servlet-mapping>

默认请求路径：（少用这个）

<!--    默认请求路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

指定一些后缀或者前缀等等..

<!--    可以自定义后缀实现请求映射
注意点，*前面不能加映射的路径-->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.ljy</url-pattern>
</servlet-mapping>

优先级问题

指定了固有的映射路径优先级最高，如果找不到就会走默认的处理请求；

<!--    404-->
<servlet>
    <servlet-name>404</servlet-name>
    <servlet-class>com.li.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>404</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

ServletContext

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

应用：

共享数据

我在这个Servlet中保存的数据，可以在另一个Servlet中拿到；
放取它的类：

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


        // this.getInitParameter()  初始化参数
        //this.getServletConfig()   Servlet配置
        //this.getServletContext()   Servlet上下文
        ServletContext context = this.getServletContext();

        String username = "宇";  //数据
        context.setAttribute("username", username); //将一个数据保存在了ServletContext中，名字为：username（第一个）；值为：username（第二个）

    }
}

读取它的类：

public class GetHservlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();

        String username = (String) context.getAttribute("username");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().print("名字" + username);

    }

xml文件：

<servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.li.servlet.HelloServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
    <servlet-name>getc</servlet-name>
    <servlet-class>com.li.servlet.GetHservlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>getc</serAvlet-name>
    <url-pattern>/getc</url-pattern>
</servlet-mapping>

测试访问结果：先访问hello再访问getc，

获取初始化参数

<!-- 配置一些web应用初始化参数-->
<context-param>
    <param-name>url</param-name>
    <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
</context-param>

protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    String url = context.getInitParameter("url");
    resp.getWriter().print(url);
}

请求转发

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    ServletContext context = this.getServletContext();
    System.out.println("进入了Demo04");
    //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); //转发的请求路径
    //requestDispatcher.forward(req,resp);  //调用forward方法实现请求转发；
    context.getRequestDispatcher("/gp").forward(req, resp);

}

读取资源文件

Properties类

在Java目录下新建properties
在resources目录下新建properties

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath；

思路：需要一个文件流；

properties

username=root
password=123456

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

        InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");

        Properties prop = new Properties();
        prop.load(is);
        String user = prop.getProperty("username");
        String pwd = prop.getProperty("password");

        resp.getWriter().print(user + ":" + pwd);


    }

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

访问测试。

HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse。

如果要获取客户端请求过来的参数：找HttpServletRequest
如果要给客户端响应的一些信息：找HttpServletResponse

简单分类

负责向浏览器发送数据的方法

ServletOutputStream getOutputStream() throws IOException;
PrintWriter getWriter() throws IOException;

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

void setCharacterEncoding(String var1);

    void setContentLength(int var1);

    void setContentLengthLong(long var1);

    void setContentType(String var1);

  void setDateHeader(String var1, long var2);

    void addDateHeader(String var1, long var2);

    void setHeader(String var1, String var2);

    void addHeader(String var1, String var2);

    void setIntHeader(String var1, int var2);

    void addIntHeader(String var1, int var2);

响应的状态码：（重点记住 200成功 3xx请求重定向 4xx 404找不到资源 5xx 500服务器错误）

    int SC_CONTINUE = 100;
    int SC_SWITCHING_PROTOCOLS = 101;
    int SC_OK = 200;
    int SC_CREATED = 201;
    int SC_ACCEPTED = 202;
    int SC_NON_AUTHORITATIVE_INFORMATION = 203;
    int SC_NO_CONTENT = 204;
    int SC_RESET_CONTENT = 205;
    int SC_PARTIAL_CONTENT = 206;
    int SC_MULTIPLE_CHOICES = 300;
    int SC_MOVED_PERMANENTLY = 301;
    int SC_MOVED_TEMPORARILY = 302;
    int SC_FOUND = 302;
    int SC_SEE_OTHER = 303;
    int SC_NOT_MODIFIED = 304;
    int SC_USE_PROXY = 305;
    int SC_TEMPORARY_REDIRECT = 307;
    int SC_BAD_REQUEST = 400;
    int SC_UNAUTHORIZED = 401;
    int SC_PAYMENT_REQUIRED = 402;
    int SC_FORBIDDEN = 403;
    int SC_NOT_FOUND = 404;
    int SC_METHOD_NOT_ALLOWED = 405;
    int SC_NOT_ACCEPTABLE = 406;
    int SC_PROXY_AUTHENTICATION_REQUIRED = 407;
    int SC_REQUEST_TIMEOUT = 408;
    int SC_CONFLICT = 409;
    int SC_GONE = 410;
    int SC_LENGTH_REQUIRED = 411;
    int SC_PRECONDITION_FAILED = 412;
    int SC_REQUEST_ENTITY_TOO_LARGE = 413;
    int SC_REQUEST_URI_TOO_LONG = 414;
    int SC_UNSUPPORTED_MEDIA_TYPE = 415;
    int SC_REQUESTED_RANGE_NOT_SATISFIABLE = 416;
    int SC_EXPECTATION_FAILED = 417;
    int SC_INTERNAL_SERVER_ERROR = 500;
    int SC_NOT_IMPLEMENTED = 501;
    int SC_BAD_GATEWAY = 502;
    int SC_SERVICE_UNAVAILABLE = 503;
    int SC_GATEWAY_TIMEOUT = 504;
    int SC_HTTP_VERSION_NOT_SUPPORTED = 505;

常见应用（下载文件）

向浏览器输出消息
下载文件
1. 要获取下载文件的路径
2. 下载的文件名是什么？
3. 设置想办法让浏览器能够支持下载我们需要的东西
4. 获取下载文件的输入流
5. 创建缓冲区
6. 获取OutputStream对象
7. 将FileOutputStream流写入到buffer缓冲区
8. 使用OutputStream将缓冲区中的数据输出到客户端！

package com.li.servlet;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.URLEncoder;

public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //  1. 要获取下载文件的路径
    String realPath = "F:\\Learning software cache\\自学\\JavaWeb\\Maven\\javaweb-02-servlet\\response\\target\\classes\\1.png";
    System.out.println("下载文件的路径:" + realPath);
    //  2. 下载的文件名是什么？
    String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
    //  3. 设置想办法让浏览器能够支持下载我们需要的东西,中文文件名； URLEncoder.encode编码  否则可能乱码。
    resp.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(fileName, "utf-8"));
    //  4. 获取下载文件的输入流
    FileInputStream in = new FileInputStream(realPath);

    //  5. 创建缓冲区
    int len = 0;
    byte[] buffer = new byte[1024];
    //  6. 获取OutputStream对象
    ServletOutputStream out = resp.getOutputStream();
    //  7. 将FileOutputStream流写入到buffer缓冲区,使用OutputStream将缓冲区中的数据输出到客户端！

    while ((len = in.read(buffer)) > 0) {
        out.write(buffer, 0, len);

    }
    in.close();
    out.close();
}


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

验证码功能

验证怎么来的？

前段实现
后端实现，需要用到Java的图片类，生产一个图片

package com.li.servlet;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;

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

        // 如何让浏览器5S自动刷新一次
        resp.setHeader("refresh", "3");

        // 在内存中创建一个图片
        BufferedImage image = new BufferedImage(80, 20, BufferedImage.TYPE_INT_RGB);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();  //相当于笔
        // 设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0, 0, 80, 20);
        //给图片写数据
        g.setColor(Color.black);
        g.setFont(new Font(null, Font.BOLD, 20));
        g.drawString(makeNum(), 0, 20);

        //告诉浏览器，这个请求用图片的方式打开
        resp.setContentType("image/jpeg");
        //网站存在缓存，不让浏览器缓存
        resp.setDateHeader("expires", -1);
        resp.setHeader("Cache-Control", "no-cache");
        resp.setHeader("Pragma", "no-cache");

        //把图片写给浏览器
        ImageIO.write(image, "jpg", resp.getOutputStream());

    }

    //生成随机数
    private String makeNum() {
        Random random = new Random();
        String num = random.nextInt(9999999) + "";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < 7 - num.length(); i++) {
            sb.append("0");
        }
        String s = sb.toString() + num;
        return num;

    }

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

实现重定向（重要）

（b)一个Web资源收到客户端请求后，(B)他会通知客户端(A)去访问另一个web资源(C)，这个过程叫重定向。

void sendRedirect(String var1) throws IOException;

测试：

   @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
       /*
       重定向原理     这里的down是我Tomcat里设置的URL
       resp.setHeader("Location","/down/img");
       resp.setStatus(302);
        */

        resp.sendRedirect("/down/img");  //重定向

    }

代码：

package com.li.servlet;

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

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        // System.out.println("进入这个请求了");
        //处理请求
        String usename = req.getParameter("usename");
        String password = req.getParameter("password");
        System.out.println(usename + ":" + password);

        //重定向的时候一定要注意路径问题，否则就是404
        resp.sendRedirect("/down/success.jsp");
    }

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

index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello World!</h2>

<%--这里提交的路径，需要寻找到项目的路径--%>
<%--pageContext.request.contextPath代表当前的项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
    用户名：<input type="text" name="usename"><br>
    密码：<input type="password" name="password"><br>
    <input type="submit">
</form>
</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>Success</h1>
</body>
</html>

面试题：

请你聊聊重定向和转发的区别：

相同点：

页面都会实现跳转

不同点：

请求转发的时候，URL不会发生变化
重定向的时候，URL地址栏会发生变化。

HttpServletRequest

HttpServletRequest代表客户端的请求，用户通过Http协议访问服务器，HTTP请求中的所以信息会被封装到HttpServletRequest，通过这个HttpServletRequest的方法，获得客户端的所有信息；

获取前端传递的参数并请求转发

package com.li.servlet;

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

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String[] hobbys = req.getParameterValues("hobbys");
        System.out.println("=============================");
        //后台接收中文乱码问题：
        System.out.println(username);
        System.out.println(password);
        System.out.println(Arrays.toString(hobbys));
        System.out.println("=============================");

        //通过请求转发
        req.getRequestDispatcher("/success.jsp").forward(req, resp);

    }

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>登录</title>
</head>
<body>
<h1>登录</h1>
<div style="text-align: center">
    <%--    这里表单表示的意思：以Post方式提交表单，提交到我们的login请求--%>
    <form action="${pageContext.request.contextPath}/login" method="post">
        用户名：<input type="text" name="username"> <br>
        密 码：<input type="password" name="password"><br>
        爱 好：
        <input type="checkbox" name="hobbys" value="女孩">女孩
        <input type="checkbox" name="hobbys" value="代码">代码
        <input type="checkbox" name="hobbys" value="篮球">篮球
        <br>
        <input type="submit">
    </form>
</div>

</body>
</html>

success.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录成功</h1>
</body>
</html>

面试题：

请你聊聊重定向和转发的区别：

相同点：

页面都会实现跳转

不同点：

请求转发的时候，URL不会发生变化 307
重定向的时候，URL地址栏会发生变化。 302

Cookie、Session

会话

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

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

保存会话的两种技术：

Cookie

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

Session

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

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

从请求中拿到cookie信息
服务器响应给客户端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); //设置一个有效期
resp.addCookie(cookie);  //响应给客户端一个cookie

代码：

package com.li.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("gb2312");
        resp.setCharacterEncoding("gb2312");

        PrintWriter out = resp.getWriter();

        //Cookie,服务器端从客户端获取
        Cookie[] cookies = req.getCookies(); //这里返回数组,说明cookie可能存在多个

        //判断cookie是否存在
        if (cookies != null) {
            //如果存在怎么办
            out.write("你上一次访问的时间是：");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                //获得cookie的名字
                if (cookie.getName().equals("lastLoginTime")) {
                    //获取cookie中的值
                    long lastLoginTime = Long.parseLong(cookie.getValue());
                    Date date = new Date(lastLoginTime);
                    out.write(date.toLocaleString());


                }

            }

        } else {
            out.write("这是你第一次访问本网站");
        }

        //服务器给客户端响应（发送）一个cookie

        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");
        //给cookie设置一个有效时间(1天)
        cookie.setMaxAge(24 * 60 * 60);
        resp.addCookie(cookie);


    }

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

一个网站cookie是否存在上限！ 细节问题

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

删除Cookie：

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

package com.li.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 CookieDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //创建一个cookie，名字必须要和要删除的名字一致
        Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis() + "");

        //将cookie有效区设置为0
        cookie.setMaxAge(0);

        resp.addCookie(cookie);

    }

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

编码解码：

URLEncoder.encode("李","utf-8");
URLDecoder.decode(cookie.getValue(),"utf-8");

Session(重点！！！)

什么是Session：

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

常用方法：

Session和Cookie的区别：

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

使用场景

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

使用Session代码：

demo01

package com.li.servlet;

import pojo.Person;

import javax.servlet.ServletException;
import javax.servlet.http.*;
import java.io.IOException;

public class SessionDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码问题
        resp.setCharacterEncoding("UTF-8");
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();

        //给Session中存东西
        session.setAttribute("name", new Person("李", 1));

        //获取Session的ID
        String sessionID = session.getId();

        //判断session是不是新创建的
        if (session.isNew()) {
            resp.getWriter().write("session创建成功,ID:" + sessionID);
        } else {
            resp.getWriter().write("session已经在服务器中存在了,ID:" + sessionID);

        }
        //Session创建的时候做了什么事情
//        Cookie cookie = new Cookie("JSESSIONID",sessionID);
//        resp.addCookie(cookie);

    }

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

demo02

package com.li.servlet;

import pojo.Person;

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 SessionDemo02 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //解决乱码问题
        resp.setCharacterEncoding("UTF-8");
        req.setCharacterEncoding("UTF-8");
        resp.setContentType("text/html;charset=utf-8");
        //得到Session
        HttpSession session = req.getSession();

        Person person = (Person) session.getAttribute("name");
        System.out.println(person.toString());
    }

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

demo03

package com.li.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 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);
    }
}

person

package pojo;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

web.xml 设置会话自动过期

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

JSP

什么是JSP

Java Server Pages ： Java服务器端页面，也和Servlet一样，用于动态Web技术！

最大的特点：

写JSP就像在写HTML
区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入JAVA代码，为用户提供动态数据；

JSP原理

思路：JSP到底怎么执行的！

代码层面没有任何问题
服务器内部工作

tomcat中有一个work目录；

IDEA中使用Tomcat的会在IDEA的tomcat中生产一个work目录

我电脑的地址：

C:\Users\Administrator\AppData\Local\JetBrains\IntelliJIdea2020.2\tomcat\Unnamed_javaweb-session-cookie_2\work\Catalina\localhost\ROOT\org\apache\jsp

发现页面转变成了Java程序！

浏览器向服务器发送请求，不管访问什么资源其实都是在访问Servlet

JSP最终也会被转换成为一个Java类！

JSP 本质上就是一个Servlet

//初始化
  public void _jspInit() {
      
  }
//销毁
  public void _jspDestroy() {
  }
//JSPService
  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                      //响应

输出页面前增加的代码

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页面中直接使用！

在JSP页面中；

只要是 JAVA代码就会原封不动的输出；

如果是HTML代码，就会被转换为：

out.write("<html>\r\n");

这样的格式，输出到前端！

JSP基础语法：

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

JSP表达式 <% %>

  <%--JSP表达式
  作用：用来将程序的输出，输出到客户端
  <%= 变量或者表达式%>
  --%>
  <%= new java.util.Date()%>

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);
  %>
  <p>这是一个JSP文档</p>
  <%
    int y = 2;
    out.println(y);
  %>

  <hr>


  <%--在代码嵌入HTML元素--%>
  <%
    for (int i = 0; i < 5; i++) {
  %>
    <h1>Hello,World  <%=i%> </h1                                                                                         >
  <%
    }
  %>

JSP声明

  <%!
    static {
      System.out.println("Loading Servlet!");
    }

    private int globalVar = 0;

    public void kuang(){
      System.out.println("进入了方法Kuang！");
    }
  %>

JSP声明：会被编译到JSP生成Java的类中！其他的，就会被生成到_jspService方法中！

在JSP，嵌入Java代码即可！

<%%>   片段
<%=%>   表达式
<%!%>   声明

<%--注释--%>

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

JSP定制错误页面

JSP指令（了解）

<%@page args.... %>
<%@include file=""%>

<%--@include会将两个页面合二为一--%>

<%@include file="common/header.jsp"%>
<h1>网页主体</h1>

<%@include file="common/footer.jsp"%>

<hr>


<%--jSP标签
    jsp:include：拼接页面，本质还是三个
    --%>
<jsp:include page="/common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="/common/footer.jsp"/>

9大内置对象

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号");  //保存的数据只在服务器中有效，从打开服务器到关闭服务器

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

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

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

测试：这里如果name5用<%=name5%>这结果最后会有一个null。所以一般不使用，建议用EL表达式

JSP标签、JSTL标签、EL表达式

<!--    jstl表达式的依赖-->
<dependency>
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>
<!--    standard标签库-->
<dependency>
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>

EL表达式：${}

获取数据
执行运算
获取web开发的常用对象
调用Java方法（不用了解比较麻烦）

JSP标签

<%--jsp:include--%>

<%--
http://localhost:8080/jsptag.jsp?name=kuangshen&age=12
--%>

<jsp:forward page="/jsptag2.jsp">
    <jsp:param name="name" value="kuangshen"></jsp:param>
    <jsp:param name="age" value="12"></jsp:param>
</jsp:forward>

JSTL表达式

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

格式化标签

SQL标签

XML 标签

核心标签 （掌握部分）

JSTL标签库使用步骤

引入对应的taglib
使用其中的方法
在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

<head>
    <title>Title</title>
</head>
<body>


<h4>if测试</h4>

<hr>

<form action="coreif.jsp" method="get">
    <%--
    EL表达式获取表单中的数据
    ${param.参数名}
    --%>
    <input type="text" name="username" value="${param.username}">
    <input type="submit" value="登录">
</form>

<%--判断如果提交的用户名是管理员，则登录成功--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="管理员欢迎您！"/>
</c:if>

<%--自闭合标签--%>
<c:out value="${isAdmin}"/>

</body>

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

<%

    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, 要遍历的对象
begin,   哪里开始
end,     到哪里
step,   步长
--%>
<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有特定的写法：

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

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

ORM：对象关系映射

表--->类
字段---->数据
行记录---->对象

People表

id	name	age	address
1	1号	2	重庆
2	2号	13	重庆
3	3号	15	重庆

class People{
    private int id;
    private String name;
    private int age;
    private String address;
    
}

class A{
    new  People(1,"1号",3,"重庆");
}

练习代码：

<%@ page import="com.li.pojo.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<%
    //  People people = new People();
%>
<jsp:useBean id="people" class="com.li.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="address" value="重庆"/>
<jsp:setProperty name="people" property="name" value="1"/>
<jsp:setProperty name="people" property="age" value="2"/>

地址：
<jsp:getProperty name="people" property="address"/>
姓名：
<jsp:getProperty name="people" property="name"/>
年龄：
<jsp:getProperty name="people" property="age"/>

</body>
</html>

package com.li.pojo;

//实体类 我们一般都是和数据库中的表结构一一对应！
public class People {
    private int id;
    private String name;
    private int age;
    private String address;

    public People() {
    }

    public People(int id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "People{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

数据库图：

MVC三层架构

什么是MVC :Model view Controller 模型、视图、控制器

早些年

用户直接访问控制层，控制层就可以直接操作数据库

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层查询用户名和密码是否正确

Filter过滤器（重点）

Filter：过滤器，用来过滤网站的数据；

处理中文乱码
登录验证...

Filter开发步骤：

导包
编写过滤器
1. 导包不要错
2. 实现filter接口

代码

package com.li.filter;


import javax.servlet.*;
import java.io.IOException;

public class CharacterEncodingFilter implements Filter {

    //初始化  web服务器启动.就初始化了，随时等待过滤对象出现
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化");
    }

    @Override
    // 链
    /*
    1.过滤中的所有代码，在过滤特点请求的时候都会执行
    2.必须要让过滤器继续同行
    Chain.doFilter(Request,Response);
     */
    public void doFilter(ServletRequest Request, ServletResponse Response, FilterChain filterChain) throws IOException, ServletException {
        Request.setCharacterEncoding("utf-16");   //过来
        Response.setCharacterEncoding("utf-16");  //过去
        Response.setContentType("text/html;charset=UTF-16");

        System.out.println("CharacterEncodingFilter执行前...");
        filterChain.doFilter(Request, Response); //让我们的请求继续走，如果不写，程序到这里就被拦截停止
        System.out.println("CharacterEncodingFilter执行后...");
    }

    // 销毁
    @Override
    public void destroy() {
        System.out.println("CharacterEncodingFilter销毁");

    }
}

在web.xml中配置Filter

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

监听器（了解）

实现一个监听接口；（有N种）

编写一个监听器

实现监听器的接口

//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
    @Override
    // 创建sesssion监听
    // 一旦创建session就会触发一次这个事件
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        System.out.println(se.getSession().getId());
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount == null) {
            onlineCount = new Integer(1);
        } else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count + 1);
        }

        ctx.setAttribute("OnlineCount", onlineCount);
    }

    @Override
    //销毁session监听
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();
        se.getSession().invalidate();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");

        if (onlineCount == null) {
            onlineCount = new Integer(0);
        } else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count - 1);
        }

        ctx.setAttribute("OnlineCount", onlineCount);
    }
}
/*
Session销毁
1. 手动销毁    se.getSession().invalidate();
2. 自动销毁
 */

web.xml中配置监听器

<!--    注册监听器-->
    <listener>
        <listener-class>com.li.listener.OnlineCountListener</listener-class>
    </listener>

看情况是否使用！

过滤器与监听器的常见应用

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

package com.li.listener;

import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("测试框");  //建立窗口
        Panel panel = new Panel(null);  //面板
        frame.setLayout(null); //设置窗口样式

        frame.setBackground(new Color(0, 0, 255));
        frame.setBounds(400, 400, 500, 500);

        panel.setBounds(100, 100, 300, 300);
        panel.setBackground(new Color(0, 255, 255));

        frame.add(panel);

        frame.setVisible(true);


        // 监听事件，关闭事件
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
    }

}

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

注意：表单这里post方法不能抓取数据 get方法才可以抓取数据。

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

filter代码：

HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;

if (request.getSession().getAttribute("USER_SESSION") == null) {
    response.sendRedirect("/Error.jsp");
}

Chain.doFilter(request, response);

servlet中loginservlet代码：

package com.li.servlet;

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

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);
    }
}

login代码：

<h1>登录</h1>
<form action="/servlet/login" method="get">
    <input type="text" name="username">
    <input type="submit">
</form>

xml：

<filter>
    <filter-name>SysFilter</filter-name>
    <filter-class>com.li.filter.SysFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>SysFilter</filter-name>
    <url-pattern>/Sys/*</url-pattern>
</filter-mapping>

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

JDBC复习

什么是JDBC：Java连接数据库！

需要jar包的支持：

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

实验环境搭建

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','845353@qq.com','1998-12-12');
INSERT INTO `users`(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','8@qq.com','1998-11-12');
INSERT INTO `users`(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','8451@qq.com','1998-10-12');

SELECT *FROM users;

导入数据库依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

IDEA中连接数据库

JDBC固定步骤：

加载驱动
连接数据库，代表数据库
向数据库发送SQL的对象Statement、PreparedStatement：CRUD
编写SQL（根据业务，不同的SQL）
执行SQL
释放资源

public static void main(String[] args) throws ClassNotFoundException, SQLException {
    //配置信息
    //useUnicode=true&characterEncoding=uft-8 解决中文乱码问题
    String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&&useSSL=false";
    String username = "root";
    String password = "ljy123456";

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

    // 3. 向数据库发送SQL的对象statement  ：CRUD
    Statement statement = connection.createStatement();

    // 4.编写SQL
    String sql = "select * from users";

    // 5.执行SQL，返回一个ResultSet  ：结果集
    ResultSet rs = statement.executeQuery(sql);

    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("birthday=" + rs.getObject("birthday"));
    }

    //6.关闭连接，释放资源（必须做） 先开的后关

    rs.close();
    statement.close();
    connection.close();

}

预编译SQL

public class TestDjbc2 {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        //useUnicode=true&characterEncoding=uft-8 解决中文乱码问题
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&&useSSL=false";
        String username = "root";
        String password = "ljy123456";

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

        // 3.编写SQL
        String sql = "insert into users(id, name, password, email, birthday) VALUES (?,?,?,?,?)";


        // 4.预编译  ：CRUD
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1, 6);// 填写第一个？的值为6
        preparedStatement.setString(2, "第三方");// 给第二个占位符？赋值  值为 第三方
        preparedStatement.setString(3, "845465");
        preparedStatement.setString(4, "658485@qq.com");
        preparedStatement.setDate(5, new Date(new java.util.Date().getTime()));

        //5 . 执行SQL
        int i = preparedStatement.executeUpdate();

        if (i > 0) {
            System.out.println("插入成功！");
        }

        //6.关闭连接，释放资源（必须做） 先开的后关


        preparedStatement.close();
        connection.close();

    }
}

事务

要么都成功，要么都不成功！

ACID原则：保证数据的安全。

开启事务
事务提交  commit（）
事务回滚  rollback（）
关闭事务

    
    
转账：
A:1000    B:2000

A(900) ----100-->B(1100)

Junit单元测试

依赖：

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

简单使用

@Test注解只有在方法上有效，只要加了这个注解的方法，就可以直接运行！

@Test
public void test(){
    System.out.println("hello");
}

搭建一个环境实验

public class TestJDBC3 {
    @Test
    public void test() {

        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=false";
        String username = "root";
        String password = "ljy123456";

        Connection connection = null;

        // 1.加载驱动
        try {
            Class.forName("com.mysql.jdbc.Driver");

            // 2.连接数据库，代表数据库
            connection = DriverManager.getConnection(url, username, password);

            // 3. 通知数据库开启事务 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("提交成功");
        } catch (Exception e) {
            try {
                //如果出现异常，就通知数据库回滚事务
                connection.rollback();
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

posted @ 2021-01-26 21:11 喂s别闹阅读(230) 评论(0) 编辑收藏举报

刷新页面返回顶部

Javaweb：servlet、cookie、session、jsp、JavaBean、MVC、Fillter过滤器、监听器、JDBC复习

Servlet

Servlet简介

HelloServlet

Servlet原理

Mapping

ServletContext

共享数据

获取初始化参数

请求转发

读取资源文件

HttpServletResponse

简单分类

常见应用（下载文件）

验证码功能

实现重定向（重要）

面试题：

HttpServletRequest

获取前端传递的参数并请求转发

面试题：

Cookie、Session

会话

保存会话的两种技术：

Cookie

Session(重点！！！)

JSP

什么是JSP

JSP原理

JSP基础语法：

JSP表达式 <% %>

jsp脚本片段

JSP声明

JSP指令（了解）

9大内置对象

JSP标签、JSTL标签、EL表达式

JavaBean

MVC三层架构

早些年

MVC三层架构

Filter过滤器（重点）

监听器（了解）

过滤器与监听器的常见应用

JDBC复习

事务

公告