JavaWeb
包含两个概念：Java和Web
1. 基本概念
1.1 前言
web开发：
-
web是网页的意思，比如www.baidu.com
-
静态web
- 使用html、css等技术实现的
- 提供给所有人看的数据始终不会发生变化
-
动态web
- 使用技术栈：Servlet/JSP,ASP,PHP
- 提供给所有人看的数据始终会发生变化，每个人在不同的时间不同的地点看到的信息各不相同。
- 比如淘宝，以及几乎所有的网站都使用动态web
在Java中，动态web资源开发的技术统称为JavaWeb。
1.2 web应用程序
什么是程序：是指一组指示计算机或其他具有信息处理能力装置执行动作或做出判断的指令
什么是web应用程序：可以提供给浏览器访问的程序
- a.html、b.html…整合多个web资源，这些web资源可以被外界访问，对外界提供服务
- 能访问到的任何一个页面或者资源，都存在于这个世界的某一个角落的计算机上
- URL：统一资源定位符
- 这些统一的web资源会被放在同一个文件夹中，就是web应用程序。（依赖于Tomcat服务器）
- 一个web应用由多部分组成（静态web，动态web）
- html，css，js
- jsp，servlet
- Java程序
- jar包
- 配置文件（.properties）
web应用程序编写完毕后，若想提供给外界访问，需要一个服务器来统一管理
1.3 静态web
- *.htm, *.html都是网页的后缀，如果服务器上一直存在这些东西，就可以通过网络直接读取。
- 静态web存在的缺点
- web页面无法动态更新，所有用户看到的都是同一个
- 伪动态：比如轮播图，点击特效
- 通过JavaScript（用的多）和VBScript实现
- 无法和数据库交互（数据无法被持久化，用户无法交互）
- web页面无法动态更新，所有用户看到的都是同一个
1.4 动态web
页面动态展示，web的页面展示效果因人而异
缺点：
- 假如服务器的动态web资源出现错误，要重新编写我们的后台程序，重新发布（停机维护）
优点：
- web页面可以动态更新，所有用户看到的都不是同一个
- 可以和数据库交互（数据持久化：注册后可以保存各种信息）
2. web服务器
2.1 技术讲解
ASP
- 微软：国内最早流行的
- 在HTML中嵌入了VB的脚本，ASP+COM
- ASP开发中，页面中嵌入java代码，页面极其混乱
- 维护成本高
<%
System.out.println("hello")
%>
PHP
- 开发速度很快，功能强大，跨平台，代码简单
- 局限性：无法承载大访问量的情况下
JSP/Servlet：
- sun公司主推的B/S架构（浏览器和服务器）
- 基于Java（所有的大公司或开源的组件，都是用Java写的）
- 可以承载三高（高并发、高可用、高性能）带来的影响
- 语法像ASP，加强市场强度
2.2 web服务器
服务器是一种被动的操作，用来处理用户的请求和给用户一些响应信息。
- IIS
微软的：ASP程序，Windows自带
- Tomcat
Tomcat是Apache 软件基金会(Apache Software Foundation)的Jakarta 项目中的一个核心项目，最新的Servlet 和JSP 规范总是能在Tomcat 中得到体现，Tomcat 5支持最新的Servlet 2.4 和JSP 2.0 规范。因为Tomcat 技术先进、性能稳定，而且免费，因而深受Java 爱好者的喜爱并得到了部分软件开发商的认可，成为目前比较流行的Web 应用服务器。
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML(标准通用标记语言下的一个应用)页面的访问请求。实际上Tomcat是Apache 服务器的扩展，但运行时它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。对于Java初学web的人来说，是最佳的选择。
诀窍是，当配置正确时，Apache 为HTML页面服务，而Tomcat 实际上运行JSP 页面和Servlet。另外，Tomcat和IIS等Web服务器一样，具有处理HTML页面的功能，另外它还是一个Servlet和JSP容器，独立的Servlet容器是Tomcat的默认模式。不过，Tomcat处理静态HTML的能力不如Apache服务器。目前Tomcat最新版本为9.0.37。
下载Tomcat：
- 安装or解压
- 了解配置文件及目录结构
- 作用
rt.jar（所有的class文件）
src.zip（源文件）
3. Tomcat
3.1 安装Tomcat
官网：[http://tomcat.apache.org/]
下载Tomcat9
选择64位安装包下载
（tar.gz是Linux系统下的安装包）
下载完成后解压
3.2 Tomcat启动和配置
- bin：启动、关闭的脚本文件
- conf：配置文件
- lib：依赖的jar包
- logs：日志
- temp：临时文件
- webapps：存放网站的
启动、关闭Tomcat：
bin目录下的startup.bat和shutdown.bat
访问测试：[http://localhost:8080/]
启动后：
关闭后：
在这个过程中，遇到了两个问题
（1）点击startup.bat闪退。原因是JAVA_HOME没有配置好（确切地说是之前没配置过，只配了PATH）。
（2）Tomcat访问显示错误500。原因是把Tomcat放在了C盘目录下，无法访问。更换到用户目录下就可以了。
PS：乱码问题改配置文件
3.3 配置
server.xml
可以配置启动的端口号
Tomcat默认端口号：8080
MySQL：3306
http：80
https：443
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
可以配置主机的名称
默认的主机名为：localhost（127.0.0.1）
默认的网站应用存房位置为：webapps
<Host name="localhost" appBase="webapps"
unpackWARs="true" autoDeploy="true">
面试题
请谈谈网站是如何进行访问的
C:\Windows\System32\drivers\etc\hosts
1、输入一个域名；回车后
2、检查本机的C:\Windows\System32\drivers\etc\hosts配置文件下有没有这个域名映射：
（1）有的话，直接返回对应的ip地址。这个地址中，有需要访问的web程序，可以直接访问
（2)没有的话，去DNS（Domain Name System）服务器找，找到的话返回，否则返回找不到。
3.4 发布一个web网站
模仿
- 将自己写的网站，放到Tomcat服务器中指定的web应用的文件夹（webapps）下，就可以访问了
网站应有的结构
webapps:Tomcat服务器的web目录
ROOT
study：网站的目录名
WEB-INF
class：java程序
lib：web应用所依赖的jar包
web.xml：网络配置文件
index.html 默认的首页
static：存放的一些静态资源文件
css
style.css
js
img
4. HTTP
4.1 什么是HTTP
HTTP（Hyper Text Transfer Protocol,超文本传输协议）是一个简单的请求-响应协议，它通常运行在TCP之上。端口号：80
HTTPS：安全的，端口号：443
4.2 两个时代
HTTP/1.0 客户端和web服务器连接后，只能获得一个web资源，之后会断开连接
HTTP/1.1 客户端和web服务器连接后，可以获得多个web资源
4.3 HTTP请求
- 客户端-发送请求-服务器
百度General：
Request URL: https://www.baidu.com/ //请求地址
Request Method: GET//方法：get和post
Status Code: 200 OK//状态码：200
Remote Address: 180.101.49.11:443//远程地址，端口号
Referrer Policy: no-referrer-when-downgrade
Request Headers:
Accept: text/html,application/xhtml+xml,application/xml;
Accept-Encoding: gzip, deflate, br 编码
Accept-Language: zh-CN,zh;q=0.9 语言
Cache-Control: max-age=0
Connection: keep-alive
Cookie: BAIDUID=A24BA666976B7B08B6DB066B68187F9E:FG=1; BIDUPSID=A24BA666976B7B08B6DB066B68187F9E; PSTM=1590660598; BDUSS=jItRGhPc1NtMzVXWEFOQTJ5Ty1TRzA2cTVzR3BSeEVGVElqaEhwMFNJR3p3MUJmRVFBQUFBJCQAAAAAAAAAAAEAAAAiOsaGu~q157~GMDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALM2KV-zNilfQ; BDUSS_BFESS=jItRGhPc1NtMzVXWEFOQTJ5Ty1TRzA2cTVzR3BSeEVGVElqaEhwMFNJR3p3MUJmRVFBQUFBJCQAAAAAAAAAAAEAAAAiOsaGu~q157~GMDcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALM2KV-zNilfQ; __yjs_duid=1_c99f946502bfde10acf9f661bdf9a7031608950277029; BD_HOME=1; H_PS_PSSID=33425_1450_33401_33306_32970_33286_33350_33313_33312_33311_33310_33414_33309_26350_33308_33307_33383_33370; BD_UPN=12314753; BA_HECTOR=0l2l8k00852l8h8g8g1fv0fkk0r
Host: www.baidu.com
Sec-Fetch-Mode: navigate
Sec-Fetch-Site: none
Sec-Fetch-User: ?1
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.108 Safari/537.36
1. 请求行
请求行中的请求方式：GET（还有一个是POST）
get:请求能够携带的参数比较少，大小有限制，会在浏览器的URL地址栏显示数据内容，不安全，但高效
post:请求能够携带的参数没有限制，大小没有限制，不会在浏览器的URL地址栏显示数据内容，安全，但不高效
2. 消息头
Accept: 它所支持的数据类型
Accept-Encoding: 支持哪种编码格式 GBK UTF-8 GB2312 ISO8859-1
Accept-Language: 语言环境
Cache-Control: 缓存控制
Connection: 请求完成是断开还是保持连接
Host: 主机
4.4 HTTP响应
- 服务器-反馈响应-客户端
Response Headers:
Bdpagetype: 2
Bdqid: 0x85c0df7f00307c0b
Cache-Control: private 缓存控制
Connection: keep-alive 连接
Content-Encoding: gzip 编码
Content-Type: text/html;charset=utf-8 类型
Date: Sat, 02 Jan 2021 09:43:20 GMT
Expires: Sat, 02 Jan 2021 09:43:20 GMT
Server: BWS/1.1
Set-Cookie: BDSVRTM=294; path=/
Set-Cookie: BD_HOME=1; path=/
Set-Cookie: H_PS_PSSID=33425_1450_33401_33306_32970_33286_33350_33313_33312_33311_33310_33414_33309_26350_33308_33307_33383_33370; path=/; domain=.baidu.com
Strict-Transport-Security: max-age=172800
Traceid: 160958060005571010669637948939129879563
Transfer-Encoding: chunked
X-Ua-Compatible: IE=Edge,chrome=1
1. 响应体
Refresh:多久刷新一次
Location:让网页重新定位
2. 响应状态码（重点）
200：请求响应成功
3xx：请求重定向 304
重定向：重新到指定的新位置上去
4xx：找不到资源 404
资源不存在
5xx：服务器代码错误 500 502（网关错误）
面试题：
浏览器中输入地址栏并回车的一瞬间到页面展示出来的过程中，发生了什么？
5. Maven
为什么要学习Maven
1、在JavaWeb开发中，需要使用大量的jar包，需要手动导入
2、如果有一个工具能够自动导入和配置这些jar包就好了
因此，Maven诞生了
5.1 Maven项目架构管理工具
目前就是用来方便导入jar包的
核心思想：约定大于配置（有约束，不要去违反）
Maven会规定好该如何去编写Java代码，必须按照这个规范来
5.2 Maven的下载和安装
官网：[https://maven.apache.org/]
下载完成后，解压即可
- bin ：执行文件
- boot：启动依赖的jar包
- conf：配置文件
- lib：jar包
5.3 配置环境变量
在系统变量中，配置：
- M2_HOME maven目录下的bin目录
- MAVEN_HOME maven目录
- 在系统的PATH里配置 %MAVEN_HOME%\bin
配置完成后：
5.4 修改配置文件-阿里云镜像
镜像mirrors：方便下载和使用（加速）
Maven是国外的，国内有墙，访问外网会很慢
国内建议使用阿里云的镜像
<mirror>
<id>alimaven</id>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/groups/public/</url>
<mirrorOf>central</mirrorOf>
</mirror>
5.5 修改配置文件-本地仓库
仓库分为本地仓库和远程仓库
建立一个本地仓库localRepository
<localRepository>D:\Program Files\Maven\apache-maven-3.6.3-bin\apache-maven-3.6.3\maven-repo</localRepository>
5.6 在IDEA中使用maven
1、启动IDEA
2、创建一个Maven项目
3、等待项目初始化完毕
4、maven仓库中多了东西
5、IDEA中的maven设置
创建成功后，看一眼maven的配置
6、maven在IDEA中的配置和使用就完成了
5.7 创建一个普通的maven项目
以下只有在web应用下才会有
5.8 标记文件夹功能
5.9 在IDEA中配置Tomcat
警告解决方式：
选择war包，警告消失
为什么存在这个警告呢？
因为在Tomcat访问一个网站时，必须要指定一个文件夹的名字，这个步骤就是做这个事情。
启动成功：
这里访问的HelloWorld就是默认的index.jsp中的内容
5.10 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.chao</groupId>
<artifactId>javaweb-01-maven</artifactId>
<version>1.0-SNAPSHOT</version>
<!--Package：项目的打包方式
jar：java应用
war：javaweb应用-->
<packaging>war</packaging>
<name>javaweb-01-maven Maven Webapp</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<!--配置-->
<properties>
<!--项目的默认构建编码-->
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!--项目依赖-->
<dependencies>
<!--具体依赖的jar包配置文件-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
</dependencies>
<!--项目构建用的东西-->
<build>
<finalName>javaweb-01-maven</finalName>
<pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
<plugins>
<plugin>
<artifactId>maven-clean-plugin</artifactId>
<version>3.1.0</version>
</plugin>
<!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>3.0.2</version>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
</plugin>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.22.1</version>
</plugin>
<plugin>
<artifactId>maven-war-plugin</artifactId>
<version>3.2.2</version>
</plugin>
<plugin>
<artifactId>maven-install-plugin</artifactId>
<version>2.5.2</version>
</plugin>
<plugin>
<artifactId>maven-deploy-plugin</artifactId>
<version>2.8.2</version>
</plugin>
</plugins>
</pluginManagement>
</build>
</project>
maven的高级之处在于，会帮你导入这个jar包所依赖的其他jar包
由于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>
5.11 IDEA操作
5.12 问题解决
1、maven3.6.3不兼容
版本过高
方法：降级为3.6.1
2、Tomcat闪退
这个问题我自己配置的过程中遇到过，是因为java环境配置的问题。缺少JAVA_HOME。配置好后，问题解决。
3、IDEA中每次都要重复配置maven
没有进行全局配置，只进行了项目配置
方法：在IDEA的全局默认配置中去配置
在新建项目的时候，就不用重新配置了
4、maven项目中Tomcat无法配置
根据版本配置
5、maven默认web版本中的web.xml版本太老了
方法：从Tomcat的web.xml里替换为webapp4.0版本，与Tomcat保持一致
<?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.13 maven仓库的使用
地址：[https://mvnrepository.com/]
搜索的时候，找不到需要的。因此想到去Tomcat的lib里看它需要的jar包，找到了servlet-api
找使用最多的那个
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.xml是配置web的核心应用-->
<!--注册servlet-->
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.chao.servlet.HelloServlet</servlet-class>
</servlet>
<!--一个servlet对应一个mapping（映射）-->
<servlet-mapping>
<servlet-name>helloServlet</servlet-name><!--和上面的servlet-name对应-->
<!--映射的请求路径-->
<url-pattern>/kuangshen</url-pattern>
</servlet-mapping>
</web-app>
HelloServlet.java
package com.chao.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse response) throws ServletException, IOException {
//响应的类型：html
response.setContentType("text/html");
//获取响应的输出流
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head>");
out.println("<title>Hello World!</title>");
out.println("</head>");
out.println("<body>");
out.println("<h1>Hello World!</h1>");
out.println("</body>");
out.println("</html>");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
6. Servlet
6.1 Servlet简介
- sun公司开发动态web的一门技术
- sun公司在这些API中提供一个借口叫做：servlet，如果想开发一个servlet程序，只需要完成两个小步骤
- 编写一个类，实现servlet接口
- 把开发好的Java类部署到web服务器中
把实现了servlet接口的Java程序叫做：servlet
6.2 HelloServlet
sun公司有两个servlet默认的实现类：HTTPServlet和GenericServlet
1、构建一个普通的maven项目，删掉里面的src目录，以后就在这个项目里建立Module。这个空的工程就是Maven的主工程。
New->Module
2、关于maven父子工程的理解
父项目中有：
<modules>
<module>servlet-01</module>
</modules>
子项目中有：
<parent>
<artifactId>javaweb-02-servlet</artifactId>
<groupId>com.chao</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
父项目中的jar包子项目可以直接使用
3、maven环境优化
（1）修改web.xml为最新的；
（2）将maven的结构搭建完整
4、编写一个servlet程序
（1）编写一个普通类
（2）实现servlet接口，这里直接继承HttpServlet
类的结构：
Servlet-》GenericServlet -》HttpServlet-》自己创建的类（只需要继承HttpServlet即可）
public class HelloServlet extends HttpServlet {
//由于get或host只是请求实现的不同的方式，可以相互调用，业务逻辑都一样
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// ServletOutputStream outputStream = resp.getOutputStream();
PrintWriter writer = resp.getWriter();//响应流
writer.print("Hello Servlet");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
super.doPost(req, resp);
}
}
5、编写Servlet的映射
为什么需要映射？
我们写的是java程序，但是需要通过浏览器访问，而浏览器需要连接web服务器，所以我们需要在web服务中注册我们写的Servlet，还需要给它一个浏览器能够访问的路径。
<!--注册servlet-->
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.chao.servlet.HelloServlet</servlet-class>
</servlet>
<!--servlet的请求路径-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
6、配置Tomcat
注意一些地方的修改，以及项目发布的路径
7、启动测试
6.3 Servlet原理
Servlet是由web服务器调用的，web服务器在收到浏览器请求之后，会：
（09p）
6.4 Mapping问题
1、一个servlet可以指定一个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
请求项目名下的名字即可
localhost:8080/s1/hello
2、一个servlet可以指定多个映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello2</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello3</url-pattern>
</servlet-mapping>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello4</url-pattern>
</servlet-mapping>
3、一个servlet可以指定通用映射路径
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello/*</url-pattern>
</servlet-mapping>
使用通配符
4、默认请求路径
<!--默认请求路径，不进index.jsp了-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
5、指定一些后缀或者前缀等等
<!--自定义后缀实现请求映射
注意点：*前面不能加映射的路径-->
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>*.chao</url-pattern>
</servlet-mapping>
注意点：*前面不能加映射的路径
6、优先级问题
指定了的固有的映射路径优先级最高，如果找不到就会走默认的处理请求
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.chao.servlet.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<!--404-->
<servlet>
<servlet-name>error</servlet-name>
<servlet-class>com.chao.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>error</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
6.5 ServletContext
web容器在启动的时候。它会为每一个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用。
1、共享数据
在这个Servlet中保存的数据，可以在另一个Servlet中拿到
HelloServlet.java(放数据的类)
public class HelloServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
System.out.println("Hello");
// this.getInitParameter() 初始化参数
// this.getServletConfig() Servlet配置
// this.getServletContext() 上下文
ServletContext context = this.getServletContext();
String username = "qinjiang";//数据
context.setAttribute("username",username);//讲一个数据保存在了ServletContext中，名字为username，值是username
}
}
GetServlet.java(读数据的类)
public class GetServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
ServletContext context = this.getServletContext();
String username = (String) context.getAttribute("username");
resp.setContentType("text/html");
resp.setCharacterEncoding("utf-8");
resp.getWriter().print("名字"+username);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>hello</servlet-name>
<servlet-class>com.chao.servlet.HelloServlet</servlet-class>
<!-- <init-param>-->
<!-- <param-name></param-name>-->
<!-- <param-value></param-value>-->
<!-- </init-param>-->
</servlet>
<servlet-mapping>
<servlet-name>hello</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>getc</servlet-name>
<servlet-class>com.chao.servlet.GetServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>getc</servlet-name>
<url-pattern>/getc</url-pattern>
</servlet-mapping>
测试访问结果：
如果没执行hello就直接getc
执行完hello再getc
2. 获取初始化参数
ServletDemo.java
public class ServletDemo 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);
}
}
web.xml
<!--配置一些web应用的初始化参数-->
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql://localhost:3306:mybatis</param-value>
</context-param>
<servlet>
<servlet-name>gp</servlet-name>
<servlet-class>com.chao.servlet.ServletDemo</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>gp</servlet-name>
<url-pattern>/gp</url-pattern>
</servlet-mapping>
3. 请求转发
重定向是发送两次请求得到两次响应，而转发是一次请求一次响应；
ServletDemo04.java
public class ServletDemo 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);
}
}
web.xml
<servlet>
<servlet-name>sd4</servlet-name>
<servlet-class>com.chao.servlet.ServletDemo04</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>sd4</servlet-name>
<url-pattern>/sd4</url-pattern>
</servlet-mapping>
4. 读取资源文件
properties
- 在java目录下新建properties
- 在resources目录下新建properties
发现：都被打包到了同一个路径下：classes（项目下的），俗称这个路径为classpath
思路：需要一个文件流
db.properties
username=root
password=123456
PropertiesServlet.java
public class PropertiesServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
InputStream is = this.getServletContext().getResourceAsStream("/WEB-INF/classes/com/chao/servlet/aa.properties");
//第一个斜杠不能省略，是相对路径，代表当前web项目
Properties properties = new Properties();
properties.load(is);
String user = properties.getProperty("username");
String pwd = properties.getProperty("password");
resp.getWriter().print(user+":"+pwd);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>ps</servlet-name>
<servlet-class>com.chao.servlet.PropertiesServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ps</servlet-name>
<url-pattern>/ps</url-pattern>
</servlet-mapping>
访问测试即可
6.6 HttpServletResponse
响应
web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象和代表相应的HttpServletResponse对象。
- 如果要获取客户端请求过来的参数：使用HttpServletRequest
- 如果要给客户端响应一些信息：使用HttpServletResponse
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);
响应的状态码
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;
2. 常见应用
1、向浏览器输出消息
getOutputStream()
getWriter()
2、下载文件
（1）获取下载文件的路径
（2）获取下载的文件名
（3）让浏览器能支持下载我们需要的东西
（4）获取下载文件的输入流
（5）创建缓冲区
（6）获取OutputStream对象
（7）将FileOutputStream流写入到buffer缓冲区
（8）使用OutputStream将缓冲区中的数据输出到客户端
FileServlet.java
public class FileServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//（1）获取下载文件的路径
String realPath = "C:\\Users\\Wang Yingchao\\IdeaProjects\\javaweb-02-servlet\\response\\target\\classes\\测试.png";
System.out.println("下载文件的路径："+realPath);
//（2）获取下载的文件名
String filename = realPath.substring(realPath.lastIndexOf("\\") + 1);
//（3）让浏览器能支持(Content-disposition)下载我们需要的东西
resp.setHeader("Content-disposition","attachment;filename="+URLEncoder.encode(filename,"utf-8"));
//（4）获取下载文件的输入流
FileInputStream in = new FileInputStream(realPath);
//（5）创建缓冲区
int len = 0;
byte[] buffer = new byte[1024];
//（6）获取OutputStream对象
ServletOutputStream out = resp.getOutputStream();
//（7）将FileOutputStream流写入到buffer缓冲区（8）使用OutputStream将缓冲区中的数据输出到客户端
while((len=in.read(buffer))>0){
out.write(buffer,0,len);
}
in.close();
out.close();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>filedown</servlet-name>
<servlet-class>com.chao.servlet.FileServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>filedown</servlet-name>
<url-pattern>/down</url-pattern>
</servlet-mapping>
小问题：中文名会导致下载显示错误
//中文文件名使用此编码
URLEncoder.encode(filename,"UTF-8"))
3、验证码
怎么实现验证？
- 前端，使用js判断
- 后端，使用Java的图片类，生成一个图片
public class ImageServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//如何让浏览器5秒自动刷新一次
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");
//把图片写给浏览器
boolean write = 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);
}
}
4、实现重定向
一个web资源B收到客户端A请求后，会通知客户端A去访问另一个web资源C，这个过程叫重定向。
常见场景：
- 用户登录
void sendRedirect(String var1) throws IOException;
测试代码：
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.sendRedirect("/response_war/img");//重定向
/*
原理：
resp.setHeader("Location","/r/img");
resp.setStatus(302);
*/
}
面试题：重定向与转发的异同
相同点：页面都会实现跳转
不同点：请求转发的时候，URL不会产生变化；重定向的时候，URL会产生变化。
index.jsp
<%@page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<body>
<h2>Hello World!</h2>
<%--这里提交的路径，需要找到项目的路径
${pageContext.request.contextPath}代表当前的项目--%>
<form action="${pageContext.request.contextPath}/login" method="get">
用户名：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
<input type="submit">
</form>
</body>
</html>
success.jsp
<%--
Created by IntelliJ IDEA.
User: Wang Yingchao
Date: 2021/1/5
Time: 20: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>success</h1>
</body>
</html>
web.xml
<servlet>
<servlet-name>request</servlet-name>
<servlet-class>com.chao.servlet.RequestTest</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>request</servlet-name>
<url-pattern>/login</url-pattern>
</servlet-mapping>
RequestTest.java
public class RequestTest extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//处理请求
String username = req.getParameter("username");
String password = req.getParameter("password");
System.out.println(username+":"+password);
//重定向一定要注意路径问题，否则会出现404
resp.sendRedirect("/response_war/success.jsp");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
6.7 HttpServletRequest
代表客户端的请求，用户通过Http协议访问服务器，Http请求中的所有信息会被封装到HttpServletRequest中。通过HttpServletRequest的方法，可以获得客户端的所有信息。
1. 获取前端的参数
String getParameter(String var1);
String[] getParameterValues(String var1);
//下面两个不常用
Enumeration<String> getParameterNames();
Map<String, String[]> getParameterMap();
2. 请求转发
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//后台接收乱码问题的处理
req.setCharacterEncoding("utf-8");
String name = req.getParameter("name");
String password = req.getParameter("password");
//获取多个值
String[] hobbies = req.getParameterValues("hobby");
System.out.println("==================================");
System.out.println(name);
System.out.println(password);
System.out.println(Arrays.toString(hobbies));
System.out.println("==================================");
//通过请求转发
//这里的/代表当前的web应用
req.getRequestDispatcher("/success.jsp").forward(req,resp);
}
}
转发与重定向的区别
转发的时候，url不会发生变化
重定向的时候，url会发生变化
7. Cookie和Session
7.1 概述
会话：用户打开浏览器，点开了很多超链接，访问多个web资源后，关闭了浏览器。这个过程可以称为会话。
例子：怎么证明一个人是某大学的学生？
1、通过校园卡：大学发给学生的
2、通过学校的花名册：大学标记的
类似的，怎么证明访问过一个网站？（要在客户端与服务器端建立联系）
1、服务器端给客户端一个信件，下次客户端带着信件访问服务器端就可以了。cookie
2、服务器端登记来过了，下次来的时候进行匹配。session
有状态会话：有一个同学来过，下次再来的时候，会知道这个同学曾经来过，称之为有状态会话。
7.2 保存会话的两种技术
cookie
是一种客户端技术（涉及到响应与请求）
session
是一种服务器端技术。利用这个技术，可以保存用户的会话信息。
可以把信息或者数据放在session中。
常见应用：
网站登录之后，下次不用登录直接就上去了。
7.3 Cookie
CookieDemo01.java
//保存用户上一次访问的时间
public class CookieDemo01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//服务器告诉用户访问的时间，把这个时间封装成一个信件，下次带来就知道来过了
//解决中文乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
PrintWriter out = resp.getWriter();
//cookie，使用时服务器端从客户端获取
Cookie[] cookies = req.getCookies();//这里返回数组，说明cookie可能存在多个
//判断cookie是否存在
if(cookies!=null){
//如果存在怎么办
out.write("你上一次访问的时间是：");
for (int i = 0; i < cookies.length; i++) {
Cookie cookie = cookies[i];
//获取cookie的名字
if (cookie.getName().equals("lastLoginTime")) {
//获取cookie中的值
long lastLoginTime = Long.parseLong(cookie.getValue());
Date date = new Date(lastLoginTime);
out.write(date.toLocaleString());
}
}
}else {
out.write("这是您第一次访问本站");
}
//服务器给客户端响应一个cookie
Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");
//cookie有效期为1天
cookie.setMaxAge(24*60*60);
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>CookieDemo01</servlet-name>
<servlet-class>com.chao.servlet.CookieDemo01</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>CookieDemo01</servlet-name>
<url-pattern>/c1</url-pattern>
</servlet-mapping>
1、从请求中拿到cookie信息
2、服务器响应给客户端cookie
使用到的方法
req.getCookies();//获得cookie
cookie。getName();//获得cookie中的key
cookie.getValue();//获得cookie中的值
new Cookie("lastLoginTime", System.currentTimeMillis()+"");//新建cookie
cookie.setMaxAge(24*60*60);//设置cookie的有效期
resp.addCookie(cookie);//响应给客户端一个cookie
cookie一般会保存在本地的用户目录下appdata
问题：一个网站是否存在cookie上限
- 一个cookie只能保存一个信息；
- 一个web站点可以给浏览器发送多个cookie，最多存放20个；
- cookie大小有限制，上限4kb
- 浏览器的cookie上限是300
删除cookie的方法：
- 不设置有效期，关闭浏览器自动失效
- 设置有效期时间为0
public class CookieDemo02 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//创建一个cookie，名字必须要和要删除的名字一致
Cookie cookie = new Cookie("lastLoginTime", System.currentTimeMillis()+"");
//将cookie有效期设置为0，立马过期
cookie.setMaxAge(0);;
resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
编码和解码：
//编码
Cookie cookie = new Cookie("name", URLEncoder.encode("秦疆","utf-8"));
//解码 out.write(URLDecoder.decode(cookie.getValue(),"utf-8"));
7.4 Session（重点）
什么是session：
- 服务器会给每一个用户（浏览器）创建一个session对象
- 一个session独占一个浏览器，只要这个浏览器没有关闭，这个session就存在
- 用户登录之后，整个网站都可以访问（保存用户的信息或购物车的信息）
HttpSession里的方法
session和cookie的区别
- cookie是把用户的数据写给浏览器，浏览器保存（可以保存多个）
- session把用户的数据写到用户独占的session中，服务器端保存（保存重要的信息，减少服务器资源的浪费）
使用场景：
- 保存一个登录用户的信息
- 购物车信息
- 整个网站中经常使用的数据，保存在session中
SessionDemo01.java
public class SessionDemo01 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//得到session
HttpSession session = req.getSession();
//给session存东西
session.setAttribute("name",new Person("秦疆",1));
//获取session的ID
String sessionId = session.getId();
//判断session是不是新创建的
if (session.isNew()) {
resp.getWriter().write("session创建成功，ID为"+sessionId);
}else {
resp.getWriter().write("session已经在服务器中存在，ID为"+sessionId);
}
//session创建的时候做了什么事情
// Cookie cookie = new Cookie("JSESSIONID", sessionId);
// resp.addCookie(cookie);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
SessionDemo02.java
public class SessionDemo02 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//解决乱码问题
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//得到session
HttpSession session = req.getSession();
Person person = (Person) session.getAttribute("name");
System.out.println(person.toString());
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req,resp);
}
}
SessionDemo03.java
public class SessionDemo03 extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
HttpSession session = req.getSession();
session.removeAttribute("name");
//手动注销session
session.invalidate();
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
web.xml
<servlet>
<servlet-name>SessionDemo01</servlet-name>
<servlet-class>com.chao.servlet.SessionDemo01</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SessionDemo01</servlet-name>
<url-pattern>/s1</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>SessionDemo02</servlet-name>
<servlet-class>com.chao.servlet.SessionDemo02</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SessionDemo02</servlet-name>
<url-pattern>/s2</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>SessionDemo03</servlet-name>
<servlet-class>com.chao.servlet.SessionDemo03</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SessionDemo03</servlet-name>
<url-pattern>/s3</url-pattern>
</servlet-mapping>
会话自动过期的xml配置
<!--设置session默认的失效时间-->
<session-config>
<!--15分钟后session自动失效，以分钟为单位-->
<session-timeout>15</session-timeout>
</session-config>
8. JSP
8.1 什么是JSP
Java Server Pages，Java服务器页面。和Servlet一样，用于开发动态web。
最大的特点：写JSP就像在写HTML
JSP与HTML区别：
- HTML只给用户提供静态的数据
- JSP页面中可以嵌入Java代码，为用户提供动态数据
8.2 JSP原理
JSP怎么执行的
-
代码层面很像HTML
-
服务器层面
Tomcat中有一个work目录
IDEA中使用Tomcat会在IDEA的Tomcat中生成一个work目录
C:\Users\Wang Yingchao\.IntelliJIdea2019.3\system\tomcat\Unnamed_javaweb-session-cookie\work\Catalina\localhost\ROOT\org\apache\jsp
页面变成了java程序
浏览器向服务器发送请求，不管访问什么资源，其实都是在访问Servlet
JSP最终也会被转换为一个Java类
HttpJspPage继承了JspPage，JspPage继承了Servlet
本质还是一个Servlet
//初始化
public void _jspInit() {
}
//销毁
public void _jspDestroy() {
}
//JSPService
public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
1、判断请求
2、内置了一些对象
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;//当前页
HttpServletRequest request//请求
HttpServletResponse response//响应
3、输出页面前增加的代码
response.setContentType("text/html");//设置响应的页面类型为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("<head>\r\n");
这样的格式，输出到前端。
8.3 JSP基础语法
建立一个普通的maven项目，添加web框架支持
ctrl+F10
任何语言都有自己的语法。JSP作为Java技术的一种应用，拥有一些扩充的语法，同时支持所有的java语法格式。
JSP表达式
<%--JSP表达式
作用：用来将程序的输出，输出到客户端
<%= 变量或者表达式%>
--%>
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 =20;
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代码即可（可以使用EL表达式）
<%%> 片段
<%=%> 表达式输出一个值
<%!%> 定义全局的值
<%--注释--%> 注释
JSP的注释不会在客户端显示，而HTML的代码可以在客户端显示。
8.4 JSP指令
jsp2.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--定制错误页面--%>
<%@ page errorPage="error/500.jsp" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
int x = 1/0;
%>
</body>
</html>
500.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<img src="../img/500.png" alt="500">
</body>
</html>
404.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<img src="../img/404.png" alt="">
</body>
</html>
web.xml
<error-page>
<error-code>404</error-code>
<location>/error/404.jsp</location>
</error-page>
<error-page>
<error-code>500</error-code>
<location>/error/500.jsp</location>
</error-page>
<%--显式的声明这是一个错误页面--%>
<%@ page isErrorPage="true" %>
<%@ page args... %>
<%--include会将两个页面合二为一--%>
<%@include file="common/header.jsp"%>
<h1>网页主体</h1>
<%@include file="common/footer.jsp"%>
<hr>
<%--JSP标签--%>
<%--使用jsp:include拼接页面，本质还是三个--%>
<jsp:include page="common/header.jsp"/>
<h1>网页主体</h1>
<jsp:include page="common/footer.jsp"/>
8.5 九大内置对象
- PageContext 存东西
- Request 存东西
- Response
- session 存东西
- application（ServletContext）存东西
- config（ServletConfig）
- out
- page 不用了
- exception
PageContextDemo01.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--内置对象--%>
<%
pageContext.setAttribute("name1","一号");//保存的数据只在一个页面中有效
request.setAttribute("name2","二号");//保存的数据只在一次请求中有效。请求转发会携带这个数据
session.setAttribute("name3","三号");//保存的数据只在一次会话中有效。从打开浏览器到关闭浏览器
application.setAttribute("name4","四号");//保存的数据。从打开服务器到关闭服务器
%>
<%--通过pageContext取出保存的值--%>
<%
//从pageContext里取出
pageContext.getAttribute("name1");
//使用寻找的方式来
//作用域从底层到高层,pgae->request->session->application
//JVM的双亲委派机制
String name1 = (String) pageContext.findAttribute("name1");
String name2 = (String) pageContext.findAttribute("name2");
String name3 = (String) pageContext.findAttribute("name3");
String name4 = (String) pageContext.findAttribute("name4");
String name5 = (String) pageContext.findAttribute("name5");//不存在
%>
<%--使用EL表达式输出${}}--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3><%= name5%></h3><%--打印null--%>
<h3>${name5}</h3><%--被过滤--%>
</body>
</html>
运行结果
pageDemo02.jsp
<%--
Created by IntelliJ IDEA.
User: Wang Yingchao
Date: 2021/1/8
Time: 14:43
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
//从pageContext里取出
pageContext.getAttribute("name1");
//使用寻找的方式来
//作用域从底层到高层
String name1 = (String) pageContext.findAttribute("name1");
String name2 = (String) pageContext.findAttribute("name2");
String name3 = (String) pageContext.findAttribute("name3");
String name4 = (String) pageContext.findAttribute("name4");
String name5 = (String) pageContext.findAttribute("name5");//不存在
%>
<%--使用EL表达式输出${}}--%>
<h1>取出的值为：</h1>
<h3>${name1}</h3>
<h3>${name2}</h3>
<h3>${name3}</h3>
<h3>${name4}</h3>
<h3><%= name5%></h3><%--打印null--%>
</body>
</html>
运行结果
pageContextDemo02.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
pageContext.forward("/index.jsp");
// request.getRequestDispatcher("/index.jsp").forward(request,response);
%>
</body>
</html>
总结：
request：客户端向服务器发送请求，产生的数据用户看完就没用了。比如：新闻；
session：客户端向服务器发送请求，产生的数据用户用完一会还有用。比如：购物车信息；
application：客户端向服务器发送请求，产生的数据一个用户用完了，其他用户还可能使用。比如：聊天记录。
8.6 JSP标签、JSTL标签、EL表达式
<!-- jstl表达式的依赖 -->
<dependency>
<groupId>javax.servlet.jsp.jstl</groupId>
<artifactId>jstl-api</artifactId>
<version>1.2</version>
</dependency>
<!-- standard标签库 -->
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
EL表达式：
- 获取数据
- 执行运算
- 获取web开发的常见对象
- 调用Java方法
JSP标签
<%--<jsp:include page=""/>--%>
<%--在转发的时候携带参数，相当于
http://localhost:8080/jsptag.jsp?name=wdc&age=18
--%>
<jsp:forward page="/jsptag2.jsp">
<jsp:param name="name" value="wdc"/>
<jsp:param name="age" value="18"/>
</jsp:forward>
<%--在jsptag2里取出参数--%>
名字：<%= request.getParameter("name")%>
年龄：<%= request.getParameter("age")%>
JSTL标签
JSTL标签库的使用就是为了弥补HTML标签的不足。它自定义了许多标签，可以供我们使用。标签的功能和java代码一样。
分类：核心标签 格式化标签 SQL标签 XML标签
核心标签
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
使用步骤：
1、引入对应的taglib
2、使用其中的方法
在Tomcat里也要引入JSTL的包，否则报错:JSTL解析错误
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL核心标签库，才能使用JSTL标签--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h4>if测试</h4>
<hr>
<form action="core.jsp" method="get">
<%--EL表达式获取表单中的数据
${param.参数名}
--%>
<input type="text" name="username" value="${param.username}">
<input type="submit" value="登录">
</form>
<%--判断如果提交的用户是管理员，则登录成功--%>
<%--<%--%>
<%-- if(request.getParameter("username").equals("admin")){--%>
<%-- out.print("登录成功");--%>
<%-- }--%>
<%--%>--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
<c:out value="管理员欢迎您！"/>
</c:if>
<c:out value="${isAdmin}"/>
</body>
</html>
coreif.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入JSTL核心标签库，才能使用JSTL标签--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h4>if测试</h4>
<hr>
<form action="core.jsp" method="get">
<%--EL表达式获取表单中的数据
${param.参数名}
--%>
<input type="text" name="username" value="${param.username}">
<input type="submit" value="登录">
</form>
<%--判断如果提交的用户是管理员，则登录成功--%>
<%--<%--%>
<%-- if(request.getParameter("username").equals("admin")){--%>
<%-- out.print("登录成功");--%>
<%-- }--%>
<%--%>--%>
<c:if test="${param.username=='admin'}" var="isAdmin">
<c:out value="管理员欢迎您！"/>
</c:if>
<c:out value="${isAdmin}"/>
</body>
</html>
corewhen.jsp
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--定义一个变量score，值为85--%>
<c:set var="score" value="95"/>
<%--从上到下选择--%>
<c:choose>
<c:when test="${score>=90}">
你的成绩为优秀
</c:when>
<c:when test="${score>=80}">
你的成绩为一般
</c:when>
<c:when test="${score>=70}">
你的成绩为良好
</c:when>
<c:when test="${score<=60}">
你的成绩为不及格
</c:when>
</c:choose>
</body>
</html>
coreforeach.jsp
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
ArrayList<String> people = new ArrayList<>();
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="2">
<c:out value="${people}"/><br>
</c:forEach>
</body>
</html>
9. JavaBean
实体类
JavaBean有特定的写法
- 必须要有一个无参构造
- 属性必须私有化
- 必须要有对应的get/set方法
一般用来和数据库的字段做映射 ORM
ORM：对象关系映射
- 表—>类
- 字段—>属性
- 行记录—>对象
people表
| id | name | age | address |
|---|---|---|---|
| 1 | 张三 | 3 | 北京 |
| 2 | 李四 | 18 | 上海 |
| 3 | 王五 | 100 | 广州 |
class People{
private int id;
private String name;
private int age;
private String address;
}
class A{
new People(1,"张三",3,"北京");
new People(2,"李四",18,"上海");
new People(3,"王五",100,"广州");
}
People.java
package com.chao.pojo;
//实体类，一般都是和数据库中的表结构一一对应
public class People {
private int id;
private String name;
private int age;
private String address;
public People() {
}
public People(int id, String name, int age, String address) {
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", address='" + address + '\'' +
'}';
}
}
javabean.jsp
<%@ page import="com.chao.pojo.People" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
// People people = new People();
// people.setId(4);
// people.setName("wdc");
// people.setAge(18);
// people.setAddress("长沙");
%>
<jsp:useBean id="people" class="com.chao.pojo.People" scope="page"/>
<jsp:setProperty name="people" property="id" value="4"/>
<jsp:setProperty name="people" property="name" value="wdc"/>
<jsp:setProperty name="people" property="age" value="18"/>
<jsp:setProperty name="people" property="address" value="长沙"/>
id:<jsp:getProperty name="people" property="id"/>
姓名：<jsp:getProperty name="people" property="name"/>
年龄：<jsp:getProperty name="people" property="age"/>
地址：<jsp:getProperty name="people" property="address"/>
</body>
</html>
10. MVC三层架构
什么是MVC
Model-View-Controller：模型-视图-控制器
10.1 早期的架构
用户直接访问控制层，控制层就可以直接操作数据库
servlet(已经写了CRUD)-》操作数据库
servlet代码中包含：处理请求、响应、视图跳转、处理JDBC、处理业务代码、处理逻辑代码
弊端：程序非常臃肿，耦合度高，不利于维护。
架构的层面：没有什么是加一层解决不了的
10.2 MVC三层架构
model
- 业务处理：负责业务逻辑（service）
- 数据持久层：CRUD（Dao层）
view
- 展示数据
- 提供链接发起servlet请求（a,img,form…)
controller
- 接收用户的请求：req，获得请求参数、session信息
- 交给业务层处理对应的代码
- 控制视图跳转
eg：
登录-》接收用户的登录请求-》处理用户的请求（获取用户登录的参数，用户名和密码）-》交给业务层处理登录业务（判断用户名和密码是否正确：事务）-》Dao层查询用户名和密码是否正确-》查询数据库
11. Filter（重点）
filter：过滤器，用来过滤网站的数据
- 处理中文乱码
- 登录验证
filter也需要请求和响应，和servlet一样
新建普通maven项目后导入web文件夹
filter开发步骤：
1、导包
2、编写过滤器
（1）导包不要选错了，是javax.servlet下的
（2）实现Filter接口，重写对应的方法即可
package com.chao.filter;
import javax.servlet.*;
import java.io.IOException;
public class CharacterEncodingFilter implements Filter {
//初始化，web服务器启动就初始化了，随时等待过滤对象出现
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("CharacterEncodingFilter初始化！");
}
//chain：链
/*
1、过滤器中的所有代码，在过滤特定请求的时候都会执行
2、必须要让过滤器继续通行
chain.doFilter(request,response);
*/
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
request.setCharacterEncoding("utf-8");
response.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=UTF-8");
System.out.println("CharacterEncodingFilter执行前");
chain.doFilter(request,response);//让我们的请求继续走，如果不写，程序到这里就被拦截停止了
System.out.println("CharacterEncodingFilter执行后");
}
//销毁，web服务器关闭的时候，过滤会销毁
public void destroy() {
System.out.println("CharacterEncodingFilter销毁！");
}
}
3、在web.xml中配置filter
<filter>
<filter-name>CharacterEncodingFilter</filter-name>
<filter-class>com.chao.filter.CharacterEncodingFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<!--只要是/servlet的任何请求，都会经过这个过滤器-->
<url-pattern>/servlet/*</url-pattern>
</filter-mapping>
12. 监听器
实现一个监听器的接口（有很多种）
1、编写一个监听器（实现监听器的接口，重写里面的方法）
package com.chao.listener;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
//统计网站在线人数：统计session
public class OnlineCountListener implements HttpSessionListener {
//创建session监听，观察一举一动
//一旦创建session就会触发一次这个事件
public void sessionCreated(HttpSessionEvent se) {
ServletContext ctx = se.getSession().getServletContext();
System.out.println(se.getSession().getId());
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if(onlineCount==null){
onlineCount = new Integer(1);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count+1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
//销毁session监听
//一旦销毁session就会触发一次这个事件
public void sessionDestroyed(HttpSessionEvent se) {
ServletContext ctx = se.getSession().getServletContext();
Integer onlineCount = (Integer) ctx.getAttribute("OnlineCount");
if(onlineCount==null){
onlineCount = new Integer(0);
}else {
int count = onlineCount.intValue();
onlineCount = new Integer(count-1);
}
ctx.setAttribute("OnlineCount",onlineCount);
}
/*session销毁的方法
1、手动销毁：se.getSession().invalidate();
2、自动销毁：在web.xml中配置过期时间<session-config>里的<session-timeout>
*/
}
2、在web.xml中注册监听器
<!--注册监听器-->
<listener>
<listener-class>com.chao.listener.OnlineCountListener</listener-class>
</listener>
13. 过滤器和监听器的常见应用
监听器：GUI编程中经常使用
package com.chao.listener;
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class TestPanel {
public static void main(String[] args) {
Frame frame = new Frame("新年快乐");//新建一个窗体
Panel panel = new Panel(null);//新建一个面板
frame.setLayout(null);//设置窗体的布局
frame.setBounds(300,300,500,500);
frame.setBackground(new Color(0,0,255));
panel.setBounds(50,50,300,300);
panel.setBackground(new Color(0,255,0));
frame.add(panel);
//监听事件，监听关闭事件
frame.addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.setVisible(true);
}
}
用户登录之后才能进入主页，用户注销后就不能进入主页
sys/success.jsp
<%@ 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>
LoginServlet.java
package com.chao.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//获取前端请求的参数
String username = req.getParameter("username");
if(username.equals("admin")){//登录成功
req.getSession().setAttribute("USER_SESSION",req.getSession().getId());//获取信息
resp.sendRedirect("/sys/success.jsp");//跳转到成功页面
}else {//登录失败
resp.sendRedirect("/error.jsp");//跳转到失败页面
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
Login.jsp
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<h1>登录</h1>
<form action="/servlet/login" method="get">
<input type="text" name="username">
<input type="submit">
</form>
</body>
</html>
error.jsp
<%@ 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>
LogoutServlet.java
package com.chao.servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class LogoutServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//不移除session，移除属性
Object user_session = req.getSession().getAttribute("USER_SESSION");
if(user_session!=null){
req.getSession().removeAttribute("USER_SESSION");
}
resp.sendRedirect("/Login.jsp");
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
SysFilter.java
package com.chao.filter;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class SysFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
}
public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) resp;
if(request.getSession().getAttribute("USER_SESSION")==null){
response.sendRedirect("/Login.jsp");
}
chain.doFilter(request,response);
}
public void destroy() {
}
}
web.xml
<servlet>
<servlet-name>LoginServlet</servlet-name>
<servlet-class>com.chao.servlet.LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LoginServlet</servlet-name>
<url-pattern>/servlet/login</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>LogoutServlet</servlet-name>
<servlet-class>com.chao.servlet.LogoutServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>LogoutServlet</servlet-name>
<url-pattern>/servlet/logout</url-pattern>
</servlet-mapping>
<filter>
<filter-name>SysFilter</filter-name>
<filter-class>com.chao.filter.SysFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>SysFilter</filter-name>
<url-pattern>/sys/*</url-pattern>
</filter-mapping>
如果想要定制页面，增加sys/vip1、vip2、vip3文件夹，跳转不同的index页面
if(request.getSession().setAttribute("USER_SESSION").level==VIP1){
response.sendRedirect("/vip1/index.jsp");
}
1、用户登录之后，向session放入用户的数据
2、进入主页的时候判断用户是否已经登录（要求：在过滤器中实现）
14. JDBC复习
JDBC:Java Data Base Connectivity
增加一层驱动，适应不同的厂商
需要jar包的支持：
java.sql
javax.sql
mysql-connector-java
MySQL语句
CREATE TABLE `users`(
`id` INT(10) PRIMARY KEY,
`name` VARCHAR(40),
`password` VARCHAR(40),
`email` VARCHAR(60),
`birthday` DATE
);
INSERT INTO `users`
VALUES(1,'张三','123456','123@qq.com','2000-01-01'),
(2,'李四','123456','12@qq.com','2000-01-01'),
(3,'王五','123456','1@qq.com','2000-01-01');
SELECT * FROM users;
导入数据库依赖
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
</dependencies>
IDEA中连接数据库
JDBC的步骤：
1、加载驱动
2、连接数据库
3、向数据库发送SQL的对象，Statement
4、根据业务，编写SQL
5、执行SQL
6、关闭连接
TestJdbc.java
package com.chao.test;
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&useSSL=true";
String username = "root";
String password = "123456";
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库
Connection connection = DriverManager.getConnection(url, username, password);
//3.向数据库发送SQL的对象statement
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"));
// }
//4.编写SQL
String sql = "delete from users where id = 4";
//5.执行查询SQL，返回int类型，受影响的行数
//增删改都使用update
int i = statement.executeUpdate(sql);
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
package com.chao.test;
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&useSSL=true";
String username = "root";
String password = "123456";
//1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
//2.连接数据库
Connection connection = DriverManager.getConnection(url, username, password);
//3.编写SQL
String sql = "insert into users(id,name,password,email,birthday) values (?,?,?,?,?);";
//4.预编译
PreparedStatement preparedStatement = connection.prepareStatement(sql);
preparedStatement.setInt(1,4);//给第一个占位符赋值为4
preparedStatement.setString(2,"田七");
preparedStatement.setString(3,"123456");
preparedStatement.setString(4,"172@qq.com");
preparedStatement.setDate(5,new Date(new java.util.Date().getTime()));
//5.执行SQL，返回结果集ResultSet
int i = preparedStatement.executeUpdate();
if(i>0){
System.out.println("插入成功");
}
//6.关闭连接，释放资源，先开后关
preparedStatement.close();
connection.close();
}
}
事务
要么都成功，要么都失败
ACID原则：保证数据的安全
- 开启事务
- 事务提交
- 事务回滚
- 关闭事务
Junit单元测试
依赖
<!--单元测试 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
简单使用
@Test注解只有在方法上有效，加了这个主节点方法就可以直接运行
package com.chao.test;
import org.junit.Test;
public class TestJdbc3 {
@Test
//以前想要执行这个方法，就要新建对象，调用方法
public void test(){
System.out.println("Hello");
}
}
测试成功：
测试失败：
package com.chao.test;
import org.junit.Test;
public class TestJdbc3 {
@Test
//以前想要执行这个方法，就要新建对象，调用方法
public void test(){
System.out.println(1/0);
}
}
搭建测试环境
创建表插入数据
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);
在数据库里操作事务
start transaction;#开启事务
update account set money = money - 100 where name = 'A';
update account set money = money + 100 where name = 'B';
rollback ;
commit ;
TestJdbc.java
package com.chao.test;
import org.junit.Test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class TestJdbc3 {
@Test
//以前想要执行这个方法，就要新建对象，调用方法
public void test() {
//配置信息，解决中文乱码问题
String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf-8&useSSL=true";
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.通知数据库开启事务
connection.setAutoCommit(false);
String sql1="update account set money = money - 100 where name = 'A';";
connection.prepareStatement(sql1).executeUpdate();
//制造错误
// int i = 1/0;
String sql2="update account set money = money + 100 where name = 'B';";
connection.prepareStatement(sql2).executeUpdate();
connection.commit();//以上两条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();
}
}
}
}
（有关项目的没看）
扫一扫
184
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
