丝 雨 如 愁
丝 雨 如 愁

----java进阶 项目实战

java进阶内容

数据库

卸载数据库

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

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

  1. 卸载数据库软件：在命令行或终端中，使用适用于你的操作系统的软件包管理工具来卸载数据库软件。以下是一些常见数据库的卸载命令示例：

    • 对于 MySQL：
    sudo apt-get remove mysql-server
    • 对于 PostgreSQL：
    sudo apt-get remove postgresql
    • 对于 MongoDB：
    sudo apt-get remove mongodb

  2. 删除数据文件：此步骤可选，如果你想完全删除数据库相关的数据文件，可以手动删除。请注意，这将永久删除所有数据库和数据，包括备份文件。要删除数据文件，请找到数据库数据目录并删除它。根据数据库和操作系统的不同，数据目录的位置也会有所不同。

  3. 确认卸载：完成上述步骤后，你可以通过运行以下命令来确认数据库是否已成功卸载：

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

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

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

安装数据库

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

  1. 打开您的Web浏览器，并前往MySQL官方网站（https://www.mysql.com）。

  2. 在MySQL官方网站主页上，点击菜单中的 “Downloads”（下载）。

  3. 在下载页面上，您会看到MySQL各个版本的列表。根据您的操作系统选择适当的版本。常见的操作系统如Windows、macOS和Linux都有对应的MySQL版本。

  4. 在选择版本后，向下滚动到相关产品部分。找到与您的操作系统匹配的下载选项，例如Windows MSI Installer或macOS DMG Archive。

  5. 单击相应的下载链接，将会跳转到另一个页面。

  6. 在新页面上，您需要登录或创建一个MySQL帐户。如果您已经拥有账户，请登录；否则，请点击 “Create An Account”（创建账户）进行注册。

  7. 完成登录或注册后，您将被引导到另一个页面，您可以选择下载的方式：MySQL Community Server（社区版）或MySQL Enterprise Edition（企业版）。通常情况下，选择社区版即可。

  8. 点击 “Download”（下载），将开始下载MySQL安装程序。

  9. 下载完成后，找到下载的安装程序文件，双击运行。

  10. 按照安装程序的指示进行安装。在安装过程中，您可以选择安装路径、配置数据库和设置管理员密码等选项。请按照提示逐步完成安装过程。

  11. 安装完成后，您可以通过开始菜单（Windows）或Launchpad（macOS）中的MySQL图标来启动MySQL服务器。

  12. 一旦MySQL服务器启动，您可以使用MySQL客户端工具（如MySQL Shell、MySQL Workbench）或命令行来管理和操作MySQL数据库。

  13. 下载成功后去文件夹下面测试一下(用户名假设是root).输入

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

    则安装成功.

  14. 配置环境变量,复制地址去环境变量-系统变量-新建(键是 MYSQL_HOME 值是 文件夹地址)-编辑path(新建(%%\bin,然后中间添加一个MYSQL_HOME == %MYSQL_HOME%\bin))

  15. 最后去测试一下数据库是否配置成功.

数据库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的一些主要好处：

  1. 多种数据库支持：Navicat支持各种常见的数据库系统，包括MySQL、SQL Server、Oracle、PostgreSQL等。这意味着您可以在一个工具中管理多个不同类型的数据库，而无需学习和使用多个单独的工具。

  2. 直观的用户界面：Navicat具有直观的用户界面，易于使用和导航。它采用了直观的图形化界面，使得执行各种数据库操作和管理任务变得更加简单和可视化。

  3. 数据库连接管理：Navicat提供了方便的数据库连接管理功能。您可以轻松添加、编辑和删除数据库连接，并保存连接信息以便日后快速使用。这使得在不同数据库之间切换和管理连接变得更加方便。

  4. 数据导入和导出：Navicat支持数据的导入和导出。您可以使用导入功能将数据从外部文件、其他数据库或备份文件导入到目标数据库中。同样，您也可以使用导出功能将数据导出为各种格式，如CSV、Excel、SQL脚本等。

  5. 数据库设计和建模：Navicat提供了强大的数据库设计和建模功能。您可以使用图形界面创建和编辑数据库对象（表、视图、存储过程等），并生成相应的SQL脚本。

  6. SQL查询和脚本执行：Navicat提供了功能强大的SQL查询编辑器，可用于编写和执行复杂的SQL查询语句。它还支持批量执行SQL脚本，方便进行数据库操作和数据处理。

  7. 数据同步和备份：Navicat允许您轻松进行数据同步和备份操作。您可以比较和同步不同数据库之间的数据和结构差异，以确保数据的一致性。此外，您还可以创建数据库备份，并根据需要进行定期备份。

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

idea连接数据库

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

  1. 打开IntelliJ IDEA，并打开您的项目。

  2. 点击顶部菜单栏中的 “View”，然后选择 “Tool Windows”，再选择 “Database” （或者直接使用快捷键 Alt + F8），以打开 “Database” 工具窗口。

  3. 在 “Database” 工具窗口中，点击窗口右上角的 “+” 图标，选择 “Data Source”。

  4. 在弹出的对话框中，选择您要连接的数据库类型，比如MySQL、PostgreSQL、Oracle等，并点击 “Next”。

  5. 在新的对话框中，填写您的数据库连接信息，包括主机名（Host）、端口（Port）、数据库名称（Database）、用户名（User）和密码（Password）等。您可以点击 “Test Connection” 按钮来验证连接是否成功。

  6. 验证通过后，点击 “OK” 完成数据库连接配置。

  7. IntelliJ IDEA将会在 “Database” 工具窗口中显示您连接的数据库，您可以展开数据库并浏览其表格、视图等对象。您还可以在代码中使用数据库相关的工具和功能。

Druid

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

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

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

创建表

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

  1. 定义表名：

    CREATE TABLE table_name (
...
);

    在 CREATE TABLE 语句中，指定表的名称。

  2. 定义列：

    CREATE TABLE table_name (
    column1 datatype constraint,
    column2 datatype constraint,
    ...
);

    在 CREATE TABLE 语句中，按照列的顺序定义每个列的名称、数据类型和约束。例如，使用 column1 datatype constraint 的形式，其中 column1 是列名，datatype 是数据类型（如 INT、VARCHAR 等），constraint 是列的约束（如 PRIMARY KEY、NOT NULL 等）。

  3. 指定主键：

    CREATE TABLE table_name (
    column1 datatype PRIMARY KEY,
    ...
);

    您可以使用 PRIMARY KEY 约束将一列或多列定义为主键。主键是唯一标识表中每一行的列。通常情况下，主键的值是唯一且不可为空。

  4. 添加外键关联：

    CREATE TABLE table_name1 (
    column1 datatype,
    ...
    FOREIGN KEY (column_name) REFERENCES table_name2(column_name)
);

    使用 FOREIGN KEY 约束创建外键关联。外键关联在当前表中的一列引用了另一个表中的列。在 FOREIGN KEY 约束中，指定当前表的列和引用表的列之间的关系。

  5. 定义默认值：

    CREATE TABLE table_name (
    column1 datatype DEFAULT default_value,
    ...
);

    使用 DEFAULT 关键字为列指定默认值。如果插入新行时未提供具体值，将使用默认值代替。

  6. 指定约束：

    CREATE TABLE table_name (
    column1 datatype CONSTRAINT constraint_name constraint_definition,
    ...
);

    使用 CONSTRAINT 关键字为特定列定义自定义约束。约束可以是 NOT NULL（列不能为空）、UNIQUE（列的值必须唯一）或其他自定义约束。

  7. 创建索引：

    CREATE TABLE table_name (
    column1 datatype,
    ...
    CONSTRAINT index_name UNIQUE (column_name)
);

    使用 CONSTRAINT 关键字创建唯一性索引。索引可以提高查询性能，并确保某一列或多列的唯一性。

  8. 添加注释：

    CREATE TABLE table_name (
    column1 datatype,
    ...
    COMMENT 'Your comment here'
);

    使用 COMMENT 关键字为表添加注释。注释用于说明表、列或其他数据库对象的用途或特性。

添加

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

  1. 使用 INSERT INTO 语句开始添加操作：

    INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);

    在 INSERT INTO 语句中，指定表名以及要插入数据的列名和对应的值。

  2. 指定要插入的列和对应的值：

    INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...);

    在 INSERT INTO 语句中，指定要插入的列名，然后使用 VALUES 关键字指定对应的值。确保列名和值的数量、顺序和数据类型一致。

  3. 添加多个数据行：

    INSERT INTO table_name (column1, column2, ...)
VALUES (value1, value2, ...),
       (value1, value2, ...),
       ...;

    您可以一次性插入多个数据行。在 VALUES 子句的括号中，以逗号分隔每个数据行的值。

  4. 插入查询结果：

    INSERT INTO table_name (column1, column2, ...)
SELECT column1, column2, ...
FROM another_table
WHERE condition;

    您还可以使用插入查询结果的方式向表中添加数据。在 INSERT INTO 语句中，指定要插入的列名，然后使用 SELECT 语句选择要插入的数据行。确保查询结果的列名、数量和数据类型与目标表的要求一致。

删除

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

  1. 删除整个表：

    DROP TABLE table_name;

    使用 DROP TABLE 语句可以完全删除一个表及其所有数据。请谨慎执行此操作，因为删除后将无法恢复。

  2. 删除特定行：

    DELETE FROM table_name
WHERE condition;

    使用 DELETE FROM 语句可以删除符合指定条件的数据行。在 WHERE 子句中，您可以根据需要指定要删除的行的条件。

  3. 删除所有行：

    DELETE FROM table_name;

    如果不提供任何条件，则 DELETE FROM 语句将删除表中的所有数据行。

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

修改

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

  1. 使用 UPDATE 语句开始修改操作：

    UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

    在 UPDATE 语句中，指定要更新的表名。使用 SET 关键字指定要修改的列名和对应的新值。在 WHERE 子句中，指定要更新的数据行的条件。

  2. 更新特定行：

    UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;

    使用 UPDATE 语句可以更新符合指定条件的数据行。在 WHERE 子句中，根据需要指定要更新的行的条件。

  3. 更新所有行：

    UPDATE table_name
SET column1 = value1, column2 = value2, ...;

    如果不提供任何条件，则 UPDATE 语句将更新表中的所有数据行。

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

查询

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

查询语句

select * from 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;

  1. 使用 SELECT 语句开始查询操作：

    SELECT column1, column2, ...
FROM table_name;

    在 SELECT 语句中，指定要检索的列名。使用 FROM 关键字指定要查询的表名。

  2. 检索所有列：

    SELECT *
FROM table_name;

    如果要检索表中的所有列，可以使用 * 作为列名。

  3. 添加过滤条件：

    SELECT column1, column2, ...
FROM table_name
WHERE condition;

    使用 WHERE 子句可以添加条件来过滤查询结果。在条件中，您可以指定要检索的数据行的特定条件。

  4. 排序查询结果：

    SELECT column1, column2, ...
FROM table_name
ORDER BY column1 ASC/DESC;

    使用 ORDER BY 子句可以按照指定列的升序（ASC）或降序（DESC）对查询结果进行排序。

  5. 进行聚合函数操作：

    SELECT aggregate_function(column)
FROM table_name;

    使用聚合函数（如 COUNT、SUM、AVG、MAX、MIN 等）可以对查询结果进行计算和统计操作。

  6. 连接多个表：

    SELECT column1, column2, ...
FROM table1
INNER JOIN table2
ON table1.column = table2.column;

    如果数据库包含多个相关联的表，您可以使用连接操作（如 INNER JOIN、LEFT JOIN 等）根据共享的列将它们连接在一起。

数据库设计的三大范式

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

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

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

MySQL驱动程序

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

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

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

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

    2. 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版本

    3. 下载后得到 mysql-connector-j-8.0.33.jar

    4. 新建lib目录,与src同级,

    5. 将jar添加到lib中,点击右键添加到项目库中,成功后可以有个三角可以点开.

    6. 用代码直接连接数据库,然后操作数据库

  2. 加载驱动程序：在连接到MySQL数据库之前，需要将驱动程序加载到Java应用程序中。可以使用以下代码来加载驱动程序：

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

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

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

  4. 执行数据库操作：一旦建立了数据库连接，就可以使用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 可以按照以下步骤进行操作：

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

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

对于 Windows 操作系统：

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

对于 Linux 或 macOS 操作系统：

  1. 打开终端或命令行界面，进入解压后的 Tomcat 文件夹。
  2. 在命令行中，执行 “./catalina.sh start” 命令来启动 Tomcat 服务器。
  3. 打开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，可以按照以下步骤进行操作：

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

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

web程序

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

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

web目录

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

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

  1. WEB-INF目录：这是一个非常重要的目录，用于存放Web应用程序的配置文件和只能通过服务器端访问的资源。具体来说，WEB-INF目录中通常包含以下内容：

    • web.xml文件：这是Web应用程序的部署描述符（Deployment Descriptor），用于配置Servlet、过滤器、监听器等组件、URL映射、请求处理等信息。
    • classes目录：用于存放编译后的Java类文件。
    • lib目录：用于存放依赖的库文件（JAR文件）。

  2. 静态资源目录：这个目录用于存放Web应用程序的静态资源文件，如HTML页面、CSS样式表、JavaScript脚本、图像文件等。这些文件可以直接从浏览器请求并返回给用户。

  3. JSP目录：如果Web应用程序使用JSP（JavaServer Pages）来实现动态内容，那么JSP文件通常会放在这个目录中。

  4. 资源文件目录：这个目录用于存放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 时，你需要完成以下几个步骤：

  1. 创建一个 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 请求
   }
}
  1. 在 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 路径。

  1. 部署 Web 应用程序。将编写好的 Servlet 类打包成 WAR 文件，并将其部署到 Java Web 服务器（如 Tomcat、Jetty 等）中。

  2. 启动 Web 服务器。启动 Web 服务器，并确保你的应用程序成功部署。

  3. 访问 Servlet。通过浏览器或其他客户端工具，访问配置的 URL 路径（例如：http://localhost:8080/yourwebapp/myservlet）即可触发 Servlet 的处理逻辑。

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

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

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

  1. 创建一个 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映射。

  1. 部署 Web 应用程序。将编写好的 Servlet 类打包成 WAR 文件，并将其部署到 Java Web 服务器（如 Tomcat、Jetty 等）中。

  2. 启动 Web 服务器。启动 Web 服务器，并确保你的应用程序成功部署。

  3. 访问 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 类中一些常用的方法：

  1. doGet(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP GET 请求。开发者可以在这个方法中编写逻辑来处理客户端发起的 GET 请求，并生成相应的响应。

  2. doPost(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP POST 请求。与 doGet 方法类似，你可以在这个方法中实现逻辑以处理客户端发起的 POST 请求。

  3. doPut(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP PUT 请求。开发者可以在这个方法中编写逻辑来处理客户端发起的 PUT 请求。

  4. doDelete(HttpServletRequest request, HttpServletResponse response): 用于处理 HTTP DELETE 请求。你可以在这个方法中实现逻辑以处理客户端发起的 DELETE 请求。

  5. init(ServletConfig config): 在 Servlet 被初始化时调用的方法。你可以在这个方法中进行一些初始化操作，例如读取配置文件、建立数据库连接等。

  6. 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 方法：

  1. setAttribute(String name, Object value): 在会话中设置属性值。
  2. getAttribute(String name): 获取会话中指定属性的值。
  3. removeAttribute(String name): 从会话中移除指定属性。
  4. getId(): 获取会话的唯一标识符（Session ID）。
  5. isNew(): 判断会话是否是新创建的。
  6. 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 类的一些常用方法和属性：

  1. Cookie(String name, String value): 构造一个带有指定名称和值的 Cookie 对象。

  2. setMaxAge(int maxAge): 设置 Cookie 的最大生命周期（以秒为单位）。当设置为负值时，表示该 Cookie 仅在当前会话有效。当设置为 0 时，表示该 Cookie 将立即过期并被删除。

  3. getName(): 获取 Cookie 的名称。

  4. getValue(): 获取 Cookie 的值。

  5. setPath(String path): 设置 Cookie 的路径。默认情况下，Cookie 的路径为当前请求的上下文路径（Context Path）。

  6. setDomain(String domain): 设置 Cookie 的域名。默认情况下，Cookie 的域名为当前请求的服务器地址。

  7. setSecure(boolean secure): 设置 Cookie 是否仅在安全连接（HTTPS）下传输。

  8. 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 方法：

  1. getInitParameter(String paramName): 获取指定名称的上下文参数，可以在 web.xml 文件中定义。

  2. getAttribute(String attrName): 从 ServletContext 中获取指定名称的属性值。

  3. setAttribute(String attrName, Object attrValue): 向 ServletContext 中设置指定名称的属性值。

  4. getRequestDispatcher(String path): 获得用于转发请求的 RequestDispatcher 对象。

  5. getRealPath(String path): 将虚拟路径（例如 /index.html）转换为在服务器上的实际路径。

  6. getContextPath(): 获取当前 Web 应用程序的上下文路径。

  7. getResourceAsStream(String path): 返回与给定路径相对应的输入流，可以用来加载包含在 war 文件中的资源文件等。

  8. 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 应用程序中常见的功能之一。下面我将简要介绍文件上传和下载的基本概念和实现方式。

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

    文件上传的一般步骤如下：

    • 在客户端网页中创建包含文件选择的表单。
    • 客户端选择要上传的文件，并点击提交按钮。
    • 服务器接收到请求，解析表单数据，提取上传的文件数据。
    • 服务器将文件保存到指定位置，并进行相应的处理（例如读取文件内容、存储文件路径等）。

    在 Java Web 应用程序中，可以使用 javax.servlet.http.Part 接口或 org.springframework.web.multipart.MultipartFile 类来处理文件上传。具体的实现方式会根据所使用的框架而有所不同。

  2. 文件下载：
    文件下载是指从服务器端将文件发送给客户端，使客户端可以保存该文件到本地计算机。通常，文件下载需要提供一个文件下载链接或按钮，当客户端点击链接或按钮时，服务器将相应的文件发送给客户端浏览器。

    文件下载的一般步骤如下：

    • 在客户端网页中提供文件下载的链接或按钮。
    • 客户端点击链接或按钮，发送下载请求到服务器。
    • 服务器接收到下载请求，并根据请求的文件路径或标识符找到相应的文件。
    • 服务器将文件以流的形式发送给客户端浏览器。

    在 Java Web 应用程序中，可以使用 javax.servlet.ServletOutputStream 将文件内容写入响应输出流，或者使用框架提供的工具类来简化文件下载的实现。

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

jsp

jsp指令标签

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

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

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

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

  2. include 指令：用于在当前页面中包含其他文件的内容。示例：

    <%@ include file="header.jsp" %>

  3. taglib 指令：用于导入自定义标签库，以便在 JSP 页面中使用自定义标签。示例：

    <%@ taglib prefix="mylib" uri="http://www.example.com/mylib" %>

  4. tag 指令：用于定义标签文件以及其对应的处理类。示例：

    <%@ tag description="My custom tag" pageEncoding="UTF-8" %>

  5. directive 指令：可用于设置页面的编码、继承、会话管理等。示例：

    <%@ directive pageEncoding="UTF-8" extends="javax.servlet.http.HttpServlet" %>

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

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

jsp四大域对象

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

  1. page 域（Page Context）：表示当前页面的上下文信息，只在当前页面内有效。在 JSP 页面中，可以使用 pageContext 对象来访问 page 域。

  2. request 域（Request Context）：表示客户端发送的 HTTP 请求信息，可以在同一次请求的多个页面中共享数据。在 JSP 页面中，可以使用 request 对象来访问 request 域。

  3. session 域（Session Context）：表示用户会话信息，由服务器创建并管理，可以在整个会话期间共享数据。在 JSP 页面中，可以使用 session 对象来访问 session 域。

  4. application 域（Application Context）：表示 Web 应用程序的全局信息，可以在整个应用程序范围内共享数据。在 JSP 页面中，可以使用 application 对象来访问 application 域。

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

  1. 使用 page 域对象：

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

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

  2. 使用 request 域对象：

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

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

  3. 使用 session 域对象：

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

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

  4. 使用 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 表达式的一些常见用法：

  1. 访问属性：
    EL 可以通过 ${} 语法来访问 JavaBean 的属性。例如，${user.name} 可以获取名为 “user” 的 JavaBean 对象的 name 属性值。

  2. 访问集合和数组元素：
    EL 可以通过 ${} 语法访问集合和数组的元素。例如，${myArray[0]} 可以获取名为 “myArray” 的数组的第一个元素。

  3. 调用方法：
    EL 支持调用 JavaBean 的方法，并获取方法的返回值。例如，${user.getName()} 可以调用名为 “user” 的 JavaBean 对象的 getName 方法。

  4. 条件判断：
    EL 支持条件判断表达式，例如 ${age > 18} 可以判断变量 age 是否大于 18。

  5. 集合和数组操作：
    EL 提供了一些操作符来处理集合和数组，例如 ${names.length()} 可以获取集合或数组的长度，${names.isEmpty()} 可以判断集合或数组是否为空。

  6. 空值处理：
    EL 提供了一些特殊的操作符来处理空值，例如 ${user?.name} 可以安全地获取名为 “user” 的 JavaBean 对象的 name 属性，即使 user 是 null。

  7. 字符串拼接：
    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 的几个主要标签库：

  1. Core 标签库：包含了一些基本的控制流和变量操作的标签。

    • ：条件判断标签，用于根据表达式的结果来决定是否输出某个内容。
    • 、、：类似于 Java 中的 switch-case 结构。
    • ：迭代标签，用于遍历集合、数组等数据结构。
    • ：设置变量值的标签。

  2. Formatting 标签库：用于格式化数据的标签库，可以格式化日期、时间、数字等。

    • ：格式化日期。
    • ：格式化数字。
    • ：解析数字。

  3. SQL 标签库：用于与数据库进行交互的标签库。

    • ：设置数据库连接信息。
    • ：执行 SQL 查询。
    • ：执行 SQL 更新。

  4. 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 标签库时，以下是更详细的说明：

  1. Core 标签库（）：

    • ：根据表达式的结果来决定是否输出某个内容。示例：...
    • ：迭代标签，用于遍历集合、数组等数据结构。示例：...
    • ：设置变量值的标签。示例：
    • 、、：类似于 Java 中的 switch-case 结构，根据条件选择不同的分支。示例：
      
  ...
  ...
  ...

  2. Formatting 标签库（）：

    • ：用于格式化日期。示例：
    • ：用于格式化数字。示例：
    • ：用于解析数字。示例：

  3. SQL 标签库（）：

    • ：设置数据库连接信息。示例：
    • ：执行 SQL 查询。示例：${sql}
    • ：执行 SQL 更新。示例：${sql}

  4. XML 标签库（）：

    • ：解析 XML。示例：
    • ：迭代 XML 元素。示例：...

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

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

前端页面输出集合数据

  1. 由后端ShowNtable 转发 页面到NtableAll

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

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

  3. 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}

后端service层功能实现

  1. 建表,注意主键自动递增

  2. 添加lib mysql-connector-j 添加库

  3. 创建pojo目录,添加表对应的实体类

  4. 封装数据连接

      /*  $方法的内容$
        创建数据库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;
        }
    }

  5. 创建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;
}

  6. 在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;
    }
}

  7. 写一个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;
    }

}

前端页面输出集合数据

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

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

    
    
      javax.el
      javax.el-api
      3.0.0

  2. 由后端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 页面


    }
	}

  3. 在 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}

业务逻辑实现

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

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




    
管理系统

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}
      
      
    

  


<%--添加表单--%>
(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,取到从后端传来的数据,并且传给后端进行添加操作--%>
    
    
    


    
    


    





	//修改数据操作
	@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,mysql,tomcat,web3,jsp,笔记)

  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • mysql禁用远程登录 igotyback mysql
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • git常用命令笔记 咩酱-小羊 git笔记
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
  • 509. 斐波那契数(每日一题) lzyprime
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记 爱吃丸子的小樱桃
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day17笔记-高阶函数 ~在杰难逃~ Python笔记python开发语言pycharm数据分析
    高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • MYSQL面试系列-04 king01299 面试mysql面试
    MYSQL面试系列-0417.关于redolog和binlog的刷盘机制、redolog、undolog作用、GTID是做什么的？innodb_flush_log_at_trx_commit及sync_binlog参数意义双117.1innodb_flush_log_at_trx_commit该变量定义了InnoDB在每次事务提交时，如何处理未刷入（flush）的重做日志信息（redolog）。它
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 【Git】常见命令(仅笔记) 好想有猫猫 GitLinux学习笔记git笔记elasticsearchlinuxc++
    文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解 秋刀prince mysqlmysql数据库
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • 为什么你总是对下属不满意? ZhaoWu1050
    【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
  • 母亲节如何做小红书营销 美橙传媒
    小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • 矩阵求逆（JAVA）利用伴随矩阵 qiuwanchi 利用伴随矩阵求逆矩阵
    package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(利用伴随矩阵) * @author 邱万迟
  • 单例（Singleton）模式 aoyouzi 单例模式Singleton
    3.1           概述 如果要保证系统里一个类最多只能存在一个实例时，我们就需要单例模式。这种情况在我们应用中经常碰到，例如缓存池，数据库连接池，线程池，一些应用服务实例等。在多线程环境中，为了保证实例的唯一性其实并不简单，这章将和读者一起探讨如何实现单例模式。 3.2
  • [开源与自主研发]就算可以轻易获得外部技术支持,自己也必须研发 comsci 开源
          现在国内有大量的信息技术产品，都是通过盗版，免费下载，开源，附送等方式从国外的开发者那里获得的。。。。。。        虽然这种情况带来了国内信息产业的短暂繁荣，也促进了电子商务和互联网产业的快速发展，但是实际上，我们应该清醒的看到，这些产业的核心力量是被国外的
  • 页面有两个frame,怎样点击一个的链接改变另一个的内容 Array_06 UIXHTML
    <a src="地址"  targets="这里写你要操作的Frame的名字" />搜索 然后你点击连接以后你的新页面就会显示在你设置的Frame名字的框那里 targerts="",就是你要填写目标的显示页面位置 ===================== 例如： <frame src=&
  • Struts2实现单个/多个文件上传和下载 oloz 文件上传struts
    struts2单文件上传：     步骤01:jsp页面 <!--在进行文件上传时，表单提交方式一定要是post的方式，因为文件上传时二进制文件可能会很大，还有就是enctype属性，这个属性一定要写成multipart/form-data，不然就会以二进制文本上传到服务器端--> 　　<form action="fileUplo
  • 推荐10个在线logo设计网站 362217990 logo
    在线设计Logo网站。 1、http://flickr.nosv.org（这个太简单） 2、http://www.logomaker.com/?source=1.5770.1 3、http://www.simwebsol.com/ImageTool 4、http://www.logogenerator.com/logo.php?nal=1&tpl_catlist[]=2 5、ht
  • jsp上传文件 香水浓 jspfileupload
    1. jsp上传 Notice： 1. form表单 method 属性必须设置为 POST 方法 ，不能使用 GET 方法 2. form表单 enctype 属性需要设置为 multipart/form-data 3. form表单 action 属性需要设置为提交到后台处理文件上传的jsp文件地址或者servlet地址。例如 uploadFile.jsp 程序文件用来处理上传的文
  • 我的架构经验系列文章 - 前端架构 agevs JavaScriptWeb框架UIjQuer
    框架层面：近几年前端发展很快，前端之所以叫前端因为前端是已经可以独立成为一种职业了，js也不再是十年前的玩具了，以前富客户端RIA的应用可能会用flash/flex或是silverlight，现在可以使用js来完成大部分的功能，因此js作为一门前端的支撑语言也不仅仅是进行的简单的编码，越来越多框架性的东西出现了。越来越多的开发模式转变为后端只是吐json的数据源，而前端做所有UI的事情。MVCMV
  • android ksoap2 中把XML(DataSet) 当做参数传递 aijuans android
    我的android app中需要发送webservice ，于是我使用了 ksop2 进行发送，在测试过程中不是很顺利,不能正常工作.我的web service 请求格式如下     [html]  view plain copy   <Envelope xmlns="http://schemas.
  • 使用Spring进行统一日志管理 + 统一异常管理 baalwolf spring
    统一日志和异常管理配置好后，SSH项目中，代码以往散落的log.info() 和 try..catch..finally 再也不见踪影！ 统一日志异常实现类： [java]  view plain copy   package com.pilelot.web.util;      impor
  • Android SDK 国内镜像 BigBird2012 android sdk
    一、镜像地址： 1、东软信息学院的 Android SDK 镜像，比配置代理下载快多了。 配置地址， http://mirrors.neusoft.edu.cn/configurations.we#android 2、北京化工大学的： IPV4:ubuntu.buct.edu.cn  IPV4:ubuntu.buct.cn IPV6:ubuntu.buct6.edu.cn
  • HTML无害化和Sanitize模块 bijian1013 JavaScriptAngularJSLinkySanitize
    一.ng-bind-html、ng-bind-html-unsafe         AngularJS非常注重安全方面的问题，它会尽一切可能把大多数攻击手段最小化。其中一个攻击手段是向你的web页面里注入不安全的HTML，然后利用它触发跨站攻击或者注入攻击。         考虑这样一个例子，假设我们有一个变量存
  • [Maven学习笔记二]Maven命令 bit1129 maven
    mvn compile compile编译命令将src/main/java和src/main/resources中的代码和配置文件编译到target/classes中，不会对src/test/java中的测试类进行编译 MVN编译使用 maven-resources-plugin:2.6:resources maven-compiler-plugin:2.5.1:compile &nbs
  • 【Java命令二】jhat bit1129 Java命令
    jhat用于分析使用jmap dump的文件，，可以将堆中的对象以html的形式显示出来，包括对象的数量，大小等等，并支持对象查询语言。 jhat默认开启监听端口7000的HTTP服务，jhat是Java Heap Analysis Tool的缩写 1. 用法： [hadoop@hadoop bin]$ jhat -help Usage: jhat [-stack <bool&g
  • JBoss 5.1.0 GA:Error installing to Instantiated: name=AttachmentStore state=Desc ronin47
    进到类似目录 server/default/conf/bootstrap，打开文件 profile.xml找到： Xml代码<bean    name="AttachmentStore"  class="org.jboss.system.server.profileservice.repository.AbstractAtta
  • 写给初学者的6条网页设计安全配色指南 brotherlamp UIui自学ui视频ui教程ui资料
    网页设计中最基本的原则之一是，不管你花多长时间创造一个华丽的设计，其最终的角色都是这场秀中真正的明星——内容的衬托     我仍然清楚地记得我最早的一次美术课，那时我还是一个小小的、对凡事都充满渴望的孩子，我摆放出一大堆漂亮的彩色颜料。我仍然记得当我第一次看到原色与另一种颜色混合变成第二种颜色时的那种兴奋，并且我想，既然两种颜色能创造出一种全新的美丽色彩，那所有颜色
  • 有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。写一个函数实现。复杂度是什么。 bylijinnan java算法面试
    import java.util.Random; import java.util.Set; import java.util.TreeSet; /** * http://weibo.com/1915548291/z7HtOF4sx * #面试题#有一个数组，每次从中间随机取一个，然后放回去，当所有的元素都被取过，返回总共的取的次数。 * 写一个函数实现。复杂度是什么
  • struts2获得request、session、application方式 chiangfai application
    1、与Servlet API解耦的访问方式。 a.Struts2对HttpServletRequest、HttpSession、ServletContext进行了封装，构造了三个Map对象来替代这三种对象要获取这三个Map对象，使用ActionContext类。 ----->   package pro.action; import java.util.Map; imp
  • 改变python的默认语言设置 chenchao051 python
    import sys sys.getdefaultencoding()  可以测试出默认语言，要改变的话，需要在python lib的site-packages文件夹下新建： sitecustomize.py， 这个文件比较特殊，会在python启动时来加载，所以就可以在里面写上： import sys sys.setdefaultencoding('utf-8') &n
  • mysql导入数据load data infile用法 daizj mysql导入数据
    我们常常导入数据！mysql有一个高效导入方法，那就是load data infile 下面来看案例说明 基本语法： load data  [low_priority] [local] infile 'file_name txt' [replace | ignore] into table tbl_name [fields [terminated by't'] [OPTI
  • phpexcel导入excel表到数据库简单入门示例 dcj3sjt126com PHPExcel
    跟导出相对应的，同一个数据表，也是将phpexcel类放在class目录下，将Excel表格中的内容读取出来放到数据库中 <?php error_reporting(E_ALL); set_time_limit(0); ?> <html> <head> <meta http-equiv="Content-Type"
  • 22岁到72岁的男人对女人的要求 dcj3sjt126com
    22岁男人对女人的要求是：一，美丽，二，性感，三，有份具品味的职业，四，极有耐性，善解人意，五，该聪明的时候聪明，六，作小鸟依人状时尽量自然，七，怎样穿都好看，八，懂得适当地撒娇，九，虽作惊喜反应，但看起来自然，十，上了床就是个无条件荡妇。 32岁的男人对女人的要求，略作修定，是：一，入得厨房，进得睡房，二，不必服侍皇太后，三，不介意浪漫蜡烛配盒饭，四，听多过说，五，不再傻笑，六，懂得独
  • Spring和HIbernate对DDM设计的支持 e200702084 DAO设计模式springHibernate领域模型
    A：数据访问对象     DAO和资源库在领域驱动设计中都很重要。DAO是关系型数据库和应用之间的契约。它封装了Web应用中的数据库CRUD操作细节。另一方面，资源库是一个独立的抽象，它与DAO进行交互，并提供到领域模型的“业务接口”。    资源库使用领域的通用语言，处理所有必要的DAO，并使用领域理解的语言提供对领域模型的数据访问服务。
  • NoSql 数据库的特性比较 geeksun NoSQL
    Redis 是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。目前由VMware主持开发工作。   1. 数据模型 作为Key-value型数据库，Redis也提供了键（Key）和值（Value）的映射关系。除了常规的数值或字符串，Redis的键值还可以是以下形式之一： Lists （列表） Sets
  • 使用 Nginx Upload Module 实现上传文件功能 hongtoushizi nginx
    转载自： http://www.tuicool.com/wx/aUrAzm   普通网站在实现文件上传功能的时候，一般是使用Python，Java等后端程序实现，比较麻烦。Nginx有一个Upload模块，可以非常简单的实现文件上传功能。此模块的原理是先把用户上传的文件保存到临时文件，然后在交由后台页面处理，并且把文件的原名，上传后的名称，文件类型，文件大小set到页面。下
  • spring-boot-web-ui及thymeleaf基本使用 jishiweili springthymeleaf
    视图控制层代码demo如下：   @Controller @RequestMapping("/") public class MessageController { private final MessageRepository messageRepository; @Autowired public MessageController(Mes
  • 数据源架构模式之活动记录 home198979 PHP架构活动记录数据映射
    hello!架构 一、概念 活动记录（Active Record）：一个对象，它包装数据库表或视图中某一行，封装数据库访问，并在这些数据上增加了领域逻辑。 对象既有数据又有行为。活动记录使用直截了当的方法，把数据访问逻辑置于领域对象中。   二、实现简单活动记录 活动记录在php许多框架中都有应用，如cakephp。 <?php /** * 行数据入口类 *
  • Linux Shell脚本之自动修改IP pda158 linuxcentosDebian脚本
    作为一名 Linux SA，日常运维中很多地方都会用到脚本，而服务器的ip一般采用静态ip或者MAC绑定，当然后者比较操作起来相对繁琐，而前者我们可以设置主机名、ip信息、网关等配置。修改成特定的主机名在维护和管理方面也比较方便。如下脚本用途为：修改ip和主机名等相关信息，可以根据实际需求修改，举一反三！ #!/bin/sh #auto Change ip netmask ga
  • 开发环境搭建 独浮云 eclipsejdktomcat
           最近在开发过程中，经常出现MyEclipse内存溢出等错误，需要重启的情况，好麻烦。对于一般的JAVA+TOMCAT项目开发，其实没有必要使用重量级的MyEclipse，使用eclipse就足够了。尤其是开发机器硬件配置一般的人。         &n
  • 操作日期和时间的工具类 vipbooks 工具类
       大家好啊，好久没有来这里发文章了，今天来逛逛，分享一篇刚写不久的操作日期和时间的工具类，希望对大家有所帮助。 /* * @(#)DataFormatUtils.java 2010-10-10 * * Copyright 2010 BianJing,All rights reserved. */ package test; impor
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他