JavaWeb基础02

最新推荐文章于 2022-05-11 23:12:59 发布

不脱发的业内人士

最新推荐文章于 2022-05-11 23:12:59 发布

阅读量172

点赞数

分类专栏： JavaWeb

本文链接：https://blog.csdn.net/weixin_52181177/article/details/118653187

版权

JavaWeb 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

7、Cookie、Session

7.1、会话

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

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

你能怎么证明你是绿地的学生？

你绿地

发票绿地给你发票
学校登记绿地标记你来过了

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

客户端服务端

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

7.2、保存会话的两种技术

cookie

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

session

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

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

7.3、Cookie

在这里插入图片描述

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

package com.chen.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 {
        //服务器告诉你来的时间，把这个时间封装成为一个信件，下次带来，我就知道你来了

        //解决中文乱码
		resp.setContentType("text/html; Charset=UTF-8");

        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的有效期
        cookie.setMaxAge(24*60*60);//有效期一天
        
        resp.addCookie(cookie);

    }

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

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")//解码

7.4、Session（重点）

在这里插入图片描述

什么是Session：

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

Session和cookie的区别：

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

使用场景：

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

package com.chen.servlet;

import com.chen.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 SessionDemo01 extends HttpServlet {

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

        //解决乱码问题
        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);
    }

}

package com.chen.servlet;

import com.chen.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 {

        //解决乱码问题
        req.setCharacterEncoding("utf-8");
        resp.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);
    }
}

package com.chen.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
        session.invalidate();
    }

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

package com.chen.pojo;

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

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

    public Person() {
    }

    public String getName() {
        return name;
    }

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

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

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

   <servlet>
        <servlet-name>SessionDemo01</servlet-name>
        <servlet-class>com.chen.servlet.SessionDemo01</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionDemo01</servlet-name>
        <url-pattern>/s1</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>SessionDemo02</servlet-name>
        <servlet-class>com.chen.servlet.SessionDemo02</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionDemo02</servlet-name>
        <url-pattern>/s2</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>SessionDemo03</servlet-name>
        <servlet-class>com.chen.servlet.SessionDemo03</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>SessionDemo03</servlet-name>
        <url-pattern>/s3</url-pattern>
    </servlet-mapping>

会话自动过期：web.xml配置

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

8、JSP

8.1、什么是JSP

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

最大的特点：

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

8.2、JSP原理

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

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

tomcat中有一个work目录；

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

在这里插入图片描述

发现页面转变成了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>\n");

在这里插入图片描述

8.3、JSP基础语法

修改web.xml为最新

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">

</web-app>

添加依赖

  <!-- servlet的依赖 -->
  <dependencies>
  <dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
  </dependency>

  <!-- JSP的依赖 -->
  <dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>javax.servlet.jsp-api</artifactId>
    <version>2.3.3</version>
  </dependency>

    <!-- JSTL表达式的依赖，这个表达式要依赖一些标签，下面taglibs就是标签库 -->
    <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>
    </dependency>

  </dependencies>

任何语言都有自己的语法，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>");
  %>

在这里插入图片描述

这里的"="号就类似于out.print()

在输出的代码片段JSP表达式和JSp脚本片段的输出地方可以相互转换

在这里插入图片描述

脚本片段的再实现

  <%
    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 ok(){
      System.out.println("进入了方法ok！");
    }
  %>

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

JSP的注释不会在源代码显示，HTML注释会在源代码显示！

总结：

<%%>
<%=%>
<%!%>

<%--注释--%>

8.4、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"/>

在这里插入图片描述

8.5、九大内置对象

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

<%--
  Created by IntelliJ IDEA.
  User: Lenovo
  Date: 2021/6/6
  Time: 11:45
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%-- 内置对象 --%>

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

%>

<%
    //从pageContext取出，我们通过寻找的方式来
    //从底层到高层（作用域）：page->request->session->application
    //JVM：委派机制
    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");//不存在
    
    //pageContext.forward("/pageDemo02.jsp");转发

%>

<%-- 使用EL表达式输出 ,EL表达式会自动过滤没有设置的值，不会输出null --%>

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

</body>
</html>

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

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

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

8.6、JSp标签、JSTL标签、EL表达式

    <!-- JSTL表达式的依赖，这个表达式要依赖一些标签，下面taglibs就是标签库 -->
    <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>
    </dependency>

EL表达式： ${ }

获取数据
执行运算
获取web开发的常用对象

jsp标签

<%--
  Created by IntelliJ IDEA.
  User: Lenovo
  Date: 2021/6/6
  Time: 15:54
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>


<%--jsp:include--%>

<jsp:forward page="/jsptag2.jsp">

    <jsp:param name="name" value="chen"></jsp:param>
    <jsp:param name="age" value="3"></jsp:param>

</jsp:forward>



</body>
</html>

JSTL标签包括以下标签

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

格式化标签

SQL标签

XML 标签

JSTL函数

核心标签 （掌握部分）

在这里插入图片描述

JSTL标签库使用步骤

引入对应的 taglib

引用核心标签库的语法如下：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

引用格式化标签库的语法如下：
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

引用SQL标签库的语法如下：
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>

引用XML标签库的语法如下：
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>

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

c：if

<%--
  Created by IntelliJ IDEA.
  User: Lenovo
  Date: 2021/6/6
  Time: 16:26
  To change this template use File | Settings | File Templates.
--%>
<%@ 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>

<h3>if测试</h3>

<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>
</html>

c：when

<%--
  Created by IntelliJ IDEA.
  User: Lenovo
  Date: 2021/6/6
  Time: 16:54
  To change this template use File | Settings | File Templates.
--%>
<%@ 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>

<%--定义一个变量score，值为85--%>
<c:set var="score" value="85"/>

<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>
</html>

c：foreach

<%--
  Created by IntelliJ IDEA.
  User: Lenovo
  Date: 2021/6/6
  Time: 17:04
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%

    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>

</body>
</html>

9、JavaBean

实体类

JavaBean有特定的写法：

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

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

ORM ：对象关系映射

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

id	name	age	address
1	陈禹汐	3	成都
2	小花	18	北京
3	小红	15	西安

package com.chen.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 + '\'' +
                '}';
    }
}

<%@ 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.chen.pojo.People" scope="page"/>

<jsp:setProperty name="people" property="address" value="成都"/>
<jsp:setProperty name="people" property="id" value="1"/>
<jsp:setProperty name="people" property="age" value="3"/>
<jsp:setProperty name="people" property="name" value="陈禹汐"/>

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

</body>
</html>

10、MVC三层架构

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

10.1、以前的架构

在这里插入图片描述

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

servlet--CRUD-->数据库
弊端：程序十分臃肿，不利于维护  
servlet的代码中：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码

架构：没有什么是加一层解决不了的！
程序猿调用
↑
JDBC （实现该接口）
↑
Mysql Oracle SqlServer ....（不同厂商）

10.2、MVC三层架构

在这里插入图片描述

Model

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

View

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

Controller （Servlet）

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

控制视图的跳转

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

11、Filter(重点)

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

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

（比如用来过滤网上骂人的话，我***我自己）

在这里插入图片描述

Filter开发步骤：

导包，，注意导包不要错

在这里插入图片描述

编写过滤器

实现Filter接口，重写对应的方法即可

package com.chen.filter;

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

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销毁");
    }
}

在web.xml中配置 Filter

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.chen.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <!--只要是/servlet的任何请求，会经过这个过滤器-->
        <url-pattern>/servlet/*</url-pattern>
        <!--<url-pattern>/*</url-pattern> 整个网站都会经过这个过滤器，不建议这样写-->
        <!-- 别偷懒写个 /* -->
    </filter-mapping>

12、监听器

实现一个监听器的接口；（有n种监听器）

编写一个监听器

实现监听器的接口，重写对应的方法即可

package com.chen.listener;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

//统计网站在线人数 ： 统计session
public class OnlineCountListener implements HttpSessionListener {

    //创建session监听：看你的一举一动
    //一旦创建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);

    }

    //销毁session监听
    //一旦销毁Session就会触发一次这个事件！
    public void sessionDestroyed(HttpSessionEvent se) {
        ServletContext ctx = se.getSession().getServletContext();

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

    }
}

web.xml中注册监听器

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

<!-- 很多监听器不会在前端显示，看情况是否使用-->

index.xml

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

<h2>当前有<span><%=request.getServletContext().getAttribute("OnlineCount")%>人在线</span></h2>
</body>
</html>

13、过滤器、监听器常见应用

监听器：GUI编程(图形界面编程)中经常使用；

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

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

    }
}

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

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

package com.chen.servlet;

import com.chen.util.Constant;

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(Constant.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);
    }
}

package com.chen.servlet;

import com.chen.util.Constant;

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 LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        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);
    }
}

package com.chen.filter;

import com.chen.util.Constant;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class SysFliter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        //ServletRequest 父子关系  HttpServletRequest
        HttpServletRequest request1=(HttpServletRequest) request;
        HttpServletResponse response1=(HttpServletResponse) response;

        if(request1.getSession().getAttribute(Constant.USER_SESSION)==null){
            response1.sendRedirect("/error.jsp");
        }

        chain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

package com.chen.util;

public class Constant {
    public static String USER_SESSION = "USER_SESSION";
}
//将用户session提取为常量有利于维护和修改

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

<h1>登录</h1>

<form action="/servlet/Login" method="post">
    <input type="text" name="username">
    <input type="submit">
</form>

</body>
</html>

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

<h1>错误</h1>

<p><a href="/Login.jsp">返回登录页面</a></p>

</body>
</html>

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


<h1>主页</h1>

<p><a href="/servlet/logout">注销</a></p>

</body>
</html>

   <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.chen.servlet.LoginServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/servlet/Login</url-pattern>
    </servlet-mapping>

    <servlet>
        <servlet-name>LogoutServlet</servlet-name>
        <servlet-class>com.chen.servlet.LogoutServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>LogoutServlet</servlet-name>
        <url-pattern>/servlet/logout</url-pattern>
    </servlet-mapping>


    <filter>
        <filter-name>SysFliter</filter-name>
        <filter-class>com.chen.filter.SysFliter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>SysFliter</filter-name>
        <!--只要是/servlet的任何请求，会经过这个过滤器-->
        <url-pattern>/sys/*</url-pattern>
        <!--<url-pattern>/*</url-pattern> 整个网站都会经过这个过滤器，不建议这样写-->
        <!-- 别偷懒写个 /* -->
    </filter-mapping>

14、JDBC复习

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

在这里插入图片描述

需要jar包的支持：

java.sql
javax.sql
mysql-conneter-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','zs@qq.com','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','ls@qq.com','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','ww@qq.com','2000-01-01');


SELECT	* FROM users;

导入数据库依赖

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

IDEA中连接数据库：

在这里插入图片描述

JDBC 固定步骤：

加载驱动
连接数据库,代表数据库
创建向数据库发送SQL的对象Statement : CRUD
编写SQL （根据业务，不同的SQL）
执行SQL
关闭连接（先开的后关）

package com.chen.test;

import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        //配置信息
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url="jdbc:mysql://localhost:3306/jdbc?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
        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("email="+rs.getObject("email"));
            System.out.println("birthday="+rs.getObject("birthday"));
            System.out.println("===================================");
        }

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

预编译SQL

package com.chen.test;

import java.sql.Connection;
import java.sql.Date;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

public class TestJdbc2 {
        public static void main(String[] args) throws Exception {
            //配置信息
            //useUnicode=true&characterEncoding=utf-8 解决中文乱码
            String url="jdbc:mysql://localhost:3306/jdbc?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
            String sql = "insert into  users(id, name, password, email, birthday) values (?,?,?,?,?);";

            //4.预编译
            PreparedStatement preparedStatement = connection.prepareStatement(sql);

            preparedStatement.setInt(1,4);//给第一个占位符？ 的值赋值为4；
            preparedStatement.setString(2,"陈禹汐");//给第二个占位符？ 的值赋值为狂神说Java；
            preparedStatement.setString(3,"123456");//给第三个占位符？ 的值赋值为123456；
            preparedStatement.setString(4,"1870943033@qq.com");//给第四个占位符？ 的值赋值为1；
            preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));//给第五个占位符？ 的值赋值为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:1000
    
A(900)   --100-->   B(1100)

Junit单元测试

依赖

<!--单元测试-->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

简单使用

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

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

搭建一个环境测试事务

CREATE TABLE account(
   id INT PRIMARY KEY AUTO_INCREMENT,
   `name` VARCHAR(40),
   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);

package com.chen.test;

import org.junit.Test;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class TestJdbc3 {
    @Test
    public void test() {
        //配置信息
        //useUnicode=true&characterEncoding=utf-8 解决中文乱码
        String url="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8";
        String username = "root";
        String password = "123456";

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

15、SMBMS(超市管理项目)

在这里插入图片描述

数据库：

在这里插入图片描述

项目如何搭建？
考虑是不是用maven？ jar包，依赖

15.1、搭建项目准备工作

搭建一个maven web 项目
配置Tomcat
测试项目是否能够跑起来
导入项目中需要的jar包;
jsp，Servlet，mysql驱动jstl，stand…
构建项目包结构
编写实体类
ROM映射:表-类映射

编写基础公共类

数据库配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306?useUnicode=true&characterEncoding=utf-8
user=root
password=123456

编写数据库的公共类

package com.chen.dao;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

/**
 * 操作数据库的公共类
 * @author Administrator
 *
 */
public class BaseDao {
	
	static{//静态代码块,在类加载的时候执行
		init();
	}
	
	private static String driver;
	private static String url;
	private static String user;
	private static String password;
	
	//初始化连接参数,从配置文件里获得
	public static void init(){
		Properties params=new Properties();
		String configFile = "database.properties";
		InputStream is=BaseDao.class.getClassLoader().getResourceAsStream(configFile);
		try {
			params.load(is);
		} catch (IOException e) {
			e.printStackTrace();
		}
		driver=params.getProperty("driver");
		url=params.getProperty("url");
		user=params.getProperty("user");
		password=params.getProperty("password");

	}   
	
	
	/**
	 * 获取数据库连接
	 * @return
	 */
	public static Connection getConnection(){
		Connection connection = null;
		try {
			Class.forName(driver);
			connection = DriverManager.getConnection(url, user, password);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		return connection;
	}
	/**
	 * 查询操作
	 * @param connection
	 * @param pstm
	 * @param rs
	 * @param sql
	 * @param params
	 * @return
	 */
	public static ResultSet execute(Connection connection,PreparedStatement pstm,ResultSet rs,
			String sql,Object[] params) throws Exception{
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);
		}
		rs = pstm.executeQuery();
		return rs;
	}
	/**
	 * 更新操作
	 * @param connection
	 * @param pstm
	 * @param sql
	 * @param params
	 * @return
	 * @throws Exception
	 */
	public static int execute(Connection connection,PreparedStatement pstm,
			String sql,Object[] params) throws Exception{
		int updateRows = 0;
		pstm = connection.prepareStatement(sql);
		for(int i = 0; i < params.length; i++){
			pstm.setObject(i+1, params[i]);
		}
		updateRows = pstm.executeUpdate();
		return updateRows;
	}
	
	/**
	 * 释放资源
	 * @param connection
	 * @param pstm
	 * @param rs
	 * @return
	 */
	public static boolean closeResource(Connection connection,PreparedStatement pstm,ResultSet rs){
		boolean flag = true;
		if(rs != null){
			try {
				rs.close();
				rs = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		if(pstm != null){
			try {
				pstm.close();
				pstm = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		if(connection != null){
			try {
				connection.close();
				connection = null;//GC回收
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				flag = false;
			}
		}
		
		return flag;
	}

}

编写字符编码过滤器

package com.chen.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class CharacterEncodingFilter implements Filter {

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub

	}

	@Override
	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		// TODO Auto-generated method stub
		request.setCharacterEncoding("UTF-8");
		response.setCharacterEncoding("UTF-8");
		response.setContentType("text/html;charset=UTF-8");
		chain.doFilter(request, response);
	}

	@Override
	public void destroy() {
		// TODO Auto-generated method stub

	}

}

    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>com.chen.filter.CharacterEncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <!--只要是/servlet的任何请求，会经过这个过滤器-->
        <url-pattern>/*</url-pattern>
        <!--<url-pattern>/*</url-pattern> 整个网站都会经过这个过滤器，不建议这样写-->
        <!-- 别偷懒写个 /* -->
    </filter-mapping>

导入静态资源

15.2、登录功能实现

在这里插入图片描述

编写前端页面

 <!-- 设置欢迎页面-->
    <welcome-file-list>
        <welcome-file>login.jsp</welcome-file>
    </welcome-file-list>

编写dao层登录用户登录的接口

package com.chen.dao.user;

import com.chen.pojo.User;

import java.sql.Connection;

public interface UserDao {
    //得到要登录的用户
    public User getLoginUser(Connection connection, String userCode) throws Exception;

}

编写dao层接口的实现类

package com.chen.dao.user;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import com.chen.dao.BaseDao;
import com.chen.pojo.User;

public class UserDaoImpl implements UserDao{
    //持久层只做查询数据库的内容
    public User getLoginUser(Connection connection, String userCode) throws Exception{
        //准备三个对象
        PreparedStatement pstm = null;
        ResultSet rs = null;
        User user = null;
        //判断是否连接成功
        if(null != connection){
            String sql = "select * from smbms_user where userCode=?";
            Object[] params = {userCode};
            rs = BaseDao.execute(connection, pstm, rs, sql, params);
            if(rs.next()){
                user = new User();
                user.setId(rs.getInt("id"));
                user.setUserCode(rs.getString("userCode"));
                user.setUserName(rs.getString("userName"));
                user.setUserPassword(rs.getString("userPassword"));
                user.setGender(rs.getInt("gender"));
                user.setBirthday(rs.getDate("birthday"));
                user.setPhone(rs.getString("phone"));
                user.setAddress(rs.getString("address"));
                user.setUserRole(rs.getInt("userRole"));
                user.setCreatedBy(rs.getInt("createdBy"));
                user.setCreationDate(rs.getTimestamp("creationDate"));
                user.setModifyBy(rs.getInt("modifyBy"));
                user.setModifyDate(rs.getTimestamp("modifyDate"));
            }
            BaseDao.closeResource(null, pstm, rs);
        }
        return user;
    }
}

业务层接口

package com.chen.service.user;

import com.chen.pojo.User;


public interface UserService {

    public User login(String userCode, String password) throws Exception;

}

业务层实现类

package com.chen.service.user;

import java.sql.Connection;

//import org.junit.Test;

import com.chen.dao.BaseDao;
import com.chen.dao.user.UserDao;
import com.chen.dao.user.UserDaoImpl;
import com.chen.pojo.User;
import org.junit.Test;

public class UserServiceImpl implements UserService {
    //业务层都会调用dao层.所以我们要引入Dao层（重点）
    //只处理对应业务

    private UserDao userDao;
    public UserServiceImpl(){
        userDao = new UserDaoImpl();
    }

    @Override
    public User login(String userCode, String password) throws Exception {

        Connection connection = null;
        //通过业务层调用对应的具体数据库操作
        User user = null;
        try {
            connection = BaseDao.getConnection();
            user = userDao.getLoginUser(connection, userCode);
        } catch (Exception e) {

            e.printStackTrace();
        }finally{
            BaseDao.closeResource(connection, null, null);
        }
        return user;
    }


//	@Test
//	public void test() throws Exception {
//		UserServiceImpl userService = new UserServiceImpl();
//		String userCode = "admin";
//		String userPassword = "12345678";
//		User admin = userService.login(userCode, userPassword);
//		System.out.println(admin.getUserPassword());
//
//	}

}

编写Servlet

package com.chen.servlet.user;

import com.chen.pojo.User;
import com.chen.service.user.UserService;
import com.chen.service.user.UserServiceImpl;
import com.chen.util.Constants;

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


public class LoginServlet extends HttpServlet {


	public void doGet(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {

	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		System.out.println("login ============ " );
		//获取用户名和密码
		String userCode = request.getParameter("userCode");
		String userPassword = request.getParameter("userPassword");
		//调用service方法，进行用户匹配
		UserService userService = new UserServiceImpl();
		User user = null;
		try {
			user = userService.login(userCode,userPassword);
		} catch (Exception e) {
			e.printStackTrace();
		}
		if(null != user){//登录成功
			//放入session
			request.getSession().setAttribute(Constants.USER_SESSION,user);
			//页面跳转（frame.jsp）
			response.sendRedirect("jsp/frame.jsp");
		}else{
			//页面跳转（login.jsp）带出提示信息--转发
			request.setAttribute("error", "用户名或密码不正确");
			request.getRequestDispatcher("login.jsp").forward(request, response);
		}

	}


}

提取常量

package com.chen.util;

public class Constants {
    public final static String USER_SESSION = "userSession";

}

注册Servlet

    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.chen.servlet.user.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login.do</url-pattern>
    </servlet-mapping>

测试访问,保证以上功能可以成功

15.3、登录功能优化

注销功能：

思路：移除session，返回登录界面

package com.chen.servlet.user;

import com.chen.util.Constants;

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 LogoutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //清除session
        req.getSession().removeAttribute(Constants.USER_SESSION);
        resp.sendRedirect(req.getContextPath()+"/login.jsp");//返回登录页面

    }

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

注册xml

    <servlet>
        <servlet-name>LogoutServlet</servlet-name>
        <servlet-class>com.chen.servlet.user.LogoutServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LogoutServlet</servlet-name>
        <url-pattern>/jsp/logout.do</url-pattern>
    </servlet-mapping>

15.4、登录拦截优化

编写一个过滤器，并注册

package com.chen.filter;

import com.chen.pojo.User;
import com.chen.util.Constants;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class SysFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest request1 = (HttpServletRequest) request;
        HttpServletResponse response1 = (HttpServletResponse) response;
        //过滤器，从session中获取用户
        User user = (User)request1.getSession().getAttribute(Constants.USER_SESSION);
        if(user == null){//已经被移除或者注销了，或者未登录
            response1.sendRedirect("/smbms/error.jsp");
        }else {
            chain.doFilter(request, response);
        }
        
    }

    @Override
    public void destroy() {

    }
}

注册xml

    <!-- 用户登录过滤器 -->
    <filter>
        <filter-name>SysFilter</filter-name>
        <filter-class>com.chen.filter.SysFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>SysFilter</filter-name>
        <url-pattern>/jsp/*</url-pattern>
    </filter-mapping>

测试，登录，注销，权限，都要保证OK

15.5、密码修改

导入前端素材

<li><a href="${pageContext.request.contextPath }/jsp/pwdmodify.jsp">密码修改</a></li>

写项目，建议从底层向上写

在这里插入图片描述

UserDao接口

//修改当前用户密码
	public int updatePwd(Connection connection,int id,int password)throws SQLException, Exception;

UserDao接口实现类

@Override//修改当前密码
	public int updatePwd(Connection connection, int id, int password) throws Exception {
、
		PreparedStatement pstm = null;
		int execute =0;
		if(connection!=null) {
			String sql = "update smbms_user set = userPassword = ? where id = ?";
			Object[] params = {password,id};
			execute = BaseDao.execute(connection, pstm, sql, params);
			BaseDao.closeResource(null, pstm, null);
		}
		return execute;			
	}

UserService层

        //根据用户ID修改密码
    public boolean updatePwd(int id,int password)throws SQLException, Exception;

UserService实现类

public boolean updatePwd(int id, int password) throws SQLException, Exception {
            Connection connection = null;
            boolean flag = false;
            //修改密码
            try {
                connection = BaseDao.getConnection();
                if(userDao.updatePwd(connection, id, password)>0) {
                    flag = true;
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                BaseDao.closeResource(connection, null, null);
            }
            return flag;
        }

servlet记得实现复用，要提取出方法！

package com.chen.servlet.user;

import com.chen.pojo.User;
import com.chen.service.user.UserService;
import com.chen.service.user.UserServiceImpl;
import com.chen.util.Constants;

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.sql.SQLException;

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

        String method = req.getParameter("method");
        if (method.equals("savepwd") && method != null) {
            this.updatePwd(req, resp);
        }
        //实现复用~~~~~~
        // 想添加新的增删改查，直接用if(method.equals("savepwd") && method != null);
    }

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


    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) {
        // 通过session获得用户id
        Object o = req.getSession().getAttribute(Constants.USER_SESSION);
        String newpassword = req.getParameter("newpassword");
        boolean flag = false;
        if (o != null && newpassword != null) {
            UserService userService = new UserServiceImpl();

            try {
                flag = userService.updatePwd(((User) o).getId(), newpassword);
            } catch (SQLException e) {

                e.printStackTrace();
            } catch (Exception e) {

                e.printStackTrace();
            }
            if (flag) {
                req.setAttribute("message", "密码修改成功，请退出，使用新密码登录");
                // 密码修改成功,移除session(移除后不能再次修改密码,建议不移除)
                req.getSession().removeAttribute(Constants.USER_SESSION);
            } else {
                // 密码修改失败
                req.setAttribute("message", "密码修改失败");
            }

        } else {
            // 密码修改有问题
            req.setAttribute("message", "新密码有问题");
        }
        try {
            req.getRequestDispatcher("/jsp/pwdmodify.jsp").forward(req, resp);
        } catch (ServletException e) {

            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        }
    }
}

注册xml

    <servlet>
        <servlet-name>UserServlet</servlet-name>
        <servlet-class>com.chen.servlet.user.UserServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>UserServlet</servlet-name>
        <url-pattern>/jsp/user.do</url-pattern>
    </servlet-mapping>

测试

15.6、优化密码修改使用Ajax

阿里巴巴的fastjson

<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.68</version>
</dependency>

后台代码修改

package com.chen.servlet.user;

import com.alibaba.fastjson.JSONArray;
import com.chen.pojo.User;
import com.chen.service.user.UserService;
import com.chen.service.user.UserServiceImpl;
import com.chen.util.Constants;
import com.mysql.jdbc.StringUtils;

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.io.PrintWriter;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map;

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

        String method = req.getParameter("method");
        if (method.equals("savepwd") && method != null) {
            this.updatePwd(req, resp);
        }else if (method.equals("pwdmodify") && method !=null){
            this.pwdmodify(req, resp);

        }
        //实现复用~~~~~~
        // 想添加新的增删改查，直接用if(method.equals("方法名") && method != null);
    }

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

    //修改密码
    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) {
        // 通过session获得用户id
        Object o = req.getSession().getAttribute(Constants.USER_SESSION);
        String newpassword = req.getParameter("newpassword");
        boolean flag = false;
        if (o != null && newpassword != null) {
            UserService userService = new UserServiceImpl();

            try {
                flag = userService.updatePwd(((User) o).getId(), newpassword);
            } catch (SQLException e) {

                e.printStackTrace();
            } catch (Exception e) {

                e.printStackTrace();
            }
            if (flag) {
                req.setAttribute("message", "密码修改成功，请退出，使用新密码登录");
                // 密码修改成功,移除session(移除后不能再次修改密码,建议不移除)
                req.getSession().removeAttribute(Constants.USER_SESSION);
            } else {
                // 密码修改失败
                req.setAttribute("message", "密码修改失败");
            }

        } else {
            // 密码修改有问题
            req.setAttribute("message", "新密码有问题");
        }
        try {
            req.getRequestDispatcher("/jsp/pwdmodify.jsp").forward(req, resp);
        } catch (ServletException e) {

            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        }
    }

    //验证旧密码，session中有用户的密码
    public void pwdmodify(HttpServletRequest req, HttpServletResponse resp){
        // 通过session获得用户id
        Object o = req.getSession().getAttribute(Constants.USER_SESSION);
        String oldpassword = req.getParameter("oldpassword");
        //万能的Map：结果集
        Map<String, String> resultMap = new HashMap<String, String>();
        if(o==null) {//session失效，session过期了
            resultMap.put("result","seesionerror");
        }else if(StringUtils.isNullOrEmpty(oldpassword)){//输入密码为空
            resultMap.put("result","error");
        }else {
            String userPassword = ((User)o).getUserPassword();//seesion中的用户密码
            if(oldpassword.equals(userPassword)) {
                resultMap.put("result","true");
            }else {
                resultMap.put("result","false");
            }
        }

        try {
            resp.setContentType("application/josn");
            PrintWriter writer = resp.getWriter();
            //JsonArray 阿里巴巴的SON工具类，转换格式
            /*
             * resultMap = ["result","sessionerror","result",error]
             * josn格式={key,value
             */
            writer.write(JSONArray.toJSONString(resultMap));
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

测试

15.7、用户管理实现

在这里插入图片描述

导入分页的工具类-PageSupport
用户列表页面导入-userlist.jsp

1、获取用户数量

UserDao

//查询记录数
	public int getUserCount(String username, int userRole);

UserDaoImpl

    @Override
    public int getUserCount(Connection connection, String username, int userRole) throws SQLException, Exception {
            PreparedStatement pstm = null;
            ResultSet rs = null;
            int count = 0;

            if(connection != null){
                StringBuffer sql = new StringBuffer();
                sql.append("select count(1) as count from smbms_user u,smbms_role r where u.userRole = r.id");
                List<Object> list = new ArrayList<Object>();//存放我们的参数

                if(!StringUtils.isNullOrEmpty(username)){
                    sql.append(" and u.userName like ?");
                    list.add("%"+username+"%");//默认开始index：0
                }

                if(userRole > 0){
                    sql.append(" and u.userRole = ?");
                    list.add(userRole);//默认开始index：1
                }

                Object[] params = list.toArray();//怎么把list转换为数组

                System.out.println("UserDaoImpl --> getUserCount：" + sql.toString());//输出最后完整的SQL语句
                rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);

                if(rs.next()){
                    count = rs.getInt("count");//从结果集中获取最终的数量
                }

                BaseDao.closeResource(null, pstm, rs);
            }
            return count;
        }

UserService

//查询记录数
public int getUserCount(String username, int userRole);

UserServiceImpl

    @Override
    //查询记录数
    public int getUserCount(String username, int userRole) {
            Connection connection = null;
            int count = 0;

            try {
                connection = BaseDao.getConnection();
                count = userDao.getUserCount(connection, username,userRole);
            } catch (Exception e) {
                e.printStackTrace();
            }finally{
                BaseDao.closeResource(connection, null, null);
            }
            return count;
        }

2、获取用户列表

UserDao

//通过条件查询-userList
	public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize)throws Exception;

UserDaoImpl

@Override
public List<User> getUserList(Connection connection, String userName, int userRole, int currentPageNo, int pageSize) throws Exception {

        PreparedStatement pstm = null;
        ResultSet rs = null;
        List<User> userList = new ArrayList<User>();
        if(connection != null){
            StringBuffer sql = new StringBuffer();
            sql.append("select u.*,r.roleName as userRoleName from smbms_user u,smbms_role r where u.userRole = r.id");
            List<Object> list = new ArrayList<Object>();
            if(!StringUtils.isNullOrEmpty(userName)){
                sql.append(" and u.userName like ?");
                list.add("%"+userName+"%");
            }
            if(userRole > 0){
                sql.append(" and u.userRole = ?");
                list.add(userRole);
            }
            //在数据库中，分页显示 limit startIndex，pageSize；总数
            //当前页  (当前页-1)*页面大小
            //0,5  1  0    01234
            //5,5  2  5    56789
            //10,5 3  10    10~
            sql.append(" order by creationDate DESC limit ?,?");
            currentPageNo = (currentPageNo-1)*pageSize;
            list.add(currentPageNo);
            list.add(pageSize);

            Object[] params = list.toArray();
            System.out.println("sql ----> " + sql.toString());

            rs = BaseDao.execute(connection, pstm, rs, sql.toString(), params);
            while(rs.next()){
                User _user = new User();
                _user.setId(rs.getInt("id"));
                _user.setUserCode(rs.getString("userCode"));
                _user.setUserName(rs.getString("userName"));
                _user.setGender(rs.getInt("gender"));
                _user.setBirthday(rs.getDate("birthday"));
                _user.setPhone(rs.getString("phone"));
                _user.setUserRole(rs.getInt("userRole"));
                _user.setUserRoleName(rs.getString("userRoleName"));
                userList.add(_user);
            }
            BaseDao.closeResource(null, pstm, rs);
        }
        return userList;
    }

UserService

//根据条件查询用户列表
	public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize);

UserServiceImpl

    @Override
    public List<User> getUserList(String queryUserName, int queryUserRole, int currentPageNo, int pageSize) {
            Connection connection = null;
            List<User> userList = null;
            System.out.println("queryUserName ---- > " + queryUserName);
            System.out.println("queryUserRole ---- > " + queryUserRole);
            System.out.println("currentPageNo ---- > " + currentPageNo);
            System.out.println("pageSize ---- > " + pageSize);
            
            try {
                connection = BaseDao.getConnection();
                userList = userDao.getUserList(connection, queryUserName,queryUserRole,currentPageNo,pageSize);
            } catch (Exception e) {

                e.printStackTrace();
            }finally{
                BaseDao.closeResource(connection, null, null);
            }
            return userList;
        }

3、获取角色操作

为了我们的职责统一，我们可以把角色的操作单独放在一个包中，和pojo类对应…

RoleDao

package com.chen.dao.role;

import com.chen.pojo.Role;

import java.sql.Connection;
import java.util.List;

public interface RoleDao {
    //获取角色列表
    public List<Role> getRoleList(Connection connection)throws Exception;
}

RoleDaoIpml

package com.chen.dao.role;

import com.chen.dao.BaseDao;
import com.chen.pojo.Role;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;

public class RoleDaoImpl implements RoleDao{

    @Override
    public List<Role> getRoleList(Connection connection) throws Exception {
        PreparedStatement pstm = null;
        ResultSet rs = null;
        List<Role> roleList = new ArrayList<Role>();
        if (connection != null) {
            String sql = "select * from smbms_role";
            Object[] params = {};
            rs = BaseDao.execute(connection, pstm, rs, sql, params);
            while (rs.next()) {
                Role _role = new Role();
                _role.setId(rs.getInt("id"));
                _role.setRoleCode(rs.getString("roleCode"));
                _role.setRoleName(rs.getString("roleName"));
                roleList.add(_role);
            }
            BaseDao.closeResource(null, pstm, rs);
        }

        return roleList;
    }

}

RoleService

package com.chen.service.role;

import com.chen.pojo.Role;
import java.util.List;

public interface RoleService {

    //获取角色列表
    public List<Role> getRoleList();

}

RoleServiceIpml

package com.chen.service.role;

import com.chen.dao.BaseDao;
import com.chen.dao.role.RoleDao;
import com.chen.dao.role.RoleDaoImpl;
import com.chen.pojo.Role;

import java.sql.Connection;
import java.util.List;

public class RoleServiceImpl implements RoleService{

    //导入Dao
    private RoleDao roleDao;
    public RoleServiceImpl(){roleDao = new RoleDaoImpl();}

    @Override
    public List<Role> getRoleList() {
        Connection connection = null;
        List<Role> roleList = null;
        try {
            connection = BaseDao.getConnection();
            roleList = roleDao.getRoleList(connection);
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            BaseDao.closeResource(connection, null, null);
        }
        return roleList;
    }

}

4、用户显示的Servlet

获取用户前端的数据（查询）
判断请求是否需要执行，看参数的值判断
为了实现分页，需要计算出当前页面和总页面，页面大小…
用户列表展示
返回前端

package com.chen.servlet.user;

import com.alibaba.fastjson.JSONArray;
import com.chen.pojo.Role;
import com.chen.pojo.User;
import com.chen.service.role.RoleServiceImpl;
import com.chen.service.user.UserService;
import com.chen.service.user.UserServiceImpl;
import com.chen.util.Constants;
import com.chen.util.PageSupport;
import com.mysql.jdbc.StringUtils;

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.io.PrintWriter;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserServlet extends HttpServlet {

    //实现复用~~~~~~
    // 想添加新的增删改查，直接用if(method.equals("方法名") && method != null);
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String method = req.getParameter("method");
        if (method.equals("savepwd") && method != null) {
            this.updatePwd(req, resp);
        }else if (method.equals("pwdmodify") && method !=null){
            this.pwdmodify(req, resp);
        }else if (method.equals("query") && method !=null){
            this.query(req,resp);

        }
    }

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

    //重点、难点
    public void query(HttpServletRequest req, HttpServletResponse resp){

        //查询用户列表
        //从前端获取数据
        String queryUserName = req.getParameter("queryname");
        String temp = req.getParameter("queryUserRole");
        String pageIndex = req.getParameter("pageIndex");
        int queryUserRole = 0;

        //获取用户列表
        UserServiceImpl userService = new UserServiceImpl();
        List<User> userList = null;

        //第一次请求肯定是走第一页，页面大小固定的
        //设置页面容量
        int pageSize = 5;//可以把这个写在在配置文件里,后面方便修改
        //当前页码
        int currentPageNo = 1;

        if(queryUserName == null){
            queryUserName = "";
        }
        if(temp != null && !temp.equals("")){
            queryUserRole = Integer.parseInt(temp);//给查询赋值
        }
        if(pageIndex != null) {
            currentPageNo = Integer.parseInt(pageIndex);
        }


        //获取用户总数（分页	上一页：下一页的情况）
        //总数量（表）
        int totalCount = userService.getUserCount(queryUserName,queryUserRole);

        //总页数支持
        PageSupport pageSupport = new PageSupport();
        pageSupport.setCurrentPageNo(currentPageNo);
        pageSupport.setPageSize(pageSize);
        pageSupport.setTotalCount(totalCount);


        //(totalCount+pageSize-1/pageSize)取整
        // pageSupport.getTotalCount()

        //System.out.println("totalCount ="+totalCount);
        //System.out.println("pageSize ="+pageSize);
        //System.out.println("totalPageCount ="+totalPageCount);

        int totalPageCount =pageSupport.getTotalPageCount();//总共有几页
        //控制首页和尾页
        //如果页面小于 1 就显示第一页的东西
        if(currentPageNo < 1) {
            currentPageNo = 1;
        }else if(currentPageNo > totalPageCount) {//如果页面大于了最后一页就显示最后一页
            currentPageNo =totalPageCount;
        }
        //获取用户列表展示
        userList = userService.getUserList(queryUserName, queryUserRole, currentPageNo, pageSize);
        req.setAttribute("userList", userList);

        RoleServiceImpl roleService = new RoleServiceImpl();
        List<Role> roleList = roleService.getRoleList();
        req.setAttribute("roleList", roleList);
        req.setAttribute("totalCount", totalCount);
        req.setAttribute("currentPageNo", currentPageNo);
        req.setAttribute("totalPageCount", totalPageCount);
        req.setAttribute("queryUserName", queryUserName);
        req.setAttribute("queryUserRole", queryUserRole);

        //返回前端
        try {
            req.getRequestDispatcher("userlist.jsp").forward(req, resp);
        } catch (ServletException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    //修改密码
    public void updatePwd(HttpServletRequest req, HttpServletResponse resp) {
        // 通过session获得用户id
        Object o = req.getSession().getAttribute(Constants.USER_SESSION);
        String newpassword = req.getParameter("newpassword");
        boolean flag = false;
        if (o != null && newpassword != null) {
            UserService userService = new UserServiceImpl();

            try {
                flag = userService.updatePwd(((User) o).getId(), newpassword);
            } catch (SQLException e) {

                e.printStackTrace();
            } catch (Exception e) {

                e.printStackTrace();
            }
            if (flag) {
                req.setAttribute("message", "密码修改成功，请退出，使用新密码登录");
                // 密码修改成功,移除session(移除后不能再次修改密码,建议不移除)
                req.getSession().removeAttribute(Constants.USER_SESSION);
            } else {
                // 密码修改失败
                req.setAttribute("message", "密码修改失败");
            }

        } else {
            // 密码修改有问题
            req.setAttribute("message", "新密码有问题");
        }
        try {
            req.getRequestDispatcher("/jsp/pwdmodify.jsp").forward(req, resp);
        } catch (ServletException e) {

            e.printStackTrace();
        } catch (IOException e) {

            e.printStackTrace();
        }
    }

    //验证旧密码，session中有用户的密码
    public void pwdmodify(HttpServletRequest req, HttpServletResponse resp){
        // 通过session获得用户id
        Object o = req.getSession().getAttribute(Constants.USER_SESSION);
        String oldpassword = req.getParameter("oldpassword");
        //万能的Map：结果集
        Map<String, String> resultMap = new HashMap<String, String>();
        if(o==null) {//session失效，session过期了
            resultMap.put("result","seesionerror");
        }else if(StringUtils.isNullOrEmpty(oldpassword)){//输入密码为空
            resultMap.put("result","error");
        }else {
            String userPassword = ((User)o).getUserPassword();//seesion中的用户密码
            if(oldpassword.equals(userPassword)) {
                resultMap.put("result","true");
            }else {
                resultMap.put("result","false");
            }
        }

        try {
            resp.setContentType("application/josn");
            PrintWriter writer = resp.getWriter();
            //JsonArray 阿里巴巴的SON工具类，转换格式
            /*
             * resultMap = ["result","sessionerror","result",error]
             * josn格式={key,value
             */
            writer.write(JSONArray.toJSONString(resultMap));
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

15.8、小黄鸭调试法：自问式方法

15.9、项目原理流程图

在这里插入图片描述

不脱发的业内人士

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaWeb基础02

7、Cookie、Session7.1、会话会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；你能怎么证明你是绿地的学生？你绿地发票绿地给你发票学校登记绿地标记你来过了一个网站，怎么证明你来过？客户端服务端服务端给客户端一个信件，客户端下次访问服务端带上信件就可以了； cookie服务器登记你来过了，下次你来的时候我来匹配你；
复制链接

扫一扫

专栏目录