javaweb

最新推荐文章于 2024-08-13 09:02:16 发布

巡山小钻风つ

最新推荐文章于 2024-08-13 09:02:16 发布

阅读量567

点赞数

分类专栏： java 笔记 web 文章标签： java tomcat maven 后端 idea

本文链接：https://blog.csdn.net/qq_51497041/article/details/121212536

版权

笔记同时被 3 个专栏收录

39 篇文章 2 订阅

订阅专栏

java

27 篇文章 0 订阅

订阅专栏

web

6 篇文章 0 订阅

订阅专栏

4.6 创建javaweb项目文件约定格式

5.6 HttpServletResponse（响应）

6.1 会话（Session），有状态会话（Session）

7.5 JSP标签/JSTL标签/EL表达式

12 Filter实现权限拦截（监听器和过滤器）

动态web流程

web服务器

ASP：

国内最早流行的
缺点维护成本高

php

速度快，功能强大跨平台
无法承载大访问量

JSP/Servlet

B/S：浏览器和服务器
C/S: 客户端和服务器
可以承受三高问题带来的影响：高并发，高可用，高性能

web应用服务器

IIS

微软的，ASP……windows中自带的

tomacat

tomcat

发布web网站

网站应该有的结构

--webapps: Tomacat 服务器的web目录

-ROOT

-kuangstudy：网站的目录名

-web-INF

-classes ：java程序

-lib： web应用所依赖的jar包

-web.xml:网站配置文件

- index.html 默认的首页

-static

-css

-style.css

-js

-img

- ……

3 http讲解

3.1 什么是http

HTTP（超文本传输协议）是一个简单的请求协议，他通常运行再TCP上

文本：html 字符串……
超文本：图片，音乐，视频，定位，地图

HTTPS：安全的，443

3.2 Http

3.2.1 http请求：

百度：

请求（Request） URL:https://www.baidu.com/

请求方法:GET

状态（Status Code）代码:200 OK

远程（Remote）地址:110.242.68.4:443

引用站点策略:origin-when-cross-origin

请求行

请求行中的请求方式：GET
请求方式：Get，Post

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

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

消息头

3.2.2 http 响应：

Cache-Control：private 缓存控制

Connection：Keep-Alive 连接

Content-Encoding：gzip 编码

Content_Type:text/html 类型

3.2.3 响应体

3.2.4 响应状态码（重）

200：请求响应成功

3xx：请求重定向->303

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

4xx：找不到资源 404

资源不存在；

5xx：服务器代码错误 500 502：网关错误

常见面试题：

当你的浏览器中地址栏输入地址并回车的一瞬间到页面能展示出来，经历了什么

答：

4 meven

方便导入jar包

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

有约定不要违反

maven会规定好给如何编写Java代码

4.1 maven下载

Maven传送门
提取码：60v8

4.2 Maven环境变量配置

M2_MAVEN 地址是：maven的bin目录

MAVEN_HOME 地址：maven目录

path中:%MAVEN_HOME%\bin

4.3 镜像 mirror

国内建议阿里镜像：

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

目录：maven——> conf——>settings.xml

4.4 本地仓库

建立本地仓库：localRepository

在maven文件夹里创建文件夹 maven-repo

在settings.xml文件里配置路径

4.5 IDEA中创建Maven

新创建Maven项目

修改为刚才自己安装的maven的地址、配置文件和本地仓库

创建完成后，会自动下载jar包，需要等待初始化完毕

出现BUILD SUCCESS，说明搭建成功

查看本地仓库，会出现jar包

IDEA中的Maven设置

file ——>setting——>Maven

4.6 创建javaweb项目文件约定格式

三种方式：

一、在创建项目时，不勾选

二、自己创建java文件和resources资源文件

然后将将java文件夹和resources设置为源目录和资源目录

三、创建好java和resources目录后，

点击项目结构 ——>模块

可以在这里直接修改

clean 可以清理运行后在target生成的项目

直接双击clean就可以

maven导出问题解决：

问题：maven由于他的约定大于配置，之后可能遇到写配置文件，无法被到处或生效的问题，

解决：添加

5 tomcat

一定要注意：选择tomcat server 不要选tomEE这个

启动Tomcat

5 Servlet

5.1 servlet 简介

Servlet 就是sun公司开发动态web的一门技术
Sun在这些API中提供一个接口叫做：Servlet。

开发一个Servlet程序，只需要完成两步：

编写一个类，实现Servlet接口‘
把开发好的Java类部署到web服务器。

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

5.2 HelloServlet

1.构建普通Maven项目，删掉里面的src目录，在里面建立Moudel，这个空的工程就是Maven主工程。

然后在这个里面可以建立多个web项目，且依赖可以共享！

2.关于Maven父子工程的理解，

父目录中会有

子项目会有

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

son extends father

3.Maven环节优化

修改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>

将maven 的结构搭建完整

4.编写servlet程序

package com.gao.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.io.PrintWriter;

//这里需要点一下导包
public class HelloServlet extends HttpServlet {

    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter();
        writer.print("hello，Serlvet");
    }

    //这里doPost调用上面的doGet
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

5.编写Servlet 的映射

为什么需要映射：我们写的时java程序，但是要通过浏览器访问，而浏览器需要连接web服务器，所以我们要在web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的权限；

在web.xml中写

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

6.配置tomcat

7.启动测试

5.3 Servlet原理

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

step1.浏览器依据ip,port建立与servlet容器之间的链接
step2.浏览器将请求数据打包（即按照http协议的要求，将相关数据封装成一个数据包，一般称之为请求数据包）并发送给servlet容器
step3.servlet容器解析请求数据包，并将解析之后得到的数据放到request对象上。同时，容器还要创建一个response对象。
step4.servlet容器依据请求资源路径（即/web01/hello）找到servlet配置（toncat看到应用名web01之后，会找webapps下面的一个文件夹，也叫web01，进去以后有一个web.xml，打开，然后找到一个一个"/hello"的配置跟<servlet-name>对应，<servlet-name>（如：HelloWorldServlet）又跟<servlet-class>（如:web.HelloWorldServlet）即类名对应，所以容器知道是要处理哪一个类，会调用这个类的构造器去创建servlet对象），然后创建servlet对象。
step5.容器接下来调用servlet对象的service方法，并且会将事先创建好的request对象和response对象作为service方法的
参数传递给servlet对象。
step6.servelt可以通过request对象获得请求参数，进行相应的处理，然后将处理结果写到response对象上。
step7.容器读取response对象上的数据，然后将处理结果打包（响应数据包）并发送给浏览器。
step8.浏览器解析响应数据包，将返回的的数据展现给用户。

5.4 mapping

在web.xml中的映射是从上到下顺序执行的，如果找不到就会走默认的处理请求

5.5 ServletContext

共享数据

tomcat部署里只添加需要测试的项目即可，都添加上，运行时回都打包，会比较慢

XML文件

<servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.gao.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.gao.servlet.GetServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>getc</servlet-name>
        <url-pattern>/getc</url-pattern>
    </servlet-mapping>

public class GetServlet 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);
    }

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

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getServletContext() Servlet上下文
        ServletContext context = this.getServletContext();
        String username = "只狼";//数据
        context.setAttribute("username",username);//将数据保存在了ServletContext中，名字为：username。值为username
    }

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

获取上下文的信息

通过访问/gp可直接获取到url中的value

   <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>


    <servlet>
        <servlet-name>gp</servlet-name>
        <servlet-class>com.gao.servlet.ServletDemo03</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>gp</servlet-name>
        <url-pattern>/gp</url-pattern>
    </servlet-mapping>

public class ServletDemo03 extends HelloServlet{
    @Override
    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 doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

请求转发

A希望拿到C的资源，

public class ServletDemo04 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        System.out.println("进入了ServletDemo04");
        //前半段为转发的路径后半段为转发
        context.getRequestDispatcher("/gp").forward(req,resp);
    }

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

<servlet>
        <servlet-name>sd4</servlet-name>
        <servlet-class>com.gao.servlet.ServletDemo04</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd4</servlet-name>
        <url-pattern>/sd4</url-pattern>
    </servlet-mapping>

读取资源文件

    <servlet>
        <servlet-name>sd5</servlet-name>
        <servlet-class>com.gao.servlet.ServletDemo05</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd5</servlet-name>
        <url-pattern>/sd5</url-pattern>
    </servlet-mapping>

public class ServletDemo05 extends HelloServlet{
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //从web中获取资源（流的形式）
        //路径是相对路径（是在target文件中db的路径）
        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);
    }

5.6 HttpServletResponse（响应）

5.6.1 介绍

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

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

5.6.2 简单分类

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

ServletOutputstream getOurputStream（） throws IOException；

PrintWriter gerWriter() throws IOException;

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

void setCharacterEncoding(String var1);

void setContentLength(int var1);

void setContentLengthLong(long var1);

void setContentType(String var1)

……

5.6.3 常见应用

- 向浏览器输出消息

下载文件：

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

 <servlet>
    <servlet-name>filedown</servlet-name>
    <servlet-class>com.gao.servlet.FileServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>filedown</servlet-name>
    <url-pattern>/filedown</url-pattern>
  </servlet-mapping>
</web-app>

在resources中添加图片，并查看绝对路径赋值到realPath

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        要获取下载文件的路径
          String realPath = "D:\\IJ_soft\\javaweb-02-servlet\\response\\src\\main\\resources\\img.png";
          System.out.println("下载文件的路径："+realPath);
//        下载的文件名是啥
          String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
//        设置想办法让浏览器能够支持下载我们需要的东西
          resp.setHeader("Content-Disposition","attachment;filename"+fileName);
//        获取下载文件的输入流
          FileInputStream in = new FileInputStream(realPath);
//        创建缓冲区
          int len =0;
          byte[] buffer = new byte[1024];
//        获取OutputStream对象
          ServletOutputStream out = resp.getOutputStream();
//        将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);
    }

5.7 response验证码实现

<servlet>
    <servlet-name>ImageSerlet</servlet-name>
    <servlet-class>com.gao.servlet.ImageServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ImageSerlet</servlet-name>
    <url-pattern>/img</url-pattern>
  </servlet-mapping>

public class ImageServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //如何让浏览器3秒自动刷新一次
        resp.setHeader("refresh","3");
        //在内存中创建一个图片
        BufferedImage image = new BufferedImage(80,20,BufferedImage.TYPE_3BYTE_BGR);
        //得到图片
        Graphics2D g = (Graphics2D) image.getGraphics();//笔
        //设置图片的背景颜色
        g.setColor(Color.white);
        g.fillRect(0,0,80,20);
        //设置图片的背景颜色
        g.setColor(Color.BLUE);
        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");
        }
        num = sb.toString() +num;
        return num;
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }

5.8 实现重定向

public class RedirectServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //重定向
        resp.sendRedirect("/response_war/img");

    }

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

  <servlet>
    <servlet-name>RedirectServlet</servlet-name>
    <servlet-class>com.gao.servlet.RedirectServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>RedirectServlet</servlet-name>
    <url-pattern>/red</url-pattern>
  </servlet-mapping>

重定向和转发区别：

相同点：

页面都会发生跳转

不同点：

请求转发的时候url不会发生变化

重定向时url地址栏会发生变化

登录页面（重定向）

java实现页面的重定向

public class RequestTest extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //处理请求
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        System.out.println(username+":"+password);
        //这里重定向注意路径问题
        resp.sendRedirect("/response_war/success.jsp");
    }

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

XML代码

 <servlet>
    <servlet-name>requset</servlet-name>
    <servlet-class>com.gao.servlet.RequestTest</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>requset</servlet-name>
    <url-pattern>/login</url-pattern>
  </servlet-mapping>

表单提交页面

<html>

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

表单跳转到的页面

<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>success</h1>
</body>
</html>

5.9 request

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

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="text" name="password"><br>
            爱好:
            <input type="checkbox" name="hobbys" value="女孩">女孩
            <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>

6 Cookie，Session

6.1 会话（Session），有状态会话（Session）

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

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

1.服务端给客户端一个信件，客户端下次访问服务端信件就可以了；Cookie

2.服务登记你来过了，下次你来的时候我来匹配你，Seesion

6.2 保存会话的两种技术

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

session

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

常见：网站登录后，下次不用再登陆了，

6.2.1 Cookie

从请求中拿到Coolie信息

服务器响应给客户端Cookie

一个网站Cookie是否存在上限：

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

删除Coolie

//创建一个Cookie，名字必须要和要删除的名字一致

Cookie cookie = new Cookie("lastLoginTime",System.currentTimeMillis()+"")

//将cookie有效期设置为0，即立马失效

cookie.setMaxAge(0);

resp.addCookie(cookie);

Cookie中文数据传递（乱码问题解决）

URLEncoder.encode(cookie.getValue(),"UTF-8") //编码

URLDecoder.decode(cookie.getValue(),"UTF-8"); //解码

Cookie保存时间

//保存用户上次访问的时间
public class CookieDemo01 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //服务器：告诉你，你来的时间，把这个时间封装成一个信件，你下次带来，我就知道你来了

        //解决中文乱码问题
        req.setCharacterEncoding("utf-8");
        resp.setCharacterEncoding("utf-8");

        PrintWriter out = resp.getWriter();

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

        //判断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依然存在
        //cookie.setMaxAge(24*60*60);
        resp.addCookie(cookie);
    }

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

<servlet>
    <servlet-name>CookieDemo01</servlet-name>
    <servlet-class>com.kuang.servlet.CookieDemo01</servlet-class>

</servlet>
    <servlet-mapping>
        <servlet-name>CookieDemo01</servlet-name>
        <url-pattern>/c1</url-pattern>
    </servlet-mapping>

6.2.2 Sesion （重）

Session介绍：

服务器会给每个用户（浏览器）创建一个Seesion 对象；
一个Seesion独占一个浏览器，浏览器关闭，Session就不存在
用户登陆之后，整个网站他都可以访问——>保存用户的信息

Session和Cookie的区别：

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

使用场景：

保存一个登录用户的信息
购物车信息
在整个网站中经常回使用的数据，将他保存在Session中

把对象保存在Session

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

        //得到Session
        HttpSession session = req.getSession();

        //给Session中存东西(可存对象，可存字符串)
        session.setAttribute("name", new Person("只狼",521));

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

        //判断Session是不是新创建
        if (session.isNew()) {
            resp.getWriter().write("session创建成功，Id：" + sessionId);
        } else {
            resp.getWriter().write("session已经在服务器中存在了，Id："+sessionId);
        }
    }

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

把Session输出到后台

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

        //得到Session
        HttpSession session = req.getSession();
        //取出session
        Person person = (Person) session.getAttribute("name");
        //输出到Session
        System.out.println(person.toString());
    }

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

手动删除Session和自动删除Session

public class SessionDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //Session的注销
        HttpSession session = req.getSession();
        session.removeAttribute("name");
        session.invalidate();
    }

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

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

7 JSP

7.1 JSP原理

JSP == Java Servlet Pages java服务端页面，和Servlet一样，用于动态Web技术

在JSP页面中：

如果是java代码就会原封不动的输出；

如果是HTML，就会转换成out.write("<html>\r\n")输出到前端进行渲染；

jsp最终会转换成一个java类

添加pom.xml配置

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>taglibs</groupId>
            <artifactId>standard</artifactId>
            <version>1.1.2</version>
        </dependency>
    </dependencies>

7.2 JSP基础语法

JSP作为java技术的一种应用，它拥有一些自己扩充的语法，以及java的左右语法

<%= 变量或者表达式%>
<%= new java.util.Date()%>

<%--jsp脚本片段--%>
 <%
    int sum =0;
    for(int i = 0;i<=100;i++){
      sum+=i;
    }
    out.println("<h1>Sum="+sum+"</h1>");
 %>

脚本片段实现：

<%--在代码嵌入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("进入了方法");
    }
  %>

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

在JSP，嵌入java代码即可！

<%java代码%>

<%=取值%>

<%!声明%>

<%--注释--%>

7.3 JSP指令

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

文本类型：html

编码：UTF-8

页面编写语言是：java

导包：

1. <@ page import="java.util.Date" %>

2. ctrl+enter

自定义错误页面

声明这是个错误页面

<%@ page isErrorPage="true"%>

<img src="img/RC.png">

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--定制错误页面--%>
<%@ page errorPage="error/500.jsp" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        int x = 1/0;
    %>
</body>
</html>



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

</head>
<body>
    <!--这里注意写../会报错-->
    <img src="/img/RC.png">
</body>
</html>

2.在xml中处理错误

只要发生404错误就会跳转打指定页面

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

提取公共页面

1.利用指令

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

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<h1>我是Footer</h1>


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<h1>我是Header</h1>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%@ include file="footer.jsp"%>
    <h1>主体</h1>
    <%@ include file="header.jsp"%>
</body>
</html>

2.利用标签

<%--

jsp标签

jsp:include: 拼接页面，本质上还是三个

--%>

<jsp:include page="header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="footer.jsp"/>

7.4 9大内置对象

PageContext 存东西
Request 存东西
Response
Session 存东西
Application {ServletContext} 存东西
config {ServletConfig}
out
page
exception

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--内置对象--%>
    <%
        //从底层到高层 (作用域): page-->request-->session-->application
        //JVM:双亲委派机制 :加载包的过程,先查看RT.JAR(根包)下是否有,再找扩展类的包,再找应用型包(自己定义的包)
        pageContext.setAttribute("name1","只狼1");//保存的数据只在一个页面中有效
        request.setAttribute("name2","只狼2");//保存的数据只在一次请求中有效,请求转发会携带这个数据
        session.setAttribute("name3","只狼3");//保存你的数据只在一次会话中有效,从打开浏览器到关闭浏览器
        application.setAttribute("name4","只狼4");//保存的数据只在服务器中有效,从打开服务器到关闭服务器
    %>

    <%
        //从pageContext取出,我们通过寻找的方式来获取
        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");//不存在
    %>

    <%--使用EL表达式输出 ${} --%>
    <h1>取出的值</h1>
    <h3>${name1}</h3>
    <h3>${name2}</h3>
    <h3>${name3}</h3>
    <h3>${name4}</h3>
    <h3>${name5}</h3>
</body>
</html>

使用另一个网页也可访问到session和application中存储的数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%
        //从pageContext取出,我们通过寻找的方式来获取
        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");//不存在
    %>

    <%--使用EL表达式输出 ${} --%>
    <h1>取出的值</h1>
    <h3>${name1}</h3>
    <h3>${name2}</h3>
    <h3>${name3}</h3>
    <h3>${name4}</h3>
    <h3>${name5}</h3>
</body>
</html>

也可在客户端实现页面的跳转

    <%
        //客户端的页面跳转
        pageContext.forward("/index.jsp");

    %>

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

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

application:客户端向服务器放松请求,产生数据,一个用户用完了,卡用户还可能使用,比如聊天数据

7.5 JSP标签/JSTL标签/EL表达式

pom.xml添加依赖

  <!--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>
        </dependency>

EL表达式: ${}

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

JSP标签:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--jsp:include--%>
    <%--在转发时携带参数,单独访问页面jsptag2.jsp无数据--%>
    <jsp:forward page="/jsptag2.jsp">
        <jsp:param name="name" value="zhilang"/>
        <jsp:param name="age" value="23"/>
    </jsp:forward>

</body>
</html>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>取参数</h1>
    名字:<%=request.getParameter("name")%>
    年龄:<%=request.getParameter("age")%>
</body>
</html>

JSTL表达式:

JSTL标签库的使用就是为了弥补HTML标签的不足;他自定义许多标签,可以供我们使用,标签的功能和java代码一样;

核心标签:

使用JSTL标签需要导入jar包

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
  <%
      ArrayList<String> people = new ArrayList<>();
      //这里的序号得从0开始
      people.add(0,"张三");
      people.add(1,"李四");
      people.add(2,"王五");
      people.add(3,"赵六");
      request.setAttribute("list",people);
  %>
  <%--
    var 每一次遍历出来的变量
    items  要遍历的对象
  --%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/><br>
</c:forEach>
<hr>
  <%--起始 终止 步长--%>
<c:forEach var="people" items="${list}" begin="1" end="3" step="2">
    <c:out value="${people}"/> <br>
</c:forEach>
</body>
</html>

when

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--定义一个变量score,值为85--%>
    <%--拦腰截断,不会匹配出多个值--%>
    <c:set var="score" value="85"/>

    <c:choose>
        <c:when test="${score>=80}">
            你很一般!
        </c:when>
        <c:when test="${score>=90}">
            你很厉害!
        </c:when>

    </c:choose>
</body>
</html>

foreach

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %><%--
  
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
  <%
      ArrayList<String> people = new ArrayList<>();
      //这里的序号得从0开始
      people.add(0,"张三");
      people.add(1,"李四");
      people.add(2,"王五");
      people.add(3,"赵六");
      request.setAttribute("list",people);
  %>
  <%--
    var 每一次遍历出来的变量
    items  要遍历的对象
  --%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/><br>
</c:forEach>
<hr>
  <%--起始 终止 步长--%>
<c:forEach var="people" items="${list}" begin="1" end="3" step="2">
    <c:out value="${people}"/> <br>
</c:forEach>
</body>
</html>

格式化标签:

SQL标签:

XML标签:

问题:

JSTL解析错误

这个是tomcat服务器中,缺少两个包需要导入

第一个包

放到tomcat的lib目录里

第二个包

添加到tomcat的lib目录

8 JAVABean

8.1 介绍

实体类

JavaBean有特定的写法:

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

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

ORM:对象关系映射

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

people表

id	name	age	address
1	只狼1	33	北京
2	只狼2	22	上海
3	只狼3	11	深圳

class people{

        private int id;

        private String name;

        private int age;

        private String address;

}
class A{
    new people(1,"只狼1",33,"北京") ;
    new people(2,"只狼2",22,"上海") ;
    new people(3,"只狼3",33,"深圳") ;
}

alt+insert 自动生成set和put方法

8.2 从类中获取字段

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


}

<%@ page import="com.gao.pojo.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <%--第一种方式--%>
    <%--
  <%
    People people = new People();
    people.setAddress();
    people.setAge();
    people.setId();
    people.setName();
  %>
    --%>
<%--第二种方式--%>
<jsp:useBean id="people" class="com.gao.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="33"/>
    <jsp:setProperty name="people" property="name" value="只狼1"/>

    地址:<jsp:getProperty name="people" property="address" /><br>
    编号:<jsp:getProperty name="people" property="id" /><br>
    年龄:<jsp:getProperty name="people" property="age" /><br>
    名字:<jsp:getProperty name="people" property="name" />
</body>
</html>

9 MVC三层架构

9.1 介绍:

什么是MVC:

Model(模型)

业务处理:业务逻辑(Service)
数据持久层:CRUD(Dao)

View(视图)

展示数据
提供链接发起请求Servlet请求(a,form,img)

Controller(jsp页面)

接收用户的请求:(req:请求参数,Session信息)
交代业务层处理对应的代码
控制视图的跳转

登录-->接收用户的登录请求-->处理用户的请求(获取用户登录的参数,username,password)

-->交给业务处理登录业务(判断业务名密码是否正确:事务) -->Dao层查询用户和密码是否正确-->数据库

10 Filter（过滤器）

Filter:过滤器，用来过滤网站数据，

每次请求都会走一次过滤器。直到服务器关闭

Filter：实现步骤：

（1 导包

<dependencies>
        <!--Servlet 依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!--JSP 依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.3</version>
        </dependency>
        <!--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>
        </dependency>
        <!--连接数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
    </dependencies>

（2 编写过滤器

注意filter的导包，是导入Filter（javax.servlet）

package com.gao.filter;

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

//注意导入的包
public class CharacterEncodingFilter implements Filter {

    //初始化
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("CharacterEncodingFilter初始化");
    }
    //
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        //chain:链
        /*
        * 1.过滤中的所有代码，在过滤特定请求的是偶都会执行
        * 2.必须要让过滤器继续同行
        *   filterChain.doFilter(servletRequest,servletResponse);
        * */
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=UTF-8");

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

(3 在web.xml 中配置Filter

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

辅助类：

package com.gao.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 ShowServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("你好啊！只狼");
    }

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

  <servlet>
    <servlet-name>ShowServlet</servlet-name>
    <servlet-class>com.gao.servlet.ShowServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ShowServlet</servlet-name>
    <url-pattern>/show</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>ShowServlet</servlet-name>
    <url-pattern>/servlet/show</url-pattern>
  </servlet-mapping>

11. 监听器

<1> 编写监听器的接口

实现监听器接口

package com.gao.listener;

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

//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
    //创建session监听：
    //一但创建Session就会触发一次这个事请
    @Override
    public void sessionCreated(HttpSessionEvent httpSessionEvent) {
        ServletContext ctx = httpSessionEvent.getSession().getServletContext();
        Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
        System.out.println(httpSessionEvent.getSession().getId());
        if (onlineCount == null){
            onlineCount = new Integer(1);
        }else {
            int count = onlineCount.intValue();
            onlineCount = new Integer(count+1);
        }
        ctx.setAttribute("OnlineCount",onlineCount);
    }
    //销毁session监听
    //一但销毁session就会触发一次这个事件！
    /*
    * session手动销毁 ，getSession().invalidate();
    * 自动销毁 在xml中配置有效期（之前写session时写过）
    * */
    @Override
    public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
        ServletContext ctx = httpSessionEvent.getSession().getServletContext();
        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);
    }
}

<2> web.xml中注册监听器

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

12 Filter实现权限拦截（监听器和过滤器）

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

代码：

三个jsp文件分别问登录成功和失败

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>登录</h1>
<form action="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="Logout">注销</a></p>
</body>
</html>

<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>错误</h1>
    <h3>没有权限，用户名错误</h3>
    <a href="Login.jsp">返回到登录页面</a>
</body>
</html>

两个servlet

package com.gao.servlet;

import com.gao.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("success.jsp");
        }else {//登陆失败
            resp.sendRedirect("error.jsp");
        }
    }

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










package com.gao.servlet;

import com.gao.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 {
        Object user_session=req.getSession().getAttribute(Constant.USER_SESSION);

        if (user_session!=null){
            req.getSession().removeAttribute(Constant.USER_SESSION);
            resp.sendRedirect("Login.jsp");
        }else{
            resp.sendRedirect("Login.jsp");
        }
    }

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

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">


  <servlet>
    <servlet-name>LoginServlet</servlet-name>
    <servlet-class>com.gao.servlet.LoginServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>LoginServlet</servlet-name>
    <url-pattern>/Login</url-pattern>
  </servlet-mapping>

<servlet>
  <servlet-name>LogoutServlet</servlet-name>
  <servlet-class>com.gao.servlet.logoutServlet</servlet-class>
</servlet>
  <servlet-mapping>
    <servlet-name>LogoutServlet</servlet-name>
    <url-pattern>/Logout</url-pattern>
  </servlet-mapping>

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







  <servlet>
    <servlet-name>ShowServlet</servlet-name>
    <servlet-class>com.gao.servlet.ShowServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ShowServlet</servlet-name>
    <url-pattern>/show</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>ShowServlet</servlet-name>
    <url-pattern>/servlet/show</url-pattern>
  </servlet-mapping>

  <filter>
    <filter-name>CharachterEncodingFilter</filter-name>
    <filter-class>com.gao.filter.CharacterEncodingFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>CharachterEncodingFilter</filter-name>
    <!--只要是 /servlet的任何请求都会经过这个过滤器-->
    <url-pattern>/servlet/*</url-pattern>
  </filter-mapping>
  
  <!--注册监听器-->
  <listener>
    <listener-class>com.gao.listener.OnlineCountListener</listener-class>
  </listener>

</web-app>

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.gao</groupId>
  <artifactId>javaweb-filter</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>javaweb-filter Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <!--Servlet 依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
    <!--JSP 依赖-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>javax.servlet.jsp-api</artifactId>
      <version>2.3.3</version>
    </dependency>
    <!--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>
    </dependency>
    <!--连接数据库-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

  </dependencies>

  <build>
    <finalName>javaweb-filter</finalName>
    <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
      <plugins>
        <plugin>
          <artifactId>maven-clean-plugin</artifactId>
          <version>3.1.0</version>
        </plugin>
        <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
        <plugin>
          <artifactId>maven-resources-plugin</artifactId>
          <version>3.0.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-compiler-plugin</artifactId>
          <version>3.8.0</version>
        </plugin>
        <plugin>
          <artifactId>maven-surefire-plugin</artifactId>
          <version>2.22.1</version>
        </plugin>
        <plugin>
          <artifactId>maven-war-plugin</artifactId>
          <version>3.2.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-install-plugin</artifactId>
          <version>2.5.2</version>
        </plugin>
        <plugin>
          <artifactId>maven-deploy-plugin</artifactId>
          <version>2.8.2</version>
        </plugin>
      </plugins>
    </pluginManagement>
  </build>
</project>

一个过滤器

package com.gao.filter;

import com.gao.util.Constant;

import javax.servlet.*;
import javax.servlet.http.HttpServlet;
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 servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //如果session里面的值是空就不让进入
        HttpServletRequest request = (HttpServletRequest)servletRequest;
        HttpServletResponse response = (HttpServletResponse)servletResponse;
        if (request.getSession().getAttribute(Constant.USER_SESSION)==null){
            response.sendRedirect("/error.jsp");
        }
        //连接，如果没有程序就断到这儿了
        filterChain.doFilter(servletRequest,servletResponse);

    }

    @Override
    public void destroy() {

    }
}

13 JDBC

需要jar包的支持

java.sql
javax.sql
mysql-conneter-java……（连接驱动）

第一种方法：不能解决sql注入问题

package com.gao.text;


import java.sql.*;

public class TestJdbc {
    public static void main(String[] args) throws SQLException,ClassNotFoundException {
        //配置信息
        String url = "jdbc:mysql://localhost:3306/gao?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "Aaqwe123";

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

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

        //编写SQL（容易出错所以，可以到可视化界面有错误提示 没有 ; ）
        String sql = "select * from users";

        //执行查询SQL，返回一个ResultSet :结果集;
        ResultSet rsultSet = statement.executeQuery(sql);

        while (rsultSet.next()){
            System.out.println("id=" + rsultSet.getObject("id"));
            System.out.println("name=" + rsultSet.getObject("name"));
            System.out.println("password=" + rsultSet.getObject("password"));
            System.out.println("email=" + rsultSet.getObject("email"));
            System.out.println("birthday=" + rsultSet.getObject("birthday"));

        }

        //关闭连接，释放资源（必须关）先开后关
        rsultSet.close();
        statement.close();
        connection.close();
    }
}

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

第二种使用占位符：可以解决sql占位符问题

package com.gao.text;

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{
        //配置信息
        String url = "jdbc:mysql://localhost:3306/gao?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "Aaqwe123";

        //加载驱动
        Class.forName("com.mysql.jdbc.Driver");
        //连接数据库，代表数据库
        Connection connection = DriverManager.getConnection(url,username,password);
        //编写SQL
        String sql = "insert into users(id,name,password,email,birthday) values(?,?,?,?,?)";

        //预编译
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,3);//给第一个占位符赋值为1
        preparedStatement.setString(2,"高");
        preparedStatement.setString(3,"12356");
        preparedStatement.setString(4,"12323@343");
        preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));

        //执行SQL
        int i = preparedStatement.executeUpdate();
        if (i>0){
            System.out.println("插入成功");
        }else {
            System.out.println("插入失败");
        }

        //关闭连接释放资源
        preparedStatement.close();
        connection.close();
    }
}

14 数据库——事务

要么都成功要么都失败

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

创建表：

CREATE TABLE account(
	id INT PRIMARY KEY,
	’name‘ VARCHAR(20),
	money FLOAT
);

插入数据：

INSERT INTO account (id, NAME, money)
VALUES
	(2, 'B', 1000);

事务执行代码:

package com.gao.text;

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

public class TestJdbc3 {
    public static void main(String[] args) {
        //配置信息
        String url = "jdbc:mysql://localhost:3306/gao?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "Aaqwe123";

        //提高有效范围
        Connection connection = null;


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

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

        //通知数据库开启事务，false（关闭自动提交的意思），开启
        connection.setAutoCommit(false);

        //提交语句
        String sql1 = "update account set money = money-100 where name='A'";
        connection.prepareStatement(sql1).executeUpdate();

        //制造错误
        //int i = 1/0;

        //提交语句
        String sql2 = "update account set money = money+100 where name='B'";
        connection.prepareStatement(sql2).executeUpdate();

        connection.commit();
        System.out.println("提交");
        } catch (Exception e) {
            try {
                //如果出现错误就同时数据库回滚
                connection.rollback();
                System.out.println("事务已回滚");
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            e.printStackTrace();
        }
    }
}

15.文件上传

15.1 文件上传的注意事项

1 为保证服务器安全，上传文件应该放在外界无法直接访问的目录下，比如WEB-INF目录下

2 为防止文件覆盖现象发生，腰围上传产生一个唯一的文件名。

3 要限制上传文件的最大值。

4 可以限制上传文件类型，在收到上传文件名时，判断后缀名为合法。

表单中如果包含一个文件传输项的话，这个表单的enctype属性就必须设置为multtipart/form-data

16 邮件发送

16.1 不带附件类型（简单类型）

首先需要在qq邮箱上打开pop3功能，然后点击图片上的生成授权码

然后需要导入两个jar包

代码如下：

package com.gao;

import java.util.Properties;

import com.sun.mail.util.MailSSLSocketFactory;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;


public class MailDemo01 {
    public static void main(String[] args) throws Exception{
        Properties prop = new Properties();
        prop.setProperty("mail.host","smtp.qq.com");//设置QQ邮件服务器
        prop.setProperty("mail.transport.protocol","smtp");//邮件发送协议
        prop.setProperty("mail.smtp.auth","true");//需要验证用户密码

        //授权码：dxqdbmujudotbjif
        //关于QQ邮件，还要设置SSl加密，加上以下代码即可
        MailSSLSocketFactory sf = new MailSSLSocketFactory();
        sf.setTrustAllHosts(true);
        prop.put("mail.smtp.ssl.enable","true");
        prop.put("mail.smtp.ssl.socketFactory",sf);

        //使用JavaMail发送邮件的5个步骤
        //1、创建定义整个应用程序所需的环境信息的Session对象
        //创建定义整个应用程序所需的环境信息的Session对象

        //只有QQ才有其他邮箱不用
        Session session = Session.getDefaultInstance(prop, new Authenticator() {
            @Override
            public PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication("邮箱","授权码");
            }
        });

        //开启Session的debug模式，这样就可以查看刀程序发送Email的运行状态
        session.setDebug(true);

        //2、通过session得到transport对象
        Transport ts = session.getTransport();
        //3、使用邮箱的用户和授权码连上服务器
        ts.connect("smtp.qq.com","邮箱","授权码");
        //4、创建邮件
        //注意传递session
        MimeMessage message = new MimeMessage(session);
        //指明发件人
        message.setFrom(new InternetAddress("邮箱"));
        //指明邮件的收件人，现在发件人和收件人一样的，就是自己给自己发
        message.setRecipient(Message.RecipientType.TO,new InternetAddress("1969769020@qq.com"));
        //邮件标题
        message.setSubject("标题");
        //邮件内容
        message.setContent("<h1 style='color:red'>内容</h1>","text/html;charset=UTF-8");
        //5、发送邮件
        ts.sendMessage(message,message.getAllRecipients());
        //6、关闭连接
        ts.close();
    }
}

16.2 发送带附件类型的邮件

邮件只有文本，设置为alternative

邮件有文本和内嵌资源，设置为related

邮件有文本、内嵌资源和附件，设置为mixed

附：

junit：单元测试

需要再pom.xml里加一个依赖

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

简单使用

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

IDEA快捷键

ctrl+shift+alt：多行操作
psvm：生成main()方法；
fori：生成for循环；
Ctrl+Alt+v：自动补齐返回值类型
ctrl+o：覆写方法
ctrl+i：实现接口中的方法
ctrl+shift+u：大小写转换
CTRL+SHIFT+Z：取消撤销
Alt＋Insert：生成构造方法、getter、setter
ctrl+y：删除当前行
Ctrl+Shift+J：将选中的行合并成一行
ctrl+g：定位到某一行
Ctrl+Shitft+向下箭头：将光标所在的代码块向下整体移动
Ctrl+Shift+向上箭头：将光标所在的代码块向上整体移动
Alt+Shift+向下箭头：将行向下移动
Alt+Shift+向上箭头：将行向上移动
Ctrl+F：在当前文件中查找
Ctrl+R：替换字符串
Ctrl+Shift+F:在全局文件中查找字符串
Ctrl+Shift+R：在全局中替换字符串
Ctrl+Shift+Enter：自动补齐{}或者分号;
Shift+Enter：在当前行的下方开始新行
Ctrl+Alt+Enter：在当前行的上方插入新行
Ctrl+Delete：删除光标所在至单词结尾处的所有字符