Mysql笔记
服务器操作:(必须保证MySQL为windows服务)
开启服务器:net start mysql
关闭服务器:net stop mysql
客户端操作 cmd
登录服务器: mysql -uroot -p123 [-hlocalhost]
-h:后面跟随IP
什么是sql:结构化查询语言
SQL分类:
DDL:数据定义语言(结构) 操作数据库、表 关键字 create drop alter
DML:数据操作语言(数据) 增删改表中的数据 关键字 insert delete update
DCL:数据控制语言(grant) 授权 关键字 grant
DQL:数据查询语言 查询表中的数据 关键字 select where
连接数据库: mysql -uroot-p
显示所有数据库: show databases;
创建数据库: create database 数据库名
创建数据库并判断是否存在(不存在再创建): create database if not exists 数据库名
创建数据库并指定字符集: create database 数据库名 character set gbk;
练习:创建db4数据库,判断是否存在,并指定字符集为gbk: create database if not exists db4 character set gbk;
显示某个数据库的字符集 show create database 数据库名
修改数据库的字符集 alter database 数据库名 character set 字符集名称;
删除数据库: drop database 数据库名;
删除数据库是否存在(存在在删除): drop database if exists 数据库名;
使用数据库: use 数据库名;
查看当前正在操作的库 select database();
查看数据库下面所有的表: show tables;
删除表: drop table 表名;
删除表: drop table if exists 表名;
修改表名: rename table 旧表名 to 新表名;
修改表名: alter table 旧表名 rename to 新表名(oracle,mysql也可以)
查看当前表的字符集: show create table 表名
修改表的字符集: alter table 表名 character set 字符集
查看表结构: desc 表名;
date:日期类型,格式为:yyyy-MM-dd
time:时间类型,格式为:hh:mm:ss
创建表: create table [if not exists] 表名(
列名 列类型 [约束],
列名 列类型 [约束]);
create table users(
uid int primary key auto_increment,
uname varchar(20),
uaddress varchar(20)
)
单表约束:
primary key:主键约束 要求被修饰的字段:唯一和非空
unique:唯一约束 要求被修饰的字段:唯一
not null:非空约束 要求被修饰的字段:非空
要记得在外键列后面加一个,才可以
修改表时增加外键约束:alter table 从表 add [constraint] [外键名称] foreign key (从表外键字段名) references 主表(主表的主键)
例子:alter table 表名 add constraint fk_emp_deptno foreign key(deptno) references dept(deptno)
删除外键约束: alter table 表名 drop foreign key fk_emp_deptno /*外键名称*/
mysql命令敲错了 可以\c退出 设置字符集 set names gbk;
复制表: create table 表名 like 被复制的表名
表增加列:alter table 表名 add 列名 列类型 增加的列默认是在表的最后一列
如果想增加在自己想添加的列 用after 如:alter table 表名 add 列名 列类型 after 列名
如果新增的列放在最前面 用first 如:alter table 表名 add 列名 列类型 first
表修改列:
查看指定表的创建语句:show create table 表名
修改列类型(长度、约束):alter table 表名 modify 列名 列类型
修改列名:alter table 表名 change 原列名 新列名 列类型
删除列:alter table 表名 drop 列名
在数据库中所有的字符串类型,必须使用单引,不能使用双引 日期类型也要使用单引
表中的数据默认值修改 ALTER TABLE 表名 ALTER 列名 SET DEFAULT '50'
添加表数据:(主键自增)
insert into表名(id,title,name) values(null,‘题目’,‘张三’);
insert into表名(title,name) values(题目’,‘张三’);(
insert into表名 values(null,‘题目’,‘张三’);
批量添加数据 insert into表名 values (1,‘题目’,‘张三’), (2,‘题目’,’李四’)
修改表数据: update 表名 set id=2 where title=‘题目’;
修改表数据多个字段: update 表名 set id=2,列名=1 where title=‘题目’;
删除表数据: delete from 表名 where;
查看表数据 select * from 表名;
mysql数据库事务
开启事务 :start transaction
回滚:rollback
提交:commit
面试题:
删除表中所有记录使用delete from 表名; 还是用truncate table 表名;
删除方式:delete 一条一条删除,不清空auto_increment记录数。配合事务可以将数据找回
truncate 直接将表删除,重新建表,auto_increment将置为零,从新开始。数据无法找回
去重
select distinct * from 表名
select distinct sal from 表名
数据库的与或非 and or not
Select查询:where group(用于统计场合)having order by limit 顺序
where:
in(在某集合内) between()
in (值1,值2…值N)中的任意一个都行
between 值1 and 值2 中之间
不等于 != 或者<>
模糊查询:like % 通配任意字符 _ 单个字符
查询列名非空例子: select * from 表名 where 列名 is not null
group(用于统计场合)
聚合函数:将一列数据作为一个整体,进行纵向的计算
max min sum avg count (聚合函数)
注意:聚合函数的计算,排除null值
解决方案:
1.选择不包含非空的列计算 2.ifull函数 select count(ifnull(english,0)) from student
起别名:as
where:where在分组前对数据进行过滤 having:having在分组后对数据进行过滤
order by:
desc 降序 asc 升序 默认就是升序
order by 列1[desc/asc],列2[desc/asc];第一个比较不出来就比第二个
limit 在语句的最后,起到限制条目的作用
公式: 开始的索引=(当前页-1)*每页显示的条数
数据库中 如果有null参与运算,计算结果都是null 我们可以这样避免 ifull(math,0) 当math为null的时候,我们就给它变成0
多表关联
create table student(
sid int primary key auto_increment,
sname varchar(50)
);
create table teacher(
tid int primary key auto_increment,
tname varchar(50)
);
create table stu_tea(
sid int,
tid int,
constraint fk_student foreign key(sid) references student(sid );
constraint fk_teacher foreign key(tid) references teacher(tid );
表与表之间的关系:
一对一: 都可以 按照实际情况
一对多:外键放在多方
多对多:外键放在关联表中
利用MySQL的函数:对密码‘123456’进行MD5加密 select md5(‘123456’);
子查询:
where子查询 from型子查询 exists子查询
where型子查询:把内层查询的结果作为外层查询的比较条件
from型子查询: 把内层查询的结果当成临时表,供外层sql再次查询(+as 临时表名)
exists查询:把外层查询结果拿到内层,看内层的查询是否成立。(在如下情况下使用:查询有商品的栏目)
union:联合
作用:把2次或者多次查询结果合并起来
要求:两次查询的列数一致
可以来自多张表,以第1个sql的列名为主
如果不同的语句中取出的行,有完全相同(每个列的值都相同),那么相同的行将会合并(去重复) 如果不去重复,可以加all来指定(union all)
如果子句中有order by limit,那么子句要用()包起来,子句中只有order by ,没有limit,则不起作用
连接:左连接 又连接 内连接 交叉连接(笛卡尔积-得到的是两个表的乘机,一般不用)
select * from 表1,表2 会出现笛卡儿积
左连接:A left join B on 条件
右连接:A right join B on 条件
内连接查询:
隐式内连接:select * from A,B where 条件;
select * from category c,product p where c.cid=p.category_id; (注意隐式连接要写个别名)
显示内连接 :select * from A inner join B on 条件
select * from category inner join product on cid=category_id;
内连接和外链接的区别:
内连接:查询两个表的交集。
左外连接:查询左表全部及两个表的交集
右外连接:查询右表全部及两个表的交集
备份与恢复
备份(mysqldump)mysqldump可以导出库表
导出一个库下面的表
mysqldump -u用户名 -p密码 库名 表1 表2>地址/备份文件名称 如:
导出一个库下面的所有表
mysqldump -u用户名 -p密码 库名 >地址/备份文件名称 如:
mysqldump -uroot -p密码 数据库>/root/hsyj.sql
导出以库为单位的
mysqldump -u用户名 -p密码 -B 库名 >地址/备份文件名称 如(这是两个库)
导出所有库
mysqldump -u用户名 -p密码 -A >地址/备份文件名称
恢复:
- 登陆到mysql命令行
对于库级的备份文件 source 备份文件地址
对于表级的备份文件 use 库名; source 备份文件地址
- 不登录到mysql命令行
对于库级的备份文件 mysql -u用户名 -p密码 <库级备份文件地址
对于表级的备份文件 mysql -u用户名 -p密码 库名 <表级备份文件地址
DCL管理用户
1.添加用户 CREATE USER '用户名'@'主机名' IDENTIFIED by '密码';
如:CREATE USER 'zhangsan'@'localhost' IDENTIFIED by '密码'; 表示只能在本地使用用户zhangsan登录数据库
CREATE USER 'lisi'@'%' IDENTIFIED by '密码'; 表示任意主机可以使用用户lisi登录数据库
2.删除用户 DROP USER '用户名'@'主机名'
3.修改用户密码
UPDATE USER SET PASSWORD=PASSWORD('新密码') WHERE USER='用户名';
SET PASSWORD FOR '用户名'@'主机名'=PASSWORD('新密码');
在mysql中忘记了root用户的密码
(同时开了两个cmd窗口)
4.查询用户
1)切换到mysql数据库 use mysql;
2)查询user表 select * from user;
通配符:%表示可以在任意主机使用用户登录数据库
权限管理
1.查询权限 SHOW GRANTS FOR '用户名'@'主机名'
2.授予权限 GRANT 权限列表 ON 数据库名.表名 TO '用户名'@'主机名'
3.撤销权限
JDBC的本质:
1.java语言连接数据库
2.官方定义的一个接口,各个数据库厂商去实现这套接口
JDBC开发步骤:
注册驱动 建立连接 创建sql语句 执行sql命令,并返回结果集 处理结果集 释放资源
db.properties文件建议放在src下面
注册驱动:
1.DriverManager.registerDriver(new Driver()) 内存中会有两个Driver对象 不建议使用
2. 推荐方式:Class.forName(“com.mysql.jdbc.Driver”);
建立连接:DriverManager.getConnection(url, user, password)
url:jdbc:mysql: //localhost:3306/数据库名
创建sql对象
createStatement():创建向数据库发送sql的statement对象。
prepareStatement(sql) :创建向数据库发送预编译sql的 返回的是PreparedStatement
execute(String sql):用于向数据库发送任意sql语句
executeQuery(String sql) :只能向数据发送select语句。
executeUpdate(String sql):只能向数据库发送insert、update或delete语句 返回值是int
executeQuery():查询的是预编译语句
executeUpdate():更新的是预编译语句
若有站位符? 记得如:pst.setString(1,name);
executeQuery要记得getString(“”)
释放资源
Connection的使用原则是尽量晚创建,尽量早的释放。
资源释放代码也一定要放在finally语句中。
Statement和PrepareStatement有什么区别?那个性能更好?
与Statement相比,
1 PrepareStatement接口代表预编译的语句,减少sql的编译错误并增加sql的安全性。
2 PrepareStatement中sql语句可以带参数的,避免了用字符串连接拼接sql语句的麻烦和不安全
3 批量处理sql或者频繁执行相同的查询时PrepareStatement有明显的优势。
读取src文件下的*.properties时,使用类加载器
InputStream in=类.class.getClassLoader().getResourceAsStream(“文件名”);
读取配置文件如:db.properties
ResourceBundle bundle=ResourcBundle.getBundle(“db”)
driver=bundle.getString(“driver”);
url=bundle.getString(“url”);
user=bundle.getString(“user”);
password=bundle.getString(“password”);
JDBC的批处理:两种方式
第一种:statement.addBatch(sql)
执行批处理SQL语句:
executeBatch()方法:执行批处理命令
clearBatch()方法:清除批处理命令
第二种:PreparedStatement.addBatch() 通常用于:同一个表中批量插入数据,或批量更新表的数据。
JDBC控制事务语句
Connection.setAutoCommit(false); Connection.rollback(); Connection.commit();
什么是事务:一个事情有n个组成单元,要不这n个组成单元同时成功,要不同时失败
事务:(ACID特性)
原子性(atomicity):数据库事务的不可再分的原则即为原子性,要么全部执行,要么全部取消
一致性(consistency):指数据的规则,在事务前/后应保持一致(比如张三给李四转钱 每个都是20 不管怎么变 总金额都是40)
隔离性(isolation):某个事务的操作对其他事务不可见的
持久性(durability):当事务完成后,其影响应该保留下来,不能撤销
开启事务:start transaction;
commit提交/rollback回滚 当一个事务commit 或者rollback后就结束了
并发访问问题---由隔离性引起
脏读:一个事务读取了另外一个事务未提交的数据
不可重复读:在一个事物内读取表中的某一行数据,多次读取结果不同。
虚读/幻读:在一个事务内读取到了别的事务插入的数据
事务的四种隔离级别:
set session transaction isolation level 设置事务隔离级别
select @@tx_isolation 查询当前事务隔离级别(有个-)
查询事务默认的提交方式
select @@autocommit 1 代表自动提交 0表示手动提交
set @@autocommit =0 设置为手动提交
DBUtils控制事务语句
QueryRunner runner=new QueryRunner()
Connection conn=….
设置事务回滚点
Savepoint sp = Connection.setSavepoint();
Connection.rollback(sp);
Connection.commit(); //回滚后必须要提交
DBUtils框架:对JDBC的简单封装
QueryRunner(类)对sql实现crud操作 ResultSetHandler(接口) 封装结果集
DBUtils类 关闭资源与事务处理
QueryRunner类提供了两个构造方法: 空参构造 通过DataSource构造
空参的构造方法 update有Connection对象 另外要手动关闭
update()增删改
query()查询 可变参是由于sql语句中有?占位符
使用QueryRunner类,实现对数据表的 insert delete update
调用QueryRunner类的方法update(Connection conn , String sql ,Object… param)
返回的是 int 调用QueryRunner类的方法
query(Connection conn , String sql ,ResultSetHandle<T> r Object… param)
DBUtils.closeQuietly(conn) 不需要处理异常 关闭连接
JavaBean:javaBean就是一个类,在开发中常用封装数据
1.需要实现接口Serializable
2.提供私有字段
3.提供setter和getter方法
4.提供无参构造
ResultSetHandle的实现类在下面
连接池:DBCP和C3P0
DBCP和C3P0
DBCP 数据库连接池(tomcat) C3P0 数据库连接池(hibernate)
DBCP和C3P0,都是Java开源的,且都必须直接或间接实现javax.sql.DataSource接口
c3p0代码:必须要有配置文件
c3p0-confing.xml文件放在src目录下(自动加载配置文件)
主要代码:
DBCP代码
通过配置文件的方式来实现dbcp的操作
DataSource dataSource = BasicDataSourceFactory.createDataSource(props);
使用druid数据库连接池
写druid工具类
/**
* Druid连接池的工具类
*/
public class JDBCUtils {
//1.定义成员变量 DataSource
private static DataSource ds ;
static{
try {
//1.加载配置文件
Properties pro = new Properties();
pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
//2.获取DataSource
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取连接
*/
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
/**
* 释放资源
*/
public static void close(Statement stmt, Connection conn){
/* if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();//归还连接
} catch (SQLException e) {
e.printStackTrace();
}
}*/
close(null,stmt,conn);
}
public static void close(ResultSet rs , Statement stmt, Connection conn){
if(rs != null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn != null){
try {
conn.close();//归还连接
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 获取连接池方法
*/
public static DataSource getDataSource(){
return ds;
}
}
Spring JDBC
* Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
* 步骤:
1. 导入jar包
2. 创建JdbcTemplate对象。依赖于数据源DataSource
* JdbcTemplate template = new JdbcTemplate(ds);
3. 调用JdbcTemplate的方法来完成CRUD的操作
* update():执行DML语句。增、删、改语句
* queryForMap():查询结果将结果集封装为map集合,将列名作为key,将值作为value 将这条记录封装为一个map集合
* 注意:这个方法查询的结果集长度只能是1
* queryForList():查询结果将结果集封装为list集合
* 注意:将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
* query():查询结果,将结果封装为JavaBean对象
* query的参数:RowMapper
* 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
* new BeanPropertyRowMapper<类型>(类型.class)
* queryForObject:查询结果,将结果封装为对象
* 一般用于聚合函数的查询
* 需求:
1. 修改1001号数据的 salary 为 10000
2. 添加一条记录
3. 删除刚才添加的记录
4. 查询id为1001的记录,将其封装为Map集合
5. 查询所有记录,将其封装为List
6. 查询所有记录,将其封装为Emp对象的List集合
7. 查询总记录数
DROP TABLE IF EXISTS `emp`;
CREATE TABLE `emp` (
`id` int(11) NOT NULL,
`ename` varchar(50) DEFAULT NULL,
`job_id` int(11) DEFAULT NULL,
`mgr` int(11) DEFAULT NULL,
`joindate` date DEFAULT NULL,
`salary` decimal(7,2) DEFAULT NULL,
`bonus` decimal(7,2) DEFAULT NULL,
`dept_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `emp_jobid_ref_job_id_fk` (`job_id`),
KEY `emp_deptid_ref_dept_id_fk` (`dept_id`),
CONSTRAINT `emp_deptid_ref_dept_id_fk` FOREIGN KEY (`dept_id`) REFERENCES `dept` (`id`),
CONSTRAINT `emp_jobid_ref_job_id_fk` FOREIGN KEY (`job_id`) REFERENCES `job` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
INSERT INTO `emp` VALUES ('1001', '孙悟空', '4', '1004', '2000-12-17', '8000.00', null, '20');
INSERT INTO `emp` VALUES ('1002', '卢俊义', '3', '1006', '2001-02-20', '16000.00', '3000.00', '30');
INSERT INTO `emp` VALUES ('1003', '林冲', '3', '1006', '2001-02-22', '12500.00', '5000.00', '30');
INSERT INTO `emp` VALUES ('1004', '唐僧', '2', '1009', '2001-04-02', '29750.00', null, '20');
INSERT INTO `emp` VALUES ('1005', '李逵', '4', '1006', '2001-09-28', '12500.00', '14000.00', '30');
INSERT INTO `emp` VALUES ('1006', '宋江', '2', '1009', '2001-05-01', '28500.00', null, '30');
INSERT INTO `emp` VALUES ('1007', '刘备', '2', '1009', '2001-09-01', '24500.00', null, '10');
INSERT INTO `emp` VALUES ('1008', '猪八戒', '4', '1004', '2007-04-19', '30000.00', null, '20');
INSERT INTO `emp` VALUES ('1009', '罗贯中', '1', null, '2001-11-17', '50000.00', null, '10');
INSERT INTO `emp` VALUES ('1010', '吴用', '3', '1006', '2001-09-08', '15000.00', '0.00', '30');
INSERT INTO `emp` VALUES ('1011', '沙僧', '4', '1004', '2007-05-23', '11000.00', null, '20');
INSERT INTO `emp` VALUES ('1012', '李逵', '4', '1006', '2001-12-03', '9500.00', null, '30');
INSERT INTO `emp` VALUES ('1013', '小白龙', '4', '1004', '2001-12-03', '30000.00', null, '20');
INSERT INTO `emp` VALUES ('1014', '关羽', '4', '1007', '2002-01-23', '13000.00', null, '10');
public class Emp {
private Integer id;
private String ename;
private Integer job_id;
private Integer mgr;
private Date joindate;
private Double salary;
private Double bonus;
private Integer dept_id;
}
public class JdbcTemplateDemo {
//1. 获取JDBCTemplate对象
private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
/**
* 1. 修改1001号数据的 salary 为 10000
*/
@Test
public void test1(){
//2. 定义sql
String sql = "update emp set salary = 10000 where id = 1001";
//3. 执行sql
int count = template.update(sql);
System.out.println(count);
}
/**
* 2. 添加一条记录
*/
@Test
public void test2(){
String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
int count = template.update(sql, 1015, "郭靖", 10);
System.out.println(count);
}
/**
* 3.删除刚才添加的记录
*/
@Test
public void test3(){
String sql = "delete from emp where id = ?";
int count = template.update(sql, 1015);
System.out.println(count);
}
/**
* 4.查询id为1001的记录,将其封装为Map集合
* 注意:这个方法查询的结果集长度只能是1
*/
@Test
public void test4(){
String sql = "select * from emp where id = ? or id = ?";
Map<String, Object> map = template.queryForMap(sql, 1001,1002);
System.out.println(map);
//{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
}
/**
* 5. 查询所有记录,将其封装为List
*/
@Test
public void test5(){
String sql = "select * from emp";
List<Map<String, Object>> list = template.queryForList(sql);
for (Map<String, Object> stringObjectMap : list) {
System.out.println(stringObjectMap);
}
}
/**
* 6. 查询所有记录,将其封装为Emp对象的List集合
*/
@Test
public void test6(){
String sql = "select * from emp";
List<Emp> list = template.query(sql, new RowMapper<Emp>() {
@Override
public Emp mapRow(ResultSet rs, int i) throws SQLException {
Emp emp = new Emp();
int id = rs.getInt("id");
String ename = rs.getString("ename");
int job_id = rs.getInt("job_id");
int mgr = rs.getInt("mgr");
Date joindate = rs.getDate("joindate");
double salary = rs.getDouble("salary");
double bonus = rs.getDouble("bonus");
int dept_id = rs.getInt("dept_id");
emp.setId(id);
emp.setEname(ename);
emp.setJob_id(job_id);
emp.setMgr(mgr);
emp.setJoindate(joindate);
emp.setSalary(salary);
emp.setBonus(bonus);
emp.setDept_id(dept_id);
return emp;
}
});
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 6. 查询所有记录,将其封装为Emp对象的List集合
*/
@Test
public void test6_2(){
String sql = "select * from emp";
List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
for (Emp emp : list) {
System.out.println(emp);
}
}
/**
* 7. 查询总记录数
*/
@Test
public void test7(){
String sql = "select count(id) from emp";
Long total = template.queryForObject(sql, Long.class);
System.out.println(total);
}
}
问题:
1.简单的jdbc连接数据库的insert
2.简单的jdbc连接数据库的查询
3.实现用户登录,用户名和密码来检查数据库 演示被别人SQL注入 模拟SQL注入 输入 任意用户名和密码'or' 1=1 会得到所有的密码
4.实现用户登录,用户名和密码来检查数据库 防止sql注入
5.使用PrepareStatement接口,实现数据表的更新操作
6.使用PrepareStatement接口,实现数据表的查询操作
7.创建JdbcUtils工具类 并且测试是否好使
8.JDBC读取数据表answer7,每行数据封装到answer7类对象中 很多个answer类对象,存储到list集合中
9.读取src下面的db.properties文件
10.读取src下面的db.properties文件来实现JdbcUtilsConfig的工具类 并且测试是否获得连接
11.使用QueryRunner类,实现对数据表的insert delete update
调用QueryRunner类的方法 update (Connection con,String sql,Object...param)
Object...param 可变参数,Object类型,SQL语句会出现?占位符
12.QueryRunner数据查询操作:
调用QueryRunner类方法query(Connection con,String sql,ResultSetHandler r, Object..params)
ResultSetHandler r 结果集的处理方式,传递ResultSetHandler接口实现类
Object..params SQL语句中的?占位符
13.通过dbcp来实现数据库的连接
14.创建DBCP连接池工具类,并且测试是否好使 定义2个方法,实现数据表的添加,数据表查询
public class Answer1 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
Statement stat=conn.createStatement();
int i=stat.executeUpdate("insert into answer7(sname,sprice,sdesc) values('家电1',2000.0,'优惠的促销1')");
System.out.println(i);
}
}
public class Answer2 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
Statement stat=conn.createStatement();
String sql="select * from answer7";
ResultSet rs=stat.executeQuery(sql);
while(rs.next()){
// System.out.println(rs.getInt(1)+" "+rs.getString(2)+" "+rs.getDouble(3)+" "+rs.getString(4));
// System.out.println(rs.getObject(1)+" "+rs.getObject(2)+" "+rs.getObject(3)+" "+rs.getObject(4));
System.out.println(rs.getInt("sid")+" "+rs.getString("sname")+" "+rs.getDouble("sprice")+" "+rs.getString("sdesc"));
}
rs.close();
stat.close();
conn.close();
}
}
public class Answer3 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
Statement stat=conn.createStatement();
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名");
String u=sc.nextLine();
System.out.println("请输入密码");
String p=sc.nextLine();
// String sql="select * from user where username='用户名'and PASSWORD='密码' or 1=1";
String sql="select * from user where username='"+u+ "'and PASSWORD='"+p+"'";
ResultSet rs=stat.executeQuery(sql);
while(rs.next()){
System.out.println(rs.getString("username")+" "+rs.getString("PASSWORD"));
}
rs.close();
stat.close();
conn.close();
}
}
/*
控制台输入
请输入用户名
a
请输入密码
a 'or' 1=1
会显示所有的用户名和密码
a 1
b 1
*/
public class Answer4 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
Scanner sc=new Scanner(System.in);
System.out.println("请输入用户名");
String u=sc.nextLine();
System.out.println("请输入密码");
String p=sc.nextLine();
String sql="select * from user where username=? and PASSWORD=?";
PreparedStatement pst=conn.prepareStatement(sql);
pst.setString(1, u);
pst.setString(2,p);
ResultSet rs=pst.executeQuery();
while(rs.next()){
System.out.println(rs.getString("username")+" "+rs.getString("PASSWORD"));
}
rs.close();
pst.close();
conn.close();
}
}
public class Answer5 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
String sql="update answer7 set sname=?,sprice=?,sdesc=? where sid=? ";
PreparedStatement pst=conn.prepareStatement(sql);
pst.setString(1, "郭叶兵");
pst.setDouble(2,200.0);
pst.setString(3,"郭叶兵");
pst.setInt(4, 1);
int i=pst.executeUpdate();
System.out.println(i);
pst.close();
conn.close();
}
}
public class Answer6 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
Connection conn=DriverManager.getConnection(url,user,password);
String sql="select * from answer7 ";
PreparedStatement pst=conn.prepareStatement(sql);
ResultSet rs=pst.executeQuery();
while(rs.next()){
System.out.println(rs.getInt("sid")+" "+rs.getString("sname")+" "+rs.getDouble("sprice")+" "+rs.getString("sdesc"));
}
rs.close();
pst.close();
conn.close();
}
}
public class JdbcUtils {
private JdbcUtils(){}
private static Connection conn;
static{
try {
Class.forName("com.mysql.jdbc.Driver");
String url="jdbc:mysql://localhost:3306/javase_day2";
String user="root";
String password="root";
conn=DriverManager.getConnection(url,user,password);
} catch (Exception e) {
throw new RuntimeException(e+"数据库连接失败");
}
}
public static Connection getConnection(){
return conn;
}
public static void close(Connection conn,Statement stat,ResultSet rs){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection conn,Statement stat){
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public class Answer7 {
public static void main(String[] args) throws ClassNotFoundException, SQLException {
Connection conn=JdbcUtils.getConnection();
String sql="select sname from answer7 ";
PreparedStatement pst=conn.prepareStatement(sql);
ResultSet rs=pst.executeQuery();
while(rs.next()){
System.out.println(rs.getString("sname"));
}
rs.close();
pst.close();
conn.close();
}
}
public class Domain {
private int sid;
private String sname;
private Double sprice;
private String sdesc;
public Domain() {
}
public Domain(int sid, String sname, Double sprice, String sdesc) {
super();
this.sid = sid;
this.sname = sname;
this.sprice = sprice;
this.sdesc = sdesc;
}
public int getSid() {
return sid;
}
public void setSid(int sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Double getSprice() {
return sprice;
}
public void setSprice(Double sprice) {
this.sprice = sprice;
}
public String getSdesc() {
return sdesc;
}
public void setSdesc(String sdesc) {
this.sdesc = sdesc;
}
public String toString() {
return sid + "....." + sname + "......" + sprice + "......" + sdesc;
}
}
public class Answer8 {
public static void main(String[] args) throws SQLException {
Connection conn=JdbcUtils.getConnection();
String sql="select * from answer7";
PreparedStatement pst=conn.prepareStatement(sql);
ResultSet rs=pst.executeQuery();
//创建集合对象
List<Domain> list=new ArrayList<>();
while(rs.next()){
//获取每个列数据,封装到Domain对象中
Domain domain=new Domain(rs.getInt("sid"),rs.getString("sname"),rs.getDouble("sprice"),rs.getString("sdesc"));
//封装的Domain对象,存储到集合中
list.add(domain);
}
JdbcUtils.close(conn, pst, rs);
//遍历List集合
for(Domain d:list){
System.out.println(d);
}
}
}
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/javase_day2
user=root
password=root
public class Answer9 {
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException {
InputStream is=Answer9.class.getClassLoader().getResourceAsStream("db.properties");
Properties pro=new Properties();
pro.load(is);
//获取集合中的键值对
String driver=pro.getProperty("driver");
String url=pro.getProperty("url");
String user=pro.getProperty("user");
String password=pro.getProperty("password");
Class.forName(driver);
Connection conn=DriverManager.getConnection(url, user, password);
System.out.println(conn);
}
}
db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/javase_day2
user=root
password=root
//方式一
public class JdbcUtilsConfig {
private static String driver;
private static String url;
private static String user;
private static String password;
private static Connection conn;
//加载配置文件
private static void readConfig() throws IOException{
InputStream in=JdbcUtilsConfig.class.getClassLoader().getResourceAsStream("db.properties");
Properties pro=new Properties();
pro.load(in);
driver=pro.getProperty("driver");
url=pro.getProperty("url");
user=pro.getProperty("user");
password=pro.getProperty("password");
}
static{
try{
readConfig();
Class.forName(driver);
conn=DriverManager.getConnection(url,user,password);
}catch(Exception ex){
throw new RuntimeException("数据库连接失败");
}
}
public static Connection getConnection(){
return conn;
}
public static void close(Connection conn,Statement stat,ResultSet rs){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection conn,Statement stat){
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
//方式二
public class JdbcUtilsConfig2 {
private static String driver;
private static String url;
private static String user;
private static String password;
private static Connection conn;
/**
* 静态代码块加载配置文件信息
*/
static{
ResourceBundle bundle = ResourceBundle.getBundle("db");
driver = bundle.getString("driver");
url = bundle.getString("url");
user = bundle.getString("user");
password = bundle.getString("password");
}
static{
try{
Class.forName(driver);
conn=DriverManager.getConnection(url,user,password);
}catch(Exception ex){
throw new RuntimeException("数据库连接失败");
}
}
public static Connection getConnection(){
return conn;
}
public static void close(Connection conn,Statement stat,ResultSet rs){
if(rs!=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
public static void close(Connection conn,Statement stat){
if(stat!=null){
try {
stat.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if(conn!=null){
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
public class Answer10 {
public static void main(String[] args) {
Connection conn=JdbcUtilsConfig.getConnection();
System.out.println(conn);
}
}
public class Answer11 {
private static Connection conn=JdbcUtilsConfig.getConnection();
public static void main(String[] args) throws SQLException{
// insert();
// update();
delete();
}
//增加
public static void insert() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="insert into answer7(sname,sprice,sdesc) values(?,?,?)";
Object[] params={"水果",200.0,"新鲜美味"};
int i=qr.update(conn, sql, params);
System.out.println(i);
DbUtils.closeQuietly(conn);
}
//修改
public static void update()throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="update answer7 set sname=?,sprice=?,sdesc=? where sid=?";
Object[] params={"花店",100,"情人节特属",6};
int i=qr.update(conn, sql, params);
System.out.println(i);
DbUtils.closeQuietly(conn);
}
// 删除
public static void delete()throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="delete from answer7 where sid=?";
int i=qr.update(conn, sql, 6);
System.out.println(i);
DbUtils.closeQuietly(conn);
}
}
public class Answer12 {
private static Connection conn=JdbcUtilsConfig.getConnection();
public static void main(String[] args) throws SQLException{
// ArrayHandler();
// ArrayListHandler();
// BeanHandler();
// BeanListHandler();
// ColunmListHandler();
// ScalarHandler();
// MapHandler();
MapListHandler();
}
/*
* 结果集第八种处理方法,MapListHandler
* 将结果集每一行存储到Map集合,键:列名,值:数据
* Map集合过多,存储到List集合
*/
public static void MapListHandler()throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法query,传递结果集实现类MapListHandler
//返回值List集合, 存储的是Map集合
List<Map<String, Object>> list=qr.query(conn, sql, new MapListHandler());
for(Map<String, Object> map:list){
for(String key: map.keySet()){
System.out.print(key+"..."+map.get(key));
}
System.out.println();
}
}
/*
* 结果集第七种处理方法,MapHandler
* 将结果集第一行数据,封装到Map集合中
* Map<键,值> 键:列名 值:这列的数据
*/
public static void MapHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法query,传递结果集实现类MapHandler
//返回值: Map集合,Map接口实现类, 泛型
Map<String,Object> map=qr.query(conn, sql, new MapHandler());
//遍历Map集合
for(String key:map.keySet()){
System.out.println(key+"..."+map.get(key));
}
}
/*
* 结果集第六种处理方法,ScalarHandler
* 对于查询后,只有1个结果
*/
public static void ScalarHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select count(*) from answer7";
Long count=qr.query(conn, sql, new ScalarHandler<Long>());
System.out.println(count);
}
/*
* 结果集第五种处理方法,ColumnListHandler
* 结果集,指定列的数据,存储到List集合
* List<Object> 每个列数据类型不同
*/
public static void ColunmListHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法 query,传递结果集实现类ColumnListHandler
//实现类构造方法中,使用字符串的列名
List<Object> list=qr.query(conn, sql, new ColumnListHandler<Object>("sname"));
for(Object obj:list){
System.out.println(obj);
}
}
/*
* 结果集第四种处理方法, BeanListHandler
* 结果集每一行数据,封装JavaBean对象
* 多个JavaBean对象,存储到List集合
*/
public static void BeanListHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法query,传递结果集处理实现类BeanListHandler
List<Domain> list=qr.query(conn, sql, new BeanListHandler<Domain>(Domain.class));
for(Domain domain:list){
System.out.println(domain);
}
}
/*
* 结果集第三种处理方法,BeanHandler
* 将结果集的第一行数据,封装成JavaBean对象
* 注意: 被封装成数据到JavaBean对象, Domain类必须有空参数构造
*/
public static void BeanHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法,传递结果集实现类BeanHandler
Domain domain=qr.query(conn, sql, new BeanHandler<Domain>(Domain.class));
System.out.println(domain);
}
/*
* 结果集第二种处理方法,ArrayListHandler
* 将结果集的每一行,封装到对象数组中, 出现很多对象数组
* 对象数组存储到List集合
*/
public static void ArrayListHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用query方法,结果集处理的参数上,传递实现类ArrayListHandler
//方法返回值 每行是一个对象数组,存储到List
List<Object[]> result=qr.query(conn, sql,new ArrayListHandler());
//集合的遍历
for(Object[] objs:result){
//遍历对象数组
for(Object obj:objs){
System.out.print(obj);
}
System.out.println();
}
}
/*
* 结果集第一种处理方法, ArrayHandler
* 将结果集的第一行存储到对象数组中 Object[]
*/
public static void ArrayHandler() throws SQLException{
QueryRunner qr=new QueryRunner();
String sql="select * from answer7";
//调用方法query执行查询,传递连接对象,SQL语句,结果集处理方式的实现类
//返回对象数组
Object[] result=qr.query(conn, sql, new ArrayHandler());
for(Object obj:result){
System.out.println(obj);
}
}
}
public class Answer13 {
public static void main(String[] args) {
BasicDataSource datasource=new BasicDataSource();
// 连接数据库的4个最基本信息,通过对象方法setXXX设置进来
datasource.setDriverClassName("com.mysql.jdbc.Driver");
datasource.setUrl("jdbc:mysql://localhost:3306/javase_day2");
datasource.setUsername("root");
datasource.setPassword("root");
try {
// 通过getConnection获取数据库的连接
Connection conn=datasource.getConnection();
System.out.println(conn);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("数据库连接失败");
}
}
}
public class DbcpUtils {
//创建出BasicDataSource类对象
private static BasicDataSource datasource=new BasicDataSource();
//静态代码块,对象BasicDataSource对象中的配置,自定义
static{
//数据库连接信息,必须的
datasource.setDriverClassName("com.mysql.jdbc.Driver");
datasource.setUrl("jdbc:mysql://localhost:3306/javase_day2");
datasource.setUsername("root");
datasource.setPassword("root");
//对象连接池中的连接数量配置,可选的
datasource.setInitialSize(10); //初始化的连接数
datasource.setMaxActive(8); //最大连接数量
datasource.setMaxActive(5); //最大空闲数
datasource.setMinIdle(1); //最小空闲
}
//定义静态方法,返回BasicDataSource类的对象
public static DataSource getDataSource(){
return datasource;
}
}
public class Answer14 {
//QueryRunner类对象,写在类成员位置
private static QueryRunner qr=new QueryRunner(DbcpUtils.getDataSource());
public static void main(String[] args) {
// insert();
query();
}
public static void query(){
String sql="select * from answer7";
try {
List<Object[]> list=qr.query(sql, new ArrayListHandler());
for(Object[] objs:list){
for(Object obj:objs){
System.out.print(obj+"\t");
}
System.out.println();
}
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("数据查询失败");
}
}
public static void insert(){
String sql="insert into answer7(sname,sprice,sdesc) values(?,?,?)";
Object[] params={"水果",100.12,"刚刚上市的核桃"};
try {
int row=qr.update(sql, params);
System.out.println(row);
} catch (SQLException e) {
e.printStackTrace();
throw new RuntimeException("数据库添加失败");
}
}
}