JDBC

1，JDBC概述

在开发中我们使用的是java语言，那么势必要通过java语言操作数据库中的数据。这就是接下来要学习的JDBC。

1.1 JDBC概念

JDBC 就是使用Java语言操作关系型数据库的一套API

全称：( Java DataBase Connectivity ) Java 数据库连接

1.2 JDBC本质

• 官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口
• 各个数据库厂商去实现这套接口，提供数据库驱动jar包
• 我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类

1.3 JDBC好处

• 各数据库厂商使用相同的接口，Java代码不需要针对不同数据库分别开发
• 可随时替换底层数据库，访问数据库的Java代码基本不变

以后编写操作数据库的代码只需要面向JDBC（接口），操作哪儿个关系型数据库就需要导入该数据库的驱动包，如需要操作MySQL数据库，就需要再项目中导入MySQL数据库的驱动包。如下图就是MySQL驱动包

2.1 编写代码步骤

• 创建工程，导入驱动jar包

• 注册驱动

  Class.forName("com.mysql.jdbc.Driver");
  

• 获取连接

  Connection conn = DriverManager.getConnection(url, username, password);
  

  Java代码需要发送SQL给MySQL服务端，就需要先建立连接

• 定义SQL语句

  String sql =  “update…” ;
  

• 获取执行SQL对象

  执行SQL语句需要SQL执行对象，而这个执行对象就是Statement对象

  Statement stmt = conn.createStatement();
  

• 执行SQL

  stmt.executeUpdate(sql);
  

• 处理返回结果

• 释放资源

• 在添加为库文件的时候，有如下三个选项

  • Global Library ： 全局有效
  • Project Library : 项目有效
  • Module Library ： 模块有效

• 编写代码如下

/*** JDBC快速入门*/
public class JDBCDemo {public static void main(String[] args) throws Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接String url = "jdbc:mysql://127.0.0.1:3306/db1";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql = "update account set money = 2000 where id = 1";//4. 获取执行sql的对象 StatementStatement stmt = conn.createStatement();//5. 执行sqlint count = stmt.executeUpdate(sql);//受影响的行数//6. 处理结果System.out.println(count);//7. 释放资源stmt.close();conn.close();}
}

3，JDBC API详解

3.1 DriverManager

DriverManager（驱动管理类）作用：

• 注册驱动

  在该类中的静态代码块中已经执行了 DriverManager 对象的 registerDriver() 方法进行驱动的注册了，那么我们只需要加载 Driver 类，该静态代码块就会执行。而 Class.forName("com.mysql.jdbc.Driver"); 就可以加载 Driver 类。

  提示：

  • MySQL 5之后的驱动包，可以省略注册驱动的步骤
  • 自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类

• 获取数据库连接

  参数说明：

  • url ： 连接路径

    语法：jdbc:mysql://ip地址(域名):端口号/数据库名称?参数键值对1&参数键值对2…

    示例：jdbc:mysql://127.0.0.1:3306/db1

    细节：

    • 如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称?参数键值对

    • 配置 useSSL=false 参数，禁用安全连接方式，解决警告提示

  • user ：用户名

  • poassword ：密码

3.2 Connection

Connection（数据库连接对象）作用：

• 获取执行 SQL 的对象
• 管理事务

3.2.1 获取执行对象

• 普通执行SQL对象

  Statement createStatement()
  

  入门案例中就是通过该方法获取的执行对象。

• 预编译SQL的执行SQL对象：防止SQL注入

  PreparedStatement  prepareStatement(sql)
  

  通过这种方式获取的 PreparedStatement SQL语句执行对象是我们一会重点要进行讲解的，它可以防止SQL注入。

• 执行存储过程的对象

  CallableStatement prepareCall(sql)
  

  通过这种方式获取的 CallableStatement 执行对象是用来执行存储过程的，而存储过程在MySQL中不常用，所以这个我们将不进行讲解。

3.2.2 事务管理

先回顾一下MySQL事务管理的操作：

• 开启事务 ： BEGIN; 或者 START TRANSACTION;
• 提交事务 ： COMMIT;
• 回滚事务 ： ROLLBACK;

MySQL默认是自动提交事务

接下来学习JDBC事务管理的方法。

Connection几口中定义了3个对应的方法：

• 开启事务

  参与autoCommit 表示是否自动提交事务，true表示自动提交事务，false表示手动提交事务。而开启事务需要将该参数设为为false。

• 提交事务

• 回滚事务

具体代码实现如下：

/*** JDBC API 详解：Connection*/
public class JDBCDemo3_Connection {public static void main(String[] args) throws Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql1 = "update account set money = 3000 where id = 1";String sql2 = "update account set money = 3000 where id = 2";//4. 获取执行sql的对象 StatementStatement stmt = conn.createStatement();try {// ============开启事务==========conn.setAutoCommit(false);//5. 执行sqlint count1 = stmt.executeUpdate(sql1);//受影响的行数//6. 处理结果System.out.println(count1);int i = 3/0;//5. 执行sqlint count2 = stmt.executeUpdate(sql2);//受影响的行数//6. 处理结果System.out.println(count2);// ============提交事务==========//程序运行到此处，说明没有出现任何问题，则需求提交事务conn.commit();} catch (Exception e) {// ============回滚事务==========//程序在出现异常时会执行到这个地方，此时就需要回滚事务conn.rollback();e.printStackTrace();}//7. 释放资源stmt.close();conn.close();}
}

3.3 Statement

3.3.1 概述

Statement对象的作用就是用来执行SQL语句。而针对不同类型的SQL语句使用的方法也不一样。

• 执行DDL、DML语句

• 执行DQL语句

  该方法涉及到了 ResultSet 对象，而这个对象我们还没有学习，一会再重点讲解。

3.3.2 代码实现

• 执行DML语句

  /*** 执行DML语句* @throws Exception*/
  @Test
  public void testDML() throws  Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql = "update account set money = 3000 where id = 1";//4. 获取执行sql的对象 StatementStatement stmt = conn.createStatement();//5. 执行sqlint count = stmt.executeUpdate(sql);//执行完DML语句，受影响的行数//6. 处理结果//System.out.println(count);if(count > 0){System.out.println("修改成功~");}else{System.out.println("修改失败~");}//7. 释放资源stmt.close();conn.close();
  }
  

• 执行DDL语句

  /*** 执行DDL语句* @throws Exception*/
  @Test
  public void testDDL() throws  Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql = "drop database db2";//4. 获取执行sql的对象 StatementStatement stmt = conn.createStatement();//5. 执行sqlint count = stmt.executeUpdate(sql);//执行完DDL语句，可能是0//6. 处理结果System.out.println(count);//7. 释放资源stmt.close();conn.close();
  }
  

  注意：

  • 以后开发很少使用java代码操作DDL语句

3.4 ResultSet

3.4.1 概述

ResultSet（结果集对象）作用：

• 封装了SQL查询语句的结果。

而执行了DQL语句后就会返回该对象，对应执行DQL语句的方法如下：

ResultSet  executeQuery(sql)：执行DQL 语句，返回 ResultSet 对象

那么我们就需要从 ResultSet 对象中获取我们想要的数据。ResultSet 对象提供了操作查询结果数据的方法，如下：

boolean next()

• 将光标从当前位置向前移动一行
• 判断当前行是否为有效行

方法返回值说明：

• true ： 有效航，当前行有数据
• false ： 无效行，当前行没有数据

xxx getXxx(参数)：获取数据

• xxx : 数据类型；如： int getInt(参数) ；String getString(参数)
• 参数
  • int类型的参数：列的编号，从1开始
  • String类型的参数： 列的名称

如下图为执行SQL语句后的结果

一开始光标指定于第一行前，如图所示红色箭头指向于表头行。当我们调用了 next() 方法后，光标就下移到第一行数据，并且方法返回true，此时就可以通过 getInt("id") 获取当前行id字段的值，也可以通过 getString("name") 获取当前行name字段的值。如果想获取下一行的数据，继续调用 next() 方法，以此类推。

3.4.2 代码实现

/*** 执行DQL* @throws Exception*/
@Test
public void testResultSet() throws  Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql = "select * from account";//4. 获取statement对象Statement stmt = conn.createStatement();//5. 执行sqlResultSet rs = stmt.executeQuery(sql);//6. 处理结果， 遍历rs中的所有数据/* // 6.1 光标向下移动一行，并且判断当前行是否有数据while (rs.next()){//6.2 获取数据  getXxx()int id = rs.getInt(1);String name = rs.getString(2);double money = rs.getDouble(3);System.out.println(id);System.out.println(name);System.out.println(money);System.out.println("--------------");}*/// 6.1 光标向下移动一行，并且判断当前行是否有数据while (rs.next()){//6.2 获取数据  getXxx()int id = rs.getInt("id");String name = rs.getString("name");double money = rs.getDouble("money");System.out.println(id);System.out.println(name);System.out.println(money);System.out.println("--------------");}//7. 释放资源rs.close();stmt.close();conn.close();
}

3.5 案例

• 需求：查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中

• 代码实现

  /*** 查询account账户表数据，封装为Account对象中，并且存储到ArrayList集合中* 1. 定义实体类Account* 2. 查询数据，封装到Account对象中* 3. 将Account对象存入ArrayList集合中*/
  @Test
  public void testResultSet2() throws  Exception {//1. 注册驱动//Class.forName("com.mysql.jdbc.Driver");//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);//3. 定义sqlString sql = "select * from account";//4. 获取statement对象Statement stmt = conn.createStatement();//5. 执行sqlResultSet rs = stmt.executeQuery(sql);// 创建集合List<Account> list = new ArrayList<>();// 6.1 光标向下移动一行，并且判断当前行是否有数据while (rs.next()){Account account = new Account();//6.2 获取数据  getXxx()int id = rs.getInt("id");String name = rs.getString("name");double money = rs.getDouble("money");//赋值account.setId(id);account.setName(name);account.setMoney(money);// 存入集合list.add(account);}System.out.println(list);//7. 释放资源rs.close();stmt.close();conn.close();
  }
  

3.6 PreparedStatement

PreparedStatement作用：

• 预编译SQL语句并执行：预防SQL注入问题

对上面的作用中SQL注入问题大家肯定不理解。那我们先对SQL注入进行说明.

3.6.1 SQL注入

SQL注入是通过操作输入来修改事先定义好的SQL语句，用以达到执行代码对服务器进行攻击的方法。

文件中的用户名和密码，文件内容如下：

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=1234

在MySQL中创建名为 test 的数据库

create database test;

3.6.2 代码模拟SQL注入问题

@Test
public void testLogin() throws  Exception {//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);// 接收用户输入 用户名和密码String name = "sjdljfld";String pwd = "' or '1' = '1";String sql = "select * from tb_user where username = '"+name+"' and password = '"+pwd+"'";// 获取stmt对象Statement stmt = conn.createStatement();// 执行sqlResultSet rs = stmt.executeQuery(sql);// 判断登录是否成功if(rs.next()){System.out.println("登录成功~");}else{System.out.println("登录失败~");}//7. 释放资源rs.close();stmt.close();conn.close();
}

上面代码是将用户名和密码拼接到sql语句中，拼接后的sql语句如下

select * from tb_user where username = 'sjdljfld' and password = ''or '1' = '1'

从上面语句可以看出条件 username = 'sjdljfld' and password = '' 不管是否满足，而 or 后面的 '1' = '1' 是始终满足的，最终条件是成立的，就可以正常的进行登陆了。

接下来我们来学习PreparedStatement对象.

3.6.3 PreparedStatement概述

PreparedStatement作用：

• 预编译SQL语句并执行：预防SQL注入问题

• 获取 PreparedStatement 对象

  // SQL语句中的参数值，使用？占位符替代
  String sql = "select * from user where username = ? and password = ?";
  // 通过Connection对象获取，并传入对应的sql语句
  PreparedStatement pstmt = conn.prepareStatement(sql);
  

• 设置参数值

  上面的sql语句中参数使用 ? 进行占位，在之前之前肯定要设置这些 ? 的值。

  PreparedStatement对象：setXxx(参数1，参数2)：给 ? 赋值

  • Xxx：数据类型 ； 如 setInt (参数1，参数2)

  • 参数：

    • 参数1： ？的位置编号，从1 开始

    • 参数2： ？的值

• 执行SQL语句

  executeUpdate(); 执行DDL语句和DML语句

  executeQuery(); 执行DQL语句

  注意：

  • 调用这两个方法时不需要传递SQL语句，因为获取SQL语句执行对象时已经对SQL语句进行预编译了。

3.6.4 使用PreparedStatement改进

 @Test
public void testPreparedStatement() throws  Exception {//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写String url = "jdbc:mysql:///db1?useSSL=false";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);// 接收用户输入 用户名和密码String name = "zhangsan";String pwd = "' or '1' = '1";// 定义sqlString sql = "select * from tb_user where username = ? and password = ?";// 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);// 设置？的值pstmt.setString(1,name);pstmt.setString(2,pwd);// 执行sqlResultSet rs = pstmt.executeQuery();// 判断登录是否成功if(rs.next()){System.out.println("登录成功~");}else{System.out.println("登录失败~");}//7. 释放资源rs.close();pstmt.close();conn.close();
}

执行上面语句就可以发现不会出现SQL注入漏洞问题了。那么PreparedStatement又是如何解决的呢？它是将特殊字符进行了转义，转义的SQL如下：

select * from tb_user where username = 'sjdljfld' and password = '\'or \'1\' = \'1'

3.6.5 PreparedStatement原理

PreparedStatement 好处：

• 预编译SQL，性能更高
• 防止SQL注入：将敏感字符进行转义

Java代码操作数据库流程如图所示：

• 将sql语句发送到MySQL服务器端

• MySQL服务端会对sql语句进行如下操作

  • 检查SQL语句

    检查SQL语句的语法是否正确。

  • 编译SQL语句。将SQL语句编译成可执行的函数。

    检查SQL和编译SQL花费的时间比执行SQL的时间还要长。如果我们只是重新设置参数，那么检查SQL语句和编译SQL语句将不需要重复执行。这样就提高了性能。

  • 执行SQL语句

接下来我们通过查询日志来看一下原理。

• 开启预编译功能

  在代码中编写url时需要加上以下参数。而我们之前根本就没有开启预编译功能，只是解决了SQL注入漏洞。

  useServerPrepStmts=true
  

• 配置MySQL执行日志（重启mysql服务后生效）

  在mysql配置文件（my.ini）中添加如下配置

  log-output=FILE
  general-log=1
  general_log_file="D:\mysql.log"
  slow-query-log=1
  slow_query_log_file="D:\mysql_slow.log"
  long_query_time=2
  

• java测试代码如下：

   /*** PreparedStatement原理* @throws Exception*/
  @Test
  public void testPreparedStatement2() throws  Exception {//2. 获取连接：如果连接的是本机mysql并且端口是默认的 3306 可以简化书写// useServerPrepStmts=true 参数开启预编译功能String url = "jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true";String username = "root";String password = "1234";Connection conn = DriverManager.getConnection(url, username, password);// 接收用户输入 用户名和密码String name = "zhangsan";String pwd = "' or '1' = '1";// 定义sqlString sql = "select * from tb_user where username = ? and password = ?";// 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);Thread.sleep(10000);// 设置？的值pstmt.setString(1,name);pstmt.setString(2,pwd);ResultSet rs = null;// 执行sqlrs = pstmt.executeQuery();// 设置？的值pstmt.setString(1,"aaa");pstmt.setString(2,"bbb");// 执行sqlrs = pstmt.executeQuery();// 判断登录是否成功if(rs.next()){System.out.println("登录成功~");}else{System.out.println("登录失败~");}//7. 释放资源rs.close();pstmt.close();conn.close();
  }
  

• 执行SQL语句

4，数据库连接池

4.2 数据库连接池实现

• 标准接口：DataSource

  官方(SUN) 提供的数据库连接池标准接口，由第三方组织实现此接口。该接口提供了获取连接的功能：

  Connection getConnection()
  

  那么以后就不需要通过 DriverManager 对象获取 Connection 对象，而是通过连接池（DataSource）获取 Connection 对象。

• 常见的数据库连接池

  • DBCP
  • C3P0
  • Druid

  我们现在使用更多的是Druid，它的性能比其他两个会好一些。

• Druid（德鲁伊）

  • Druid连接池是阿里巴巴开源的数据库连接池项目

  • 功能强大，性能优秀，是Java语言最好的数据库连接池之一

4.3 Driud使用

• 导入jar包 druid-1.1.12.jar
• 定义配置文件
• 加载配置文件
• 获取数据库连接池对象
• 获取连接

现在通过代码实现，首先需要先将druid的jar包放到项目下的lib下并添加为库文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db1?useSSL=false&useServerPrepStmts=true
username=root
password=1234
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

使用druid的代码如下：

/*** Druid数据库连接池演示*/
public class DruidDemo {public static void main(String[] args) throws Exception {//1.导入jar包//2.定义配置文件//3. 加载配置文件Properties prop = new Properties();prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));//4. 获取连接池对象DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);//5. 获取数据库连接 ConnectionConnection connection = dataSource.getConnection();System.out.println(connection); //获取到了连接后就可以继续做其他操作了//System.out.println(System.getProperty("user.dir"));}
}

5，JDBC练习

5.1 需求

完成商品品牌数据的增删改查操作

• 查询：查询所有数据
• 添加：添加品牌
• 修改：根据id修改
• 删除：根据id删除

5.2 案例实现

5.2.1 环境准备

• 数据库表 tb_brand

  -- 删除tb_brand表
  drop table if exists tb_brand;
  -- 创建tb_brand表
  create table tb_brand (-- id 主键id int primary key auto_increment,-- 品牌名称brand_name varchar(20),-- 企业名称company_name varchar(20),-- 排序字段ordered int,-- 描述信息description varchar(100),-- 状态：0：禁用  1：启用status int
  );
  -- 添加数据
  insert into tb_brand (brand_name, company_name, ordered, description, status)
  values ('三只松鼠', '三只松鼠股份有限公司', 5, '好吃不上火', 0),('华为', '华为技术有限公司', 100, '华为致力于把数字世界带入每个人、每个家庭、每个组织，构建万物互联的智能世界', 1),('小米', '小米科技有限公司', 50, 'are you ok', 1);
  

• 在pojo包下实体类 Brand

  /*** 品牌* alt + 鼠标左键：整列编辑* 在实体类中，基本数据类型建议使用其对应的包装类型*/
  public class Brand {// id 主键private Integer id;// 品牌名称private String brandName;// 企业名称private String companyName;// 排序字段private Integer ordered;// 描述信息private String description;// 状态：0：禁用  1：启用private Integer status;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getBrandName() {return brandName;}public void setBrandName(String brandName) {this.brandName = brandName;}public String getCompanyName() {return companyName;}public void setCompanyName(String companyName) {this.companyName = companyName;}public Integer getOrdered() {return ordered;}public void setOrdered(Integer ordered) {this.ordered = ordered;}public String getDescription() {return description;}public void setDescription(String description) {this.description = description;}public Integer getStatus() {return status;}public void setStatus(Integer status) {this.status = status;}@Overridepublic String toString() {return "Brand{" +"id=" + id +", brandName='" + brandName + '\'' +", companyName='" + companyName + '\'' +", ordered=" + ordered +", description='" + description + '\'' +", status=" + status +'}';}
  }
  

5.2.2 查询所有

 /*** 查询所有* 1. SQL：select * from tb_brand;* 2. 参数：不需要* 3. 结果：List<Brand>*/@Test
public void testSelectAll() throws Exception {//1. 获取Connection//3. 加载配置文件Properties prop = new Properties();prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));//4. 获取连接池对象DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);//5. 获取数据库连接 ConnectionConnection conn = dataSource.getConnection();//2. 定义SQLString sql = "select * from tb_brand;";//3. 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);//4. 设置参数//5. 执行SQLResultSet rs = pstmt.executeQuery();//6. 处理结果 List<Brand> 封装Brand对象，装载List集合Brand brand = null;List<Brand> brands = new ArrayList<>();while (rs.next()){//获取数据int id = rs.getInt("id");String brandName = rs.getString("brand_name");String companyName = rs.getString("company_name");int ordered = rs.getInt("ordered");String description = rs.getString("description");int status = rs.getInt("status");//封装Brand对象brand = new Brand();brand.setId(id);brand.setBrandName(brandName);brand.setCompanyName(companyName);brand.setOrdered(ordered);brand.setDescription(description);brand.setStatus(status);//装载集合brands.add(brand);}System.out.println(brands);//7. 释放资源rs.close();pstmt.close();conn.close();
}

5.2.3 添加数据

/*** 添加* 1. SQL：insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);* 2. 参数：需要，除了id之外的所有参数信息* 3. 结果：boolean*/
@Test
public void testAdd() throws Exception {// 接收页面提交的参数String brandName = "香飘飘";String companyName = "香飘飘";int ordered = 1;String description = "绕地球一圈";int status = 1;//1. 获取Connection//3. 加载配置文件Properties prop = new Properties();prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));//4. 获取连接池对象DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);//5. 获取数据库连接 ConnectionConnection conn = dataSource.getConnection();//2. 定义SQLString sql = "insert into tb_brand(brand_name, company_name, ordered, description, status) values(?,?,?,?,?);";//3. 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);//4. 设置参数pstmt.setString(1,brandName);pstmt.setString(2,companyName);pstmt.setInt(3,ordered);pstmt.setString(4,description);pstmt.setInt(5,status);//5. 执行SQLint count = pstmt.executeUpdate(); // 影响的行数//6. 处理结果System.out.println(count > 0);//7. 释放资源pstmt.close();conn.close();
}

5.2.4 修改数据

/*** 修改* 1. SQL：update tb_brandset brand_name  = ?,company_name= ?,ordered     = ?,description = ?,status      = ?where id = ?* 2. 参数：需要，所有数据* 3. 结果：boolean*/@Test
public void testUpdate() throws Exception {// 接收页面提交的参数String brandName = "香飘飘";String companyName = "香飘飘";int ordered = 1000;String description = "绕地球三圈";int status = 1;int id = 4;//1. 获取Connection//3. 加载配置文件Properties prop = new Properties();prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));//4. 获取连接池对象DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);//5. 获取数据库连接 ConnectionConnection conn = dataSource.getConnection();//2. 定义SQLString sql = " update tb_brand\n" +"         set brand_name  = ?,\n" +"         company_name= ?,\n" +"         ordered     = ?,\n" +"         description = ?,\n" +"         status      = ?\n" +"     where id = ?";//3. 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);//4. 设置参数pstmt.setString(1,brandName);pstmt.setString(2,companyName);pstmt.setInt(3,ordered);pstmt.setString(4,description);pstmt.setInt(5,status);pstmt.setInt(6,id);//5. 执行SQLint count = pstmt.executeUpdate(); // 影响的行数//6. 处理结果System.out.println(count > 0);//7. 释放资源pstmt.close();conn.close();
}

5.2.5 删除数据

/*** 删除* 1. SQL：delete from tb_brand where id = ?* 2. 参数：需要，id* 3. 结果：boolean*/
@Test
public void testDeleteById() throws Exception {// 接收页面提交的参数int id = 4;//1. 获取Connection//3. 加载配置文件Properties prop = new Properties();prop.load(new FileInputStream("jdbc-demo/src/druid.properties"));//4. 获取连接池对象DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);//5. 获取数据库连接 ConnectionConnection conn = dataSource.getConnection();//2. 定义SQLString sql = " delete from tb_brand where id = ?";//3. 获取pstmt对象PreparedStatement pstmt = conn.prepareStatement(sql);//4. 设置参数pstmt.setInt(1,id);//5. 执行SQLint count = pstmt.executeUpdate(); // 影响的行数//6. 处理结果System.out.println(count > 0);//7. 释放资源pstmt.close();conn.close();
}

Servlet

访问服务器的某个URL

• 在浏览器的地址栏中输入对应的URL，属于GET提交
• 使用a标签，在href中输入对应的URL，属于GET提交
• 使用form表单，在action中输入对应的URL，通过method修改提交方式为GET或POST

页面向服务端提交数据的方式

• 使用form表单的name属性显示提交

  <form action="http://localhost:8080/day1/hero" method="get"><input type="text" name="username"><input type="submit">
  </form>
  

  提交的数据会暴露在浏览器的地址栏中

• 使用form表单的name属性隐式提交

  <form action="http://localhost:8080/day1/hero" method="post"><input type="text" name="username"><input type="submit">
  </form>
  

  提交的数据不会暴露在浏览器的地址栏中

• 通过"?参数名=值"方式提交

  • 在地址栏中输入URL的时候，末尾加入这部分

    https://www.baidu.com/s?wd=hello
    

  • 在a标签的href属性中加入这部分，如果有多个参数，通过&拼接

    <a href="https://www.baidu.com/s?wd=hello&a=1&b=2">访问</a>
    

服务器端获取页面传递的数据

以上任何方式提交到服务器的数据，都可以使用以下方式获取。

String str=request.getParameter("name名或?后的参数名");

class TestServlet extends HttpServlet{doGet(HttpServletRequest req,HttpServletResponse resp){//获取表单提交的数据req.getParameter("表单中某个表单元素的name值");String username = req.getParameter("username");}doPost(HttpServletRequest req,HttpServletResponse resp){doGet();}
}

表单提交数据注意事项

• 表单通过action提交设置的路径，如果要在路径中传递参数，只能使用post方式提交

  <form action="xxxxx?参数=值" method="post"></form>
  

• 使用get方式提交，无法识别action路径中的参数，如果要传递参数，使用隐藏域

  <form action="xxxxx" method="get"><input type="hidden" name="参数名" value="参数值">
  </form>
  

解决请求和响应的中文乱码

//在servlet的doGet或doPost所有代码之前中加入
req.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");

使用Servlet实现单表的增删改查

数据库脚本文件

/*Navicat Premium Data TransferSource Server         : localhost_3306Source Server Type    : MySQLSource Server Version : 80029Source Host           : localhost:3306Source Schema         : gamedbTarget Server Type    : MySQLTarget Server Version : 80029File Encoding         : 65001Date: 03/01/2023 14:46:16
*/SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;-- ----------------------------
-- Table structure for hero
-- ----------------------------
DROP TABLE IF EXISTS `hero`;
CREATE TABLE `hero`  (`id` int NOT NULL AUTO_INCREMENT COMMENT '编号',`name` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '姓名',`position` varchar(20) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '定位',`sex` char(1) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL DEFAULT '男' COMMENT '性别',`price` int NOT NULL DEFAULT 4800 COMMENT '价格',`shelf_date` date NULL DEFAULT NULL COMMENT '上架日期',PRIMARY KEY (`id`) USING BTREE,UNIQUE INDEX `name`(`name`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 16 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;SET FOREIGN_KEY_CHECKS = 1;

实体类entity

实体的属性名保持和表的字段名一致，使用驼峰命名法

package com.hqyj.entity;public class Hero {private int id;private String name;private String position;private String sex;private int price;private String shelfDate;/*全参构造方法用于查询*/public Hero(int id, String name, String position, String sex, int price, String shelfDate) {this.id = id;this.name = name;this.position = position;this.sex = sex;this.price = price;this.shelfDate = shelfDate;}/*不带id的构造方法用于添加*/public Hero(String name, String position, String sex, int price, String shelfDate) {this.name = name;this.position = position;this.sex = sex;this.price = price;this.shelfDate = shelfDate;}//省略get/set/toString
}

数据操作类dao

package com.hqyj.dao;import com.hqyj.entity.Hero;
import com.hqyj.util.DBUtil;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;public class HeroDao {Connection conn;PreparedStatement pst;ResultSet rs;/** 查询所有* */public List<Hero> queryAll() {ArrayList<Hero> list = new ArrayList<>();conn = DBUtil.getConn();try {pst = conn.prepareStatement("select * from hero");rs = pst.executeQuery();while (rs.next()) {int id = rs.getInt(1);String name = rs.getString(2);String position = rs.getString(3);String sex = rs.getString(4);int price = rs.getInt(5);String shelfDate = rs.getString(6);Hero hero = new Hero(id, name, position, sex, price, shelfDate);list.add(hero);}} catch (Exception e) {System.out.println("查询所有异常" + e);} finally {DBUtil.release(conn, pst, rs);}return list;}/** 添加* */public boolean addHero(Hero hero) {conn = DBUtil.getConn();String sql = "insert into hero values(null,?,?,?,?,?)";try {pst = conn.prepareStatement(sql);pst.setString(1, hero.getName());pst.setString(2, hero.getPosition());pst.setString(3, hero.getSex());pst.setInt(4, hero.getPrice());pst.setString(5, hero.getShelfDate());return pst.executeUpdate() > 0;} catch (SQLException e) {System.out.println("添加异常" + e);} finally {DBUtil.release(conn, pst, rs);}return false;}/** 删除* */public boolean delete(int id) {conn = DBUtil.getConn();try {pst = conn.prepareStatement("delete from hero where id=?");pst.setInt(1, id);return pst.executeUpdate() > 0;} catch (SQLException e) {System.out.println("删除异常" + e);} finally {DBUtil.release(conn, pst, rs);}return false;}/** 根据id查询* */public Hero findById(int id) {conn = DBUtil.getConn();try {pst = conn.prepareStatement("select * from hero where id=?");pst.setInt(1, id);rs = pst.executeQuery();if (rs.next()) {String name = rs.getString(2);String position = rs.getString(3);String sex = rs.getString(4);int price = rs.getInt(5);String shelfDate = rs.getString(6);Hero hero = new Hero(id, name, position, sex, price, shelfDate);return hero;}} catch (Exception e) {System.out.println("根据id查询异常" + e);} finally {DBUtil.release(conn, pst, rs);}return null;}/** 修改* */public boolean update(Hero updateHero) {conn = DBUtil.getConn();try {pst = conn.prepareStatement("update hero set name=?,position=?,sex=?,price=?,shelf_date=? where id=?");pst.setString(1, updateHero.getName());pst.setString(2, updateHero.getPosition());pst.setString(3, updateHero.getSex());pst.setInt(4, updateHero.getPrice());pst.setString(5, updateHero.getShelfDate());pst.setInt(6, updateHero.getId());return pst.executeUpdate() > 0;} catch (SQLException e) {System.out.println("修改异常" + e);} finally {DBUtil.release(conn, pst, rs);}return false;}
}

控制层/表现层servlet

package com.hqyj.servlet;import com.hqyj.dao.HeroDao;
import com.hqyj.entity.Hero;import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;public class HeroServlet extends HttpServlet {//当前Servlet中需要访问Hero表中的数据，所以加入HeroDao对象HeroDao heroDao = new HeroDao();@Overrideprotected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {doPost(req, resp);}@Overrideprotected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {//解决请求和响应的中文乱码req.setCharacterEncoding("utf-8");resp.setContentType("text/html;charset=utf-8");//获取op,用一个Servlet，判断不同的op值来执行不同的操作String op = req.getParameter("op");switch (op) {case "queryAll"://调用查询List<Hero> list = heroDao.queryAll();//通过resp响应对象调用getWriter()方法，获取字符输出流对象writer，通过writer打印页面PrintWriter writer = resp.getWriter();writer.println("<html>");writer.println("<body>");writer.println("<table border='1'>");writer.println("<tr><td>编号</td><td>姓名</td><td>定位</td><td>性别</td><td>价格</td><td>上架时间</td><td colspan=2>操作</td></tr>");for (Hero hero : list) {writer.println("<tr>");writer.println("<td>" + hero.getId() + "</td>");writer.println("<td>" + hero.getName() + "</td>");writer.println("<td>" + hero.getPosition() + "</td>");writer.println("<td>" + hero.getSex() + "</td>");writer.println("<td>" + hero.getPrice() + "</td>");writer.println("<td>" + hero.getShelfDate() + "</td>");//修改的步骤：1.根据id查询,打印详情页   2.在详情页中修改writer.println("<td><a href='http://localhost:8080/day1/hero?op=findById&id=" + hero.getId() + "'>修改</a></td>");//访问某个URL时传递多个参数：  URL?参数1=值&参数2=值..writer.println("<td><a href='http://localhost:8080/day1/hero?op=delete&id=" + hero.getId() + "'>删除</a></td>");writer.println("</tr>");}writer.println("</table>");writer.println("</body>");writer.println("</html>");writer.close();break;case "delete":int id = Integer.parseInt(req.getParameter("id"));if (heroDao.delete(id)) {//跳转到查询所有resp.sendRedirect("http://localhost:8080/day1/hero?op=queryAll");}break;case "findById"://获取要修改的idint findId = Integer.parseInt(req.getParameter("id"));//调用查询Hero byId = heroDao.findById(findId);//打印详情页PrintWriter pw = resp.getWriter();pw.println("<html>");pw.println("<body>");//如果表单要在action中传递数据，只能使用post方式提交//pw.println("<form action='http://localhost:8080/day1/hero?op=update' method='post'> ");//如果表单使用get方式提交，通过隐藏域提交oppw.println("<form action='http://localhost:8080/day1/hero'> ");pw.println("<input type='hidden' name='op' value='update' >");//使用隐藏域提交idpw.println("<input type='hidden' name='id' value='" + byId.getId() + "' >");pw.println("姓名：<input type='text' name='name' value='" + byId.getName() + "'><br>");pw.println("定位：<input type='text' name='position' value='" + byId.getPosition() + "'><br>");/*if("男".equals(byId.getSex())){pw.println("<input type='radio' checked>男");pw.println("<input type='radio' >女");}else{pw.println("<input type='radio' >男");pw.println("<input type='radio' checked>女");}*/pw.println("性别：<input type='radio' name='sex' value='男' " + ("男".equals(byId.getSex()) ? "checked" : "") + ">男");pw.println("<input type='radio' name='sex' value='女' " + ("女".equals(byId.getSex()) ? "checked" : "") + ">女<br>");pw.println("价格：<input type='num' name='price' value='" + byId.getPrice() + "'><br>");pw.println("上架时间：<input type='date' name='shelfDate' value='" + byId.getShelfDate() + "'><br>");pw.println("<input type='submit' value='修改'><br>");pw.println("</form>");pw.println("</body>");pw.println("</html>");break;case "update"://获取参数int updateId = Integer.parseInt(req.getParameter("id"));String updateName = req.getParameter("name");String updateSex = req.getParameter("sex");String updatePosition = req.getParameter("position");int updatePrice = Integer.parseInt(req.getParameter("price"));String updateShelfDate = req.getParameter("shelfDate");//创建待修改的对象，调用修改，跳转到查询所有页面Hero updateHero = new Hero(updateId, updateName, updatePosition, updateSex, updatePrice, updateShelfDate);heroDao.update(updateHero);//跳转到查询所有resp.sendRedirect("http://localhost:8080/day1/hero?op=queryAll");break;case "addHero"://获取页面提交的数据//request.getParameter("name名")String name=req.getParameter("name");String position=req.getParameter("position");String sex=req.getParameter("sex");int price=Integer.parseInt(req.getParameter("price"));String shelfDate=req.getParameter("shelfDate");//创建添加对象，调用添加方法Hero hero = new Hero(name, position, sex, price, shelfDate);if (heroDao.addHero(hero)) {resp.sendRedirect("http://localhost:8080/day1/hero?op=queryAll");}break;}}
}

配置Servlet

<?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><servlet-name>hero</servlet-name><servlet-class>com.hqyj.servlet.HeroServlet</servlet-class></servlet><servlet-mapping><servlet-name>hero</servlet-name><url-pattern>/hero</url-pattern></servlet-mapping></web-app>

添加页面

<!DOCTYPE html>
<html lang="en">
<head><meta charset="UTF-8"><title>Title</title>
</head>
<body><form action="http://localhost:8080/day1/hero"><!--通过隐藏域提交op--><input type="hidden" name="op" value="addHero">角色名：<input type="text" name="name" required><br>定位：<input type="text" name="position" required><br>性别：<input type="radio" name="sex" value="男" checked>男<input type="radio" name="sex" value="女">女<br>价格：<input type="number" min="1" name="price" required><br>上架日期：<input type="date" name="shelfDate" required><br><input type="submit" value="添加">
</form></body>
</html>

主页

<!DOCTYPE html>
<html lang="en"><head><meta charset="UTF-8"><title>Title</title></head><body><a href="http://localhost:8080/day1/hero?op=queryAll">查看所有hero</a><a href="http://localhost:8080/day1/pages/addHero.html">添加</a></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"><!--设置项目启动的欢迎页--><welcome-file-list><welcome-file>login.html</welcome-file></welcome-file-list><!--设置错误页面--><error-page><!--错误码--><error-code>404</error-code><!--页面路径--><location>/404.html</location></error-page><error-page><!--异常类型--><exception-type>java.lang.NullPointerException</exception-type><location>/error.html</location></error-page><!--上下文参数--><context-param><!--参数名--><param-name>contentParam</param-name><!--参数值--><param-value>全局参数</param-value></context-param><!--servlet标签--><!--servlet-mapping标签--><!--filter标签--><!--filter-mapping标签--><!--session-config标签--></web-app>

Servlet的生命周期

构造方法**–>init()–>service()/doGet()/doPost()–>**destory()

在访问某servlet时

1.执行构造方法一次

2.初始化一次，调用init()方法

3.调用service()方法，之后每次访问都会调用该方法。有该方法时，doGet和doPost失效。

如果没有该方法，会根据请求方式试图调用doGet或doPost，如果没有相应的方法，会出现405状态码，表示请求方式不允许

4.在当前servlet所在项目从tomcat中停止时，销毁一次，调用destory()方法

使用注解开发Servlet

/** 使用注解开发Servlet* 注解：@特定单词  如@Override** 定义且配置Servlet的注解:@WebServlet("/请求映射")* */
@WebServlet("/sysAdmin")
public class SysAdminServlet extends HttpServlet {@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp)  {//访问该Servlet时要执行的内容}
}
//@WebServlet("/sysAdmin")相当于在web.xml中进行配置servlet映射

绝对路径

<a href="localhost:8080/system/pages/hello.html">跳转</a>

相对路径问题

• /

  表示从根目录(域名+ip)出发

• ./

  表示从当前位置出发

• …/

  表示跳向上一层

如有index页面所在路径为
localhost:8080/system/pages/index.html<a href="/hello.html">跳转</a>
这种方式，从根目录(localhost:8080)出发，会跳转到localhost:8080/hello.html<a href="./hello.html">跳转</a>
这种方式，从当前位置(localhost:8080/system/pages)出发，会跳转到localhost:8080/system/pages/hello.html<a href="../hello.html">跳转</a>
这种方式，从当前位置跳向上一层，会跳转到localhost:8080/system/hello.html

• 在jsp页面中，可以使用**${pageContex.request.contextPath}**表示页面上下文路径。

如项目默认上下文访问路径为localhost:8080/system

<a href="${pageContex.request.contextPath}/pages/hello.html">跳转</a>

以上路径相当于/system/pages/hello.html，即从根目录出发localhost:8080/system/pages/hello.html

如果在jsp页面中无法识别${}，在<%@ page%>中加入isELIgnored=“false”

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

四大作用域对象

作用域：共享数据的区域

pageContext

当前页面对象。共享数据区域范围为当前页面。

如果不在同一个页面，数据无法读取。

request

请求对象。共享数据区域范围为一次请求。

如果跳转中途使用了重定向，数据无法读取。

session

会话对象。会话是用户访问服务器时的某个时间段。

共享数据区域范围在这个时间段内，默认30分钟。

如果在指定时间内没有操作或销毁会话时，数据无法读取。

application

项目对象。共享数据区域范围为整个项目。

作用域范围

application > session > request > pageContext

以上四个作用域对象，都有这几个方法

//将某个对象obj保存到作用域中，命名为str
作用域对象.setAttribute(String str,Object obj);
//从某个作用域中获取保存的某个对象
Object obj = 作用域对象.getAttribute(String str);
//从某个作用域中移除某个保存的对象
作用域对象.removeAttribute(String str);

作用域对象的使用

在JSP页面中

作用域对象也称为内置对象，直接通过对应的单词使用

p1.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><title>Title</title>
</head>
<body>
<%//在jsp中使用pageContext页面上下文对象，跳转到p2时不能使用pageContext.setAttribute("str","保存在pageContext作用域中的字符串");//在jsp中使用request请求对象，请求转发到p2时可以使用，重定向到p2时不能使用request.setAttribute("str","保存在request中的字符串");//在jsp中使用session会话对象，在默认的30分钟内，没有销毁，哪种跳转都能在p2中使用session.setAttribute("str","保存在session中的字符串");//在jsp中使用application应用程序对象，整个项目中任何页面都能使用application.setAttribute("str","保存在application中的字符串");//以上四个作用域对象，也是jsp中的内置对象，无需定义//销毁会话//session.invalidate();//使用请求转发跳转到p2.jsp//request.getRequestDispatcher("p2.jsp").forward(request,response);//使用重定向跳转到p2.jspresponse.sendRedirect("p2.jsp");
%>
<h1><%=pageContext.getAttribute("str")%></h1></body>
</html>

p2.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html><head><title>Title</title></head><body><h3><%=pageContext.getAttribute("str")%></h3><h3><%=request.getAttribute("str")%></h3><h3><%=session.getAttribute("str")%></h3><h3><%=application.getAttribute("str")%></h3></body>
</html>

在servlet中使用

• pageContext

  servlet本身就是一个java类，在类中定义成员变量，就能在当前类中使用。

  所以在servlet中不会使用pageContext对象

• request

  使用doGet/doPost/service方法中的HttpServletRequest参数req

• session

  //在servlet中使用session，需要通过请求对象request调用getSession()方法
  HttpSession session= req.getSession();
  

• application

  //通过getServletContext()方法获取的ServletContext类型对象，就是当前项目对象
  ServletContext application = getServletContext();
  

总结

• 在jsp页面中使用pageContext保存的数据，只能共享于当前页面
• 通常在servlet中查询后的数据保存在request中，使用请求转发跳转到其他页面，在对应的页面中数据数据
• 通常在登录后，将登录的用户保存在session中，无论用哪种方式跳转，都能从session中获取当时登录的用户。
• 在application中保存一些共享于整个项目中的数据

购物车

添加商品时，如果不存在，直接添加，如果存在，修改数量。

采用HashMap作为核心容器。将商品作为键，将购买数量作为值。

使用Hash相关集合，需要重写实体类中的hashcode和equals方法。

实现过程

1.BookInfo和BookType类重写equals和hashcode方法，选择所有属性

2.创建购物车类Cart类

package com.hqyj.bookShop.util;import com.hqyj.bookShop.entity.BookInfo;import java.util.HashMap;/** 购物车* 使用HashMap作为购物车容器* 添加商品方法* 移除商品方法* 查看购物车* 清空购物车** */
public class Cart {/** 商品作为键，购买数量作为值* */private HashMap<BookInfo, Integer> hm;/** 创建购物车对象时，初始化HashMap* */public Cart() {hm = new HashMap<>();}/** 添加到购物车* */public void addToCart(BookInfo bi, int buyNum) {//判断键是否存在if (hm.containsKey(bi)) {//如果存在，修改数量//获取现有数量Integer oldNum = hm.get(bi);//覆盖原本的值hm.put(bi,oldNum+buyNum);}else{//如果不存在，直接添加hm.put(bi,buyNum);}}/** 获取购物车* */public HashMap<BookInfo, Integer> getCart() {return hm;}/*移除商品*//*清空购物车*/
}

3.在登录成功后，创建购物车Cart对象，将其保存到session中

case "login"://获取登录信息String phone = req.getParameter("phone");String password = req.getParameter("password");//调用登录Customer login = dao.login(phone, password);if (login != null) {//登录成功后，创建购物车对象Cart cart = new Cart();//将购物车保存到session中session.setAttribute("cart",cart);//将登录成功的对象，保存到session中session.setAttribute("customer", login);//使用重定向跳转到查询所有图书的servletresp.sendRedirect("./bookInfo?op=search");} else {System.out.println("登录失败");}
break;

4.在图书详情页中，创建添加商品到购物车的表单

<%--提交到图书servlet--%>
<form action="./bookInfo"><%--op、图书编号、购买数量--%><input type="hidden" name="op" value="addToCart"><input type="hidden" name="id" value="<%=bi.getBookId()%>"><input type="number" name="buyNum" value="1" min="1" max="<%=bi.getBookNum()%>" ><br><input type="submit" value="添加到购物车">
</form>

5.在图书servlet中添加新op判断，获取要购买的数据

case "addToCart":
//图书编号
String buyId = req.getParameter("id");
//调用查询
BookInfo byId = biDao.findById(Integer.parseInt(buyId));
//获取购买数量
int buyNum = Integer.parseInt(req.getParameter("buyNum"));
//从session中获取购物车
Cart cart = (Cart) req.getSession().getAttribute("cart");
//调用添加
cart.addToCart(byId, buyNum);
//跳转购物车页面
resp.sendRedirect("./pages/cart.jsp");
break;

6.购物车页面

<%@ page import="com.hqyj.bookShop.util.Cart" %>
<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html><head><style>* {margin: 0;padding: 0;}body {background-color: #f5f5f5;}.wrap {width: 900px;height: 660px;margin: 100px auto;background-color: #fff;}a {text-decoration: none;color: deepskyblue;}.wrap table {width: 100%;border: 1px solid skyblue;border-collapse: collapse;}.wrap table th, td {width: 120px;height: 20px;border: 1px solid skyblue;}</style></head><body><%--防止在未登录的情况下访问该页面--%><%--如果登录成功，session中保存登录的对象customer，如果没有登录或者退出，customer对象就会消失。所以判断customer对象是否存在，决定是否显示该页面--%><%//如果从session中无法获取customer对象，跳转到登录页面if (session.getAttribute("customer") == null) {response.sendRedirect("login.html");return;}//获取session中的购物车对象Cart cart = (Cart) session.getAttribute("cart");%><jsp:include page="top.jsp"></jsp:include><div class="wrap"><table><tr><th>图书编号</th><th>图书名称</th><th>图书作者</th><th>图书单价</th><th>购买数量</th><th>小计</th></tr><%double sumPrice = 0;for (BookInfo bookInfo : cart.getCart().keySet()) {sumPrice += cart.getCart().get(bookInfo) * bookInfo.getBookPrice();%><tr><td><%=bookInfo.getBookId()%></td><td><%=bookInfo.getBookName()%></td><td><%=bookInfo.getBookAuthor()%></td><td><%=bookInfo.getBookPrice()%></td><td><%=cart.getCart().get(bookInfo)%></td><td><%=cart.getCart().get(bookInfo) * bookInfo.getBookPrice()%></td></tr><%}%><tr><td colspan="5">总计</td><td><%=sumPrice%></td></tr></table></div></body>
</html>

JSP

Java Server Page

使用Java开发、运行在服务器上的页面。

jsp文件的后缀名为".jsp"。

由于最初由servlet渲染页面，在Java代码中加入大量html的内容，使用极不方便。所以Sun公司推出了JSP，可以在页面中加入java代码，让页面成为动态页面。

JSP页面的本质是一个java文件(servlet)。

在访问某个jsp页面时，会让该页面重新编译为.java文件–>.class文件，所以第一次访问某个JSP页面时会慢一些。

JSP的组成

1.HTML元素

2.脚本(java代码)

<%java代码;%>

3.表达式

用于在页面中嵌入变量的值

<%=变量%>

4.指令

<%@ 指令名 属性="值" %>

page指令 用于设置当前页面的属性

include指令 用于引入其他页面

taglib指令 用于引入其他标签库

5.注释

<%-- jsp注释 --%>

在浏览器中可以查看html的注释，无法查看jsp的注释

6.声明

<%!  定义方法  %>

在<%%>中无法定义方法，如果非要在jsp页面中定义方法，需要使用声明。不建议在jsp页面中定义方法。

7.动作

jsp中定义了一些标签，可以代替某些java代码

<jsp:动作名></jsp:动作名>

跳转

页面与页面之间跳转

<a href="另一个页面的地址">超链接</a><form action="另一个页面的地址"><input type="submit">
</form><button id="btn">跳转</button>
<script>$("#btn").click(function(){location.href="另一个页面的地址";location.assign("另一个页面的地址");});
</script>

页面跳转至Servlet

<a href="servlet映射名">超链接</a><form action="servlet映射名"><input type="submit">
</form>

Servlet跳转到页面或另一个Servlet

请求转发(内部跳转)

request.getRequestDispatcher("跳转的地址").forward(request,response);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BTb9F9HR-1673432610013)(D:\JavaWeb\JavaWebDay3.assets\image-20230104143342895.png)]

如A同学问B同学问题，B同学自己去问C同学后得到了答案，将答案告诉给A同学。

• 跳转到目的地时，浏览器的地址栏中的内容是访问时的地址

• 如果在某个Servlet做完增删改的操作后，不要使用请求转发。因为当重新刷新页面时，会重复提交

• 如果在request中保存了数据，只能通过请求转发才能读取request中保存的数据

重定向(外部跳转)

response.sendRedirect("跳转的地址");

如A同学问B同学问题，B同学告诉A同学去问C同学，A同学重新问C同学后得到答案。

• 跳转到目的地时，浏览器的地址栏中的内容是最终的目的路径
• 在做完增删改的操作后，使用重定向，可以保证最终页面与之前页面无关，刷新时不会重新提交
• 如果在request中保存了数据，使用重定向，保存的数据就会丢失

跳转时传递数据

保存

作用域对象.setAttribute(String str,Object obj);
//将一个名为str的对象obj保存到某个作用域中。request就是一个作用域。List<泛型> 集合 = dao.查询();
//将查询到的集合保存到请求中，命名为list
request.setAttribute("list",集合);

获取

Object obj = 作用域对象.getAttribute(String str);
//获取到的数据是Object类型，通常需要转型List<泛型> list =(List<泛型>) request.getAttribute("list");

带有外键字段的实体类设计

图书类型book_type表(主表)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pM0DakHo-1673432610014)(D:\JavaWeb\JavaWebDay3.assets\image-20230104173450135.png)]

图书详情book_info表(从表)

1.创建主表的实体类

BookType类

package com.hqyj.bookShop.entity;
/*
* 创建主表对应的实体类
* */
public class BookType {private int typeId;private String typeName;//省略get/set/构造方法/toString
}

2.创建从表的实体类

BookInfo类

遇到外键字段，额外添加一个外键对应的主表实体对象属性

package com.hqyj.bookShop.entity;/** 创建带有外键字段的表(从表)对应的实体类* 1.写出所有字段对应的属性* 2.写出外键对应的主表实体对象* */
public class BookInfo {private int bookId;private int typeId;private String bookName;private String bookAuthor;private int bookPrice;private int bookNum;private String publisherDate;//额外添加属性：外键对应的主表实体对象private BookType bookType;/** 用于查询的构造方法* */public BookInfo(int bookId, int typeId, String bookName, String bookAuthor, int bookPrice, int bookNum, String publisherDate, BookType bookType) {this.bookId = bookId;this.typeId = typeId;this.bookName = bookName;this.bookAuthor = bookAuthor;this.bookPrice = bookPrice;this.bookNum = bookNum;this.publisherDate = publisherDate;this.bookType = bookType;}//省略get/set/toString}

3.创建两个实体类的数据访问层对象

BookTypeDao类

package com.hqyj.bookShop.dao;import com.hqyj.bookShop.entity.BookType;
import com.hqyj.bookShop.util.DBUtil;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;public class BookTypeDao {Connection conn;PreparedStatement pst;ResultSet rs;/** 根据类型编号查询类型对象* */public BookType findById(int id) {conn = DBUtil.getConn();try {pst = conn.prepareStatement("select * from book_type where type_id=?");pst.setInt(1, id);rs = pst.executeQuery();if (rs.next()) {BookType bookType = new BookType(rs.getInt(1), rs.getString(2));return bookType;}} catch (SQLException e) {System.out.println("根据ID查询异常" + e);} finally {DBUtil.release(conn, pst, rs);}return null;}}

BookInfoDao类

package com.hqyj.bookShop.dao;import com.hqyj.bookShop.entity.BookInfo;
import com.hqyj.bookShop.entity.BookType;
import com.hqyj.bookShop.util.DBUtil;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;public class BookInfoDao {BookTypeDao btDao = new BookTypeDao();/** 查询所有类型* */Connection conn;PreparedStatement pst;ResultSet rs;/** 查询所有* */public List<BookInfo> queryAll() {ArrayList<BookInfo> list = new ArrayList<>();conn = DBUtil.getConn();try {pst = conn.prepareStatement("select * from book_info");rs = pst.executeQuery();while (rs.next()) {int bookId = rs.getInt(1);int typeId = rs.getInt(2);String bookName = rs.getString(3);String bookAuthor = rs.getString(4);int bookPrice = rs.getInt(5);int bookNum = rs.getInt(6);String publisherDate = rs.getString(7);//参数中所需的主表对象实体，需要通过dao对象查询BookInfo bookInfo = new BookInfo(bookId, typeId, bookName, bookAuthor, bookPrice, bookNum, publisherDate, btDao.findById(typeId));list.add(bookInfo);}} catch (SQLException e) {System.out.println("查询所有异常" + e);} finally {DBUtil.release(conn, pst, rs);}return list;}}

4.创建Servlet

这里创建BookInfo的Servlet即可

BookInfoServlet类

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.BookInfoDao;
import com.hqyj.bookShop.entity.BookInfo;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 java.io.IOException;
import java.util.List;@WebServlet("/bookInfo")
public class BookInfoServlet extends HttpServlet {//创建数据访问层对象BookInfoDao biDao= new BookInfoDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");switch (op) {case "queryAll"://查询所有图书，保存到请求中，跳转到页面List<BookInfo> list = biDao.queryAll();req.setAttribute("list",list);req.getRequestDispatcher("./pages/bookList.jsp").forward(req,resp);break;}}
}

5.创建页面

列表页面位于pages目录下，遍历数据

<!--样式略--><%for (BookInfo bookInfo : list) {%>
<div><img src="图片路径"><p class="title"><%=bookInfo.getBookName()%></p><p class="desc"><%=bookInfo.getBookAuthor()%>｜<%=bookInfo.getBookType().getTypeName()%></p><p class="price"><%=bookInfo.getBookPrice()%>元起</p>
</div>
<% }%>

MySQL分页查询

原理

select * from 表;
-- 查询前N条记录
select * from 表 limit N;
-- 从第N条记录开始查询M条记录
select * from 表 limit N,M;-- 如每页显示8条,第一页
select * from 表 limit 0,8
-- 第二页
select * from 表 limit 8,8-- 公式 size表示每页显示的数量 page表示页数
select * from 表 limit (page-1)*size,size

dao层中分页相关方法

/** 查询总记录数* */
public int getSumCount() {conn = DBUtil.getConn();String sql = "select count(book_id) from book_info ";try {pst = conn.prepareStatement(sql);rs = pst.executeQuery();if (rs.next()) {return rs.getInt(1);}} catch (SQLException e) {System.out.println("查询总记录数异常" + e);} finally {DBUtil.release(conn, pst, rs);}return 0;
}/** 分页查询* */
public List<BookInfo> queryByPage(int page, int size) {ArrayList<BookInfo> list = new ArrayList<>();conn = DBUtil.getConn();String sql = "select * from book_info limit ?,?";try {pst = conn.prepareStatement(sql);pst.setInt(1, (page - 1) * size);pst.setInt(2, size);rs = pst.executeQuery();while (rs.next()) {int bookId = rs.getInt(1);int typeId = rs.getInt(2);String bookName = rs.getString(3);String bookAuthor = rs.getString(4);int bookPrice = rs.getInt(5);int bookNum = rs.getInt(6);String publisherDate = rs.getString(7);String bookImg = rs.getString(8);//参数中所需的主表对象实体，需要通过dao对象查询BookInfo bookInfo = new BookInfo(bookId, typeId, bookName, bookAuthor, bookPrice, bookNum, publisherDate, bookImg, btDao.findById(typeId));list.add(bookInfo);}} catch (SQLException e) {System.out.println("分页查询异常" + e);} finally {DBUtil.release(conn, pst, rs);}return list;
}

servlet中加入分页请求判断

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.BookInfoDao;
import com.hqyj.bookShop.entity.BookInfo;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 java.io.IOException;
import java.util.List;@WebServlet("/bookInfo")
public class BookInfoServlet extends HttpServlet {//创建数据访问层对象BookInfoDao biDao = new BookInfoDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");switch (op) {//分页查询case "queryByPage"://得到总记录数int sumCount = biDao.getSumCount();//将总记录数保存到请求中req.setAttribute("sumCount",sumCount);//初始第一页int page=1;int size=8;//获取要查询的页数if (req.getParameter("page")!=null) {page=Integer.parseInt(req.getParameter("page"));}//调用分页查询List<BookInfo> list2 = biDao.queryByPage(page,size);//将查询的结果保存、跳转req.setAttribute("list", list2);req.getRequestDispatcher("./pages/bookList.jsp").forward(req, resp);break;}}
}

页面

<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><meta charset="utf-8"><title></title>
</head>
<body>
<%List<BookInfo> list = (List<BookInfo>) request.getAttribute("list");
%>
<div class="product_list"><div class="left"></div><div class="right"><%for (BookInfo bookInfo : list) {%><div><img alt="暂无图片" src="./img/<%=bookInfo.getBookImg()%>"><p class="title"><%=bookInfo.getBookName()%></p><p class="desc"><%=bookInfo.getBookType().getTypeName()%>｜<%=bookInfo.getBookAuthor()%></p><p class="price">￥<%=bookInfo.getBookPrice()%></p></div><% }%></div>
</div>
<%/*pno默认1*/int pno = 1;/*从请求中获取当前页数*/if (request.getParameter("page") != null) {pno = Integer.parseInt(request.getParameter("page"));}/*获取总记录数*/int sumCount = (Integer) request.getAttribute("sumCount");//计算最大页数int maxPage=(int)Math.ceil(sumCount/8.0);
%>
<div class="pageTool"><%--在请求分页的servlet时，传递page参数表示当前页--%><a href="http://localhost:8080/Web03/bookInfo?op=queryByPage&page=<%=(pno-1==0)?1:pno-1%>">上一页</a><span>第<%=pno%>页</span><span>共<%=maxPage%>页</span><a href="http://localhost:8080/Web03/bookInfo?op=queryByPage&page=<%=pno+1>maxPage?maxPage:pno+1%>">下一页</a>
</div>
</body>
</html>

条件分页(关键字搜索)

原理

select * from 表 where 字段 like concat('%',keyword,'%') limit (page-1)*size,size

dao

package com.hqyj.bookShop.dao;import com.hqyj.bookShop.entity.BookInfo;
import com.hqyj.bookShop.entity.BookType;
import com.hqyj.bookShop.util.DBUtil;import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;public class BookInfoDao {BookTypeDao btDao = new BookTypeDao();/** 查询所有类型* */Connection conn;PreparedStatement pst;ResultSet rs;/** 根据关键字查询总记录数* */public int getSumCount(String keyword) {conn = DBUtil.getConn();String sql = "select count(book_id) from book_info where book_name like concat('%',?,'%')";try {pst = conn.prepareStatement(sql);pst.setString(1,keyword);rs = pst.executeQuery();if (rs.next()) {return rs.getInt(1);}} catch (SQLException e) {System.out.println("查询总记录数异常" + e);} finally {DBUtil.release(conn, pst, rs);}return 0;}/** 条件查询(关键字分页)* */public List<BookInfo> queryByCondition(int page,int size,String keyword){ArrayList<BookInfo> list = new ArrayList<>();conn = DBUtil.getConn();String sql = "select * from book_info where book_name like concat('%',?,'%') limit ?,?";try {pst = conn.prepareStatement(sql);pst.setString(1, keyword);pst.setInt(2, (page-1)*size);pst.setInt(3, size);rs = pst.executeQuery();while (rs.next()) {int bookId = rs.getInt(1);int typeId = rs.getInt(2);String bookName = rs.getString(3);String bookAuthor = rs.getString(4);int bookPrice = rs.getInt(5);int bookNum = rs.getInt(6);String publisherDate = rs.getString(7);String bookImg = rs.getString(8);//参数中所需的主表对象实体，需要通过dao对象查询BookInfo bookInfo = new BookInfo(bookId, typeId, bookName, bookAuthor, bookPrice, bookNum, publisherDate, bookImg, btDao.findById(typeId));list.add(bookInfo);}} catch (SQLException e) {System.out.println("关键字分页查询异常" + e);} finally {DBUtil.release(conn, pst, rs);}return list;}}

servlet

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.BookInfoDao;
import com.hqyj.bookShop.entity.BookInfo;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 java.io.IOException;
import java.util.List;@WebServlet("/bookInfo")
public class BookInfoServlet extends HttpServlet {//创建数据访问层对象BookInfoDao biDao = new BookInfoDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");switch (op) {case "search"://获取搜索关键字，第一次访问时没有关键字，使用""查询String keyword = req.getParameter("keyword")==null?"":req.getParameter("keyword");//得到总记录数int sumCount = biDao.getSumCount(keyword);//将总记录数保存到请求中req.setAttribute("sumCount", sumCount);//初始第一页int page = 1;int size = 8;//获取要查询的页数if (req.getParameter("page") != null) {page = Integer.parseInt(req.getParameter("page"));}//调用条件查询，保存集合，跳转页面List<BookInfo> list = biDao.queryByCondition(page, size, keyword);req.setAttribute("list",list);req.getRequestDispatcher("./pages/bookList.jsp").forward(req, resp);break;}}
}

页面

<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><meta charset="utf-8"><title></title><style>* {margin: 0;padding: 0;}body {background-color: #f5f5f5;}.product_list {width: 1240px;height: 614px;margin: 0px auto;}.product_list > div {float: left;}.left {width: 234px;height: 614px;background-image: url(./img/left.jpg);background-size: 100%;}.right {width: 992px;height: 614px;}.right > div {width: 234px;height: 300px;background-color: #fff;float: left;margin-left: 14px;margin-bottom: 14px;position: relative;transition-duration: 0.2s;}.right > div img {width: 160px;height: 160px;display: block;margin: 20px auto;}.right .title {font-size: 14px;font-weight: 400;text-align: center;color: #333;}.right .desc {width: 214px;height: 18px;margin: 2px auto 10px;font-size: 12px;color: #b0b0b0;overflow: hidden;text-align: center;}.right .price {text-align: center;color: #ff6700;font-size: 14px;}.right > div:hover {/* 向上平移2px */transform: translate(0, -3px);box-shadow: rgba(0, 0, 0, 0.2) 0 0 20px;}.header {width: 100%;height: 80px;border-bottom: 2px solid #eee;background-color: #fff;}.header .logo {width: 240px;height: 80px;float: left;margin-left: 100px;background-image: url("./img/logo.png");background-size: cover;}.header .customer {float: right;width: 300px;height: 80px;text-align: center;line-height: 80px;color: deepskyblue;font-size: 14px;margin-right: 100px;}a {text-decoration: none;color: deepskyblue;}.search {width: 600px;height: 80px;margin: 0 auto;}.search input[type="text"] {width: 300px;height: 40px;margin-top: 20px;margin-left: 100px;font-size: 20px;outline: none;border: none;border: 1px solid skyblue;}.search input[type="submit"] {width: 80px;height: 40px;border: none;background-color: #fff;color: deepskyblue;font-size: 20px;}.pageTool {width: 200px;margin: 0 auto 100px;}</style>
</head>
<body>
<%List<BookInfo> list = (List<BookInfo>) request.getAttribute("list");
%><div class="header"><div class="logo"></div><div class="customer">当前客户:xxx<a href="#">我的购物车</a><a href="#">安全退出</a></div>
</div>
<div class="search"><form action="./bookInfo"><input type="hidden" name="op" value="search"><input type="text" placeholder="请输入关键字查询" value="<%=request.getParameter("keyword")==null?"": request.getParameter("keyword")%>"  name="keyword"><input type="submit" value="搜索"></form>
</div>
<div class="product_list"><div class="left"></div><div class="right"><%for (BookInfo bookInfo : list) {%><div><img alt="暂无图片" src="./img/<%=bookInfo.getBookImg()%>"><p class="title"><%=bookInfo.getBookName()%></p><p class="desc"><%=bookInfo.getBookType().getTypeName()%>｜<%=bookInfo.getBookAuthor()%></p><p class="price">￥<%=bookInfo.getBookPrice()%></p></div><% }%></div>
</div><%/*pno默认1*/int pno = 1;/*从请求中获取当前页数*/if (request.getParameter("page") != null) {pno = Integer.parseInt(request.getParameter("page"));}/*获取总记录数*/int sumCount = (Integer) request.getAttribute("sumCount");//计算最大页数int maxPage=(int)Math.ceil(sumCount/8.0);//获取请求中的关键字，如果没有搜索过，使用空白字符串String keyword= request.getParameter("keyword")==null?"": request.getParameter("keyword");%>
<div class="pageTool"><%--在请求分页的servlet时，传递page参数表示当前页--%><a href="http://localhost:8080/Web03/bookInfo?op=search&keyword=<%=keyword%>&page=<%=(pno-1==0)?1:pno-1%>">上一页</a><span>第<%=pno%>页</span><span>共<%=maxPage%>页</span><a href="http://localhost:8080/Web03/bookInfo?op=search&keyword=<%=keyword%>&page=<%=pno+1>maxPage?maxPage:pno+1%>">下一页</a>
</div>
</body>
</html>

首页

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html><head><title>Title</title></head><body><%/*访问该页面时，跳转至分页查询*/response.sendRedirect("http://localhost:8080/Web03/bookInfo?op=search");%></body>
</html>

EL

Expression Language 表达式语言

是为了使JSP写起来更加简便，替换JSP中的<%=%>，简化了JSP页面中输出数据的操作。

主要输出保存在某个作用域中的数据。

特点

如果通过"某个作用域对象.setAttribute(“cus”,customer)"方法保存的对象，

在JSP页面中如果用表达式，使用<%=cus%>，如果用EL，使用**${cus}**输出。

会依次从pageContext–>reqeust–>session–>application中获取指定对象，

如果一旦从某个作用域中获取到了指定对象，就不再判断后续作用域。

也可以输出指定作用域中的对象。

• 只能输出保存在作用域中的对象

• 减少代码(省去了获取对象、转换的过程)

• 免去非空判断

  • 如果某个要输出的对象不存在，不会输出null，而是输出空字符串""。

使用

在页面中输出保存在作用域中的对象

• 从作用域中依次查询并输出对象

  ${对象名}
  

• 从指定作用域中输出对象

  作用域	对应作用域	代码
  pageScope	当前页pageContex	${pageScope.对象}
  requestScope	请求request	${requestScope.对象}
  sessionScope	会话session	${sessionScope.对象}
  applicationScope	项目application	${applicationScope.对象}

• 输出对象的属性

  ${对象名.属性名}
  ${对象名["属性名"]}
  

• 输出对象的方法返回值

  ${对象名.方法名()}
  

如在servlet中

Person p = new Person("admin","男",20);
request.setAttribute("p",p);

跳转到某个页面中

<html><head></head><body><%-- 如果不用EL,先获取对象，向下转型 --%><% Person p =(Person) request.getAttribute("p");%><%-- 如果p为null，会报错，如果name没有赋值，会输出null --%><h3><%=p.getName()%>;</h3><%--如果使用EL,无需获取对象，无需转型，直接通过保存的对象名.属性名即可--%><h3>${p.name}</h3><%--使用EL输出对象的属性时，该对象必须要有getXX()方法--%><%--如果没有在任何作用域中获取到对象p，或对象p没有name属性，不会保存，输出空字符串--%><h3>${p["name"]}</h3></body>
</html>

在页面中获取请求中的参数

用于获取表单提交的数据或超链接?后传递的数据。

使用${param.参数名}替换request.getParameter(“参数”)。

如有表单或超链接

<form action="page.jsp"><input type="text" name="username"><input type="submit">
</form><a href="page.jsp?username=admin">跳转</a>

在page.jsp中获取

<html><head></head><body><%-- 传统写法--%><% String username =  request.getParameter("username");%><h3><%=username%>;</h3><%--如果使用EL--%><h3>${param.username}</h3></body>
</html>

用于获取当前项目上下文(根目录+项目名)路径

如http://localhost:8080/Web03/就是一个项目上下文路径，

在JSP中使用**${pageContext.request.contextPath}**获取项目上下文路径

<form action="${pageContext.request.contextPath}/servlet映射"></form><a href="${pageContext.request.contextPath}/页面路径">超链接</a>

注意

• web.xml版本在4.0之后，在JSP中使用EL时，默认可以识别。

• 如果JSP无法识别EL，在指令(<%@ %>)中加入 isELIgnored="false"表示不忽略EL。

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

• 如果在使用EL过程中，出现PropertyNotFoundException异常，表示未发现指定属性，原因有

  • 缺少指定属性
  • 指定属性没有对应的get方法

JSTL

Java Server Page Standarded Tag Library JSP标准标签库

可以使用JSTL中的特定标签，来替换JSP中常见的Java代码。如循环判断等，减少Java代码，提高页面的可读性。

使用

1.导入JSTL对应的依赖

https://mvnrepository.com/artifact/javax.servlet/jstl/1.2

<dependency><groupId>javax.servlet</groupId><artifactId>jstl</artifactId><version>1.2</version>
</dependency>

2.在JSP页面中，加入标签库指令

<%--在当前页面中使用jstl，加入以下指令--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

这句话可以不写，在使用循环遍历时会自动生成。

3.具体用法

• 定义变量或给变量赋值

  <c:set var="变量名" value="值"></c:set>
  

  如

  <c:set var="num" value="123123"></c:set>
  

• if判断

  <c:if test="判断条件">满足条件时的内容
  </c:if>
  

  如在servlet中

  request.setAttribute("person",new Person("ez","男"));
  

  在Jsp中

  <c:if test="${person.sex=='男'}"><input type="raido" name="sex" checked>男<input type="raido" name="sex" >女
  </c:if>
  

• 遍历List集合

  <c:forEach items="要遍历的集合" var="遍历出的对象名"></c:forEach>
  

  如servlet中保存了集合

  List<BookInfo> list = dao.queryAll();
  request.setAttribute("list",list);
  

  在jsp页面中

    <%--判断集合为空--%><c:if test="${empty list}">无数据</c:if><c:forEach items="${list}" var="bi"><tr><td>${bi.bookName}</td><td>${bi.bookAuthor}</td></tr></c:forEach>
  

• 遍历Map集合

  <c:forEach items="要遍历的集合名" var="遍历出的键值对的名称">${键值对名.key.属性}${键值对名.value.属性}
  </c:forEach>
  

  如

  <%HashMap<String,String> hm=new HashMap();hm.put("yyds","永远单身");hm.put("xswl","吓死我了");hm.put("pyq","朋友圈");session.setAttribute("hm",hm);
  %>
  <c:forEach items="${hm}" var="kv"><!--遍历键--><h3>${kv.key}</h3><!--遍历值--><h3>${kv.value}</h3>
  </c:forEach>
  

使用EL和JSTL实现商城首页

客户servlet

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.CustomerDao;
import com.hqyj.bookShop.entity.Customer;
import com.hqyj.bookShop.util.Cart;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;@WebServlet("/customer")
public class CustomerServlet extends HttpServlet {CustomerDao dao = new CustomerDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");//获取session对象，默认30分钟有效HttpSession session = req.getSession();//设置session有效时间，单位为秒//session.setMaxInactiveInterval(10);switch (op) {case "login"://获取登录信息String phone = req.getParameter("phone");String password = req.getParameter("password");//调用登录Customer login = dao.login(phone, password);if (login != null) {//登录成功后，创建购物车对象Cart cart = new Cart();//将购物车保存到session中session.setAttribute("cart",cart);//将登录成功的对象，保存到session中session.setAttribute("customer", login);//使用重定向跳转到查询所有图书的servletresp.sendRedirect("./bookInfo?op=search");} else {System.out.println("登录失败");}break;case "logout"://从session中移除登录的对象//session.removeAttribute("customer");//销毁sessionsession.invalidate();resp.sendRedirect("./bookInfo?op=search");break;}}
}

商品servlet

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.BookInfoDao;
import com.hqyj.bookShop.entity.BookInfo;
import com.hqyj.bookShop.util.Cart;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.util.List;@WebServlet("/bookInfo")
public class BookInfoServlet extends HttpServlet {//创建数据访问层对象BookInfoDao biDao = new BookInfoDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");switch (op) {case "search"://获取搜索关键字，第一次访问时没有关键字，使用""查询String keyword = req.getParameter("keyword") == null ? "" : req.getParameter("keyword");//得到总记录数int sumCount = biDao.getSumCount(keyword);//将总记录数保存到请求中req.setAttribute("sumCount", sumCount);//初始第一页int page = 1;int size = 8;//获取要查询的页数if (req.getParameter("page") != null) {page = Integer.parseInt(req.getParameter("page"));}//调用条件查询，保存集合，跳转页面List<BookInfo> list = biDao.queryByCondition(page, size, keyword);req.setAttribute("list", list);req.getRequestDispatcher("./pages/bookList.jsp").forward(req, resp);break;case "findById"://获取要查询的id,调用方法，保存查询的结果，跳转详情页面int id = Integer.parseInt(req.getParameter("id"));BookInfo bi = biDao.findById(id);req.setAttribute("bi", bi);req.getRequestDispatcher("./pages/bookInfo.jsp").forward(req, resp);break;//    添加到购物车case "addToCart"://图书编号String buyId = req.getParameter("id");//调用查询BookInfo byId = biDao.findById(Integer.parseInt(buyId));//获取购买数量int buyNum = Integer.parseInt(req.getParameter("buyNum"));//从session中获取购物车Cart cart = (Cart) req.getSession().getAttribute("cart");//调用添加cart.addToCart(byId, buyNum);//跳转购物车页面resp.sendRedirect("./pages/cart.jsp");break;//移除商品case "remove"://图书编号String removeId = req.getParameter("id");//调用查询BookInfo removeBook = biDao.findById(Integer.parseInt(removeId));//调用移除((Cart) req.getSession().getAttribute("cart")).removeFromCart(removeBook);//跳转购物车页面resp.sendRedirect("./pages/cart.jsp");break;case "clear"://调用移除((Cart) req.getSession().getAttribute("cart")).clearCart();//跳转购物车页面resp.sendRedirect("./pages/cart.jsp");break;}}
}

顶部页面

<%@ page import="com.hqyj.bookShop.entity.Customer" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html><head><title>Title</title><style>样式略</style></head><body><div class="header"><a href="${pageContext.request.contextPath}/bookInfo?op=search"><div class="logo"></div></a><div class="customer"><%--这个判断表示customer是否为Null--%><c:if test="${empty customer}"><a href="${pageContext.request.contextPath}/pages/login.html">请登录</a></c:if><%--这个判断表示customer是否不为Null--%><c:if test="${!empty customer}">当前客户:${customer.phone}<a href="${pageContext.request.contextPath}/pages/cart.jsp">我的购物车</a><a href="${pageContext.request.contextPath}/customer?op=logout">安全退出</a></c:if></div></div></body>
</html>

所有商品页面

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page import="java.util.List" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head><meta charset="utf-8"><title></title><style>样式略</style>
</head>
<body><%--通过jsp动作：jsp:include导入某个页面--%>
<jsp:include page="top.jsp"></jsp:include><div class="search"><form action="${pageContext.request.contextPath}/bookInfo"><input type="hidden" name="op" value="search"><input type="text" placeholder="请输入关键字查询" value="${param.keyword}" name="keyword"><input type="submit" value="搜索"></form>
</div>
<div class="product_list"><div class="left"></div><%--判断集合为空--%><%--    <c:if test="${list.size()==0}">--%><c:if test="${empty list}"><div class="right">未查询到相应图书</div></c:if><div class="right"><c:forEach items="${list}" var="book"><div><a href="${pageContext.request.contextPath}/bookInfo?op=findById&id=${book.bookId}"><img alt="暂无图片" src="${pageContext.request.contextPath}/img/${book.bookImg}"></a><p class="title">${book.bookName}</p><p class="desc">${book.bookType.typeName}｜${book.bookAuthor}</p><p class="price">￥${book.bookPrice}</p></div></c:forEach></div>
</div><%/*pno默认1*/int pno = 1;/*从请求中获取当前页数*/if (request.getParameter("page") != null) {pno = Integer.parseInt(request.getParameter("page"));}/*获取总记录数*/int sumCount = (Integer) request.getAttribute("sumCount");//计算最大页数int maxPage = (int) Math.ceil(sumCount / 8.0);//获取请求中的关键字，如果没有搜索过，使用空白字符串%>
<div class="pageTool"><%--在请求分页的servlet时，传递page参数表示当前页--%><a href="${pageContext.request.contextPath}/bookInfo?op=search&keyword=${param.keyword}&page=<%=(pno-1==0)?1:pno-1%>">上一页</a><span>第<%=pno%>页</span><span>共<%=maxPage%>页</span><a href="${pageContext.request.contextPath}/bookInfo?op=search&keyword=${param.keyword}&page=<%=pno+1>maxPage?maxPage:pno+1%>">下一页</a>
</div>
</body>
</html>

详情页面

<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<!DOCTYPE html>
<html>
<head><meta charset="utf-8"><title></title><style>样式略</style>
</head>
<body><%//获取查询出的详情对象//BookInfo bi = (BookInfo) request.getAttribute("bi");%>
<jsp:include page="top.jsp"></jsp:include>
<div class="wrap"><div class="book" style="background-image: url(${pageContext.request.contextPath}/img/${bi.bookImg})"></div><div class="info"><p style="font-size: 24px;font-weight: bold">《${bi.bookName}》</p><p style="font-size: 16px;color: #aaa">"${bi.bookAuthor}"作品</p><p style="font-size: 24px;color: #f00;">￥${bi.bookPrice}</p><%if (session.getAttribute("customer") != null) {%><%--提交到图书servlet--%><form action="${pageContext.request.contextPath}/bookInfo"><%--op、图书编号、购买数量--%><input type="hidden" name="op" value="addToCart"><input type="hidden" name="id" value="${bi.bookId}"><input type="number" value="1" min="1" max="${bi.bookNum}" name="buyNum"><br><input type="submit" value="添加到购物车"></form><%} else {%><h3>请登录后购买</h3><%}%></div>
</div></body>
</html>

购物车页面

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="com.hqyj.bookShop.util.Cart" %>
<%@ page import="com.hqyj.bookShop.entity.BookInfo" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html><head><style>样式略</style></head><body><%--防止在未登录的情况下访问该页面--%><%--如果登录成功，session中保存登录的对象customer，如果没有登录或者退出，customer对象就会消失。所以判断customer对象是否存在，决定是否显示该页面--%><%//如果从session中无法获取customer对象，跳转到登录页面if (session.getAttribute("customer") == null) {response.sendRedirect("login.html");return;}%><jsp:include page="top.jsp"></jsp:include><div class="wrap"><table><tr><th>图书编号</th><th>图书名称</th><th>图书作者</th><th>图书单价</th><th>购买数量</th><th>小计</th><th>操作</th></tr><%--定义总价--%><c:set var="sum" value="0"></c:set><%--cart是登录成功后保存在session中的购物车Cart类对象--%><%--hm是Cart类中的属性：HashMap对象--%><%--hm必须要有getHm()方法--%><c:forEach items="${cart.hm}" var="kv"><tr><%--HashMap中，图书对象是键，购买数量是值--%><%--kv.key即是遍历出的图书对象--%><td>${kv.key.bookId}</td><td>${kv.key.bookName}</td><td>${kv.key.bookAuthor}</td><td>${kv.key.bookPrice}</td><%--kv.value即是遍历出的购买数量--%><td>${kv.value}</td><%--EL中可以进行计算--%><td>￥${kv.value * kv.key.bookPrice}</td><td><a href="${pageContext.request.contextPath}/bookInfo?op=remove&id=${kv.key.bookId}">移除</a></td></tr><%--将小计累加--%><c:set var="sum" value="${sum+kv.value * kv.key.bookPrice}"></c:set></c:forEach><tr><td colspan="5">总计</td><td>￥${sum}</td><td><a href="${pageContext.request.contextPath}/bookInfo?op=clear">清空购物车</a></td></tr></table></div></body>
</html>

Ajax

Asynchronous Javascript And XML

异步JavaScript和XML

一种数据交互方式，请求和响应是异步的。

使用ajax能实现在整个页面不重新加载的情况下，更新局部内容。

使用

浏览器都是支持异步提交，原生的JavaScript就能实现ajax，但使用极不方便，所以都是使用jquery封装后的**.ajax()∗∗或.ajax()**或.ajax()∗∗或.get() $.post()等函数。

1.在页面中导入jquery文件

<!--使用Ajax,需要导入jquery-->
<script src="jquery文件路径"></script>

2.在script标签中写ajax

<script>某个节点.事件(function(){//使用ajax异步提交数据$.ajax({//访问的URL地址url:"servlet映射或具体url"，//提交的数据data:{//键:值"形参":值,"形参":值},//提交方式type:"get/post/put/delete",//成功访问URL后的回调函数success:function(res){//res表示访问URL后返回的数据},//访问URL失败时的回调函数error:function(){}});});
</script>

具体案例

servlet

package com.hqyj.bookShop.servlet;import com.hqyj.bookShop.dao.CustomerDao;
import com.hqyj.bookShop.entity.Customer;
import com.hqyj.bookShop.util.Cart;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;@WebServlet("/customer")
public class CustomerServlet extends HttpServlet {CustomerDao dao = new CustomerDao();@Overrideprotected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {req.setCharacterEncoding("utf-8");String op = req.getParameter("op");switch (op) {case "login"://获取登录信息String phone = req.getParameter("phone");String password = req.getParameter("password");//调用登录Customer login = dao.login(phone, password);if (login != null) {//将登录成功的对象，保存到session中session.setAttribute("customer", login);//使用输出流对象输出一个字符串"ok"resp.getWriter().print("ok");} else {//使用输出流对象输出一个字符串"ok"resp.getWriter().print("error");}break;}}
}

页面

<html><head></head><body><input type="text" name="phone"  placeholder="请输入手机号"/><br><br><input type="password" name="password"  placeholder="请输入密码"/><br><br><input id="submit" type="button" value="登录"/></body><script src="./../system/bootstrap-3.4.1-dist/js/jquery-3.6.2.min.js"></script><script>//如果是普通按钮，需要写单击事件$("#submit").click(function () {//获取输入的信息let phone = $("input[name=phone]").val();let password = $("input[name=password]").val();if (phone == "" || password == "") {alert("输入不能为空");return;}//使用ajax提交登录信息$.ajax({//请求地址url: "http://localhost:8080/Web03/customer",//提交方式type: "post",//提交数据data: {"op":"login","phone": phone,"password": password},//访问成功(能正常访问指定地址)后的回调函数。success: function (res) {if(res=="error"){alert("用户名或密码错误");}if(res=="ok") {location.href="http://localhost:8080/Web03/bookInfo?op=search";}}});});//如果是表单，需要写表单提交事件// $("form:eq(0)").submit();</script>
</html>

JSP内置对象

在jsp页面中有一些对象是已经定义好了可以直接使用的，称为内置对象。

一共有9个内置对象。

“rrppsoace”

• request
  • 请求作用域对象
• response
  • 响应对象
• pageContext
  • 当前页作用域对象
• session
  • 会话作用域对象
• page
  • 当前jsp页面对象
• out
  • 输出对象
• application
  • 项目作用域对象
• config
  • 配置对象
• exception
  • 异常对象

Session和Cookie

这两个都是用于保存数据的对象。

session是一个作用域对象，在servlet中通过request.getSession()获取，在JSP中直接使用内置对象session获取。

cookie是一个对象，也是一个文件，保存在本地。

Cookie

cookie通常用于更长时间地保存一些信息，即便关闭浏览器，也能保存。

cookie的创建

//创建cookie
Cookie cookie = new Cookie("username", "保存在cookie中的用户名");
//设置有效时长,单位为秒，这里表示7天有效
cookie.setMaxAge(60*60*24*7);
//通过响应对象response保存cookie对象到本地
response.addCookie(cookie);

cookie的获取

//读取cookie时是获取当前站点的所有cookie数组
Cookie[] cks = request.getCookies();
//遍历
for(Cookie ck :cks){System.out.println( ck.getName()+"--"+ck.getValue());
}

Session

session是一个作用域对象，在访问任意jsp页面时，默认就会创建一个session对象(可以通过设置取消自动创建)。

通常使用session保存一些信息，用于在同一站点的各个页面之间共享数据。

原理：

• 1.当访问的jsp页面或servlet中使用了session，会创建一个JSESSIONID(session编号)，这是一个字符串，保存在一个cookie中。

  • 默认访问某个jsp页面时，该页面中没有使用session，也会自动创建session，因为

    <%--默认每个jsp页面都有这句话，表示访问该页面时，自动使用session--%>
    <%@ page session="true"%>
    

    如果将其设置为false，访问该jsp时则不会自动创建session。

• 2.再次访问该页面时，会查询该JSESSIONID是否存在，如果存在，直接使用，如果不存在，创建新的JSESSIONID

• 3.保存该JSESSIONID的cookie会随着浏览器的关闭自动销毁，所以关闭浏览器，session就会失效。

session对象的常用方法

常用方法	作用
session.setAttribute(String str,Object obj)	将obj对象保存在session中，命名为str
session.getAttribute(String str)	获取保存在session中的对象
session.removeAttribute(String str)	移除保存在session中的对象
session.invalidate()	销毁session
session.getCreationTime()	获取session创建时间对应的毫秒数
session.getId()	获取JSESSIONID
session.getMaxInactiveInterval()	获取session有效时长(默认1800秒)
session.setMaxInactiveInterval(int seconds)	设置session有效时长，参数为秒
ServletContext app = session.getServletContext();	获取当前application对象

设置全局session有效时长

在指定时间内，打开浏览器但对session无操作，就会自动销毁session。

• 通过session.setMaxInactiveInterval(int seconds)设置有效秒数

• 在web.xml中配置

  <!--设置全局session配置-->
  <session-config><!--session有效时长，单位为分钟--><session-timeout>15</session-timeout>
  </session-config>
  

Session和Cookie对比

• session中保存的是对象Object，cookie中保存的是字符串String，都以键值对的形式保存
• session保存在浏览器和服务器端，cookie保存在浏览器
• session保存的数据没有大小限制，cookie保存的数据有大小限制，不超过3KB
• session在30分钟内没有访问或随着浏览器的关闭而销毁，cookie可以设置销毁时间

监听器Listener

对于项目的某个操作进行监听，这个操作可以是创建或销毁application、session，发送请求、得到响应。

用于在执行某个操作时，通过监听器同时再执行其他操作，如记录日志、统计站点人数等。

常用的三个监听器接口

ServletContextListener       application监听器
HttpSessionListener         session监听器
ServletRequestListener      request监听器

实现一个监听器

1.创建一个类，实现某个监听器接口

2.重写某个监听器接口中方法

• 初始化的方法
• 销毁的方法

3.在web.xml中配置监听器或通过注解配置

• 如果在web.xml中配置

  <!--配置监听器-->
  <listener><!--设置监听器的全限定名--><listener-class>com.hqyj.bookShop.listener.MyListener</listener-class>
  </listener>
  

• 如果通过注解配置，在自定义的监听器类上，加入@Web

package com.hqyj.bookShop.listener;import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;/*
* 监听器
* 1.创建一个类，实现某个或多个监听器接口
* 2.重写方法
* 3.在该类上加入@WebListener注解或在web.xml中配置监听器
* */
@WebListener
public class MyListener implements ServletContextListener,HttpSessionListener, ServletRequestListener {@Overridepublic void contextInitialized(ServletContextEvent sce) {System.out.println("监听到项目初始化");}@Overridepublic void contextDestroyed(ServletContextEvent sce) {System.out.println("监听到项目销毁");}@Overridepublic void requestDestroyed(ServletRequestEvent sre) {System.out.println("监听到请求销毁");}@Overridepublic void requestInitialized(ServletRequestEvent sre) {System.out.println("监听到发送请求");}@Overridepublic void sessionCreated(HttpSessionEvent se) {System.out.println("监听到session创建");}@Overridepublic void sessionDestroyed(HttpSessionEvent se) {System.out.println("监听到session销毁");}
}

过滤器Filter

使用

1.创建一个类，继承HttpFilter

2.重写其中受保护的doFilter的方法

3.在web.xml中配置过滤器或使用注解配置

• 在web.xml中配置的话

  <!--声明过滤器-->
  <filter><filter-name>myFilter</filter-name><filter-class>com.hqyj.filter.MyFilter</filter-class>
  </filter>
  <!--设置什么请求要经过该过滤器，通常过滤所有请求-->
  <filter-mapping><filter-name>myFilter</filter-name><!--/*表示过滤所有请求--><url-pattern>/*</url-pattern>
  </filter-mapping>
  

• 使用@WebFilter(“/*”)注解配置的话

  package com.hqyj.filter;import javax.servlet.FilterChain;
  import javax.servlet.ServletException;
  import javax.servlet.annotation.WebFilter;
  import javax.servlet.http.HttpFilter;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;/** 自定义一个过滤器* 1.继承HttpFilter* 2.重写受保护的doFilter方法* 3.web.xml中配置该过滤器* */
  //@WebFilter("/*")
  public class MyFilter extends HttpFilter {@Overrideprotected void doFilter(HttpServletRequest req, HttpServletResponse res, FilterChain chain) throws IOException, ServletException {//由于设置了过滤所有请求，所以在这里设置请求的编码格式req.setCharacterEncoding("utf-8");//获取请求的地址后，决定是否放行String uri = req.getRequestURI();System.out.println(uri+"试图访问");//判断地址中是否包含登录页或登录页相关的servlet映射或资源路径if (uri.contains("login")|| uri.contains("customer")||uri.contains("jquery")) {//允许放行chain.doFilter(req,res);return;}//如果登录成功，会在session中保存customer，所以在这里判断session中是否存在customer，如果存在，放行一切请求if(req.getSession().getAttribute("customer")==null){res.sendRedirect("http://localhost:8080/Web03/pages/login.html");}else{//允许放行chain.doFilter(req,res);}}
  }

(javaweb基础相关推荐

1. 超详细的Java面试题总结（四 ）之JavaWeb基础知识总结

   系列文章请查看: 超详细的Java面试题总结(一)之Java基础知识篇 超详细的Java面试题总结(二)之Java基础知识篇 超详细的Java面试题总结(三)之Java集合篇常见问题 超详细的Java ...

2. index加载显示servlet数据_[WEB篇]-JavaWeb基础与应用-02-Servlet开发

   JavaWeb基础与应用 2.Servlet开发 Servlet是sun公司提供的一门用于开发动态web资源的技术. Sun公司在其API中提供了一个servlet接口,用户若想用发一个动态web资源 ...

3. javaweb基础知识点记录2

   javaweb基础知识点记录 1.在service方法中,首先获得请求的方法名,然后根据方法名调用对应的doXXXX方法,比如说请求参数为GET,那么就会去调用doGet方法,请求参数为POST,那么 ...

4. javaweb基础知识点记录1

   javaweb基础知识点记录 1.当我们通过在浏览器的输入栏中直接输入网址的方式访问网页的时候,浏览器采用的就是GET方法向服务器获取资源. 2.我们可以将Servlet看做是嵌套了HTML代码的ja ...

5. 黑马程序员最新版JavaWeb基础教程-学习笔记

   da@黑马程序员最新版JavaWeb基础教程-学习笔记 day06-HTML&CSS HTML HTML(HyperTest Markup Language):超文本标记语言 是一门语言,所有 ...

6. JavaWeb基础5——HTTP，TomcatServlet

    导航: [黑马Java笔记+踩坑汇总]JavaSE+JavaWeb+SSM+SpringBoot+瑞吉外卖+SpringCloud/SpringCloudAlibaba+黑马旅游+谷粒商城 目录 一 ...

7. JavaWeb基础核心技术-佟刚-专题视频课程

   JavaWeb基础核心技术-132383人已学习 课程介绍         本Java视频教程涵盖JavaWEB 企业级开发所需的Servlet.JSP.MVC 设计模式.EL 表达式.JavaBea ...

8. JavaWeb基础学习2

   目录 JavaWeb基础 Http Maven JavaWeb基础 Http 什么是Http Http是一个简单的请求–响应协议(超文本传输协议),它通常运行在TCP之上 80端口 Https:443 ...

9. JavaWeb基础知识总结

    [Java面试题]JavaWeb基础知识总结. 1.web服务器与HTTP协议 Web服务器 l WEB,在英语中web即表示网页的意思,它用于表示Internet主机上供外界访问的资源. l ...

10. 黑马程序员最新版JavaWeb基础教程最后的案例学习记录

    黑马程序员最新版JavaWeb基础教程最后的案例学习记录这里写自定义目录标题 调试中我遇到的问题 调试中我遇到的问题 若db1报错: 则 改成自己的数据库名称 web.xml报错:则用这一段代码 &l ...

最新文章

1. Linux6.x修改出eth0网卡的解决方法
2. 永磁电机设计唐任远_新能源汽车的关键技术中钕铁硼永磁同步电机结构设计
3. 9月安卓机性能榜单公布：华为未进前十，第一名有点意外
4. Linux中文件查找方法大全
5. Microsoft .NET 框架常见问题
6. IDEA生成SerialVersionUID
7. 基于软件仿真的PLC系统测试技术
8. 计算机毕业设计参考文献
9. PDF的文档转成HTML乱序,PDF文档怎么转换成HTML文件？用迅捷PDF转换器就不难！
10. 将ui文件转换为py文件
11. 计算机轴测图绘图实验报告,Auto_CAD实验报告_轴测图.doc
12. Cloudera Manager —— 端到端的企业数据中心管理工具
13. 能力素质有所欠缺_如何提高孩子动手能力？
14. Python制作背单词exe
15. python中bool函数用法_在python中bool函数的取值方法
16. target找不到*.xml和*.properties文件 报错：FileNotFoundException
17. tensorflow之tf.tensordot详解
18. USB-DFP UFP DRP模式
19. HTML外边框塌陷什么意思,html-margin塌陷 ：
20. 数据结构之ISAM文件和VSAM文件

热门文章

1. 【教程】Derby数据库安装与使用
2. [个人小记]什么是APT攻击
3. 内网穿透工具zerotier的安装及使用
4. 精彩继续，2020 Greenplum峰会 第二周精华回顾
5. win7计算机信息服务,Win7怎么打开系统服务？Win7查看系统服务信息方法
6. 基于SSM车辆维修管理系统-JavaWeb汽车保养管理系统
7. pascal voc使用coco标准评测AP50与pasal标准评测的AP50不一致(短)
8. 星外php mysql_PHP环境自动安装|星外PHP一键安装包下载 v5.0 For IIS_最火软件站
9. 络达开发----RACE指令之---DSP中AudioLoopbackTest如何触发执行
10. 初创公司威努特认为工控安全领域将迎来爆发期