[大数据]Java Web

Java Web

Java Web指的是用Java技术来解决相关Web互联网领域的技术栈，即使用Java语言开发基于互联网的应用。Web软件架构可分为C/S(Client/Server，客户端/服务器)和B/S(Browser/Server，浏览器/服务器)。在B/S架构中资源可分为静态资源和动态资源。静态资源就是使用静态网页技术发布的资源，如HTML、CSS、JavaScript等，所有用户访问得到的结果都是一样的，如果用户请求的是静态资源，那么服务器会直接将静态资源发送给浏览器，浏览器中内置的静态资源解析引擎可以展示静态资源；动态资源就是使用动态网页开发技术发布的资源，如JSP、Servlet、PHP、ASP等，每个用户访问得到的结果可能是不一样的，如果用户请求的是动态资源，那么服务器就会执行动态资源并将其转换为静态资源后再发送给浏览器。学习动态资源前必须学习静态资源。

MySQL

MySQL是一种关系型数据库管理系统，关系型数据库都是将数据保存在不同的表中的，而不是将所有数据放在一个大仓库里，这样就增加了速度并提高了灵活性。数据库(DataBase)就是用于存储和管理数据的仓库，可以持久化存储数据，数据库本质上就是一个文件系统，方便存储和管理数据，使用了统一的方式来操作数据库，所有的关系型数据库都可以使用通用的SQL语句进行管理。

结构化查询语言(Structured Query Language，简称SQL)定义了操作所有关系型数据库的规则，每种数据库操作的方式存在不一样的地方，这称为数据库“方言”。SQL语句可以单行或多行书写，以分号结尾；MySQL数据库的SQL语句不区分大小写，关键字建议大写；MySQL三种注释，单行注释(–和MySQL特有的#))，多汗注释(/**/)。

MySQL命令行操作

-- 启动MySQL服务
net start mysql
-- 关闭MySQL服务
net stop mysql
-- 登录MySQL
mysql -u用户名 -p密码
mysql -hIP地址 -u用户名 -p密码
mysql --host = ip地址 --user = 用户名 --password = 密码
-- 退出MySQL
exit、quit
-- 备份数据库
mysqldrmp -u用户名 -p密码 数据库名称 > 保存的路径
-- 还原数据库
source SQL文件路径

SQL常用数据类型

注意 : 除了数字类型的数据无需使用单引号或双引号括起来，其它数据类型都需要使用！

SQL语句的分类

• 数据定义语言(Data Definition Language，简称DDL)是用来定义数据库对象的，如数据库、数据库表。

• 数据操作语言(Data Manipulation Language，简称DML)是用来对数据库表中的数据进行增删改的。

• 数据查询语言(Data Query Language，简称DQL)是用来查询数据库表中记录(数据)的。

• 数据控制语言(Data Control Language，简称DCL)是用来定义数据库访问权限和安全级别及创建用户的。

数据定义语言

-- 创建数据库并指定字符集
CREATE DATABASE [IF NOT EXISTS] 数据库名 [CHARACTER SET 字符集名];
-- 删除数据库
DROP DATABASE [IF EXISTS] 数据库名;
-- 修改数据库字符集
ALTER DATABASE 数据库名 CHARACTER SET 字符集名;
-- 查询所有数据库
SHOW DATABASES;
-- 查询数据库字符集(创建语句)
SHOW CREATE DATABASE 数据库名;
-- 使用数据库
USE 数据库名;
-- 查询当前正在使用的数据库
SELECT DATABASE();

-- 创建表并添加字段
CREATE TABLE 表名(
    字段1 数据类型,
    字段N 数据类型
);
-- 复制表结构，不复制数据
CREATE TABLE 表名 LIKE 源表;
-- 复制表数据到新表
INSERT INTO 表名 SELECT * FROM 源表;
-- 复制表结构及表数据(无约束)
CREATE TABLE 表名 SELECT * FROM 源表;
-- 删除表
DROP TABLE [IF EXISTS] 表名;
-- 修改表名
ALTER TABLE 表名 RENAME TO 新表名;
-- 修改表字符集
ALTER TABLE 表名 CHARACTER SET 字符集名;
-- 添加一个字段(列)
ALTER TABLE 表名 ADD 字段名 数据类型;
-- 修改字段名、数据类型
ALTER TABLE 表名 CHANGE 字段名 新字段名 新数据类型;
-- 修改字段数据类型
ALTER TABLE 表名 MODIFY 字段名 新数据类型;
-- 删除字段
ALTER TABLE 表名 DROP 字段名;
-- 查询数据库中所有表
SHOW TABLES;
-- 查询表结构(字段)
DESC 表名;
-- 查询表字符集(创建语句)
SHOW CREATE TABLE 表名;

数据操作语言

-- 向表中添加数据，字段和字段值要一一对应
INSERT INTO 表名(字段1, 字段N) VALUES(字段值1, 字段值N);
-- 向表中添加数据，可以不定义字段名，但必须给所有字段赋值
INSERT INTO 表名 VALUES(字段值1, 字段值N);
-- 向表中添加多条数据，前提是同表同列，且必须给所有字段赋值
INSERT INTO 表名 VALUES(字段值1, 字段值N), (字段值1, 字段值N);
-- 删除表中的数据，如果不加条件，则删除表中的所有记录
DELETE FROM 表名 [WHERE 条件];
-- 删除表中的所有记录，有多少条记录就会执行多少次删除操作
DELETE FROM 表名;
-- 先删除表，再创建一张一模一样的没有数据的空表，效率更高
TRUNCATE TABLE 表名;
-- 修改表中的数据，如果不加条件，则修改表中的所有记录
UPDATE 表名 SET 字段1 = 字段值1, 字段N = 字段值N [WHERE 条件];

数据查询语言

查询语法

SELECT 
    字段列表/聚合函数 
FROM 
    表名列表 
WHERE 
    条件列表 
GROUP BY 
    分组字段 
HAVING 
    分组后条件 
ORDER BY 
    排序 
LIMIT 
    分页限定;

基础查询

-- 查询表中所有记录
SELECT * FROM 表名;
-- 查询单个字段列表
SELECT 字段 FROM 表名;
-- 查询多个字段列表
SELECT 字段1, 字段N FROM 表名;
-- 查询单个字段列表并去除重复的结果集
SELECT DISTINCT 字段 FROM 表名;
-- 查询多个字段列表并去除重复的结果集，查询的多个字段都一样才会去重
SELECT DISTINCT 字段1, 字段N FROM 表名;
-- 查询字段间四则运算的结果，如果有NULL参与的运算，运算结果都为NULL
SELECT 字段A + 字段B FROM 表名;
-- 查询字段间四则运算的结果，如果字段B为NULL，则将字段B的值替换为X再计算
SELECT 字段A - IFNULL(字段B, X) FROM 表名;
-- 为字段起别名
SELECT 字段 [AS] 别名 FROM 表名;

条件查询

-- 查询字段等于值N的所有记录，比较运算符有>、<、>=、<=、=、!=、<>
SELECT * FROM 表名 WHERE 字段 = 值N;
-- 查询字段不等于值N的所有记录，排除NULL值
SELECT * FROM 表名 WHERE 字段 <> 值N;
-- 查询字段大于等于值1且小于等于值2的所有记录，逻辑运算符有&&、||、!
SELECT * FROM 表名 WHERE 字段 >= 值1 AND 字段 <= 值2;
-- 查询字段在值1和值2之间的所有记录，且包含值1和值2
SELECT * FROM 表名 WHERE 字段 BETWEEN 值1 AND 值2;
-- 查询字段为值1或字段为值2的所有记录
SELECT * FROM 表名 WHERE 字段 = 值1 OR 字段 = 值2;
-- 查询字段为值1或字段为值2的所有记录
SELECT * FROM 表名 WHERE 字段 IN (值1, 值2);
-- 查询字段为NULL的所有记录
SELECT * FROM 表名 WHERE 字段 IS NULL;
-- 查询字段不为NULL的所有记录
SELECT * FROM 表名 WHERE 字段 IS NOT NULL;

模糊查询

-- 查询字段中第一个字符为X的所有记录，占位符%表示多个任意字符
SELECT * FROM 表名 WHERE 字段 LIKE "X%";
-- 查询字段中第二个字符为X的所有记录，占位符_表示单个任意字符
SELECT * FROM 表名 WHERE 字段 LIKE "_X%";
-- 查询字段为三个字符的所有记录
SELECT * FROM 表名 WHERE 字段 LIKE "___";
-- 查询字段中包含X的所有记录
SELECT * FROM 表名 WHERE 字段 LIKE "%X%";

排序查询

-- 按字段升序进行排序，不加ASC默认也是升序
SELECT * FROM 表名 ORDER BY 字段 ASC;
-- 按字段降序进行排序
SELECT * FROM 表名 ORDER BY 字段 DESC;
-- 按字段1进行升序，如果字段1的值一样，则再按字段2进行降序排序
SELECT * FROM 表名 ORDER BY 字段1 ASC, 字段2 DESC;

聚合函数

-- 聚合函数就是将一列数据作为一个整体进行纵向的计算

-- 查询记录的个数，会排除NULL值的存在，尽量使用非空的列，如主键
SELECT COUNT(字段) FROM 表名;
-- 先判断字段中是否有NULL，有就将NULL替换为0，再查询记录的个数
SELECT COUNT(IFNULL(字段, 0)) FROM 表名;
-- 查询记录的个数，只要记录中有一个字段不为NULL，就能算一条记录
SELECT COUNT(*) FROM 表名;

SELECT MAX(字段) FROM 表名; -- 查询字段中的最大值 
SELECT MIN(字段) FROM 表名; -- 查询字段中的最小值
SELECT SUM(字段) FROM 表名; -- 查询字段所有值的和
SELECT AVG(字段) FROM 表名; -- 查询字段中的平均值

分组查询

-- GROUP BY分组后可查询的字段有分组字段、聚合函数
-- WHERE在分组前进行限定，不满足条件不参与分组，WHERR后不可以跟聚合函数
-- Having在分组后进行限定，不满足结果不会被查询出来，HAVING后可以进行聚合函数的判断

-- 按字段1进行分组，查询字段1及每组记录的条数
SELECT 字段1, COUNT(*) FROM 表名 GROUP BY 字段1;
-- 按字段1进行分组，查询字段1及每组记录的条数，需满足WHERE和HAVING的条件限定
SELECT 字段1, COUNT(*) FROM 表名 [WHERE 条件] GROUP BY 字段1 [HAVING 条件];

分页查询

-- LIMIT 开始的索引, 每页查询的条数；LIMIT是MySQL的“方言”
-- 开始的索引 = (当前页码 - 1) * 每页显示的条数

SELECT * FROM 表名 LIMIT 00, N; -- 第一页，查询N条记录
SELECT * FROM 表名 LIMIT 1N, N; -- 第二页，查询N条记录
SELECT * FROM 表名 LIMIT 2N, N; -- 第三页，查询N条记录

数据控制语言

用户管理

-- 添加用户，主机名为%表示可以被远程登录
CREATE USER "用户名" @"主机名" IDENTIFIED BY "密码";
-- 删除用户
DROP USER "用户名" @"主机名";
-- 修改用户密码，需刷新MySQL的系统权限相关表
UPDATE USER SET PASSWORD = PASSWORD("新密码") WHERE USER = "用户名";
FLUSH PRIVILEGES;
-- 修改用户密码
SET PASSWORD FOR "用户名" @"主机名" = PASSWORD("新密码");
-- 查询用户，需要先切换到mysql数据库
SELECT * FROM USER;
-- MySQL中忘记了root用户密码
1.管理员身份打开CMD-->net stop mysql 停止MySQL服务
2.使用无验证方式启动MySQL服务-->mysqld --skip-grant-tables
3.打开新的CMD窗口，直接输入mysql命令后回车就可以登录成功了
4.USE mysql;
5.SET PASSWORD FOR "root" @"主机名" = PASSWORD("新密码");
6.打开任务管理器，手动结束mysqld.exe的进程
7.启动MySQL服务后就可以使用新密码登录了

权限管理

-- 查询权限
SHOW GRANTS FOR "用户名" @"主机名";
-- 授予权限，权限列表为All表示所有权限，数据库名和表名为*表示所有数据库和所有表
GRANT 权限列表 ON 数据库名.表名 TO "用户名" @"主机名";
-- 撤销权限，权限有CREATE、SELECT、UPDATE、DELETE等
REVOKE 权限列表 ON 数据库名.表名 FROM "用户名" @"主机名";

MySQL约束

非空约束

-- 约束就是对表中的数据进行限定，以此来保证数据的正确性、有效性和完整性
-- 非空约束 NOT NULL 字段中的值不能为NULL

-- 创建表时为字段添加非空约束
CREATE TABLE 表名(
    ···
    字段 数据类型 NOT NULL
);
-- 创建表后为字段添加非空约束，前提是表的字段中不能存在NULL值
ALTER TABLE 表名 MODIFY 字段 数据类型 NOT NULL;
-- 删除此字段的非空约束
ALTER TABLE 表名 MODIFY 字段 数据类型;

唯一约束

-- 唯一约束 UNIQUE 字段中的值不能重复，唯一约束限定的列的值可以有多个NULL

-- 创建表时为字段添加唯一约束
CREATE TABLE 表名(
    ···
    字段 数据类型 UNIQUE
);
-- 创建表后为字段添加唯一约束，前提是表的字段中不能存在重复的值
ALTER TABLE 表名 MODIFY 字段 数据类型 UNIQUE;
-- 删除此字段的唯一约束
ALTER TABLE 表名 DROP INDEX 字段;

主键约束

-- 主键约束 PRIMARY KEY 非空且唯一
-- 一张表只能有一个字段为主键，主键就是表中记录的唯一标识
-- 如果某一字段是数值类型的，可使用AUTO_INCREMENT来完成值的自动增长

-- 创建表时添加主键约束并设置为自动增长
CREATE TABLE 表名(
    ···
    字段 数据类型 PRIMARY KEY AUTO_INCREMENT
);
-- 创建表后添加主键约束
ALTER TABLE 表名 MODIFY 字段 数据类型 PRIMARY KEY;
-- 删除此表的主键约束
ALTER TABLE 表名 DROP PRIMARY KEY;
-- 创建表后添加自动增长
ALTER TABLE 表名 MODIFY 字段 数据类型 AUTO_INCREMENT;
-- 删除自动增长
ALTER TABLE 表名 MODIFY 字段 数据类型;

外键约束

-- 外键约束 FOREIGN KEY 让表与表产生关系，从而保证数据的正确性

-- 创建表时添加外键约束
CREATE TABLE 表名(
    ···
    外键字段名 数据类型;
    CONSTRAINT 外键名 FOREIGN KEY (外键字段名) REFERENCES 主表名(主表字段名)
);
-- 创建表后添加外键约束
ALTER TABLE 表名 ADD
    CONSTRAINT 外键名 FOREIGN KEY (外键字段名) REFERENCES 主表名(主表字段名);
-- 删除外键
ALTER TABEL 表名 DROP FOREIGN KEY 外键名;
-- 级联操作，创建表后添加外键约束并设置级联
ALTER TABLE 表名 ADD
    CONSTRAINT 外键名 FOREIGN KEY (外键字段名) REFERENCES 主表名(主表字段名)
        ON UPDATE CASCADE  -- 级联更新
        ON DELETE CASCADE; -- 级联删除

MySQL多表

多表查询可分为内连接查询、外连接查询以及子查询。笛卡尔积指的是在数学中两个集合X和Y的所有组成情况，要完成多表查询就需要消除无用的数据。

多表关系实现

• 一对一，可以在任意一方添加唯一外键指向另一方的主键。
• 一对多，(多对一)可以在多的一方建立外键指向另一方的主键。
• 多对多，需借助第三张中间表，表中至少包含的两个字段来作为第三张表的外键分别指向两张表的主键。

内连接查询

-- 隐式内连接，使用WHERE条件消除无用数据
SELECT 字段列表 FROM 表名列表 WHERE 条件列表;
-- 显式内连接
SELECT 字段列表 FROM 表1 [INNER] JOIN 表2 ON 条件;

注意 : 使用内连接查询需要知道是从哪些表中查询数据，条件是什么，以及要查询的字段有哪些？

外连接查询

-- 左外连接，查询的是左表所有数据及其交集的部分
SELECT 字段列表 FROM 表1 LEFT [OUTER] JOIN 表2 ON 条件;
-- 右外连接，查询的是右表所有数据及其交集的部分
SELECT 字段列表 FROM 表1 RIGHT [OUTER] JOIN 表2 ON 条件;

嵌套子查询

-- 查询中嵌套查询，称嵌套查询为子查询
-- 子查询结果是单行单列的，子查询可以作为条件，使用运算符去判断，>、<、>=、<=、=、<>
-- 子查询结果是多行单列的，子查询可以作为条件，使用运算符IN来判断
-- 子查询结果是多行多列的，子查询可以作为一张虚拟表来参与查询

MySQL事务

事务指的是要做的或所作的事情，如果一个包含多个步骤的业务操作被事务管理，那么这些操作要么同时成功，要么同时失败。

-- 开启事务
START TRANSACTION;
-- 回滚事务
ROLLBACK;
-- 提交事务
COMMIT;

事务提交方式

• 自动提交，MySQL数据库就是自动提交的，一条DML语句就会自动提交一次事务。
• 手动提交，Oracle数据库默认就是手动提交的，需要先开启事务再提交。

-- 查看事务的默认提交方式，查询结果为1代表自动提交，为0代表手动提交
SELECT @@AUTOCOMMIT;
-- 修改默认提交方式为手动提交
SET @@AUTOCOMMIT = 0;

事务四大特征

• 原子性，是不可分割的最小操作单位，要么同时成功，要么同时失败。
• 持久性，当事务提交或回滚后，数据库会持久化的保存数据。
• 隔离性，隔离状态执行事务，多个事务之间相互独立。
• 一致性，事务操作前后，数据库的完整性约束没有被破坏。

事务隔离级别

多个事务之间是隔离的、相互独立的。但是如果多个事务操作同一批数据则会引发一些问题，设置不同的隔离级别就可以解决这些问题。多个事务之间会存在的问题如下，

• 脏读，一个事务读取到另一个事务中没有提交的数据。
• 虚读，又称不可重复读，在同一个事务中两次读取到的数据不一样。
• 幻读，一个事务操作数据表中的所有记录，另一个事务添加了一条数据，则第一个事务查询不到自己的修改。

-- 读取未读，产生的问题，脏读、不可重复读、幻读
READ UNCOMMITTED;
-- 读已提交，产生的问题，不可重复读、幻读 (Oracle默认)
READ COMMITTED;
-- 可重复读，产生的问题，幻读 (MySQL默认)
REPEATABLE READ;
-- 串行化，可解决所有问题
SERIALIZABLE;
-- 数据库查询隔离级别
SELECT @@TX_ISOLATION;
-- 数据库设置隔离级别
SELECT GLOBAL TRANSACTION ISOLATION LEVEL 级别字符串;

注意 : 隔离级别从小到大安全性越来越高，但效率越来越低！

数据库设计

在设计数据库时需遵循一些规范，设计出合理的关系型数据库，这些不同的规范要求被称为不同的范式，各种范式呈递次规范，越高的范式数据冗余越小，要遵循后边的范式要求就必须先遵循前边的所有范式要求。目前关系型数据库有六种范式，第一范式(1NF)、第二范式(2NF)、第三范式(3NF)、巴斯·科德范式(BCNF)、第四范式(4NF)和第五范式(5NF，完美范式)。

• 函数函数依赖，A–>B，如果A属性(属性组)的值可以确定唯一B属性的值，则称B依赖于A。
• 完全函数依赖，A–>B，如果A是一个属性组，则B属性值的确认需要依赖A属性组中所有的属性值。
• 部分函数依赖，A–>B，如果A是一个属性组，则B属性值的确认只需依赖A属性组中某些属性值即可。
• 传递函数依赖，A–>B,B–>C，如果通过A属性(属)的值可以确定唯一B属性的值，通过B属性(组)的值可以确定唯一C属性的值，则称C传递依赖于A。

注意 : 如果在一张表中一个属性(组)被其它属性完全依赖，则称这个属性(组)为该表的码，主属性指的是属性组中的所有属性，非主属性指的是除码属性(组)的属性！

JDBC

Java数据库连接(Java Database Connectivity，简称JDBC)是Sun公司定义的一套操作所有关系型数据库的规则(接口)。数据库产商实现这套接口并且提供数据库驱动Jar包，我们就可以使用这套接口来操作数据库。

DriverManager:驱动管理对象

• static synchronized void registerDriver(java.sql.Driver driver)注册驱动，告知程序该使用哪一个数据库驱动Jar包

• static Connection getConnection(String url, String name, String password)参数url指的是数据库连接的路径；user指的是数据库用户名；password指的是密码

Connection:数据库连接对象

• Statement createStatement()获取执行SQL的对象，在拼接SQL时会造成SQL注入的问题

• PreparedStatement prepareStatement(String sql)获取执行SQL的对象，使用预编译的SQL，参数使用?作为占位符可有效防止SQL注入的问题

• void setAutoCommit(boolean autoCommit)参数设置为false即开启事务

• void commit()当所有SQL都执行完提交事务

• void rollback()回滚事务，多用于catch中

Statement:执行SQL的对象

• boolean execute(String sql)可以执行任意SQL，不推荐使用

• int executeUpdate(String sql)用于执行insert、create、alter、drop等语句，返回值为影响的行数，返回值>0则执行成功，反之则失败

• ResultSet executeQuery(String sql)用于执行select语句

PreparedStatement:执行SQL的对象

• void setXxx(int parameterIndex, xxx x)给?赋值，参数parameterIndex指的是?从1开始的位置编号；x指的是?的值

ResultSet:结果集对象

• boolean next()游标向下移动一行并判断当前行是否为末尾行，是则返回false，反之返回true

• xxx getXxx(String columnLabel)用于获取数据，Xxx指的是数据类型；xxx指的是列从1开始的编号；参数columnLabel指的是列名

DB.sql

CREATE DATABASE db000;
USE db000;

-- 账户表
CREATE TABLE account(
    id INT PRIMARY KEY AUTO_INCREMENT,
    name VARCHAR(11) NOT NULL,
    money INT
);

INSERT INTO account VALUES
(NULL, 'chongyi', 100),
(NULL, 'lianger', 200),
(NULL, 'zhansan', 300);

Demo.java

import java.sql.*;

public class Demo {
    public static void main(String[] args) throws Exception {
        Connection conn = null;
        PreparedStatement prep = null;
        ResultSet rs = null;

        try {
            // 注册驱动，告诉程序该使用哪个数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            // 获取连接对象
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db000", "root", "root");
            // 开启事务
            conn.setAutoCommit(false);
            // 获取执行SQL的对象PreparedStatement
            prep = conn.prepareStatement("update account set money = 300 where id = ?");
            // 给?赋值
            prep.setInt(1, 4);
            // 执行SQL并判断是否执行失败
            if (prep.executeUpdate() <= 0) {
                System.out.println("SQL执行失败！");
            }
            
            // 手动制造异常
            int i = 1 / 0;
            
            // 获取执行SQL的对象PreparedStatement
            prep = conn.prepareStatement("select * from account");
            // 执行SQL并获取结果集
            rs = prep.executeQuery();
            // 遍历输出结果集中的内容
            while (rs.next()) {
                System.out.println(rs.getInt(1) + " " + rs.getString("name") + " " + rs.getInt("money"));
            }
            // 提交事务
            conn.commit();
        } catch (Exception e) {
            // 回滚事务
            if (conn != null) {
                conn.rollback();
            }
            e.printStackTrace();
        } finally {
            // 释放资源
            if (rs != null) {
                rs.close();
            }
            if (prep != null) {
                prep.close();
            }
            if (conn != null) {
                conn.close();
            }
        }
    }
}

/*------------------------------
SQL执行失败！
------------------------------*/

JDBCUtils

jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/db000
user=root
password=root

JDBCUtils.java

import java.sql.*;
import java.util.Properties;

public class JDBCUtils {
    private static String driver;
    private static String url;
    private static String user;
    private static String password;

    static {
        try {
            // 创建Properties集合对象
            Properties prop = new Properties();
            // 加载配置文件
            prop.load(JDBCUtils.class.getClassLoader().getResourceAsStream("jdbc.properties"));
            // 读取配置文件中的内容并赋值
            driver = prop.getProperty("driver");
            url = prop.getProperty("url");
            user = prop.getProperty("user");
            password = prop.getProperty("password");
            // 注册驱动
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
        获取连接
     */
    public static Connection getConnection() throws Exception {
        return DriverManager.getConnection(url, user, password);
    }

    /*
        释放资源
     */
    public static void close(Connection conn, PreparedStatement prep, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (prep != null) {
            try {
                prep.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

数据库连接池

数据库连接池其实就是一个用于存放数据库连接的容器(集合)。当系统初始化后容器会被创建并且申请一些连接对象，当用户来访问数据库时会从容器中获取连接对象，用户访问完后会将对象归还给容器。使用数据库连接池可以有效的节约资源，且用户访问更高效。实现数据库连接池的标准接口为javax.sql.DataSource，我们一般不会去实现它，都是由数据库产商来实现。常见的数据库连接池技术有c3p0、druid等。

• Connection getConnection()用于获取连接

• void close()用于归还连接，如果连接对象Connection是从连接池中获取的，那么调用该方法则不再关闭连接了，而是归还连接

c3p0-config.xml

<c3p0-config>
    <!-- 使用默认配置读取数据库连接池对象 -->
    <default-config>
        <!-- 数据库连接参数 -->
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db000</property>
        <property name="user">root</property>
        <property name="password">root</property>

        <!-- 初始化申请的连接数量 -->
        <property name="initialPoolSize">5</property>
        <!-- 最大的连接数量 -->
        <property name="maxPoolSize">10</property>
        <!-- 超时时间 -->
        <property name="checkoutTimeout">3000</property>
    </default-config>

    <!-- 使用自定义配置读取数据库连接池对象 -->
    <named-config name="other-c3p0">
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/db000</property>
        <property name="user">root</property>
        <property name="password">root</property>

        <property name="initialPoolSize">5</property>
        <property name="maxPoolSize">10</property>
        <property name="checkoutTimeout">3000</property>
    </named-config>
</c3p0-config>

druid.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///db000
username=root
password=root
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大等待时间
maxWait=3000

Demo.java

import com.alibaba.druid.pool.DruidDataSourceFactory;
import com.mchange.v2.c3p0.ComboPooledDataSource;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import java.util.Random;

public class Demo {
    public static void main(String[] args) throws Exception {
        DataSource ds;
        Connection conn;

        if ((new Random().nextInt(2)) == 0) {
            // 使用c3p0获取连接池对象
            ds = new ComboPooledDataSource();
        } else {
            // 创建Properties集合的对象
            Properties prop = new Properties();
            // 加载配置文件
            prop.load(Demo.class.getClassLoader().getResourceAsStream("druid.properties"));
            // 使用druid获取连接池对象
            ds = DruidDataSourceFactory.createDataSource(prop);
        }
        // 获取连接对象
        conn = ds.getConnection();
        // 获取执行SQL的对象PreparedStatement
        PreparedStatement prep = conn.prepareStatement("select * from account");
        // 执行SQL并获取结果集
        ResultSet rs = prep.executeQuery();
        // 遍历输出结果集中的内容
        while (rs.next()) {
            System.out.println(rs.getInt(1) + " " + rs.getString("name") + " " + rs.getInt("money"));
        }
        // 释放资源使用JDBCUtils
        JDBCUtils.close(conn, prep, rs);
    }
}

/*------------------------------
1 chongyi 100
2 lianger 200
3 zhansan 300
------------------------------*/

JDBCUtils.java

import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

public class JDBCUtils {
    private static DataSource ds;

    static {
        try {
            // 创建properties集合对象
            Properties prop = new Properties();
            // 加载配置文件
            prop.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
            // 获取连接池对象
            ds = DruidDataSourceFactory.createDataSource(prop);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /*
        获取连接池
     */
    public static DataSource getDataSource() {
        return ds;
    }

    /*
        获取连接
     */
    public static Connection getConnection() throws SQLException {
        return ds.getConnection();
    }

    /*
        释放资源
     */
    public static void close(Connection conn, PreparedStatement prep, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (prep != null) {
            try {
                prep.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

HTML

超文本标记语言(Hyper Text Markup Language，简称HTML)是最基础的网页开发语言。超文本指的是用超链接的方法将各种不同空间的文字信息组织在一起的网状文本；标记语言指的是由标签构成的语言，标记语言并不是编程语言。单标签指的是只有一个结束标签的标签；双标签指的是有开始标签也有结束标签的一对标签；标签中嵌套的标签必须一一对应；在标签中可以定义属性，其属性是由键值对构成，值需使用引号引起来。

<!DOCTYPE html><html><head>
    <meta charset="UTF-8">
    <title>HTML</title>
</head><body>
    HelloWorld
</body></html>

常用标签

表单标签

表单是用于采集用户输入的数据的来和服务器进行交互的，它可以定义一个采集用户数据的范围。其属性action指的是提交数据的URL；method指的是提交的方式(get、post较为常用)，get请求的参数会在地址栏中显示，会封装到请求行中(post请求则会被封装到请求体中)，请求参数的大小有限制且不太安全；post请求刚好相反。表单项中的数据要想被提交就必须指定其name属性，表单项标签可以通过其type属性值来改变元素展示的样式。

CSS

层叠样式表(Cascading Style Sheets，简称CSS)不仅可以静态地修饰网页，还能配合各种脚本语言动态地对网页各元素进行格式化，层叠指的是多个样式可以作用在同一个HTML元素上且同时生效，使用CSS可以将内容展示和样式控制进行分离，从而降低耦合度并提高开发效率。

• 内联样式，标签内使用style属性；内部样式，head标签内定义style标签。
• 外部样式，head标签内定义link标签，设置其属性href；或在style标签内定义@import url(CSS文件路径)。

选择器 {
    ···
    属性: 属性值;
}

选择器

常用属性

JS

(JavaScript，简称JS)是一种具有函数优先的轻量级、解释性或即时编译型的编程语言。其运行在客户端浏览器中，每个浏览器都有JS的解析引擎。JS可用来增强用户和HTML页面的交互过程；可以控制HTML让页面有一些动态的效果以增强用户的体验。JS = ECMAScript(客户端脚本语言的标准)+ JS自己特有的内容。JS代码可以定义在HTML页面的任何地方且可定义多个，但定义的位置会影响执行顺序。

• JS内部定义，定义script标签，标签体的内容就是JS代码。
• JS外部引入，定义script标签，通过src属性引入外部JS文件。

数据类型

JS中的数据类型可分为基本数据类型(number、string、boolean、null、undefined)和引用数据类型(对象)。number类型中NaN(not a number)指的是一个不是数字的数字类型。

变量

变量指的是一块存储数据的内存空间，Java是强类型语言，而JS是弱类型语言。强类型指的是在开辟变量存储空间时定义了空间将来存储数据的类型，只能存储固定类型的数据；弱类型指的是在开辟变量存储空间时不定义空间将来的存储数据的类型，可存放任意类型的数据。typeof()方法可以获取变量的类型，null运算后得到的是Object。定义变量时如果使用var关键字则该变量为局部变量；不使用该变量则为全局变量。

运算符

JS中运算符可分为算数运算符、赋值运算符、比较运算符、逻辑运算符和三元运算符。===(全等于)在比较前会先判断类型是否相同，相同则继续判断数值，不同则直接返回false。

流程控制

流程控制可分为顺序结构、选择结构和循环结构，如if、else、switch、for、while、do···while等。

基本对象

<!DOCTYPE html><html><head>
    <meta charset="UTF-8">
    <title>JavaScript</title>
</head><body>
    <script>
        // 定义一个方法
        function fun(x, y) {
            // 页面输出
            document.write(x + y);
            // 控制台输出
            console.log(x - y);
        }
        // 调用方法
        fun(2, 1);
        // 获取方法的形参个数
        var num = fun.length;
    
        // 定义数组
        var ar1 = new Array(1, 2, 3, 4);
        var ar2 = new Array(4);
        var ar3 = [1, 2, 3, 4];
        // 将数组元素按指定的分隔符拼接成字符串
        var str = ar3.join("-");
        // 向数组末尾添加一个或多个元素并返回数组长度
        var num = ar3.push(5, 6);
        // 调用并返回数组长度
        var num = ar3.length;
    
        // 创建日期对象
        var date = new Date();
        // 获取当前Date对象对应的时间本地字符串格式
        var tim = date.toLocaleString();
        // 获取毫秒值
        var tod = date.getTime();
    
        // 随机数，获取1-100范围内的随机数
        var nu1 = Math.random() * 100 + 1;
        // 去尾法，获取1-100内的整数
        var nu2 = Math.floor(nu1);
        // 进一法
        var nu3 = Math.ceil(nu1);
        // 四舍五入
        var nu4 = Math.round(nu1);
        // 圆周率
        var pi1 = Math.PI;
    
        // 创建正则表达式
        var re1 = new RegExp("^\\w{6,16}$");
        var re2 = /^\w{6,16}$/;
        // 定义一个字符串
        var str = "goodhbao";
        // 验证指定字符串是否符合正则定义的规范
        var fla = re2.test(str);
    
        // 定义一个字符串
        var str = "https://www.baidu.com?wd=计算机";
        // URI编码，后者编码更全
        var encode1 = encodeURI(str);
        var encode2 = encodeURIComponent(str);
        // URI解码
        var decode1 = decodeURI(encode1);
        var decode2 = decodeURIComponent(encode2);
        // 将部分字符串转换为数字
        var num = parseInt("123abc");
        // 定义一个变量为NaN
        var nnn = NaN;
        // 判断是否为NaN
        document.write(nnn == NaN); // false
        document.write(isNaN(nnn)); // true
        // 将字符串形式的JS代码当作脚本代码来执行
        eval(alert("Hello"));
    </script>
</body></html>

事件

事件是JS和HTML之间交互的手段，即某些组件被执行了某些操作后而触发了某些代码的执行。事件指的就是某些操作，如单击、双击等；事件源指的就是组件，如按钮、文本框等；监听器指的就是代码。注册监听就是将事件、事件源、监听器结合在一起，当事件源上发生了某个事件则会触发某个监听器代码。

事件绑定

• 在html标签上指定事件的属性，属性值就是JS代码。
• 通过JS获取元素对象并指定事件属性(设置一个函数)。

常用事件

<!DOCTYPE html><html><head>
    <meta charset="UTF-8">
    <title>JavaScript</title>
</head><body onload="alert('加载事件触发')">
    <input type="button" onclick="alert('单击事件触发')" value="单击">
    <input type="button" ondblclick="alert('双击事件触发')" value="双击"><br>
    <input type="text" onchange="alert('内容改变事件触发')"><br>
    <input type="text" onfocus="console.log('获得焦点事件触发')"><br>
    <input type="text" onblur="alert('失去焦点事件触发')"><br>
    <input type="text" onkeydown="alert('按键按下事件触发')"><br>
    <input type="text" onkeypress="alert('部分按键按下事件触发')"><br>
    <input type="text" id="sk"><br>

    <script>
        document.getElementById("sk").onkeyup = function() {
            alert("按键松开事件触发");
        }
    </script>
</body></html>

BOM

浏览器对象模型(Browser Object Model，简称BOM)指的是将浏览器各个组成部分封装成对象，由Window窗口对象、Navigator浏览器对象、Screen显示器屏幕对象、History历史记录对象、Location地址栏对象组成。

<!DOCTYPE html><html><head>
    <meta charset="UTF-8">
    <title>JavaScript</title>
</head><body>
    <script>
        // 弹出框
        window.alert("弹出带有一段消息和一个确认按钮的警告框");
        document.write(confirm("弹出带有一段消息以及确认、取消按钮的对话框，确定返回true，取消返回false"));
        console.log(prompt("弹出带有一段消息以及确认、取消按钮和供用户输入的对话框，返回值为用户输入的值"));
        // 打开一个新的浏览器窗口并返回一个新的Window对象
        var win = window.open("https://www.baidu.com");
        // 关闭浏览器窗口，谁调用关谁
        win.close();
        // 在指定毫秒值后调用JS代码或函数，返回值为用于取消定时器的唯一标识
        var tim = window.setTimeout("alert('指定毫秒值后弹出')", 3000);
        // 取消定时器
        clearTimeout(tim);
        // 循环在指定毫秒值后调用JS代码或函数
        var tim = setInterval(function() {
            alert("循环在指定毫秒值后弹出");
        }, 3000);
        // 取消定时器
        clearInterval(tim);

        // 重新加载当前页
        location.reload();
        // 获取当前页的URL
        alert(location.href);
        // 设置当前页的URL
        location.href = "https://www.baidu.com";

        // 加载当前页前一个URL
        history.back();
        // 加载当前页后一个URL
        history.forward();
        // 跳转当前页指定的URL，正数为后面的URL，负数为前面的URL
        history.go(2);
        // 返回当前页中URL数量
        alert(history.length);
    </script>
</body></html>

DOM

文档对象模型(Document Object Model，简称DOM)指的是将标记语言文档的各个组成部分封装为对象，我们可以使用这些对象来对标记语言文档进行CRUD的动态操作。

<!DOCTYPE html><html><head>
    <meta charset="UTF-8">
    <title>JavaScript</title>
    <style>
        #s1 {width: 200px; height: 200px; background-color: #00f;}
        #s2 {width: 100px; height: 100px; background-color: #0f0;}
        #s3 {width: 100px; height: 100px; background-color: #0ff;}
        .s4 {width: 100px; height: 100px; background-color: #aaa;}
    </style>
</head><body>
    <div id="iiii">1</div>
    <div class="c">2</div>
    <div name="nn">3</div>
    <div>4</div>

    <div id="s1">
        <div id="s2"></div>
    </div>

    <p id="p1">HelloWorld</p>
    <script>
        // 根据id属性获取元素对象，id属性值唯一
        document.getElementById("iiii").onclick = function() {
            alert(1);
        }
        // 根据class属性获取元素对象们，返回值是一个数组
        document.getElementsByClassName("c")[0].onclick = function() {
            alert(2);
        }
        // 根据name属性获取元素对象们
        document.getElementsByName("nn")[0].onclick = function() {
            alert(3);
        }
        // 根据标签名称获取元素对象们
        document.getElementsByTagName("div")[3].onclick = function() {
            alert(4);
        }

        // 获取s2元素对象
        var s2 = document.getElementById("s2");
        // 获取s2的父节点s1元素对象
        var s1 = s2.parentNode;
        // 删除子节点
        s1.removeChild(s2);
        // 创建一个div节点
        var s3 = document.createElement("div");
        // 设置属性
        s3.setAttribute("id", "s3");
        // 删除属性
        s3.removeAttribute("id");
        // 添加子节点
        s1.appendChild(s3);

        // 获取p1元素对象
        var p1 = document.getElementById("p1");
        // 设置元素的颜色
        p1.style.color = "#f00";
        // 设置元素的class属性
        p1.className = "s4";
        // 获取标签体内容并在控制台输出
        console.log(p1.innerHTML);
        // 更改标签体内容
        p1.innerHTML = "JavaScript";
    </script>
</body></html>