黑马程序员技术交流社区
标题: 【厦门JavaEE就业1期-每日总结】JDBC [打印本页]
作者: 厦门校区 时间: 2018-5-27 19:59
标题: 【厦门JavaEE就业1期-每日总结】JDBC
同学们，今天学习了JDBC，我们从JavaSE，前端，数据库又重新回到了我们的Java代码。
今日需要掌握的有：
- 能够用自己的话阐述什么是JDBC？使用JDBC作用是什么？
- 能够用自己的话阐述什么是SQL注入漏洞并给出解决方法
- 独立完成使用JDBC的预编译对象进行CRUD操作(重点)
- 会使用JDBC工具类操作数据库
请同学们按照如上要求，总结今日所学。
作者: AsusCoder 时间: 2018-5-27 21:13
本帖最后由 AsusCoder 于 2018-5-28 08:37 编辑
曾耀峰
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;
作者: 许大炮 时间: 2018-5-27 21:20
许剑鸿 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类型数据 表示变动了几行)
事:释放资源
作者: 磬辰 时间: 2018-5-27 21:20
林文辉 总结
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
漏洞注入的问题。
作者: 厦门陈强 时间: 2018-5-27 21:20
陈强
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下的包,导包的错误,会使得代码异常和运行的结果报错!!!
作者: finfin12 时间: 2018-5-27 21:22
本帖最后由 finfin12 于 2018-5-28 23:08 编辑
张育辉
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连接对象时候,加载驱动并且获取连接;
作者: 六道的骸6 时间: 2018-5-27 21:26
张裕
今天学习了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
作者: q55w66 时间: 2018-5-27 21:34
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
作者: 渣.. 时间: 2018-5-27 21:37
柯威龙
JDBC是一种用java语言来实现数据库的一种语句.用java执行SQL语句.学习了几个字来实现JDBC的大部分步骤
贾(加载驱动)琏(获得连接)欲(获得预处理对象(编写SQL语句))执(执行SQL语句)事(释放资源).
五个字简单明了的说明了JDBC的步骤.中华文化博大精深.导致我今天学的比平常懂.
今天学了两种的增删改查.一种是简单的增删改查,增删改的代码其实都差不多,按照五个步骤来就可以了,
查的话有一个结果集,如果要遍历全部的话还要使用while循环.但是这种增删改查很容易引起SQL的注入
漏洞.安全性能较低.所以我们学习了PreparedStatement的增删改查.可以预防注入漏洞.两种的增删改查代码
大部分都是一样的.这样子的话我们学习创建工具类,把增删改查里面相同的代码提取到工具类里面.这样子可以
让代码看起来没有那么繁杂,比较的清晰易懂.
作者: 咸鱼coder 时间: 2018-5-27 21:38
万冕
今天学习了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来读取，
且给那些值赋值。
疯狂敲代码
作者: 李志勇 时间: 2018-5-27 21:43
李志勇:
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
.........
作者: seilye 时间: 2018-5-27 21:44
叶身辉:
今天学习了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;
}
另外加载驱动和获得连接以及释放资源我们都可以写到工具类中,还可以将配置信息提取到外部文件中,方便修改,
作者: 偏离X 时间: 2018-5-27 21:45
郭明杰:
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预编译对象进行解决
作者: 凉面要趁热吃 时间: 2018-5-27 21:47
黄进安:
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)
用指定的键在此属性列表中搜索属性
作者: rkko 时间: 2018-5-27 21:52
杜石苇
JDBC总结
JDBC就是 java链接使用数据库
SQL注入漏洞是利用Statement 传入的STR中有的SQL关键字 比如or来查询成功
解决方法是用PreparedStatement 单独设置要传入的变量来解决
JDBC 用来增删改查简单的来说就是
加载驱动
链接数据库
设置要执行的SQL语句
传入SQL执行语句,获取返回结果(查询是有RS集合,
添加删除修改是返回修改了多少个结果的int值)
释放资源
设置JDBC工具类
首先设置 加载驱动方法
然后设置 链接数据库方法( 在里面添加前面设置的加载驱动的方法 有返回值 返回Connection对象)
最后设置 释放资源方法(用方法重载设置2个方法 一个传入RS结果集,PreparedStatement,Connection) 另一个传入(PreparedStatement,Connection)
作者: Yanmo_ 时间: 2018-5-27 21:54
颜琳琳
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工具类中进行使用,最后在使用中进行调用就可以.(工具类中定义释放资源的方法需要有两个,因为增删改和查所释放的资源参数不同)
作者: 厦门黑马王子 时间: 2018-5-27 21:54
郑雪平
今天专门学习了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{}括号内
作者: lnongge 时间: 2018-5-27 21:55
16weisong
今天主要学习JDBC,JDBC就是sun公司提供的一组用java连接数据库的接口,使用JDBC主要有5个步骤:加载驱动,获得连接,创建执行sql语句对象,执行sql,释放资源.其中第三步中为了解决sql注入的漏洞,我们使用PrepareStatement对象,它通过对'进行转义来防止sql注入,今天内容只要把JDBC5步骤搞清楚就可以
作者: 滴滴eclipse启动 时间: 2018-5-27 21:56
江某人:
注册驱动:
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
.........
作者: 光宇 时间: 2018-5-27 21:56
侯玉林
今天讲了jdbc,就是用java操作数据库的一门技术.
sun公司向外提供了一套完整的接口规范jdbc.各个数据库厂商通过对jdbc接口的重写,实现了对数据库的操作.
由于数据库厂商实现了对jdbc的重写,所以我们可以直接通过多态对直接调用jdbc的实现类,进而操作数据库
作者: wpwing 时间: 2018-5-27 21:56
吴鹏
总结
----------------------------------------------------------------
一 什么是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值来对操作进行判断,提示操作是否成功;
释放资源;
作者: conan75 时间: 2018-5-27 21:57
今天对JDBC:java与database的连接进行了初步的学习,JDBC是java为数据库厂商提供的一组接口,在使用时有以下步骤:
贾:加载驱动 一般采用反射方法加载驱动(Class.forName("com.mysql.jdbc.Driver")),可以避免驱动的二次加载,提高代码运行的效率
琏:创建数据库连接对象 通过DriverManager.getConnection获取
欲:创建sql语句执行对象 通过connection对象调用方法获取(其中preparedStatement可以有效地避免sql注入漏洞)
执:执行sql语句 当需要进行DQL操作时,调用的方法与DML操作时存在区别,返回一个resultset集合,遍历需用到next方法
事:释放内存 释放资源时手动将资源置为null的目的是为了让垃圾回收机制更早地释放发现回收
作者: 13163997058 时间: 2018-5-27 21:57
本帖最后由 13163997058 于 2018-5-28 12:51 编辑
王刘锁
在艰难的学完数据库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{释放资源}给捕获才行!
作者: 郑学馨 时间: 2018-5-27 21:57
郑学馨
什么是JDBC:
是一个桥梁,用来连接数据库与我们的java语句的;
JDBC是sun公司定义的一个接口,规范各个不同的数据库厂商的
数据库,保证其能在java中正常使用
方法的重载:
方法名相同,参数类型不同,这样的额方法就叫做方法的重载
如何只用JDBC:
口诀:五步骤:贾琏欲执事
贾(加):加载jdbc的驱动也叫注册驱动,
琏(连):连接数据库<创建数据库连接>
欲(语):创建SQL语句
执(执):执行SQL语句
事(释):释放资源
五步骤代码表示:
贾(加):Class.forname("com.mysql.jdbc.Driver");
(连):connection
conn=drivermanager.getconnection(数据库路径,用户名,密码)
欲(语):创建SQL语句
string sql="sql语句";
pps=conn.preparestatement(sql)
设置sql语句中的值
pps.set(问号位置,要设置的值)
执(执):执行SQL语句
int i=pps.excuteupdate();增删改专用词
resultset rs=pps.excutequery();查询专用词
事(释):释放资源
增删改:conn.close()
pps.close();
查:conn.close()
pps.close();
rs.close()
注意:为什么在第三步时要用preparestatement代替statement?
因为用statement时会出sql注入,用preparestatement时
jvm在编译时会将特殊字符转移成字符串,避免出现sql注入
jdbc工具类的创建:
一:常量的创建
二:静态代码块:对上面常量进行赋值
三:提取出的方法的创建
作者: 2902 时间: 2018-5-27 21:58
今天学习了用java来操作数据库;增删改查,内容都比较相似,增删改除了执行的sql语句不同 其他的一样,五个步骤,
加载驱动;Class.forName("com.mysql.jdbc.Driver");
创建连接 DriverManager.getConnection("jdbc:mysql:///abc", "root", "root");
创建sql执行语句,执行sql语句,释放资源;
查询多了一个遍历结果集结果集;释放资源也要多释放一个结果集
作者: 5119 时间: 2018-5-27 21:59
游荣辉
总结
今天学习了JDBC (数据库连接)就是在Java中写SQL语句
想要使用JDBC 第一步就必须导包(.jar的文件)
他有固定的步骤
1.注册驱动 Class.forName("com.mysql.jdbc.Driver");
2.获得连接 Connection conn = DriverManager.getConnection(“jdbc:mysql://主机名:端口号/数据库的名称”,”数据库的用户名”,”数据库的密码”);
Connection con = DriverManager.getConnection(“jdbc:mysql:///数据库名称”,”数据库用户名”,”数据库密码”);
3.获得预处理对象 Statement stmt = con.createStatement();
4.处理结果集(只有查询的的时候有结果集,添加,删除,修改都没有)ResultSet rs = stat.executeQuery(sql);
添加,删除,修改使用 int num = stat.executeUpdate
5.释放资源 先判断资源是否为null, 不为null就是说明里面有东西,然后将他捕获,在手动设为null
还有sql注入的问题(把Statement改成prepareStatement就可以解决了)
如何使用呢
1.注册驱动
2.获取连接
3.获取预处理对象
String sql = "";(写入sql的增删改查的语句)
PreparedStatement stat = conn.prepareStatement(sql);
4.为sql语句设置实际参数
5.执行sql语句
6.遍历结果集
while(rs.next()){
System.out.println( rs.getString("sid")+"--"+rs.getString("sname"));
}
作者: Eclipse启动 时间: 2018-5-27 21:59
郑阳阳
JDBC是sun公司提供的一套统一的规范的接口.
使用JDBC首先需要加载驱动,需要使用DriverManager.
加载驱动 Class.fromName("com.mysql.jdbc.Driver");
DriverManager还有个作用是获得连接 DriverManager.getConnection(url,username,password);
url与数据库连接的路径,简写 jdbc:mysql:///数据库名称
username 数据库的用户名,password 数据库的密码;
获得连接返回一个Connection对象,Connection可以创建执行SQL语句对象,
Statement :可以执行SQL,不过不安全,有SQL注入漏洞.
CallableStatement : 执行数据库中存储过程,今天没有使用.
PreparedStatement : 也是执行SQL,可以对SQL实行预处理,可以防止SQL注入漏洞(一般使用这个).
Connection还有个管理事务的作用,今天没有使用.
Connection.PreparedStatement返回一个PreparedStatement对象.
Connection.PreparedStatement(SQL)需要传入一个SQL语句,SQL的参数需要使用?号代替
修改例:update 表名 set name=? where id=?;
PreparedStatement对象调用setString可以给?号赋值,set后面根据数据类型改版
PreparedStatement调用executeUpdate返回一个int值,表示被修改的行数,适用与增删改
PreparedStatement调用executeQuery返回一个ResultSet对象.适用查找
ResultSet是一个结果集,可以遍历结果集拿到表的数据.
JDBC的增删改查
增删改查大致步骤差不多
1.加载驱动 2.获取连接 3.编写SQL语句 4.SQL的预处理 5.释放资源
增删改需要在编写后给定参数
释放资源的标准写法:
Connection,PreparedStatement,ResultSet需要释放资源.
Connection对象稀有需要晚创建,早释放.
if(需要关流的对象!=null){
try{
对象.close();
}catch(SQLException e){
e.printStackTrace();
}
}
对象=null;
JDBC的工具类:
就是把增删改查中重复的代码抽取出来,有加载驱动,获得连接和释放资源
工具类中需要用到的参数可以通用配置文件使其更好更改.
配置文件的拓展名是.properties 内容是:key=value
使用的时候在静态代码块中创建Properties对象,使用load方法可以输入配置文件路径,
然后使用getProperty(key)赋值.
差不多就这些了.
作者: 沅瞻 时间: 2018-5-27 21:59
詹源
今天学习了JDBC的一些初步运用
JDBC用于应用和数据库之间的连接,由一组JAVA语言编写的类和接口组成.
JDBC是一套规范,有了JDBC,程序员无需在开发不同系统时,为了连接不同数据库,
而去了解不同数据库驱动的API.SUN公司提供JDBC这个规范(接口),各个数据库生产商则
提供JDBC的实现.有了JDBC,使得开发系统时候,连接数据库更加便捷,节约开发成本.
今天的重点在于,利用JDBC进行对数据库表的增删改查.
要使用JDBC,首先要在项目内引入jar包
JDBC开发步骤分四步:
第一步:加载驱动 Class.forName("com.mysql.jdbc.Driver");
第二步:获得连接 创建Connection对象.与数据库建立连接
第三步:基本操作 创建Statement对象执行SQL语句,然后编写SQL语句,执行语句
第四步:释放资源 Connection对象关闭!Statement对象关闭!如果有执行查询功能ResultSet对象也关闭!
代码中的加载驱动,获取跟数据库的连接,释放资源等操作,存在大量重复.因此可以抽取出来放在工具类中
JDBC存在SQL注入漏洞,需要采用PreparedStatement 对象解决这个问题.
作者: 小故事 时间: 2018-5-27 22:00
谢洪彬:
今天学习了JDBC,学习了这个最大区别就是可以将前两天学的数据库在java上进行操作,而JDBC的运用又可以分为4个步奏:
4步奏:
1.加载
先找到对应的.jar架包导入java工具中
利用ClassforName(com.mysql.jdbc.Driver);加载
2.连接
利用conn = DriverManager.getConnection(url,username,password);获取连接对象
3.操作
利用ppatt = conn.prepareStatement(sql);获取操作sql对象,并传入sql对象.
4.释放资源
Close()释放资源;
增删改使用executeUpdate()方法,并且释放资源时只要释放两个
查询使用executeQuery()方法,但是释放资源需要释放三个,应为查询多出了结果集,结果集也是需要遍历调用get类型拿到相应的值.
JDBC工具类,就是把重复的代码抽取出来,减少代码复用性.
还可以将主机名,用户和密码像类似与键值对的样子存储到.properties文件中,这样操作起来方便,可读性高.
作者: chenyelong 时间: 2018-5-27 22:02
陈叶隆
用@Test注解可以不写main方法;
Part i:JDBC开发步骤：
1加载驱动: Class.forName("com.mysql.jdbc.Driver");
2.获得连接:Connection conn = DriverManager.getConnection(“jdbc:mysql://localhost:3306/db1”,”root”,”root”);
3.获得处理语言对象: PreparedStatement ppsm = conn.prepareStatement(sql);
4.执行操作: ppsm.setString(1, "数码产品");ResultSet rs = ppsm.executeQuery();while( rs.next() ){
System.out.println( rs.getInt("id")+"--"+rs.getString("name"));
}
5.释放资源: rs.close();stmt.close();con.close();
Part ii:配置文件:
Properties prop=new Properties();
prop.load(new FileInputStream(“src/db.properties”));
url=prop.getProperty(“url”);
作者: LittleSky 时间: 2018-5-27 22:34
常小天
今天学习的是JDBC的内容。JDBC是将java和数据库连接起来的桥梁。使用JDBC可以让我们在java中来操作数据库。JDBC是一组接口，也就是一组规范。各数据库在驱动中实现这组接口，从而达到各种不同的数据库都能接入到java语言中进行操作。使用JDBC的步骤为：加载驱动、获取连接、创建sql语句对象、编写并执行sql语句、最后释放资源。加载驱动时采用获取驱动类的class对象的方式加载驱动，因为Driver类中的静态代码块中会加载一次驱动。获取连接的方法是DriverManager中的静态方法getConnection（），该方法中有三个参数，URL为要连接的数据库的路径，后两个为用户名和密码。之后通过连接对象调用方法获得语句对象，这里要采用可以解决SQL注入漏洞的preparedStatement（）对象。接下来预编译SQL语句，注意别漏了问号。执行增删改操作使用executeUpdate()，返回受影响的行数，判断返回值是否大于0来确定是否操作成功，执行查询操作使用executeQuery()，返回值为结果集，遍历结果集并输出。此外有两点注意的地方，一是导包要到导java.sql下的包，不要导错，二是在配置属性文件时，属性文件中的信息末尾不要加任何多余的符号，尤其是不要加空格，会特别难检查出来。
作者: 名字被人注册了 时间: 2018-5-27 22:47
刘文峰
Jdbc是一套接口规范,为了避免当我们要使用java连接不同数据库时都要学习不同数据库的语法而产生的.
sql注入漏洞是指在登录网站时在知道用户名的情况下输入 用户名’ or ‘1=1 即可不要密码就能登录.解决方法是不使用Statement 改为使用PreparedStatement来执行sql语句.他会在sql语句执行前进行一次预编译,从而避免sql注入漏洞的发生.
使用预编译对象进行增删改查
第一步 加载驱动 Class.forName(“com.mysql.jdbc.Driver”);
第二步 获得连接
Connection conn = DriverManager.getConnection(“jdbc:mysql://主机地址:端口号/数据库名称”,用户名,密码);
第三步 预编译对象执行操作 PreparedStatement;
首先编写sql语句 :String sql = “sql语句”;
接着获得预编译对象 PreparedStatement pstmt = conn.PreparedStatement(sql);
Sql语句里的部分参数可以用?代替;我们可以给?号赋值
例如 pstmt.setString(1, “aaa”); 1是指第几个?号,”aaa”是设置一个字符串类型的值,
SetString()可以给字符串赋值,setInt()可以给int类型赋值等等有很多个方法可以给不同类型的参数赋值;
然后执行sql语句 :pstmt.executeUpdate();可以进行增删改操作;返回收影响记录的数量,我们可以进行判断,如果大于零,则操作成功,否则操作失败.
Pstmt.executeQuery();可以进行查询语句操作, 返回一个结果集(ResultSet,只有查询会有),可以遍历结果集查看获得的数据
最后一步是关流. 创建的三个对象都需要关流,关流的方法都一样,只是对象不一样
If(conn.next() !=null ){
Try{
Conn.close();
}catch(Exception e) {
e.printStackTrace();
}
}
作者: sts 时间: 2018-5-27 23:00
苏海斌
JDBC就是让SQL语句能在Java代码中执行,
步骤是贾琏欲执事,
贾:加载驱动
琏:获得链接
欲:获得语句对象
执:执行语句
事:释放资源
我们操作JDBC代码会 存在注入漏洞,也就是安全性低,存在风险,所以用PreparedStatement来解决这一问题,
作者: 1748341437 时间: 2018-5-27 23:06
2018/5/27 林玮
今天讲了一个JDBC,我知道了什么是JDBC,它是干嘛用的,它要怎么用,
什么是JDBC?JDBC是一个能连接两个应用的接口规范.它是由Sun公司提供的为了方便程序员操作java连接各种数据库,反正我是这么理解的.
JDBC有什么用?
通俗来讲就是连接了
(重点)JDBC要怎么用?
在进行操作之前要先导入驱动jar包,然后在java软件中编写代码,但和之前的的代码稍有不同,它的入口函数不是main方法,是test测试方法.
注意:1.有test方法就不能有main方法;2.test方法的开头必须要有@Test;3.test方法不能用static修饰;4.当一个类里有多个test方法时,方法名不能相同.
JDBC主要用法就是让java连接到数据库从而对数据库进行增删改查操作,他们的代码大致上一样除了查的代码会多一个ResultSet结果集,有一个会打了,其他就也会打了.大致结构:注册驱动--获取连接--创建sql对象--编写sql语句--执行sql语句--释放资源.这是基本结构,缺点有:代码不够简洁,安全性低; 不够简洁主要是因为他们之间代码大部分相同,解决方法:提取代码到工具类. 安全性低是因为代码会有sql注入漏洞,解决方法:这个就简单了,之前我们用的都是Statement对象,改用PreparedStatement就好了,因为Statement只能执行SQL语句,而PreparedStatement既能执行SQL,还能对SQL进行预处理,也就是对SQL提前处理,这就解决了SQL注入漏洞的安全问题.
作者: Nevermo 时间: 2018-5-27 23:36
许煜
每日总结
JDBC Java Date Base Conncetivity直译 java与数据库的连接驱动器
增删改查CRUD create research update delete 四个案例遵循以下步骤
1 加载驱动 通过反射加载 Class.forname(“com.mysql,jdbc.Driver”)
2创建连接对象 drivermanager.getconnection()
3 创建语句对象 conncetion.createpreparedstatement();
4 编写sql语句 string str=”sql语句”;
5执行语句 增删改executeupdate() 查executequery() 用resultSet接收
6释放资源 写进finally代码块
抽取共性创建jdbcutils工具类使用起来更加简便
Preapredstatem是通过使用转义符使特殊符号失效,防止sql注入.
今天学习的内容主要意义在于了解通过java程序修改数据库的基础内容.毕竟以后开发的时候基本上不可能是使用控制台或者数据库可视工具手动来修改数据库,基本上都是靠程序对各种情况进行判断然后执行相应程序对数据库的数据实现修改.今天的内容之于以后的学习的意义更像是一把钥匙或者一扇门.以后不管是使用高级的框架或者工具类来实现java程序修改数据库,但是我觉得底层内容应该就是这些.
作者: 李成林 时间: 2018-5-27 23:41
李成林
总结 JDBC
java连接mysql数据库的步骤
加载驱动:
Class.forName(jar包);
创建连接:
Connection conn=DriverManager.getConnection();
创建执行事务
Statement stmt= conn.createStatement;
创建sql 查询语句
String sql = "select *from emp ";
创建结果集
resultSet rs= stmt.executeQuery(sql);
遍历集合
.......
sql的语句
添加语句格式
String sql="insert into emp values(.......)"
删除语句格式
String sql = "delete from emp where ........"
修改语句格式
String sql ="updete emp set ............";
作者: zzx835387607 时间: 2018-5-27 23:41
郑志祥（day10jdbc）
能够用自己的话阐述什么是JDBC？使用JDBC作用是什么？
JDBC是由sum公司提供的一套规范的借口，（让所有的数据库厂商都通用的接口）
数据库驱动；两个设备之间的沟通桥梁。
能够用自己的话阐述什么是SQL注入漏洞并给出解决方法？
SQL漏洞的产生是在用户名填写入了
aaa’ or ‘1=1 密码随意(方式一）
aaa’ -- 密码随意（方式二）
"select * from user where username = '"+username+"' and password = '"+password+"'"
Statement对于sql语句字符串只能进行拼接，容易出现SQL漏洞注入
解决方式；PreparedStatement则可以使用占位符 ?，通过这个来代替字符串拼接，解决了SQL漏洞注入的问题。
// 编写SQL语句:
String sql = "select * from user where username = ? and password = ?";
// 预编译SQL
pstmt = conn.prepareStatement(sql);
// 设置参数:
pstmt.setString(1, username);
pstmt.setString(2, password);
注释1,2,代替的？的位置，从1开始，跟索引区别
独立完成使用JDBC的预编译对象进行CRUD操作(重点)
1,加载驱动
2,获得连接
3,获得语句对象
4.执行代码
5,释放资源
如果是查找记得加上ResultSet结果集，多个查找用while遍历，如果是单个查找用if语句，还学学习了抽取工具类（不是很明白），大概知道是为了减少代码的重复性，而进行优化，
作者: it小白001 时间: 2018-5-27 23:48
吴俊斌
jdbc就是sun公司提供的接口,用java和数据库之间通信的桥梁
一般步骤:贾琏欲执事
1.加载驱动
就是通过Class.forName("com.mysql.jdbc.Driver");
2.获得连接
Connection 变量名=DriverManager.getConnection("jdbc:mysql://ip地址:端口/数据库名","用户名",密码);
3.创建Sql语句对象
Statement 变量名=连接对象名.createStatement();
4.执行sql语句
查询的方法是:sql对象.executeQuery("sql执行语句")得到一个结果
可以遍历它.
while(结果对象.next){
用对象.getString等获取想要输出的内容
}
5.释放资源
就是把对象.close
这会产生漏洞注入,解决方法就是使用preparedStatement代替,将有可能出现问题的用?号代替.再通过setString之类的方法
替换.这样在用户输入符号就会转成普通没有特殊意思的字符
作者: hpb199567 时间: 2018-5-27 23:51
何平波
JDBC
1.什么是JDBC? 一套被规范的接口
java database connection (java与数据库的连接)
可以让我们在java代码中写sql语言,用java代码操作数据库.
2.精髓 贾琏欲执事
(1)引包 导包
5行代码步骤
1.加载驱动
class.forname("jdbc包的路径")
2.获得连接: drivermanager.getconnection
写法:Connection conn =drivermanager.getconnection("url","数据库账户","数据库密码") 这里需要connection接受获得
Connection:和数据库连接的对象
作用:1.创建执行sql语句
2.管理实务..
url:与数据库连接的路径 jdbc:mysql://localhost:3306/数据库名
jdbc:连接数据库的协议
mysql:是jdbc的子协议
localhost:3306 连接的mysql数据库服务器的主机地址
3306:mysql数据库服务器端口号
user:与数据库连接的用户名
passwo:与数据库连接的密码
注意:1.这里的localhost:3306连接的是自己的主机,如果连接的是其他主机的数据库填入的是其他主机的IP地址.
2.url中间的localhost:3306是可以省略不写的,因为这里连接的是自己的主机名.但不推介这种方式.
获得语句对象
3.获得执行sql语句的对象 Statement Statement = conn.createStatement();
编写sql语句
执行sql
遍历结果集
释放资源
3.工具类的抽取
注册驱动的方法:void 捕获注册方法
获得连接的方法:将驱动一并注册, 路径账户密码
返回注册对象 方法一样
释放资源的方法
释放资源 两个 或 3个
(statement , connection ) 两个或3个参数
这种方法经常需要修改数据
私有的final来修饰需要床数据的对象 如注册 路径 账户 密码
然后放在静态代码块里
作者: 黄志彬 时间: 2018-5-28 00:06
黄志彬
今天学习了JDBC 就是Java的数据库（DataBase）接口（ Connection），是两个应用之间的通信桥梁。
Connerction 作用： 创建执行SQL语句，管理事务
jdbc开发的5个步骤：贾琏欲执事
1加载驱动。成功加载后会将driver类的示例注册到DriverManager类中
2获得连接
3获得语句对象 编写sql,创建语句查询对象,执行sql,遍历(查询)
4执行语句。 Statement接口提供了三种执行SQL语句的方法，executeQuery （查）和executeUpdate（增删改）及 execute。
5释放资源。 操作完成后要把所有使用的JDBC对象全部关闭，以释放JDBC资源，关闭顺序和声明顺序相反
注意，导包的话要导java.sql下的包，测试方法不加静态修饰
。
JDBC的增删改查
修改操作
设置参数里面的数是从1开始的，而不是索引
工具类的提取和配置文件：
JDBC所需要的四个参数（用户名， 密码， URL，driverClass驱动）
获取属性文件中的内容 为常量赋值
java中有一个对象Properties可以获得属性中的内容
解析属性文件中的内容要调用load方法 方法里面传入输入流
使用对象properties调用getProperty（传入属性文件中的key）,获取到的值赋给JDBC所需要的四个参数
命名规则：除了数据，其他的尽量不要写中文，安装目录也不要写中文
作者: 张述明 时间: 2018-5-28 00:10
张述明
今天学习了Jdbc
jdbc 是SUN公司提供的一套接口规范.
今天主要对jdbc的基本操作,包括增删修查
重点要掌握的内容 Connection Statement ResultSet preparedStatement
Jdbc的开发步骤
贾琏欲执事
贾 加载驱动
琏 获得连接
欲 创建SQL语句
执 执行sql语句
事 释放资源
加载驱动 Class.forName(“com.mysql.jdbc.Driver”);
获得连接 DriverManager.getConnection(“url”,”username””password”)
释放资源 分成两种 如果有结果集 就要多释放一个ResultSet
增删改没有结果集 在执行语句可用executeUpdate(sql) 返回一个int类型值
只有查询有 查询在执行语句用executeQuary (sql)返回一个String类型
由于今天的许多代码重复,所以可抽取工具类中,然后在测试中调用方法
重复的代码主要是加载驱动,获得连接,和释放资源
将可变的元素抽取到prpperties文件中 如url,username,password,DriverclassName;
preparedStatement 是为了解决sql的注入漏洞 将sql中的操作对象用?代替,然后调用set方法来赋值,解决了sql的注入漏洞的问题.
作者: 一梦 时间: 2018-5-28 00:17
陈世彪:
今天学习了JDBS
JDBS是java和数据库进行连接的桥梁
JDBS的作用是可以为多种数据库提供统一访问,是一种标准,节约开发成本
SQL注入漏洞是通过已知的用户名直接进入到系统当中去,不用输入密码
解决方法:prepareStatement,这个对象将SQL预先进行编译，使用?作为占位符。再次传入变量,这个时候就不会再识别这些关键字。
使用JDBC进行编译时分为:
打开驱动
Class.for("com.mysql.jdbc.Driver")
获取连接对象
DriverManager.getConnection("jdbc:mysql://localhost:3306/classsql","root", "root");
获取执行语句的对象
conn.createStatement()
执行语句并处理数据
statement.executeQuery(sql);
释放数据操作相关对象
.close
结果集为ResultSet rs。使用while(rs.next())遍历是否有下一个数据
使用prepareStatement 可以使用setString()来设置数据,第一个是指第几个? 第二个是要设置的值
?也是来表示占位符
作者: 李思贤126 时间: 2018-5-28 00:33
李思贤:今天学习了JDBC(java database connectivity),它是连接java与数据库的一座桥梁.
注意:使用JDBC 必须先导入jar包.
JDBC基本使用步骤:贾琏欲执释{
1.加载驱动 Class.forName("com.mysql.jdbc.Driver");
2获得连接 conn=DriverManager.getConnection("...","root",""123456");
3.获得执行SQL语句对象 statement=conn.createStatement();
4.执行SQL语句 rs=statement.executeQuery("SQL语句");
5.释放资源
}
CRUD的操作,即增删改查的使用,这些的使用中查和增删改查基本执行的方法相同,不同的是查询使用executeQuery(),增删改使用executeUpdate().
由于操作中的内容重复的太多,然后可以将其抽取出来进行封装成一个JDBCUtil工具类来进行使用.
将配置信息提取到配置文件.properties然后在util工具类中进行使用,最后在使用中进行调用就可以
(工具类中定义释放资源的方法需要有两个,因为增删改和查所释放的资源参数不同)
作者: 追风筝的人哇 时间: 2018-5-28 00:52
康元中
1 JDBC : 是一个接口作用是 java程序访问数据库的一个桥梁. 大大降低程序员学习负担
(因为数据库有上百种如mysql 和Oracle 等如果要开发一个系统要是用某个数据库就得学习该数据库的
各种驱动 所以sun公司提供了一套规范,每个数据库的生产商提供这套规范的实现 )
2 SQL注入漏洞是 : 使用statement时为了不使得数据写死,使用字符串拼接的方式书写sql语句,
但是传入的字符串中有带有单引号的字符漏洞 就改变了sql拼接语句中的含义,使得出现漏洞
通过prepareStatement预编译可避免sql注入漏洞
解决sql注入漏洞方法是 使用PreparedStatement 就可以吧解决,因为该对象方法中已经
对输出的特殊符号进行处理 .通过?占位符固定了sql语句的格式.
3JDBC的编译对像进行CRUD操作
步骤: "贾琏欲执事""的记忆步骤
加载驱动
获取连接对象
编写sql语句
获取sql执行对象
释放资源
作者: ...ylq 时间: 2018-5-28 01:19
叶凌青
今天主要学习了JDBC
什么是jdbc,自我理解就是一组接口,一些规范
导入驱动jar包
开发步骤：
1注册驱动
Class.forName("com.mysql.jdbc.Driver");
类加载到内存，该类的静态代码将自动执行。
2.获得连接
Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);
3.获得预处理对象
Statement stmt = con.createStatement();
常用方法：
int executeUpdate(String sql); --执行insert update delete语句.
ResultSet executeQuery(String sql); --执行select语句.
boolean execute(String sql); --执行select返回true 执行其他的语句返回false.
4.处理结果集，执行select的时候需要（执行insert、update、delete无需处理）
ResultSet rs = stat.executeQuery(sql);
5.释放资源
rs.close();
stmt.close();
con.close();
从后往前，逐个关闭
总结:开发步骤贾莲欲执事
作者: 丶犯二 时间: 2018-5-28 07:44
任佳锋
JDBC 数据库连接接口,是一种用于执行SQL语句的JavaAPI,统一规范了多种关系数据库的访问方式.
使用JDBC前需要先将jar包导入,通过才行
JDBC的一般开发步骤为:
(贾琏欲执事)
贾1.加载驱动
Class.forName("com.mysql.jdbc.Driver")
琏2.获得连接
Connection conn = DriverManager.getConnection("jdbc:mysql:///数据库名", 数据库用户名, 数据库密码
);
欲3.编写sql语句
String sql = "写入需要的sql语句";
执4.执行sql语句
Statement(存在sql注入漏洞)
PreparedStatement(预编译避免sql注入漏洞的产生)
事5.释放资源
通常将ResultSet,Statement,Connection等对象要释放的资源代码写到finally中
if(rs !=null){
try {
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
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();
}
conn = null;
}
JDBC工具类
由于开发过程中重复代码很多,因此可以抽取重复代码编写出工具类,减少代码量,提高代码的复用性.
测试工具类时使用test测试,写入test通过Alt＋斜杠的快捷方式调用
作者: 376091692 时间: 2018-5-28 08:25
凌辉
今天学习了jdbc
jdbc是一种执行sql语句的javaAPI,
步骤是:
1加载驱动;
2 获得连接;
3 基本操作;
4 释放资源;
学习了sql漏洞,解决办法是需要采用PreparedStatement对象解决SQL注入漏洞。
这个对象将SQL预先进行编译，使用?作为占位符,
所代表内容是SQL所固定。再次传入变量（包含SQL的关键字）。
这个时候也不会识别这些关键字。
作者: 柯建程 时间: 2018-5-28 08:27
柯建程
JDBC 是java与数据库的桥梁,可以再java中写sql,用java操作数据库
接口规范
驱动:两个设备(应用)之间通信的桥梁
1创建数据库
2创建项目,引入jar包
五行代码
加载驱动
class.forname(com.mysql.jdbc.driver)
获得连接
connection conn=drivermanager.getconnection();
语句对象
statement sta=conn.createstatemen();
(编写sql)String s="";
执行
查询 resultset rs=sta.executequery(s)
增删改 int i=sta.executeupdate(s)
释放
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
statement = null;
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
作者: doudou0606 时间: 2018-5-28 08:47
施炎生
开发步骤（贾琏欲执事：
1注册驱动
Class.forName("com.mysql.jdbc.Driver");
2.获得连接
Connection con = DriverManager.getConnection(“jdbc:mysql://localhost:3306/mydb”,”root”,”root”);
3.获得预处理对象
常用方法：
int executeUpdate(String sql); --执行insert update delete语句.
ResultSet executeQuery(String sql); --执行select语句.
boolean execute(String sql); --执行select返回true 执行其他的语句返回false.
4.处理结果集，执行select的时候需要（执行insert、update、delete无需处理）
ResultSet rs = stat.executeQuery(sql);
5.释放资源
rs.close();
stmt.close();
con.close();
作者: 林荣彬 时间: 2018-5-28 08:49
林荣彬
今天学习了JDBC,主要学习了JDBC的开发步骤和在JDBC中增删改查的操作,学习PreparedStatemet执行SQL.对SQL进行预处理。解决SQL注入漏洞。
需要导入驱动包
JDBC的开发步骤:可以用一句话概述"贾琏欲执事"
1.加载驱动
Class.forName("com.mysql.jdbc.Driver");
2.获得连接
onn = DriverManager.getConnection("jdbc:mysql://localhost:3306/web_test3", "root", "abc");
3.获得执行SQL语句对象
Statement statement = conn.createStatement();
4.执行SQL
int num = pstmt.executeUpdate();
5.释放资源
conn.close();
作者: wahahaha 时间: 2018-5-28 08:58
林恒山
jdbc是sun公司提供的java与数据库之间通信的接口.
mysql实现jdbc的5个步骤:贾琏欲执事.也就是1:加载驱
动;2创建连接3获得执行sql语句的对象;4执行SQL语句;5释
放资源.
jsbc的增删改查的步骤是
1.加载驱动Class.forName("com.mysql.jdbc.Driver");
2.创建连接conn = DriverManager.getConnection
("jdbc:mysql://localhost:3306/db1", "root",
"root");
3获得执行sql语句的对象:
首先写sql语句;
Statement state=conn.createStatement();使用这个
createStatement()会产生sql注入漏洞,要使用
PreparedStatement pstmt=conn.prepareStatement(sql)
4执行sql :调用executeUpdate()
5释放资源. 关闭Connection和PreparedStatement.
增删改的区别只是在写sql语句上有区别.而查会有一个
ResultSet结果集,执行sql语句的时候使用的是
executeQuery(),最后释放资源的时候ResultSet也要释放
掉.
增删改查的代码重复性太多,抽取到工具类中,可以把注册驱
动/创建连接/释放资源放到工具类中.
sql注入漏洞的解决方法:使用PreparedStatement
pstmt=conn.prepareStatement(sql).
作者: 望蜀 时间: 2018-5-28 10:30
JDBC Java Database Connectivity
sun公司提供的一组接口规范
Java和数据库的桥梁:可以让我们在Java代码中写sql,使用JAVA代码操作MySQL数据库
没有JDBC的时候 要开发一套系统,Java程序员需要了解很多数据库驱动API
开发步骤:
贾琏欲执事
加载驱动
获得连接
获得sql语句的对象
执行sql语句
释放资源
connection:1.获取语句对象 2.管理事务
drivermanager:1.获取连接 2.注册/加载驱动
statement:1.执行sql 2.批行处理sql语句
工具类的抽取 减少不必要的重复
用PreparedStatement对象解决SQL注入漏洞。它将SQL进行预编译，使用?作为占位符。?所代表内容是SQL所固定。再次传入变量（包含SQL的关键字）。这个时候也不会识别这些关键字。
注意:导包要全部导java.sql下的包 不要导jdbc的包
作者: COLDER 时间: 2018-5-28 16:43
本帖最后由 COLDER 于 2018-10-18 19:14 编辑
Day10
今天的学习内容为JDBC入门,JDBC的开发步骤,JDBC的两种增删改查方式.
JDBC(Java Date Base Connectivity):Java数据库连接,它是一组接口,由Java编写而成,作用:为不同的关系型数据库
提供统一的访问,JDBC可以通过执行SQL语言来对数据库中的数据进行操作.
JDBC的开发步骤:加载驱动,获得连接,获得执行SQL的对象,编写SQL,执行SQL,释放资源(贾琏欲执事)
加载驱动:Class.forName("com.mysql.jdbc.Driver");
获得连接:conn = DriverManager.getConnection(url,username,password);
获得执行SQL对象:stmt = conn.createStatement();
编写SQL:String sql = "SQL语句";
执行SQL:stmt.excuteUpdate(sql)(对数据库中的数据记录进行增删改操作)
stmt.excuteQuery(sql)(对数据库中的数据记录进行查询操作)
释放资源:conn.close();stmt.close();
JDBC的两种增删改查方式:Statement,preparedStatement
区别:使用statement方式对数据库中数据进行读取操作,缺乏安全性(案例:账号密码登录),Statement和preparedStatement
在开发步骤上也有区别,statement是先获得执行SQL语句的对象,再编写SQL,而preparedStatement是先编写SQL语句,再
预编译SQL,设置参数.
今天的重点主要是掌握使用预编译方式对数据库的数据进行增删改查.
作者: Do1 时间: 2018-5-30 19:04
本帖最后由 Do1 于 2019-11-23 00:35 编辑
JDBC是java连接mysql数据库的aip工具,通过jdbc可以从mysql数据库中提取数据,使用时需要导入mysql包
原始的连接方式为:
1.Class.forName(Stirng)
从指定的com包加载驱动
2.Connection conn=DriverManager.getConnection(URL,USER,PASS);
创建连接,需要传入的参数为Mysql数据库的URL地址,这里的地址包含了你所要使用的指定数据库名称,以及用户名和密码
3.Statement stmt=conn.createStatement();
实例化mysql对象
stmt.executeQuery(String sql);
传入sql语句,如果是查询的话就用一个ResultSet集合来接收并且使用executeQuery方法
如果是增删改的话可以用int类型来接收,判断是否添加成功,int类型收到的是表中受影响的row数,使用executeUpdate;方法
SQL注入漏洞是因为实例化对象编译sql语句时传入的是一个字符串,这个字符串就代表sql中的语句,通过注入漏洞将判定语句中的and 给隔开了,如果加一个or进去的话 就可以随意输入密码,解决方法是使用比Statment更高级的Statment的子类PreparedStatement,它可以预编译sql,设置参数,安全性高
作者: avip0000 时间: 2018-6-4 17:35
白有旺
JDBC是JAVA连接数据库的途径 普通连接的话 每次访问都会创建一次连接 所以使用连接池
连接池 需要导包 有Druil c3p0 dbutlis 等
| 欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) |
黑马程序员IT技术论坛 X3.2 |