狂神说JavaWeb学习笔记

JavaWeb学习总结

1. 基本概念

web开发:

• web,网页
• 静态web
  • html,css
  • 提供给所有人看的数据始终不会发生变化!
• 动态web
  • 提供给所有人看的数据会发生变化,每个人在不同的时间,不同的地点看到的信息各不相同
  • 技术栈: Servlet/JSP, ASP, PHP

在java中,动态web资源开发的技术统称为Javaweb

1.1 web应用程序

web应用程序:可以提供浏览器访问的程序;

• 一个web应用由多部分组成(静态web,动态web)
  • html,css,js
  • jsp,servlet
  • java程序
  • jar包
  • 配置文件(properties)

web应用程序编写完毕后,若想提供给外界访问:需要一个服务器来同意管理;

1.2 静态web

• *.html,这些都是网页的后缀,如果服务器上一直存在这些东西,我们就可以直接进行读取.通络;
• 静态web存在的缺点
  • web页面无法动态更新,所有用户看到都是同一个页面
  • 无法和数据库交互(数据无法持久化,用户无法交互)

1.3 动态web

页面会动态展示:“web的页面展示因人而异”

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cD7TC2El19edb4ef6bdb7d71872)9c3c6.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xhbmNlTGVlMA==,size_16,color_FFFFFF,t_(0#pic_center:
Pictures\kuang\image-20210627092835291.png)]

缺点

• 加入服务器的动态web资源出现了错误,我们需要重新编写我们的后台程序,重新发布.
  • 停机维护
• 优点
  • web页面可以动态更新,用户看到的页面会不同
  • 可以与数据库交互(数据持久化:注册,商品信息,用户信息)

1.4 web服务器

网站是如何进行访问的!

• 1.输入一个域名;回车

• 2.检查本机的 C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名的映射;

  • 有:直接返回对应的IP地址,这个地址中,有我们需要访问的web程序,可以直接访问
  • 没有: 去DNS服务器(全世界的域名都在这里管理)找

2. Tomcat

2.1 发布一个web网站

不会就先模仿

• 将自己写的网站,放到服务器(Tomcat)中指定的web应用的文件夹(webapps)下,就可以访问了.

网站应该有的结构

--webapps : Tomcat服务器的web目录
    -Root
    -Lee : 网站的目录名
        - WEB-INF
        	-classes : java
            -lib: webjar
            -web.xml : 
		-index.xml 
        -static
            -css
            	-style.css
            -js
            -img
        -.....

2.2 网站是如何访问的

1. 输入一个域名; 回车
2. 检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射;
   1. 有: 直接返回对应的IP地址,这个地址用,有我们需要访问的web程序,可以直接访问
   2. 没有 : 去DNS服务器找,找到的话就返回,找不到就返回找不到

3. Http

3.1 什么是http

HTTP(超文本传输协议) 是一个简单的请求-响应协议,它通常运行在TCP之上

• 文本:HTML, 字符串, …
• 超文本: 图片, 音乐, 视频…
• 80端口

Https: 安全的

• 443端口

3.2 两个时代

• http1.0
  • http/1.0: 客户端可以与web服务器连接后,只能获得一个web资源, 断开连接
• http2.0
  • http/1.1: 客户端可以与web服务器连接后,可以获得多个web资源

3.3 http请求

• 客户端—发请求(Request) – 服务器

百度:

Request URL: https://www.baidu.com/   请求地址
Request Method: GET    get方法/post方法
Status Code: 200 OK    状态码: 200
Remote Address: 14.215.177.38:443  远程IP地址

Accept: text/html
Accept-Encoding: gzip, deflate, br
Accept-Language: zh-CN,zh;q=0.9    语言
Cache-Control: no-cache
Connection: keep-alive

1.请求行

• 请求行中的请求方式:get
• 请求方式:get,post,head,delete,put,tract
  • get:请求能够携带的参数比较少,大小有限制,会在浏览器的URL地址栏显示数据,不安全,但高效
  • post:请求能够携带的参数无限制,大小无限制,不会在浏览器的URL地址栏显示数据,安全,但不高效

2.消息头

Accept: 告诉浏览器它所支持的数据类型
Accept-Encoding: 支持哪种编码格式  GBK  UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器,请求完成是断开还是保持连接
HOST: 主机.../..

3.4 http响应

• 服务器–响应–客户端

百度:

Cache-Control: private    缓存控制
Connection: keep-alive    连接
Content-Encoding: gzip    编码
Content-Type: text/html;charset=utf-8   类型

1.响应题

Accept: 告诉浏览器它所支持的数据类型
Accept-Encoding: 支持哪种编码格式  GBK  UTF-8 GB2312 ISO8859-1
Accept-Language: 告诉浏览器它的语言环境
Cache-Control: 缓存控制
Connection: 告诉浏览器,请求完成是断开还是保持连接
HOST: 主机.../..
Refrush: 告诉客户端,多久刷新一次
Location: 让网页重新定位:

2. 响应状态码

200:请求响应成功 200

3XX: 请求重定向 304

• 重定向:重新定位到一个新位置

4XX:找不到资源 404

• 资源不存在;

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

4. Maven

为什么要学习Maven

• 1.在javaweb开发中,需要使用大量的jar包,我们手动去导入;
• 2.如何能够让一个东西自动帮我导入和配置这个jar包.有次,Maven诞生了!

4.1 Maven项目架构管理工具

目前用来就是方便导入jar包的!

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

• 有约束,不要去违反

4.2 下载安装Maven

官网:https://maven.apache.org/

建议使用3.6.1版本

下载完成解压即可.

4.3 配置环境变量

在环境变量中配置如下配置:

• 新建M2_HOME maven目录下的bin目录
• 新建MAVEN_HOME maven的目录
• 在系统的path中配置%MAVEN_HOME%\bin

4.4 阿里云镜像

• 镜像:mirrors
  • 作用:加速下载
• 国内建议使用阿里云的镜像

修改一下conf/settings.xml

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

4.5 本地仓库

在本地的仓库,远程仓库;

**建立一个本地仓库:**localRepository

在Maven目录下创建一个maven-repo文件夹,再修改conf/settings.xml的配置信息

<localRepository>E:\Maven\apache-maven-3.6.1-bin\apache-maven-3.6.1\maven-repo</localRepository>

4.6 在IDEA中使用Maven

1.创建一个Maven项目

2.查看Settings->Build…->Build Tools->Maven的maven路径和settings文件是否正确

4.7 在IDEA中配置Tomcat

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1HC1aKX60fffd3ec95348c1dccf096903d8a627273.PNG#pic_center(
:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210630091402316.png)]

2.点+,找到Tomcat server的local

3.更改名字,选择Tomcat路径

4.点Deployment,点+,Artifact

5.更改Application context(可改可不改)

6.ok,运行

4.8 maven导出问题

maven由于他的约定大于配置,可能会产生配置文件无法导出或者生效问题解决方法:

<!--在build中配置resources,来防止我们资源导出失败的问题-->
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <excludes>
                    <exclude>**/*.properties</exclude>

                    <exclude>**/*.xml</exclude>
                </excludes>
                <filtering>false</filtering>

            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>

                    <include>**/*.xml</include>                </includes>                <filtering>false</filtering>            </resource>
        </resources>
    </build>

4.9 Maven仓库的使用

地址:https://mvnrepository.com/

搜索相关相关的包然后复制其maven代码,然后粘贴到pom.xml文件的dependencies中

5. Servlet

5.1 Servlet简介

Setvlet是发开动态web的API接口.

实现步骤:

• 编写一个类,实现Servlet接口
• 把开发好的java类部署到web服务器中

5.2 HelloServlet

Servlet接口有两个默认的实现类:HttpServlet,GenericServlet

1.构建一个普通的maven项目,把src目录删除

2.在maven官网找到相关的maven依赖放进pom.xml的中

3.项目目录右击选择新建module,先maven的webapp项目

4.把新建的webapp的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>

5.在main中新建java目录和resource目录,并标志为sources root和resources root

6.编写一个Servlet程序:

• 1.编写一个普通类
• 2.实现Servlet接口,可以直接继承Servlet的实现类HttpServlet
• 3.重写doGet和doPost方法

package com.kuang;

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

public class HelloServlet extends HttpServlet {
    //由于get和post只是请求实现的不同的方式,可以相互调用,业务逻辑都一样
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ServletOutputStream outputStream = resp.getOutputStream();响应字节输出流
        PrintWriter writer = resp.getWriter();//响应字符输出流
        writer.println("hello,servlet");
    }

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

7.编写Servlet的映射

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

修改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>
        <servlet-name>hello</servlet-name><!--Servlet名称-->
        <servlet-class>com.kuang.HelloServlet</servlet-class><!--Servlet的类-->
    </servlet>
    <!--Servlet的请求路径-->
    <servlet-mapping>

        <servlet-name>hello</servlet-name><!--Servlet名称-->
        <url-pattern>/hello</url-pattern><!--Servlet的请求路径-->
</servlet-mapping></web-app>

8.配置Tomcat

配置项目发布的路径就可以了

9.启动测试

5.3 Servlet原理

Servlet是由web服务器调用,web服务器在收到浏览器请求之后,会:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ojibtd1H-1627277171877)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20210701102240148.png)]

5.4 Mapping问题

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

	<servlet-mapping>

    
    <servlet-name>hello</servlet-name><!--Servlet名称-->


        <url-pattern>/hello</url-pattern><!--Servlet的请求路径-->

    </servlet-mapping>

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

	<servlet-mapping>
        <servlet-name>hello</servlet-name><!--Servlet名称-->
        <url-pattern>/hello</url-pattern><!--Servlet的请求路径-->
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name><!--Servlet名称-->
        <url-pattern>/hello2</url-pattern><!--Servlet的请求路径-->    </servlet-mapping>    <servlet-mapping>
        <servlet-name>hello</servlet-name><!--Servlet名称-->
        <url-pattern>/hello3</url-pattern><!--Servlet的请求路径-->    </servlet-mapping>

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

<servlet-mapping>        <servlet-name>hello</servlet-name><!--Servlet名称-->        <url-pattern>/hello/*</url-pattern><!--Servlet的请求路径  *表示任意字符-->

    </servlet-mapping>

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

<!--可以自定义后缀实现请求映射,*前面不能加路劲-->
    <servlet-mapping>        <servlet-name>hello</servlet-name><!--Servlet名称-->        <url-pattern>*.asd</url-pattern><!--Servlet的请求路径  *表示任意字符-->    </servlet-mapping>

5.优先级问题

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

5.5 ServletContext

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

5.51 共享数据

在这个Servlet中保存的数据,可以在另外一个Servlet中拿到;

编写HelloServlet并设置ServletContext的键和值

public class HelloServlet extends HttpServlet {
    @Override

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


 {
    

    ServletContext context = this.getServletContext();

        String username="Lee";//数据
        context.setAttribute("username",username);//将一个数据保存在ServletContext中,名字为username,值username


    }

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

编写get并读取ServletContext的值

public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        Object 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 {
    }
}

配置web.xml注册Servlet

	<servlet>

        <servlet-name>hello</servlet-name>

        <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>

    </servlet>

    <servlet-mapping>

        <servlet-name>hello</servlet-name>

        <url-pattern>/h</url-pattern>

    </servlet-mapping>

    <servlet>        <servlet-name>get</servlet-name>        <servlet-class>com.kuang.servlet.GetServlet</servlet-class>    </servlet>    <servlet-mapping>        <servlet-name>get</servlet-name>        <url-pattern>/get</url-pattern>    </servlet-mapping>

测试访问

5.52 获取初始化参数

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

public class Servlet03 extends HttpServlet {
    @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);
    }
}

5.53 请求转发

public class Servlet04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        System.out.println("进入了Servlet04");        ServletContext context = this.getServletContext();
        //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp");//转发的请求路径
        //requestDispatcher.forward(req,resp);//调用forward方法实现请求转发
        context.getRequestDispatcher("/gp").forward(req,resp);//请求转发,会显示/gp(即Servlet03)的内容.
    }

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

        doGet(req,resp);
    }
}

5.54 读取资源文件

Properties

• 在java目录下新建properties
• 在resources目录下新建properties

发现:都被打包到同一个路径下:classes.我们俗称这个路径为classpath

在resources创建一个资源文件db.properties

username=root
password=123456

再创建一个PropertiesServlet程序读取资源文件

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

    

    InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");//将资源转换为流
        Properties prop = new Properties();
        prop.load(is);//加载资源流
        String user = prop.getProperty("username");//通过键获取值
        String pwd = prop.getProperty("password");//通过键获取值

        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");
        resp.getWriter().println("名字:"+user);
        resp.getWriter().println("密码:"+pwd);    }    @Override    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {        doGet(req, resp);
    }
}

<servlet>
        <servlet-name>ps</servlet-name>
        <servlet-class>com.kuang.servlet.PropertiesServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>ps</servlet-name>
        <url-pattern>/ps</url-pattern>
    </servlet-mapping>

5.6 HttpServletResponse

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

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

5.6.1 简单分类

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

ServletOutputStream getOutputStream() throws IOException;

PrintWriter getWriter() throws IOException;

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

void setCharacterEncoding(String var1);

void setContentLength(int var1);

void setContentLengthLong(long var1);

void setContentType(String var1);

void setDateHeader(String var1, long var2);

void addDateHeader(String var1, long var2);

void setHeader(String var1, String var2);

void addHeader(String var1, String var2);

void setIntHeader(String var1, int var2);

void addIntHeader(String var1, int var2);

5.6.2 下载文件

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

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //要获取下载文件的路径
    String realPath = "E:\\IDEA\\JavaWeb\\javaweb-02-maven\\response\\target\\classes\\李.png";
    System.out.println("下载文件的路径"+realPath);
    //下载的文件名
    String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);//获取/后面的字符串
    //设置想办法让浏览器能够支持(Content-Disposition)下载,中文文件名用URLEncoder.encode编码
    resp.setHeader("Content-Disposition","attachment; filename="+ URLEncoder.encode(fileName,"UTF-8"));//设置响应的头信息
    //获取下载文件的输入流
    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))!=-1){
        out.write(buffer,0,len);
    }
    //关闭流
    out.close();
    in.close();
}

<servlet>
    <servlet-name>filedown</servlet-name>
    <servlet-class>com.kuang.servlet.FileServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>filedown</servlet-name>
    <url-pattern>/down</url-pattern>
</servlet-mapping>

5.6.3 验证码功能

验证码怎么来的?

• 前端实现
• 后端实现,需要用到java的图片类,生产一个图片

5.6.4 实现重定向

B一个web资源受到客户端A请求后,B它会通知客户端去访问另外一个web资源C,这个过程叫重定向

void sendRedirect(String var1) throws IOException;

测试:

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //重定向原理
    //resp.setHeader("Location","/r/img");
    //resp.setStatus(302);
    resp.sendRedirect("/r/img");//重定向
}

重定向和转发的区别

• 相同点
  • 页面都会实现跳转
• 不同点
  • 请求转发的时候,URL不会产生变化; 307
  • 重定向的时候,URL地址栏会发生变化; 302

5.7 HttpServletRequest

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

获取参数,请求转发

req.getParameter(String s)//返回String
req.getParameterValues(String s)//返回String[]

@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 pwd = req.getParameter("pwd");
    String[] hobbies = req.getParameterValues("hobby");//获取多次参数放到一个数组里
    System.out.println(username);
    System.out.println(pwd);
    System.out.println(Arrays.toString(hobbies));

    //通过请求转发   请求转发的/代表当前应用,所以不需要再额外添加项目路径(req.getContextPath()+)
    req.getRequestDispatcher("/Success.jsp").forward(req,resp);
    //重定向
    //resp.sendRedirect(req.getContextPath()+"/Success.jsp");
}

6. Cookie, Session

6.1 会话

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

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

一个网站,怎么证明来过

客户端 服务端

1.服务端给客户端一个信件,客户端下一次访问服务端带上信件就可以了; cookie

2.服务器登记你来过了,下次来的时候进行匹配; session

6.2 保存会话的两种技术

cookie

• 客户端技术(响应,请求)

session

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

常见网站登录之后,你下次不用再登录了,第二次访问可以直接登上

6.3 Cookie

1.从请求中拿到cookie信息

2.服务器响应给客户端cookie

Cookie[] cookies = req.getCookies();//获取请求的cookie
cookie.getName();//获得cookie的key
cookie.getValue();//获得cookie的值
Cookie cookie = new Cookie("LastLoginTime", System.currentTimeMillis()+"");//新建一个cookie
cookie.setMaxAge(10);//设置cookie有效期单位为秒
resp.addCookie(cookie);//响应给客户端一个cookie

@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    //服务器告诉你来的时间,把这个时间封装成为一个信件,你下次带来就知道你来了

    //解决中文乱码
    req.setCharacterEncoding("utf-8");
    resp.setCharacterEncoding("utf-8");
    resp.setContentType("text/html");

    PrintWriter out = resp.getWriter();

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

    //判断Cookie是否存在
    if(cookies!=null){
        //如果存在
        out.write("你上一次访问的时间是:");

        for (int i = 0; i <cookies.length; i++) {//遍历所有的cookie
            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(10);

}

cookie:一般会保存在本地的用户目录下的APPdata;

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

删除cookie

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

编码解码:

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

7. Session

什么是session:

• 服务器会给每个用户(浏览器)创建一个session对象
• 一个session独占一个浏览器,只要浏览器没有关闭,这个Session就存在;
• 用户登录之后,整个网站都可以访问!–>保存用户的信息;保存购物车的信息

@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("李",18));

        //获取session的id
        String id = session.getId();

        //判断session是否为新创建
        if(session.isNew()){
            resp.getWriter().write("Session创建成功,ID为"+id);
        }else{
            resp.getWriter().write("服务器已存在session,ID为"+id);
        }

        //Session创建的时候相当于创建一个Cookie("JSESSIONID",id)然后给响应添加cookie
//        Cookie cookie = new Cookie("JSESSIONID",id);
//        resp.addCookie(cookie);
        
    }

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

Person person = (Person) session.getAttribute("name");//获得节点
resp.getWriter().write(person.getName());
resp.getWriter().write(person.getAge());

session.removeAttribute("name");//删除节点
        session.invalidate();//注销session

会话自动过期:在web.xml配置

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

​ Session和cookie的区别:

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

使用场景:

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

8.JSP

8.1 什么是JSP

Java Server Pages : java服务器端页面,和Servlet一样,用于动态web技术

最大的特点:

• 写JSP就像在写HTML
• 区别:
  • HTML只会给用户提供静态的数据
  • JSP页面中可以嵌入JAVA代码,为用户提供动态数据

8.2 JSP原理

思路:JSP到底怎么执行的

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

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

JSP本质上就是一个Servlet

8.3 JSP的基础语法

JSP表达式

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

jsp脚本片段

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

脚本片段和HTML元素相互嵌套

 <%--脚本片段和HTML元素相互嵌套--%>
  <%
    for (int i = 0; i <5; i++) {
  %>
  <h1>hello <%=i%> </h1>
  <%
    }
  %>

JSP声明

<%!
    //用于声明变量或者方法等
    static {
      System.out.println("hello");
    }

    private int globalVar=0;

    public void method(){
      System.out.println("进人了方法");
    }
  %>

jsp声明:会被编译到JSP生成的java类中!其他的,就会被生成到_jspService方法中!

8.4 JSP指令

<%@page errorPage="error/500.jsp" %>


<%--@include将两个页面合二为一--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footed.jsp"%>

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

8.5 内置对象

• PageContext 存数据
• Request 存数据
• Response
• Session 存数据
• Application (ServletContext) 存数据
• config (ServletConfig)
• out
• page
• exception

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

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

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

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

8.6 JSP标签 JSTL标签 EL表达式

<dependency>
    <!--JSTL 表达式依赖-->
    <groupId>javax.servlet.jsp.jstl</groupId>
    <artifactId>jstl-api</artifactId>
    <version>1.2</version>
</dependency>

<dependency>
    <!--standard标签库-->
    <groupId>taglibs</groupId>
    <artifactId>standard</artifactId>
    <version>1.1.2</version>
</dependency>

EL表达式: ${}

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

JSP标签

<%--  <jsp:include page=""/>  --%>

<%--请求转发--%>
<jsp:forward page="/jsptag2.jsp">
    <%--携带参数--%>
    <jsp:param name="name" value="lee"></jsp:param>
</jsp:forward>

JSTL标签

JSTL标签库的使用为了弥补HTML标签的不足;它自定义很多标签,标签的功能和就java代码一样

使用步骤

• 引入对应的taglib
• 使用其中的方法
• 在Tomcat也需要引入JSTL的包,否则会报错:JSTL错误

<%@ 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>
<h1>if测试</h1>

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

<%--判断如果提交的用户是管理员,则登录成功--%>
<%--
<%
    if(request.getParameter("username").equals("admin")){
        out.println("登录成功");
    }
%>
--%>

<c:if test="${param.username=='admin'}" var="isAdmin">
    <c:out value="登录成功"/>
</c:if>

<c:out value="${isAdmin}"/>
</body>
</html>

<%--定义一个变量score,值为85--%>
<c:set var="score" value="85"/>
<c:choose>
    <c:when test="${score>=60}">
        及格
    </c:when>
    <c:when test="${score<60}">
        不及格
    </c:when>
</c:choose>

<%
    ArrayList<String> people = new ArrayList<>();
    people.add("Lee");
    people.add("L");
    people.add("Lance");
    request.setAttribute("list",people);
%>

<%--
var  每次变量出来的变量
items,   要遍历的对象
--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/><br>
</c:forEach>

9. JvavBean

实体类

JavaBean有特定的写法:

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

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

ORM : 对象关系映射

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

10. MVC三层架构

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

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

MVC三层架构

Model

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

View

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

Controller (Servlet)

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

登录—>接收用户的登录请求—>处理用户的请求 ( 获取用户登录的参数, username, password )—>交给业务层处理登录业务 ( 判断用户名密码是否正确 : 事务 )—>Dao层查询用户名和密码是否正确—>数据库

11. Filter

Filter : 过滤器 , 用来过滤网站的数据

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

Filter开发步骤:

1.导包

2.编写过滤器

1. 实现Filter(javax.servlet)接口

2. 重写对应的方法

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

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

    //FilterChain  链
    //1. 过滤中的所有代码,在过滤特定请求的时候都会执行
    //2. 必须要让过滤器继续执行filterChain.doFilter(servletRequest,servletResponse)

    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        servletRequest.setCharacterEncoding("utf-8");
        servletResponse.setCharacterEncoding("utf-8");
        servletResponse.setContentType("text/html;charset=utf-8");

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

3.在web.xml中配置Filter

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

12. 监听器

实现一个监听器的接口

1.编写一个监听器,实现监听器接口

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

//统计在线人数 : 统计session
public class OnLineCountListener implements HttpSessionListener {
    //创建session监听
    @Override
    public void sessionCreated(HttpSessionEvent se) {
        ServletContext ctx = se.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);

    }

    //销毁session监听
    @Override
    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);
    }
}

2.在web.xml中配置注册监听器

<!--注册监听器-->
<listener>
    <listener-class>com.kuang.listener.OnLineCountListener</listener-class>
</listener>

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

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

1. 用户登录之后,向Session中放入用户的数据

2. 进入主页的时候要判断用户是否已经登录; 要求: 在过滤器中实现!

3. import javax.servlet.*;
   import javax.servlet.http.*;
   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 {
           //ServletRequest   HttpServletRequest
           //ServletResponse   HttpServletResponse强转
           HttpServletRequest request=(HttpServletRequest) servletRequest;
           HttpServletResponse response=(HttpServletResponse) servletResponse;
   
           Object user_session = request.getSession().getAttribute("USER_SESSION");
   
           if (user_session==null){
               response.sendRedirect("/login.jsp");
           }
   
           filterChain.doFilter(servletRequest, servletResponse);
       }
   
       @Override
       public void destroy() {
   
       }
   }
   

14. JDBC

java连接数据

需要jar包:

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

设计数据库

CREATE DATABASE `jdbc`CHARACTER SET utf8 COLLATE utf8_general_ci;

USE `jdbc`;

CREATE TABLE users(
   id INT PRIMARY KEY,
   `name` VARCHAR(40),
   `password` VARCHAR(40)
);

INSERT INTO users VALUES(1,'Lee','123456'),(2,'Lance','123456'),(3,'L','123456');

SELECT * FROM users;

导入数据库依赖

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

IDEA中连接数据库JDBC

import java.sql.*;

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

        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");//通过反射
        //2.连接数据库  connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写SQL
        String sql="select * from users;";
        //4.预编译  创建preparedStatement代表向数据库发送SQL的对象   进行增删改查
        PreparedStatement preparedStatement = connection.prepareStatement(sql);

        //5.执行查询SQL,返回一个ResultSet结果集
        ResultSet resultSet = preparedStatement.executeQuery(sql);
        //6.获取结果
        while (resultSet.next()){
            System.out.println("id="+resultSet.getInt("id"));
            System.out.println("name="+resultSet.getString("name"));
            System.out.println("password="+resultSet.getString("password"));
        }
        //7.关闭连接,释放资源
        resultSet.close();
        preparedStatement.close();
        connection.close();
    }
}

import java.sql.*;

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

        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");//通过反射
        //2.连接数据库  connection代表数据库
        Connection connection = DriverManager.getConnection(url, username, password);
        //3.编写SQL
        String sql="insert into users values (?,?,?);";
        //4.预编译  创建PreparedStatement代表向数据库发送SQL的对象   进行增删改查
        PreparedStatement preparedStatement = connection.prepareStatement(sql);
        preparedStatement.setInt(1,4);//给第一个占位符?赋值为4
        preparedStatement.setString(2,"LEE");//给第二个占位符?赋值为LEE
        preparedStatement.setString(3,"123456");//给第三个占?位符赋值为123456

        //5.执行SQL,返回受影响行数
        int i = preparedStatement.executeUpdate();

        if(i>0){
            System.out.println("插入成功");
        }
        //6.关闭连接,释放资源
        preparedStatement.close();
        connection.close();
    }
}

事务

要么都成功,要么都失败

ACID原则:保证数据的安全.

开启事务
事务提交	commit()
事务回滚	rollback()
关闭事务

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 VALUES(1,'A',1000),(2,'B',1000),(3,'C',1000);

SELECT * FROM account;

转账测试

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

    Connection connection=null;
    //1.加载驱动
    try {
        Class.forName("com.mysql.cj.jdbc.Driver");//通过反射

        //2.连接数据库  connection代表数据库
        connection = DriverManager.getConnection(url, username, password);
        //3.通知数据库开启事务,false关闭自动提交,相当于start transaction;
        connection.setAutoCommit(false);
        String sql="update account set money=money-100 where name='A';";
        connection.prepareStatement(sql).executeUpdate();

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

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

        connection.commit();//以上两条SQL都执行成功了,就提交事务!
        System.out.println("转账成功");
    } catch (Exception e) {
        try {
            connection.rollback();//如果出错则回滚
        } catch (SQLException ex) {
            ex.printStackTrace();
        }
        e.printStackTrace();
    }finally {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

狂神说JavaWeb : https://www.bilibili.com/video/BV12J411M7Sj