JavaWeb

我有点小叛逆

已于 2023-05-10 13:16:07 修改

阅读量1k

点赞数

分类专栏： java框架文章标签： servlet java web

于 2023-04-02 19:49:20 首次发布

本文链接：https://blog.csdn.net/weixin_51714391/article/details/129759412

版权

java框架专栏收录该内容

9 篇文章 1 订阅

订阅专栏

本文详细介绍了JavaWeb开发中的核心技术，包括Servlet的生命周期、JSP语法、Maven项目构建、Http协议的工作原理、Session和Cookie的使用，以及过滤器和监听器的应用。同时，还涵盖了JDBC进行数据库操作的基础知识。

摘要由CSDN通过智能技术生成

前言
一、基本概念
- 1.1 前言
- 1.2 web应用程序
- 1.3 静态web
- 1.4 动态web
二、Web服务器
- 2.1、技术讲解
- 2.2、web服务器
三、Tomcat
- 3.1、安装Tomcat
- 3.2、Tomcat启动和配置
- 3.3、配置
- 3.4、发布一个web网站
四、Http
- 4.1、什么是Http
- 4.2、两个时代
- 4.3、Http请求
- 4.4、Http响应
五、Maven
- 5.1、Maven项目架构管理工具
- 5.2、下载安装Maven
- 5.3、配置环境变量
- 5.4、阿里云镜像
- 5.5、本地仓库
- 5.6、创建JavaWeb模板的Maven项目
- 5.7、JavaWeb的Maven项目配置Tomcat
- 5.8、pom文件
- 5.9、IDEA操作
六、Servlet
- 6.1、Servlet简介
- 6.2、Servlet入门例子
- 6.3、Servlet原理
- 6.4、ServletContext
- 6.5、HttpServletResponse
- 6.6、HttpServletRequest
- - 获取参数、请求转发
七、Cookie、Session
- 7.1、会话
- 7.2、保存会话的两种技术
- 7.3、Cookie
- - 入门例子
  - Cookie方法总结
- 7.4、Session（重点）
- - session实例应用
八、Jsp
- 8.1、什么是JSP
- 8.2、JSP原理
- 8.3、JSP基础语法
- 8.4、JSP指令
- 8.5、九大内置对象
- 8.6、JSP标签、JSTL标签、EL表达式
九、JavaBean
十、MVC三层架构
十一、Filter （重点）
十二、监听器（很少用）
十三、过滤器、监听器常见应用
十四、JDBC

前言

本博客基于b站狂神说，视频链接如下：
javaweb狂神说（idea版本）

一、基本概念

1.1 前言

web开发：

web，网页的意思， www.baidu.com
静态web
- html，css
- 提供给所有人看的数据始终不会发生变化！
动态web
- 淘宝，几乎是所有的网站；
- 提供给所有人看的数据始终会发生变化，每个人在不同的时间，不同的地点看到的信息各不相同！
- 技术栈：Servlet/JSP，ASP，PHP
在Java中，动态web资源开发的技术统称为JavaWeb；

1.2 web应用程序

web应用程序：可以提供浏览器访问的程序；

a.html、b.html…多个web资源，这些web资源可以被外界访问，对外界提供服务；
你们能访问到的任何一个页面或者资源，都存在于这个世界的某一个角落的计算机上。
URL：UniformResourceLocator,意为统一资源定位器,也被称为网页地址
这个统一的web资源会被放在同一个文件夹下，web应用程序–>Tomcat：服务器
一个web应用由多部分组成（静态web，动态web）
- html，css，js
- jsp，servlet
- Java程序
- jar包
- 配置文件（Properties）

web应用程序编写完毕后，若想提供给外界访问：需要一个服务器来统一管理；

1.3 静态web

*.htm, *.html,这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以直接进行读取。通络；

在这里插入图片描述

静态web存在的缺点

Web页面无法动态更新，所有用户看到都是同一个页面
- 轮播图，点击特效：伪动态
- JavaScript [实际开发中，它用的最多]
- VBScript
它无法和数据库交互（数据无法持久化，用户无法交互）

1.4 动态web

页面会动态展示： “Web的页面展示的效果因人而异”；

在这里插入图片描述

缺点：
- 加入服务器的动态web资源出现了错误，我们需要重新编写我们的后台程序,重新发布；
- 停机维护
优点：
- Web页面可以动态更新，所有用户看到都不是同一个页面
- 它可以与数据库交互（数据持久化：注册，商品信息，用户信息…）

二、Web服务器

2.1、技术讲解

ASP:

微软：国内最早流行的就是ASP；
在HTML中嵌入了VB的脚本，ASP+COM；
在ASP开发中，基本一个页面都有几干行的业务代码，页面极其换乱
维护成本高！
C#
IIS

在这里插入图片描述

php:

PHP开发速度很快，功能很强大，跨平台，代码很简单（70%，WP）
无法承载大访问量的情况（局限性）

jSP/Servlet:
B/S；浏览和服务器C/S：客户端和服务器

sun公司主推的B/S架构
基于Java语言的（所有的大公司，或者一些开源的组件，都是用Java写的）
可以承载三高问题带来的影响；
语法像ASP，ASP->JSP，加强市场强度；

2.2、web服务器

服务器是一种被动的操作，用来处理用户的一些请求和给用户一些响应信息；
lIS
微软的；ASP.,Windows中自带的
Tomcat

在这里插入图片描述面向百度编程：
Tomcat是Apache 软件基金会（Apache Software Foundation)的jakarta项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat中得到体现，因为Tomcat 技术先进、性能稳定，而且免费，因而深受lava爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web应用服务器。

Tomcat 服务器是一个免费的开放源代码的Web应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP程序的首选。对于一个Java初学web的人来说，它是最佳的选择

Tomcat 实际上运行JSP页面和Serlet。Tornct最新版易9.0

三、Tomcat

3.1、安装Tomcat

官网：http://tomcat.apache.org/

在这里插入图片描述

3.2、Tomcat启动和配置

文件夹作用：
在这里插入图片描述
启动。关闭Tomcat

在这里插入图片描述

访问测试：http://localhost:8080/

可能遇到的问题：

Java环境变量没有配置
闪退问题：需要配置兼容性
乱码问题：配置文件中设置

3.3、配置

在这里插入图片描述
可以配置启动的端口号

tomcat的默认端口号为：8080
mysql:3306
http:80
https：443

<Connector port="8081" protocol="HTTP/1.1"
      connectionTimeout="20000"
      redirectPort="8443" />

可以配置主机的名称

默认的主机名为：localhost->127.0.0.1
默认网站应用存放的位置为：webapps

  <Host name="www.qinjiang.com"  appBase="webapps"
        unpackWARs="true" autoDeploy="true">

高难度面试题：
请你谈谈网站是如何进行访问的！

1、输入一个域名；回车
2、检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射；

有：直接返回对应的ip地址，这个地址中，有我们需要访问的web程序，可以直接访问
没有：去DNS服务器找，找到的话就返回，找不到就返回找不到；

在这里插入图片描述

3.4、发布一个web网站

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

--webapps ：Tomcat服务器的web目录
	-ROOT
	-kuangstudy ：网站的目录名
		- WEB-INF
			-classes : java程序
			-lib：web应用所依赖的jar包
			-web.xml ：网站配置文件
		- index.html 默认的首页
		- static 
            -css
            	-style.css
            -js
            -img
         -.....

例如：

首先在webapps目录下创建GQStudy文件夹

在这里插入图片描述

其次，设计好网页首页文件：index.html

在这里插入图片描述

访问：也可以省略到index.html 因为默认是访问index.html

四、Http

4.1、什么是Http

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

文本：html，字符串，…
超文本：图片，音乐，视频，定位，地图.……
端口:80

HTTPS:多的一个S表示safe，安全的

端口：443

4.2、两个时代

http1.0
- HTTP/1.0：客户端可以与web服务器连接后，只能获得一个web资源，断开连接
http2.0
- HTTP/1.1：客户端可以与web服务器连接后，可以获得多个web资源。

4.3、Http请求

客户端–发请求（Request）–服务器
Http请求包含请求行和消息头
- 1、请求行：
  - 请求方式：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：主机..../.

以访问百度官网为例子：请求时请求行和消息头分别为：

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

//消息头
Accept:text/html  
Accept-Encoding:gzip, deflate, br
Accept-Language:zh-CN,zh;q=0.9    语言
Cache-Control:max-age=0
Connection:keep-alive

4.4、Http响应

服务器–响应…….客户端
相应包含响应体和响应状态码
- 响应体：

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

响应状态码

200：请求响应成功200
3xx:请求重定向·重定向：你重新到我给你新位置去；
4xx:找不到资源 404·资源不存在；
5xx:服务器代码错误 500 502:网关错误

常见面试题：
当你的浏览器中地址栏输入地址并回车的一瞬间到页面能够展示回来，经历了什么？

五、Maven

5.1、Maven项目架构管理工具

5.2、下载安装Maven

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

在这里插入图片描述

5.3、配置环境变量

在我们的系统环境变量中
配置如下配置：

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

在这里插入图片描述

5.4、阿里云镜像

在这里插入图片描述

镜像：mirrors
- 作用：加速我们的下载
国内建议使用阿里云的镜像

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

5.5、本地仓库

在本地的仓库，远程仓库；
建立一个本地仓库：localRepository

<localRepository>D:\MyWork\Program\maven\apache-maven-3.5.4\repository</
localRepository>

5.6、创建JavaWeb模板的Maven项目

5.6.1、启动IDEA

5.6.2、创建一个MavenWeb项目

在这里插入图片描述

5.6.3、等待项目初始化完毕

5.6.4、IDEA中的Maven设置

注意：IDEA项目创建成功后，看一眼Maven的配置

在这里插入图片描述

5.7、JavaWeb的Maven项目配置Tomcat

在这里插入图片描述
解决警告问题
必须要的配置：为什么会有这个问题：我们访问一个网站，需要指定一个文件夹名字；
也即是，必须要在Tomcat中webapps文件中添加一个文件夹（一个文件夹对应一个网站）：

在这里插入图片描述这样设置之后，也即是，在Tomcat中webapps文件中添加一个文件夹（一个文件夹对应一个网站）

5.8、pom文件

pom.xml 是Maven的核心配置文件
在这里插入图片描述

<?xml version="1.0" encoding="UTF-8"?>
<!--Maven版本和头文件-->
<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>
	<!--这里就是我们刚才配置的GAV-->
	<groupId>com.kuang</groupId>
	<artifactId>javaweb-01-maven</artifactId>
	<version>1.0-SNAPSHOT</version>
	<!--Package：项目的打包方式
	jar：java应用
	war：JavaWeb应用
	-->
	<packaging>war</packaging>


	<!--配置-->
	<properties>
		<!--项目的默认构建编码-->
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<!--编码版本-->
		<maven.compiler.source>1.8</maven.compiler.source>
		<maven.compiler.target>1.8</maven.compiler.target>
	</properties>
	
	<!--项目依赖-->
	<dependencies>
		<!--具体依赖的jar包配置文件-->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
		</dependency>
	</dependencies>

<!--项目构建用的东西-->
	<build>
		<finalName>javaweb-01-maven</finalName>
		<pluginManagement>
			<plugins>
			<plugin>
				<artifactId>maven-clean-plugin</artifactId>
				<version>3.1.0</version>
			</plugin>
			
			<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>

在这里插入图片描述
maven由于他的约定大于配置，我们之后可以能遇到我们写的配置文件，无法被导出或者生效的问题，
解决方案：

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
	<resources>
	<resource>
		<directory>src/main/resources</directory>
		<includes>
			<include>**/*.properties</include>
			<include>**/*.xml</include>
		</includes>
		<filtering>true</filtering>
	</resource>
	<resource>
		<directory>src/main/java</directory>
		<includes>
			<include>**/*.properties</include>
			<include>**/*.xml</include>
		</includes>
		<filtering>true</filtering>
	</resource>
	</resources>
</build>

5.9、IDEA操作

在这里插入图片描述

六、Servlet

6.1、Servlet简介

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

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

6.2、Servlet入门例子

Serlvet接口Sun公司有两个默认的实现类：HttpServlet，GenericServled
其结构如下：
在这里插入图片描述

步骤一：创建普通Maven工程

首先创建一个普通的Maven工程(javaweb-02-maven)，删掉原有的Src目录，也就是留着空的Maven工程:
在这里插入图片描述导入依赖：

在这里插入图片描述

步骤二: 将建javaweb子项目

在空Maven项目中，新建javaweb子项目（servlet-01）
在这里插入图片描述将javaweb子项目（servlet-01）中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>

步骤三：配置Tomcat

配置过程见5.7
配置结果如下：

在这里插入图片描述

步骤四：创建一个类，继承HttpServlet

首先将子项目servlet-01 结构补充完整
在这里插入图片描述其次，创建一个类HelloServlet，继承HttpServlet，并且重写其中的doGet以及doPost方法

在这里插入图片描述

步骤五：编写selvet映射

在步骤四中写了servlet类，需要进一步将此类映射到web项目中

在这里插入图片描述

步骤六：测试

开启Tomcat，并测试
网站路径输入：http://localhost:8080/kuang/servlet_01_war/lj_hello

在这里插入图片描述

6.3、Servlet原理

Servlet是由Web服务器调用，其运行具体结构为：

首先浏览器发送请求给web容器
若首次访问，则Servlet进行加载，一直保存到项目中，后续访问不会再重复加载，这也是为什么第一次访问某个页面会比较慢
web容器读取（响应）信息
web容器调用Servlet中Servive方法处理浏览器的请求，并返回对应的响应信息

在这里插入图片描述

6.4、ServletContext

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；
ServletContext非常重要，其可以实现多个Web应用（网页）的互通。
同一个javaweb项目中，多个Web应用（页面）共享一个ServletContext

基于ServletContext共享数据

本节例子：
基于两个web应用（页面），其中页面一：（Servlet入门例子中的页面 http://localhost:8080/kuang/servlet_01_war/lj_hello ）注入数据到ServletContext中。
页面二，获取页面一注入的数据（实现了页面一和页面二数据共享）

步骤一：
创建页面二：http://localhost:8080/kuang/servlet_01_war/lj_page2

在这里插入图片描述
步骤二：通过页面一中在ServletContext中注入数据信息
注入一个数据 data，其值为 gaoqiang

在这里插入图片描述 步骤三：页面二获取数据
在页面二中重写方法，用以获取公共数据

在这里插入图片描述

package com.kuang.servlet;

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

public class Page2 extends HelloServlet{

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext(); //获取ServetContxt对象
        String data = (String)context.getAttribute("data"); //获取页面一输入的数据 data

        //将获取的公共数据打印到前端
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("test/html");
        PrintWriter writer = resp.getWriter();
        writer.print(data);

    }

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

步骤四：测试
首先打开页面一（根据写打代码，数据会注入ServletContext）
其次，打开页面二，会呈现页面一注入的公共数据

基于ServletContext获取初始化参数

在这里插入图片描述

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

获取初始化参数:

在这里插入图片描述

package com.kuang.servlet;

import javax.servlet.ServletContext;
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 getParm 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 {
        super.doPost(req, resp);
    }
}

在这里插入图片描述

基于ServletContext请求转发

请求转发和重定向的区别

请求转发：
- 客户端A发送请求给web B，webB请求转发给web C，因此界面会呈现为web C的界面，但是url还是web B的
重定向：
- 客户端A发送请求给web B，webB重定向给web C，因此界面会呈现为web C的界面，并且url是web C的

在这里插入图片描述
例子：新建一个web页面testCdx

package com.kuang.servlet;

import javax.servlet.ServletContext;
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 testCdx extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext();
        //RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); //转发的请求路径
        //requestDispatcher.forward(req,resp); //调用forward实现请求转发；
        context.getRequestDispatcher("/lj_getParm").forward(req,resp);
    }

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

因此，访问网站：http://localhost:8080/kuang/servlet_01_war/lj_testcdx
实际是访问到了：http://localhost:8080/kuang/servlet_01_war/lj_getParm

基于ServletContext获取资源文件

基于ServletContext可以获取得到项目路径中的文件

例子
在resources目录下新建properties （最好在resources下面创建）
在这里插入图片描述

如果在java下面创建，那么必须要修改pom配置文件（5.8节有说明）

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
	<resources>
	<resource>
		<directory>src/main/resources</directory>
		<includes>
			<include>**/*.properties</include>
			<include>**/*.xml</include>
		</includes>
		<filtering>true</filtering>
	</resource>
	<resource>
		<directory>src/main/java</directory>
		<includes>
			<include>**/*.properties</include>
			<include>**/*.xml</include>
		</includes>
		<filtering>true</filtering>
	</resource>
	</resources>
</build>

新建网页，用以获取资源文件aa.properties中的内容

在这里插入图片描述

package com.kuang.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.InputStream;
import java.util.Properties;

public class getSour extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        InputStream resource = this.getServletContext().getResourceAsStream("/WEB-INF/classes/aa.properties");
        Properties properties = new Properties();
        properties.load(resource);
        String name = properties.getProperty("name");
        String age = properties.getProperty("age");

    }

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

在这里插入图片描述

6.5、HttpServletResponse

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

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

简单分类

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

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

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

void setCharacterEncoding(String var1);
void setContentLength(int var1);
void setContentLengthLong(long var1);
void setContentType(String var1);
void setDateHeader(String var1, long var2);
void addDateHeader(String var1, long var2);
void setHeader(String var1, String var2);
void addHeader(String var1, String var2);
void setIntHeader(String var1, int var2);
void addIntHeader(String var1, int var2);

响应的状态码

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

下载文件

下载文件的步骤：

获取下载文件的路径
获取下载文件的文件名
设置浏览器为可下载文件类型
获取下载文件的输入流
创建缓冲区
创建文件输出流
将文件通过文件输入流输入到缓冲区，并通过文件输出流输出到客户端

例子：
第一步：新建一个javaweb子项目（response），配置好对应maven环境以及Tomcat环境（参照上文6.2 Servlet入门例子）

在这里插入图片描述

**第二步：**编写一个java类（也就是一个web网站）实现HttpServlet，重写其中的方法，实现文件下载（先自己在resourse目录下创建一个文件高强.png，已备下载）
在这里插入图片描述

import sun.misc.UCDecoder;

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

public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //  1. 获取下载文件的路径
        //  getRealPath已经自动取到D:/MyWork\Program/Tomcat/apache-tomcat-7.0.77/webapps/kuang#response_war
        String realPath = this.getServletContext().getRealPath("/WEB-INF/classes/高强.png");
        System.out.println(realPath);
        //  2. 获取下载文件的文件名
        String name = realPath.substring(realPath.lastIndexOf("\\")+1); //获取得到了高强.png
        //  3. 设置浏览器为可下载文件类型   设置想办法让浏览器能够支持(Content-Disposition)下载我们需要的东西,中文文件名URLEncoder.encode编码，否则有可能乱码
        resp.setHeader("content-disposition", "attachment;filename="+ URLEncoder.encode(name,"utf-8"));
        //  4、创建输入流
        FileInputStream input = new FileInputStream(realPath);
        //  5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
        //  6. 创建文件输出流
        ServletOutputStream output = resp.getOutputStream();
        //  7. 将文件通过文件输入流输入到缓冲区，并通过文件输出流输出到客户端
        while (  (len = input.read(buffer))  > 0) {
            output.write(buffer,0,len);
        }

        //关闭流
        input.close();
        output.close();
    }




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

在这里插入图片描述

测试：http://localhost:8080/kuang/response_war/down
得到：
在这里插入图片描述

验证码功能

验证怎么来的？有两种方法

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

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

public class ImageServlet extends HttpServlet {

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

    <servlet>
        <servlet-name>image</servlet-name>
        <servlet-class>ImageServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>image</servlet-name>
        <url-pattern>/img</url-pattern>
    </servlet-mapping>

测试：http://localhost:8080/kuang/response_war/img
得到:
在这里插入图片描述

重定向（重点）

在这里插入图片描述

B一个web资源收到客户端A请求后，B他会通知A客户端去访问另外一个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不会产生变化
- 重定向时候，url地址栏会发生变

在这里插入图片描述
简单实现登录重定向
（由登录页面跳转到success.jsp）

首先：在index.jsp中用前端知识写出登录界面

在这里插入图片描述
第二步：书写/login 页面（在此里面书写重定向函数）

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 reDirect extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //处理请求
        String name = req.getParameter("name");
        String passwprd = req.getParameter("passwprd");

        //重定向到验证码的那个页面 (验证码页面在web.xml中配置的路径为/img)
        resp.sendRedirect("/kuang/response_war/scuuess.jsp");
    }

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

在这里插入图片描述
测试：
输入：http://localhost:8080/kuang/response_war/login
得出：
点击提交，重定向到success.jsp的页面

6.6、HttpServletRequest

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

获取参数、请求转发

前端的构造为：

在这里插入图片描述

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("=============================");
	System.out.println(req.getContextPath());
	//通过请求转发
	//这里的 / 代表当前的web应用  一般还是使用resp进行重定向
	req.getRequestDispatcher("/success.jsp").forward(req,resp);
}

七、Cookie、Session

7.1、会话

会话：用户打开一个浏览器，点击了很多超链接，访问多个web资源，关闭浏览器，这个过程可以称之为会话；
有状态会话：一个同学来过教室，下次再来教室，我们会知道这个同学，曾经来过，称之为有状态会话；

你能怎么证明你是西开的学生？

你 ------------------ 尚硅谷

发票西开给你发票
学校登记西开标记你来过了

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

客户端 ---------------------服务端

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

7.2、保存会话的两种技术

cookie
- 客户端技术（响应，请求）
session
- 服务器技术，利用这个技术，可以保存用户的会话信息？我们可以把信息或者数据放在Session 中！

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

7.3、Cookie

在这里插入图片描述

入门例子

目的：访问一个页面，得到上一次访问此页面的时间

步骤一：创建环境
创建maven环境–>创建javaweb子项目–>配置Tomcat
（具体步骤可见6.2 Servlet入门例子）

其中pom文件中需要导入依赖：

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

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

在这里插入图片描述

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

在这里插入图片描述
步骤二：编写web资源（编写页面）
写一个类实现HttpServlet，并且重写方法，实现访问此页面，得到上一次访问此页面的时间

在这里插入图片描述

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.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Date;

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

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


        //获取客户端的Cookie
        Cookie[] cookies = req.getCookies(); //这里返回数组，说明Cookie可能存在多个

        PrintWriter out = resp.getWriter();
        //判断Cookie是否存在
        if (cookies!= null){
            //如果存在，直接输出到页面上
            out.write("你上一次访问的时间是：");
            for (int i = 0; i < cookies.length; i++) {
                Cookie cookie = cookies[i];
                if (cookie.getName().equals("LastLoginTime")) {
                    //获取cookie中的值，并且为时间格式    URLDecoder：解码，防止乱码 
                    long l = Long.parseLong(URLDecoder.decode(cookie.getValue(),"utf-8"));
                    Date date = new Date(l);
                    out.write(date.toLocaleString());
                }

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

        //服务器给客户端响应一个cookie   URLEncoder.encode：编码，防止乱码
        Cookie cookie = new Cookie("LocalLoginTime", URLEncoder.encode(System.currentTimeMillis() + "","utf-8"));
        resp.addCookie(cookie);

    }

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

在这里插入图片描述
测试：
输入：http://localhost:8080/cookie_war/cookiedemo 两次，得到上一次访问的时间

Cookie方法总结

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

Cookie[] cookies = req.getCookies(); //获得Cookie
cookie.getName(); //获得cookie中的key
cookie.getValue(); //获得cookie中的vlaue
new Cookie("lastLoginTime", System.currentTimeMillis()+""); //新建一个cookie
cookie.setMaxAge(24*60*60); //设置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中；

session实例应用

我们利用session来实现一个登录验证的功能。如果用户登录成功了，那么我们在1天内访问主页面就不需要登录了。我们利用session进行实现。
创建了一个html页面，2个servlet来实现这次功能。代码如下

在这里插入图片描述

package com.kuang.session;

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

//这个Servlet用于判断用户名和密码是否是我们规定的

@WebServlet("/checkLogin")
public class checkServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取用户名和密码
        String name = req.getParameter("uesrname");
        String password = req.getParameter("password");

        //判断用户名和密码是否为我们设置的密码
        if (name.equals("高强")  && password.equals("Gq333888")) {
            //得到session
            HttpSession session = req.getSession();
            //设置最长访问间隔时间
            session.setMaxInactiveInterval(60*60*24);
            //将用户名存入session
            session.setAttribute("username",name);
            //重定向到主页面
            resp.sendRedirect(req.getContextPath()+ "/mainPage");
        } else {
            //设置MIME类型和编码
            resp.setContentType("text/html;charest=utf-8");
            //写回提示信息
            PrintWriter writer = resp.getWriter();
            writer.write("<h1>账号或密码错误</h1>");
            writer.write("<h3><a href='"+req.getContextPath()+"/login.jsp'>点击重新登录</a></h3>");
        }
    }

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

在这里插入图片描述

package com.kuang.session;

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

//这个Servlet就是我们的主页面
@WebServlet("/mainPage")
public class mainServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //设置响应的MIME类型和编码
        resp.setContentType("text/html;charest=utf-8");
        //得到session
        HttpSession session = req.getSession();
        //取出用户名
        Object username = session.getAttribute("username");
        PrintWriter writer = resp.getWriter();
        //判断用户名是否存在
        if (username != null) {
            //在一天内登陆过，无需再次登录
            writer.write("<h1>用户：" + username + "登录成功</h1>");
        } else {
            //没有登录。或者登录间隔大于1天。重定向登陆页面
            resp.sendRedirect(req.getContextPath()+"/login.jsp");
        }


    }

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

注意：要想使用 @WebServlet 注解。必须在web.xml中保证：
在这里插入图片描述其中version必须大于4.0
且：
metadata-complete=“false”
（metadata-complete="false"表示基于注解
metadata-complete="true"表示基于配置文件）

八、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目录

在这里插入图片描述
比如，书写一个简单的 hello 的jsp页面 hello.jsp:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Hello</title>
</head>
<body>
	<h1>hello</>
</body>
</html>

对应底层是把hello.jsp生成hello.java文件

/*
一个简单的 书写 hello 的jsp文件，对应的java文件
 */
package org.apache.jsp;

import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;

public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
    implements org.apache.jasper.runtime.JspSourceDependent {

  private static final javax.servlet.jsp.JspFactory _jspxFactory =
          javax.servlet.jsp.JspFactory.getDefaultFactory();

  private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;

  private volatile javax.el.ExpressionFactory _el_expressionfactory;
  private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;

  public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
    return _jspx_dependants;
  }

  public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
    if (_el_expressionfactory == null) {
      synchronized (this) {
        if (_el_expressionfactory == null) {
          _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
        }
      }
    }
    return _el_expressionfactory;
  }

  public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
    if (_jsp_instancemanager == null) {
      synchronized (this) {
        if (_jsp_instancemanager == null) {
          _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
        }
      }
    }
    return _jsp_instancemanager;
  }

  public void _jspInit() {
  }

  public void _jspDestroy() {
  }

  public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
        throws java.io.IOException, javax.servlet.ServletException {

    final javax.servlet.jsp.PageContext pageContext;
    javax.servlet.http.HttpSession session = null;
    final javax.servlet.ServletContext application;
    final javax.servlet.ServletConfig config;
    javax.servlet.jsp.JspWriter out = null;
    final java.lang.Object page = this;
    javax.servlet.jsp.JspWriter _jspx_out = null;
    javax.servlet.jsp.PageContext _jspx_page_context = null;


    try {
      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;

      out.write("<\r\n");
      out.write("<html>\r\n");
      out.write("<head>\r\n");
      out.write("<title>titel</title>\r\n");
      out.write("</head>\r\n");
      out.write("<body>\r\n");
            out.write("\r\n");
            out.write("hello\r\n");
            out.write("\r\n");
      out.write("<body>\r\n");
      out.write("<html>\r\n");

          } catch (java.io.IOException e) {}
        if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
        else throw new ServletException(t);
      }
    } finally {
      _jspxFactory.releasePageContext(_jspx_page_context);
    }
  }
}

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

JSP最终也会被转换成为一个Java类！
JSP 本质上就是一个Servlet，对应的方法如下：

//初始化
  public void _jspInit() {
      
  }
//销毁
  public void _jspDestroy() {
  }
//JSPService
  public void _jspService(.HttpServletRequest request,HttpServletResponse response)

内置一些对象：

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

输出页面前增加的代码：

response.setContentType("text/html");       //设置响应的页面类型
pageContext = _jspxFactory.getPageContext(this, request, response,
       null, true, 8192, true);
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;

以上的这些个对象我们可以在JSP页面中直接使用！

在这里插入图片描述
在JSP页面中；

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

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

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

这样的格式，输出到前端

8.3、JSP基础语法

JSP表达式

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

jsp脚本片段


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

脚本片段的再实现

  <%
    int x = 10;
    out.println(x);
  %>
  <p>这是一个JSP文档</p>
  <%
    int y = 2;
    out.println(y);
  %>

  <hr>


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

JSP声明

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

    private int globalVar = 0;

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

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

在JSP，嵌入Java代码即可！

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

<%--注释--%>

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

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、九大内置对象

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                      //响应

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

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


//因此，作用域：
application (也即ServletContext) > session > request > pageContext

场景例子：

request：客户端向服务器发送请求，产生的数据，用户看完就没用了，比如：新闻，用户看完没用的！
session：客户端向服务器发送请求，产生的数据，用户用完一会还有用，比如：购物车；
application：客户端向服务器发送请求，产生的数据，一个用户用完了，其他用户还可能使用，比如：聊天数据

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

首先要使用JSP标签，需要导入依赖

<!-- 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表达式

EL表达式 ${} 其主要作用有：

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

JSP标签

<%--jsp:include--%>

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

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

JSTL表达式

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

格式化标签
SQL标签
XML 标签
核心标签（掌握部分）

可以去JSTL菜鸟网站看看JSTL的用法

在这里插入图片描述

JSTL标签库使用步骤

在JSP文件中引入对应的 taglib

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

注意：在Tomcat 也需要引入 jstl的包，否则会报错：JSTL解析错误

使用其中的方法

c:if

<%--引入对应的 taglib --%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

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


<h4>if测试</h4>

<hr>

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

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

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

</body>

c:choose c:when

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

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

<c:choose>
    <c:when test="${score>=90}">
        你的成绩为优秀
    </c:when>
    <c:when test="${score>=80}">
        你的成绩为一般
    </c:when>
    <c:when test="${score>=70}">
        你的成绩为良好
    </c:when>
    <c:when test="${score<=60}">
        你的成绩为不及格
    </c:when>
</c:choose>

</body>

c:forEach

<%

    ArrayList<String> people = new ArrayList<>();
    people.add(0,"张三");
    people.add(1,"李四");
    people.add(2,"王五");
    people.add(3,"赵六");
    people.add(4,"田六");
    request.setAttribute("list",people);
%>


<%--
var , 每一次遍历出来的变量
items, 要遍历的对象
begin,   哪里开始
end,     到哪里
step,   步长
--%>
<c:forEach var="people" items="${list}">
    <c:out value="${people}"/> <br>
</c:forEach>

<hr>

<c:forEach var="people" items="${list}" begin="1" end="3" step="1" >
    <c:out value="${people}"/> <br>
</c:forEach>

九、JavaBean

实体类

JavaBean有特定的写法：

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

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

ORM ：对象关系映射

people表
在这里插入图片描述

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

class A{
    new People(1,"秦疆1号",3，"西安");
    new People(2,"秦疆2号",3，"西安");
    new People(3,"秦疆3号",3，"西安");
}

十、MVC三层架构

在这里插入图片描述

Model
- 业务处理：业务逻辑（Service）
- 数据持久层：CRUD （Dao - 数据持久化对象）
View
- 展示数据
- 提供链接发起Servlet请求（a，form，img…）
Controller （Servlet）
- 接收用户的请求：（req：请求参数、Session信息….）
- 交给业务层处理对应的代码
- 控制视图的跳转

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

十一、Filter （重点）

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

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

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

（比如用来过滤网上骂人的话，我***我自己 0-0）
（可以有多个过滤器串行，用以实现不同的过滤功能）

在这里插入图片描述
Filter开发步骤：

添加依赖

    <!--Servlet依赖-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
    </dependency>
    <!--JSP依赖-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>
    <!--JSTL表达式依赖-->
    <dependency>
      <groupId>javax.servlet.jsp.jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <!--standrad标签库-->
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>

编写过滤器

      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.kuang.filter.CharacterEncodingFilter</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>CharacterEncodingFilter</filter-name>
       <!--只要是 /servlet的任何请求，会经过这个过滤器-->
       <url-pattern>/servlet/*</url-pattern>
       <!-- 别偷懒写个 /* -->
   </filter-mapping>

十二、监听器（很少用）

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

编写一个监听器
实现监听器的接口…

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

    //创建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);

    }


    /*
    Session销毁：
    1. 手动销毁  getSession().invalidate();
    2. 自动销毁   在xml文件中配置
     */
}

web.xml中注册监听器

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

十三、过滤器、监听器常见应用

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

public class TestPanel {
    public static void main(String[] args) {
        Frame frame = new Frame("中秋节快乐");  //新建一个窗体
        Panel panel = new Panel(null); //面板
        frame.setLayout(null); //设置窗体的布局

        frame.setBounds(300,300,500,500);
        frame.setBackground(new Color(0,0,255)); //设置背景颜色

        panel.setBounds(50,50,300,300);
        panel.setBackground(new Color(0,255,0)); //设置背景颜色

        frame.add(panel);

        frame.setVisible(true);

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

    }
}

过滤器：例子
用户登录之后才能进入主页！用户注销后就不能进入主页了！要求：在过滤器中实现！

结构如下：

在这里插入图片描述

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.kuang</groupId>
    <artifactId>login_test</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>


    <dependencies>
        <!--导入jstl标签依赖-->
        <dependency>
            <groupId>javax.servlet.jsp.jstl</groupId>
            <artifactId>jstl-api</artifactId>
            <version>1.2</version>
        </dependency>

        <!--Servlet依赖-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <!--JSP依赖-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>

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

    </dependencies>

</project>

类CharacterFilter：

package com.kuang.Filter;

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

public class CharacterFilter implements Filter {


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

    }

    @Override
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入了过滤器1");
        //HttpServletRequest 是 ServletRequest的子类
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        response.setContentType("text/html;charset=UTF-8");

        //开启链
        filterChain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

类sysFilter：

package com.kuang.Filter;

import com.kuang.util.Constant;

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 servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入了过滤器sys");
        HttpServletRequest rep = (HttpServletRequest)servletRequest;
        HttpServletResponse resp = (HttpServletResponse)servletResponse;

        Object session = rep.getSession().getAttribute(Constant.USER_SESSION);

        if (session == null) {
            //转入到error.jsp
            resp.sendRedirect(rep.getContextPath() + "/error.jsp");;
        }

        filterChain.doFilter(rep,resp);

    }

    @Override
    public void destroy() {

    }
}

类LayOutServlet ：

package com.kuang.Servlet;

import com.kuang.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 LayOutServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        Object session = req.getSession().getAttribute(Constant.USER_SESSION);
        if (session != null) {
            //注销掉
            req.getSession().removeAttribute(Constant.USER_SESSION);
            //重定向到登陆页面
            resp.sendRedirect(req.getContextPath()+"/login.jsp");
        } else {
            resp.sendRedirect(req.getContextPath()+"/login.jsp");
        }
    }

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

类LoginServlet ：

package com.kuang.Servlet;

import com.kuang.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;
import java.io.PrintWriter;

public class LoginServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        PrintWriter writer = resp.getWriter();
        //获取前端的信息
        String username = req.getParameter("username");

        //判断登录名是否为admin
        if (username.equals("admin")) {
            //登录成功，保存session
            req.getSession().setAttribute(Constant.USER_SESSION,req.getSession().getId());
            //转向到成功的页面
            resp.sendRedirect(req.getContextPath()+"/sys/success.jsp");
        } else { //登陆失败
            //转到失败的页面
            resp.sendRedirect(req.getContextPath()+"/error.jsp");
        }
    }

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

类Constant ：

package com.kuang.util;

public class Constant {
    public final static String USER_SESSION = "USER_SESSION";
}

success.jsp:

<%--
  Created by IntelliJ IDEA.
  User: gaoqiang
  Date: 2023/4/1
  Time: 21:47
  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>
<h1>主页</h1>
<p><a href="../servlet/logout"> 注销 </a> </p>
</body>
</html>

error.jsp

<%--
  Created by IntelliJ IDEA.
  User: gaoqiang
  Date: 2023/4/1
  Time: 21:47
  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>
<h1> 错误</h1>
<h3>没有权限，登录名错误</h3>

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

</body>
</html>

login.jsp

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

<%--action的根目录为webapps 不包括login_test_war_exploded--%>
<%--action若最前面有/ 则表示：http://localhost:8080/   所以需要写成/login_test_war_exploded/servlet/login  就拼接为：http://localhost:8080/login_test_war_exploded/servlet/login--%>
<%--action若最前面无/ 则表示：http://localhost:8080/login_test_war_exploded  所以需要写成 servlet/login  就拼接为：http://localhost:8080/login_test_war_exploded/servlet/login--%>
<form action="servlet/login" method="post">
    <input type="text" name="username">
    <input type="submit">
</form>
</body>
</html>

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

        <!-- 配置/servlet/login        -->
         <servlet>
             <servlet-name>LoginServlet</servlet-name>
             <servlet-class>com.kuang.Servlet.LoginServlet</servlet-class>
         </servlet>
         <servlet-mapping>
             <servlet-name>LoginServlet</servlet-name>
             <url-pattern>/servlet/login</url-pattern>
         </servlet-mapping>

        <!-- 配置/servlet/logout        -->
        <servlet>
            <servlet-name>Logout</servlet-name>
            <servlet-class>com.kuang.Servlet.LayOutServlet</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>Logout</servlet-name>
            <url-pattern>/servlet/logout</url-pattern>
        </servlet-mapping>


        <!-- 配置过滤器   -->
        <filter>
            <filter-name>CharacterEncodingFilter</filter-name>
            <filter-class>com.kuang.Filter.CharacterFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>CharacterEncodingFilter</filter-name>
            <!--只要是 /servlet的任何请求，会经过这个过滤器-->
            <url-pattern>/*</url-pattern>
            <!-- 别偷懒写个 /* -->
        </filter-mapping>

        <filter>
            <filter-name>sysFilter</filter-name>
            <filter-class>com.kuang.Filter.sysFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>sysFilter</filter-name>
            <!--只要是 /servlet的任何请求，会经过这个过滤器-->
            <url-pattern>/sys/*</url-pattern>
            <!-- 别偷懒写个 /* -->
        </filter-mapping>
</web-app>

十四、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
关闭连接（先开的后关）

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

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

预编译SQL

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,2);//给第一个占位符？ 的值赋值为1；
        preparedStatement.setString(2,"狂神说Java");//给第二个占位符？ 的值赋值为狂神说Java；
        preparedStatement.setString(3,"123456");//给第三个占位符？ 的值赋值为123456；
        preparedStatement.setString(4,"24736743@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)

搭建一个环境，测试事物

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

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