javase_day9_mysql&jdbc

最新推荐文章于 2023-12-10 17:19:26 发布

guoyebing

最新推荐文章于 2023-12-10 17:19:26 发布

阅读量256

点赞数

分类专栏： java复习

本文链接：https://blog.csdn.net/lushizhuo9655/article/details/95256471

版权

java复习专栏收录该内容

23 篇文章 0 订阅

订阅专栏

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("数据库添加失败");
		}
	}
}

guoyebing

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
javase_day9_mysql&jdbc

Mysql笔记服务器操作：（必须保证MySQL为windows服务）开启服务器：net start mysql关闭服务器：net stop mysql客户端操作 cmd登录服务器： mysql -uroot -p123 [-hlocalhost]-h：后面跟随IP什么是sql：结构化查询语言SQL分类：DDL：数据定义语言(结构)DML：数据操作语言...
复制链接

扫一扫