Mysql数据库、JDBC

最新推荐文章于 2024-10-07 23:02:18 发布

转载最新推荐文章于 2024-10-07 23:02:18 发布 · 249 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/u/3299202/blog/3062231

本文深入探讨Java Web开发中的自定义标签、MVC模式、三层结构及MySQL数据库操作，涵盖自定义标签的创建与使用、JavaBean规范、MVC模式解析、MySQL数据库的CRUD操作、SQL语句优化及存储过程、触发器等高级特性。

day15

1 课程回顾

自定义标签&编码实战

1）自定义标签步骤：

1.1 编写标签处理器类，继承SimpleTagSupport类，覆盖doTag方法

1.2 在WEB-INF目录下建立tld文件，在tld配置标签

1.3 在jsp页面导入标签库，使用taglib指令

1.4 在jsp页面中使用标签库中的标签

2）自定义标签生命周期：

SimpleTag接口：

setJspContext(JspContext context) --传入pagContext对象

setParent(JspTag tag) --传入父标签对象

setXXX(参数) --给属性赋值

setJspBody(JspFrament jspBody) --传入标签体内容

doTag() --执行标签

3）自定义标签的作用：

3.1 控制是否输出标签体内容

输出： this.getJspBody().invoke(null)

不输出: 不调用invoke(null)方法

3.2 控制标签余下内容是否输出

输出：什么不都做！

不输出：抛出SkipPageException异常

3.3 重复输出标签体内容

重复调用： this.getJspBody().invoke(null)

3.4 修改标签体内容

StringWriter sw = new StringWriter();

this.getJspBody().invoke(sw);

String content = sw.toString();

//修改内容

//手动输出到浏览器

this.getJspContext().getOut().writer(修改过的内容);

3.5 带属性的标签

a）在标签处理器类中声明成员变量和setter方法，用于给属性变量赋值。

b）在tld文件中声明属性

c）使用属性

4）JavaBean规范

4.1 必须要有无参的构造方法

4.2 所有成员属性必须私有化（private）

4.3 必须提供公开的getter和setter方法

5）MVC开发模式

MVC就是servlet+jsp+javabean的开发模式

M，Model，javabean实现，封装业务数据

V，View，jsp实现，显示数据

C，Controller，servlet实现，接收参数，调用业务逻辑，跳转视图

6）三层结构开发

dao层：数据访问对象。实现对数据的操作相关的方法

service层：业务逻辑对象。实现对项目的业逻辑处理相关的方法

web层：表现层。处理和用户直接相关的，接收参数，处理参数，跳转视图，展示数据。

今天的目标： mysql数据库

2.3 市面上数据库软件

Oracle，甲骨文公司的产品。当前最流行应用最广泛的数据库软件。和java语言兼容非常好。

适合中大型，中大应用。

SQL Server: 是微软公司的产品。window平台应用非常广泛。和c#，net平台兼容非常好。

DB2： IBM公司的产品。IBM服务器--> UNIX -> DB2- > Websphere

MySQL: 开源组织的产品。甲骨文公司的产品。免费！！！和java语言兼容非常好！适合中小企业，中小应用

关系型数据库。

MongoDB：非关系型数据库。

2.4 MySQL入门

1）到mysql官网下载。

2）安装mysql软件

3）使用

验证是否成功

打开cmd -> 输入 mysql -u root -p 回车 -> 输入密码回车

C:\Users\APPle>mysql -u root -p

3 MySQL数据库

3.1 mysql数据存储结构

先数据库，再表，再有数据

4 数据库管理

4.1 查询所有数据库

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |     -- mysql元数据，基础数据
| mysql              |    --mysql配置数据库，其中包含用户信息。（用户名和密码，权限管理）
| performance_schema |    --mysql数据库软件的运行数据，日志信息，性能数据
| test               |     --测试数据库。空的
+--------------------+
4 rows in set (0.00 sec)

4.2 创建数据库

mysql> create database day15       -- 指定默认字符集创建数据库
    -> default character set utf8
    -> ;
Query OK, 1 row affected (0.00 sec)

4.3 查看数据库的默认字符集

mysql> show create database day15;
+----------+----------------------------------------------------------------+
| Database | Create Database                                                |
+----------+----------------------------------------------------------------+
| day15    | CREATE DATABASE `day15` /*!40100 DEFAULT CHARACTER SET utf8 */ |
+----------+----------------------------------------------------------------+
1 row in set (0.00 sec)

4.4 删除数据库

mysql> drop database day15;
Query OK, 0 rows affected (0.01 sec)

4.5 修改数据库

mysql> alter database day15 default character set gbk;

Query OK, 1 row affected (0.00 sec)

5 表管理

选择数据库

5.1 查看所有表

mysql> show tables;
+-----------------+
| Tables_in_day15 |
+-----------------+
| student         |
+-----------------+
1 row in set (0.00 sec)

5.2 创建表

mysql> create table student(
    -> sid int,
    -> sname varchar(20),
    -> sage int
    -> );
Query OK, 0 rows affected (0.01 sec)

5.3 查看表结构


mysql> desc student;
+-------+-------------+------+-----+---------+-------+
| Field | Type        | Null | Key | Default | Extra |
+-------+-------------+------+-----+---------+-------+
| sid   | int(11)     | YES  |     | NULL    |       |
| sname | varchar(20) | YES  |     | NULL    |       |
| sage  | int(11)     | YES  |     | NULL    |       |
+-------+-------------+------+-----+---------+-------+
3 rows in set (0.01 sec)

5.4 删除表

mysql> drop table student;
Query OK, 0 rows affected (0.01 sec)

5.5 修改表

1）添加字段

mysql> alter table student add column sgender varchar(2);

Query OK, 0 rows affected (0.03 sec)

Records: 0 Duplicates: 0 Warnings: 0

2）删除字段

mysql> alter table student drop column sgender;

Query OK, 0 rows affected (0.03 sec)

Records: 0 Duplicates: 0 Warnings: 0

3）修改字段类型

mysql> alter table student modify column remark varchar(100);

Query OK, 0 rows affected (0.07 sec)

Records: 0 Duplicates: 0 Warnings: 0

4）修改字段名称

mysql> alter table student change column sgender gender varchar(2);

Query OK, 0 rows affected (0.03 sec)

Records: 0 Duplicates: 0 Warnings: 0

5）修改表名称

mysql> alter table student rename to teacher;

Query OK, 0 rows affected (0.01 sec)

6 增删改数据

-- ********一、增删改数据********* ---
-- 1.1 增加数据
-- 插入所有字段。一定依次按顺序插入
INSERT INTO student VALUES(1,'张三','男',20);
-- 注意不能少或多字段值
-- INSERT INTO student VALUES(2,'李四','女');
-- 插入部分字段
INSERT INTO student(id,NAME) VALUES(2,'李四');

-- 1.2 修改数据
-- 修改所有数据（建议少用）
UPDATE student SET gender='女';
-- 带条件的修改（推荐使用）
UPDATE student SET gender='男' WHERE id=1; -- 修改id为1的学生，修改性别为男
-- 修改多个字段,注意: SET 字段名=值,字段名=值,....
UPDATE student SET gender='男',age=30 WHERE id=2;

-- 1.3 删除数据
-- 删除所有数据（建议少用）
DELETE FROM student;
-- 带条件的删除(推荐使用)
DELETE FROM student WHERE id=2;
--  另一种方式
-- delete from: 可以全表删除      1)可以带条件删除  2）只能删除表的数据，不能删除表的约束     3)使用delete from删除的数据可以回滚（事务）
-- truncate table: 可以全表删除   1）不能带条件删除 2）即可以删除表的数据，也可以删除表的约束 3）使用truncate table删除的数据不能回滚
TRUNCATE TABLE student;

7 查询数据（重点）

7.1 查询所有列

-- 2.1 查询所有列
SELECT * FROM student;

7.2 查询指定列

-- 2.2 查询指定列
SELECT id,NAME,gender FROM student;

7.3 查询时添加常量列

-- 2.4 查询时添加常量列
-- 需求： 在查询student表时添加一个班级列，内容为“java就业班”
SELECT id,NAME,gender,age,'java就业班' AS '年级'  FROM student;

7.4 查询时合并列

-- 2.5 查询时合并列
-- 需求： 查询每个学生的servlet和jsp的总成绩
SELECT id,NAME,(servlet+jsp) AS '总成绩' FROM student;
-- 注意：合并列只能合并数值类型的字段
SELECT id,(NAME+servlet) FROM student;

7.5 查询时去除重复记录

-- 2.6 查询时去除重复记录(DISTINCT)
-- 需求： 查询学生的性别     男 女
SELECT DISTINCT gender FROM student;
-- 另一种语法
SELECT DISTINCT(gender) FROM student;
-- 需求: 查询学生所在的地区
SELECT DISTINCT address FROM student;

7.6 条件查询

-- 2.7 条件查询(where)
-- 2.7.1 逻辑条件： and(与)     or(或)
-- 需求： 查询id为2，且姓名为李四的学生
SELECT * FROM student WHERE id=2 AND NAME='李四'; -- 交集

-- 需求： 查询id为2，或姓名为张三的学生
SELECT * FROM student WHERE id=2 OR NAME='张三'; -- 并集

-- 2.7.2 比较条件： >   <   >=  <=  =  <>(不等于)     between and (等价于>= 且 <=)
-- 需求： 查询servlet成绩大于70分的学生
SELECT * FROM student WHERE servlet>70;

-- 需求： 查询jsp成绩大于等于75，且小于等于90分的学生
SELECT * FROM student WHERE jsp>=75 AND jsp<=90;
-- 另一个语法
SELECT * FROM student WHERE jsp BETWEEN 75 AND 90; -- (包前包后)

SELECT * FROM student WHERE gender<>'男';


-- 2.7.3 判空条件(null 空字符串)：  is null / is not null / =''  / <>''
-- 需求： 查询地址为空的学生（包括null和空字符串）
-- null vs  空字符串
-- null：表示没有值
-- 空字符串：有值的！
-- 判断null
SELECT * FROM student WHERE address IS NULL ;
-- 判断空字符串
SELECT * FROM student WHERE address='';

SELECT * FROM student WHERE address IS NULL OR address=''; -- （包括null和空字符串）

-- 需求： 查询有地址的学生(不包括null和空字符串)
SELECT * FROM student WHERE address IS NOT NULL AND address<>'';

-- 2.7.4 模糊条件： like
-- 通常使用以下替换标记：
-- % : 表示任意个字符
-- _ : 表示一个字符
-- 需求： 查询姓‘张’的学生
SELECT * FROM student WHERE NAME LIKE '李%';

-- 需求： 查询姓‘李’，且姓名只有两个字的学生
SELECT * FROM student WHERE NAME LIKE '李_';

7.7 聚合查询

-- 2.8 聚合查询（使用聚合函数的查询）
 -- 常用的聚合函数： sum()  avg()  max()  min()  count()
-- 需求：查询学生的servlet的总成绩 (sum() :求和函数)
SELECT SUM(servlet) AS 'servlet的总成绩' FROM student;

-- 需求： 查询学生的servlet的平均分
SELECT AVG(servlet) AS 'servlet的平均分' FROM student;

-- 需求: 查询当前servlet最高分
SELECT MAX(servlet) AS '最高分' FROM student;

-- 需求： 查询最低分
SELECT MIN(servlet) AS '最低分' FROM student;

-- 需求： 统计当前有多少学生(count(字段))
SELECT COUNT(*) FROM student;

SELECT COUNT(id) FROM student;

-- 注意：count（）函数统计的数量不包含null的数据
-- 使用count统计表的记录数，要使用不包含null值的字段
SELECT COUNT(age) FROM student;

7.8 分页查询

-- 2.9 分页查询（limit 起始行,查询几行）
-- 起始行从0开始
-- 分页：当前页  每页显示多少条
-- 分页查询当前页的数据的sql: SELECT * FROM student LIMIT (当前页-1)*每页显示多少条,每页显示多少条;

-- 需求： 查询第1,2条记录（第1页的数据）
SELECT * FROM student LIMIT 0,2;
-- 查询第3,4条记录（第2页的数据）
SELECT * FROM student LIMIT 2,2;
-- 查询第5,6条记录（第3页的数据）
SELECT * FROM student LIMIT 4,2;
-- 查询第7,8条记录 (没有记录不显示)
SELECT * FROM student LIMIT 6,2;

7.9 查询排序

-- 2.10 查询排序（order by ）
-- 语法 ：order by 字段 asc/desc
-- asc: 顺序，正序。数值：递增，字母：自然顺序（a-z）
-- desc: 倒序，反序。数值：递减，字母：自然反序(z-a)

-- 默认情况下，按照插入记录顺序排序
SELECT * FROM student;

-- 需求： 按照id顺序排序
SELECT * FROM student ORDER BY id ASC;
SELECT * FROM student ORDER BY id; -- 默认正序

SELECT * FROM student ORDER BY id DESC;-- 反序

-- 注意：多个排序条件
-- 需求： 按照servlet正序，按照jsp的倒序
SELECT * FROM student ORDER BY servlet ASC,jsp DESC;

7.10 分组查询

-- 2.11 分组查询(group by)
-- 需求： 查询男女的人数
-- 预期结果：
  --  男   3
  --- 女   2
  -- 1) 把学生按照性别分组(GROUP BY gender)
  -- 2) 统计每组的人数(COUNT(*))
SELECT gender,COUNT(*) FROM student GROUP BY gender;

7.11 分组查询后筛选

-- 2.12 分组查询后筛选
-- 需求： 查询总人数大于2的性别
-- 1) 查询男女的人数
-- 2）筛选出人数大于2的记录(having)
--- 注意： 分组之前条件使用where关键字，分组之前条件使用having关键字
SELECT gender,COUNT(*) FROM student WHERE GROUP BY gender HAVING COUNT(*)>2;

总结：

mysql基础

1）mysql数据库作用：管理数据

2）mysql存储结构：

数据库：管理数据库（CRUD）

表：管理表（CRUD）

数据：管理数据

增删改：

查询：

12种查询（单表查询）

DAY16

1. 课程回顾

mysql基础

1）mysql存储结构：数据库 -> 表 -> 数据 sql语句

2）管理数据库：

增加： create database 数据库 default character utf8;

删除： drop database 数据库;

修改： alter database 数据库 default character gbk;

查询： show databases / show create database 数据库;

3) 管理表：

选择数据库：use 数据库;

增加： create table 表(字段名1 字段类型,字段名2 字段类型......);

删除： drop table 表;

修改：

添加字段： alter table 表 add [column] 字段名字段类型;

删除字段: alter table 表 drop [column] 字段名;

修改字段类型： alter table 表 modify 字段名新的字段类型;

修改字段名称： alter table 表 change 旧字段名新字段名字段类型;

修改表名称： alter table 表 rename [to] 新表名;

查询：

show tables / desc student;

4) 管理数据:

增加： insert into 表(字段1，字段2,。。。) values(值1，值2.。。。。);

删除： delete from 表 where 条件;

修改： update 表 set 字段1=值1，字段2=值2...... where 条件;

查询：

4.1）所有字段： select * from 表;

4.2）指定字段： select 字段1,字段2.... from 表;

4.3)指定别名： select 字段1 as 别名 from 表;

4.4 )合并列： select (字段1+字段2) from 表;

4.5)去重： select distinct 字段 from 表;

4.6)条件查询：

a)逻辑条件：and(与) or（或）

select * from 表 where 条件1 and/or 条件2

b）比较条件： > < >= <= = <> between and(在。。。之间)

select * from 表 where servlet>=90;

c）判空条件：

判断null： is null / is not null

判断空字符串： ='' / <>''

d）模糊条件： like

%: 替换任意个字符

_: 替换一个字符

4.7 分页查询：limit 起始行,查询行数

起始行从0开始

4.8 排序： order by 字段 asc/desc

asc: 正序，顺序

desc：反序，倒序

4.9 分组查询：group by 字段

4.10: 分组后筛选： having 条件

SQL语句的分类：

DDL：数据定义语言

create / drop / alter

DML：数据操作语句

insert / delete /update / truncate

DQL：数据查询语言：

select / show

今天的目标：

大纲：

1）数据约束

2）数据库设计（表设计）

3）存储过程

4）触发器

5）mysql权限问题

2 数据约束

2.1什么数据约束

对用户操作表的数据进行约束

2.2 默认值

作用：当用户对使用默认值的字段不插入值的时候，就使用默认值。

注意：

1）对默认值字段插入null是可以的。

2）对默认值字段可以插入非null

-- 1.1 默认值
CREATE TABLE student(
	id INT,
	NAME VARCHAR(20),
	address VARCHAR(20) DEFAULT '广州天河'  -- 默认值
)

DROP TABLE student;
-- 当字段没有插入值的时候，mysql自动给该字段分配默认值
INSERT INTO student(id,NAME) VALUES(1,'张三');

-- 注意：默认值的字段允许为null
INSERT INTO student(id,NAME,address) VALUE(2,'李四',NULL);
INSERT INTO student(id,NAME,address) VALUE(3,'王五','广州番禺');

2.3 非空

作用：限制字段必须赋值

注意：

1）非空字符必须赋值

2）非空字符不能赋null

-- 1.2 非空
-- 需求： gender字段必须有值（不为null）
CREATE TABLE student(
	id INT,
	NAME VARCHAR(20),
	gender VARCHAR(2) NOT NULL -- 非空
)

-- 非空字段必须赋值
INSERT INTO student(id,NAME) VALUES(1,'李四');
-- 非空字符不能插入null
INSERT INTO student(id,NAME,gender) VALUES(1,'李四',NULL);

2.4 唯一

作用：对字段的值不能重复

注意：

1）唯一字段可以插入null

2）唯一字段可以插入多个null

- 1.3 唯一
CREATE TABLE student(
	id INT UNIQUE, -- 唯一
	NAME VARCHAR(20)
)

INSERT INTO student(id,NAME) VALUES(1,'zs');
INSERT INTO student(id,NAME) VALUES(1,'lisi'); -- ERROR 1062 (23000): Duplicate entry '1' for key 'id'

INSERT INTO student(id,NAME) VALUES(2,'lisi');

2.5 主键

作用：非空+唯一

注意：

1）通常情况下，每张表都会设置一个主键字段。用于标记表中的每条记录的唯一性。

2）建议不要选择表的包含业务含义的字段作为主键，建议给每张表独立设计一个非业务含义的id字段。

-- 1.4 主键（非空+唯一）
DROP TABLE student;

CREATE TABLE student(
	id INT PRIMARY KEY, -- 主键
	NAME VARCHAR(20)
)

INSERT INTO student(id,NAME) VALUES(1,'张三');
INSERT INTO student(id,NAME) VALUES(2,'张三');
-- INSERT INTO student(id,NAME) VALUES(1,'李四'); -- 违反唯一约束： Duplicate entry '1' for key 'PRIMARY'

-- insert into student(name) value('李四'); -- 违反非空约束： ERROR 1048 (23000): Column 'id' cannot be null

2.6 自增长

作用：自动递增

-- 1.5 自增长
CREATE TABLE student(
	id INT(4) ZEROFILL PRIMARY KEY AUTO_INCREMENT, -- 自增长，从0开始  ZEROFILL 零填充
	NAME VARCHAR(20)
)

-- 自增长字段可以不赋值，自动递增
INSERT INTO student(NAME) VALUES('张三');
INSERT INTO student(NAME) VALUES('李四');
INSERT INTO student(NAME) VALUES('王五');

SELECT * FROM student;
-- 不能影响自增长约束
DELETE FROM student;
-- 可以影响自增长约束
TRUNCATE TABLE student;

2.7 外键

作用：约束两种表的数据

出现两种表的情况：

解决数据冗余高问题：独立出一张表

例如：员工表和部门表

问题出现：在插入员工表数据的时候，员工表的部门ID字段可以随便插入！！！！！

使用外键约束：约束插入员工表的部门ID字段值

解决办法：在员工表的部门ID字段添加一个外键约束

-- 部门表（主表）
CREATE TABLE dept(
	id INT PRIMARY KEY,
	deptName VARCHAR(20)
)

-- 修改员工表（副表/从表）
CREATE TABLE employee(
	id INT PRIMARY KEY,
	empName VARCHAR(20),
	deptId INT,-- 把部门名称改为部门ID
	-- 声明一个外键约束
	CONSTRAINT emlyee_dept_fk FOREIGN KEY(deptId) REFERENCES dept(id)
	--           外键名称                  外键               参考表(参考字段)
)

注意：

1）被约束的表称为副表，约束别人的表称为主表，外键设置在副表上的！！！

2）主表的参考字段通用为主键！

3）添加数据： 先添加主表，再添加副表

4）修改数据： 先修改副表，再修改主表

5）删除数据： 先删除副表，再删除主表

-- 1.6 外键约束
-- 员工表
CREATE TABLE employee(
	id INT PRIMARY KEY,
	empName VARCHAR(20),
	deptName VARCHAR(20) -- 部门名称
)

INSERT INTO employee VALUES(1,'张三','软件开发部');
INSERT INTO employee VALUES(2,'李四','软件开发部');
INSERT INTO employee VALUES(3,'王五','应用维护部');

SELECT * FROM employee;

-- 添加员工，部门名称的数据冗余高
INSERT INTO employee VALUES(4,'陈六','软件开发部');

-- 解决数据冗余高的问题：给冗余的字段放到一张独立表中
-- 独立设计一张部门表
CREATE TABLE dept(
	id INT PRIMARY KEY,
	deptName VARCHAR(20)
)

DROP TABLE employee;

-- 修改员工表
CREATE TABLE employee(
	id INT PRIMARY KEY,
	empName VARCHAR(20),
	deptId INT,-- 把部门名称改为部门ID
	-- 声明一个外键约束
	CONSTRAINT emlyee_dept_fk FOREIGN KEY(deptId) REFERENCES dept(id) ON UPDATE CASCADE ON DELETE CASCADE  -- ON CASCADE UPDATE ：级联修改
	--           外键名称                  外键               参考表(参考字段)
)

INSERT INTO dept(id,deptName) VALUES(1,'软件开发部');
INSERT INTO dept(id,deptName) VALUES(2,'应用维护部');
INSERT INTO dept(id,deptName) VALUES(3,'秘书部');

INSERT INTO employee VALUES(1,'张三',1);
INSERT INTO employee VALUES(2,'李四',1);
INSERT INTO employee VALUES(3,'王五',2);
INSERT INTO employee VALUES(4,'陈六',3);

-- 问题: 该记录业务上不合法，员工插入了一个不存在的部门数据
INSERT INTO employee VALUES(5,'陈六',4); -- 违反外键约束： Cannot add or update a child row: a foreign key constraint fails (`day16`.`employee`, CONSTRAINT `emlyee_dept_fk` FOREIGN KEY (`deptId`) REFERENCES `dept` (`id`))

-- 1）当有了外键约束，添加数据的顺序： 先添加主表，再添加副表数据
-- 2）当有了外键约束，修改数据的顺序： 先修改副表，再修改主表数据
-- 3）当有了外键约束，删除数据的顺序： 先删除副表，再删除主表数据
-- 修改部门(不能直接修改主表)
UPDATE dept SET id=4 WHERE id=3;
-- 先修改员工表
UPDATE employee SET deptId=2 WHERE id=4;
 
-- 删除部门
DELETE FROM dept WHERE id=2;

-- 先删除员工表
DELETE FROM employee WHERE deptId=2;

SELECT * FROM dept;
SELECT * FROM employee;

2.8 级联操作

问题：当有了外键约束的时候，必须先修改或删除副表中的所有关联数据，才能修改或删除主表！但是，我们希望直接修改或删除主表数据，从而影响副表数据。可以使用级联操作实现！！！

级联修改： ON UPDATE CASCADE

级联删除： ON DELETE CASCADE

CREATE TABLE employee(
	id INT PRIMARY KEY,
	empName VARCHAR(20),
	deptId INT,-- 把部门名称改为部门ID
	-- 声明一个外键约束
	CONSTRAINT emlyee_dept_fk FOREIGN KEY(deptId) REFERENCES dept(id) ON UPDATE CASCADE ON DELETE CASCADE  -- ON CASCADE UPDATE ：级联修改
	--           外键名称                  外键               参考表(参考字段)
)
注意： 级联操作必须在外键基础上使用

-- 级联修改（修改）
-- 直接修改部门
UPDATE dept SET id=5 WHERE id=4;

-- 级联删除
-- 直接删除部门 
DELETE FROM dept WHERE id=1;

3.2 三大范式

设计原则：建议设计的表尽量遵守三大范式。

第一范式：要求表的每个字段必须是不可分割的独立单元

student : name -- 违反第一范式

张小名|狗娃

sutdent ： name old_name --符合第一范式

张小名狗娃

第二范式：在第一范式的基础上，要求每张表只表达一个意思。表的每个字段都和表的主键有依赖。

employee（员工）: 员工编号员工姓名部门名称订单名称 --违反第二范式

员工表：员工编号员工姓名部门名称

订单表：订单编号订单名称 -- 符合第二范式

第三范式：在第二范式基础，要求每张表的主键之外的其他字段都只能和主键有直接决定依赖关系。

员工表：员工编号（主键）员工姓名部门编号部门名 --符合第二范式，违反第三范式（数据冗余高）

员工表：员工编号（主键）员工姓名部门编号 --符合第三范式（降低数据冗余）

部门表：部门编号部门名

4 关联查询(多表查询)1205

-  **************二、关联查询（多表查询）****************----
-- 需求：查询员工及其所在部门(显示员工姓名，部门名称)
-- 2.1 交叉连接查询（不推荐。产生笛卡尔乘积现象：4 * 4=16，有些是重复记录）
SELECT empName,deptName FROM employee,dept;

-- 需求：查询员工及其所在部门(显示员工姓名，部门名称)
-- 多表查询规则：1）确定查询哪些表   2）确定哪些哪些字段   3）表与表之间连接条件 (规律：连接条件数量是表数量-1)
-- 2.2 内连接查询：只有满足条件的结果才会显示(使用最频繁)
SELECT empName,deptName       -- 2）确定哪些哪些字段
	FROM employee,dept    -- 1）确定查询哪些表
	WHERE employee.deptId=dept.id  -- 3）表与表之间连接条件
	
-- 内连接的另一种语法
SELECT empName,deptName
	FROM employee
	INNER JOIN dept
	ON employee.deptId=dept.id;
	
-- 使用别名
SELECT e.empName,d.deptName
	FROM employee e
	INNER JOIN dept d
	ON e.deptId=d.id;

-- 需求： 查询每个部门的员工
-- 预期结果：
 --  软件开发部  张三
 --  软件开发部  李四
 --  应用维护部  王五
 --  秘书部      陈六
 --  总经办      null 
-- 2.2 左[外]连接查询： 使用左边表的数据去匹配右边表的数据，如果符合连接条件的结果则显示，如果不符合连接条件则显示null
 -- （注意： 左外连接：左表的数据一定会完成显示！）
SELECT d.deptName,e.empName
	FROM dept d
	LEFT OUTER JOIN employee e
	ON d.id=e.deptId;

-- 2.3 右[外]连接查询: 使用右边表的数据去匹配左边表的数据，如果符合连接条件的结果则显示，如果不符合连接条件则显示null
 -- （注意： 右外连接：右表的数据一定会完成显示！）
SELECT d.deptName,e.empName
	FROM employee e
	RIGHT OUTER JOIN dept d
	ON d.id=e.deptId;

-- 2.4 自连接查询
-- 需求：查询员工及其上司
-- 预期结果：       
	-- 张三    null
	-- 李四    张三
	-- 王五    李四
	-- 陈六    王五
SELECT e.empName,b.empName
	FROM employee e 
	LEFT OUTER JOIN employee b
	ON e.bossId=b.id;

5 存储过程

5.1 什么是存储过程

存储过程，带有逻辑的sql语句

之前的sql没有条件判断，没有循环

存储过程带上流程控制语句（if while）

5.2 存储过程特点

1）执行效率非常快！存储过程是在数据库的服务器端执行的！！！

2）移植性很差！不同数据库的存储过程是不能移植。

-- 创建存储过程
DELIMITER $       -- 声明存储过程的结束符
CREATE PROCEDURE pro_test()           --存储过程名称(参数列表)
BEGIN             -- 开始
	-- 可以写多个sql语句;          -- sql语句+流程控制
	SELECT * FROM employee;
END $            -- 结束 结束符

-- 执行存储过程
CALL pro_test();          -- CALL 存储过程名称(参数);

参数：
IN：   表示输入参数，可以携带数据带存储过程中
OUT： 表示输出参数，可以从存储过程中返回结果
INOUT： 表示输入输出参数，既可以输入功能，也可以输出功能

-- **************三、存储过程*******************-
-- 声明结束符
-- 创建存储过程
DELIMITER $
CREATE PROCEDURE pro_test()
BEGIN
	-- 可以写多个sql语句;
	SELECT * FROM employee;
END $

-- 执行存储过程
CALL pro_test();

-- 3.1 带有输入参数的存储过程
-- 需求：传入一个员工的id，查询员工信息
DELIMITER $
CREATE PROCEDURE pro_findById(IN eid INT)  -- IN: 输入参数
BEGIN
	SELECT * FROM employee WHERE id=eid;
END $ 

-- 调用
CALL pro_findById(4);

-- 3.2 带有输出参数的存储过程
DELIMITER $
CREATE PROCEDURE pro_testOut(OUT str VARCHAR(20))  -- OUT：输出参数
BEGIN
        -- 给参数赋值
	SET str='helljava';
END $

-- 删除存储过程
DROP PROCEDURE pro_testOut;
-- 调用
-- 如何接受返回参数的值？？
-- ***mysql的变量******
--  全局变量（内置变量）：mysql数据库内置的变量 （所有连接都起作用）
        -- 查看所有全局变量： show variables
        -- 查看某个全局变量： select @@变量名
        -- 修改全局变量： set 变量名=新值
        -- character_set_client: mysql服务器的接收数据的编码
        -- character_set_results：mysql服务器输出数据的编码
        
--  会话变量： 只存在于当前客户端与数据库服务器端的一次连接当中。如果连接断开，那么会话变量全部丢失！
        -- 定义会话变量: set @变量=值
        -- 查看会话变量： select @变量
        
-- 局部变量： 在存储过程中使用的变量就叫局部变量。只要存储过程执行完毕，局部变量就丢失！！

-- 1)定义一个会话变量name, 2)使用name会话变量接收存储过程的返回值
CALL pro_testOut(@NAME);
-- 查看变量值
SELECT @NAME;

-- 3.3 带有输入输出参数的存储过程
DELIMITER $
CREATE PROCEDURE pro_testInOut(INOUT n INT)  -- INOUT： 输入输出参数
BEGIN
   -- 查看变量
   SELECT n;
   SET n =500;
END $

-- 调用
SET @n=10;

CALL pro_testInOut(@n);

SELECT @n;

-- 3.4 带有条件判断的存储过程
-- 需求：输入一个整数，如果1，则返回“星期一”,如果2，返回“星期二”,如果3，返回“星期三”。其他数字，返回“错误输入”;
DELIMITER $
CREATE PROCEDURE pro_testIf(IN num INT,OUT str VARCHAR(20))
BEGIN
	IF num=1 THEN
		SET str='星期一';
	ELSEIF num=2 THEN
		SET str='星期二';
	ELSEIF num=3 THEN
		SET str='星期三';
	ELSE
		SET str='输入错误';
	END IF;
END $

CALL pro_testIf(4,@str);
 
SELECT @str;

-- 3.5 带有循环功能的存储过程
-- 需求： 输入一个整数，求和。例如，输入100，统计1-100的和
DELIMITER $
CREATE PROCEDURE pro_testWhile(IN num INT,OUT result INT)
BEGIN
	-- 定义一个局部变量
	DECLARE i INT DEFAULT 1;
	DECLARE vsum INT DEFAULT 0;
	WHILE i<=num DO
	      SET vsum = vsum+i;
	      SET i=i+1;
	END WHILE;
	SET result=vsum;
END $

DROP PROCEDURE pro_testWhile;


CALL pro_testWhile(100,@result);

SELECT @result;

USE day16;

-- 3.6 使用查询的结果赋值给变量（INTO）
DELIMITER $
CREATE PROCEDURE pro_findById2(IN eid INT,OUT vname VARCHAR(20) )
BEGIN
	SELECT empName INTO vname FROM employee WHERE id=eid;
END $

CALL pro_findById2(1,@NAME);

SELECT @NAME;

6 触发器

6.1 触发器作用

当操作了某张表时，希望同时触发一些动作/行为，可以使用触发器完成！！

例如：当向员工表插入一条记录时，希望同时往日志表插入数据

-- 需求： 当向员工表插入一条记录时，希望mysql自动同时往日志表插入数据
-- 创建触发器(添加)
CREATE TRIGGER tri_empAdd AFTER INSERT ON employee FOR EACH ROW    -- 当往员工表插入一条记录时
     INSERT INTO test_log(content) VALUES('员工表插入了一条记录');
     
-- 插入数据
INSERT INTO employee(id,empName,deptId) VALUES(7,'扎古斯',1);
INSERT INTO employee(id,empName,deptId) VALUES(8,'扎古斯2',1);

-- 创建触发器(修改)
CREATE TRIGGER tri_empUpd AFTER UPDATE ON employee FOR EACH ROW    -- 当往员工表修改一条记录时
     INSERT INTO test_log(content) VALUES('员工表修改了一条记录');
     
 -- 修改
 UPDATE employee SET empName='eric' WHERE id=7;
 
-- 创建触发器(删除)
CREATE TRIGGER tri_empDel AFTER DELETE ON employee FOR EACH ROW    -- 当往员工表删除一条记录时
     INSERT INTO test_log(content) VALUES('员工表删除了一条记录');
  
 -- 删除
 DELETE FROM employee WHERE id=7;

7 mysql权限问题

- ***********五、mysql权限问题****************
 -- mysql数据库权限问题：root ：拥有所有权限（可以干任何事情）
 -- 权限账户，只拥有部分权限（CURD）例如，只能操作某个数据库的某张表
 -- 如何修改mysql的用户密码？
 -- password: md5加密函数(单向加密)
 SELECT PASSWORD('root'); -- *81F5E21E35407D884A6CD4A731AEBFB6AF209E1B
 
--  mysql数据库，用户配置 : user表
USE mysql;

SELECT * FROM USER;

-- 修改密码
UPDATE USER SET PASSWORD=PASSWORD('123456') WHERE USER='root';

-- 分配权限账户
GRANT SELECT ON day16.employee TO 'eric'@'localhost' IDENTIFIED BY '123456';
GRANT DELETE ON day16.employee TO 'eric'@'localhost' IDENTIFIED BY '123456';

项目中用到过的sql语句

建表语句    create table T_C_POOR_USER_DAY_REPORT 
( 
STATTIME TIMESTAMP(9) not null, 
USERID  VARCHAR2(512),
DeviceID VARCHAR2(64) not null,
MACADDR  VARCHAR2(32),
REGION  VARCHAR2(512) ,
PLAYTIME  NUMBER(9),
ALARMTIME NUMBER(9),
PERIODNORMALTIME NUMBER(9),
PERIODABNORMALTIME NUMBER(9),
TCPDelayHistogram VARCHAR2(128),
PacketLossRatioHistogram VARCHAR2(128),
EPGHTTPDelayHistogram VARCHAR2(32),
ChannelDelayHistogram  VARCHAR2(128),
VODPlayDelayHistogram  VARCHAR2(128),
CONSTRAINT prikey PRIMARY KEY (STATTIME,DeviceID) USING INDEX LOCAL TABLESPACE HVS_ISEE_DAT
)
PARTITION BY RANGE (STATTIME) 
interval(NUMTODSINTERVAL(1, 'DAY'))
STORE IN (HVS_ISEE_DAT)
(
	partition OLDPARTITION values less than (to_date('01012016', 'DDMMYYYY')) tablespace HVS_ISEE_DAT
);

存储过程：
create or replace procedure proc_REPORT_STATTIME_Deletee
as
  v_date     DATE;
    v_date_cut DATE := trunc(SYSDATE-30);
begin
FOR r IN (SELECT * FROM user_tab_partitions tp WHERE  tp.table_name = 'T_C_POOR_USER_DAY_REPORT')
    LOOP
    EXECUTE IMMEDIATE 'SELECT ' || r.high_value || ' from dual' INTO v_date;

        IF v_date < v_date_cut
        THEN
            IF r.interval = 'NO'
            THEN
                EXECUTE IMMEDIATE 'alter table ' || r.table_name || ' truncate partition ' || r.partition_name; 
            ELSE
                EXECUTE IMMEDIATE 'alter table ' || r.table_name || ' drop partition ' || r.partition_name;
            END IF;
        END IF;
    END LOOP;
end proc_REPORT_STATTIME_Deletee;



维护索引：
alter table T_C_POOR_USER_DAY_REPORT drop constraint prikey;

ALTER TABLE T_C_POOR_USER_DAY_REPORT ADD CONSTRAINT constarint PRIMARY KEY(STATTIME,DeviceID)
     USING INDEX LOCAL TABLESPACE HVS_ISEE_DAT;
	 
	 
定时删除的job 	 
commit;

  declare
    jobno number;
    BEGIN
     sys.dbms_job.submit(jobno,
                      what => 'proc_c_delete_isee_data;',
                      next_date => to_date('2019-03-16 01:00:00','YYYY-MM-DD hh24:mi:ss'),
                      interval => 'TRUNC(SYSDATE+1)+1/24');
      COMMIT;
      DBMS_JOB.RUN(jobno);
   end;
/

day17

mysql加强

1）数据约束（表约束）

默认值： default 默认值

非空： not null

唯一： unique

主键： primary key （非空+唯一）

自增长： auto_increment

外键： foreign key 约束两种表

2）关联查询（多表查询）

2.1 交叉连接（产生笛卡尔积：原因：连接条件不足够）表数量-1

2.2 内连接查询： inner join

只有满足连接条件的数据才会显示！！！

2.3 左【外】连接查询：left [outer] join

左表的数据必须全部显示，用左表去匹配右表的数据，如果右表有符号条件的数据则显示符合条件的数据；如果不符合条件，则显示null。

2.4 右【外】连接查询： right [outer] join

右表的数据必须全部显示，用右表去匹配左表的数据，如果左表有符号条件的数据则显示符合条件的数据；如果不符合条件，则显示null。

2.5 自连接查询

3）存储过程

-- 创建存储过程语法

delimeter 结束符号

create procedure 名称(IN/OUT/INOUT 参数名称参数类型)

begin

带逻辑的sql语句

end 结束符号

--调用存储过程

CALL 存储过程名称(实际参数);

今天的目标： jdbc基础

2 jdbc入门

2.1 之前操作数据

1）通过mysql的客户端工具，登录数据库服务器（mysql -u root -p 密码）

2）编写sql语句

3）发送sql语句到数据库服务器执行

2.2 什么是jdbc？

使用java代码（程序）发送sql语句的技术，就是jdbc技术！！！！

2.3 使用jdbc发送sql前提

登录数据库服务器（连接数据库服务器）

数据库的IP地址

端口

数据库用户名

密码

/**
 * jdbc连接数据库
 * @author APPle
 *
 */
public class Demo1 {
	//连接数据库的URL
	private String url = "jdbc:mysql://localhost:3306/day17";
	                    // jdbc协议:数据库子协议:主机:端口/连接的数据库   //

	private String user = "root";//用户名
	private String password = "root";//密码
	
	/**
	 * 第一种方法
	 * @throws Exception
	 */
	@Test
	public void test1() throws Exception{
		//1.创建驱动程序类对象
		Driver driver = new com.mysql.jdbc.Driver(); //新版本
		//Driver driver = new org.gjt.mm.mysql.Driver(); //旧版本
		
		//设置用户名和密码
		Properties props = new Properties();
		props.setProperty("user", user);
		props.setProperty("password", password);
		
		//2.连接数据库，返回连接对象
		Connection conn = driver.connect(url, props);
		
		System.out.println(conn);
	}
	
	/**
	 * 使用驱动管理器类连接数据库(注册了两次，没必要)
	 * @throws Exception
	 */
	@Test
	public void test2() throws Exception{
		Driver driver = new com.mysql.jdbc.Driver();
		//Driver driver2 = new com.oracle.jdbc.Driver();
		//1.注册驱动程序(可以注册多个驱动程序)
		DriverManager.registerDriver(driver);
		//DriverManager.registerDriver(driver2);
		
		//2.连接到具体的数据库
		Connection conn = DriverManager.getConnection(url, user, password);
		System.out.println(conn);
		
	}
	
	/**
	 * （推荐使用这种方式连接数据库）
	 * 推荐使用加载驱动程序类  来 注册驱动程序 
	 * @throws Exception
	 */
	@Test
	public void test3() throws Exception{
		//Driver driver = new com.mysql.jdbc.Driver();
		
		//通过得到字节码对象的方式加载静态代码块，从而注册驱动程序
		Class.forName("com.mysql.jdbc.Driver");
		
		//Driver driver2 = new com.oracle.jdbc.Driver();
		//1.注册驱动程序(可以注册多个驱动程序)
		//DriverManager.registerDriver(driver);
		//DriverManager.registerDriver(driver2);
		
		//2.连接到具体的数据库
		Connection conn = DriverManager.getConnection(url, user, password);
		System.out.println(conn);
		
	}

}

2.4 JDBC接口核心的API

java.sql.* 和 javax.sql.*

|- Driver接口：表示java驱动程序接口。所有的具体的数据库厂商要来实现此接口。

|- connect(url, properties): 连接数据库的方法。

url: 连接数据库的URL

URL语法： jdbc协议:数据库子协议://主机:端口/数据库

user：数据库的用户名

password：数据库用户密码

|- DriverManager类：驱动管理器类，用于管理所有注册的驱动程序

|-registerDriver(driver) : 注册驱动类对象

|-Connection getConnection(url,user,password); 获取连接对象

|- Connection接口：表示java程序和数据库的连接对象。

|- Statement createStatement() ：创建Statement对象

|- PreparedStatement prepareStatement(String sql) 创建PreparedStatement对象

|- CallableStatement prepareCall(String sql) 创建CallableStatement对象

|- Statement接口：用于执行静态的sql语句

|- int executeUpdate(String sql) ：执行静态的更新sql语句（DDL，DML）

|- ResultSet executeQuery(String sql) ：执行的静态的查询sql语句（DQL）

|-PreparedStatement接口：用于执行预编译sql语句

|- int executeUpdate() ：执行预编译的更新sql语句（DDL，DML）

|-ResultSet executeQuery() ：执行预编译的查询sql语句（DQL）

|-CallableStatement接口：用于执行存储过程的sql语句（call xxx）

|-ResultSet executeQuery() ：调用存储过程的方法

|- ResultSet接口：用于封装查询出来的数据

|- boolean next() ：将光标移动到下一行

|-getXX() : 获取列的值

3 使用Statement执行sql语句

3.1 执行DDL语句

 /**
	 * 执行DDL语句(创建表)
	 */
	@Test
	public void test1(){
		Statement stmt = null;
		Connection conn = null;
		try {
			//1.驱动注册程序
			Class.forName("com.mysql.jdbc.Driver");
			
			//2.获取连接对象
			conn = DriverManager.getConnection(url, user, password);
			
			//3.创建Statement
			stmt = conn.createStatement();
			
			//4.准备sql
			String sql = "CREATE TABLE student(id INT PRIMARY KEY AUTO_INCREMENT,NAME VARCHAR(20),gender VARCHAR(2))";
			
			//5.发送sql语句，执行sql语句,得到返回结果
			int count = stmt.executeUpdate(sql);
			
			//6.输出
			System.out.println("影响了"+count+"行！");
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally{
			//7.关闭连接(顺序:后打开的先关闭)
			if(stmt!=null)
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
			if(conn!=null)
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
		}
	}

连接SQL工具类

package gz.itcast.util;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * jdbc工具类
 * @author APPle
 *
 */
public class JdbcUtil {
	private static String url = null;
	private static String user = null;
	private static String password = null;
	private static String driverClass = null;
	
	/**
	 * 静态代码块中（只加载一次）
	 */
	static{
		try {
			//读取db.properties文件
			Properties props = new Properties();
			/**
			 *  . 代表java命令运行的目录
			 *  在java项目下，. java命令的运行目录从项目的根目录开始
			 *  在web项目下，  . java命令的而运行目录从tomcat/bin目录开始
			 *  所以不能使用点.
			 */
			//FileInputStream in = new FileInputStream("./src/db.properties");
			
			/**
			 * 使用类路径的读取方式
			 *  / : 斜杠表示classpath的根目录
			 *     在java项目下，classpath的根目录从bin目录开始
			 *     在web项目下，classpath的根目录从WEB-INF/classes目录开始
			 */
			InputStream in = JdbcUtil.class.getResourceAsStream("/db.properties");
			
			//加载文件
			props.load(in);
			//读取信息
			url = props.getProperty("url");
			user = props.getProperty("user");
			password = props.getProperty("password");
			driverClass = props.getProperty("driverClass");
			
			
			//注册驱动程序
			Class.forName(driverClass);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("驱程程序注册出错");
		}
	}

	/**
	 * 抽取获取连接对象的方法
	 */
	public static Connection getConnection(){
		try {
			Connection conn = DriverManager.getConnection(url, user, password);
			return conn;
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
	
	
	/**
	 * 释放资源的方法
	 */
	public static void close(Connection conn,Statement stmt){
		if(stmt!=null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
		if(conn!=null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
	}
	
	public static void close(Connection conn,Statement stmt,ResultSet rs){
		if(rs!=null)
			try {
				rs.close();
			} catch (SQLException e1) {
				e1.printStackTrace();
				throw new RuntimeException(e1);
			}
		if(stmt!=null){
			try {
				stmt.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
		if(conn!=null){
			try {
				conn.close();
			} catch (SQLException e) {
				e.printStackTrace();
				throw new RuntimeException(e);
			}
		}
	}
}

3.2 执行DML语句

/**
 * 使用Statement执行DML语句
 * @author APPle
 *
 */
public class Demo2 {
	private String url = "jdbc:mysql://localhost:3306/day17";
	private String user = "root";
	private String password = "root";

	/**
	 * 增加
	 */
	@Test
	public void testInsert(){
		Connection conn = null;
		Statement stmt = null;
		try {
			//通过工具类获取连接对象
			conn = JdbcUtil.getConnection();
			
			//3.创建Statement对象
			stmt = conn.createStatement();
			
			//4.sql语句
			String sql = "INSERT INTO student(NAME,gender) VALUES('李四','女')";
			
			//5.执行sql
			int count = stmt.executeUpdate(sql);
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally{
			//关闭资源
			/*if(stmt!=null)
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
			if(conn!=null)
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}*/
			JdbcUtil.close(conn, stmt);
		}
	}
	
	/**
	 * 修改
	 */
	@Test
	public void testUpdate(){
		Connection conn = null;
		Statement stmt = null;
		//模拟用户输入
		String name = "陈六";
		int id = 3;
		try {
			/*//1.注册驱动
			Class.forName("com.mysql.jdbc.Driver");
			
			//2.获取连接对象
			conn = DriverManager.getConnection(url, user, password);*/
			//通过工具类获取连接对象
			conn = JdbcUtil.getConnection();
			
			//3.创建Statement对象
			stmt = conn.createStatement();
			
			//4.sql语句
			String sql = "UPDATE student SET NAME='"+name+"' WHERE id="+id+"";
			
			System.out.println(sql);
			
			//5.执行sql
			int count = stmt.executeUpdate(sql);
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally{
			//关闭资源
			/*if(stmt!=null)
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
			if(conn!=null)
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}*/
			JdbcUtil.close(conn, stmt);
		}
	}
	
	/**
	 * 删除
	 */
	@Test
	public void testDelete(){
		Connection conn = null;
		Statement stmt = null;
		//模拟用户输入
		int id = 3;
		try {
			/*//1.注册驱动
			Class.forName("com.mysql.jdbc.Driver");
			
			//2.获取连接对象
			conn = DriverManager.getConnection(url, user, password);*/
			//通过工具类获取连接对象
			conn = JdbcUtil.getConnection();
			
			//3.创建Statement对象
			stmt = conn.createStatement();
			
			//4.sql语句
			String sql = "DELETE FROM student WHERE id="+id+"";
			
			System.out.println(sql);
			
			//5.执行sql
			int count = stmt.executeUpdate(sql);
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally{
			//关闭资源
			/*if(stmt!=null)
				try {
					stmt.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}
			if(conn!=null)
				try {
					conn.close();
				} catch (SQLException e) {
					e.printStackTrace();
					throw new RuntimeException(e);
				}*/
			JdbcUtil.close(conn, stmt);
		}
	}
}

3.3 执行DQL语句

/**
 * 使用Statement执行DQL语句（查询操作）
 * @author APPle
 */
public class Demo3 {

	@Test
	public void test1(){
		Connection conn = null;
		Statement stmt = null;
		try{
			//获取连接
			conn = JdbcUtil.getConnection();
			//创建Statement
			stmt = conn.createStatement();
			//准备sql
			String sql = "SELECT * FROM student";
			//执行sql
			ResultSet rs = stmt.executeQuery(sql);
			
			//移动光标
			/*boolean flag = rs.next();
			
			flag = rs.next();
			flag = rs.next();
			if(flag){
				//取出列值
				//索引
				int id = rs.getInt(1);
				String name = rs.getString(2);
				String gender = rs.getString(3);
				System.out.println(id+","+name+","+gender);
				
				//列名称
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String gender = rs.getString("gender");
				System.out.println(id+","+name+","+gender);
			}*/
			
			//遍历结果
			while(rs.next()){
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String gender = rs.getString("gender");
				System.out.println(id+","+name+","+gender);
			}
			
		}catch(Exception e){
			e.printStackTrace();
			throw new RuntimeException(e);
		}finally{
			JdbcUtil.close(conn, stmt);
		}
	}
}

4 使用PreparedStatement执行sql语句

public class Demo1 {

	/**
	 * 增加
	 */
	@Test
	public void testInsert() {
		Connection conn = null;
		PreparedStatement stmt = null;
		try {
			//1.获取连接
			conn = JdbcUtil.getConnection();
			
			//2.准备预编译的sql
			String sql = "INSERT INTO student(NAME,gender) VALUES(?,?)"; //?表示一个参数的占位符
			
			//3.执行预编译sql语句(检查语法)
			stmt = conn.prepareStatement(sql);
			
			//4.设置参数值
			/**
			 * 参数一： 参数位置  从1开始
			 */
			stmt.setString(1, "李四");
			stmt.setString(2, "男");
			
			//5.发送参数，执行sql
			int count = stmt.executeUpdate();
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.close(conn, stmt);
		}
	}
	
	/**
	 * 修改
	 */
	@Test
	public void testUpdate() {
		Connection conn = null;
		PreparedStatement stmt = null;
		try {
			//1.获取连接
			conn = JdbcUtil.getConnection();
			
			//2.准备预编译的sql
			String sql = "UPDATE student SET NAME=? WHERE id=?"; //?表示一个参数的占位符
			
			//3.执行预编译sql语句(检查语法)
			stmt = conn.prepareStatement(sql);
			
			//4.设置参数值
			/**
			 * 参数一： 参数位置  从1开始
			 */
			stmt.setString(1, "王五");
			stmt.setInt(2, 9);
			
			//5.发送参数，执行sql
			int count = stmt.executeUpdate();
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.close(conn, stmt);
		}
	}
	
	/**
	 * 删除
	 */
	@Test
	public void testDelete() {
		Connection conn = null;
		PreparedStatement stmt = null;
		try {
			//1.获取连接
			conn = JdbcUtil.getConnection();
			
			//2.准备预编译的sql
			String sql = "DELETE FROM student WHERE id=?"; //?表示一个参数的占位符
			
			//3.执行预编译sql语句(检查语法)
			stmt = conn.prepareStatement(sql);
			
			//4.设置参数值
			/**
			 * 参数一： 参数位置  从1开始
			 */
			stmt.setInt(1, 9);
			
			//5.发送参数，执行sql
			int count = stmt.executeUpdate();
			
			System.out.println("影响了"+count+"行");
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.close(conn, stmt);
		}
	}
	
	/**
	 * 查询
	 */
	@Test
	public void testQuery() {
		Connection conn = null;
		PreparedStatement stmt = null;
		ResultSet rs = null;
		try {
			//1.获取连接
			conn = JdbcUtil.getConnection();
			
			//2.准备预编译的sql
			String sql = "SELECT * FROM student"; 
			
			//3.预编译
			stmt = conn.prepareStatement(sql);
			
			//4.执行sql
			rs = stmt.executeQuery();
			
			//5.遍历rs
			while(rs.next()){
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String gender = rs.getString("gender");
				System.out.println(id+","+name+","+gender);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			//关闭资源
			JdbcUtil.close(conn,stmt,rs);
		}
	}
}

PreparedStatement vs Statment

1）语法不同：PreparedStatement可以使用预编译的sql，而Statment只能使用静态的sql

2）效率不同： PreparedStatement可以使用sql缓存区，效率比Statment高

3）安全性不同： PreparedStatement可以有效防止sql注入，而Statment不能防止sql注入。

推荐使用PreparedStatement

5 CallableStatement执行存储过程

/**
 * 使用CablleStatement调用存储过程
 * @author APPle
 *
 */
public class Demo1 {

	/**
	 * 调用带有输入参数的存储过程
	 * CALL pro_findById(4);
	 */
	@Test
	public void test1(){
		Connection conn = null;
		CallableStatement stmt = null;
		ResultSet rs = null;
		try {
			//获取连接
			conn = JdbcUtil.getConnection();
			
			//准备sql
			String sql = "CALL pro_findById(?)"; //可以执行预编译的sql
			
			//预编译
			stmt = conn.prepareCall(sql);
			
			//设置输入参数
			stmt.setInt(1, 6);
			
			//发送参数
			rs = stmt.executeQuery(); //注意： 所有调用存储过程的sql语句都是使用executeQuery方法执行！！！
			
			//遍历结果
			while(rs.next()){
				int id = rs.getInt("id");
				String name = rs.getString("name");
				String gender = rs.getString("gender");
				System.out.println(id+","+name+","+gender);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.close(conn, stmt ,rs);
		}
	}
	
	/**
	 * 执行带有输出参数的存储过程
	 * CALL pro_findById2(5,@NAME);
	 */
	@Test
	public void test2(){
		Connection conn = null;
		CallableStatement stmt = null;
		ResultSet rs = null;
		try {
			//获取连接
			conn = JdbcUtil.getConnection();
			//准备sql
			String sql = "CALL pro_findById2(?,?)"; //第一个？是输入参数，第二个？是输出参数
			
			//预编译
			stmt = conn.prepareCall(sql);
			
			//设置输入参数
			stmt.setInt(1, 6);
			//设置输出参数(注册输出参数)
			/**
			 * 参数一： 参数位置
			 * 参数二： 存储过程中的输出参数的jdbc类型    VARCHAR(20)
			 */
			stmt.registerOutParameter(2, java.sql.Types.VARCHAR);
			
			//发送参数，执行
			stmt.executeQuery(); //结果不是返回到结果集中，而是返回到输出参数中
			
			//得到输出参数的值
			/**
			 * 索引值： 预编译sql中的输出参数的位置
			 */
			String result = stmt.getString(2); //getXX方法专门用于获取存储过程中的输出参数
			
			System.out.println(result);

		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.close(conn, stmt ,rs);
		}
	}
}

day19

BeanUtils组件

1.1简介

程序中对javabean的操作很频繁，所以apache提供了一套开源的api，方便对javabean的操作！即BeanUtils组件。

BeanUtils组件，作用是简化javabean的操作！

用户可以从www.apache.org下载BeanUtils组件，然后再在项目中引入jar文件！

使用BenUtils组件：

引入commons-beanutils-8.3.jar核心包
引入日志支持包: commons-logging-1.1.3.jar

如果缺少日志jar文件，报错：

如果缺少日志jar文件，报错：
java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory
	at org.apache.commons.beanutils.ConvertUtilsBean.<init>(ConvertUtilsBean.java:157)
	at org.apache.commons.beanutils.BeanUtilsBean.<init>(BeanUtilsBean.java:117)
	at org.apache.commons.beanutils.BeanUtilsBean$1.initialValue(BeanUtilsBean.java:68)
	at

1.2 实例，基本用法

方法1：对象属性的拷贝

BeanUtils.copyProperty(admin, "userName", "jack");

BeanUtils.setProperty(admin, "age", 18);

方法2：对象的拷贝

BeanUtils.copyProperties(newAdmin, admin);

方法3： map数据拷贝到javabean中

【注意：map中的key要与javabean的属性名称一致】

BeanUtils.populate(adminMap, map);

//1. 对javabean的基本操作
	@Test
	public void test1() throws Exception {
		
		// a. 基本操作
		Admin admin = new Admin();
//		admin.setUserName("Jack");
//		admin.setPwd("999");
		
		// b. BeanUtils组件实现对象属性的拷贝
		BeanUtils.copyProperty(admin, "userName", "jack");
		BeanUtils.setProperty(admin, "age", 18);
		
		// 总结1： 对于基本数据类型，会自动进行类型转换!
		
		
		// c. 对象的拷贝
		Admin newAdmin = new Admin();
		BeanUtils.copyProperties(newAdmin, admin);
		
		// d. map数据，拷贝到对象中
		Admin adminMap = new Admin();
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("userName", "Jerry");
		map.put("age", 29);
		// 注意：map中的key要与javabean的属性名称一致
		BeanUtils.populate(adminMap, map);
		
		// 测试
		System.out.println(adminMap.getUserName());
		System.out.println(adminMap.getAge());
	}

1.3 实例，日期类型的拷贝

需要注册日期类型转换器，2中方法参见下边代码：

//2. 自定义日期类型转换器
	@Test
	public void test2() throws Exception {
		// 模拟表单数据
		String name = "jack";
		String age = "20";
		String birth = "   ";
		
		// 对象
		Admin admin = new Admin();
		
		// 注册日期类型转换器：1， 自定义的方式
		ConvertUtils.register(new Converter() {
			// 转换的内部实现方法，需要重写
			@Override
			public Object convert(Class type, Object value) {
				
				// 判断
				if (type != Date.class) {
					return null;
				}
				if (value == null || "".equals(value.toString().trim())) {
					return null;
				}
				
				
				try {
					// 字符串转换为日期
					SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
					return sdf.parse(value.toString());
				} catch (ParseException e) {
					throw new RuntimeException(e);
				}
			}
		},Date.class);
		
		
		
		// 把表单提交的数据，封装到对象中
		BeanUtils.copyProperty(admin, "userName", name);
		BeanUtils.copyProperty(admin, "age", age);
		BeanUtils.copyProperty(admin, "birth", birth);
		
		//------ 测试------
		System.out.println(admin);
	}
	
	//2. 使用提供的日期类型转换器工具类
	@Test
	public void test3() throws Exception {
		// 模拟表单数据
		String name = "jack";
		String age = "20";
		String birth = null;
		
		// 对象
		Admin admin = new Admin();
		
		// 注册日期类型转换器：2， 使用组件提供的转换器工具类
		ConvertUtils.register(new DateLocaleConverter(), Date.class);
				
		// 把表单提交的数据，封装到对象中
		BeanUtils.copyProperty(admin, "userName", name);
		BeanUtils.copyProperty(admin, "age", age);
		BeanUtils.copyProperty(admin, "birth", birth);
		
		//------ 测试------
		System.out.println(admin);
	}
}

1.4 应用

public class WebUtils {

	
	@Deprecated
	public static <T> T copyToBean_old(HttpServletRequest request, Class<T> clazz) {
		try {
			// 创建对象
			T t = clazz.newInstance();
			
			// 获取所有的表单元素的名称
			Enumeration<String> enums = request.getParameterNames();
			// 遍历
			while (enums.hasMoreElements()) {
				// 获取表单元素的名称:<input type="password" name="pwd"/>
				String name = enums.nextElement();  // pwd
				// 获取名称对应的值
				String value = request.getParameter(name);
				// 把指定属性名称对应的值进行拷贝
				BeanUtils.copyProperty(t, name, value);
			}
			
			return t;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	/**
	 * 处理请求数据的封装
	 */
	public static <T> T copyToBean(HttpServletRequest request, Class<T> clazz) {
		try {
			// （注册日期类型转换器）
			// 创建对象
			T t = clazz.newInstance();
			BeanUtils.populate(t, request.getParameterMap());
			return t;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

2.元数据

在jdbc中获取数据库的定义，例如：数据库、表、列的定义信息。就用到元数据。
在jdbc中可以使用：数据库元数据、参数元数据、结果集元数据
(元数据定义相关api， ..MetaData)

public class App {

	//1. 数据库元数据
	@Test
	public void testDB() throws Exception {
		// 获取连接
		Connection conn = JdbcUtil.getConnection();
		// 获取数据库元数据
		DatabaseMetaData metaData = conn.getMetaData();// alt + shift + L  快速获取方法返回值
		
		System.out.println(metaData.getUserName());
		System.out.println(metaData.getURL());
		System.out.println(metaData.getDatabaseProductName());
	}
	
	//2. 参数元数据
	@Test
	public void testParams() throws Exception {
		// 获取连接
		Connection conn = JdbcUtil.getConnection();
		// SQL
		String sql = "select * from dept where deptid=? and deptName=?";
		// Object[] values = {"tom","888"};
		
		PreparedStatement pstmt = conn.prepareStatement(sql);
		// 参数元数据
		ParameterMetaData p_metaDate = pstmt.getParameterMetaData();
		// 获取参数的个数
		int count = p_metaDate.getParameterCount();
		
		
		// 测试
		System.out.println(count);
	}
	
	// 3. 结果集元数据
	@Test
	public void testRs() throws Exception {
		String sql = "select * from dept ";
		
		// 获取连接
		Connection conn = JdbcUtil.getConnection();
		PreparedStatement pstmt = conn.prepareStatement(sql);
		ResultSet rs = pstmt.executeQuery();
		// 得到结果集元数据(目标：通过结果集元数据，得到列的名称)
		ResultSetMetaData rs_metaData = rs.getMetaData();
		
		// 迭代每一行结果
		while (rs.next()) {
			// 1. 获取列的个数
			int count = rs_metaData.getColumnCount();
			// 2. 遍历，获取每一列的列的名称
			for (int i=0; i<count; i++) {
				// 得到列的名称
				String columnName = rs_metaData.getColumnName(i + 1);
				// 获取每一行的每一列的值
				Object columnValue = rs.getObject(columnName);
				// 测试
				System.out.print(columnName + "=" + columnValue + ",");
			}
			System.out.println();
		}
		
	}
	
	
	
}

3.Dao操作的抽取, BaseDao

Dao操作通用的步骤：

写SQL语句
获取连接
创建stmt
执行sql
1. 更新
2. 查询
关闭/异常

通过的dao,

更新

String sql = “select * from admin”;

String sql = “select * from admin where id=? And pwd =?”;

public void update(String sql, Object[] paramValues);

2.查询

String sql = “select * from admin”;

String sql = “select * from admin where id=? And pwd =?”;

// 传入的什么类型的对象，就封装为什么类型

// 要求：列的名称，要与指定类型的对象的属性名称一样

Public List<T> query (String sql , Object[] paramValues , Class<T> clazz);

T t; // 对象赋值


/**
 * 通用的dao，自己写的所有的dao都继承此类;
 * 此类定义了2个通用的方法：
 * 	1. 更新
 *  2. 查询
 * @author Jie.Yuan
 *
 */
public class BaseDao {
	
	// 初始化参数
	private Connection con;
	private PreparedStatement pstmt;
	private ResultSet rs;

	/**
	 * 更新的通用方法
	 * @param sql   更新的sql语句(update/insert/delete)
	 * @param paramsValue  sql语句中占位符对应的值(如果没有占位符，传入null)
	 */
	public void update(String sql,Object[] paramsValue){
		
		try {
			// 获取连接
			con = JdbcUtil.getConnection();
			// 创建执行命令的stmt对象
			pstmt = con.prepareStatement(sql);
			// 参数元数据： 得到占位符参数的个数
			int count = pstmt.getParameterMetaData().getParameterCount();
			
			// 设置占位符参数的值
			if (paramsValue != null && paramsValue.length > 0) {
				// 循环给参数赋值
				for(int i=0;i<count;i++) {
					pstmt.setObject(i+1, paramsValue[i]);
				}
			}
			// 执行更新
			pstmt.executeUpdate();
			
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.closeAll(con, pstmt, null);
		}
	}
	
	/**
	 * 查询的通用方法
	 * @param sql
	 * @param paramsValue
	 */
	public <T> List<T> query(String sql, Object[] paramsValue,Class<T> clazz){
		
		try {
			// 返回的集合
			List<T> list = new ArrayList<T>();
			// 对象
			T t = null;
			
			// 1. 获取连接
			con = JdbcUtil.getConnection();
			// 2. 创建stmt对象
			pstmt = con.prepareStatement(sql);
			// 3. 获取占位符参数的个数， 并设置每个参数的值
			int count = pstmt.getParameterMetaData().getParameterCount();
			if (paramsValue != null && paramsValue.length > 0) {
				for (int i=0; i<paramsValue.length; i++) {
					pstmt.setObject(i+1, paramsValue[i]);
				}
			}
			// 4. 执行查询
			rs = pstmt.executeQuery();
			// 5. 获取结果集元数据
			ResultSetMetaData rsmd = rs.getMetaData();
			// ---> 获取列的个数
			int columnCount = rsmd.getColumnCount();
			
			// 6. 遍历rs
			while (rs.next()) {
				// 要封装的对象
				t = clazz.newInstance();
				
				// 7. 遍历每一行的每一列, 封装数据
				for (int i=0; i<columnCount; i++) {
					// 获取每一列的列名称
					String columnName = rsmd.getColumnName(i + 1);
					// 获取每一列的列名称, 对应的值
					Object value = rs.getObject(columnName);
					// 封装： 设置到t对象的属性中  【BeanUtils组件】
					BeanUtils.copyProperty(t, columnName, value);				
				}
				
				// 把封装完毕的对象，添加到list集合中
				list.add(t);
			}
			
			return list;
		} catch (Exception e) {
			throw new RuntimeException(e);
		} finally {
			JdbcUtil.closeAll(con, pstmt, rs);
		}
	}
}



public class AdminDao extends BaseDao {

	// 删除
	public void delete(int id) {
		String sql = "delete from admin where id=?";
		Object[] paramsValue = {id};
		super.update(sql, paramsValue);
	}

	// 插入
	public void save(Admin admin) {
		String sql = "insert into admin (userName,pwd) values (?,?)";
		Object[] paramsValue = {admin.getUserName(),admin.getPwd()};
		super.update(sql, paramsValue);
	}
	
	// 查询全部
	public List<Admin> getAll(){
		String sql = "select * from admin";
		List<Admin> list = super.query(sql, null, Admin.class);
		return list;
	}
	
	// 根据条件查询(主键)
	public Admin findById(int id){
		String sql = "select * from admin where id=?";
		List<Admin> list = super.query(sql, new Object[]{id}, Admin.class);
		return  (list!=null&&list.size()>0) ? list.get(0) : null;
	}
	
}

4. DbUtils组件

commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。

DbUtils组件，

简化jdbc操作
下载组件，引入jar文件 : commons-dbutils-1.6.jar

实例

|-- DbUtils 关闭资源、加载驱动

|-- QueryRunner 组件的核心工具类：定义了所有的与数据库操作的方法(查询、更新)

Int update(Connection conn, String sql, Object param); 执行更新带一个占位符的sql

Int update(Connection conn, String sql, Object… param); 执行更新带多个占位符的sql

Int[] batch(Connection conn, String sql, Object[][] params) 批处理

T query(Connection conn ,String sql, ResultSetHandler<T> rsh, Object... params) 查询方法

Int update( String sql, Object param);

Int update( String sql, Object… param);

Int[] batch( String sql, Object[][] params)

注意：如果调用DbUtils组件的操作数据库方法，没有传入连接对象，那么在实例化QueryRunner对象的时候需要传入数据源对象： QueryRunner qr = new QueryRunner(ds);

DbUtils提供的封装结果的一些对象：

BeanHandler: 查询返回单个对象
BeanListHandler: 查询返回list集合，集合元素是指定的对象

3) ArrayHandler, 查询返回结果记录的第一行，封装对对象数组, 即返回：Object[]

4) ArrayListHandler, 把查询的每一行都封装为对象数组，再添加到list集合中

5) ScalarHandler 查询返回结果记录的第一行的第一列 (在聚合函数统计的时候用)

6) MapHandler 查询返回结果的第一条记录封装为map

day20 连接池、分页

1.连接池

思考：

程序中连接如何管理？

连接资源宝贵；需要对连接管理
连接：
1. 操作数据库，创建连接
2. 操作结束，关闭！

分析：

涉及频繁的连接的打开、关闭，影响程序的运行效率！

连接管理：

预先创建一组连接，有的时候每次取出一个；用完后，放回；

学习连接池：

自定义一个连接池
学习优秀的连接池组件
1. DBCP
2. C3P0

代理：

如果对某个接口中的某个指定的方法的功能进行扩展，而不想实现接口里所有方法，可以使用(动态)代理模式!

Java中代理模式：静态/动态/Cglib代理(spring)

使用动态代理，可以监测接口中方法的执行！

如何对Connection对象，生成一个代理对象：

|--Proxy

static Object newProxyInstance(

ClassLoader loader, 当前使用的类加载器

Class<?>[] interfaces, 目标对象(Connection)实现的接口类型

InvocationHandler h 事件处理器：当执行上面接口中的方法的时候，就会自动触发事件处理器代码，把当前执行的方法(method)作为参数传入。

)

/**
 * 自定义连接池, 管理连接
 * 代码实现：
	1.  MyPool.java  连接池类，   
	2.  指定全局参数：  初始化数目、最大连接数、当前连接、   连接池集合
	3.  构造函数：循环创建3个连接
	4.  写一个创建连接的方法
	5.  获取连接
	------>  判断： 池中有连接， 直接拿
	 ------>                池中没有连接，
	------>                 判断，是否达到最大连接数； 达到，抛出异常；没有达到最大连接数，
			创建新的连接
	6. 释放连接
	 ------->  连接放回集合中(..)
 *
 */
public class MyPool {

	private int init_count = 3;		// 初始化连接数目
	private int max_count = 6;		// 最大连接数
	private int current_count = 0;  // 记录当前使用连接数
	// 连接池 （存放所有的初始化连接）
	private LinkedList<Connection> pool = new LinkedList<Connection>();
	
	
	//1.  构造函数中，初始化连接放入连接池
	public MyPool() {
		// 初始化连接
		for (int i=0; i<init_count; i++){
			// 记录当前连接数目
			current_count++;
			// 创建原始的连接对象
			Connection con = createConnection();
			// 把连接加入连接池
			pool.addLast(con);
		}
	}
	
	//2. 创建一个新的连接的方法
	private Connection createConnection(){
		try {
			Class.forName("com.mysql.jdbc.Driver");
			// 原始的目标对象
			final Connection con = DriverManager.getConnection("jdbc:mysql:///jdbc_demo", "root", "root");
			
			/**********对con对象代理**************/
			
			// 对con创建其代理对象
			Connection proxy = (Connection) Proxy.newProxyInstance(
					
					con.getClass().getClassLoader(),    // 类加载器
					//con.getClass().getInterfaces(),   // 当目标对象是一个具体的类的时候 
					new Class[]{Connection.class},      // 目标对象实现的接口
					
					new InvocationHandler() {			// 当调用con对象方法的时候， 自动触发事务处理器
						@Override
						public Object invoke(Object proxy, Method method, Object[] args)
								throws Throwable {
							// 方法返回值
							Object result = null;
							// 当前执行的方法的方法名
							String methodName = method.getName();
							
							// 判断当执行了close方法的时候，把连接放入连接池
							if ("close".equals(methodName)) {
								System.out.println("begin:当前执行close方法开始！");
								// 连接放入连接池
								pool.addLast(con);
								System.out.println("end: 当前连接已经放入连接池了！");
							} else {
								// 调用目标对象方法
								result = method.invoke(con, args);
							}
							return result;
						}
					}
			);
			return proxy;
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
	
	//3. 获取连接
	public Connection getConnection(){
		
		// 3.1 判断连接池中是否有连接, 如果有连接，就直接从连接池取出
		if (pool.size() > 0){
			return pool.removeFirst();
		}
		
		// 3.2 连接池中没有连接： 判断，如果没有达到最大连接数，创建；
		if (current_count < max_count) {
			// 记录当前使用的连接数
			current_count++;
			// 创建连接
			return createConnection();
		}
		
		// 3.3 如果当前已经达到最大连接数，抛出异常
		throw new RuntimeException("当前连接已经达到最大连接数目 ！");
	}
	
	
	//4. 释放连接
	public void realeaseConnection(Connection con) {
		// 4.1 判断： 池的数目如果小于初始化连接，就放入池中
		if (pool.size() < init_count){
			pool.addLast(con);
		} else {
			try {
				// 4.2 关闭 
				current_count--;
				con.close();
			} catch (SQLException e) {
				throw new RuntimeException(e);
			}
		}
	}
	
	public static void main(String[] args) throws SQLException {
		MyPool pool = new MyPool();
		System.out.println("当前连接: " + pool.current_count);  // 3
		
		// 使用连接
		pool.getConnection();
		pool.getConnection();
		Connection con4 = pool.getConnection();
		Connection con3 = pool.getConnection();
		Connection con2 = pool.getConnection();
		Connection con1 = pool.getConnection();
		
		// 释放连接, 连接放回连接池
//		pool.realeaseConnection(con1);
		/*
		 * 希望：当关闭连接的时候，要把连接放入连接池！【当调用Connection接口的close方法时候，希望触发pool.addLast(con);操作】
		 * 																			把连接放入连接池
		 * 解决1：实现Connection接口，重写close方法
		 * 解决2：动态代理
		 */
		con1.close();
		
		// 再获取
		pool.getConnection();
		
		System.out.println("连接池：" + pool.pool.size());      // 0
		System.out.println("当前连接: " + pool.current_count);  // 3
	}
	
}

代理的总结：(了解会用)

使用代理，可以在不实现接口的情况，对接口的方法进行扩展，添加额外的用户需要的业务逻辑！

2.开源的连接池技术

概述：

Sun公司约定：如果是连接池技术，需要实现一个接口！

javax.sql.DataSource;

连接池：

DBCP

C3P0

2.1DBCP连接池：

DBCP 是 Apache 软件基金组织下的开源连接池实现，使用DBCP数据源，应用程序应在系统中增加如下两个 jar 文件：
- Commons-dbcp.jar：连接池的实现
- Commons-pool.jar：连接池实现的依赖库
Tomcat 的连接池正是采用该连接池来实现的。该数据库连接池既可以与应用服务器整合使用，也可由应用程序独立使用。
核心类：BasicDataSource
使用步骤
- 引入jar文件
  - commons-dbcp-1.4.jar
  - commons-pool-1.5.6.jar


public class App_DBCP {

	// 1. 硬编码方式实现连接池
	@Test
	public void testDbcp() throws Exception {
		// DBCP连接池核心类
		BasicDataSource dataSouce = new BasicDataSource();
		// 连接池参数配置：初始化连接数、最大连接数 / 连接字符串、驱动、用户、密码
		dataSouce.setUrl("jdbc:mysql:///jdbc_demo");			//数据库连接字符串
		dataSouce.setDriverClassName("com.mysql.jdbc.Driver");  //数据库驱动
		dataSouce.setUsername("root");							//数据库连接用户
		dataSouce.setPassword("root"); 							//数据库连接密码
		dataSouce.setInitialSize(3);  // 初始化连接
		dataSouce.setMaxActive(6);	  // 最大连接
		dataSouce.setMaxIdle(3000);   // 最大空闲时间
		
		// 获取连接
		Connection con = dataSouce.getConnection();
		con.prepareStatement("delete from admin where id=3").executeUpdate();
		// 关闭
		con.close();
	}
	
	@Test
	// 2. 【推荐】配置方式实现连接池  ,  便于维护
	public void testProp() throws Exception {
		// 加载prop配置文件
		Properties prop = new Properties();
		// 获取文件流
		InputStream inStream = App_DBCP.class.getResourceAsStream("db.properties");
		// 加载属性配置文件
		prop.load(inStream);
		// 根据prop配置，直接创建数据源对象
		DataSource dataSouce = BasicDataSourceFactory.createDataSource(prop);
		
		// 获取连接
		Connection con = dataSouce.getConnection();
		con.prepareStatement("delete from admin where id=4").executeUpdate();
		// 关闭
		con.close();
	}
}
配置方式实现DBCP连接池，  配置文件中的key与BaseDataSouce中的属性一样：
db.properties
url=jdbc:mysql:///jdbc_demo
driverClassName=com.mysql.jdbc.Driver
username=root
password=root
initialSize=3
maxActive=6
maxIdle=3000

2.2 C3P0连接池：

C3P0连接池：

最常用的连接池技术！Spring框架，默认支持C3P0连接池技术！

C3P0连接池，核心类：

CombopooledDataSource ds;

使用：

下载，引入jar文件: c3p0-0.9.2.jar
使用连接池，创建连接
1. 硬编码方式
2. 配置方式(xml)


public class App {

	@Test
	//1. 硬编码方式，使用C3P0连接池管理连接
	public void testCode() throws Exception {
		// 创建连接池核心工具类
		ComboPooledDataSource dataSource = new ComboPooledDataSource();
		// 设置连接参数：url、驱动、用户密码、初始连接数、最大连接数
		dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc_demo");
		dataSource.setDriverClass("com.mysql.jdbc.Driver");
		dataSource.setUser("root");
		dataSource.setPassword("root");
		dataSource.setInitialPoolSize(3);
		dataSource.setMaxPoolSize(6);
		dataSource.setMaxIdleTime(1000);
		
		// ---> 从连接池对象中，获取连接对象
		Connection con = dataSource.getConnection();
		// 执行更新
		con.prepareStatement("delete from admin where id=7").executeUpdate();
		// 关闭
		con.close();
	}
	
	@Test
	//2. XML配置方式，使用C3P0连接池管理连接
	public void testXML() throws Exception {
		// 创建c3p0连接池核心工具类
		// 自动加载src下c3p0的配置文件【c3p0-config.xml】
		ComboPooledDataSource dataSource = new ComboPooledDataSource();// 使用默认的配置
		
		// 获取连接
		Connection con = dataSource.getConnection();
		// 执行更新
		con.prepareStatement("delete from admin where id=5").executeUpdate();
		// 关闭
		con.close();
		
	}
}

转载于:https://my.oschina.net/u/3299202/blog/3062231