----java进阶项目实战

java进阶内容

数据库

卸载数据库

要卸载数据库，你需要根据你使用的具体数据库类型和操作系统进行相应的操作。以下是一般情况下卸载数据库的步骤：

停止数据库服务：打开命令行或终端窗口，输入适用于你的数据库的停止命令。例如，对于 MySQL 数据库，可以使用以下命令来停止服务：

sudo service mysql stop

卸载数据库软件：在命令行或终端中，使用适用于你的操作系统的软件包管理工具来卸载数据库软件。以下是一些常见数据库的卸载命令示例：
- 对于 MySQL：
```
sudo apt-get remove mysql-server
```
- 对于 PostgreSQL：
```
sudo apt-get remove postgresql
```
- 对于 MongoDB：
```
sudo apt-get remove mongodb
```
删除数据文件：此步骤可选，如果你想完全删除数据库相关的数据文件，可以手动删除。请注意，这将永久删除所有数据库和数据，包括备份文件。要删除数据文件，请找到数据库数据目录并删除它。根据数据库和操作系统的不同，数据目录的位置也会有所不同。
确认卸载：完成上述步骤后，你可以通过运行以下命令来确认数据库是否已成功卸载：

mysql --version  # 替换为适用于你的数据库命令

如果返回类似 “command not found” 的消息，则表示数据库已成功卸载。

请注意，这些步骤仅适用于一般情况，具体步骤可能因数据库类型和操作系统而有所不同。在执行任何操作之前，请备份重要的数据库和数据。

安装数据库

要下载MySQL，请按照以下步骤操作：

打开您的Web浏览器，并前往MySQL官方网站（https://www.mysql.com）。
在MySQL官方网站主页上，点击菜单中的 “Downloads”（下载）。
在下载页面上，您会看到MySQL各个版本的列表。根据您的操作系统选择适当的版本。常见的操作系统如Windows、macOS和Linux都有对应的MySQL版本。
在选择版本后，向下滚动到相关产品部分。找到与您的操作系统匹配的下载选项，例如Windows MSI Installer或macOS DMG Archive。
单击相应的下载链接，将会跳转到另一个页面。
在新页面上，您需要登录或创建一个MySQL帐户。如果您已经拥有账户，请登录；否则，请点击 “Create An Account”（创建账户）进行注册。
完成登录或注册后，您将被引导到另一个页面，您可以选择下载的方式：MySQL Community Server（社区版）或MySQL Enterprise Edition（企业版）。通常情况下，选择社区版即可。
点击 “Download”（下载），将开始下载MySQL安装程序。
下载完成后，找到下载的安装程序文件，双击运行。
按照安装程序的指示进行安装。在安装过程中，您可以选择安装路径、配置数据库和设置管理员密码等选项。请按照提示逐步完成安装过程。
安装完成后，您可以通过开始菜单（Windows）或Launchpad（macOS）中的MySQL图标来启动MySQL服务器。
一旦MySQL服务器启动，您可以使用MySQL客户端工具（如MySQL Shell、MySQL Workbench）或命令行来管理和操作MySQL数据库。
下载成功后去文件夹下面测试一下(用户名假设是root).输入

mysql -u root -p 然后输入密码 123456,如果出现 mysql>

则安装成功.
配置环境变量,复制地址去环境变量-系统变量-新建(键是 MYSQL_HOME 值是文件夹地址)-编辑path(新建(%%\bin,然后中间添加一个MYSQL_HOME == %MYSQL_HOME%\bin))
最后去测试一下数据库是否配置成功.

数据库DOS操作

操作	命令
查看版本	mysql --version
登录mysql	mysql -u root -p
查看数据库	show databases;
进入数据库	use 数据库的名字;
查看库下面的表	show tables;
查询表内容	select * from 表名;
插入表中	insert into 表名 (列1, 列2, 列3, …) values (值1, 值2, 值3, …);
跟新表中数据	update 表名 set 列1 = 新值1, 列2 = 新值2 where 条件;
删除表中数据	delete from 表名 where 条件;

下载破解版navicat

Navicat是一种流行的数据库管理工具，它提供了许多功能和好处，使得数据库管理更加高效和便捷。以下是使用Navicat的一些主要好处：

多种数据库支持：Navicat支持各种常见的数据库系统，包括MySQL、SQL Server、Oracle、PostgreSQL等。这意味着您可以在一个工具中管理多个不同类型的数据库，而无需学习和使用多个单独的工具。
直观的用户界面：Navicat具有直观的用户界面，易于使用和导航。它采用了直观的图形化界面，使得执行各种数据库操作和管理任务变得更加简单和可视化。
数据库连接管理：Navicat提供了方便的数据库连接管理功能。您可以轻松添加、编辑和删除数据库连接，并保存连接信息以便日后快速使用。这使得在不同数据库之间切换和管理连接变得更加方便。
数据导入和导出：Navicat支持数据的导入和导出。您可以使用导入功能将数据从外部文件、其他数据库或备份文件导入到目标数据库中。同样，您也可以使用导出功能将数据导出为各种格式，如CSV、Excel、SQL脚本等。
数据库设计和建模：Navicat提供了强大的数据库设计和建模功能。您可以使用图形界面创建和编辑数据库对象（表、视图、存储过程等），并生成相应的SQL脚本。
SQL查询和脚本执行：Navicat提供了功能强大的SQL查询编辑器，可用于编写和执行复杂的SQL查询语句。它还支持批量执行SQL脚本，方便进行数据库操作和数据处理。
数据同步和备份：Navicat允许您轻松进行数据同步和备份操作。您可以比较和同步不同数据库之间的数据和结构差异，以确保数据的一致性。此外，您还可以创建数据库备份，并根据需要进行定期备份。

总而言之，Navicat作为一种强大的数据库管理工具，提供了许多方便和高效的功能，使得数据库管理和开发变得更加容易和高效。无论是开发人员、数据库管理员还是数据分析师，都可以从Navicat的各种特性和好处中受益。

idea连接数据库

在IntelliJ IDEA中连接数据库的步骤如下：

打开IntelliJ IDEA，并打开您的项目。
点击顶部菜单栏中的 “View”，然后选择 “Tool Windows”，再选择 “Database” （或者直接使用快捷键 Alt + F8），以打开 “Database” 工具窗口。
在 “Database” 工具窗口中，点击窗口右上角的 “+” 图标，选择 “Data Source”。
在弹出的对话框中，选择您要连接的数据库类型，比如MySQL、PostgreSQL、Oracle等，并点击 “Next”。
在新的对话框中，填写您的数据库连接信息，包括主机名（Host）、端口（Port）、数据库名称（Database）、用户名（User）和密码（Password）等。您可以点击 “Test Connection” 按钮来验证连接是否成功。
验证通过后，点击 “OK” 完成数据库连接配置。
IntelliJ IDEA将会在 “Database” 工具窗口中显示您连接的数据库，您可以展开数据库并浏览其表格、视图等对象。您还可以在代码中使用数据库相关的工具和功能。

Druid

Druid 是一个开源的高性能、可扩展的实时分析数据库。它最初由阿里巴巴集团开发，用于满足大规模数据实时查询和分析的需求。

以下是一些关键特性和功能：

实时处理：Druid 可以在毫秒级别内对大规模数据进行实时查询和分析，适用于需要快速反馈和实时决策的应用场景。
分布式架构：Druid 的分布式架构可以水平扩展，支持横向扩展并处理大规模数据集。它通过将数据划分为多个分片并在集群中进行并行处理，实现高吞吐量和低延迟。
多维数据模型：Druid 采用了多维数据模型，支持对多个维度进行灵活的分组、过滤和聚合操作。这使得用户可以轻松地进行复杂的查询和分析，从而发现数据中的模式和趋势。
高效存储：Druid 使用了列式存储和压缩算法，以最小化存储占用空间，并提高查询性能。它还支持数据分区和索引，以加速数据的读取和过滤。
实时数据摄入：Druid 提供了实时数据摄入的能力，可以接收来自各种数据源的实时流数据，并对其进行实时分析和查询。这使得用户可以及时了解并做出针对实时数据的决策。
SQL 查询支持：Druid 支持使用常见的 SQL 查询语言进行数据查询和分析。这使得已经熟悉 SQL 的开发人员能够轻松上手并快速进行数据探索。

url=jdbc:mysql://localhost:3306/数据库名字
username=你的账号
password=你的密码
driverClassName=com.mysql.cj.jdbc.Driver
initialSize=5
maxActive=20
minIdle=1
maxWait=60000

另外需要建一个实体类 Student

package com.MG_2.sql;


import com.MG.pojo.Student;
import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.List;
import java.util.Properties;

/**
 * @author MG
 * @date 2023/9/22 10:09
 * @今天一定要开心哦!
 * @description:
 * druid 连接需要导入 sql druid 和 dbutils 三个包
 */

public class DLY_Connect_Sql {
    public static void main(String[] args) throws Exception {
        查询方法一Method();
    }

    /**
     * 在外部创建一个sql.properties 里面内容固定写法
     * @return
     * @throws Exception
     */
    public static QueryRunner DruidPoole_Method() throws Exception {
        Properties properties = new Properties();
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("sql.properties"), "UTF-8"));
        properties.load(reader);
        DruidDataSource dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
        QueryRunner runner = new QueryRunner(dataSource);
        return runner;
    }

    public static void 查询方法一Method() throws Exception {
        QueryRunner runner = DruidPoole_Method();
        String Query_sql = "select * from student ";
        String Del_sql = "delete from student where id = 2";
        String Add_sql = "insert into student (name,id) values ('大花',2)";
        String Update_sql = "update  student set Name='小花' where ID=2";


        Student query1 = runner.query(Query_sql, new BeanHandler<>(Student.class));
        System.out.println("Druid 单条查询: " + query1);
        System.out.println("初始数据------");
        List<Student> query = runner.query(Query_sql, new BeanListHandler<>(Student.class));
        System.out.println("Druid 多条查询: " + query);

        runner.update(Del_sql);
        System.out.println("删除后的数据------");
        List<Student> query2 = runner.query(Query_sql, new BeanListHandler<>(Student.class));
        System.out.println("Druid 多条查询: " + query2);

        runner.update(Add_sql);
        System.out.println("添加后的数据------");
        List<Student> query3 = runner.query(Query_sql, new BeanListHandler<>(Student.class));
        System.out.println("Druid 多条查询: " + query3);

        runner.update(Update_sql);
        System.out.println("修改后的数据------");
        List<Student> query4 = runner.query(Query_sql, new BeanListHandler<>(Student.class));
        System.out.println("Druid 多条查询: " + query4);
    }
}

创建表

当创建新表时，您可以更详细地定义每个列的数据类型、约束和索引。以下是在关系型数据库中创建表时的详细步骤：

定义表名：
```
CREATE TABLE table_name (
...
);
```
在 CREATE TABLE 语句中，指定表的名称。
定义列：
```
CREATE TABLE table_name (
    column1 datatype constraint,
    column2 datatype constraint,
    ...
);
```
在 CREATE TABLE 语句中，按照列的顺序定义每个列的名称、数据类型和约束。例如，使用 column1 datatype constraint 的形式，其中 column1 是列名，datatype 是数据类型（如 INT、VARCHAR 等），constraint 是列的约束（如 PRIMARY KEY、NOT NULL 等）。
指定主键：
```
CREATE TABLE table_name (
    column1 datatype PRIMARY KEY,
    ...
);
```
您可以使用 PRIMARY KEY 约束将一列或多列定义为主键。主键是唯一标识表中每一行的列。通常情况下，主键的值是唯一且不可为空。
添加外键关联：
```
CREATE TABLE table_name1 (
    column1 datatype,
    ...
    FOREIGN KEY (column_name) REFERENCES table_name2(column_name)
);
```
使用 FOREIGN KEY 约束创建外键关联。外键关联在当前表中的一列引用了另一个表中的列。在 FOREIGN KEY 约束中，指定当前表的列和引用表的列之间的关系。
定义默认值：
```
CREATE TABLE table_name (
    column1 datatype DEFAULT default_value,
    ...
);
```
使用 DEFAULT 关键字为列指定默认值。如果插入新行时未提供具体值，将使用默认值代替。
指定约束：
```
CREATE TABLE table_name (
    column1 datatype CONSTRAINT constraint_name constraint_definition,
    ...
);
```
使用 CONSTRAINT 关键字为特定列定义自定义约束。约束可以是 NOT NULL（列不能为空）、UNIQUE（列的值必须唯一）或其他自定义约束。
创建索引：
```
CREATE TABLE table_name (
    column1 datatype,
    ...
    CONSTRAINT index_name UNIQUE (column_name)
);
```
使用 CONSTRAINT 关键字创建唯一性索引。索引可以提高查询性能，并确保某一列或多列的唯一性。
添加注释：
```
CREATE TABLE table_name (
    column1 datatype,
    ...
    COMMENT 'Your comment here'
);
```
使用 COMMENT 关键字为表添加注释。注释用于说明表、列或其他数据库对象的用途或特性。

添加

添加操作是向已创建的表中插入新的数据行。以下是详细的添加操作步骤：

使用 INSERT INTO 语句开始添加操作：
```
INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);
```
在 INSERT INTO 语句中，指定表名以及要插入数据的列名和对应的值。
指定要插入的列和对应的值：
```
INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);
```
在 INSERT INTO 语句中，指定要插入的列名，然后使用 VALUES 关键字指定对应的值。确保列名和值的数量、顺序和数据类型一致。
添加多个数据行：
```
INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...),
       (value1, value2, ...),
       ...;
```
您可以一次性插入多个数据行。在 VALUES 子句的括号中，以逗号分隔每个数据行的值。
插入查询结果：
```
INSERT INTO table_name (column1, column2, ...)
SELECT column1, column2, ...
FROM another_table
WHERE condition;
```
您还可以使用插入查询结果的方式向表中添加数据。在 INSERT INTO 语句中，指定要插入的列名，然后使用 SELECT 语句选择要插入的数据行。确保查询结果的列名、数量和数据类型与目标表的要求一致。

删除

删除操作是从表中删除数据行或整个表的操作。下面是详细的删除操作步骤：

删除整个表：
```
DROP TABLE table_name;
```
使用 DROP TABLE 语句可以完全删除一个表及其所有数据。请谨慎执行此操作，因为删除后将无法恢复。
删除特定行：
```
DELETE FROM table_name
WHERE condition;
```
使用 DELETE FROM 语句可以删除符合指定条件的数据行。在 WHERE 子句中，您可以根据需要指定要删除的行的条件。
删除所有行：
```
DELETE FROM table_name;
```
如果不提供任何条件，则 DELETE FROM 语句将删除表中的所有数据行。

请注意，删除操作是一个敏感且不可逆的操作，请在执行删除操作之前确保谨慎并备份重要数据。

修改

修改操作用于更新表中已存在的数据行。以下是详细的修改操作步骤：

使用 UPDATE 语句开始修改操作：
```
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;
```
在 UPDATE 语句中，指定要更新的表名。使用 SET 关键字指定要修改的列名和对应的新值。在 WHERE 子句中，指定要更新的数据行的条件。
更新特定行：
```
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;
```
使用 UPDATE 语句可以更新符合指定条件的数据行。在 WHERE 子句中，根据需要指定要更新的行的条件。
更新所有行：
```
UPDATE table_name
SET column1 = value1, column2 = value2, ...;
```
如果不提供任何条件，则 UPDATE 语句将更新表中的所有数据行。

请注意，在执行修改操作之前，请确保了解目标表的结构和数据类型，并谨慎选择要更新的数据行和新的值。

查询

查询操作用于从数据库表中检索数据。以下是详细的查询操作步骤：

查询语句

*	tableNmae	where tid is not null	order by acs正序 desc倒序
name,count(*)			group by name	having count(*)>3
distinct 去重	table1 a,table2 b	where
	XXx a 主表 left join xxx b on a.xxX= b.xXX;

使用 SELECT 语句开始查询操作：
```
SELECT column1, column2, ...
FROM table_name;
```
在 SELECT 语句中，指定要检索的列名。使用 FROM 关键字指定要查询的表名。
检索所有列：
```
SELECT *
FROM table_name;
```
如果要检索表中的所有列，可以使用 * 作为列名。
添加过滤条件：
```
SELECT column1, column2, ...
FROM table_name
WHERE condition;
```
使用 WHERE 子句可以添加条件来过滤查询结果。在条件中，您可以指定要检索的数据行的特定条件。
排序查询结果：
```
SELECT column1, column2, ...
FROM table_name
ORDER BY column1 ASC/DESC;
```
使用 ORDER BY 子句可以按照指定列的升序（ASC）或降序（DESC）对查询结果进行排序。
进行聚合函数操作：
```
SELECT aggregate_function(column)
FROM table_name;
```
使用聚合函数（如 COUNT、SUM、AVG、MAX、MIN 等）可以对查询结果进行计算和统计操作。
连接多个表：
```
SELECT column1, column2, ...
FROM table1
INNER JOIN table2
ON table1.column = table2.column;
```
如果数据库包含多个相关联的表，您可以使用连接操作（如 INNER JOIN、LEFT JOIN 等）根据共享的列将它们连接在一起。

数据库设计的三大范式

范式，就是规范，就是指设计数据库需要（应该）遵循的原则。

每个范式，都是用来规定某种结构或数据要求——后一范式都是在前一范式已经满足的情况用来“加强要求”（这句话很重要）。

原子性（存储的数据应该具有“不可再分性”）
唯一性 (消除非主键部分依赖联合主键中的部分字段)（一定要在第一范式已经满足的情况下）
独立性，消除传递依赖(非主键值不依赖于另一个非主键值)

MySQL驱动程序

在Java中，可以使用MySQL驱动程序来连接和操作MySQL数据库。MySQL提供了一个官方的JDBC驱动程序称为MySQL Connector/J，它是Java应用程序与MySQL数据库进行通信的标准方式。

MySQL Connector/J 是一个纯Java实现的MySQL JDBC驱动程序，可通过以下步骤使用：

下载驱动程序：首先，需要从MySQL官方网站下载合适版本的 MySQL Connector/J 驱动程序（JAR 文件）。可以在项目中添加该驱动程序。

搜索MySQL-connector-java下载windows https://downloads.mysql.com/archives/c-j/

Product Version:	8.0.33	选择版本
Operating System:	Platform Independent	选择Windows系统
Platform Independent(Architecture Independent), Compressed TAR Archive	下载	这个是linux版本
Platform Independent (Architecture lndependent),ZIP Archive	下载	这个是Windows版本

下载后得到 mysql-connector-j-8.0.33.jar
新建lib目录,与src同级,
将jar添加到lib中,点击右键添加到项目库中,成功后可以有个三角可以点开.
用代码直接连接数据库,然后操作数据库

加载驱动程序：在连接到MySQL数据库之前，需要将驱动程序加载到Java应用程序中。可以使用以下代码来加载驱动程序：
```
Class.forName("com.mysql.cj.jdbc.Driver");
```

建立数据库连接：使用以下代码创建与MySQL数据库的连接：

String url = "jdbc:mysql://localhost:3306/mydatabase";
String username = "root";
String password = "password";
Connection connection = DriverManager.getConnection(url, username, password);

执行数据库操作：一旦建立了数据库连接，就可以使用Connection对象执行各种数据库操作，例如查询、插入、更新等。

Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT * FROM mytable");
while (resultSet.next()) {
    // 处理结果集
}

关于MySQL关系，MySQL是一个关系型数据库管理系统（RDBMS），它基于关系模型存储和处理数据。在MySQL中，数据以表格（也称为关系）的形式组织，每个表包含多个行和列。

通过使用主键-外键关系，可以在MySQL中建立表之间的关系。主键是唯一标识表中每行的列，而外键是指向其他表中主键的列。这种关系可以用来实现数据之间的相关性和引用完整性。

通过SQL语句，可以创建表、定义列和数据类型、执行查询和操作数据，并使用关系进行数据连接和查询。MySQL提供了强大的功能和特性，使得可以在Java应用程序中使用关系型数据库进行灵活和高效的数据管理。

web

tomcat

下载

安装 Tomcat 可以按照以下步骤进行操作：

首先，访问 Apache Tomcat 的官方网站：https://tomcat.apache.org/
在主页上找到 “Download”（下载）选项，点击进入下载页面。
在下载页面上，你会看到一系列可供下载的 Tomcat 版本。选择适合你的操作系统和需求的版本进行下载，推荐下载最新版本。
下载完成后，解压缩下载的压缩文件。解压后的文件夹中包含了 Tomcat 的安装文件和目录结构。

接下来，根据你所使用的操作系统，执行相应的安装步骤：

对于 Windows 操作系统：

打开解压后的 Tomcat 文件夹，找到 “bin” 目录。
在 “bin” 目录中，双击运行 “startup.bat” 启动 Tomcat 服务器。
打开Web浏览器，输入 “http://localhost:8080” 来验证 Tomcat 是否成功安装并运行。如果能够访问到 Tomcat 的欢迎页面，则说明安装成功。

对于 Linux 或 macOS 操作系统：

打开终端或命令行界面，进入解压后的 Tomcat 文件夹。
在命令行中，执行 “./catalina.sh start” 命令来启动 Tomcat 服务器。
打开Web浏览器，输入 “http://localhost:8080” 来验证 Tomcat 是否成功安装并运行。如果能够访问到 Tomcat 的欢迎页面，则说明安装成功。

在成功启动 Tomcat 服务器后，你可以进一步配置和使用 Tomcat。例如，配置端口号、配置虚拟主机、部署 Web 应用程序等。你可以通过编辑 Tomcat 的配置文件来进行这些操作。

查看tomcat版本

D:\tomcat\apache-tomcat-8.5.91\bin>version.bat
Using CATALINA_BASE:   "D:\tomcat\apache-tomcat-8.5.91"
Using CATALINA_HOME:   "D:\tomcat\apache-tomcat-8.5.91"
Using CATALINA_TMPDIR: "D:\tomcat\apache-tomcat-8.5.91\temp"
Using JRE_HOME:        "D:\java\jdk.8.0"
Using CLASSPATH:       "D:\tomcat\apache-tomcat-8.5.91\bin\bootstrap.jar;D:\tomcat\apache-tomcat-8.5.91\bin\tomcat-juli.jar"
Using CATALINA_OPTS:   ""
Server version: Apache Tomcat/8.5.91
Server built:   Jul 6 2023 14:43:48 UTC
Server number:  8.5.91.0
OS Name:        Windows 10
OS Version:     10.0
Architecture:   amd64
JVM Version:    1.8.0_351-b10
JVM Vendor:     Oracle Corporation
D:\tomcat\apache-tomcat-8.5.91\bin>

配置

要配置 IntelliJ IDEA 来使用 Tomcat，可以按照以下步骤进行操作：

首先，确保你已经安装了 Tomcat，并且知道 Tomcat 的安装路径。
打开 IntelliJ IDEA，进入主界面。
点击顶部菜单栏中的 “File”（文件）选项，然后选择 “Settings”（设置）。
在左侧的面板中，找到并点击 “Build, Execution, Deployment”（构建、执行、部署）选项。
在右侧的面板中，选择 “Application Servers”（应用服务器）选项。
点击右上方的 “+” 按钮，添加一个新的应用服务器。
在弹出的对话框中，选择 “Tomcat Server”（Tomcat 服务器）作为服务器类型。
在 “Tomcat Home” 字段中，指定 Tomcat 的安装路径。点击 “OK” 完成配置。
返回主界面，点击顶部菜单栏中的 “Run”（运行）选项，然后选择 “Edit Configurations”（编辑配置）。
在左侧的面板中，选择 “Tomcat Server”。
点击右上方的 “+” 按钮，添加一个新的 Tomcat 配置。
在 “Server” 选项卡中，选择之前配置的 Tomcat 服务器。
在 “Deployment” 选项卡中，点击 “+” 按钮，选择要部署的项目或模块。
完成配置后，点击 “OK” 关闭对话框。

现在，你可以使用 IntelliJ IDEA 来启动、停止和调试 Tomcat 服务器，以及部署项目到 Tomcat 中运行了。你可以通过点击 “Run” 菜单中的 “Run ‘Tomcat Server’” 或 “Debug ‘Tomcat Server’” 来启动或调试 Tomcat 服务器。

web程序

在 IntelliJ IDEA 中创建 Web 程序，可以按照以下步骤进行操作：

打开 IntelliJ IDEA，并点击主界面上的 “Create New Project”（创建新项目）。
在弹出的对话框中，选择 “Java” 作为项目类型，并选择适合的项目模板，例如 “Java Enterprise” 或 “Java Web Application”。
输入项目的名称和项目存储路径，然后点击 “Next”（下一步）。
在 “Project SDK” 下拉菜单中，选择你希望使用的 Java SDK 版本。
在 “Additional Libraries and Frameworks”（附加库和框架）中，确保选中 “Web Application”（Web 应用程序）并点击 “Next”（下一步）。
在 “Server”（服务器）中，选择要使用的应用服务器（比如 Apache Tomcat）。如果还没有配置过服务器，请点击 “Configure”（配置）按钮进行服务器配置。
在 “Java EE Version”（Java EE 版本）中，选择适合你的需求的版本，并点击 “Next”（下一步）。
在 “Project Template”（项目模板）中，选择适合你的需求的模板。通常情况下，Servlet 和 JSP 是常见的 Web 开发组件选项。
点击 “Finish”（完成）来创建项目。
导入tomcat 依赖

web目录

webapp目录是Java Web应用程序的根目录，也被称为Web应用程序目录或Web应用程序根目录。它是一个约定的目录结构，用于存放Web应用程序的所有资源和文件。

在webapp目录中，通常会包含以下一些重要的子目录或文件：

WEB-INF目录：这是一个非常重要的目录，用于存放Web应用程序的配置文件和只能通过服务器端访问的资源。具体来说，WEB-INF目录中通常包含以下内容：
- web.xml文件：这是Web应用程序的部署描述符（Deployment Descriptor），用于配置Servlet、过滤器、监听器等组件、URL映射、请求处理等信息。
- classes目录：用于存放编译后的Java类文件。
- lib目录：用于存放依赖的库文件（JAR文件）。
静态资源目录：这个目录用于存放Web应用程序的静态资源文件，如HTML页面、CSS样式表、JavaScript脚本、图像文件等。这些文件可以直接从浏览器请求并返回给用户。
JSP目录：如果Web应用程序使用JSP（JavaServer Pages）来实现动态内容，那么JSP文件通常会放在这个目录中。
资源文件目录：这个目录用于存放Web应用程序的其他资源文件，如国际化（i18n）的语言资源文件、配置文件等。

总之，webapp目录是Java Web应用程序的主目录，包含了Web应用程序的各种资源和文件，包括静态资源、动态资源、配置文件等。具体的目录结构和内容可能会因不同的开发框架或服务器而有所差异，但上述介绍给出了一个常见的webapp目录结构的概览。

前后端页面跳转

	一.	//后端跳转前端	
	1.1	//重定向
		resp.sendRedirect("index.jsp"); 
	1.2	//转发
		//举一个例子,存储string-hello 到 request 对象中,向前端传递一个string-hello
        req.setAttribute("str","hello");
        req.setAttribute("ntables", ntables); // 存储到 request 对象中
        req.getRequestDispatcher("/ntables.jsp").forward(req, resp); // 转发到 JSP 页面

		req.getContextPath() 用于获取当前 Web 应用程序的上下文路径，并与 "/login.html" 结合，生成完整的登录页面的URL。
		因此，resp.sendRedirect(req.getContextPath() + "/login.html") 的作用是将客户端重定向到当前应用程序的登录页面。
	二.	//后端跳转后端
	  	resp.sendRedirect("ShowNtable");
	三.	//前端跳转前端
   		 <%--前端跳转前端,查询按钮跳转新页面--%>
          
          <%--前端跳转前端,添加按钮在当前页面跳转--%>
          
          
     四.  //前端跳后端
          通过表单提交
           
           @WebServlet("/login")
		  public class login extends HttpServlet {
		  <%--前端跳转后端,查询按钮跳转新页面--%>

解决乱码

1、在Java代码中指定编码格式
首先在Java代码中分别加上请求和响应时的编码格式，我这里指定的字符集是“UTF-8”。

//指定request请求时的字符编码格式
req.setCharacterEncoding("UTF-8");							
//设置response响应的字符编码格式
resp.setCharacterEncoding("UTF-8");						
//设置响应内容类型为 text/html(文本/超文本标记语言);文本编码为UTF-8
resp.setContentType("text/html'charset=UTF-8");

2、前端页面中出现的中文乱码

如果前端页面是 JSP 页面，这时需要指定编码格式与Java代码中的编码格式保持一致。找到顶部的<%@ page contentType=“text/html;charset=UTF-8” language=“java” %>设置编码格式。

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

如果是 HTML 页面，需要检查下里面的编码格式是否与Java代码中指定的编码格式一致（一般默认是utf-8）。

<meta charset="UTF-8">

3、往数据库中存数据时出现的中文乱码如果从页面上往数据库中存数据时出现了中文乱码，并且前两步都检查过了没啥问题，这时需要检查下数据库的编码格式与Java中的编码格式是否一致。首先输入命令查看数据库的字符编码，然后修改字符编码（数据库中的字符编码是‘utf8’格式，不是‘utf-8’，中间没有‘-’，这个一定要注意）

//在数据库中数据该代码，查看数据库的编码格式
show variables like ‘character_set_database’;
//修改数据库的字符编码位utf8格式
alter database hcwx character set utf8;

servlet

配置

3版本以下

在配置 Servlet 时，你需要完成以下几个步骤：

创建一个 Java 类来实现 Servlet 接口。这个类应该继承 HttpServlet 并重写其中的方法，如 doGet() 或 doPost() 方法，以处理客户端的请求和生成响应。

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

public class MyServlet extends HttpServlet {
   public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      // 你的代码在这里处理 GET 请求
   }

   public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      // 你的代码在这里处理 POST 请求
   }
}

在 web.xml 文件中配置 Servlet。在 web.xml 文件中添加 Servlet 的配置信息，包括 Servlet 名称、URL 映射和初始化参数等。

<web-app>
   <servlet>
      <servlet-name>MyServletservlet-name>
      <servlet-class>com.example.MyServletservlet-class>
   servlet>
   <servlet-mapping>
      <servlet-name>MyServletservlet-name>
      <url-pattern>/myservleturl-pattern>
   servlet-mapping>
web-app>

上述示例中，Servlet 的名称为 “MyServlet”，它的类是 “com.example.MyServlet”。“/myservlet” 是将请求映射到 Servlet 的 URL 路径。

部署 Web 应用程序。将编写好的 Servlet 类打包成 WAR 文件，并将其部署到 Java Web 服务器（如 Tomcat、Jetty 等）中。
启动 Web 服务器。启动 Web 服务器，并确保你的应用程序成功部署。
访问 Servlet。通过浏览器或其他客户端工具，访问配置的 URL 路径（例如：http://localhost:8080/yourwebapp/myservlet）即可触发 Servlet 的处理逻辑。

这些是使用传统的 web.xml 文件进行 Servlet 配置的步骤。

Servlet 3.0 及以上版本的配置步骤

以下是针对 Servlet 3.0 及以上版本的配置步骤：

创建一个 Java 类来实现 Servlet 接口。这个类应该继承 HttpServlet 并重写其中的方法，如 doGet() 或 doPost() 方法，以处理客户端的请求和生成响应。

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

@WebServlet("/myservlet")
public class MyServlet extends HttpServlet {

   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      // 你的代码在这里处理 GET 请求
   }

   protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
      // 你的代码在这里处理 POST 请求
   }
}

在这个示例中，我们使用了@WebServlet注解来指定Servlet的URL映射。

部署 Web 应用程序。将编写好的 Servlet 类打包成 WAR 文件，并将其部署到 Java Web 服务器（如 Tomcat、Jetty 等）中。
启动 Web 服务器。启动 Web 服务器，并确保你的应用程序成功部署。
访问 Servlet。通过浏览器或其他客户端工具，访问配置的 URL 路径（例如：http://localhost:8080/yourwebapp/myservlet）即可触发 Servlet 的处理逻辑。

上述步骤适用于 Servlet 3.0 及以上版本的容器。在较早的版本中，需要使用 web.xml 文件进行配置。如果你使用的是 Servlet 3.0 及以上版本的容器，推荐使用注解配置方式，它更加简洁和方便。

Httpservlet

HttpServlet 是 Java Servlet API 提供的一个抽象类，用于处理 HTTP 请求和响应。它是所有 Servlet 类的基类，开发者可以继承 HttpServlet 并重写其中的方法来实现自己的 Servlet。

下面是 HttpServlet 类中一些常用的方法：

doGet(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP GET 请求。开发者可以在这个方法中编写逻辑来处理客户端发起的 GET 请求，并生成相应的响应。
doPost(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP POST 请求。与 doGet 方法类似，你可以在这个方法中实现逻辑以处理客户端发起的 POST 请求。
doPut(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP PUT 请求。开发者可以在这个方法中编写逻辑来处理客户端发起的 PUT 请求。
doDelete(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP DELETE 请求。你可以在这个方法中实现逻辑以处理客户端发起的 DELETE 请求。
init(ServletConfig config): 在 Servlet 被初始化时调用的方法。你可以在这个方法中进行一些初始化操作，例如读取配置文件、建立数据库连接等。
destroy(): 在 Servlet 被销毁时调用的方法。你可以在这个方法中进行资源释放、清理等操作。

这些方法可以根据业务需求进行重写，以实现符合你应用程序逻辑的处理。当客户端发送相应的 HTTP 请求时，Servlet 容器将会调用适当的方法来处理请求。

request

通过该对象可以再一个请求中传递数据

作用范围：在一次请求中有效，即服务器跳转有效。

    //设置域对象内容
    request.setAttribute(String name, Object value);
    //获取域对象内容
    request.getAttribute(String name);
    //删除域对象内容
    request.removeAttribute(String name);

request 域对象中的数据在一次请求中有效，则经过请求转发， request 域中的数据依然存在，所以在请求转发的过程中可以通过request 来传输/共享数据。

响应数据

接收到客户端请求后，可以通过 HttpServletResponse 对象直接进行响应，响应时需要获取输出流。

有两种形式（两个不能同时使用）：

getWriter() : 获取字符流（只响应回字符）

getOutputStream() : 获取字节流（能响应一切数据）

响应回的数据到客户端被浏览器解析。

注：两个不能同时使用，否则会报错

转发 (Forward) 和重定向 (Redirect)

转发是指服务器端将请求转发给另一个 Servlet 或 JSP 页面进行处理，客户端并不知道请求已经被转发了。这种方式可以用于不同 Servlet 之间的数据传递，以及控制页面跳转流程。在 Servlet 中，可以使用 RequestDispatcher 接口的 forward() 方法来实现转发。具体使用方法如下：


RequestDispatcher dispatcher = request.getRequestDispatcher("目标路径");
dispatcher.forward(request, response);

其中，目标路径 指代将要接收请求的 Servlet 或 JSP 页面路径。

重定向是指服务器端返回一个特殊的 HTTP 响应，告诉客户端将请求重定向到另一个 URL 地址进行处理。客户端收到重定向响应后，会重新发起一个新的请求。这种方式可以用于处理用户的请求，例如登录成功后跳转到首页、处理非法访问等。在 Servlet 中，可以使用 HttpServletResponse 的 sendRedirect() 方法来实现重定向。具体使用方法如下：


response.sendRedirect("目标路径");

其中，目标路径 指代将要接收请求的 URL 地址。

需要注意的是，转发和重定向是两种不同的页面跳转方式，它们的使用场景和实现方式也有所不同。通常情况下，转发比重定向更高效，因为它可以避免浏览器发起多个请求。但在某些特定的场景下，如处理非法访问等，重定向是更为合适的选择。

HttpSession 对象

HttpSession 对象是用于在 Java Web 应用程序中跟踪用户会话状态的机制。它提供了一种在多个请求之间存储和检索数据的方式，可以用来存储特定用户的会话信息以及其他需要在整个会话期间保持的数据。

HttpSession 对象由 Servlet 容器在客户端与服务器之间建立的会话期间创建，并且为每个客户端唯一。通过使用会话标识符（也称为 Session ID），可以在不同的请求之间关联同一个会话。

以下是一些常见的 HttpSession 方法：

setAttribute(String name, Object value): 在会话中设置属性值。
getAttribute(String name): 获取会话中指定属性的值。
removeAttribute(String name): 从会话中移除指定属性。
getId(): 获取会话的唯一标识符（Session ID）。
isNew(): 判断会话是否是新创建的。
invalidate(): 使会话无效，从而终止该会话。

以下是一些使用 HttpSession 对象的示例：

// 创建或获取当前会话对象
HttpSession session = request.getSession();

// 设置会话属性值
session.setAttribute("username", "John");

// 获取会话属性值
String username = (String) session.getAttribute("username");

// 移除会话属性
session.removeAttribute("username");

// 获取会话的唯一标识符
String sessionId = session.getId();

// 判断会话是否是新创建的
boolean isNewSession = session.isNew();

// 终止会话
session.invalidate();

通过 HttpSession 对象，你可以在整个会话期间跟踪用户的状态和数据。常见的用途包括用户登录状态的管理、购物车的保存、用户首选项的存储等。

需要注意的是，默认情况下，HttpSession 对象的数据会被存储在服务器内存中，如果会话较多或数据较大，可能会对服务器的内存造成压力。可以使用分布式会话管理技术，如使用集群环境或将会话数据存储在数据库或缓存中，以提高性能和可伸缩性。

Cookie 对象

Cookie 是一种在客户端（浏览器）和服务器之间传递的小型文本文件。它可以用来存储有关用户的信息或状态，以实现会话跟踪和个性化网站体验等功能。

在 Java Web 开发中，可以使用 javax.servlet.http.Cookie 类来创建和管理 Cookie 对象。下面是 Cookie 类的一些常用方法和属性：

Cookie(String name, String value): 构造一个带有指定名称和值的 Cookie 对象。
setMaxAge(int maxAge): 设置 Cookie 的最大生命周期（以秒为单位）。当设置为负值时，表示该 Cookie 仅在当前会话有效。当设置为 0 时，表示该 Cookie 将立即过期并被删除。
getName(): 获取 Cookie 的名称。
getValue(): 获取 Cookie 的值。
setPath(String path): 设置 Cookie 的路径。默认情况下，Cookie 的路径为当前请求的上下文路径（Context Path）。
setDomain(String domain): 设置 Cookie 的域名。默认情况下，Cookie 的域名为当前请求的服务器地址。
setSecure(boolean secure): 设置 Cookie 是否仅在安全连接（HTTPS）下传输。
setHttpOnly(boolean httpOnly): 设置 Cookie 是否仅能通过 HTTP 协议访问，禁止 JavaScript 等客户端脚本访问。

可以使用以下代码示例创建一个 Cookie 对象并将其添加到响应中：

Cookie cookie = new Cookie("username", "john");
cookie.setMaxAge(3600);  // 设置 Cookie 的最大生命周期为 1 小时
response.addCookie(cookie);  // 将 Cookie 添加到响应中

要从请求中获取 Cookie，可以使用 HttpServletRequest 的 getCookies() 方法，该方法将返回一个 Cookie 数组。示例如下：

Cookie[] cookies = request.getCookies();
if (cookies != null) {
    for (Cookie cookie : cookies) {
        String name = cookie.getName();
        String value = cookie.getValue();
        // 处理 Cookie 数据...
    }
}

请注意，在处理 Cookie 时需要注意安全性和隐私性问题。存储敏感信息（如密码）或过多的用户信息在 Cookie 中是不安全的，并且可能违反隐私政策。

ServletContext 对象

ServletContext 对象是一个 Java Web 应用程序的上下文对象，代表整个 Web 应用程序，在应用程序启动时创建，贯穿整个 Web 应用程序生命周期。它提供了一种在 Web 应用程序中共享数据和资源的机制，能够提供一些全局的信息和功能。

ServletContext 对象是在 Servlet 容器启动 Web 应用程序时创建的，每个 Web 应用程序只有一个 ServletContext 对象实例。因此，ServletContext 对象可用于存储 Web 应用程序范围内的数据，如数据库连接池、配置信息等。

以下是一些常见的 ServletContext 方法：

getInitParameter(String paramName): 获取指定名称的上下文参数，可以在 web.xml 文件中定义。
getAttribute(String attrName): 从 ServletContext 中获取指定名称的属性值。
setAttribute(String attrName, Object attrValue): 向 ServletContext 中设置指定名称的属性值。
getRequestDispatcher(String path): 获得用于转发请求的 RequestDispatcher 对象。
getRealPath(String path): 将虚拟路径（例如 /index.html）转换为在服务器上的实际路径。
getContextPath(): 获取当前 Web 应用程序的上下文路径。
getResourceAsStream(String path): 返回与给定路径相对应的输入流，可以用来加载包含在 war 文件中的资源文件等。
log(String message): 记录指定消息到 ServletContext 的日志记录文件中。

以下是一些使用 ServletContext 对象的示例：

// 从 ServletContext 中获取数据库连接池对象
DataSource dataSource = (DataSource) getServletContext()
    .getAttribute("jdbc_datasource");

// 向 ServletContext 写入属性值
getServletContext().setAttribute("version", "1.0");

// 获取 RequestDispatcher 对象并转发请求
RequestDispatcher dispatcher = getServletContext()
    .getRequestDispatcher("/index.jsp");
dispatcher.forward(request, response);

// 获取资源文件的输入流
InputStream inputStream = getServletContext()
    .getResourceAsStream("/WEB-INF/config.properties");

需要注意的是，ServletContext 对象可以用来在整个 Web 应用程序中共享数据和资源，因此使用它要特别注意线程安全和同步问题。

文件上传和下载

文件上传和下载是 Web 应用程序中常见的功能之一。下面我将简要介绍文件上传和下载的基本概念和实现方式。

文件上传：
文件上传是指将本地计算机上的文件通过网页表单提交到服务器端的过程。通常，文件上传需要使用表单元素来选择并提交文件。在服务器端，可以使用各种编程语言和框架来处理文件上传，如 Java 中的 Servlet、JSP 或 Spring MVC 等。

文件上传的一般步骤如下：
- 在客户端网页中创建包含文件选择的表单。
- 客户端选择要上传的文件，并点击提交按钮。
- 服务器接收到请求，解析表单数据，提取上传的文件数据。
- 服务器将文件保存到指定位置，并进行相应的处理（例如读取文件内容、存储文件路径等）。
在 Java Web 应用程序中，可以使用 javax.servlet.http.Part 接口或 org.springframework.web.multipart.MultipartFile 类来处理文件上传。具体的实现方式会根据所使用的框架而有所不同。
文件下载：
文件下载是指从服务器端将文件发送给客户端，使客户端可以保存该文件到本地计算机。通常，文件下载需要提供一个文件下载链接或按钮，当客户端点击链接或按钮时，服务器将相应的文件发送给客户端浏览器。

文件下载的一般步骤如下：
- 在客户端网页中提供文件下载的链接或按钮。
- 客户端点击链接或按钮，发送下载请求到服务器。
- 服务器接收到下载请求，并根据请求的文件路径或标识符找到相应的文件。
- 服务器将文件以流的形式发送给客户端浏览器。
在 Java Web 应用程序中，可以使用 javax.servlet.ServletOutputStream 将文件内容写入响应输出流，或者使用框架提供的工具类来简化文件下载的实现。

需要注意的是，文件上传和下载都涉及到网络传输和文件操作，因此在实现过程中需要注意安全性、性能和可靠性等方面的考虑。

jsp

jsp指令标签

JSP（JavaServer Pages）指令标签用于在 JSP 页面中声明一些全局配置和指令。它们以 <%@ 开头，以 %> 结束。指令标签可以用于引入 Java 类、设置页面语言和编码、定义错误页面等。

以下是常见的 JSP 指令标签：

page 指令：用于设置页面的指令属性、导入类和包、设定缓冲区大小等。示例：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    import="com.example.*" buffer="8kb" %>

include 指令：用于在当前页面中包含其他文件的内容。示例：
```
<%@ include file="header.jsp" %>
```
taglib 指令：用于导入自定义标签库，以便在 JSP 页面中使用自定义标签。示例：
```
<%@ taglib prefix="mylib" uri="http://www.example.com/mylib" %>
```
tag 指令：用于定义标签文件以及其对应的处理类。示例：
```
<%@ tag description="My custom tag" pageEncoding="UTF-8" %>
```
directive 指令：可用于设置页面的编码、继承、会话管理等。示例：
```
<%@ directive pageEncoding="UTF-8" extends="javax.servlet.http.HttpServlet" %>
```

这些指令标签使得 JSP 页面可以具有更高的灵活性和可配置性，能够在页面级别上设置一些共享的属性和配置。

需要注意的是，JSP 指令标签只能在 JSP 页面中使用，而不能在 Java 类中使用。它们用于在 JSP 编译阶段进行指令处理，并最终生成对应的 Servlet 类。

jsp四大域对象

JSP（JavaServer Pages）提供了四个域对象，用于在不同的范围内存储和共享数据。这四个域对象分别为：page、request、session 和 application。

page 域（Page Context）：表示当前页面的上下文信息，只在当前页面内有效。在 JSP 页面中，可以使用 pageContext 对象来访问 page 域。
request 域（Request Context）：表示客户端发送的 HTTP 请求信息，可以在同一次请求的多个页面中共享数据。在 JSP 页面中，可以使用 request 对象来访问 request 域。
session 域（Session Context）：表示用户会话信息，由服务器创建并管理，可以在整个会话期间共享数据。在 JSP 页面中，可以使用 session 对象来访问 session 域。
application 域（Application Context）：表示 Web 应用程序的全局信息，可以在整个应用程序范围内共享数据。在 JSP 页面中，可以使用 application 对象来访问 application 域。

以下是一些示例代码，展示如何在 JSP 页面中使用四大域对象：

使用 page 域对象：

<%
    pageContext.setAttribute("name", "John");

    String name = (String) pageContext.getAttribute("name");
    out.println(name); // 输出 John
%>

使用 request 域对象：

<%
    request.setAttribute("age", 25);

    int age = (int) request.getAttribute("age");
    out.println(age); // 输出 25
%>

使用 session 域对象：

<%
    session.setAttribute("username", "Alice");

    String username = (String) session.getAttribute("username");
    out.println(username); // 输出 Alice
%>

使用 application 域对象：

<%
    application.setAttribute("count", 10);

    int count = (int) application.getAttribute("count");
    out.println(count); // 输出 10
%>

需要注意的是，对于每个域对象，都提供了相应的 getAttribute、setAttribute 和 removeAttribute 方法，用于存储、获取和删除属性。同时，属性值可以是任意类型的 Java 对象。

EL表达式的使用

EL（Expression Language）是一种用于在 JSP 和 JSF 页面中嵌入和访问表达式的简洁语言。EL 提供了一种轻量级的方式来访问 JavaBean 属性、数组、集合等数据结构，并在页面上进行展示和操作。

以下是 EL 表达式的一些常见用法：

访问属性：
EL 可以通过 ${} 语法来访问 JavaBean 的属性。例如，${user.name} 可以获取名为 “user” 的 JavaBean 对象的 name 属性值。
访问集合和数组元素：
EL 可以通过 ${} 语法访问集合和数组的元素。例如，${myArray[0]} 可以获取名为 “myArray” 的数组的第一个元素。
调用方法：
EL 支持调用 JavaBean 的方法，并获取方法的返回值。例如，${user.getName()} 可以调用名为 “user” 的 JavaBean 对象的 getName 方法。
条件判断：
EL 支持条件判断表达式，例如 ${age > 18} 可以判断变量 age 是否大于 18。
集合和数组操作：
EL 提供了一些操作符来处理集合和数组，例如 ${names.length()} 可以获取集合或数组的长度，${names.isEmpty()} 可以判断集合或数组是否为空。
空值处理：
EL 提供了一些特殊的操作符来处理空值，例如 ${user?.name} 可以安全地获取名为 “user” 的 JavaBean 对象的 name 属性，即使 user 是 null。
字符串拼接：
EL 支持字符串拼接操作符 +，例如 ${user.firstName + ' ' + user.lastName} 可以将名为 “user” 的 JavaBean 对象的 firstName 和 lastName 属性拼接成一个字符串。

EL 表达式可以在 JSP 页面中的标签、属性值、文本内容等位置使用，用于动态地获取和展示数据。通过使用 EL，可以简化 JSP 页面中的 Java 代码，并提高页面的可读性和可维护性。

JSTL

标签库的介绍和使用

JSTL（JavaServer Pages Standard Tag Library）是一个为了简化和增强 JSP 页面开发的标签库。它提供了一组标签和函数，用于处理控制流、迭代、格式化数据、访问数据库等常见的页面处理任务，减少了在 JSP 页面中编写繁琐的 Java 代码的需求。

以下是 JSTL 的几个主要标签库：

Core 标签库：包含了一些基本的控制流和变量操作的标签。
- ：条件判断标签，用于根据表达式的结果来决定是否输出某个内容。
- 、、：类似于 Java 中的 switch-case 结构。
- ：迭代标签，用于遍历集合、数组等数据结构。
- ：设置变量值的标签。
Formatting 标签库：用于格式化数据的标签库，可以格式化日期、时间、数字等。
- ：格式化日期。
- ：格式化数字。
- ：解析数字。
SQL 标签库：用于与数据库进行交互的标签库。
- ：设置数据库连接信息。
- ：执行 SQL 查询。
- ：执行 SQL 更新。
XML 标签库：用于处理 XML 数据的标签库。
- ：解析 XML。
- ：迭代 XML 元素。

下面是一个使用 JSTL 的示例：

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



  JSTL Example


  
  
  
    Hello, ${name}!
  
  
  

  
  
  Current time: ${formattedDate}

在上面的示例中，首先使用设置了一个名为 “name” 的变量，然后使用判断这个变量是否等于 “John”，如果条件成立，则输出 “Hello, John!”。接着使用标签将当前时间格式化为指定的模式，并将结果存储在 “formattedDate” 变量中，最后在页面上展示出来。

要使用 JSTL 标签库，需要在 JSP 页面的开头添加相应的标签库声明（taglib directive），并引入对应的 URI。

常用标签

当涉及到常用的 JSTL 标签库时，以下是更详细的说明：

Core 标签库（）：
- ：根据表达式的结果来决定是否输出某个内容。示例：...
- ：迭代标签，用于遍历集合、数组等数据结构。示例：...
- ：设置变量值的标签。示例：
- 、、：类似于 Java 中的 switch-case 结构，根据条件选择不同的分支。示例：
```
  ...
  ...
  ...
```
Formatting 标签库（）：
- ：用于格式化日期。示例：
- ：用于格式化数字。示例：
- ：用于解析数字。示例：
SQL 标签库（）：
- ：设置数据库连接信息。示例：
- ：执行 SQL 查询。示例：${sql}
- ：执行 SQL 更新。示例：${sql}
XML 标签库（）：
- ：解析 XML。示例：
- ：迭代 XML 元素。示例：...

以上示例中的 ${...} 表示表达式语言（EL），用于在 JSP 中引用变量、表达式或调用方法。

这些标签库提供了丰富的功能，可以帮助简化和增强 JSP 页面的开发。你可以根据具体需求选择适合的标签库和标签来使用。

前端页面输出集合数据

由后端ShowNtable 转发页面到NtableAll

在INF的lib下添加jstl和stabdard jar包

<%--引入jstl和stabdard jar包,用于前端页面实现循环查询功能--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

NtableAll 进行循环遍历输出

<%--    items:要遍历的集合或者数组(empList就是List集合)
    var:表示遍历项(emp就是一个员工对象)
    获取对象的属性值:对象名.属性名(但是一定要保证对象有getXXX方法)
    --%>
    
        
            ${tab.nname}
            ${tab.nage}
            ${tab.nid}

4.1后端代码

	@WebServlet("/ShowNtables")
	//后端查询数据后,由前端渲染
	public class ShowNtable extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        resp.setCharacterEncoding("UTF-8");
        //
        resp.setContentType("text/html;charset=UTF-8");
        Ntable ntable = new NtableImpl();
        try {
            List ntables = ntable.SelectAllNtable();
            //3、做出响应(未来我们是要将这个集合中的数据，转换json格式，由前端负责数据的渲染)
            // 3、做出响应(将数数据保存到域对象中，转发到jsp)
            req.setAttribute(   "ntables" , ntables);
            //转发到empAll.jsp页面
            req.getRequestDispatcher(  "/NtableAll.jsp" ).forward(req,resp);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
	}

4.2前端代码

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入jstl和stabdard jar包,用于前端页面实现循环查询功能--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>


    Title


<%--  ${ntables}--%>

    <%--
    items:要遍历的集合或者数组(empList就是List集合)
    var:表示遍历项(emp就是一个员工对象)
    获取对象的属性值:对象名.属性名(但是一定要保证对象有getXXX方法)
    --%>
    
        
    
        账号
        密码
        ID
    

            ${tab.nname}
            ${tab.nage}
            ${tab.nid}

账号	密码	ID
${tab.nname}	${tab.nage}	${tab.nid}

后端service层功能实现

建表,注意主键自动递增
添加lib mysql-connector-j 添加库
创建pojo目录,添加表对应的实体类

封装数据连接

  /*  $方法的内容$
        创建数据库1.下载jar
                2.配置驱动(ulr,name,password)
                3.得到数据库对象
     */
    public Statement creatmysql() throws ClassNotFoundException, SQLException {
//        加载数据库驱动的语句
        Class.forName("com.mysql.cj.jdbc.Driver");
        //用户名信息和url
        String url = "jdbc:mysql://localhost:3306/sjk1?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
        String username = "root";
        String password = "123456";
        //连接成功
        Connection connection = DriverManager.getConnection(url, username, password);
        Statement statement = connection.createStatement();
        if (connection != null) {
            return statement;
        } else {
            System.out.println("数据库为空");
            return null;
        }
    }

创建dao目录,先写接口

public interface QFtable {
    List SelectAllQFtables () throws SQLException, ClassNotFoundException;
    List SelectOneQFtables(QFtables qFtables) throws SQLException, 		ClassNotFoundException;
    int AddQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException;
    int DelQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException;
    int UpdateQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException;
}

在dao下面建一个Implml,里面写具体的实现方法

public class QFtableImpl implements QFtable {
    @Override
    public List SelectAllQFtables() throws SQLException, ClassNotFoundException {
        //连接数据库
        ContectSql contectSql = new ContectSql();
        Statement statement = contectSql.creatmysql();
        //sql语句
        String select_from = "select * from qf";
        //运行
        ResultSet resultSet = statement.executeQuery(select_from);
        //封装sql
        List r = new ArrayList<>();
        while (resultSet.next()) {
            QFtables qFtables = new QFtables();
            qFtables.setId((Integer) resultSet.getObject("id"));
            qFtables.setPhoneNumber((String) resultSet.getObject("PhoneNumber"));
            qFtables.setName((String) resultSet.getObject("name"));
            qFtables.setAddress((String) resultSet.getObject("address"));
            qFtables.setSex((String) resultSet.getObject("sex"));
            qFtables.setHobby((String) resultSet.getObject("hobby"));
            r.add(qFtables);
        }
        return r;
    }

    @Override
    public List SelectOneQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        //连接数据库
        ContectSql contectSql = new ContectSql();
        Statement statement = contectSql.creatmysql();
        //取值

        //编写sql语句
        String str = "select * from qf where id =" + qFtables.getId();
        //运行
        ResultSet resultSet1 = statement.executeQuery(str);
        //封装sql
        List r = new ArrayList<>();
        while (resultSet1.next()) {
            QFtables qFtables1 = new QFtables();
            qFtables1.setId((Integer) resultSet1.getObject("id"));
            qFtables1.setPhoneNumber((String) resultSet1.getObject("PhoneNumber"));
            qFtables1.setName((String) resultSet1.getObject("name"));
            qFtables1.setAddress((String) resultSet1.getObject("address"));
            qFtables1.setSex((String) resultSet1.getObject("sex"));
            qFtables1.setHobby((String) resultSet1.getObject("hobby"));
            r.add(qFtables1);
        }
        statement.close();
        return r;
    }

    @Override
    public int AddQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        //连接数据库
        ContectSql contectSql = new ContectSql();
        Statement statement = contectSql.creatmysql();
        //取值
        //编写sql语句
        String str1 = "insert into  qf set id = "
                + qFtables.getId()
                + " , PhoneNumber = '"
                + qFtables.getPhoneNumber() + "' , name = '" + qFtables.getName()
                + "' ,address = '" + qFtables.getAddress() + "' , sex = '"
                + qFtables.getSex() + "' , hobby = '"
                + qFtables.getHobby() + "'";
        //运行
        int i = statement.executeUpdate(str1);
        // 关闭连接
        statement.close();
        return 1;
    }

    @Override
    public int DelQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        //连接数据库
        ContectSql contectSql = new ContectSql();
        Statement statement = contectSql.creatmysql();
        //编写sql语句
        String str1 = "delete from qf WHERE id = " + qFtables.getId();
        int i = statement.executeUpdate(str1);
        return i;
    }

    @Override
    public int UpdateQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        //连接数据库
        ContectSql contectSql = new ContectSql();
        Statement statement = contectSql.creatmysql();
        //编写sql语句
        String str1 = "update  qf set PhoneNumber = '"
                + qFtables.getPhoneNumber() + "' , name = '" + qFtables.getName()
                + "' ,address = '" + qFtables.getAddress() + "' , sex = '"
                + qFtables.getSex() + "' , hobby = '"
                + qFtables.getHobby() + "' where id = " + qFtables.getId();
        int i = statement.executeUpdate(str1);
        return i;
    }
}

写一个service目录,创建一个Test类,封装接口和接口实现类的方法

public class TestQFtable {

    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        TestQFtable testQFtable = new TestQFtable();
        // testQFtable.selectALLQF();
        //testQFtable.打印selectALLQF(testQFtable.SelectAllQFtable());
        //testQFtable.打印selectALLQF(testQFtable.SelectOneQFtables(new QFtables(2)));
        // testQFtable.AddQFtables(new QFtables("子豪",2,"15582434055","1","1","1"));
        //testQFtable.DelQFtables(new QFtables(2));
        //testQFtable.UpdateQFtables(new QFtables("张子豪",2,"15582434055","1","1","1"));
    }
    //传入一个查询的结果集合,实现打印结果功能
    public void 打印selectALLQF(List qFtables) throws SQLException, ClassNotFoundException {
        TestQFtable testQFtable = new TestQFtable();
        //new QFtable("子豪",1,"15582434055","1","1","1")


        // 循环遍历并输出列表中的元素
        for (QFtables qftables : qFtables) {
            System.out.println("name: " + qftables.getName());
            System.out.println("id: " + qftables.getId());
            System.out.println("PhoneNumber: " + qftables.getPhoneNumber());
            System.out.println("性别: " + qftables.getSex());
            System.out.println("爱好: " + qftables.getHobby());
            System.out.println("地址: " + qftables.getAddress());
            System.out.println("-------------------------");
        }
    }
    //封装查询功能
    List SelectAllQFtable() throws SQLException, ClassNotFoundException {
        QFtable qFtables = new QFtableImpl();
        List qFtables1 = qFtables.SelectAllQFtables();
        return qFtables1;
    }
    //封装单独查询功能
    List SelectOneQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        QFtable qFtables1 = new QFtableImpl();
        List qFtables2 = qFtables1.SelectOneQFtables(qFtables);
        return qFtables2;
    }
    //添加功能
    public int AddQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        QFtable qFtable = new QFtableImpl();
        int i = qFtable.AddQFtables(qFtables);
        return i;
    }
    //删除功能
    public int DelQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        QFtable qFtable = new QFtableImpl();
        int i = qFtable.DelQFtables(qFtables);
        return i;
    }
    //修改功能
    public int UpdateQFtables(QFtables qFtables) throws SQLException, ClassNotFoundException {
        QFtable qFtable = new QFtableImpl();
        int i = qFtable.UpdateQFtables(qFtables);
        return i;
    }

}

前端页面输出集合数据

添加依赖,确保可以循环输出数据渲染前端页面

 
    
    
      javax.servlet.jsp.jstl
      jstl-api
      1.2-rev-1
    
    
      javax.servlet
      jstl
      1.2
    

    
    
      javax.el
      javax.el-api
      3.0.0

由后端ShowNtable 转发页面到NtableAll

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

        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        TestNtbale testNtbale=new TestNtbale();
        List ntables = testNtbale.selectNatable();
        //循环查看集合内容
        for (int i = 0; i < ntables.size(); i++) {
            Ntables ntable = ntables.get(i);
            System.out.println("Name: " + ntable.getNname());
            System.out.println("Age: " + ntable.getNage());
            System.out.println("ID: " + ntable.getNid());
            System.out.println("------------------------");
        }
        //举一个例子,存储string-hello 到 request 对象中,向前端传递一个string-hello
        req.setAttribute("str","hello");
        req.setAttribute("ntables", ntables); // 存储到 request 对象中
        req.getRequestDispatcher("/ntables.jsp").forward(req, resp); // 转发到 JSP 页面


    }
	}

在 JSP 文件中添加正确的标签库声明

<%--在 JSP 页面的指令中设置页面的内容类型和字符编码,告诉浏览器以何种方式解析和显示 JSP 页面的内容。--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%--可以在页面上使用格式化标签来对数据进行格式化和本地化。--%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%--可以在页面上使用核心标签来实现循环、条件判断、变量设置等功能。--%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%--确保在 JSP 文件的开头添加以下内容以启用 EL：--%>
<%@ page isELIgnored="false" %>



  <%--指定页面的字符编码。它告诉浏览器使用 UTF-8 编码来解析和显示页面的内容--%>
  
  Ntables


Ntables

    

<%--
  从后端接收到的字符串数据：${str}
从后端接收到的数据：<%= request.getAttribute("str") %>
--%>


  
    Name
    Age
    ID

  

  
      ${table.nname}
      ${table.nage}
      ${table.nid}

Name	Age	ID
${table.nname}	${table.nage}	${table.nid}

业务逻辑实现

1.前端from发送登录信息到Logn类


    Username:
    


    Password:

2.login类验证信息

 	@WebServlet("/login")
	public class login extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

      resp.getWriter().println("hello my name is houduan!");
        String username = req.getParameter("username");
        String password = req.getParameter("password");

        // 验证用户名和密码
        if (isValidCredentials(username, password)) {
            // 登录成功
            resp.sendRedirect("menu.jsp");
        } else {
            // 登录失败
            resp.sendRedirect("login.jsp?error=true");
        }
    }
    private boolean isValidCredentials(String username, String password) {
        // 模拟用户名和密码验证
        // 这里只是一个示例，需要根据实际情况进行验证逻辑的实现
        // 用户名为 admin，密码为 password 才是有效的凭据
        return "admin".equals(username) && "password".equals(password);
    }
 	}

3.登录成功后转到menu.jsp



    管理系统


    
        用户管理
        用户管理2

4.menu.jsp可以跳转前端也可以跳转后端,

转到用户管理功能

(4.1) 从test表中查询结果集合渲染到前端页面

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

        req.setCharacterEncoding("UTF-8");
        resp.setCharacterEncoding("UTF-8");
        TestNtbale testNtbale=new TestNtbale();
        List ntables = testNtbale.selectNatable();
        //循环查看集合内容
        for (int i = 0; i < ntables.size(); i++) {
            Ntables ntable = ntables.get(i);
            System.out.println("Name: " + ntable.getNname());
            System.out.println("Age: " + ntable.getNage());
            System.out.println("ID: " + ntable.getNid());
            System.out.println("------------------------");
        }
        //举一个例子,存储string-hello 到 request 对象中,向前端传递一个string-hello
        req.setAttribute("str","hello");
        req.setAttribute("ntables", ntables); // 存储到 request 对象中
        req.getRequestDispatcher("/ntables.jsp").forward(req, resp); // 转发到 JSP 页面
        
    }
}

(4.2) 前端页面展示结果集合

	<%-- 前端页面实现删除和修改以及添加表单功能--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page isELIgnored="false" %>




  
  Ntables
  


用户管理

    
  
    账号
    密码
    ID
    删除
    修改
  
  
      ${table.nname}
      ${table.nage}
      ${table.nid}
      
      
    
  

<%--添加表单--%>

  Username:
  


  Password:

账号	密码	ID	删除	修改
${table.nname}	${table.nage}	${table.nid}

(4.3) 删除功能实现

	@WebServlet("/DelNtable")
	public class DelNtable extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取数据
        int nid = Integer.parseInt(req.getParameter("id"));
        TestNtbale testNtbale=new TestNtbale();
        testNtbale.DeleteNatable(nid);
        resp.sendRedirect("ShowNtable");
    }
	}

(4.4) 添加功能需要判断

@WebServlet("/AddNtable")
public class AddNtable extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        //获取数据
        String username = req.getParameter("username");
        int password = Integer.parseInt(req.getParameter("password"));
        //封装数据
        TestNtbale testNtbale=new TestNtbale();
        Ntables ntables=new Ntables();
        ntables.setNname(username);
        ntables.setNage(password);
        //查询数据在不在数据表中

        Ntables ntables1 = testNtbale.selectNatableName(ntables);
        System.out.println(ntables);
        System.out.println(ntables1);
        if(ntables1!=null){
            //已经存在数据,添加失败,返回响应页面
            resp.sendRedirect("ShowNtable");
        }else{

            testNtbale.addNatable(ntables);
            //已经存在数据,添加失败,返回响应页面
            resp.sendRedirect("ShowNtable");
        }


    }
}

(4.5) 修改功能需要拿到id到后端查询,然后转发到前端页面填写表单,最后修改数据

//一. 先查询id
@WebServlet("/SelectOneNtable")
public class SelectOneNtable extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int Id = Integer.parseInt(req.getParameter("id"));
        TestNtbale testNtbale=new TestNtbale();
        Ntables ntables = testNtbale.selectNatableId(new Ntables(Id));
        //做出响应
        if(ntables==null){
            System.out.println("此用户不存在");
            resp.sendRedirect("ShowNtable");
        }else{
            //将数据保存到域对象,转发到前端页面
            req.setAttribute("NtableID",Id);
            System.out.println("传入的id是 "+Id);
            req.getRequestDispatcher("/UpdateNtable.jsp").forward(req,resp);
        }
    }
}

<%--填写表单
--%>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--确保在 JSP 文件的开头添加以下内容以启用 EL：--%>
<%@ page isELIgnored="false" %>


    Title



    <%--取到修改的并且存在的id,取到从后端传来的数据,并且传给后端进行添加操作--%>
    
    Username:
    


    Password:

	//修改数据操作
	@WebServlet("/UpdateNtable")
	public class UpdateNtable extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获取数据
        int ntableID = Integer.parseInt(req.getParameter("NtableID"));
        String username = req.getParameter("username");
        int password = Integer.parseInt(req.getParameter("password"));
        System.out.println(ntableID+""+username+""+password);
        //封装数据
        TestNtbale testNtbale=new TestNtbale();
        Ntables ntables=new Ntables();
        ntables.setNname(username);
        ntables.setNage(password);
        ntables.setNid(ntableID);
        System.out.println("接收到新前端传入的要修改的数据"+ntables);
        //查询数据在不在数据表中

        Ntables ntables1 = testNtbale.selectNatableName(ntables);
        System.out.println(ntables);
        System.out.println(ntables1);
        if(ntables1!=null){
            //已经存在数据,添加失败,返回响应页面
            req.setAttribute("NtableID",ntableID);
            System.out.println("传入的id是 "+ntableID);
            req.getRequestDispatcher("/UpdateNtable.jsp").forward(req,resp);
        }else{
            //修改数据
            testNtbale.UpdateNatable(ntables);
            //做出响应
            resp.sendRedirect("ShowNtable");
        }
    }
    }

java连接数据库和web实现增删改查

public void CreatSql() throws ClassNotFoundException, SQLException {

//        加载数据库驱动的语句
    Class.forName("com.mysql.cj.jdbc.Driver");
    //用户名信息和url
    String url="jdbc:mysql://localhost:3306/sjk1?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
    String username="root";
    String password="123456";
    //连接成功
    Connection connection  = DriverManager.getConnection(url, username, password);
    //数据库对象创建sql对象
    Statement statement = connection.createStatement();
    //执行数据库的对象
    String str = "SELECT * FROM ntable ";
    ResultSet resultSet = statement.executeQuery(str);
    while (resultSet.next()){
        System.out.println(resultSet.getObject("nname"));
        System.out.println(resultSet.getObject("nid"));
        System.out.println(resultSet.getObject("nage"));
    }
}

外面的lib 需要添加 servlet.jar              mysql-connect .jar
web的lib 需要添加 servlet.jar              mysql-connect .jar               jstl.jsr                standard.jar
------------------------------------------------------util-----------------------------------------------------
   /*   public static void main(String[] args) throws SQLException, ClassNotFoundException {
             ContectSql a=new ContectSql();
             a.CreatSql();
         }*/
    public Statement CreatSql() throws ClassNotFoundException, SQLException {

//        加载数据库驱动的语句
        Class.forName("com.mysql.cj.jdbc.Driver");
        //用户名信息和url
        String url = "jdbc:mysql://localhost:3306/sjk1?useUnicode=true&characterEncoding=UTF-8&userSSL=false&serverTimezone=GMT%2B8";
        String username = "root";
        String password = "123456";
        //连接成功
        Connection connection = DriverManager.getConnection(url, username, password);
        //数据库对象创建sql对象
        Statement statement = connection.createStatement();
        //执行数据库的对象
       /* String str = "SELECT * FROM ntable ";
        ResultSet resultSet = statement.executeQuery(str);
        while (resultSet.next()){
            System.out.println(resultSet.getObject("nname"));
            System.out.println(resultSet.getObject("nid"));
            System.out.println(resultSet.getObject("nage"));
        }*/
        return statement;
    }

------------------------------------------------------Bean - Students -----------------------------------------------------

//只有实现了serializable接口的类的对象才能被实例化。
public class Students implements Serializable {
    private int students_id;
    private String students_name;
    private String gender;
    private int age;
    private String phone_number;
    private String address;
    private String students_class;

 public Students() {

 }

 public Students(int students_id, String students_name, String gender, int age, String phone_number, String address, String students_class) {
  this.students_id = students_id;
  this.students_name = students_name;
  this.gender = gender;
  this.age = age;
  this.phone_number = phone_number;
  this.address = address;
  this.students_class = students_class;
 }

 public Students( String students_name, String gender, int age, String phone_number, String address, String students_class) {

  this.students_name = students_name;
  this.gender = gender;
  this.age = age;
  this.phone_number = phone_number;
  this.address = address;
  this.students_class = students_class;
 }

    @Override
 public String toString() {
  return "Students{" +
          "students_id=" + students_id +
          ", students_name='" + students_name + '\'' +
          ", gender='" + gender + '\'' +
          ", age=" + age +
          ", phone_number='" + phone_number + '\'' +
          ", address='" + address + '\'' +
          ", students_class='" + students_class + '\'' +
          '}';
 }

 public int getStudents_id() {
  return students_id;
 }

 public void setStudents_id(int students_id) {
  this.students_id = students_id;
 }

 public String getStudents_name() {
  return students_name;
 }

 public void setStudents_name(String students_name) {
  this.students_name = students_name;
 }

 public String getGender() {
  return gender;
 }

 public void setGender(String gender) {
  this.gender = gender;
 }

 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public String getPhone_number() {
  return phone_number;
 }

 public void setPhone_number(String phone_number) {
  this.phone_number = phone_number;
 }

 public String getAddress() {
  return address;
 }

 public void setAddress(String address) {
  this.address = address;
 }

 public String getStudents_class() {
  return students_class;
 }

 public void setStudents_class(String students_class) {
  this.students_class = students_class;
 }
}
------------------------------------------------------IStudentDao -----------------------------------------------------
public interface IStudentDao {
    //按名字模糊查询
    List<Students> selectAllStudentsName(String Name) throws SQLException, ClassNotFoundException;

    List<Students> selectAllStudents() throws SQLException, ClassNotFoundException;
    int addStudents(Students students) throws SQLException, ClassNotFoundException;
    int updateStudents(Students students) throws SQLException, ClassNotFoundException;
    int delStudents(int i) throws SQLException, ClassNotFoundException;
}

------------------------------------------------------StudentDaoImpl -----------------------------------------------------

public class StudentsDaoImpl implements IStudentDao {
    @Override
    public List<Students> selectAllStudentsName(String Name) throws SQLException, ClassNotFoundException {
        //connect sql
        CreateSql sql = new CreateSql();
        Statement statement = sql.CreatSql();
        //编写str
        String sqlStr = " select * from students where students_name Like '%"+ Name +"%'";
        ResultSet result = statement.executeQuery(sqlStr);
        List<Students> list = new ArrayList<>();
        while (result.next()) {
            Students stu = new Students();
            stu.setStudents_id((Integer) result.getObject("students_id"));
            stu.setStudents_name((String) result.getObject("students_name"));
            stu.setGender((String) result.getObject("gender"));
            stu.setAge((Integer) result.getObject("age"));
            stu.setPhone_number((String) result.getObject("phone_number"));
            stu.setAddress((String) result.getObject("address"));
            stu.setStudents_class((String) result.getObject("students_class"));
            list.add(stu);
        }
        // 关闭数据库连接
        statement.close();
        return list;

    }

    @Override
    public List<Students> selectAllStudents() throws SQLException, ClassNotFoundException {
        //connect sql
        CreateSql sql = new CreateSql();
        Statement statement = sql.CreatSql();
        //编写str
        String sqlStr = " select * from students ";
        ResultSet result = statement.executeQuery(sqlStr);
        List<Students> list = new ArrayList<>();
        while (result.next()) {
            Students stu = new Students();
            stu.setStudents_id((Integer) result.getObject("students_id"));
            stu.setStudents_name((String) result.getObject("students_name"));
            stu.setGender((String) result.getObject("gender"));
            stu.setAge((Integer) result.getObject("age"));
            stu.setPhone_number((String) result.getObject("phone_number"));
            stu.setAddress((String) result.getObject("address"));
            stu.setStudents_class((String) result.getObject("students_class"));
            list.add(stu);
        }
        // 关闭数据库连接
        statement.close();
        return list;
    }

    @Override
    public int addStudents(Students students) throws SQLException, ClassNotFoundException {
        //connect sql
        CreateSql sql = new CreateSql();
        Statement statement = sql.CreatSql();
        //编写str
        // 构建 SQL 语句
        String sqlStr = "INSERT INTO students (students_id, students_name, gender, age, phone_number, address, students_class) VALUES (" +
                students.getStudents_id() + ", '" +
                students.getStudents_name() + "', '" +
                students.getGender() + "', " +
                students.getAge() + ", '" +
                students.getPhone_number() + "', '" +
                students.getAddress() + "', '" +
                students.getStudents_class() + "')";
        int i = statement.executeUpdate(sqlStr);
        // 关闭数据库连接
        statement.close();
        return i;
    }

    @Override
    public int updateStudents(Students students) throws SQLException, ClassNotFoundException {
        //connect sql
        CreateSql sql = new CreateSql();
        Statement statement = sql.CreatSql();
        //编写str
        // 构建 SQL 语句
        String sqlStr = "UPDATE students SET " +
                "students_name = '" + students.getStudents_name() + "', " +
                "gender = '" + students.getGender() + "', " +
                "age = " + students.getAge() + ", " +
                "phone_number = '" + students.getPhone_number() + "', " +
                "address = '" + students.getAddress() + "', " +
                "students_class = '" + students.getStudents_class() + "' " +
                "WHERE students_id = " + students.getStudents_id();
        int i = statement.executeUpdate(sqlStr);
        // 关闭数据库连接
        statement.close();
        return i;
    }

    @Override
    public int delStudents(int i) throws SQLException, ClassNotFoundException {
        //connect sql
        CreateSql sql = new CreateSql();
        Statement statement = sql.CreatSql();
        // 构建 SQL 语句
        String sqlStr = "delete from students where students_id=" + i;
        int del = statement.executeUpdate(sqlStr);
        // 关闭数据库连接
        statement.close();
        return del;
    }
}
------------------------------------------------------IStudentsService-----------------------------------------------------
public interface IStudentsService {
    List<Students> selectAllStudentsName(String Name) throws SQLException, ClassNotFoundException;

    List<Students> selectAllStudents() throws SQLException, ClassNotFoundException;
    int addStudents(Students students) throws SQLException, ClassNotFoundException;
    int updateStudents(Students students) throws SQLException, ClassNotFoundException;
    int delStudents(int i) throws SQLException, ClassNotFoundException;

}

------------------------------------------------------StudentsServiceImpl-----------------------------------------------------
public class StudentsServiceImpl implements IStudentsService {

    @Override
    public List<Students> selectAllStudentsName(String Name) throws SQLException, ClassNotFoundException {
        IStudentDao iStudentDao=new StudentsDaoImpl();
        List<Students> list = iStudentDao.selectAllStudentsName(Name);
        return list;
    }

    @Override
    public List<Students> selectAllStudents() throws SQLException, ClassNotFoundException {
        IStudentDao iStudentDao=new StudentsDaoImpl();
        List<Students> list = iStudentDao.selectAllStudents();
        return list;
    }

    @Override
    public int addStudents(Students students) throws SQLException, ClassNotFoundException {
        IStudentDao iStudentDao=new StudentsDaoImpl();
        int i = iStudentDao.addStudents(students);
        System.out.println("受影响行数"+i);
        return i;
    }

    @Override
    public int updateStudents(Students students) throws SQLException, ClassNotFoundException {
        IStudentDao iStudentDao=new StudentsDaoImpl();
        int i = iStudentDao.updateStudents(students);
        System.out.println("受影响行数"+i);
        return i;
    }

    @Override
    public int delStudents(int i) throws SQLException, ClassNotFoundException {
        IStudentDao iStudentDao=new StudentsDaoImpl();
        int i1 = iStudentDao.delStudents(i);
        System.out.println("受影响行数"+i);
        return i1;
    }
}
------------------------------------------------------TestServiceStudents -----------------------------------------------------

public class TestServiceStudents {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        TestServiceStudents TesTStudent = new TestServiceStudents();

        System.out.println("进行查询");
        List<Students> list = TesTStudent.TestQuaryStudentsName("小");
        for (Students students : list) {
            System.out.println("Student ID: " + students.getStudents_id());
            System.out.println("Name: " + students.getStudents_name());
            System.out.println("Gender: " + students.getGender());
            System.out.println("Age: " + students.getAge());
            System.out.println("Phone Number: " + students.getPhone_number());
            System.out.println("Address: " + students.getAddress());
            System.out.println("Class: " + students.getStudents_class());
            System.out.println("----------------------");
        }
    }
/*    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        TestServiceStudents TesTStudent = new TestServiceStudents();
        System.out.println("进行查询");
        TesTStudent.TestQuaryStudents();
        TesTStudent.TestAddStudents(new Students(1, "小白", "大一", 22, "13233704965", "山西省太原", "大数据一班"));
        System.out.println("进行查询");
        TesTStudent.TestQuaryStudents();
        TesTStudent.TestUpdateStudents(new Students(1, "大白", "大一", 22, "13233704965", "山西省太原", "大数据一班"));
        System.out.println("进行查询");
        TesTStudent.TestQuaryStudents();
        TesTStudent.TestDelStudents(1);
        System.out.println("进行查询");
        TesTStudent.TestQuaryStudents();
    }*/

    public List<Students> TestQuaryStudentsName(String name) throws SQLException, ClassNotFoundException {
        IStudentsService iStudentsService=new StudentsServiceImpl();
        List<Students> list = iStudentsService.selectAllStudentsName(name);
        return  list;
    }

    public void TestQuaryStudents() throws SQLException, ClassNotFoundException {
        IStudentsService iStudentsService = new StudentsServiceImpl();
        List<Students> list = iStudentsService.selectAllStudents();
        for (Students students : list) {
            System.out.println("Student ID: " + students.getStudents_id());
            System.out.println("Name: " + students.getStudents_name());
            System.out.println("Gender: " + students.getGender());
            System.out.println("Age: " + students.getAge());
            System.out.println("Phone Number: " + students.getPhone_number());
            System.out.println("Address: " + students.getAddress());
            System.out.println("Class: " + students.getStudents_class());
            System.out.println("----------------------");
        }
    }

    public void TestAddStudents(Students students) throws SQLException, ClassNotFoundException {
        IStudentsService iStudentsService = new StudentsServiceImpl();
        iStudentsService.addStudents(students);
    }

    public void TestDelStudents(int i) throws SQLException, ClassNotFoundException {
        IStudentsService iStudentsService = new StudentsServiceImpl();
        iStudentsService.delStudents(i);
    }

    public void TestUpdateStudents(Students students) throws SQLException, ClassNotFoundException {
        IStudentsService iStudentsService = new StudentsServiceImpl();
        iStudentsService.updateStudents(students);
    }
}
-----------------------------------------------------思路介绍----------------------------------------------------
俩个类和一个页面
展示类 :  实现渲染,修改,添加
	get: 	
		进行数据渲染
		获取数据渲染里需要修改的id,进行sql查询是否存在,如果存在传到前端进行填写修改表单
	post:
		处理前端的添加from,通过hidden设置type 
		处理前端的修改from,从后端拿到id, 通过hidden设置id
修改类: 实现删除,模糊查询
	get:
		拿到id,进行删除
	post:
		表单提交实现模糊查询,如果存在传到前端进行渲染
一个页面:
	1.渲染的数据	有删除,修改按钮
	2.渲染模糊查询的数据
	3.添加表单
	4.模糊查询表单
	5.修改表单
-----------------------------------------------------Controller----------------------------------------------------
=======new==========

@WebServlet("/ShowStudent")
public class ShowStudent extends HttpServlet {
    // get:渲染数据 并且 实现修改功能 post : 分析表单提交类型 ( 0 : 添加  1 : 修改)
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        IStudentsService iStudentsService = new StudentsServiceImpl();
        //---------修改功能,get接收修改的id
        String students_id = req.getParameter("students_id");
        if(students_id!=null){
            int stuid= Integer.parseInt(students_id);
            try {
                List<Students> list = iStudentsService.selectAllStudentsId(stuid);
                if(list!=null){//证明修改的id存在,可以进行修改操作,但是需要将id传到前端重新填写表单,再提交操作
                    System.out.println("修改的id存在"+stuid);
                    req.setAttribute("Stuid",stuid);
                    req.setAttribute("id",1);
                    req.getRequestDispatcher("/ShowStudents.jsp").forward(req,resp);
                }
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }


        //----------------将集合数据传到页面
        try {
            List<Students> list = iStudentsService.selectAllStudents();
            //发送数据
            req.setAttribute("List", list);
            //转发页面
            req.getRequestDispatcher("/ShowStudents.jsp").forward(req, resp);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        //分析表单提交类型 0 : 添加  1 : 修改
        int type = Integer.parseInt(req.getParameter("type"));
        if (type == 0) {
            Students students = new Students();
            //封装数据,不含id
            students.setStudents_name(req.getParameter("students_name"));
            students.setGender(req.getParameter("gender"));
            students.setAge(Integer.parseInt(req.getParameter("age")));
            students.setPhone_number(req.getParameter("phone_number"));
            students.setAddress(req.getParameter("address"));
            students.setStudents_class(req.getParameter("students_class"));
            //添加数据
            IStudentsService iStudentsService=new StudentsServiceImpl();
            try {
                iStudentsService.addStudents(students);
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //跳转页面
            resp.sendRedirect("ShowStudent");
        }else if(type==1){
            Students students = new Students();
            //封装数据,含id
            students.setStudents_id(Integer.parseInt(req.getParameter("students_id")));
            students.setStudents_name(req.getParameter("students_name"));
            students.setGender(req.getParameter("gender"));
            students.setAge(Integer.parseInt(req.getParameter("age")));
            students.setPhone_number(req.getParameter("phone_number"));
            students.setAddress(req.getParameter("address"));
            students.setStudents_class(req.getParameter("students_class"));
            //添加数据
            IStudentsService iStudentsService=new StudentsServiceImpl();
            try {
                iStudentsService.updateStudents(students);
            } catch (SQLException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            //跳转页面
            resp.sendRedirect("ShowStudent");
        }else{
            System.out.println("不存在表单提交类型");
            resp.sendRedirect("ShowStudent");
        }
    }
}

=======new==========
@WebServlet("/DelStudent")
public class DelStudent extends HttpServlet {
    //get 完成删除功能 : post 完成查询功能
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        int students_id = Integer.parseInt(req.getParameter("students_id"));
        IStudentsService iStudentsService=new StudentsServiceImpl();
        try {
            iStudentsService.delStudents(students_id);
            resp.sendRedirect("ShowStudent");
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String cha = req.getParameter("cha");
        IStudentsService iStudentsService=new StudentsServiceImpl();
        try {
            List<Students> list = iStudentsService.selectAllStudentsName(cha);
            req.setAttribute("Listcha",list);
            req.getRequestDispatcher("/ShowStudents.jsp").forward(req,resp);
        } catch (SQLException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

-----------------------------------------------------jsp----------------------------------------------------
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%--引入jstl和stabdard jar包,用于前端页面实现循环查询功能--%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<%--展示 查询的数据--%>
<c:if test="${not empty List}">
    <table>
    <tr>
        <th>学生名字</th>
        <th>学生年级</th>
        <th>学生年龄</th>
        <th>学生电话</th>
        <th>学生地址</th>
        <th>学生班级</th>
        <th>操作</th>
    </tr>

        <c:forEach items="${List}" var="stu">
            <tr>
                <th>${stu.students_name}</th>
                <th>${stu.gender}</th>
                <th>${stu.age}</th>
                <th>${stu.phone_number}</th>
                <th>${stu.address}</th>
                <th>${stu.students_class}</th>
                <th>
                    <button onclick="Alter(${stu.students_id})">修改</button>
                </th>
                <th>
                    <button onclick="Del(${stu.students_id})" >删除</button>
                </th>
            </tr>
        </c:forEach>

</table>
</c:if>
<%--展示 模糊查询的数据--%>
<c:if test="${not empty Listcha}">
    <table>
    <tr>
        <th>学生名字</th>
        <th>学生年级</th>
        <th>学生年龄</th>
        <th>学生电话</th>
        <th>学生地址</th>
        <th>学生班级</th>
    </tr>

        <c:forEach items="${Listcha}" var="stu">
            <tr>
                <th>${stu.students_name}</th>
                <th>${stu.gender}</th>
                <th>${stu.age}</th>
                <th>${stu.phone_number}</th>
                <th>${stu.address}</th>
                <th>${stu.students_class}</th>
            </tr>
        </c:forEach>

    </table>
</c:if>
<%--添加操作 的表单--%>
<form method="post" action="ShowStudent">
    <h3>添加表单</h3>
    <input type="hidden" name="type" value="0">
    <label>名字</label>
    <input type="text" name="students_name" value="裴擒虎"><br/>
    <label>年级</label>
    <input type="text" name="gender" value="大三"><br/>
    <label>年龄</label>
    <input type="text" name="age" value="23"><br/>
    <label>电话</label>
    <input type="text" name="phone_number" value="17835669647"><br/>
    <label>住址</label>
    <input type="text" name="address" value="王者峡谷"><br/>
    <label>班级</label>
    <input type="text" name="students_class" value="王者培训1班"><br/>
    <input type="submit" value="添加">
</form>
<%--模糊查询 的表单--%>
<form method="post" action="DelStudent">
    <label>模糊查询</label>
    <input type="text" value="小" name="cha">
    <input type="submit" value="模糊查询">
</form>
<%--修改功能 如果 后端传来的数据不是空 则--%>
<c:if test="${not empty Stuid}">
    <!--如果存在 -->
    <form method="post" action="ShowStudent">
        <h3>修改表单</h3>
        <input type="hidden" name="students_id" value="${Stuid}">
        <input type="hidden" name="type" value="1">
        <label>名字</label>
        <input type="text" name="students_name" value="卡特"><br/>
        <label>年级</label>
        <input type="text" name="gender" value="大三"><br/>
        <label>年龄</label>
        <input type="text" name="age" value="23"><br/>
        <label>电话</label>
        <input type="text" name="phone_number" value="17835669647"><br/>
        <label>住址</label>
        <input type="text" name="address" value="LOL峡谷"><br/>
        <label>班级</label>
        <input type="text" name="students_class" value="LOL培训1班"><br/>
        <input type="submit" value="修改">
    </form>
</c:if>
<!--如果传来的数据不存在 -->
<c:if test="${empty Stuid}">
</c:if>
<a href="ShowStudent" >返回上一级</a>
</body>
<script>
    function Del(students_id) {
        if (confirm("确定删除吗?")) {
            //发生请求,通过servlet删除数据
            location.href = "/app_war_exploded/DelStudent?students_id=" + students_id;
        }
    }
    function Alter(students_id){
        location.href = "/app_war_exploded/ShowStudent?students_id=" + students_id;
    }
</script>
</html>

----java进阶 项目实战

java进阶内容

数据库

卸载数据库

安装数据库

数据库DOS操作

下载破解版navicat

idea连接数据库

Druid

创建表

添加

删除

修改

查询

查询语句

数据库设计的三大范式

MySQL驱动程序

web

tomcat

下载

查看tomcat版本

配置

web程序

web目录

前后端页面跳转

解决乱码

servlet

配置

3版本以下

Servlet 3.0 及以上版本的配置步骤

Httpservlet

request

响应数据

转发 (Forward) 和重定向 (Redirect)

HttpSession 对象

Cookie 对象

ServletContext 对象

文件上传和下载

jsp

jsp指令标签

jsp四大域对象

EL表达式的使用

JSTL

标签库的介绍和使用

常用标签

前端页面输出集合数据

4.1后端代码

4.2前端代码

后端service层功能实现

前端页面输出集合数据

Ntables

从后端接收到的字符串数据：${str}

从后端接收到的数据：<%= request.getAttribute("str") %>

业务逻辑实现

1.前端from发送登录信息到Logn类

2.login类验证信息

3.登录成功后转到menu.jsp

管理系统

4.menu.jsp可以跳转前端也可以跳转后端,

转到用户管理功能

(4.1) 从test表中查询结果集合渲染到前端页面

(4.2) 前端页面展示结果集合

用户管理

(4.3) 删除功能实现

(4.4) 添加功能需要判断

(4.5) 修改功能需要拿到id到后端查询,然后转发到前端页面填写表单,最后修改数据

java连接数据库和web实现增删改查

你可能感兴趣的:(java,mysql,tomcat,web3,jsp,笔记)

----java进阶项目实战