澳门新萄京官方网站-www.8455.com-澳门新萄京赌场网址

Java面试题之JavaWeb基础,jdbc学习笔记02

2019-10-05 作者:数据库网络   |   浏览(127)

数据库连接池

DBCP DataBase Conection Pool:数据库连接池

举个例子未有数据库连接池,每三次工作都需求服务器和数据库服务器创设一回延续,业务管理完连接断开,固然有1万次专业管理,则需求建构1万次一连,而服务器和数据库服务器频仍按键连接特别占用财富。 使用数据库连接池,连接池开始化时能够钦点多少个早先连接,倘使有连接进来直接行使起来连接,那样并不是每便都创建连接,那样能够确定保障前两次不用构建新连接直接使用起来连接,当呼吁数量超越早先连接数量的时候,然后查看最利兹接数量,若无到最大额则在池中新建三个一连,如若到了最大数量况兼当前又从不空闲连接 那就不得不等待有个别连接空闲

今日内容介绍
1、JDBC
2、DBUtils

1.简介

JDBC(Java DataBase Connectivity) 是一种可用于施行SQL语句的Java API,是一套面向对象的应用程序接口,

合併了数据库的拜望格局,数据库商家提供了完结接口的类,称为‘驱动程序’。因此JDBC并不能够直接待上访问数据库,

急需依赖数据库商家提供的JDBC驱动程序。

--SQL语言:

数据定义语言(Data Definition Language,DDL)如:create,alter,drop等

多少操纵语言(Data Manipulation Language,DML)如update,delete等

数码查询语言(Data Query language,DQL),查询

数量调控语言(Data Control Language,DCL),如grant,revoke等

事务调节语言(Transaction Control Language,TCL),如commit,rollback等

Java JDBC 操作,javajdbc操作

先是个:Class.forName()。加载数据库的连年驱动

PrepareStatement

-好处: 1. 绝相比较Statment 代码结构整齐,可读性更加高。 2. 包罗预编写翻译效果,sql语句只编写翻译一回,然后只供给修改分裂的参数就能够,所以进行功用要超过Statment(效果不是太明显) 3. 带有预编写翻译效果,可防止止SQL注入,因为在预编写翻译的时候曾经把sql逻辑固定,借使替换占位符的从头到尾的经过富含了和逻辑相关的如:or 会不奏效

注册登入的sql:

create table user(id int primary key auto_increment,username varchar(20),password varchar(20));

insert into user values(null,'liudehua','admin'), (null,'zhangxueyou','admin'), (null,'liming','admin'), (null,'zhaosi','admin');

 

学科回想: 1. Properties 读取配置文件的靶子 2. 高等的封装 3. dbcp 连接池

  1. 最后版DBUtils 5. PrepareStatement 6. SQL注入 作业: 1.把 DBUtils末了版会背写 2.精晓PrepareStatement的利用

  2. 经过JDBC达成 创制学生表(id,name,age) 插入学生的点子 删除学生的点子 修改学生的点子 查询全数学生的主意

01JDBC概念和数据库驱动程序

* A: JDBC概念和数据库驱动程序
    * a: JDBC概述     
        * JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,
            可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。是Java访问数据库的标准规范
        * JDBC提供了一种基准,据此可以构建更高级的工具和接口,使数据库开发人员能够编写数据库应用程序。
        * JDBC需要连接驱动,驱动是两个设备要进行通信,满足一定通信数据格式,数据格式由设备提供商规定,
            设备提供商为设备提供驱动软件,通过软件可以与该设备进行通信。
        * 我们使用的是mysql的驱动mysql-connector-java-5.1.39-bin.jar
    * b: 总结
        * JDBC是java提供给开发人员的一套操作数据库的接口
        * 数据库驱动就是实现该接口的实现类

2.筹划干活,以Mysql为例

a.安装了Mysql 数据库

b.下载mysql驱动包并在类型中程导弹入jar包:mysql-connector-java-5.1.42-bin.jar 

1.简介

JDBC(Java DataBase Connectivity) 是一种可用来推行SQL语句的Java API,是一套面向对象的应用程序接口,

合并了数据库的探望方式,数据库商家提供了达成接口的类,称为‘驱动程序’。由此JDBC并不可能直接访谈数据库,

要求注重数据库商家提供的JDBC驱动程序。

--SQL语言:

Java面试题之JavaWeb基础,jdbc学习笔记02。数量定义语言(Data Definition Language,DDL)如:create,alter,drop等

数据操纵语言(Data Manipulation Language,DML)如update,delete等

多少查询语言(Data Query language,DQL),查询

数码调控语言(Data Control Language,DCL),如grant,revoke等

事情调节语言(Transaction Control Language,TCL),如commit,rollback等

其次步:DriverManager.getConnection()获取数据连接对象

Java面试题之JavaWeb基础,jdbc学习笔记02。02JDBC原理

* A: JDBC原理
    * a: 描述
        * Java提供访问数据库规范称为JDBC,而生产厂商提供规范的实现类称为驱动
        * DBC是接口,驱动是接口的实现,没有驱动将无法完成数据库连接,从而不能操作数据库!
            每个数据库厂商都需要提供自己的驱动,用来连接自己公司的数据库,也就是说驱动一般都由数据库生成厂商提供。
        * 图解见day29_source/JDBC实现原理.JPG

3.JDBC的操作

步骤:

1.注册驱动

2.两次三番数据库

3.开立语句对象,用于施行SQL

4.执行SQL

5.拍卖实行结果

6.停息连接

2.预备干活,以Mysql为例

a.安装了Mysql 数据库

b.下载mysql驱动包并在项目中程导弹入jar包:mysql-connector-java-5.1.42-bin.jar 

其三步:依据SQL获取sql会话对象。有二种办法,Statement,PreparedStatement;

03预备数据

* A: 准备数据
    * a: 创建数据库和表结构
        #创建数据库
        create database mybase;
        #使用数据库
        use mybase;
        ###创建分类表
        create table sort(
          sid int PRIMARY KEY AUTO_INCREMENT,
          sname varchar(100),
          sprice DOUBLE,
          sdesc VARCHAR(500)
        );

    * b: 向表中插入数据
        #初始化数据
        insert into sort(sname,sprice,sdesc) values('家电',2000, '优惠的促销');
        insert into sort(sname,sprice,sdesc) values('家具',8900, '家具价格上调,原材料涨价');
        insert into sort(sname,sprice,sdesc) values('儿童玩具',290, '赚家长的钱');
        insert into sort(sname,sprice,sdesc) values('生鲜',500.99, '生鲜商品');
        insert into sort(sname,sprice,sdesc) values('服装',24000, '换季销售');
        insert into sort(sname,sprice,sdesc) values('洗涤',50, '洗发水促销');          

一、JDBC基本操作

1)在数据库先创制一张表Student

CREATE TABLE student(
    id INT AUTO_INCREMENT,
    NAME VARCHAR(20),
    age INT ,
    PRIMARY KEY(id)
);

2)jdbc实现

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCDemo01 {
    public static void main(String[] args) {
        //声明连接
        Connection connection = null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //数据库连接信息
            //地址  jdbc:mysql://地址/数据库
            String url = "jdbc:mysql://localhost:3306/huan";
            String user = "root";
            String password = "root";
            //获得连接
            connection = DriverManager.getConnection(url, user, password);
            //语句对象
            Statement st = connection.createStatement();
            String sql = "insert into student (name,age) values ('zhangsan',30)";
            //执行sql  DDL-execute()方法  DML-executeUpdate()方法 DQL-executeQuery()方法
            int n = st.executeUpdate(sql);
            String querySql = "select id,name,age from student";
            ResultSet rs = st.executeQuery(querySql);
            //处理结果
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }
            //释放资源
            rs.close();
            st.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            //关闭连接
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}

地方先实行了一条插入语句,由于主键id是自增的,因而直插入了名字zhangsan和年龄30,然后查询了表的数码

出口如下:

id:1 name:zhangsan age:30

3.JDBC的操作

步骤:

1.注册驱动

2.三回九转数据库

3.创设语句对象,用于实施SQL

4.执行SQL

5.管理施行结果

6.休息连接

第四步:实行SQL管理集,实施SQL前要是有参数值就安装参数值setXXX();

04JDBC的支出步骤

* A: JDBC的开发步骤
    * a: 步骤介绍
        1.注册驱动
            告知JVM使用的是哪一个数据库的驱动
        2.获得连接
            使用JDBC中的类,完成对MySQL数据库的连接
        3.获得语句执行平台
            通过连接对象获取对SQL语句的执行者对象
        4.执行sql语句
            使用执行者对象,向数据库执行SQL语句
            获取到数据库的执行后的结果
        5.处理结果
        6.释放资源  一堆close()

二、JDBC连接的包裹

是因为一连数据库的进度都是一样,为了坚实代码的重用,能够将数据库的连年封装起来:

率先将数据库的一连音信放到配置文件中,比如在品种根目录下新建文件db.properties,如下:

#db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/huan
jdbc.user=root
jdbc.password=root

JDBCUtil类

package com.huan.jdbc;

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


public class JDBCUtil {

    private static String driverClass;
    private static String url;
    private static String user;
    private static String password;
    //静态块加载数据库配置属性
    static{
        Properties config = new Properties();
        try {
            config.load(new FileInputStream("db.properties"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        driverClass = config.getProperty("jdbc.driver");
        url = config.getProperty("jdbc.url");
        user = config.getProperty("jdbc.user");
        password =config.getProperty("jdbc.password");
    }


    //获取数据库连接
    public static Connection getConnection() throws SQLException {

        try {
            Class.forName(driverClass);
            Connection connection = DriverManager.getConnection(url, user, password);
            return connection;
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new SQLException("没有找到驱动",e);
        }

    }

    //关闭资源
    public static void close(Connection connection,Statement st,ResultSet rs){

        if(connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        if(st != null){
            try {
                st.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

测试JDBCUtil

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCUtilTest {
    public static void main(String[] args) {
        Connection connection = null;
        Statement st = null;
        ResultSet rs =null;
        try {
            connection = JDBCUtil.getConnection();
            String sql = "select id ,name ,age from student" ;
            st = connection.createStatement();
            rs = st.executeQuery(sql);
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            JDBCUtil.close(connection, st, rs);
        }



    }
}

输出:

id:1 name:zhangsan age:30

一、JDBC基本操作

1)在数据库先制造一张表Student

CREATE TABLE student(
    id INT AUTO_INCREMENT,
    NAME VARCHAR(20),
    age INT ,
    PRIMARY KEY(id)
);

2)jdbc实现

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCDemo01 {
    public static void main(String[] args) {
        //声明连接
        Connection connection = null;
        try {
            //加载驱动
            Class.forName("com.mysql.jdbc.Driver");
            //数据库连接信息
            //地址  jdbc:mysql://地址/数据库
            String url = "jdbc:mysql://localhost:3306/huan";
            String user = "root";
            String password = "root";
            //获得连接
            connection = DriverManager.getConnection(url, user, password);
            //语句对象
            Statement st = connection.createStatement();
            String sql = "insert into student (name,age) values ('zhangsan',30)";
            //执行sql  DDL-execute()方法  DML-executeUpdate()方法 DQL-executeQuery()方法
            int n = st.executeUpdate(sql);
            String querySql = "select id,name,age from student";
            ResultSet rs = st.executeQuery(querySql);
            //处理结果
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }
            //释放资源
            rs.close();
            st.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            //关闭连接
            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }
}

上边先进行了一条插入语句,由于主键id是自增的,由此直插入了名字zhangsan和年龄30,然后查询了表的数量

出口如下:

id:1 name:zhangsan age:30

第五步:关闭结果集,关闭对话,关闭连接。

05导入mysql数据库驱动程序jar包

* A: 导入mysql数据库驱动程序jar包
    * a: 步骤
        * 创建lib目录,用于存放当前项目需要的所有jar包
        * 选择jar包,右键执行build path / Add to Build Path

三 SQL预管理及业务

SQL预管理:在头里的拍卖中都以将sql语句发送到数据库,有数据库的sql解释器把sql语句生成底层的内部命令,然后施行命令,完结操作,当前连连的

                  向数据库发送sql语句,会增好多据库sq解释器的承担,影响实行进程。

                  而Connection的prepareStatement(Stirng sql)方法能够对sql语句实行预管理,生成数据底层的吩咐,并封装在PrepareStatement对

                  象中,通过相应的方法施行底层数据库的通令,进而缓慢消除数据库的担任,进步访问速度。

                  并且以前的sql都是东拼西凑的,当带参数拼接时轻巧导致SQL的注入(参数中蕴藏sql成分,改造原有的sql语句逻辑),而PrepareStatement在

                 编写翻译之后,当中的sql实施陈设现已明显,当替换参数时不会转移实行计划,由此能够制止sql注入。

作业调整:   当我们在编排逻辑的时候,存在多条的插入或许更新语句,后边的sql成功实行之后现身错误,那时导致业务逻辑中断,而实施成功的多寡现已

                 存入数据库,进而致使数据不完整。为幸免这种事情的发出就需求手动进行当务调节。

                1.安息自动提交--connection.setAutoCommit(false);

                2.工作进行到位后交付-connection.commit();

                3.在遇到特别时回滚-connection.rollback();

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

public class PrepareStatementDemo {
    public static void main(String[] args) {
        Connection connection = null;
        //SQL预处理对象
        PreparedStatement ps = null;
        ResultSet rs =null;

        try {
            connection = JDBCUtil.getConnection();
            connection.setAutoCommit(false);
            //?代表参数
            String sql = "insert into student (name,age) values(?,?)";
            //编译预执行计划 在数据库上创建执行计划  
            //(第二个参数可以不要-Statement.RETURN_GENERATED_KEYS 代表返回主键,没有的话下面的要去掉ps.getGeneratedKeys()会)
            ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            //?的位置 和 替换的值
            ps.setString(1, "lisi");
            ps.setInt(2, 20);
            //n 更新结果的数量
            int n = ps.executeUpdate();
            System.out.println("成功插入" n "条数据");
            //获取插入成功数据的主键
            ResultSet keySet = ps.getGeneratedKeys();
            int key = -1;
            while(keySet.next()){
                key = keySet.getInt(1);
            }
            System.out.println("插入数据的主键:" key);
            //查询
            String querySql = "select id , name ,age from student";
            ps = connection.prepareStatement(querySql);
            rs = ps.executeQuery();
            //获取结果集的元数据相关信息
            ResultSetMetaData metaData = rs.getMetaData();
            //列数
            int count = metaData.getColumnCount();
            for(int i = 1; i <= count; i  ){
                System.out.print(metaData.getColumnName(i) " ");
            }
            System.out.println();
            //查询结果打印
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println(id " " name " " age);
            }
            //提交
            connection.commit();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            if(connection != null){
                try {
                    //出现异常回滚
                    connection.rollback();
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        }finally {
            JDBCUtil.close(connection, ps, rs);
        }

    }
}

出口结果:

成功插入1条数据
插入数据的主键:2
id name age 
1 zhangsan 30
2 lisi 20

中标插入了 lisi 那条记下,且重返主键为2.最后打字与印刷了列名和查询得到的数码

那边用了作业的回滚,假诺保留完事后再查询的高级中学级出现格外,数据是不会存到数据库的,能够入手试下。

二、JDBC连接的包裹

是因为总是数据库的历程都以同样,为了加强代码的任用,能够将数据库的连接封装起来:

首先将数据库的连日新闻放到配置文件中,譬如在项目根目录下新建文件db.properties,如下:

#db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/huan
jdbc.user=root
jdbc.password=root

JDBCUtil类

package com.huan.jdbc;

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


public class JDBCUtil {

    private static String driverClass;
    private static String url;
    private static String user;
    private static String password;
    //静态块加载数据库配置属性
    static{
        Properties config = new Properties();
        try {
            config.load(new FileInputStream("db.properties"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        driverClass = config.getProperty("jdbc.driver");
        url = config.getProperty("jdbc.url");
        user = config.getProperty("jdbc.user");
        password =config.getProperty("jdbc.password");
    }


    //获取数据库连接
    public static Connection getConnection() throws SQLException {

        try {
            Class.forName(driverClass);
            Connection connection = DriverManager.getConnection(url, user, password);
            return connection;
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            throw new SQLException("没有找到驱动",e);
        }

    }

    //关闭资源
    public static void close(Connection connection,Statement st,ResultSet rs){

        if(connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        if(st != null){
            try {
                st.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

测试JDBCUtil

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class JDBCUtilTest {
    public static void main(String[] args) {
        Connection connection = null;
        Statement st = null;
        ResultSet rs =null;
        try {
            connection = JDBCUtil.getConnection();
            String sql = "select id ,name ,age from student" ;
            st = connection.createStatement();
            rs = st.executeQuery(sql);
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            JDBCUtil.close(connection, st, rs);
        }



    }
}

输出:

id:1 name:zhangsan age:30

1.PreparedStatement接口传承Statement、PreparedStatement实例满含已编写翻译的SQL语句,所以其实施进度

06登记数据库驱动程序

* A: 注册数据库驱动程序
    * a: 案例代码
        public class JDBCDemo {
            public static void main(String[] args)throws ClassNotFoundException,SQLException{
                //1.注册驱动 反射技术,将驱动类加入到内容
                // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                //DriverManager.registerDriver(new Driver());
                //驱动类源代码,注册2次驱动程序
                Class.forName("com.mysql.jdbc.Driver");                 
            }
        }

四、JDBC的批量操作

PrepareStatement和Statement都提供了足以批量操作SQL的法子

1.将sql增加至缓存区

Statement: addBatch(sql)方法,能够将sql直接增多Statement缓存区;

PrepareStatement:须要先推行setxxx(n,参数)方法将参数赋值,然后调用addBatch(sql)方法

2.试行executeBatch()将参数批量发送到数据库,并且实行

3.方可选用clearBatch()清空缓存区的参数大概sql

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;

import org.junit.Test;

public class JDBCBatchDemo {


    @Test
    public void testJdbcPrepareBatch(){

        Connection connection = null;
        PreparedStatement ps = null;

        try {
            connection = JDBCUtil.getConnection();
            String sql  = "insert into student (name,age) values (?,?)";
            ps = connection.prepareStatement(sql);
            ps.setString(1, "ps1");
            ps.setInt(2, 11);
            ps.addBatch();
            ps.setString(1, "ps2");
            ps.setInt(2, 12);
            ps.addBatch();
            int [] n = ps.executeBatch();
            System.out.println(Arrays.toString(n));    
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }




    }


    @Test
    public void testJdbcStatementBatch(){
        Connection connection = null;
        Statement st = null;
        try {
            connection = JDBCUtil.getConnection();
            String sql1 = "insert into student(name,age) values('statement1',20)";
            String sql2 = "insert into student(name,age) values('statement2',30)";
            String sql3 = "insert into student(name,age) values('statement3',40)";

            st = connection.createStatement();
            //批量添加
            st.addBatch(sql1);
            st.addBatch(sql2);
            st.addBatch(sql3);
            //执行
            int [] n = st.executeBatch();

            System.out.println(Arrays.toString(n));

        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            JDBCUtil.close(connection, st, null);
        }
    }


}

testJdbcStatementBatch()测量试验方法完结后翻看数据库,数据成功增多:

图片 1

testJdbcPrepareBatch()测量试验方法实施之后查看数据库,数据成功增添:

图片 2

三 SQL预管理及业务

SQL预处理:在事先的拍卖中都以将sql语句发送到数据库,有数据库的sql解释器把sql语句生成底层的里边命令,然后实施命令,实现操作,当前连发的

                  向数据库发送sql语句,会大增数据库sq解释器的担当,影响实行进程。

                  而Connection的prepareStatement(Stirng sql)方法能够对sql语句进行预管理,生成数据底层的命令,并封装在PrepareStatement对

                  象中,通过相应的办法试行底层数据库的下令,从而缓和数据库的担负,进步访谈速度。

                  而且此前的sql都以东拼西凑的,当带参数拼接时便于形成SQL的注入(参数中包罗sql成分,改动原来的sql语句逻辑),而PrepareStatement在

                 编写翻译之后,在这之中的sql实践布署已经鲜明,当替换参数时不会转移实施安顿,因而能够制止sql注入。

事情调节:   当大家在编排逻辑的时候,存在多条的插入或然更新语句,前边的sql成功施行之后出现谬误,那时导致事情逻辑中断,而进行成功的数码已经

                 存入数据库,进而致使数据不完全。为制止这种事情的发出就须要手动实行职业调整。

                1.关闭自动提交--connection.setAutoCommit(false);

                2.事情施行到位后交付-connection.commit();

                3.在遇见非常时回滚-connection.rollback();

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;

public class PrepareStatementDemo {
    public static void main(String[] args) {
        Connection connection = null;
        //SQL预处理对象
        PreparedStatement ps = null;
        ResultSet rs =null;

        try {
            connection = JDBCUtil.getConnection();
            connection.setAutoCommit(false);
            //?代表参数
            String sql = "insert into student (name,age) values(?,?)";
            //编译预执行计划 在数据库上创建执行计划  
            //(第二个参数可以不要-Statement.RETURN_GENERATED_KEYS 代表返回主键,没有的话下面的要去掉ps.getGeneratedKeys()会)
            ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            //?的位置 和 替换的值
            ps.setString(1, "lisi");
            ps.setInt(2, 20);
            //n 更新结果的数量
            int n = ps.executeUpdate();
            System.out.println("成功插入" n "条数据");
            //获取插入成功数据的主键
            ResultSet keySet = ps.getGeneratedKeys();
            int key = -1;
            while(keySet.next()){
                key = keySet.getInt(1);
            }
            System.out.println("插入数据的主键:" key);
            //查询
            String querySql = "select id , name ,age from student";
            ps = connection.prepareStatement(querySql);
            rs = ps.executeQuery();
            //获取结果集的元数据相关信息
            ResultSetMetaData metaData = rs.getMetaData();
            //列数
            int count = metaData.getColumnCount();
            for(int i = 1; i <= count; i  ){
                System.out.print(metaData.getColumnName(i) " ");
            }
            System.out.println();
            //查询结果打印
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println(id " " name " " age);
            }
            //提交
            connection.commit();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            if(connection != null){
                try {
                    //出现异常回滚
                    connection.rollback();
                } catch (SQLException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                }
            }
        }finally {
            JDBCUtil.close(connection, ps, rs);
        }

    }
}

输出结果:

成功插入1条数据
插入数据的主键:2
id name age 
1 zhangsan 30
2 lisi 20

成功插入了 lisi 那条记下,且重临主键为2.终极打字与印刷了列名和查询获得的多寡

此间用了事情的回滚,假使保留完将来再查询的中档出现非常,数据是不会存到数据库的,能够入手试下。

要快于Satement

07拿走数据库的接连对象

* A:获取数据库的连接对象
    * a: 案例代码
        public class JDBCDemo {
            public static void main(String[] args)throws ClassNotFoundException,SQLException{
                //1.注册驱动 反射技术,将驱动类加入到内容
                // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                //DriverManager.registerDriver(new Driver());
                //驱动类源代码,注册2次驱动程序
                Class.forName("com.mysql.jdbc.Driver");

                //2.获得数据库连接  DriverManager类中静态方法
                //static Connection getConnection(String url, String user, String password)  
                //返回值是Connection接口的实现类,在mysql驱动程序
                //url: 数据库地址  jdbc:mysql://连接主机IP:端口号//数据库名字
                String url = "jdbc:mysql://localhost:3296/mybase";
                //用户名和密码用自己的
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);
                System.out.println(con);                    
            }
        }

五、连接池(数据源)的使用

连接池可以重用数据库的连日,调控数据库的连日总的数量,当关闭从连接池中收获的连年时,只是将此三番五次归还给连接池,未有真的的与数据库断开连接。

引用的连接池有:DBCP和c3p0

1)c3p0的使用

官方网址下载jar包,将c3p0-0.9.5.2.jar和mchange-commons-java-0.2.11.jar到场类型中。

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class C3p0DataSourceDemo {

    public static void main(String[] args) {
        Connection connection = null;

        try {
            ComboPooledDataSource cpds = new ComboPooledDataSource();
            //配置连接池参数
            cpds.setDriverClass("com.mysql.jdbc.Driver");
            cpds.setJdbcUrl("jdbc:mysql://localhost:3306/huan");
            cpds.setUser("root");
            cpds.setPassword("root");
            //连接池的管理策略 ...
            //最小连接数量
            cpds.setMinPoolSize(5);
            //最大连接数量
            cpds.setMaxPoolSize(20);
            //超时时间ms
            cpds.setCheckoutTimeout(10000);
            //获取连接
            connection = cpds.getConnection();
            String sql = "select id,name,age from student";
            PreparedStatement ps = connection.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }

            rs.close();
            ps.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

出口结果:

id:1 name:zhangsan age:30
id:2 name:lisi age:20
id:3 name:statement1 age:20
id:4 name:statement2 age:30
id:5 name:statement3 age:40
id:6 name:ps1 age:11
id:7 name:ps2 age:12

2)DBCP的使用

官方网站下载jar包,将commons-logging-1.2.jar,commons-dbcp2-2.1.1.jar和commons-pool2-2.4.2.jar下载后导入项目

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.dbcp2.BasicDataSource;

public class DBCPDemo {
    public static void main(String[] args) {
        Connection connection = null;

        try {
            BasicDataSource bds = new BasicDataSource();
            // 连接参数
            bds.setDriverClassName("com.mysql.jdbc.Driver");
            bds.setUrl("jdbc:mysql://localhost:3306/huan");
            bds.setUsername("root");
            bds.setPassword("root");
            // 管理策略参数
            bds.setInitialSize(5);
            bds.setMinIdle(5);
            bds.setMaxTotal(20);
            bds.setMaxWaitMillis(10000);

            connection = bds.getConnection();
            String sql = "select id,name,age from student";
            PreparedStatement ps = connection.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:"   id   " name:"   name   " age:"   age);
            }

            rs.close();
            ps.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                if (connection != null) {
                    connection.close();
                }

            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

输出结果:

id:1 name:zhangsan age:30
id:2 name:lisi age:20
id:3 name:statement1 age:20
id:4 name:statement2 age:30
id:5 name:statement3 age:40
id:6 name:ps1 age:11
id:7 name:ps2 age:12

至于JDBC的片段总计就写这么多了~~

四、JDBC的批量操作

PrepareStatement和Statement都提供了足以批量操作SQL的不二等秘书籍

1.将sql增添至缓存区

Statement: addBatch(sql)方法,能够将sql直接增加Statement缓存区;

PrepareStatement:必要先进行setxxx(n,参数)方法将参数赋值,然后调用addBatch(sql)方法

2.试行executeBatch()将参数批量发送到数据库,何况实践

3.得以应用clearBatch()清空缓存区的参数可能sql

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;

import org.junit.Test;

public class JDBCBatchDemo {


    @Test
    public void testJdbcPrepareBatch(){

        Connection connection = null;
        PreparedStatement ps = null;

        try {
            connection = JDBCUtil.getConnection();
            String sql  = "insert into student (name,age) values (?,?)";
            ps = connection.prepareStatement(sql);
            ps.setString(1, "ps1");
            ps.setInt(2, 11);
            ps.addBatch();
            ps.setString(1, "ps2");
            ps.setInt(2, 12);
            ps.addBatch();
            int [] n = ps.executeBatch();
            System.out.println(Arrays.toString(n));    
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }




    }


    @Test
    public void testJdbcStatementBatch(){
        Connection connection = null;
        Statement st = null;
        try {
            connection = JDBCUtil.getConnection();
            String sql1 = "insert into student(name,age) values('statement1',20)";
            String sql2 = "insert into student(name,age) values('statement2',30)";
            String sql3 = "insert into student(name,age) values('statement3',40)";

            st = connection.createStatement();
            //批量添加
            st.addBatch(sql1);
            st.addBatch(sql2);
            st.addBatch(sql3);
            //执行
            int [] n = st.executeBatch();

            System.out.println(Arrays.toString(n));

        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            JDBCUtil.close(connection, st, null);
        }
    }


}

testJdbcStatementBatch()测量试验方法完结后翻看数据库,数据成功增添:

testJdbcPrepareBatch()测量检验方法试行之后查看数据库,数据成功增添:

2。作为Statement的子类,PrepareStatement承袭了Statement的享有作用,三种办法, execute,executeQuery和executeUpdate已被转移以使之不再必要参数

08取得SQL语句的奉行对象指标

* A: 获取SQL语句的执行对象对象
    * a: 案例代码
        public class JDBCDemo {
            public static void main(String[] args)throws ClassNotFoundException,SQLException{
                //1.注册驱动 反射技术,将驱动类加入到内容
                // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                //DriverManager.registerDriver(new Driver());
                //驱动类源代码,注册2次驱动程序
                Class.forName("com.mysql.jdbc.Driver");

                //2.获得数据库连接  DriverManager类中静态方法
                //static Connection getConnection(String url, String user, String password)  
                //返回值是Connection接口的实现类,在mysql驱动程序
                //url: 数据库地址  jdbc:mysql://连接主机IP:端口号//数据库名字
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);

                //3.获得语句执行平台, 通过数据库连接对象,获取到SQL语句的执行者对象
                // con对象调用方法   Statement createStatement() 获取Statement对象,将SQL语句发送到数据库
                // 返回值是 Statement接口的实现类对象,,在mysql驱动程序
                Statement stat = con.createStatement();
                System.out.println(stat);
            }
        }

五、连接池(数据源)的使用

连接池可以重用数据库的连年,调控数据库的总是总的数量,当关闭从连接池中获得的接连时,只是将此一连归还给连接池,未有当真的与数据库断开连接。

选定的连接池有:DBCP和c3p0

1)c3p0的使用

官方网站下载jar包,将c3p0-0.9.5.2.jar和mchange-commons-java-0.2.11.jar参与项目中。

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.mchange.v2.c3p0.ComboPooledDataSource;


public class C3p0DataSourceDemo {

    public static void main(String[] args) {
        Connection connection = null;

        try {
            ComboPooledDataSource cpds = new ComboPooledDataSource();
            //配置连接池参数
            cpds.setDriverClass("com.mysql.jdbc.Driver");
            cpds.setJdbcUrl("jdbc:mysql://localhost:3306/huan");
            cpds.setUser("root");
            cpds.setPassword("root");
            //连接池的管理策略 ...
            //最小连接数量
            cpds.setMinPoolSize(5);
            //最大连接数量
            cpds.setMaxPoolSize(20);
            //超时时间ms
            cpds.setCheckoutTimeout(10000);
            //获取连接
            connection = cpds.getConnection();
            String sql = "select id,name,age from student";
            PreparedStatement ps = connection.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while(rs.next()){
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:" id " name:" name " age:" age);
            }

            rs.close();
            ps.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally {
            try {
                connection.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

出口结果:

id:1 name:zhangsan age:30
id:2 name:lisi age:20
id:3 name:statement1 age:20
id:4 name:statement2 age:30
id:5 name:statement3 age:40
id:6 name:ps1 age:11
id:7 name:ps2 age:12

2)DBCP的使用

官方网址下载jar包,将commons-logging-1.2.jar,commons-dbcp2-2.1.1.jar和commons-pool2-2.4.2.jar下载后导入项目

package com.huan.jdbc;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.dbcp2.BasicDataSource;

public class DBCPDemo {
    public static void main(String[] args) {
        Connection connection = null;

        try {
            BasicDataSource bds = new BasicDataSource();
            // 连接参数
            bds.setDriverClassName("com.mysql.jdbc.Driver");
            bds.setUrl("jdbc:mysql://localhost:3306/huan");
            bds.setUsername("root");
            bds.setPassword("root");
            // 管理策略参数
            bds.setInitialSize(5);
            bds.setMinIdle(5);
            bds.setMaxTotal(20);
            bds.setMaxWaitMillis(10000);

            connection = bds.getConnection();
            String sql = "select id,name,age from student";
            PreparedStatement ps = connection.prepareStatement(sql);
            ResultSet rs = ps.executeQuery();
            while (rs.next()) {
                int id = rs.getInt("id");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                System.out.println("id:"   id   " name:"   name   " age:"   age);
            }

            rs.close();
            ps.close();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                if (connection != null) {
                    connection.close();
                }

            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

    }

}

输出结果:

id:1 name:zhangsan age:30
id:2 name:lisi age:20
id:3 name:statement1 age:20
id:4 name:statement2 age:30
id:5 name:statement3 age:40
id:6 name:ps1 age:11
id:7 name:ps2 age:12

关于JDBC的一对总括就写这么多了~~

JDBC 操作,javajdbc操作 1.简介 JDBC(Java DataBase Connectivity) 是一种可用以试行SQL语句的Java API,是一套面向对象的应用程序接口, 统一了数据...

3.在 JDBC应用中,在其他时候都不选取Statement,原因如下

09奉行insert语句获取结果集

* A: 执行insert语句获取结果集
    * a: 案例代码
        public class JDBCDemo {
            public static void main(String[] args)throws ClassNotFoundException,SQLException{
                //1.注册驱动 反射技术,将驱动类加入到内容
                // 使用java.sql.DriverManager类静态方法 registerDriver(Driver driver)
                // Diver是一个接口,参数传递,MySQL驱动程序中的实现类
                //DriverManager.registerDriver(new Driver());
                //驱动类源代码,注册2次驱动程序
                Class.forName("com.mysql.jdbc.Driver");

                //2.获得数据库连接  DriverManager类中静态方法
                //static Connection getConnection(String url, String user, String password)  
                //返回值是Connection接口的实现类,在mysql驱动程序
                //url: 数据库地址  jdbc:mysql://连接主机IP:端口号//数据库名字
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);

                //3.获得语句执行平台, 通过数据库连接对象,获取到SQL语句的执行者对象
                // con对象调用方法   Statement createStatement() 获取Statement对象,将SQL语句发送到数据库
                // 返回值是 Statement接口的实现类对象,,在mysql驱动程序
                Statement stat = con.createStatement();
                //  4.执行sql语句
                // 通过执行者对象调用方法执行SQL语句,获取结果
                // int executeUpdate(String sql)  执行数据库中的SQL语句, insert delete update
                // 返回值int,操作成功数据表多少行
                int row = stat.executeUpdate
                        ("INSERT INTO sort(sname,sprice,sdesc) VALUES('汽车用品',50000,'疯狂涨价')");
                System.out.println(row);

                //6.释放资源  一堆close()
                stat.close();
                con.close();
            }
        }

一。代码的可读性和可维护性,Statement需求持续拼接,而PreparedStatement不会。

10奉行select语句获取结果集

* A: 执行select语句获取结果集
    * a: 案例代码
        public class JDBCDemo1 {
            public static void main(String[] args) throws Exception{
                //1. 注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                //2. 获取连接对象
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);
                //3 .获取执行SQL 语句对象
                Statement stat = con.createStatement();
                // 拼写查询的SQL
                String sql = "SELECT * FROM sort";
                //4. 调用执行者对象方法,执行SQL语句获取结果集
                // ResultSet executeQuery(String sql)  执行SQL语句中的select查询
                // 返回值ResultSet接口的实现类对象,实现类在mysql驱动中
                ResultSet rs = stat.executeQuery(sql);
                //5 .处理结果集
                // ResultSet接口方法 boolean next() 返回true,有结果集,返回false没有结果集
                while(rs.next()){
                    //获取每列数据,使用是ResultSet接口的方法 getXX方法参数中,建议写String列名
                    System.out.println(rs.getInt("sid") "   " rs.getString("sname") 
                            "   " rs.getDouble("sprice") "   " rs.getString("sdesc"));
                }

                rs.close();
                stat.close();
                con.close();
            }
        }

二。PreparedStatement尽最大或然加强质量,DB有缓存机制,同样的预编写翻译语句再度被调用会不在必要编写翻译

11SQL注入攻击

* A: SQL注入攻击
    * a: 注入问题
        * 假设有登录案例SQL语句如下:
        * SELECT * FROM 用户表 WHERE NAME = 用户输入的用户名 AND PASSWORD = 用户输的密码;
        * 此时,当用户输入正确的账号与密码后,查询到了信息则让用户登录。
            但是当用户输入的账号为XXX 密码为:XXX’  OR ‘a’=’a时,则真正执行的代码变为:
            * SELECT * FROM 用户表 WHERE NAME = ‘XXX’ AND PASSWORD =’ XXX’  OR ’a’=’a’;
        * 此时,上述查询语句时永远可以查询出结果的。那么用户就直接登录成功了,显然我们不
        * 希望看到这样的结果,这便是SQL注入问题。
    * b: 案例演示
        CREATE TABLE users(
             id INT PRIMARY KEY AUTO_INCREMENT,
             username VARCHAR(100),
             PASSWORD VARCHAR(100)
        );

        INSERT INTO users (username,PASSWORD) VALUES ('a','1'),('b','2');

        SELECT * FROM users;

        -- 登录查询
        SELECT * FROM users WHERE username='dsfsdfd' AND PASSWORD='wrethiyu'1 
        OR 1=1

        SELECT * FROM users WHERE username='a' AND PASSWORD='1'OR'1=1'
        键盘录入:
        1
        1'OR' 1=1

三,最珍贵的少数是十分的大地提升了安全性,Statement轻易SQL注入,而PreparedStatement传入内容

12SQL注入攻击顾客登入案例

* A: SQL注入攻击用户登录案例
    * a: 案例代码
        public class JDBCDemo2 {
            public static void main(String[] args)throws Exception {
                Class.forName("com.mysql.jdbc.Driver");
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username = "root";
                String password = "123";
                Connection con = DriverManager.getConnection(url, username, password);
                Statement stat = con.createStatement();

                Scanner sc = new Scanner(System.in);
                String user = sc.nextLine();
                String pass = sc.nextLine();

                //执行SQL语句,数据表,查询用户名和密码,如果存在,登录成功,不存在登录失败
        //      String sql = "SELECT * FROM users WHERE username='dsfsdfd' AND PASSWORD='wrethiyu' OR 1=1";
                String sql = "SELECT * FROM users WHERE username='" user "' AND PASSWORD='" pass "'";
                System.out.println(sql);
                ResultSet rs = stat.executeQuery(sql);
                while(rs.next()){
                    System.out.println(rs.getString("username") "   " rs.getString("password"));
                }

                rs.close();
                stat.close();
                con.close();
            }
        }

不会和sql语句产生任何相称关系

13PrepareStatement接口预编写翻译SQL语句

* A: PrepareStatement接口预编译SQL语句
    * a: 预处理对象
        * 使用PreparedStatement预处理对象时,建议每条sql语句所有的实际参数,都使用逗号分隔。
        * String sql = "insert into sort(sid,sname) values(?,?)";;
        * PreparedStatement预处理对象代码:
        * PreparedStatement psmt = conn.prepareStatement(sql)

    * b: 执行SQL语句的方法介绍
        * int executeUpdate(); --执行insert update delete语句.
        * ResultSet executeQuery(); --执行select语句.
        * boolean execute(); --执行select返回true 执行其他的语句返回false.
    * c: 设置实际参数
        * void setXxx(int index, Xxx xx) 将指定参数设置为给定Java的xx值。在将此值发送到数据库时,驱动程序将它转换成一个 SQL Xxx类型值。
        * 例如:
            * setString(2, "家用电器") 把SQL语句中第2个位置的占位符? 替换成实际参数 "家用电器"
    * d: 案例代码
        /*
         *  Java程序实现用户登录,用户名和密码,数据库检查
         *  防止注入攻击
         *  Statement接口实现类,作用执行SQL语句,返回结果集
         *  有一个子接口PreparedStatement  (SQL预编译存储,多次高效的执行SQL) 
         *  PreparedStatement的实现类数据库的驱动中,如何获取接口的实现类
         *  
         *  是Connection数据库连接对象的方法
         *  PreparedStatement prepareStatement(String sql) 

         */
        public class JDBCDemo3 {
            public static void main(String[] args)throws Exception {
                Class.forName("com.mysql.jdbc.Driver");
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username = "root";
                String password = "123";
                Connection con = DriverManager.getConnection(url, username, password);
                Scanner sc = new Scanner(System.in);
                String user = sc.nextLine();
                String pass = sc.nextLine();

                //执行SQL语句,数据表,查询用户名和密码,如果存在,登录成功,不存在登录失败
                String sql = "SELECT * FROM users WHERE username=? AND PASSWORD=?";
                //调用Connection接口的方法prepareStatement,获取PrepareStatement接口的实现类
                //方法中参数,SQL语句中的参数全部采用问号占位符
                PreparedStatement pst =  con.prepareStatement(sql);
                System.out.println(pst);
                //调用pst对象set方法,设置问号占位符上的参数
                pst.setObject(1, user);
                pst.setObject(2, pass);

                //调用方法,执行SQL,获取结果集
                ResultSet rs = pst.executeQuery();
                while(rs.next()){
                    System.out.println(rs.getString("username") "   " rs.getString("password"));
                }

                rs.close();
                pst.close();
                con.close();
            }
        }

前提:为数据库连接创立八个缓冲池。

14PrepareStatement接口预编译SQL语句推行修改

* A: PrepareStatement接口预编译SQL语句执行修改
    * 案例代码
        /*
         *  使用PrepareStatement接口,实现数据表的更新操作
         */
        public class JDBCDemo {
            public static void main(String[] args) throws Exception{
                Class.forName("com.mysql.jdbc.Driver");
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);  

                //拼写修改的SQL语句,参数采用?占位
                String sql = "UPDATE sort SET sname=?,sprice=? WHERE sid=?";
                //调用数据库连接对象con的方法prepareStatement获取SQL语句的预编译对象
                PreparedStatement pst = con.prepareStatement(sql);
                //调用pst的方法setXXX设置?占位
                pst.setObject(1, "汽车美容");
                pst.setObject(2, 49988);
                pst.setObject(3, 7);
                //调用pst方法执行SQL语句
                pst.executeUpdate();

                pst.close();
                con.close();
            }
        }

1.从连接池获取或创造可用连接

15PrepareStatement接口预编写翻译SQL语句施行查询

* A: PrepareStatement接口预编译SQL语句执行查询
    * a: 案例代码
        /*
         *  PrepareStatement接口实现数据表的查询操作
         */
        public class JDBCDemo1 {
            public static void main(String[] args) throws Exception{
                Class.forName("com.mysql.jdbc.Driver");
                String url = "jdbc:mysql://localhost:3296/mybase";
                String username="root";
                String password="123";
                Connection con = DriverManager.getConnection(url, username, password);  

                String sql = "SELECT * FROM sort";

                PreparedStatement pst = con.prepareStatement(sql);

                //调用pst对象的方法,执行查询语句,Select
                ResultSet rs=pst.executeQuery();
                while(rs.next()){
                    System.out.println(rs.getString("sid") "  " rs.getString("sname") "  " rs.getString("sprice") "  " rs.getString("sdesc"));
                }
                rs.close();
                pst.close();
                con.close();
            }
        }

2.采用完成之后,把连接重回给连接池

16JDBC的工具类和测验

* A: JDBC的工具类和测试
    * a: 案例代码
        //JDBCUtils工具类代码
        public class JDBCUtils {
            private JDBCUtils(){}
            private static Connection con ;

            static{
                try{
                    Class.forName("com.mysql.jdbc.Driver");
                    String url = "jdbc:mysql://localhost:3296/mybase";
                    String username="root";
                    String password="123";
                    con = DriverManager.getConnection(url, username, password);
                }catch(Exception ex){
                    throw new RuntimeException(ex "数据库连接失败");
                }
            }

            /*
             * 定义静态方法,返回数据库的连接对象
             */
            public static Connection getConnection(){
                return con;
            }


            public static void close(Connection con,Statement stat){

                 if(stat!=null){
                     try{
                         stat.close();
                     }catch(SQLException ex){}
                 }

                 if(con!=null){
                     try{
                         con.close();
                     }catch(SQLException ex){}
                 }

            }


            public static void close(Connection con,Statement stat , ResultSet rs){
                 if(rs!=null){
                     try{
                         rs.close();
                     }catch(SQLException ex){}
                 }

                 if(stat!=null){
                     try{
                         stat.close();
                     }catch(SQLException ex){}
                 }

                 if(con!=null){
                     try{
                         con.close();
                     }catch(SQLException ex){}
                 }

            }
        }
    //测试JDBCUtils工具类的代码
    public class TestJDBCUtils {
        public static void main(String[] args)throws Exception {
            Connection con = JDBCUtils.getConnection();
            PreparedStatement pst = con.prepareStatement("SELECT sname FROM sort");
            ResultSet rs = pst.executeQuery();
            while(rs.next()){
                System.out.println(rs.getString("sname"));
            }
            JDBCUtils.close(con, pst, rs);
        }
    }

3.在系统关闭前。断开全数连接并释放连接占用的系统财富

17数据表数据存款和储蓄对象

* A: 数据表数据存储对象
    * a: 准备工作
        * 导入jar包
        * 拷贝day32定义的工具类JDBCUtils

    * b: 案例代码
        //定义实体类Sort
        public class Sort {
            private int sid;
            private String sname;
            private double sprice;
            private String sdesc;
            public Sort(int sid, String sname, double sprice, String sdesc) {
                this.sid = sid;
                this.sname = sname;
                this.sprice = sprice;
                this.sdesc = sdesc;
            }
            public Sort(){}
            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;
            }
            @Override
            public String toString() {
                return "Sort [sid="   sid   ", sname="   sname   ", sprice="   sprice   ", sdesc="   sdesc   "]";
            }               
        }

        /*
         *  JDBC读取数据表sort,每行数据封装到Sort类的对象中
         *  很多个Sort类对象,存储到List集合中
         */
        public class JDBCDemo {
            public static void main(String[] args) throws Exception{
                //使用JDBC工具类,直接获取数据库连接对象
                Connection con = JDBCUtils.getConnection();
                //连接获取数据库SQL语句执行者对象
                PreparedStatement pst = con.prepareStatement("SELECT * FROM sort");
                //调用查询方法,获取结果集
                ResultSet rs = pst.executeQuery();
                //创建集合对象
                List<Sort> list = new ArrayList<Sort>();
                while(rs.next()){
                    //获取到每个列数据,封装到Sort对象中
                    Sort s = new Sort(rs.getInt("sid"),rs.getString("sname"),rs.getDouble("sprice"),rs.getString("sdesc"));
                    //封装的Sort对象,存储到集合中
                    list.add(s);
                }
                JDBCUtils.close(con, pst, rs);
                //遍历List集合
                for(Sort s : list){
                    System.out.println(s);
                }
            }
        }

4.能够管理无效链接,限制连接池中连连总的数量不低于可能不抢先某个限定值。

18properties配置文件

* A: properties配置文件     
    * a: 相关介绍
        * 开发中获得连接的4个参数(驱动、URL、用户名、密码)通常都存在配置文件中,方便后期维护,程序如果需要更换数据库,
            只需要修改配置文件即可。
        * 通常情况下,我们习惯使用properties文件,此文件我们将做如下要求:
            1.  文件位置:任意,建议src下
            2.  文件名称:任意,扩展名为properties
            3.  文件内容:一行一组数据,格式是“key=value”.
                a)  key命名自定义,如果是多个单词,习惯使用点分隔。例如:jdbc.driver
                b)  value值不支持中文,如果需要使用非英文字符,将进行unicode转换。

小小的连接数是连接池平素维持的数码连接,要是应用程序对数据库连接的使用量相当小,将会有大气

19properties文件的创始和编排

* A: properties文件的创建和编写
    * a: properties文件的创建
        * src路径下建立database.properties(其实就是一个文本文件)
    * b: properties文件的编写(内容如下)
        driverClass=com.mysql.jdbc.Driver
        url=jdbc:mysql://localhost:3296/mybase
        username=root
        password=123        

的数据库连接财富被浪费掉

20加载配置文件

* A: 加载配置文件
    * a: 案例代码       
        /*
         *  加载properties配置文件
         *  IO读取文件,键值对存储到集合
         *  从集合中以键值对方式获取数据库的连接信息,完成数据库的连接
         */
        public class PropertiesDemo {
            public static void main(String[] args) throws Exception{
                FileInputStream fis = new FileInputStream("database.properties");
                System.out.println(fis);
                //使用类的加载器
                InputStream in = PropertiesDemo.class.getClassLoader().getResourceAsStream("database.properties");
                System.out.println(in);
                Properties pro = new Properties();
                pro.load(in);
                System.out.println(in);                 
            }
        }

最菲尼克斯接数是三翻五次池能申请的最特古西加尔巴接数,假如数额连接请求当先了次数,后边的数目连接诉求会被参与到等候队列中,这会潜移暗化之后的数据库操作

21透过配备文件延续数据库

* A: 通过配置文件连接数据库
    * a: 案例代码
        /*
         *  加载properties配置文件
         *  IO读取文件,键值对存储到集合
         *  从集合中以键值对方式获取数据库的连接信息,完成数据库的连接
         */
        public class PropertiesDemo {
            public static void main(String[] args) throws Exception{
                FileInputStream fis = new FileInputStream("database.properties");
                System.out.println(fis);
                //使用类的加载器
                InputStream in = PropertiesDemo.class.getClassLoader().getResourceAsStream("database.properties");
                System.out.println(in);
                Properties pro = new Properties();
                pro.load(in);
                //获取集合中的键值对
                String driverClass=pro.getProperty("driverClass");
                String url = pro.getProperty("url");
                String username = pro.getProperty("username");
                String password = pro.getProperty("password");
                Class.forName(driverClass);
                Connection con = DriverManager.getConnection(url, username, password);
                System.out.println(con);

            }
        }

假定最小连接数与最罗安达接数相差太大,那么,最早的连天乞求将会赚钱,之后超过,最小连接数量的连日央求等价于

22读取配置文件的工具类

* A: 读取配置文件的工具类
    * a: 案例代码
        /*
         *  编写数据库连接的工具类,JDBC工具类
         *  获取连接对象采用读取配置文件方式
         *  读取文件获取连接,执行一次,static{}
         */
        public class JDBCUtilsConfig {
            private static Connection con ;
            private static String driverClass;
            private static String url;
            private static String username;
            private static String password;

            static{
                try{
                    readConfig();
                    Class.forName(driverClass);
                    con = DriverManager.getConnection(url, username, password);
                }catch(Exception ex){
                    throw new RuntimeException("数据库连接失败");
                }
            }

            private static void readConfig()throws Exception{
                InputStream in = JDBCUtilsConfig.class.getClassLoader().getResourceAsStream("database.properties");
                 Properties pro = new Properties();
                 pro.load(in);
                 driverClass=pro.getProperty("driverClass");
                 url = pro.getProperty("url");
                 username = pro.getProperty("username");
                 password = pro.getProperty("password");
            }


            public static Connection getConnection(){
                return con;
            }

        }           

树立一个新的数据库连接,不过,这么些超过最下连接数的数据库连接在采取完不会立刻释放,它将会被平放连接池中等待重复使用或是悠闲超时后被假释

23测量试验工具类

* A: 测试工具类
    * a: 案例代码
        public class TestJDBCUtils {
            public static void main(String[] args) {
                Connection con = JDBCUtilsConfig.getConnection();
                System.out.println(con);
            }
        }

1.Cookie和Session的区别

作业测量检验

非得能独立写出JDBCUtils工具类,保险用JDBCUtils工具类能一鼓作气功效,不用JDBCUtils工具类工具类也能够做到功能

1.map中有如下数据(顾客名=密码)

[liuyan=123456,wangbaoqiang=123321,fangbian=abcd,miejueshitai=123abc321]
在ip为127.0.0.1数据库名为stdb,连接数据库的用户名和密码为:admin和123456中有一个userinfo表相关字段为(id,username,password)
(1)将map中的手机号码取出来打印到控制台上
    * 直接使用map集合的keySet()方法获取所有的key组成的Set集合,并遍历
(2)判断map中所有的用户名在userinfo表中是否存在存在则输出"该用户已注册",如果不存在将该用户名及对应的密码存入到userinfo表中
(map中的数据不需要修改)
    * 连接到数据库
    * 创建表
    drop database stdb;
    create database stdb;
    use stdb;
    create table userinfo(
        id int(10) primary key auto_increment,
        username varchar(200),
        password varchar(200)
    );      

2.四个数据库stdb,客商名称为admin 密码为123456 已存在多个表student中有四个学生的消息,姓名,性别,年龄,分数.

id(varchar(20))       name(varchar(20))      sex(varchar(20))     score(int(10))
 1                    李少荣                 女                   80
 2                    邵凯                   男                   75
 3                    周强                   男                   95
 4                    王晓婷                 女                   55
 5                    张秀花                 女                   68
 6                    顾会                   女                   50
 7                    赵天一                 男                   32
(1)查询女性,成绩80以上的学生数量
(2)将姓张的男同学的的成绩改为100
(3)查询成绩大于60的女性,显示姓名,性别,成绩
(4)分别统计所有男同学的平均分,所有女同学的平均分及总平均分
(5)按照分数从小到大的顺序打印分数大于总平均分的学员信息(id-name-sex-score),并将分数大于总平均分的学员信息(按照分数从小到大的顺序)(id-name-sex-score)写入到studentInfo.txt文件中(写入格式:id-name-sex-score)
(6)定义查询所有学生的方法public List<Student> getAllStudent(){}
(7)定义根据id查询学生的方法public Student getStudentById(String id){}
(8)定义根据id删除学生的方法public int deleteStudentById(String id){}//注意只有数据库中有才能删除,没有无法删除
(9)定义添加学员的方法public int addStudent(){}//注意只有数据库中没有有才能添加,有无法添加
(10)定义根据id修改学员的信息public int updateStudentById(String id){}//注意只有数据库中有才能修改,没有无法修改

Cookie是web服务器发送给浏览器的一块消息,浏览器会在本地一个文件中给种种web服务器存款和储蓄cookie

从此今后浏览器再给一定的web服务器发送央求时,同有难点间会发送全部为该服务器存款和储蓄的cookie.

Session是储存在web服务器端的一块消息,session对象,存款和储蓄特定客商会话所需的品质和布置音讯,当客户在

应用程序的Web页面之间跳转时,存款和储蓄在Session对象中的变量将不会吐弃,而是在整个客户会话中央市直机关接留存下来

Cookie和session的差异点:

1。无论顾客端做哪些的设置,session都能够健康干活,当客户端禁止使用cookie时,将不能使用cookie

2.在蕴藏的数目方面,session能够存款和储蓄大肆的java对象,cookie只好存款和储蓄String类型的靶子

1,什么事jsp,什么事servlet,jsp与Servlet有如何差距,

jsp本质上正是二个Servlet,它是Servlet的一种相当格局,每一个jsp页面都以几个servlet

实例。

Servlet是由 Java提供用于支付 web服务器应用程序的二个零部件,运维在服务端,由servlet 容器管理,用来生

成动态内容。叁个 servlet 实例是落到实处了特别接口 Servlet 的 Java 类,全数自定义的 servlet 均必需贯彻 Servlet 接

分别:jsp侧重代码,servlet侧重调控。

1.什么样是xml,使用xml的利害,xml的解释器有那二种,分别有何分别?

xml是一种扩大性标识语言,帮助自定义标签使用DTD和XML Schema标准化XML结构

可取:用于配置文件,格式统一,相符标准,用于互不宽容的体系间互为数据,分享数据低价

缺欠:xml文件格式复杂,数据传输占流量,服务端和客商端分析xml文件占用大批量能源且不易于保险,

Xml常用解释器有2种,分别是,DOM和SAX;(技巧轻巧,那四个就不做过多解释)

本文由澳门新萄京官方网站发布于数据库网络,转载请注明出处:Java面试题之JavaWeb基础,jdbc学习笔记02

关键词: