MYSQL数据库（0基础）

mysql卸载与安装

1.mysql安装
1）获取安装包解压，获得mysql主目录
2）配置环境变量
path->主目录/bin
3）执行初始化命令 cmd（管理权限） bin/mysqld命令初始化与安装
$>mysqld --initialize --insecure
–initialize:初始化
–insecure：免密码，新数据库 默认用户root户用密码为空
4）执行安装命令
$>mysqld install [服务名称]
5）启动
第一种：在服务里启动
win+r:输入service.msc 进入服务，手动启动服务
第二种：命令启动
$>net start mysql服务名
$>net stop mysql 服务名
6）卸载（管理员）
$>sc delete 服务名
7）登录测试
第一次登录：
$>mysql -u root
8）初始化改默认root账户密码（前提是安装时没有设置密码）
mysql>set password =password(‘新密码’);
2.mysql测试
$>mysql -u root -p 密码
3.mysql卸载
$>sc delete 服务名

初识Mysql

1.概念
数据：如开发中的字符串、整数、对象等等存在内存中
数据库：存储数据的仓库
DBMS:数据库管理系统(软件),特点是以二维表为结构
一般称之为关系型数据库。
常见关系型数据库：
1)Apache·组织管理->中小型数据库 mysql
2)甲骨文公司->大型数据库 oracle
3)微软->中型数据 sqlserver
mysql服务器(server)：数据存储的一方
mysql客户端(client)：数据使用的一方 如程序、cmd、Navicat等
表(table)：用于存储数据的结构,类似于excel,二维结构
数据库实例：一个真实的数据库,数据库实例下有有多张表
用户：用来登录和操作数据库的凭证,用户下有多个数据库实例

2.命令操作nysql
1)连接mysql数据库
$>mysql [-h 数据库IP] -u 用户名 -p密码 //[]可省略,默认本机IP
$>mysql -h 127.0.0.1 -u root -p123456
2)显示当前用户下的所有数据库实例
$>show databases; //注意分好分号不能少
3)创建数据库实例
$>create database 数据库实例名;
$>create database bank;
4)切换数据库实例(进入下一个数据库实例)
$>use 数据库实例名;
$>use bank;
5)查看某一个数据库下的所有表(前置条件：先进入数据库)
$>show tables;
6)创建一张表
$>create table acount(
列1 类型,
列2 类型,
列3 类型);

	$>create table acount(
	-> numb int,
	-> name varchar(12),
	-> money int);

7)查看表结构

	$>desc|describe 表名;   //desc bank;

8)删除表

	$>drop table 表名;
	$>drop table acount;

9)删除数据库实例

	$>drop database 数据库名;
	$>drop database bank;

3.sql(结构查询语句)
3.1概念
sql：Structured（结构化）Query（查询）Language（语言），关系型数据库的语言使用的是sql
nosql：not only sql，不仅仅是sql
sql语言分类：DDL，DML，TCL，DCL
3.2DDL（数据定义语言 Data Definition Language)）：对结构（模式 shema）的操作
DDL：对用户，数据库实例，表结构（创建表，删除表，查看结构）等
涉及关键字：create（创建），drop（删除），alter（修改），truncate（截断）：重构表结构
3.2.1 CREATE
1）创建用户：create user 用户名 dentified by 密码
mysql ->user表中的数据即用户数据（其中host和user列）
用户中的用户：用户名@host
如： create user ‘xiaoliu66’@‘localhost’ identified by ‘123456’;
mysql> create user ‘xiaoliu66’@’%’ identified by ‘123456’;（百分号表示外机可以登录）
2）创建数据实例：create database 数据库名
第一种：create database 数据库名；//默认字符集lantin(拉丁文)
第二种：create database 数据库名 character set字符集
3）创建表：create table 表名（
列名1 类型 约束 备注，
列名2 类型 约束 comment ‘备注名’）character set字符集
alter database bank character set utf8;
4）创建视图：create view 视图 as…
5)创建索引：create index 索引名 …
3.2.2 DPOP
1)drop user 用户名（’user‘%’host‘）
drop user ‘xiaoliu66’@’%’;
2）drop database 数据库名字
drop database bank1;
3）drop table 表名
drop table t1;
4）drop view 视图名
5）drop index 索引名
3.2.3 ALTER
1）alter
database和user不能用alter修改，一般改table
3.2.4 TRUNCATE

3.3DML（数据操作语言 Data Manipulation Language）：对数据的操作
DML：对表中数据具体的操作
Insert（增加），update（修改），delete（删除），select（查询）
3.3.1 Insert
语法：insert 表名（列1，列2…）value（值1，值2,…）
insert into t2(no,age) values (3,8)
3.3.2 Update

3.3.3 Delete

3.3.4 Select
3.4 TCL（事务操作语言）：对事物的操作
3.5 DCL（数据控制语言）：对权限的操作
权限：sql中的所有操作都是一个个权限
如创建数据库 ->权限名 create
DCL 关键字：grant（授权）与revoke（取消授权）
3.5.1 grant
语法：
1）$>grant 权限名 on 数据库名.表名 to 用户名
grant create on . to ‘xiaoliu66’@‘localhost’;
2）授予所有权限：
$>grant all privileges on . to ’xiaoliu66’@‘localhost’

知识点：
	每次授权之后刷新权限
	flush privileges

3.5.2 revoke
语法：$>revoke 权限名 on 数据库名.表名 from 用户名
revoke create on . from ‘xiaoliu66’@‘localhost’;
$>revoke all privileges on . from ’xiaoliu66’@‘localhost’
4.数据类型
4.1 概念
数据库类型与java类型作用一样的，类型的意义也类似
4.2 数字类型
4.2.1 整形
int bigint tinyint（short）
int(4)和int（10）、int的区别：
1）都是占用int长度
2）如果int（n），n显示多长的内容，但是一般和zerofill填充
age int(4) zerofill
4.2.2 浮点型
1）double，float和java一样
2）decimal（长度，精度）
price decimal（7，2）；
样例数据：4500000//错误，补齐4500000.00，长度为9
1000.00001//正确，自动截取1000.00，长度为6
4.3 字符类型（类似于 java String）
1）char（n）:内存中占用n个字符的长度（固定长度），不够自动补空格，n最大255个
如：no char（10） #内存分配10个字符的内存
2）varchar：内存中最多分配n个字符的长度，n最大255
name varchar（10） #内存中最多分配10个字符的内存
3）text：超过255个的字符（文本）类型，用text，text最大储存12G。
address mediumtest；//521M
4.4 日期类型
开发中常用的数据类型：
1）date：日期类型，yyyy-mm-dd
2）time：时间类型，hh：mm：ss
3）day：天类型
4）year：年类型
5）timestamp：时间戳类型，yyyy-MM-ddHH：mm：ss000，唯一
4.4.1 date类型
4.4.2 datetime类型
4.4.3 timestamp类型
1)data yyyy-MM-dd格式

	create table biz_product(
		proid int(8) zerofill comment '商品ID',
		proName varchar(20) comment '商品姓名',
		createDate date comment '上架时间'
	)charset=utf8;
	
	insert into biz_product(proid,proName,createDate) values
		(1001,'商品A','2020-10-12'),
		(1002,'商品B','2020-10-18');

2)datatime yyyy-MM-dd hh:mm:ss-格式

	 create table order1(
		oid int comment '订单ID',
		productID int(8) comment '商品ID',
		amount int comment '购买数量',
		createTime datetime comment '下单时间'
	)charset=utf8;
	insert into order1(oid,productID,amount,createTime) values
		(5001,1002,20,'2020-11-12 08:35:50'),
		(5002,1001,30,'2020-11-20 23:21:25');

4.5 null类型
null类型在insert时，没有赋值时会出现，和java的类型不同，java的基本类型int，long都有默认值，但是数据库的int，long类型不给值就是null类型
5.其他知识
1)default：默认值
create table t1(
列名 类型 备注,
列名 类型 default 默认值 comment ‘年龄’
)charset=utf8;

create table t1(
	num int comment '编号',
	age int default 25 comment '年龄'
)charset=utf8;

insert into t1(num) values(1001);
	+------+------+
	| num  | age  |
	+------+------+
	| 1001 |   25 |
	+------+------+

2)zerofill 0填充
一般与int(n),bigint(n),tinyint(n)配套使用

	create table t1(
			num int(5) zerofill
		);
		insert into t1(no) values (3); //表中为00003

3)unsigned 无符号数(非负数)
无符号数一般和数字类型配套使用

		create table tb1(
			num int unsigned comment '编号'  //插入负数将自动变为插入0
		charset=utf8;
		insert into tb1(num) values(-10);
		+------+
		| num  |
		+------+
		|    0 |
		+------+

4)auto_increment 自增 主键如果没有给值,则从当前列中最大值(默认0)加1
自增和主键约束配套使用
create table 表名(
列名1 类型 primary key auto_increment 备注
) charset=utf8;

	create table ta(
		num int primary key auto_increment comment '商品ID',
		amount int not null comment '数量'
	)charset=utf8;
	insert into t1(amount) values (1);
		+-----+--------+
		| num | amount |
		+-----+--------+
		|   1 |      1 |
		+-----+--------+
	insert into t1(num,amount) values (11,11);
	insert into t1(amount) values (1);
		+-----+--------+
		| num | amount |
		+-----+--------+
		|   1 |      1 |
		|   2 |      1 |
		|  11 |     11 |
		|  12 |      1 |
		+-----+--------+

6.约束
6.1 概念
约束：限制值得范围,通过约束键(key)来实现约束
6.2 主键约束： primary key 非null 唯一,一张表只能设置一次,可以设置多列
1)只设置一列为主键
列名 类型 primary key 备注;

	create table t1(
		num int primary key comment '商品ID',
		amount int not null comment '数量'
	)charset=utf8;
	
	create table t3(
		num int  comment '商品ID',
		amount int comment '数量',
		primary key(num)
	)charset=utf8;

2)设置多列为主键
create table 表名(
列名1 类型 约束 备注,
列名2 类型 约束 comment ‘备注名’,
…,
primary key(列名1,列名2…)
) charset=utf8;

	create table t2(
		num int  comment '商品ID',
		amount int comment '数量',
		primary key(num,amount)
	)charset=utf8;

6.3 非null约束 not null
列名 类型 not null 备注;
oid int(11) not null comment ‘商品ID’;

6.4 唯一约束 unique key（不允许有重复值）
列名 类型 unique key 备注;
oid int(11) unique key comment ‘商品ID’;

6.5 外键约束 foregin key 表中的一列值和另外一张表的一列值对应

数据查询

1.概念
select查询 数据库的90%价值
2.语法
select 列1，列2… form表或者结果集
where 原始数据筛选条件
group by 分组条件
having 分组筛选条件
order by 排序
limit 限制结果条数 //mysql独有的关键字
执行顺序：from -> where ->group by->having-> order by -> select->limit
2 from
2.1 一张表
样例：
select
from
select so from(select no,name from test01) t1;(结果集要指定名字t1)
2.2 两张以及以上的表
2.2.1 笛卡尔积
语法：from 表1，表2
select o.*,p.*
from biz_order o,biz_producte p（可以用where去筛选）
笛卡尔积结果：总记录数：为A记录数*B记录数，总可用列数：为A列数+B列数
样例：
1）查询学生姓名，成绩，考试时间

	select stu.studentName,r.studentResult,r.examDate
	from student stu,result r
	where stu.studentNo=r.studentNo //减少冗余数据

2）查询学生姓名，科目，成绩，考试时间

	select stu.studentName,sub.subjectName,r.studentResult,r.examDate
	from student stu,result r,subject sub
	where stu.studentNo=r.studentNo and r.subjectNo=sub.subjectNo

3）查询学生姓名，年纪，科目，成绩，考试时间

	select stu.studentName,g.gradeName,sub.subjectName,r.studentResult,r.examDate
	from student stu,result r,subject sub,grade g
	where stu.studentNo=r.studentNo and r.subjectNo=sub.subjectNo and stu.gradeID=g.gradeID

2.2.2 jion
查看高阶查询笔记(下面)
3. where
3.1 概念
where对from后的原始数据的筛选
3.2 语法
3.2.1 对数字、日期的操作
1）等值操作=
2）> < != >= <=等操作
样例1：查询考试成绩大于80分的学生信息

	select stu.*
	from result r,student stu
	where r.studentNo=stu.studentNo and r.studentResult>80

样例2：查询存在课时<120课时的年级信息

	select  g.*
	from grade g,subject sub
	where g.gradeID=sub.gradeID and sub.classHour<120

样例3：查询学生姓名，性别，出生日期 科目 成绩 （要求：只要课时超过120，成绩大于80的以上信息）

	SELECT
		stu.studentName,
		stu.sex,
		stu.address,
		sub.subjectName,
		r.studentResult 
	FROM
		student stu,
		SUBJECT sub,
		result r 
	WHERE
		stu.studentNo = r.studentNo 
		AND r.subjectNo = sub.subjectNo 
		AND sub.classHour > 120 
		AND r.studentResult > 80

3.2.2 对字符的操作
1）=等值操作
样例： 查询课程名称为’C#基础’的课程信息

	select sub.*
	from subject sub
	where sub.subjectName='C#基础'

2）前模糊查询 like‘%内容’
样例：课程名称为第三学年的课程（-3）的课程信息

	select sub.*
	from subject sub
	where sub.subjectName like '%-3'

3）后模糊查询 like‘内容%’
样例：查询以高等数学开始的课程信息

	select sub.subjectName
	from `subject` sub
	where sub.subjectName like '高等数学%'

4）全模糊查询 like‘%内容%’
样例：查询包含c的课程信息

	select sub.subjectName
	from `subject` sub
	where sub.subjectName like '%c%'

5）concat拼接函数
样例1：查询id，课程编号

		select concat('编号：(',sub.subjectNo,')'),sub.subjectName
		from subject sub
    结果：
		编号：(1)	高等数学-1
		编号：(2)	高等数学-2
		编号：(3)	高等数学-3

样例2：like concat（‘%’，内容，‘%’）

		select sub.*
		from `subject` sub
		where sub.subjectName like concat('%','c','%')

3.2.3 对范围的操作
1)between 起始值 and 结束值 //两个闭区间，数值为左小右大

	select sub.*
	from `subject` sub,grade g
	where sub.gradeID=g.gradeID and g.gradeID between 2 and 3

2)in（成员1，成员2…成员n）
样例：查询大一，大二的所有课程信息

	select sub.*
	from `subject` sub,grade g
	where sub.gradeID=g.gradeID and g.gradeName in('大一','大二')

3）not in（成员1，成员2）
样例：查询不是大一的所有课程信息

	select sub.*
	from `subject` sub,grade g
	where sub.gradeID=g.gradeID and g.gradeName not in('大一')

3.2.4 对null值的操作
样例：查询没有归属年级（年级编号为null）的课程信息

select sub.*
from subject sub
where sub.subjectId is null

4.group by:分组条件
4.1 概念
分组：将原始数据根据条件分组，每一组构成一条新数据（和聚合一起使用）
4.2 样例
1）查询每个年级多少人，结果显示年级和人数

	select g.gradeName,count(stu.studentNo)
	from grade g,student stu
	where g.gradeID=stu.gradeID
	GROUP BY g.gradeID

2）显示性别为1的人数

	select stu.sex,count(stu.studentNo)
	from student stu
	where stu.sex=1;
	group by stu.sex

3）查询每个年级一共有多少门课 显示年级 课程数

	select g.gradeName,count(sub.subjectNo)
	from grade g,subject sub
	where g.gradeID=sub.gradeID
	GROUP BY g.gradeID

4） 查询每一门课的考试人数

	select sub.subjectName,count(r.studentNo)
	from subject sub,result r
	where sub.subjectNo=r.subjectNo
	GROUP BY sub.subjectName

5） 查询每一个年级的考试人数

	select g.gradeName,count(r.subjectNo)
	from grade g,result r,subject sub
	where sub.subjectNo=r.subjectNo and sub.gradeID=g.gradeID
	GROUP BY g.gradeName

4.3 易错知识点
1）一个select from 结构 只分一次组（即出现一个group by，但是可以跟多个分组条件）
2）聚合数据不能出现在 where 原始数据筛选中，只能出现在having中
如：
where avg（xxx）>75 //语法错误
3）group by，分组后，将一组数据变为一条数据
5.having
操作分组后的对象
6.聚合函数：组内 记录总数（count），平均数（avg），求和（sum），最大值（max），最小值（min）
1）count：组内统计记录的条数，count（字段名或值）
count+group by配套使用，如果没有group by，即所有数据是一组
2）avg，max，min
样例：统计每个科目的最高分，最低分，平均分

	select sub.subjectName '科目',max(g.studentResult) '最高分',
	min(g.studentResult) '最低分',avg(g.studentResult) '平均分'
	from result g,subject sub
	where g.subjectNo=sub.subjectNo
	GROUP BY sub.subjectName

3）平均分数大于75的科目名称

	select sub.subjectName,avg(r.studentResult)
	from result r,subject sub
	where r.subjectNo=sub.subjectNo
	GROUP BY sub.subjectName
	HAVING AVG(r.studentResult)>75

4）平均分数大于75的科目个数

	select count(subjectName)
	from(select sub.subjectName
	from result r,subject sub
	where r.subjectNo=sub.subjectNo
	GROUP BY sub.subjectName 
	HAVING avg(r.studentResult)>75)  t1 

6）求各个科目中的最低分中最高的科目名称

		select r.subjectNo,sub.subjectName
		from result r,subject sub
		where r.subjectNo=sub.subjectNo
		GROUP BY r.subjectNo
		HAVING min(r.studentResult)=(select max(t1.最小)
		from (select sub.subjectName,min(r.studentResult) '最小'
		from result r,subject sub
		where r.subjectNo=sub.subjectNo
		GROUP BY sub.subjectName) t1
		HAVING max(t1.最小))
		方法2：（不建议用，limit只有mysql独有）
			select r.subjectNo
			from result r
			GROUP BY r.subjectNo
			HAVING min(r.studentResult)=(
			select min(r.studentResult) 
			from result r
			GROUP BY r.subjectNo
			ORDER BY min(r.studentResult) desc
			limit 1
			)

7）求科目中带c中额最低分中最高分的科目名称
7.order by和limit
7.1 order by（结果排序）
语法：order by 列1 规则，列2 规则…
第一种：降序（desc）->从大到小
第二种：升序（asc）->从小到大
样例：查询学生信息，按照年级升序显示

		select *
		from student
		ORDER BY student.gradeID desc
		按照年级升序，年龄降序
		select *
		from student
		ORDER BY student.gradeID asc,
				student.birthday desc
        mysql中的独有排序：
		select *
		from student
		ORDER BY 6 asc,9 desc//可以用序号，代表列名

7.2 limit
limit 作用：限制最终结果集中显示的条数
语法：
第一种：limit n //显示前n条
样例：查询学生前n条

		select *
		from student
		ORDER BY student.gradeID asc,
				student.birthday desc
		limit 5

第二种：limit m，n//从第m条显示n条
样例：查询学生第5条开始后的记录，显示5条(不包含第五条)

		select *
		from student
		ORDER BY student.gradeID asc,
				student.birthday desc
		limit 5，5

8.其他知识
8.1别名
为了简写或者规避重复系列，我们一般会使用另外一个名称，这个名称即别名
8.2 表别名
第一种：from 表 as 表别名
select p.name,p.no
from test01 as p
第二种：from 表 表别名
select p.name,p.no
from test01 p
8.3 列别名
第一种：select 列1 as ”列别名“，列2…
第二种：select 列1 as 列别名，列2…
第三种：select 列1 列别名，列2…
样例：

		select test01.name as "姓名",
			test01.no as 员工编号,
				test01.salay 薪水
		from test01

错误：

	select no 员工 编号 from test01 

9.编写sql的步骤
1）确定sql题目想要的结果（确定字段）
2）如果第一步 字段在表上没有体现，间接体现出来
3）确定字段所在的表以及表之间的关系
可根据select字段确定需要哪些表
可以根据where 字段确定需要哪些表
4） 第2步和第3步的结果需要经过统计 才能出结果，那么需要分组和聚合，以及聚合数据的筛选
group by
having
5）根据题目要求规则，排序结果集，并确定显示记录条数
order by
limit
6）select 确定从最终的查询结果集中需要哪些字段
select ***

高阶查询

1.子查询
1.1 概念
子查询 即一个查询结果集，语法体现（select *** from…）
子查询能存在任何位置（select from where group by …）
1.2 子查询应用
1）select 中的子查询（一个值替换成另一个子查询的结果值）
特点：select中的子查询 结果只能是一行一列
样例：查询 学生姓名，科目名称，成绩

		select 
			(select stu.studentName from student stu where r.studentNo=stu.studentNo),
			(select sub.subjectName from subject sub where r.subjectNo=sub.subjectNo),
			r.studentResult
		from result r

样例：查询 学生姓名，科目名称，年级，成绩

		select 
		(select stu.studentName from student stu where r.studentNo=stu.studentNo) 姓名,
		(select sub.subjectName from subject sub where r.subjectNo=sub.subjectNo) 科目,
		(select g.gradeName from subject sub,grade g where sub.gradeID=g.gradeID and sub.subjectNo=r.subjectNo) 年级,
		r.studentResult 成绩
		from result r
		ORDER BY 成绩 desc

样例：查询 科目名称，最高分，最低分，平均分

		方法1：
		select
		 sub.subjectName,
		 (select max(r.studentResult)  from result r where r.subjectNo=
				sub.subjectNo GROUP BY r.subjectNo) 最高分,
		(select min(r.studentResult)  from result r where r.subjectNo=
				sub.subjectNo GROUP BY r.subjectNo) 最低分,
		(select avg(r.studentResult)  from result r where r.subjectNo=
				sub.subjectNo GROUP BY r.subjectNo) 平均分
		from subject sub
		方法2：
		select
		(select sub.subjectName from subject sub where sub.subjectNo=r.subjectNo) 课程名称,
		 max(r.studentResult)  最高分,
		 min(r.studentResult)  最低分,
		 avg(r.studentResult)  平均分
		from result r
		GROUP BY r.subjectNo

2）from中的子查询
from子查询可以是多行多列，但是要取别名
样例：年级名称，人数
3）where中的子查询
样例:查询没参加考试人的信息

	select stu.studentName
	from student stu
	where stu.studentNo not in(select DISTINCT(r.studentNo)
	from result r)

4）group by、having
1.3 子查询优缺点
优点：1）简单 2）子查询结果比较少
缺点：1）单独创建临时空间（临时表） 储存 子查询结果集
2）子查询普遍效率低（同样数据 查询次数更多）
2.连接查询
2.1 概念
连接查询：目标两张表，结果是笛卡尔积中的有效数据（两张表数据有关联）
2.2 内连接
语法： from 表A [inner] join 表B on A.字段=B.字段
样例：查询年级名称，年级id，学生编号，学生姓名

	select g.gradeName,g.gradeID,stu.studentNo,stu.studentName
	from grade g  join student stu on g.gradeID=stu.gradeID

2.3 左外连接：left join，基准表 join 左边表为主，可能会多数据
语法：from 表A left join 表B on A.字段=B.字段

	select g.gradeName,g.gradeID,stu.studentNo,stu.studentName
	from grade g  left join student stu on g.gradeID=stu.gradeID

2.4 右外连接：right join，基准表join右边表为主，可能会多数据
语法：from 表A right join 表B on A.字段=B.字段

	select g.gradeName,g.gradeID,stu.studentNo,stu.studentName
	from grade g  right join student stu on g.gradeID=stu.gradeID
多表连接：
	INNER JOIN 连接两个数据表的用法：
				SELECT * FROM 表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号
			INNER JOIN 连接三个数据表的用法：
				SELECT * FROM (表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) 
				INNER JOIN 表3 ON 表1.字段号=表3.字段号
			INNER JOIN 连接四个数据表的用法：
				SELECT * FROM ((表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号)
				 INNER JOIN 表3 ON 表1.字段号=表3.字段号) INNER JOIN 表4 ON Member.字段号=表4.字段号
			INNER JOIN 连接五个数据表的用法：
				SELECT * FROM (((表1 INNER JOIN 表2 ON 表1.字段号=表2.字段号) 
				INNER JOIN 表3 ON 表1.字段号=表3.字段号) INNER JOIN 表4 ON Member.字段号=表4.字段号) 
				INNER JOIN 表5 ON Member.字段号=表5.字段号

2.5 连接查询优缺点
优点：1）查询效率高（对比次数高）2）不需要单独开辟临时表空间（子查询需要）
缺点：1）只能做数据连接
样例：
1）统计显示 年级名称 人数

	select g.gradeName,count(stu.studentNo)
	from grade g left  join student stu on g.gradeID=stu.gradeID
	GROUP BY g.gradeID

3.exist和not exist
3.1 概念
exists 用于where子查询，用于数据联动筛选
3.2 语法
exists（查询结果集）函数作用：如果查询结果集有数据，返回true，反之false.(exists里可以是多列数据，和in有区别)
样例1：没有参加考试的学生信息

select *
from student
where not exists(select *from result where result.studentNo=student.studentNo)

样例2：没有课程的年级信息

select*
from grade
where not EXISTS(select * from subject where subject.gradeID=grade.gradeID)

3.3 exists与in和not in 与not exists 的区别
区别：
1）in 本质上还是等值判断，exists是循环判断
2）主查询的数据多于子查询的数据时使用in
主查询的数据少于子查询的数据时使用exists
3）in和exists查询次数基本相同
4. union 与union all
4.1 union
概念：两个查询结果集做累加，union 去重
语法：select 查询1 union select 查询2

样例：	select *from t1
		union 
		select *from t2 ORDER BY id
		结果：	1	A
				2	B
				2	F
				3	C
				4	D

4.2 union all
概念：两个查询结果集做累加，union all 不去重
语法：select 查询1 union all select 查询2
样例：

		select *from t1
		union all 
		select *from t2 ORDER BY id
		结果：
				1	A
				1	A
				2	B
				2	F
				3	C
				4	D

4.3 统计分析

科目名称	姓名			分数
大学数学1	人数：18人		平均分：75
			张三			71
			李四			77
高等数学2	人数：16		平均分：63
			张三			66
			李四			58
解题思路：
	1）将空白数据填充
	2）将数据分成两组：大学数学1，高等数学2。然后将数据合并调整
	3）按照名称排序，去除多余的科目名称

5.mysql函数
5.1 概念
mysql内置（已经定义好了，可以直接使用）了大量的函数
5.2 聚合函数
1)count
①count(*) *号默认找主键,一条主键则默认一条数据,若没有主键则查询所有列

		select count(*) from student s  //不能写成count(s.*)

②count(字段) 字段为null则不统计

		select count(s.studentNo) from student s

③count(n) 如果数据存在,则返回n的个数 建议使用

		select count(1) from student s   //返回1的个数
		select 1 from student s    //student表中存在一条数据则返回一个1

5.3 日期函数
1）now（）：当前时间，满足任何类型的时间：date，datetime，timestamp（时间戳）自动转换成相应类型

			select now()//当前日期
			create table tb3(createTime datetime);
			insert into tb3(createTime) values(now()); //插入为2020-11-28 11:55:45 
			create table tb3(createTime date);
			insert into tb3(createTime) values(now()); //插入为 2020-11-28

2）datediff（日期1，日期2）：两个日期之间的天数差
查询 学生姓名，年龄

	select student.studentName，floor（datediff（now()，student.brithday)/365)

3）adddate（时间，interval 数字，单位）
单位：year，month，day，house，min，second
样例：1000天之前的日期

	select ADDDATE(now(),INTERVAL -1000 day)//2018-03-04 14:09:11
	select ADDDATE(now(),INTERVAL -1000 year)

4）year，month，day（当前月份第几天）,week(当前年第几周）

		select year(now())			//当前年份
		select MONTH(now())			//当前月份
		select day(now())			//当前月份第几天
		select week(now())			//当前年第几周

5）dayOfyear（本年第几天）、dayOfmonth（本月第几天）、dayOfweek（本周第几天）

		select dayOfYear(now())    //本年第几天
		select dayOfmonth(now())   //本月第几天
		select dayOfweek(now())    //本周第几天

6）last_day（日期）：当月的最后一天

	select LAST_DAY('2020-2-3') //2020-02-29

5.4字符串函数
1）concat：字符串拼接函数
语法：concat（‘’，‘’，‘’…）
2）upper：转大写

	select upper(subject.subjectName)
	from subject

3）lower：转小写

	select lower(subject.subjectName)
	from subject

4）ifnull：如果为空则替换成其他内容
样例：查询学生姓名，出生日期，邮件

		select student.studentName,ifnull(student.birthday,'未知'),student.email  //如果生日为空则替换成未知，其他正常显示
		from student
	样例：统计查询如下结果
		科目名称	不及格人数	良好人数（小于80大于60）	优秀人数
		大学数学1	5			7							6
		大学数学2	4			9							3

5）if函数：if（布尔表达式，表达式1，表达式2）
样例：其中classHour超过120的为大课，没超过的为小课
查询：年级名称 大课数 小课数

				select
				grade.gradeName,
				sum(if(subject.classHour>=120,1,0)) 大课数,
				sum(if(subject.classHour<120,1,0)) 小课数
				from grade left join subject on grade.gradeID=subject.gradeID
				GROUP BY grade.gradeName
		结果：
				大一	1	4
				大三	0	4
				大二	0	4
				大四	4	0
				预科班	0	0
	样例：年级名称		男生人数		女生人数		22以上的人数		22以下的人数
				select
				grade.gradeName,
				concat(sum(if(student.sex=1,1,0)),'人') 男生人数,
				concat(sum(if(student.sex=2,1,0)),'人') 女生人数,
				concat(sum(if(floor(datediff(now(),student.birthday)/365)>35,1,0)),'人') 35以上年龄,
				concat(sum(if(floor(datediff(now(),student.birthday)/365)<35,1,0)),'人') 35以下年龄
				from grade left join student on grade.gradeID=student.gradeID
				GROUP BY grade.gradeID
		结果：
				大一	8人	2人	0人	8人
				大二	2人	0人	1人	1人
				大三	1人	2人	1人	2人
				大四	2人	2人	1人	3人
				预科班	0人	0人	0人	0人

6）left，right函数
语法：left（字段|字符串，截取几位）
right（字段|字符串，截取几位）
样例：

			select left('abcdefjg',3) //abc
			select right('abcdefjg',3) //fjg

7）lpad，rpad函数：填充函数 zerofill
语法：lpad（原字符串，总长度，填充内容）
rpad（原字符串，总长度，填充内容）
样例：

		select lpad('asd',10,'*')  //*******asd
		select rpad('asd',10,'*')  //asd*******

8）convert（）：类型转换函数
解决字符串和非字符串拼接中文乱码

	select concat('人数',12) //容易乱码
	select concat('人数',convert(12,char))//数字12转成字符串

5.4 其他函数
1）case when（变种的if else）

mysql事务、索引、备份与恢复

1.mysql事务
1.1 概念
事务：一个功能或一次完整操作，都是一批次的crud操作
如：转账操作：一个更改账户扣款和一个更改账户增加款的操作，这个转账操作即有两个updata操作构成，如果一个失败了，整个转账都要失败
并发事务：多个事务同时（多线程的交替）执行
事务作用：通过锁实现线程安全，保证事务作为一个整体，保证事务作为一个整体操作
关键字：commit（提交），rollback（回滚），savepoint。（提交或回滚之后事务结束）
mysql会话缓存：一个用户登录一次即一个会话（session），退出时会话消失，每一个会话都有自己的缓存
mysql数据存储：mysql数据存储在硬盘上（默认在mysql安装目录下/data）
mysql开启了自动提交机制（autocommit），会自动的将缓存数据同步到物理数据库。
如：执行一个insert、updata，都会直接和物理数据库操作
commit：缓存操作同步到物理数据库。
rollback：将缓存操作结果还原到最初的状态。
mysql的数据引擎：常见的Innodb（支持事务），myIsam（不支持事务）

	mysql> create table account(
	-> name varchar(255),
	-> money int
	-> )engine=innodb default charset=utf8;

事务的特征：ACID
原子性（Atomicity）：构成事务的多个操作是一个整体，而且最小单位
一致性（Consistency）：构成事务的多个操作最终要么都成功，要么都失败，数据状态保持一致
隔离性（Isolation）：多个事务之间具有隔离性，通过锁来实现
持久性（Duration）：单个事务如果事务中的所有操作都成功了，数据需要同步到物理数据库中（持久即数据存入硬盘）
1.2 mysql 事务操作
1）关闭自动提交机制
begin | start transaction | set autocommit=0
2)开启自动提交机制
commit | set autocomm it=1 | rollback
3）执行正常的crud操作
1.3 并发事务问题
1）丢失数据
如转账的第一个操作账户余额-1000，并发操作可能出现丢失数据，即两个事务同时操作一个共享数据，可能后操作覆盖先操作。
2）脏读：如果两个会话 A会话事务执行更改操作，B会话事务执行查询操作，A没有执行完，B执行后读取的数据可能是错误数据
（错误数据是指，B读到的是A没有执行之后的，但是没有提交的数据）
3）不可重复读：同一个事务中相同多次读取操作，结果不同，结果少了
4）幻读：同一个事务中相同多次读取操作，结果不同，结果多了
1.4 数据库实现事务隔离的方式
数据库提供了隔离级别方式，来部分解决并发事务问题。
读未提交->读提交->可重复读->串行化 四种隔离级别
1.5 锁
为了解决1.3并发问题我们通常两种方式来处理
数据库常用锁：表锁，行锁，页锁
其中innodb的锁：表锁、行锁
myisam的锁：表锁、页锁
常见的锁的类型：X锁（排他锁包括表锁和行锁），s锁（共享锁）；
创建排他锁（X）：select**from 表 for update
特点：如果X锁是表锁，所有记录都被当前session锁住
如果X锁是行锁，某一些记录被当前session锁住
创建s锁：selectfrom 表名 lock in share mode

	select *from account lock in share mode;

特点：如果表中数据事务A增加了s锁，那么其他事务还可以增加s锁，但是不能增加x锁
如果表中数据事务A增加了s锁，事务A还可以增加X锁，事务B不能增加任何锁
1.5.1 表锁（不加，自动会加一个表锁）
常见的表锁：select**from 表 for update
selectfrom account for update;
上锁步骤：①开启事务begin ②上锁：select***from 表 for update ③回滚或者提交会结束锁
上锁之后只能当前事务执行完，其他事务则等待上锁事务执行完之后再执行
概念：两个会话事务（A，B都操作同一张表）
1.5.2 行锁（行锁要在begin之外写，提交到物理数据库）
表结构中有索引字段，操作的是索引字段，排他锁产生即行锁。
alter table 表名 add index [索引名] （字段1，字段2）

		alter table account add index (name);

2.索引
2.1 概念
引入索引的概念是为了提高查询效率，索引即目录。
常见的索引：hash索引与B树（tree）索引，我们用B树索引
hash索引用于=值操作，B树索引用于>,<,范围，模糊查询等
m阶树：
索引优点：创建了一个索引表（目录），查找就可以按照索引字段查找，速度比全表扫描（不用索引）快很多
索引缺点：1）单独消耗空间（索引表）2）增删改都会变更索引表
索引常见问题解决：1）查询频率高的字段建索引，增删改频率高的不建议用索引
2）索引需要在查询中使用了索引字段才会生效
如where字段筛选
2.2 语法：
1）创建标准索引
语法：alter table 表 add index[索引名]（列1，列2…）
如：alter table result add indexresultindex
组合索引
alter table student add index（student.name，sex）//多个索引值
生效样例：
select …where studentName … and sex …
2）主键索引：创建表时，如果设置了主键，那么主键索引也建立好了
3）非空索引：创建表时，如果某些列是not null，那么这些类对应的非空索引也建立好了
4）全文索引（myisam）
3.视图（view 结构）
3.1 概念
view提高查询效率
view是一张虚表，数据来源于视图中物理表的数据
3.2 语法：
创建视图：
create view 视图名 as select ***
样例：查询所有年级，学生人数

	create view Grede_StuNum_View as
	select grade.gradeName,count(student.studentNo)
	from grade LEFT JOIN student on grade.gradeID=student.gradeID
	GROUP BY grade.gradeID

使用视图：select*from 视图名

	select *from Grede_StuNum_View

删除视图：

      drop view 视图名

4.数据备份
将数据库（表、视图、数据等）导出未一个sql文件
4.1 命令备份：结果为.sql文件
语法：不需要先登录mysql，直接通过mysqldump命令实现
$>mysqldump -h ip -u 用户名 -p 数据库 [表] >导出的位置（指定导入的文本）

 mysqldump -u root -p myschool >e:/d2005/temp/db1.sql

4.2 工具备份：结果为.sql文件和各数据库独有能识别的文件
右键数据库名（或者表名）->转存sql文件
5.数据恢复
利用备份的.sql文件恢复数据库结构和数据
5.1 mysql 命令恢复
语法：不需要先登录mysql，直接通过mysqldump命令实现
$>mysql -h ip -u 用户名 -p 数据库 [表] <导入的位置

 mysql -u root -p test <e:/d2005/temp/db1.sql

5.2 登陆后 source 命令恢复
1)登录mysql，并且选择一个数据库
$>source 文件位置
source e:/d2005/temp/db1.sql;
5.3 用工具恢复
右键数据库->运行sql文件（找到需要导入的一个sql文件）

jdbc

1.概念
jdbc：java database connection，java连接数据库技术，主要包括java操作数据库的crud（增删改查）
数据库驱动包：jdbc可以操作所有的关系型数据库，但是操作每一种数据库，都需要增加这种数据库的支持
dao：Data Access Object，数据访问对象（专职访问数据库的对象）
dao开发规范：
1）一张表 交给一个dao接口操作，一个接口至少有一个实现类
dao接口一般包位置：xxx.xxx.dao
dao接口实现类一般包位置：xxx.xxx.dao.impl
dao接口实现类命名：xxxdaoimpl.java
2）访问dao方法（执行crud）是建议通过接口来实现
biz：
2.jdbc开发步骤
1）增加数据库驱动包（mysql驱动包 mysql-connector-java）

	    <dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.41</version>
		</dependency>

2）加载驱动包中的驱动类到jvm中

	class.forName("com.mysql.jdbc.Driver")；//运行时获取类的结构,其中mysql可以更换成其他的数据库名，如SQL server

3）获取一个连接

	//url规则：jdbc：数据库类型：//ip：端口/数据库名?设置字符集
	String url="jdbc:mysql://localhost:3306/myschool?useUnicode=true&characterEncoding=utf8";
	Connection conn=
				DriverManager.getConnection(url, "用户名", "密码");

4）执行curd（增删查改）

		准备执行的SQL语句
		String sql="insert into subject(subjectNo,subjectName,classHour) 
				values (19,'数据库',130)";
		创建一个空句柄
		Statement sts=conn.createStatement();
		通过句柄执行sql语
		int a=sts.executeUpdate(sql);
		System.out.println("数据增加条数："+a)

5）关闭连接

conn.close();

3.jdbc实现查询
1）查询使用的connection 对象的executeQuery

	ResultSet rs=st.excuteQuery(sql);

2）executeQuery返回值是ResultSet对象
ResultSet对象特点：

		1）next() 一次取一行，Boolean返回值，代表是否取到了值
			如果取到了值存在rs对象里
			rs.next()
		2）rs.getXXX（“列名”）；其中xxx是结果列对应的java类型
			int id=rs.getInt("id");
			String name=rs.getString("name");

4.jdbc实现增删改
excuteUpdate返回值都是int，表示受影响数据库条数
5.jdbc事务
1）因为操作的是mysql数据库，所以需要关闭自动提交 才能开始事务

	conn.setAutoCommit(false);//关闭自动提交

2）如果成功了 提交操作，失败了回滚

	try{
		crud...
		conn.commit();//提交
	}catch(...){
		conn.rollback();//回滚
	}

6.jdbc使用配置文件
6.1 概念
将程序中的配置隔离出程序，定义成独立的文件
6.2 jdbc配置文件的使用
1）在src/main/sources 下新建databsse.properties
2）databsse.properties 文件储存的是键值对

	jdbc.driver=com.mysql.jdbc.Driver
	jdbc.user=root
	jdbc.password=123456
	jdbc.url=jdbc:mysql://localhost:3306/smbms?useUnicode=true&characterEncoding=utf8

3）程序使用properties配置文件

//读取database.properties
		Properties prop=new Properties();
		//读取文件流getClassLoader()->根目录 （bin）
		//读取后的信息存储在prop对象
		prop.load(daoUtil.class.getClassLoader().getResourceAsStream("database.properties"));
		//读取后设置root、url、password、driver
		user=prop.getProperty("jdbc.user");
		url=prop.getProperty("jdbc.url");
		password=prop.getProperty("jdbc.password");
		driver=prop.getProperty("jdbc.driver");

7. 优化DaoUtil 工具类
7.1 预编译防止注入
1) sql中使用预编译方式执行sql，防止sql注入
正式sql：select … from … where id = 值
sql正确使用：where id = 15
sql注入(非法)：where id = 500 or 1 = 1 //非法盗取所有数据

2. 预编译类似于java方法，如上面的sql定义成一个方法或函数

    fun (id) {
    	select ...
    	from ...
    	where id = 只能接受一个值
    }
   

3. 将句柄更改为预编译句柄

    String sql = "where id =" + ...;
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery(sql);
    更改为：
    String sql = "where id = ?";
    PreparedStatement stmt = conn.prepareStatement(sql);
    //在执行前补全占位符的值
    stmt.setObject(站位符序号,值);
    ResultSet rs = stmt.executeQuery();//这里不能写sql
   

7.2 新增数据，id是数据库自动完成的，需要在增加完数据后返回回来
1) DaoUtil 单独增加了 executeInsert 来实现
2) 使用预编译句柄，同时要求返回数据库自动生成的主键

	//创建预编译句柄并返回一个主键id：PreparedStatement.RETURN_GENERATED_KEYS
	PreparedStatement stmt = conn.prepareStatement(sql,
							PreparedStatement.RETURN_GENERATED_KEYS);

3. 新增还是通过executeUpdate完成的

    stmt.executeUpdate();//返回值无意义，只是用来判断插入数据是否成功
   

4. 手动获取新增后的主键

    //获取新增后的主键
    ResultSet rs = stmt.getGeneratedKeys();
    if (rs.next()) {
    	id = rs.getLong(1);//返回的是一行一列，即主键
    }
   

5. 测试样例 增加完了之后能看到这个主键id
   8.jdbc缓冲池
   8.1概念
   数据库缓冲池：是在jdbc基础（需要数据库驱动）上开发的缓冲池
   所有的数据库缓冲池技术都遵循java.sql.DataSource 接口规范
   DataSource:数据源或数据缓冲池
   通过DriverManager获取Connection（物理连接），需要消耗创建连接，运行crud时间、销毁连接时间构成、效率不高。
   数据库缓冲池（DataBasePooled）：是一种初始化连接数、最大连接数、最小连接数，Connection线程池
   如：现有一个数据库缓冲池：初始化10，最小8，最大30
   数据库常用的有三种缓冲池：
   常见缓冲池配置: dbcp ,C3P0 ,Druid
   dbcp：tomcat 的数据库缓冲池（jndi）使用的即dbcp
   c3p0：Hibernate框架使用的是c3p0数据库缓冲池
   Druid：阿里产品，微信、支付宝等数据库缓冲池都是使用的Druid
   1)基本配置：连接池进行数据库连接的四个必须配置

    		基本配置	DBCP		C3P0	Druid	 
    		用户名		username	user	username	 
    		密码		password	password	password	 
    		URL			url			jdbcUrl		url	 
    		驱动类名	driverClassName	driverClass	driverClassName	 
    		注：在Druid连接池配置中，driverClassName可配可不配，不配置的话可以根据url自动识别数据库类型，然后选择相应的driverClassName。
   

   2)关键配置：为了发挥数据库连接池的作用。

    		关键配置		DBCP				c3p0				Druid	 
    		最小连接数		minldle(0)			miniPoolSize(3)		minldle(0)	 
    		初始化连接数	initialSize(0)		initialPoolSize(3)	initialSize	 
    		最大连接数		maxTotal(8)			maxPoolSize(15)		maxActive(8)	 
    		最大等待时间	maxWaitMillis(毫秒）maxIdleTime(0秒）	maxWait(毫秒）	 
    		最大空闲连接数  maxIdle				无                  无
    		说明:	
    			最小连接数：是数据库一直保持的数据库连接数	 
    			初始化连接数：连接池启动时创建的初始化数据库连接数量	 
    			最大连接数：连接池能申请的最大连接数，请求超出此数时，后面的数据库连接请求被加入等待队列中。	 
    			最大等待时间：当没有可用连接时，连接池等待连接被归还的最大时间，超过时间则抛出异常，可设置为0或负数，无限等待。	 
    		注：在DBCP连接池的配置中，还有一个maxldle的属性，表示最大空闲连接数，超过的空闲连接将被释放。对应的该属性
    			在Druid中不再使用，配置了也不会有效果；而c3p0就没有对应的属性。	 
    		注：数据库连接池在初始化的时候会创建initialSize个连接，当有数据库操作时，会从池中取出一个连接。如果连接数
    			等于maxActive,则会等待一段时间，等待其他操作释放掉一个连接，如果这个时间超过了maxWait,就会报如果当前使用的数量没有达到maxActive，
    			则会判断当前是否空闲连接，有的话，直接使用空闲连接，没有的话，则新建一个连接。
    			连接使用完毕后，放入池中，等待其他操作复用。        
   

   3)性能配置：预缓存设置、连接有效性检测设置、连接超时关闭设置
   预缓存设置：用于控制PreparedStatement数量，提升数据库性能。

    	   　							DBCP						c3p0					Druid					性能配置
    		开启缓存功能				poolPreparedStatements		maxStatements			poolPreparedStatements
    		单个连接拥有的最大缓存数	maxOpenPreparedStatements	maxStatementsPerConnection	maxOpenPreparedStatemen
   
    		连接有效性检测设置：连接池内部有机制判断，如果当前的总连接数少于minildle，则会建立新的空闲连接，以保证
    		连接数达到minildle。如果当前连接池中某个连接处于空闲，则被物理性的关闭掉。有些数据库连接的时候有超时的
    		限制（mysql连接8小时后断开），或者由于网络中断等原因，连接池的连接会出现失效,这时候,设置一个testWhileldle
    		参数为true，可以保证连接池中，定时检测连接可用性，不可用的连接会被抛出或者重建，保证池中connection可用。
    		　				DBCP							c3p0						Druid
    		申请连接检测	testOnBorrow					testConnectionOnCheckin		testOnBorrow
    		是否超时检测	testWhileldle					testWhileldle               无
    		空闲时间		timeBetweenEvictionRunsMillis	idleConnectionTestPeriod	timeBetweenEvictionRunsMillis
    		校验sql语句		validationQuery					preferredTestQuery			validationQuery
    		归还连接检测	testOnReturn					testConnectionOnCheckout	testOnReturn
    	
    		超时连接关闭设置：用来检测当前使用的连接是否发生泄漏，所以在代码内部就假定如果一个连接建立连接
    		时间很长，则认定为泄漏，继而强制关闭。
    		　					DBCP					c3p0						Druid
    		是否超时关闭连接	removeAbandoned			breakAfterAcquireFailure	removeAbandoned
    		超时时间			removeAbandonedTimeout	checkoutTimeout				removeAbandonedTimeout
    		是否记录日志		logAbandoned	　		logAbandoned                无 
   

8.2 c3p0
8.2.1 环境准备
缓冲池：数据库驱动包+缓冲池包

<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
	<groupId>com.mchange</groupId>
	<artifactId>c3p0</artifactId>
	<version>0.9.5.5</version>
</dependency>

8.2.2 配置与使用
1）编写配置文件
2）获取缓冲池对应的DataSource（数据库缓冲池对象）

	datasource=new  ComboPooledDataSource();

3）从Datasource中获取Connection（缓冲池连接）

	Connection conn=datasource.getConnection();

4）crud
5）关闭
8.3 dbcp
8.3.1 环境准备

<dependency>
<groupId>commons-dbcp</groupId>
<artifactId>commons-dbcp</artifactId>
<version>1.4</version>
</dependency>

8.3.2 配置与使用
1）编写配置文件
2）获取缓冲池对应的DataSource（数据库缓冲池对象）

	DataSource datasource；
	Properties pro=new Properties();
	pro.load(RrsourceDaoUtil.class.getResourceAsStream("dbcp.properties"));
	datasource=BasicDataSourceFactory.createDataSource(pro);

3）从Datasource中获取Connection（缓冲池连接）

	Connection conn=datasource.getConnection();

4）crud
5）关闭
8.4 druid
8.4.1 环境准备

<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid</artifactId>
	<version>1.1.18</version>
</dependency>

8.4.2 配置与使用
1）编写配置文件
2）获取缓冲池对应的DataSource（数据库缓冲池对象）

	DataSource datasource；
	Properties pro=new Properties();
	pro.load(RrsourceDaoUtil.class.getResourceAsStream("druid.properties"));
	datasource=DruidDataSourceFactory.createDataSource(pro);

3）从Datasource中获取Connection（缓冲池连接）

	Connection conn=datasource.getConnection();

4）crud
5）关闭

版本管理

1.概念：
版本管理：多人、长时间参与同一个项目，该项目一般放在远程服务器上，项目参与人通过服务器完成项目的使用。
其中常见功能：

1）能够上传文件（commit提交）
2）能够下载文件（check out导出或者update更新）
3）能够合并文件（merge 合并）难点
4）查看历史版本记录

svn server（服务器）：

	1.存储团队公共项目
	2.与客户端交互

svn client（客户端）：

	1.如果是发起人，可以新建项目并提交项目到服务器上
	2.如果是其他参与人，第一次需要从服务器上导出项目
	3.项目参与人还可以提交本地有服务器没有的文件，也可以更新服务器上有本地没有的文件。

常见的版本管理工具（服务器和客户端）：

	1）cvs（老版本）
	2）svn：一般的版本管理
	3）git：分布式管理
版本号：...

2.windows svn 客户端安装与使用
2.1 安装

2.2 使用
2.2.1 查看某一个远程svn 服务器中的项目
没有登录过的会提示用户名和密码

1）右键->TortioseSvn->repo brower (远程项目查看)
2）填写地址：svn://47.93.45.65/homework/文件名字 回车

2.2.2 第一次导出

1）check out 

2.2.3 更新本地有的

1）svn update

2.2.4 提交本地有的，服务器没有的

1）svn commit

2.2.5 清除登录信息

svn->settings(全局配置)->saved data（保存信息）->authentication data（认证信息）->clean

3.eclipse svn 客户端安装与使用
3.1 eclipse svn插件安装

1）获取安装包 eclipse的SVN插件site-1.8.22
2）解压后看到两个文件夹 plugins features
3）将解压后的两个目录中的文件 增加到eclipse的同名文件下
4）校验是否安装成功
	eclipse 中 window->preferences->team 下多了svn

3.2 eclipse svn 插件使用
1）第一次提交项目

	右键项目->team->share project（共享项目到远程）
	添加远程位置svn://ip/homework/文件名字
	提交后只提交了项目根文件夹

2）进入同步界面（能够查看本地可提交或可更新的文件）

	本地可提交文件：黑色加号

3）提交本地文件

	.文件不允许提交，文件是本地项目文件
	只提交src文件

4）第一次导出

	右键->import->svn->svn 检出->选远程地址->地址下的某一个项目->选择第二种 作为工作空间的项目检出（文件项目导出，服务器有什么导出什么）
	补充项目描述文件（.classpath与.settings）
		我们项目构成：jdk（j2se jdk+1.8）+maven
		1)右键项目 properties（项目属性）->project facets（项目组成） kdk1.8
			
		2)maven配置：右键项目->config->convert maven project
	注意：maven配置完成后，可能出现没有仓库，这时候需要将poml文件还原，然后重新加载（project-clean）

5）提交本地当日开发代码

	右键项目->team ->打开同步视角 ->选择要提交的文件->提交（黑色图标表示可以提交的代码或文件）

6）更新远程最近服务器其他人新增的代码

	右键项目->team->打开同步视角->选择要更新的文件->更新
	蓝色图标表示可以更新的代码或文件

7）合并冲突代码（提交当日代码）

	两个人都在提交同一个文件，第一个人提交没问题。
	第二个人提交理论上需要更新了第一个提交 才能提交即提交冲突
	第一种：在同步视角 双击红色冲突文件，手动对比修改（如果有需要，沟通一下其他开发人员），然后右键文件标记为冲突合并，然后再提交
	第二种：将本地代码恢复成上一个版本，然后更新，然后再添加自己的代码，然后再提交
项目编译问题查看与重新解决：
	1）问题查看：在problem选项卡 查看
		查看某一个文件上有红×
		项目上有红色感叹号！->表示本项目无法编译，解决如下：
			先把当前错误右键删除->然后重新手动编译项目（project clean）->检查是否华友这个错误
			如果这个错误消失了表示项目正常
			如果失败找具体原因
	2）项目重新编译：project->clean 分全部手动编译与单个手动编译

4. webstrom svn 客户端安装与使用
4.1 webstrom 安装与破解

安装包：WebStorm.rar

4.2 破解 webstorm64.exe.vmoptions 配置 (32位有需求也要更改)

1) 获取破解包 JetbrainsCrack-2.8-release-enc.jar，将破解包放在bin目录下
2) 更改
	1) 第一行增加内容(破解jar所在位置)  
	-javaagent:jar位置
	如：
	-javaagent:F:\kgc2000x\app\WebStorm 2017.1.3\bin\JetbrainsCrack-2.8-release-enc.jar
	2) 更改内存
	-Xms123m	//最小
	-Xmx750m	//最大

4.3 概念
webStrom 的 project 等同于 eclipse 的 workspace，下面可以存放多个文件或目录(等同于 eclipse 的 Project)

全局设置：file->settings(ctrl+alt+s)等同于 eclipse Windows-preferences
字体设置：settings->Editor->Fonts->Font->Size

4.4 webStrom 安装svn

先svn补充操作：SVN 安装包继续安装->command-line client-tools,安装后svn安装目录下多了个svn.exe
再设置：svn设置：settings->Version Control->Subversion->
Use command client->F:\d2005\app\TortoiseSVN\bin\svn.exe

4.5 webstorm svn操作

1）第一次提交 菜单 VCS->import into version control(引入版本管理)->share project
2）右键项目->subversion提交（commit）、更新（update）、合并（merge）
3）第一次下载 vcs->check out from version control（从版本控制中查找）->subversion

4.6 svn测试