同学们，今天学习了JDBC，我们从JavaSE，前端，数据库又重新回到了我们的Java代码。

今日需要掌握的有：

• 能够用自己的话阐述什么是JDBC？使用JDBC作用是什么？
• 能够用自己的话阐述什么是SQL注入漏洞并给出解决方法
• 独立完成使用JDBC的预编译对象进行CRUD操作(重点)
• 会使用JDBC工具类操作数据库
  

   


请同学们按照如上要求，总结今日所学。

曾耀峰

  JDBC是Java Database Connection 的简称，中文名为java数据库连接接口。在JDBC没有出现之前，通过Java连接数据库，要学习相应的数据库连接方法，各个数据库厂商提供的方法还不一样。有了JDBC以后，Java连接数据库只要到JDBC官网下载相应的数据库接口，就可以使用封装好的方法直接连接，十分简便。

   使用方法:
   官方下载版本，将下载好的jar包复制到工程，右键包->Build Path->Configure..即可导入使用
   ——注意:在java中使用的连接对象全部来自于java.sql,而不是com.mysql.jdbc的内容
   
   通过案例来学习JDBC的知识:

一.案例1:写JDBC的查询和更新操作
   
  在MySQL对数据的常见操作中有我们俗称的"增删改查",分为两类，增 和删改查，在SQL中操作这样的语言分别称为DQL 和DML。因为JDBC是连接数据库的，所以也提供了Query(查询)和Update(更新)来对应SQL中的DQL和DML。因此，java代码中执行SQL的查询语句使用executeQuery(),修改使用executeUpdate()方法.

  1.首先学习了建立JDBC的六个步骤，有记忆规则"贾琏欲执事":  
  贾:注册(加载)驱动
  琏:获取连接对象
  欲:获取执行语句的对象
  执:执行语句并处理数据
  事:释放数据操作相关对象

  2.在Query()查询中，分为查询多个数据，查询单个数据
   （1）多个数据:返回结果集为ResultSet rs。使用while(rs.next())遍历是否有下一个数据，如果有，再使用getString(1,"列名称") 或者 getInt("列名称")来获得相应的数据和数据类型
    (2) 单个数据:返回还是Result rs 但是rs只有1或0条数据,可以直接使用if(rs.next()){};

  3.在Update()更新中，方法步骤类似Query()查询。只是它返回的值是int类型num.表示在操作中影响的行数。如果<0.则操作失败；否则操作成功:
     int result = pds.executeUpdate();if (result > 0)
  
  4.在java中执行SQL语句，通常使用"?"占位符来代替数据，然后用setInt(1,80),setString(2,"dollar")来填充数据。
      
   
  5.释放资源:当出现Connection、PreparedStatement()、ResultSet() 这些sql操作对象，都要在使用完毕之后释放对象。
因为这些对象都有异常产生，所以放在finally{}代码块中。


二、案例2:将JDBC操作抽取成工具类DBUtils.java:

   同上面的查询和更新操作中，每个方法共同的代码很多，所以要抽取共同的代码，做成一个工具类，方便直接调用。
   将driverClassName 驱动名字 url 数据库地址 user 用户名 password 密码 做成静态final常量。在静态代码块中赋值
static{}
   将获取驱动loadDriver()注册驱动，getConnection()获取连接对象,getStatement()获取执行语句,release()释放资源等四个方法封装。再用测试类调用工具类方法，代码简洁很多，如下:

                Connection conn = null;
                PreparedStatement pdt = null;
                conn = JDBCUtils.getConnection();
                String sql = "select * from dept";
                pdt = JDBCUtils.getStatement(sql);
                ResultSet rs = pdt.executeQuery();
                while (rs.next()) {
                        System.out.println(rs.getInt("deptno") + " " + rs.getString("dname") + " " + rs.getString("loc"));
                }
                JDBCUtils.release(conn, pdt, rs);


三、将数据库的配置信息写在配置文件db.properties，再用属性类Properties调用，方便在文件中直接修改数据库信息，而不用到代码中修改。

    properties.load(new FileInputStream("src/db.properties"));

    driverClassName = properties.getProperty("driverClassName");

四、SQL注入漏洞:

   在SQL语句中，利用statement 拼接语句的时候，使用''单引号的漏洞，只要向用户名输入框中输入“用户名+'or'1=1'”,整个sql语句就变成select * from user_tb  where user = 'aaa' or '1=1' and passowrd ='xxxx'这样的语句。
因此‘1=1’条件为true。所以变成select * from user_tb  where user = 'aaa' 只要用户名猜对，密码随便填即可登录成功。
   补救情况:

   使用PreparedStatement 预编译执行语句对象代替Statement就可以防止SQL注入的情况。因为，可以通过用占位符"?"代替SQL语句中的值。然后通过pdt.setString(1,username);pdt.setString(2,password);
   如果此时，再出现username = aaa' or '1=1' 这个情况。preparedStatement 会在用户名的特殊符号单引号加一个转义字符，使它变成和字母一样的字符。aaa\' or \' 1=1\' 。这样就阻止了SQL注入的漏洞。

   因此，以后使用PreparedStatement 预编译执行语句对象代替Statement。


五、使用Junit工具测试类Test
     
    使用Junit的Test类可以直接测试方法，用这个方式来代替main函数测试

    1.在代码区域敲"Test"，代码出现提示，选择 Test 4这个版本。即可生成Test方法
    2.执行:双击方法名，右键-Run as..Junit Test
    3.每个方法要声明一个@Test。不能直接点绿色箭头运行，不然会执行全部测试方法

六、其他常见错误点:

1.更新了外键数据，导致JDBC执行语句失败:

   在JDBC进行Update操作的时候，要注意表中存在外键的情况。比如，在部门表dpet中如果设置deptno 为职员表emp的外键,并且id有记录在外键生成，就不能随意对该记录进行Update。
   
   举个例子:部门表dept中，字段deptno 有(10,20,30,40,50)等5个记录，并且其中(10,20,30,40)在员工表emp作为外键记录生成。那么这时候，对(10,20,30,40)在部门表dept修改就会报错。但是对50这个数可以修改。如果要强行修改(10,20,30,40)中的数据，有两种操作:

    1).删除emp表中对应的数据

    2).解除外键


2. 再次回顾增删改查(QURD):

    查:select * from dept;
    增:按字段增加:insert into dept(deptno,dname,loc) values(70,'策划部','五楼');

       全字段增加: insert into dept values(60,'后勤部','六楼');

    改:修改一整列:update dept set loc = '五角大楼';//没有设置where条件的情况下，将会整列的loc值都变成'五角大楼'
       修改某一列:update dept stet loc = '双子大厦' where deptno = 40;
     
    删:删除所有:delete from dept;表中数据全部清空
       删除某个记录:delete from dept where deptno = 30;

吴鹏

总结

----------------------------------------------------------------
一 什么是JDBC

英文全称是:java database connectivity,翻译过来是Java 数据库 连通;

是一套接口和规范,让开发人员可以用这套规范使数据库和java进行联系;

1 加载驱动;
2 获得连接;
3 基本操作;
4 释放资源;

二 sql漏洞注入:
因为在java中定义sql语句时,是将获得用户的username和password与sql通过字符串拼接在一起的,当在
输入的时候,用户名为任意用户名' or ' 1=1,密码随意或者任意用户名' -- 密码随意;这样输入会使后面密码
的判断失效,只要用户名是存在在网站的数据库,且没有防sql漏洞,则不需知道密码就可以登陆;
在sql语句中,原本是:
"select * from user where username ='"+username+"' and password = '"+password+"'";
替换成上面就会是:
"select * from user where username ='"+aaa' or ' 1=1+"' and password = '"+任意+"'";
则结果必然达成,因此只要直到用户名即可以登陆;

解决的办法:
使用PreparedStatement代替Statement来接收要执行的sql语句,对于sql中未确定的值,可以用占位符?来代替;
只需在执行前使用PreparedStatement的setInt()或者setString()方法,将占位符设置成我们需要的值即可;

三 JDBC的预编译进行增删改查操作:
早上教的JDBC的增删改查是使用Statement来接收要执行的sql语句;
在下午,教导了使用PreparedStatement来进行数据库的增删改查,优点是
代码阅读更简单,使用占位符来修改sql语句中的值,提高了可维护性;
使用Statement的代码如下:

Connection conn = null;
statment stmt = null;

Class.forName("com.mysql.jdbc.Driver");
//加载驱动;
conn = DriverManager.getConnection(url,username,password);
url为数据库的地址:jdbc:mysql//localhost:3306/数据库名称;
username 数据库登陆用户名
password 数据库登陆密码
stmt = conn.createStatement();
//创建执行sql语句的对象;
String sql = "";
//创建sql语句;
int num = stmt.executeUpdate(sql);
//执行sql语句,返回的是int类型的数据,意义为增,删,改为表中的第num行;
if(num>0){System.out.println("执行成功")};
//可以根据num值来对操作进行判断,提示操作是否成功;
释放资源;
------------
当使用预编译时,将Statement替换为PreparedStatement,稍作修改;
Connection conn = null;
PreparedStatement pstmt = null;

Class.forName("com.mysql.jdbc.Driver");
//加载驱动;
conn = DriverManager.getConnection(url,username,password);
url为数据库的地址:jdbc:mysql//localhost:3306/数据库名称;
username 数据库登陆用户名
password 数据库登陆密码
String sql = "...?...?...";
//创建sql语句;
pstmt = conn.createPreparedStatement(sql);
//创建执行sql语句的对象;
pstmt.setInt(colnum,值)/pstmt.setString(colnum,值);
对占位符进行设置,特别要注意的是,占位符的首位是从1开始计数,而不是像索引值从0开始;
int num = stmt.executeUpdate(sql);
//执行sql语句,返回的是int类型的数据,意义为增,删,改为表中的第num行;
if(num>0){System.out.println("执行成功")};
//可以根据num值来对操作进行判断,提示操作是否成功;
释放资源;

王刘锁
在艰难的学完数据库MySQL之后今天终于回到了久违了近10天的eclipse
.一切还是那么陌生,好不容易记住的又想不起来了,像什么快捷键和一些语法!
不过在今天的学习中我们又重新找回了一些记忆,当然也是学了一些新知识.今儿主要学习JDBC
它是一个用来连接数据库的纽带好让我们可以用Java语言执行SQL语句来访问数据库,
其实就是SUN公司提供的一组接口和类的规范,
在使用的时候我们首先要先把提供的jar包给导进来把配置环境做好也就是build path,一说就可以想的起来,
接下来说一下怎么访问数据库,
第一步:需要注册驱动 驱动就是设备间互相访问的通道!格式是固定的记住就行
利用反射获得class文件:
     Class.forName(com.mysql.jdbc.Driver//driverClassName)
第二步:获取和数据库的连接,同样固定的格式
     Connection conn=DriverMannager.getConnectio("jdbc:mysql://localhost:3306/db1","root","root");第一个参
数是jdbc:mysql://数据库IP地址:端口,后面两个是自己的用户名和密码
第三步:获取执行sql语句的Statement对象,固定格式
Statement stmt = conn.createStatement();
第四步:写sql语句:这里sql语句一定要写正确,
     String sql = "select * from xsb";//查询 "delete from xsb where sid=3";//删除
    "update xsb sname='小阿香',sex='男' where sid=3";//修改
    "insert into xsb values(null,'小龙龙','女')";//添加
第五步:执行sql语句:
如果是查询语句要用结果集来接收,然后遍历结果集
     ResultSet rs=stmt.executeQuery(sql);
        while(rs.next()){
        System.out.println(rs.getInt("sid")+rs.getString("sname")+rs.getString("sex"));
        }
如果是增删改的话:
     int num =stmt.executeUpdate(sql);
        if(num>0){
        System.out.println("操作成功!!");
        }
第六步:最重要的一步,释放资源,
     rs.close();
     stmt.close();
     conn.close();
当然写完这些代码发现好多重复的代码!那今天还学习了抽取工具类,这里不多说了,把相同的代码抽取出来就可以,另外为
了让客户可以方便的修改个人信息还学习了设置配置文件,让客户可以直接修改文件中的信息.
此外呢还有一个sql的注入问题也就是当别人知道用户名的时候可以利用[用户名 ' or ' 1=1 ]这样的方式在sql语句加载执行的时候把sql语句拼接成[username='用户名' or '1=1' and password='密码']的格式,这时因为or关键字和1=1等式的永成立这个sql语句的条件就会永远成立,因此无论输入的密码是否正确都会登录成功!,不知道我的qq号是不是这样被人给盗的!但是今天学习了这个preparedStatement就可以解决被盗号问题了,.
这里就把改变的代码部分写出来好了,
第一步:注册驱动,
第二步:获取连接,
第三步:获取执行sql语句的对象并执行sql语句
     String sql = "insert into xsb values(null,?,?)";
     这里的信息被?占位
     PreparedStatement stmt = conn.preparStatment(sql);
     然后给?赋值,这里的1,2是第一第二个?
     stmt.setString(1,"小敏");
     stmt.setString(2,"女");
     执行sql语句
     int num = stmt.executeUpdate();
        if(num>0){
        System.out.println("操作成功!!");
        }
第四步:释放资源.
在最后声明一下,这里的代码要用try{以上代码}catch(异常类型){异常处理}finall{释放资源}给捕获才行!

常小天
今天学习的是JDBC的内容。JDBC是将java和数据库连接起来的桥梁。使用JDBC可以让我们在java中来操作数据库。JDBC是一组接口，也就是一组规范。各数据库在驱动中实现这组接口，从而达到各种不同的数据库都能接入到java语言中进行操作。使用JDBC的步骤为：加载驱动、获取连接、创建sql语句对象、编写并执行sql语句、最后释放资源。加载驱动时采用获取驱动类的class对象的方式加载驱动，因为Driver类中的静态代码块中会加载一次驱动。获取连接的方法是DriverManager中的静态方法getConnection（），该方法中有三个参数，URL为要连接的数据库的路径，后两个为用户名和密码。之后通过连接对象调用方法获得语句对象，这里要采用可以解决SQL注入漏洞的preparedStatement（）对象。接下来预编译SQL语句，注意别漏了问号。执行增删改操作使用executeUpdate()，返回受影响的行数，判断返回值是否大于0来确定是否操作成功，执行查询操作使用executeQuery()，返回值为结果集，遍历结果集并输出。此外有两点注意的地方，一是导包要到导java.sql下的包，不要导错，二是在配置属性文件时，属性文件中的信息末尾不要加任何多余的符号，尤其是不要加空格，会特别难检查出来。

许剑鸿 webDay10

JDBC : java database connectivity java数据库连接 是一种用于执行SQL语句的Java API 可以为多种关系数据库提供统一访问.

JDBC入门使用步骤:(由于JDBC增删盖查代码有重复部分,可通过编写工具类来减少代码量)
1.导入jar包
2.贾琏欲执事
贾:加载驱动 Class.forName("com.mysql.jdbc.Driver")
琏:获得连接 DriverManager.getConnection("jdbc:mysql://localhost:3306/db1(数据库名)","root(数据库用户名)","root(密码)");
欲:编写sql语句
执:执行sql语句  statement(会出现sql注入漏洞) preparestatement(防止sql注入漏洞)  
        sql注入漏洞:使用statement时 为了不让数据被写死,使用字符串拼接的方式获得SQL语句 语句中可能会被 ' or ' 或者其它语句导致sql语句改变原意而通过查询
        通过prepareStatement预编译可避免sql注入漏洞
                Connection conn = JDBCUtils.getConnection();
                String sql = "update student set sname=? where sid =?";
                prepareStatement pstat = conn.prepareStatement(sql);
                pstat.setString(1, "PGone");
                pstat.setInt(2, 13);
                int num = pstat.executeUpdate();
        executeQuery(查询语句时使用 返回一个ResultSet结果集 通过遍历获得数据库中数据)  executeUpdate(增删改语句时使用 返回一个int类型数据 表示变动了几行)

事:释放资源

林文辉 总结

JDBC: Java DataBase Connectivity,用于执行SQL语句的Java API；
JDBC的一般开发步骤为：
1.加载驱动

Class.forName("com.mysql.jdbc.Driver");

2.获取连接

Connection conn = DriverManager.getConnection("jdbc:mysql:///数据库名", 数据库用户名, 数据库密码);

ip和端口3306可省略不写，用/代替

3 获取执行SQL语句的对象

Statement stmt = conn.createStatement();
PreparedStatement pstmt = conn.preparedStatement(sql);
4.执行SQL

Statement:                        String sql = "select * from user  where id=' "+s1+" ' ";
PreparedStatement :  String sql = "select * from user  where id=?";
                pstmt.setString("s1");

pstmt.executeQuery()用于查找，返回的是结果集 用ResultSet对象接收

pstmt.executeUpdate()用于增删改，返回的int类型

Statement 同理。

5.释放资源

数据库的资源比较宝贵，且数据库允许的并发访问连接数量有限，所以在数据库资源使用
完后，应该及时的去释放资源，并且将释放资源写在最终要执行的finally的代码块中

对于工具类的抽取：
可以将驱动注册，获取连接和资源释放这几个代码块抽取出来，减轻代码的臃肿。
同时可以通过文件(.properties)将JDBC的配置信息配置到文件中，使用键值对的方式，再通过
Properties 对文件进行读取。来获取配置信息。


关于Statement和PreparedStatement:
Statement对象和PreparedStatement对象 的CRUD操作大相径庭。
1:
Statement对象执行语句时，每次都会对其进行编译，如果相同的SQL语句执行多次时，
Statement对象就会使数据库频繁的对同一条语句进行编译
PreparedStatement对象可以对SQl语句进行预编译，预编译的信息就会存在PreparedStatement
对象中，这样如果相同的SQL语句再次执行时，程序就会直接使用PreparedStatement中的数据。

2:
Statement对于sql语句字符串只能进行拼接，容易出现SQL漏洞注入
而PreparedStatement则可以使用占位符 ?，通过这个来代替字符串拼接，解决了SQL
漏洞注入的问题。

陈强
JDBC的一天
Java Database Connection就是用于Java和数据库之间通信的桥梁
一步一步,从”贾琏欲执事”开始,
1,加载驱动
2,获得连接
3,获得语句对象
4.执行代码
5,释放资源
Class.forName---DriverManeger.getconnection---Connection---PreparedStatement---ResultSet(查询时)---close
使用JDBC进行查询时,会比增删改多出一个ResultSet结果集,还要对查询的结果集进行遍历和输出查询的结果.
CRUD的操作---增删改查---由于重复代码过多,抽取成为一个工具类,然后再进行方法的调用,减少代码量;
工具类的抽取,从路径\用户名\密码都是写死的,到采用属性文件进行更替,更加方便了后期的修改;
SQL的注入漏洞----采用PreparedStatement来解决,因为PreparedStatement会对传入的有特殊符号的字符进行转译,避免特殊字符传到数据库时,因为语言的不同导致异常的产生.
代码书写的过程中发现的问题是,导包问题,这边注意到的是,Connection\DriverManager\PreparedStatement\ResultSet等都是需要导入java.sql下的包,导包的错误,会使得代码异常和运行的结果报错!!!

张育辉

JDBC总结:
        JDBC是SUN公司提供一套统一的规范（接口）。
        然后各个数据库生产商提供这套接口的实现。这套接口规范就是JDBC的规范。
        一:jdbc五步实现步骤
                1:加载驱动 DriverManager.registerDriver(new com.mysql.jdbc.Driver());不建议使用,应为调用Driver类时静态注册
                2:获取connection连接
                3:得到执行sql语句对象Statement
                4:执行sql语句并返回结果集ResultSet;
                5:关闭资源;
        
        二:        jdbc:连接数据库的协议
                mysql:是jdbc的子协议
                localhost:连接的MySQL数据库服务器的主机地址（连接是本机就可以写成localhost），如果连接不是本机的，就需要写上连接主机的IP地址。
                        3306:MySQL数据库服务器的端口号
                后面是数据库名称
                url如果连接的是本机的路径，可以简化为如下格式：
                jdbc:mysql:///web_test3
        三:        事务管理
                在获取到了connection对象之后,可以
                开启事务,connection.setAutoCommit();
                提交事务:connection.Commit();
                事务回滚:connection.rollback();
        
        四:JDBC核心对象
                DriverManager:用于注册驱动
                Connection: 表示与数据库创建的连接
                Statement: 操作数据库sql语句的对象
                ResultSet: 结果集或一张虚拟表
                Statement        :执行SQL
                CallableStatement:执行数据库中存储过程,
                PreparedStatement:执行SQL.对SQL进行预处理。解决SQL注入漏洞。
               
        五:        PreparedStatement和Statement区别:书写格式不一样,
                PreparedStatement是用?号赋值,底层执行时把特殊符号转译掉,预编译对象,是Statement对象的子类
                Statement是直接插入,有安全性的漏洞;
               
        六:增删改用executeUpdate()方法,返回int类型(数据库几行受影响)类判断是否成功
           查询用executeQuery()方法,返回一个结果集(ResultSet),循环判断有没有下一条元数来获取对应的值;
        
        七:JDBC工具类的概述:
                        增删改查,重复代码过多,加载驱动,关闭资源一直在重复,需要抽取,
                        把属性(加载驱动的架包,协议,用户名,密码)写到properties配置文件中,类加载的时候开始赋值;
                        获取连接对象时候调用加载驱动,在使用工具类的时候调用connection连接对象时候,加载驱动并且获取连接;
        

张裕
今天学习了JDBC数据库接口 (可以使java连接到数据库)
JDBC的开发步骤
        1 加载驱动
        2 获得SQL连接对象
        3 获取执行对象
        4 释放资源

                                        DriverManager
驱动管理类
        作用一:注册驱动
                因类中存在的静态代码块执行了注册驱动的动作
                所以实际开发中一般采用 Class.forName()方法来注册       
        作用二:获得连接
                getConnection(主协议:子协议://服务器ip地址:端口/数据库名) 用来与数据库连接的方法
                如果连接的是本机的SQL服务器 可以简写 ( : :///)
       
                                        Connection
与数据库的连接对象
        作用一:创建执行SQL语句的对象
                createStatement() 执行SQL
                CallableStatement() 执行数据库中存储过程
                PreparedStatement() 执行SQL对SQL进行预处理.解决SQL注入漏洞
                        常用方法：
                        int executeUpdate(String sql); --执行insert update delete语句.
                        ResultSet executeQuery(String sql); --执行select语句 返回结果集
                        boolean execute(String sql); --执行select语句返回true 执行其他的语句返回false.
                       
        作用二:管理事务
                setAutoCommit()
                rollback()

                                        Statement
执行SQL
        作用一:执行SQL语句
                execute(); 返回boolean类型
                        执行查询,修改,添加,删除的SQL语句
                executeQuery;返回ResultSet对象
                        执行查询(执行select 语句)
                executeUpdate();返回int类型
                        执行修改,添加,删除的SQL语句
        作用二:执行批处理
               

                                        ResultSet
结果集       
        通过select语句查询的结果

        结果集的遍历
                next()方法
        结果集的获取
                getxxx();
                getObject();

                                        资源释放
ResultSet,Statement,!Connection
        将资源释放的代码写入到finally的代码块中
        资源释放的代码要写的标准


                                        工具类的创建
为了提高代码的复用性 创建一个工具类
        创建私有静态 final成员变量
        通过静态代码块给变量赋值
        创建方法注册驱动 返回数据库连接对象 以及抛出异常方法 使代码不在臃肿

                                        配置文件的创建
为了方便普通人员修改数据库的url以及用户 密码 内容为 key=value 创建properties配置文件 并在工具类中解析 Properties对象

                                        SQL注入漏洞
漏洞代码
        产生原因 在变量中存在SQL关键字
        xxx' or '1=1 xxx

JDBC（Java Data Base Connectivity，Java数据库连接）：
连接Java和数据库的方式，用Java语言对数据库进行操作

SQL注入:
用Java语言进行数据库查询时，需要传入SQL语句，是个字符串，其中用户录入的数据将会拼接到SQL语句中，此时如果在录入时掺杂有单引号，便可以串改SQL语句的语义，使其便宜设计时的本意，进而对数据库数据进行攻击，如'aaa or '1=1

SQL注入漏洞解决方案：
让所有用户录入的数据的字符前面都加上转义符，那么在SQL语句中该字符发挥的仅为字符的作用，无法发挥符号的作用
即连接对象在创建语句对象时，用preparedStatement()创建PrepareStatement对象，用于替代createStatement()创建Statement对象

JDBC操作方法：（详见附图）
加载驱动
创建连接
创建语句对象
执行语句
释放资源


C:\Users\老王\Desktop\JDBC(Java Data Base Connectivity).png

柯威龙
JDBC是一种用java语言来实现数据库的一种语句.用java执行SQL语句.学习了几个字来实现JDBC的大部分步骤
贾(加载驱动)琏(获得连接)欲(获得预处理对象(编写SQL语句))执(执行SQL语句)事(释放资源).
五个字简单明了的说明了JDBC的步骤.中华文化博大精深.导致我今天学的比平常懂.
今天学了两种的增删改查.一种是简单的增删改查,增删改的代码其实都差不多,按照五个步骤来就可以了,
查的话有一个结果集,如果要遍历全部的话还要使用while循环.但是这种增删改查很容易引起SQL的注入
漏洞.安全性能较低.所以我们学习了PreparedStatement的增删改查.可以预防注入漏洞.两种的增删改查代码
大部分都是一样的.这样子的话我们学习创建工具类,把增删改查里面相同的代码提取到工具类里面.这样子可以
让代码看起来没有那么繁杂,比较的清晰易懂.

万冕

今天学习了JDBC，就是用java代码来操纵数据库，对数据库进行CRUD。

今天学了一个小口诀来让我们更快的记住了jdbc的五个步骤，贾（加载驱动）琏（连接驱动）欲（编写sql语句）
执（执行sql语句）事（释放资源）

今天的代码稍微多了一点，但是也不是非常的复杂，还学会了sql注入，非常的神奇，增删改查主要是用prepareStatement
这样可以解决sql的注入，增加的安全性，在编写sql语句是比较不同String sql = "update user set username = ?,password =?,nickname=?,age = ? where id = ?";
设置是用第一个问号开始设置（要操作第几个问号，要操作的值）

且今天的重复代码特别多，因此需要抽取，独立写一个工具类，减少代码，增加代码的可维护性，新学了一个配置文件
后缀是properties的文本，里面的关系是key = value 在工具类里创建properties的对象，在用FileInputStream来读取，
且给那些值赋值。


                                疯狂敲代码

李志勇:
JDBC:
Java DataBase Connectivity,java数据库连接
因为要捕捉异常所有提前定义
Connection conn=null;
ResultSer rs=null;(查的时候才有)
PreparedStatement pst=null;
以便后面释放资源
注册驱动   Class.forname("com.mysql.jdbc.Driver");
获得链接    Connection conn=DriverManager.getConnection(); 返回一个Connection的对象
创建sql语句
获得执行语句对象  PreparedStatement pst=conn.preparedStatement (sql);
{如果sql语句里面有创建?的话   pst.setSrting()或 pst.setInt()为?赋值}
执行sql语句   pst.executeQuery() 查 Sql语句用这个
              pst.executeUpDate() 增删改sql语句用这个
释放资源  如果是查 的   rs.colse();  conn..colse(); pst.colse();
          增删改     if(conn!=null){               pst.colse();
                        try{
                        conn.colse();       
                        }catch(Execption e){}
                        conn=null;
                     }

Properties p=new Properties ();   用了读取文本对象创建的对象
p.load(一个输入流  new FileInputStream(文件路径))
p.getProperty(文件key)返回一个key对应的值;
文件格式.properties,
      key1=值1
      key2=值2
      .........

叶身辉:
        今天学习了JDBC是一种java的数据库连接可以执行sql语句,是sum公司提供的一种借口标准,适用于所有的数据库,
        JDBC需要导入一个jar包才可以使用,
        固定的格式有:贾琏欲执事
1,加载驱动
        Class.forName("com.mysql.jdbc.Driver");
2,获得连接
        connection conn=DriverManager.getconnection(url,user,password);
        url:是数据库连接的路径:jdbc:mysql:/ip地址(本机的话可以写成localhost):端口号/数据库名;如果是本机的话可以简写:jdbc:mysql:///数据库名;
        user:是数据库账号,password:是数据库密码.
3,sql语言
        String sql = "写入需要的sql语句";
4,使用connection创建对象,用statement执行sql语句
        有三种方法,主要使用preparedStatement来执行,这种方法可以解决sql注入漏洞的问题
        connection 还可以管理事务
                4.1,执行sql语句
                        执行查询的是executeQuery();查询需要返回resultset结果集
                                resultset需要使用while遍历结果集获取方式为getInt(),getString(),等
                               
                        执行增删改的是executeUpdate();
                       
5,释放资源
        要将释放的资源代码写到finally中,标准的格式为:
                        if(conn !=null){
                                try {
                                        conn.close();
                                } catch (SQLException e) {
                                        e.printStackTrace();
                                }
                               
                                conn = null;
                        }
另外加载驱动和获得连接以及释放资源我们都可以写到工具类中,还可以将配置信息提取到外部文件中,方便修改,

郭明杰:
JDBC的开发步骤
        1 加载mysql jdbc驱动
        Class.forName("com.mysql.jdbc.Driver");
        2 获得SQL连接对象
        conn=DriverManager.getConnection("","","");
        3 基本操作
        3.1获得执行对象
                statement=conn.createStatement();
        3.2获取结果集对象
                rs=statement.executeQuery("SQL语句");
        3.3遍历结果集
                while(rs.next){
                        rs.getxxx();
                        }
        4 释放资源
               

结果集       
        通过select语句查询的结果
工具类
        为了提高代码的复用性 创建一个工具类
资源释放
        将资源释放的代码写入到finally的代码块中

漏洞代码
        产生原因 在变量中存在SQL关键字 '' 会使sql语句发生修改!

漏洞解决
        使用PrepareStatement预编译对象进行解决

黄进安:

1.      不在main方法中对方法的测试方式;

2.       今天主要学习了JDBC--->java的数据库连接,是Java提供的一种访问数据库的标准规范

开发步骤:

l  导入驱动jar包

l  注册加载驱动 Class.forName("com.mysql.jdbc.Driver");

l  创建连接

Connection  conn= DriverManager.getConnection(“jdbc:mysql://localhost:3306/web_test”,”root”,”root”);

                   jdbc:mysql://jdbc连接MySQL数据库的协议------>类似于之前学习的http://协议

l  编写执行SQL语句(增\删\改\查)

l  获取SQL对象

Statemen t stmt = con.createStatement();

PreparedStatement pstmt  = con.prepareStatement(String sql)

---->具有防SQL注入漏洞的作用

l  执行SQL(

>>>如果获取的是PreparedStatement 对象,需要对PreparedStatement对象里的SQL语句设置值:

void setString(int parameterIndex, String x)

          将指定参数设置为给定Java String 值

       voidsetInt(int parameterIndex, int x)

          将指定参数设置为给定Java int 值

ResultSet executeQuery(String sql); 执行查询（执行select语句）

int executeUpate(String sql);  执行修改，添加，删除的SQL语句

l  释放资源

rs.close();

stmt.close();

con.close();

------------->从后往前逐一关闭

3.      为了提高编程效率以及代码的整洁,抽取了Java访问数据库方法程序中的共性代码,自定义JDBC工具类：JDBCUtils

工具类中定义的静态方法:

l  利用属性集properties以及构造静态代码块为静态成员赋值,并用final修饰

l  获取驱动的加载和注册的方法

l  建立连接的方法

l  释放资源的方法

4.      Properties属性集

Properties 可保存在流中或从流中加载

属性列表中每个键及其对应值都是一个字符串

StringgetProperty(String key)

          用指定的键在此属性列表中搜索属性

杜石苇
JDBC总结
JDBC就是 java链接使用数据库
SQL注入漏洞是利用Statement 传入的STR中有的SQL关键字 比如or来查询成功
解决方法是用PreparedStatement 单独设置要传入的变量来解决
JDBC 用来增删改查简单的来说就是
加载驱动
链接数据库
设置要执行的SQL语句  
传入SQL执行语句,获取返回结果(查询是有RS集合,
添加删除修改是返回修改了多少个结果的int值)
释放资源

设置JDBC工具类
首先设置  加载驱动方法
然后设置 链接数据库方法( 在里面添加前面设置的加载驱动的方法           有返回值 返回Connection对象)
最后设置 释放资源方法(用方法重载设置2个方法  一个传入RS结果集,PreparedStatement,Connection) 另一个传入(PreparedStatement,Connection)

颜琳琳

   JDBC是用于SQL语言的API,是由java语言的类和接口组成的.
   JDBC在使用时要先在项目文件下创建有个文件夹lib,然后将其jar包复制进去,然后使用build path进行转换成libranries进行使用.在使用时用到一个测试方法:@Test;(注意用来测试方法就不能使用main方法,使用@Test测试方法有个好处就是能创建多个测试方法进行使用可同时执行.)
   今天主要学了JDBC的是API中的:Connetion, PrepareStatement, ResultSet, 其中Connetion的作用是1. 获取SQL的对象; 2.管理事务.   PrepareStatement:执行SQL语句,并解决SQL注入漏洞(SQL注入的漏洞: 例如有个用户登录,然后有人知道其用户名然后使用   用户名+'or'1=1  和  用户名' -- 然后任意的密码就都可以进行登入,使用PrepareStatement来防止他人利用此漏洞来对其他用户的数据进行胡乱操作).     ResultSet是个结果集,在遍历结果集中使用.
JDBC使用的步骤:1.加载驱动,2.获取连接,3.执行SQL语句,4.释放资源(注: 释放资源必须在finally中执行,因为释放资源是必须要执行)
JDBC中还学习了CRUD的操作,即增删改查的使用,这些的使用中查和增删改查基本执行的方法相同,其中不同的是查中使用executeQuery()方法,而增删改是使用executeUpdate()方法.
由于学习的JDBC的CRUD的操作中的内容重复的太多,然后可以将其抽取出来进行封装成一个JDBCUtil工具类来进行使用,然后再将配置信息提取到配置文件.properties然后在util工具类中进行使用,最后在使用中进行调用就可以.(工具类中定义释放资源的方法需要有两个,因为增删改和查所释放的资源参数不同)

郑雪平

今天专门学习了JDBC这个内容,JDBC的意思就是java 数据库的连接桥梁,它是由一组JAVA语言写的类和接口组成的,由SUN公司提供标准规范.在进行JDBC操作前需先创建数据库和表,然后创建项目和引入JAR包,接下来就进入开发环节,开发前要先创建Test方法,开发过程分为五个步骤:1.加载驱动 ;2.获取链接 ;3.获取SQL语句对象;4.执行SQL语句;5.释放资源.
  还有也要先进行声明,进行增删改格式为:Connection  conn=null;  Statement statement=null; 进行查询操作的话还需加上 resultSet  rs=null这句;
在进行释放资源环节时,增删改只需释放两个资源即可:if (statement != null) {
                                try {
                                        statement.close();
                                } catch (SQLException e) {
                                        e.printStackTrace();
                                }

                                statement = null;
                        }

                        if (conn != null) {
                                try {
                                        conn.close();
                                } catch (SQLException e) {
                                        e.printStackTrace();
                                }
而进行查询操作时需在释放这两个资源的基础上再执行一次如下的资源释放 rs.close(); statement.close(); conn.close();
                       
                         if(rs !=null){
                       
                          try { //rs.close(); } catch (SQLException e) {
                        e.printStackTrace(); }
                        rs = null;
被执行所有的资源释放代码都需写在finally{}括号内

16weisong
今天主要学习JDBC,JDBC就是sun公司提供的一组用java连接数据库的接口,使用JDBC主要有5个步骤:加载驱动,获得连接,创建执行sql语句对象,执行sql,释放资源.其中第三步中为了解决sql注入的漏洞,我们使用PrepareStatement对象,它通过对'进行转义来防止sql注入,今天内容只要把JDBC5步骤搞清楚就可以

江某人:

注册驱动:
Class.forName("com.mysql.jdbc.Driver");
获得连接:
conn = DriverManager.getConnection("协议:子协议:///数据库", "账号", "密码");
创建执行sql语句对象:
cre = conn.createStatement();
编写sql语句:
String sql = "delete from user where id = 8";
执行sql语句:
int num = cre.executeUpdate(sql);
释放资源  如果是显示的   rs.colse();  conn..colse(); pst.colse();
          增删改     if(conn!=null){               pst.colse();
                        try{
                        conn.colse();       
                        }catch(Execption e){}
                        conn=null;
                     }

Properties p=new Properties ();   用了读取文本对象创建的对象
p.load(一个输入流  new FileInputStream(文件路径))
p.getProperty(文件key)返回一个key对应的值;
文件格式.properties,
      key1=值1
      key2=值2
      .........
   

侯玉林
今天讲了jdbc,就是用java操作数据库的一门技术.
sun公司向外提供了一套完整的接口规范jdbc.各个数据库厂商通过对jdbc接口的重写,实现了对数据库的操作.
由于数据库厂商实现了对jdbc的重写,所以我们可以直接通过多态对直接调用jdbc的实现类,进而操作数据库