jdbc知识点(连接mysql)
jdbc连接mysql
1.JDBC简介
JDBC:
指 Java 数据库连接,是一种标准Java应用编程接口( JAVA API),用来连接 Java 编程语言和广泛的数据库。从根本上来说,JDBC 是一种规范,它提供了一套完整的接口,允许便携式访问到底层数据库
常见的 JDBC 组件:
JDBC 的 API 提供了以下接口和类:
DriverManager :这个类管理一系列数据库驱动程序。匹配连接使用通信子协议从 JAVA 应用程序中请求合适的数据库驱动程序。识别 JDBC 下某个子协议的第一驱动程序将被用于建立数据库连接。
Driver : 这个接口处理与数据库服务器的通信。你将很少直接与驱动程序互动。相反,你使用 DriverManager 中的对象,它管理此类型的对象。它也抽象与驱动程序对象工作相关的详细信息。
Connection : 此接口具有接触数据库的所有方法。该连接对象表示通信上下文,即,所有与数据库的通信仅通过这个连接对象进行。
Statement : 使用创建于这个接口的对象将 SQL 语句提交到数据库。除了执行存储过程以外,一些派生的接口也接受参数。
ResultSet : 在你使用语句对象执行 SQL 查询后,这些对象保存从数据获得的数据。它作为一个迭代器,让您可以通过它的数据来移动。
SQLException : 这个类处理发生在数据库应用程序的任何错误。
JDBC 4.0 软件包:
JDBC 4.0 主要包含 java.sql 包和 javax.sql 包,提供的主要类与数据源进行交互。
2.JDBC SQL语法
SQL语法:
结构化查询语言(SQL)是一种标准化的语言,可以让你对数据库进行curd操作,如创建项目,读取内容,更新内容和删除项目。SQL 支持你可能会使用到的任何数据库,它可以让你编写独立于底层数据库的数据库代码
创建数据库语法:create database 数据库名;
如:create database hejh;
删除数据库语法:drop database 数据库名;
如:drop database hejh;
注意:1.创建或删除数据库,必须有数据库服务器的管理员权限;
2.删除数据库会把存储在该数据库中的数据一并删除。
创建表语法:
create table 表名(
字段名1 字段类型1,
字段名2 字段类型2,
......
);
建表示例:
create table hejh(
id int not null,
age int not null,
frist varchar(20),
last varchar(20),
primary key(id)
);
删除表语法:drop table 表名;
如:drop table hejh;
insert语法:insert into 表名 values(字段值1,字段值2,...); --(这种方式默认插入所有字段的值)
如:insert into hejh values(1,22,'19990405','20190505');
select语法:select 字段1,字段2,... from 表名 where 查询限制条件;
如:select * from hejh where id=1; 注意:WHERE 子句可以使用 =,!=,<,>,<=,>=,BETWEEN 和 LIKE 这些比较操作符。
update语法:updata 表名 set 字段=字段新值 where 条件;
如:update hejh set age=33 where id=1;
注意:where子句可以使用=,!=,<,>,<=,>=,between和 like 这些比较操作符。
delete语法:delete from 表名 where 条件;
如:delete from hejh where id=1;
注意:where子句可以使用=,!=,<,>,<=,>=,between 和 like 这些比较操作符
3.设置JDBC使用环境
在开始使用 JDBC 之前,必须设置 JDBC 环境。(以mysql、windows系统为例)
1.安装jdk,配置环境变量;
2.安装mysql数据库;
3.安装eclipse;
4.JDBC简单示例
创建数据库:hejh;
create database hejh;
创建用户表:user表
create table user(
id int(5) not null,
username varchar(20) not null,
gender varchar(4),
primary key(id)
);
初始化数据:
创建JDBC应用程序
构建一个 JDBC 应用程序包括以下六个步骤:
导入数据包:导入含有需要进行数据库编程的 JDBC 类的包。大多数情况下,使用 import java.sql.就足够了。
注册 JDBC 驱动器:需要你初始化一个驱动器,以便于你打开一个与数据库的通信通道。
打开连接:需要使用 DriverManager.getConnection() 方法创建一个 Connection 对象,它代表与数据库的物理连接。
执行查询:需要使用类型声明的对象建立并提交一个 SQL 语句到数据库。
提取结果数据:要求使用适当的 ResultSet.getXXX() 方法从结果集中检索数据。
- 清理环境:依靠 JVM 的垃圾收集来关闭所有需要明确关闭的数据库资源。
查看数据库hejh中user表的数据有3条:
java源码如下:
package com.hejh.day0506; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement; import org.junit.Test; public class JdbcTest1 { static final String driver = "com.mysql.jdbc.Driver";
static final String url = "jdbc:mysql://localhost/hejh";
static final String user = "root";
static final String password = "root"; //开启junit局部测试
@Test
public void run() { ResultSet rs=null;
Statement st = null;
Connection conn =null; try {
//注册驱动
Class.forName(driver); //获取连接
conn = DriverManager.getConnection(url, user, password); //获取sql执行对象
st = conn.createStatement(); //编写sql语句
String sql = "select * from user"; //执行sql语句,返回一个结果集
rs = st.executeQuery(sql); //处理结果集
while(rs.next()) {
int id = rs.getInt("id");
String name = rs.getString("username");
String gender = rs.getString("gender");
System.out.println("["+id+","+name+","+gender+"]");
} } catch (Exception e) {
e.printStackTrace();
}finally {
//关闭资源,后开启的先关闭
try {
if(rs!=null) {
rs.close();
}else {
rs=null;
}
} catch (SQLException e) {
e.printStackTrace();
}
if(st!=null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}else {
st=null;
}
if(conn!=null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}else {
conn=null;
}
} } }
junit局部测试结果如下:
第一个jdbc案例完成。
4.JDBC 驱动类型
什么是 JDBC 驱动程序?
JDBC 驱动实现了 JDBC API 中定义的接口,该接口用于与数据库服务器进行交互。例如,使用 JDBC 驱动程序可以让你打开数据库连接,并通过发送 SQL 或数据库命令,然后通过 Java 接收结果。java.sql 包中附带的 JDK,包含了定义各种类与他们的行为和实际实现,这些类都在第三方驱动程序中完成。第三方供应商在他们的数据库驱动程序中都实现了 java.sql.Driver 接口。
JDBC驱动程序类型:
JDBC 驱动程序的实现,因为各种各样的操作系统和 Java 运行在硬件平台的不同而不同。Sun 公司将实现类型分为四类:
1.JDBC-ODBC桥驱动程序
2.JDBC-Native API
3.JDBC-Net纯Java
4.100%纯Java
具体参见资料:https://www.w3cschool.cn/jdbc/j3xk1myd.html
该使用哪种驱动程序?
如果你正在访问一个数据库,如 Oracle,Sybase 或 IBM,首选的驱动程序是类型4。
如果你的 Java 应用程序同时访问多个数据库类型,类型3是首选的驱动程序。
类型2驱动程序是在你的数据库没有提供类型3或类型4驱动程序时使用的。
类型1驱动程序不被认为是部署级的驱动程序,它存在的目的通常仅用于开发和测试。
5.JDBC连接数据库
编写建立一个 JDBC 连接的程序是相当简单的,下面是简单的四个步骤:
导入 JDBC 包:在你的 Java 代码中,用 import 语句添加你所需的类。
注册 JDBC 驱动程序:这一步会导致 JVM 加载所需的驱动程序到内存中执行,因此它可以实现你的 JDBC 请求。
数据库 URL 制定:这是用来创建格式正确的地址指向你想要连接的数据库。
- 创建连接对象:最后,代码调用 DriverManager 对象的 getConnection() 方法来建立实际的数据库连接。
1.导入jar包
import 语句告诉 Java 编译器在哪里可以找到你在代码中引用的类,这些引用放置在你的源代码起始位置。使用标准的 JDBC 包,它允许你选择,插入,更新和删除 SQL 表中的数据,添加以下引用到您的源代码中。
import java.sql.*;
import javax.sql.*;
2.注册JDBC驱动程序
方法1 - Class.forName()
注册一个驱动程序中最常用的方法是使用 Java 的Class.forName() 方法来动态加载驱动程序的类文件到内存中,它会自动将其注册。这种方法更优越一些,因为它允许你对驱动程序的注册信息进行配置,便于移植。
//注册驱动
Class.forName(“com.mysql.jdbc.Driver”);//会报异常
方法2 - DriverManager.registerDriver()
你注册一个驱动程序的第二种方法是使用静态 staticDriverManager.registerDriver() 方法。如果你使用的是不兼容 JVM 的非 JDK,比如微软提供的,你必须使用 registerDriver() 方法
try {
Driver myDriver = new oracle.jdbc.driver.OracleDriver();
DriverManager.registerDriver( myDriver );
}
catch(ClassNotFoundException ex) {
System.out.println("Error: unable to load driver class!");
System.exit(1);
}
3.数据库url制定
当你加载了驱动程序之后,你可以通过 DriverManager.getConnection() 方法建立一个连接。
为方便参考,以下列出了三个加载 DriverManager.getConnection() 方法:
- getConnection(String url)
- getConnection(String url, Properties prop)
- getConnection(String url, String user, String password)
在这里,每个格式需要一个数据库 URL ,数据库 URL 是指向数据库的地址。在建立一个数据连接的时候,大多数会在配置一个数据库 URL 时遇到问题。下表列出了常用的 JDBC 驱动程序名和数据库URL。
RDBMS | JDBC 驱动程序名称 | URL 格式 |
---|---|---|
MySQL | com.mysql.jdbc.Driver | jdbc:mysql://hostname/ databaseName |
ORACLE | oracle.jdbc.driver.OracleDriver | jdbc:oracle:thin:@hostname:port Number:databaseName |
DB2 | COM.ibm.db2.jdbc.net.DB2Driver | jdbc:db2:hostname:port Number/databaseName |
Sybase | com.sybase.jdbc.SybDriver | jdbc:sybase:Tds:hostname: port Number/databaseName |
URL 格式所有加粗的部分都是静态的,你需要将剩余部分按照你的数据库实际情况进行设置。
4.创建连接对象
调用适当的用户名和密码以及 getConnection() 方法来获得一个 Connection 对象
static final String url = "jdbc:mysql://localhost/hejh";
static final String user = "root";
static final String password = "root";
Connection conn = DriverManager.getConnection(url, user, password);
使用数据库 URL 和 Properties 对象:
第三种 DriverManager.getConnection() 方法调用需要数据库 URL 和 Properties 对象-
DriverManager.getConnection(String url, Properties info);
Properties 对象保存了一组关键数值。它通过调用 getConnection() 方法,将驱动程序属性传递给驱动程序。使用下面的代码可以建立与上述示例相同的连接:
import java.util.*; String URL = "jdbc:mysql://localhost/hejh";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" ); Connection conn = DriverManager.getConnection(URL, info);
5.关闭 JDBC 连接
在 JDBC 程序的末尾,必须明确关闭所有连接到数据库的连接,以结束每个数据库会话。但是,如果忘了,Java 垃圾收集器也会关闭连接,它会完全清除过期的对象。依托垃圾收集器,特别是在数据库编程,是非常差的编程习惯。你应该养成用 close()方法关闭连接对象的习惯。为了确保连接被关闭,你可以在代码中的 'finally' 程序块中执行。 无论异常是否发生,finally 程序是肯定会被执行的。要关闭上面打开的连接,应该调用 close()方法,如下所示:
finally {
try {
if(rs!=null) {
rs.close();
}else {
rs=null;
}
} catch (SQLException e) {
e.printStackTrace();
}
if(st!=null) {
try {
st.close();
} catch (SQLException e) {
e.printStackTrace();
}
}else {
st=null;
}
if(conn!=null) {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}else {
conn=null;
}
}
6.JDBC Statement 对象
1.Statement 对象
获得了数据库的连接,就可以和数据库进行交互了。JDBC 的 Statement,CallableStatement 和 PreparedStatement 接口定义的方法和属性,可以发送 SQL 命令或 PL/SQL 命令到数据库,并从数据库接收数据。在数据库中,它们还定义了帮助 Java 和 SQL 数据类型之间转换数据差异的方法。下表提供了每个接口的用途概要,根据实际目的决定使用哪个接口。
接口 | 推荐使用 |
---|---|
Statement | 可以正常访问数据库,适用于运行静态 SQL 语句。 Statement 接口不接受参数。 |
PreparedStatement | 计划多次使用 SQL 语句, PreparedStatement 接口运行时接受输入的参数。 |
CallableStatement | 适用于当你要访问数据库存储过程的时候, CallableStatement 接口运行时也接受输入的参数。 |
创建 Statement 对象:
使用 Statement 对象执行 SQL 语句之前,需要用 Connection 对象创建一个 Statement()对象,如下面的示例所示:
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
当创建了一个 Statement 对象之后,可以用它的三个执行方法的任一方法来执行 SQL 语句:
boolean execute(String SQL) : 如果 ResultSet 对象可以被检索,则返回的布尔值为 true ,否则返回 false 。当你需要使用真正的动态 SQL 时,可以使用这个方法来执行 SQL DDL 语句。
int executeUpdate(String SQL) : 返回执行 SQL 语句影响的行的数目。使用该方法来执行 SQL 语句,是希望得到一些受影响的行的数目,例如,INSERT,UPDATE 或 DELETE 语句。
- ResultSet executeQuery(String SQL) : 返回一个 ResultSet 对象。当你希望得到一个结果集时使用该方法,就像你使用一个 SELECT 语句。
关闭 Statement 对象:
正如关闭一个 Connection 对象来节约数据库资源,出于同样的原因你也应该关闭 Statement 对象。简单的调用 close() 方法就可以完成这项工作。如果关闭了 Connection 对象,那么它也会关闭 Statement 对象。然而,你应该始终明确关闭 Statement 对象,以确保真正的清除。
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}
catch (SQLException e) {
. . .
}
finally {
stmt.close();//会报异常
}
PreparedStatement 对象:
PreparedStatement 接口扩展了 Statement 接口,它让你用一个常用的 Statement 对象增加几个高级功能。这个 statement 对象可以提供灵活多变的动态参数。创建 PreparedStatement 对象:
PreparedStatement pstmt = null;
try {
String SQL = "update user set age = ? where id = ?";
pstmt = conn.prepareStatement(SQL);
psmt.setInt(1,22);
psmt.setInt(2,1);
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
JDBC 中所有的参数都被用 ? 符号表示,这是已知的参数标记。在执行 SQL 语句之前,你必须赋予每一个参数确切的数值。setXXX() 方法将值绑定到参数,其中 XXX 表示你希望绑定到输入参数的 Java 数据类型。如果你忘了赋予值,你将收到一个 SQLException。每个参数标记映射它的序号位置。第一标记表示位置 1 ,下一个位置为 2 等等。这种方法不同于 Java 数组索引是从 0 开始的。所有的 Statement对象 的方法都与数据库交互,(a) execute(),(b) executeQuery(),及 (c) executeUpdate() 也能被 PreparedStatement 对象引用。然而,这些方法被 SQL 语句修改后是可以输入参数的。
关闭 PreparedStatement 对象
关闭 PreparedStatement 对象,简单的调用 close() 方法可以完成这项工作。如果你关闭了 Connection 对象,那么它也会关闭 PreparedStatement 对象。然而,你应该始终明确关闭 PreparedStatement 对象,以确保真正的清除。
PreparedStatement pstmt = null;
try {
String SQL = "Update Employees SET age = ? WHERE id = ?";
pstmt = conn.prepareStatement(SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
pstmt.close();//会报异常
}
CallableStatement 对象:
正如一个 Connection 对象可以创建 Statement 对象和 PreparedStatement 对象,它也可以创建被用来执行调用数据库存储过程的 CallableStatement 对象。
在 MySQL 的 EMP 数据库中创建相同的存储过程:
DELIMITER $$ DROP PROCEDURE IF EXISTS `EMP`.`getEmpName` $$
CREATE PROCEDURE `EMP`.`getEmpName`
(IN EMP_ID INT, OUT EMP_FIRST VARCHAR(255))
BEGIN
SELECT first INTO EMP_FIRST
FROM Employees
WHERE ID = EMP_ID;
END $$ DELIMITER ;
三种类型的参数有:IN,OUT 和 INOUT。PreparedStatement 对象只使用 IN 参数。CallableStatement 对象可以使用所有的三个参数。这里是每个参数的定义:
参数 | 描述 |
---|---|
IN | 在 SQL 语句创建的时候该参数是未知的。你可以用 setXXX() 方法将值绑定到IN参数中。 |
OUT | 该参数由 SQL 语句的返回值提供。你可以用 getXXX() 方法获取 OUT 参数的值。 |
INOUT | 该参数同时提供输入输出的值。你可以用 setXXX() 方法将值绑定参数,并且用 getXXX() 方法获取值。 |
下面的代码片段展示了基于存储过程如何使用 Connection.prepareCall() 方法来实例化 CallableStatement 对象。
CallableStatement cstmt = null;
try {
String SQL = "{call getEmpName (?, ?)}";
cstmt = conn.prepareCall (SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
7.结果集
结果集:
SQL 语句从数据库查询中获取数据,并将数据返回到结果集中。SELECT 语句是一种标准的方法,它从一个数据库中选择行记录,并显示在一个结果集中。 java.sql.ResultSet 接口表示一个数据库查询的结果集。一个 ResultSet 对象控制一个光标指向当前行的结果集。术语“结果集”是指包含在 ResultSet 对象中的行和列的数据。
ResultSet 接口的方法可细分为三类:
- 导航方法:用于移动光标。
- 获取方法:用于查看当前行被光标所指向的列中的数据。
- 更新方法:用于更新当前行的列中的数据。这些更新也会更新数据库中的数据。
光标的移动基于 ResultSet 的属性。用相应的语句生成 ResultSet 对象时,同时生成 ResultSet 的属性。JDBC 提供了连接方法通过下列创建语句来生成你所需的 ResultSet 对象:
- createStatement(int RSType, int RSConcurrency);
- prepareStatement(String SQL, int RSType, int RSConcurrency);
- prepareCall(String sql, int RSType, int RSConcurrency);
第一个参数表示 ResultSet 对象的类型,第二个参数是两个 ResultSet 常量之一,该常量用于判断该结果集是只读的还是可修改的
ResultSet的类型:
可能的 RSType 如下所示。如果你不指定 ResultSet 类型,将自动获得的值是 TYPE_FORWARD_ONLY。
类型 | 描述 |
---|---|
ResultSet.TYPE_FORWARD_ONLY | 光标只能在结果集中向前移动。 |
ResultSet.TYPE_SCROLL_INSENSITIVE | 光标可以向前和向后移动。当结果集创建后,其他人对数据库的操作不会影响结果集的数据。 |
ResultSet.TYPE_SCROLL_SENSITIVE. | 光标可以向前和向后移动。当结果集创建后,其他人对数据库的操作会影响结果集的数据。 |
ResultSet的并发性:
RSConcurrency 的值如下所示,如果你不指定并发类型,将自动获得的值是 CONCUR_READ_ONLY。
并发性 | 描述 |
---|---|
ResultSet.CONCUR_READ_ONLY | 创建一个只读结果集,这是默认的值。 |
ResultSet.CONCUR_UPDATABLE | 创建一个可修改的结果集。 |
示例可以如下所示,初始化一个 Statement 对象,来创建一个只能前进而且只读的 ResultSet 对象:
try {
Statement stmt = conn.createStatement( ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
}
catch(Exception ex) {
....
}
finally {
....
}
导航结果集:
在 ResultSet 接口中包括如下几种方法涉及移动光标-
S.N. | 方法 & 描述 |
---|---|
1 | public void beforeFirst() throws SQLException
将光标移动到第一行之前。 |
2 | public void afterLast() throws SQLException
将光标移动到最后一行之后。 |
3 | public boolean first() throws SQLException
将光标移动到第一行。 |
4 | public void last() throws SQLException
将光标移动到最后一行。 |
5 | public boolean absolute(int row) throws SQLException
将光标移动到指定的第 row 行。 |
6 | public boolean relative(int row) throws SQLException
将光标移动到当前指向的位置往前或往后第 row 行的位置。 |
7 | public boolean previous() throws SQLException
将光标移动到上一行,如果超过结果集的范围则返回 false。 |
8 | public boolean next() throws SQLException
将光标移动到下一行,如果是结果集的最后一行则返回 false。 |
9 | public int getRow() throws SQLException
返回当前光标指向的行数的值。 |
10 | public void moveToInsertRow() throws SQLException
将光标移动到结果集中指定的行,可以在数据库中插入新的一行。当前光标位置将被记住。 |
11 | public void moveToCurrentRow() throws SQLException
如果光标处于插入行,则将光标返回到当前行,其他情况下,这个方法不执行任何操作。 |
查看结果集:
ResultSet接口中含有几十种从当前行获取数据的方法。每个可能的数据类型都有一个 get 方法,并且每个 get 方法有两个版本-
- 一个需要列名。
- 一个需要列的索引。
例如,如果你想查看的列包含一个 int 类型,你需要在 ResultSet 中调用 getInt()方法-
S.N. | 方法 & 描述 |
---|---|
1 | public int getInt(String columnName) throws SQLException
返回当前行中名为 columnName 的列的 int 值。 |
2 | public int getInt(int columnIndex) throws SQLException
返回当前行中指定列的索引的 int 值。列索引从 1 开始,意味着行中的第一列是 1 ,第二列是 2 ,以此类推。 |
同样的,在 ResultSet 接口中还有获取八个 Java 原始类型的 get 方法,以及常见的类型,比如 java.lang.String,java.lang.Object 和java.net.URL。
也有用于获取 SQL 数据类型 java.sql.Date, java.sql.Time, java.sql.Timestamp, java.sql.Clob,java.sql.Blob 中的方法。查看文档可以了解使用这些 SQL 数据类型的更多的信息。
更新的结果集:
ResultSet 接口包含了一系列的更新方法,该方法用于更新结果集中的数据。用 get 方法可以有两个更新方法来更新任一数据类型:
- 一个需要列名。
- 一个需要列的索引。
例如,要更新一个结果集的当前行的 String 列,你可以使用任一如下所示的 updateString()方法-
S.N. | 方法 & 描述 |
---|---|
1 | public void updateString(int columnIndex, String s) throws SQLException
将指定列的字符串的值改为 s。 |
2 | public void updateString(String columnName, String s) throws SQLException
类似于前面的方法,不同之处在于指定的列是用名字来指定的,而不是它的索引。 |
八个原始数据类型都有其更新方法,比如 String,Object,URL,和在 java.sql 包中的 SQL 数据类型。
更新结果集中的行将改变当前行的列中的 ResultSet 对象,而不是基础数据库中的数据。要更新数据库中一行的数据,你需要调用以下的任一方法:
S.N. | 方法 & 描述 |
---|---|
1 | public void updateRow()
通过更新数据库中相对应的行来更新当前行。 |
2 | public void deleteRow()
从数据库中删除当前行。 |
3 | public void refreshRow()
在结果集中刷新数据,以反映数据库中最新的数据变化。 |
4 | public void cancelRowUpdates()
取消对当前行的任何修改。 |
5 | public void insertRow()
在数据库中插入一行。本方法只有在光标指向插入行的时候才能被调用。 |
8.JDBC数据类型
JDBC 驱动程序在将 Java 数据类型数据发送到数据库之前,会将其转换为相应的 JDBC 类型数据,对于大多数数据类型都采用了默认的映射关系。例如,一个 Java int 数据类型转换为 SQL INTEGER。通过默认的映射关系来提供驱动程序之间的一致性。当你调用 PreparedStatement 中的 setXXX()方法或 CallableStatement 对象或 ResultSet.updateXXX()方法时, Java 数据类型会转换为默认的 JDBC 数据类型,如下表概述。
SQL | JDBC/Java | setXXX | updateXXX |
---|---|---|---|
VARCHAR | java.lang.String | setString | updateString |
CHAR | java.lang.String | setString | updateString |
LONGVARCHAR | java.lang.String | setString | updateString |
BIT | boolean | setBoolean | updateBoolean |
NUMERIC | java.math.BigDecimal | setBigDecimal | updateBigDecimal |
TINYINT | byte | setByte | updateByte |
SMALLINT | short | setShort | updateShort |
INTEGER | int | setInt | updateInt |
BIGINT | long | setLong | updateLong |
REAL | float | setFloat | updateFloat |
FLOAT | float | setFloat | updateFloat |
DOUBLE | double | setDouble | updateDouble |
VARBINARY | byte[ ] | setBytes | updateBytes |
BINARY | byte[ ] | setBytes | updateBytes |
DATE | java.sql.Date | setDate | updateDate |
TIME | java.sql.Time | setTime | updateTime |
TIMESTAMP | java.sql.Timestamp | setTimestamp | updateTimestamp |
CLOB | java.sql.Clob | setClob | updateClob |
BLOB | java.sql.Blob | setBlob | updateBlob |
ARRAY | java.sql.Array | setARRAY | updateARRAY |
REF | java.sql.Ref | SetRef | updateRef |
STRUCT | java.sql.Struct | SetStruct | updateStruct |
JDBC 3.0 增强了对 BLOB,CLOB,ARRAY 和 REF 数据类型的支持。 ResultSet 对象现在有 UPDATEBLOB(),updateCLOB(), updateArray(),和 updateRef()方法,通过这些方法你可以直接操作服务器上的相应数据。
你能用 setXXX()方法和 updateXXX()方法将 Java 类型转换为特定的 JDBC 数据类型。你能用 setObject()方法和 updateObject()方法将绝大部分的 Java 类型映射到 JDBC 数据类型。
ResultSet 对象为任一数据类型提供相应的 getXXX()方法,该方法可以获取任一数据类型的列值。上述任一方法的使用需要列名或它的顺序位置。
SQL | JDBC/Java | setXXX | getXXX |
---|---|---|---|
VARCHAR | java.lang.String | setString | getString |
CHAR | java.lang.String | setString | getString |
LONGVARCHAR | java.lang.String | setString | getString |
BIT | boolean | setBoolean | getBoolean |
NUMERIC | java.math.BigDecimal | setBigDecimal | getBigDecimal |
TINYINT | byte | setByte | getByte |
SMALLINT | short | setShort | getShort |
INTEGER | int | setInt | getInt |
BIGINT | long | setLong | getLong |
REAL | float | setFloat | getFloat |
FLOAT | float | setFloat | getFloat |
DOUBLE | double | setDouble | getDouble |
VARBINARY | byte[ ] | setBytes | getBytes |
BINARY | byte[ ] | setBytes | getBytes |
DATE | java.sql.Date | setDate | getDate |
TIME | java.sql.Time | setTime | getTime |
TIMESTAMP | java.sql.Timestamp | setTimestamp | getTimestamp |
CLOB | java.sql.Clob | setClob | getClob |
BLOB | java.sql.Blob | setBlob | getBlob |
ARRAY | java.sql.Array | setARRAY | getARRAY |
REF | java.sql.Ref | SetRef | getRef |
STRUCT | java.sql.Struct | SetStruct | getStruct |
日期和时间数据类型:
java.sql.Date 类映射 SQL DATE 类型,java.sql.Time 类和 java.sql.Timestamp 类也分别映射 SQL TIME 数据类型和 SQL TIMESTAMP 数据类型。以下示例显示了日期和时间类如何转换成标准的 Java 日期和时间值,并匹配成 SQL 数据类型所要求的格式。
package com.hejh.day0507;
import java.util.Date; public class TimeTest {
public static void main(String[] args) { //java util 打印当前具体时间
Date utilDate = new Date();
long utilTime = utilDate.getTime();
System.out.println("java util date:"+utilDate.toString());//java util date:Tue May 07 17:14:53 CST 2019 //sql 打印当前时间(某年-某月-某日)
java.sql.Date sqlDate = new java.sql.Date(utilTime);
System.out.println("java sql date:"+sqlDate.toString());//java sql date:2019-05-07 //sql 打印当前时间(时:分:秒)
java.sql.Time sqlTime = new java.sql.Time(utilTime);
System.out.println("java sql time:"+sqlTime.toString());//java sql time:17:34:33 //sql 打印当前具体时间(某年-某月-某日 时:分:秒)
java.sql.Timestamp sqlTimeStamp = new java.sql.Timestamp(utilTime);
System.out.println("java sql Timestamp:"+sqlTimeStamp.toString());//java sql Timestamp:2019-05-07 17:36:44.176
}
}
处理 NULL 值:
SQL 使用 NULL 值和 Java 使用 null 是不同的概念。那么,你可以使用三种策略来处理 Java 中的 SQL NULL 值:
- 避免使用返回原始数据类型的 getXXX()方法。
- 使用包装类的基本数据类型,并使用 ResultSet 对象的 wasNull()方法来测试收到 getXXX()方法返回的值是否为 null,如果是 null,该包装类变量则被设置为 null。
- 使用原始数据类型和 ResultSet 对象的 wasNull()方法来测试通过 getXXX()方法返回的值,如果是 null,则原始变量应设置为可接受的值来代表 NULL。
下面是一个处理 NULL 值的示例:
Statement stmt = conn.createStatement( );
String sql = "SELECT id, first, last, age FROM Employees";
ResultSet rs = stmt.executeQuery(sql); int id = rs.getInt(1);
if( rs.wasNull( ) ) {
id = 0;
}
9.JDBC事务
事务:
如果 JDBC 连接是处于自动提交模式下,该模式为默认模式,那么每句 SQL 语句都是在其完成时提交到数据库。对简单的应用程序来说这种模式相当好,但有三个原因你可能想关闭自动提交模式,并管理你自己的事务:
- 为了提高性能
- 为了保持业务流程的完整性
- 使用分布式事务
你可以通过事务在任意时间来控制以及更改应用到数据库。它把单个 SQL 语句或一组 SQL 语句作为一个逻辑单元,如果其中任一语句失败,则整个事务失败。
若要启用手动事务模式来代替 JDBC 驱动程序默认使用的自动提交模式的话,使用 Connection 对象的的 setAutoCommit()方法。如果传递一个布尔值 false 到 setAutoCommit()方法,你就关闭自动提交模式。你也可以传递一个布尔值 true 将其再次打开。例如,如果有一个名为 conn 的 Connection 对象,以下的代码将关闭自动提交模式:
conn.setAutoCommit(false);//关闭自动提交模式
提交和回滚:
当完成修改,并且要提交修改,可以在 connection 对象里调用 commit()方法,如下所示:
conn.commit( );
在默认情况下,事务自动提交,源码和数据库数据如下:
package com.hejh.day0508; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException; import org.junit.Test; public class AffairTest { static final String driver = "com.mysql.jdbc.Driver";
static String url = "jdbc:mysql://localhost/hejh";
static final String username = "root";
static final String password = "root"; @Test
public void run() {
Connection conn = null;
PreparedStatement ps = null;
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
String sql = "update user set username = ? where id = ? "; ps = conn.prepareStatement(sql);
ps.setString(1,"hejh11");
ps.setInt(2, 1);
int i = ps.executeUpdate();
System.out.println("影响了:"+i+"行"); //影响了:1行
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(ps!=null) {
ps.close();
}else {
ps=null;
}
} catch (Exception e) {
e.printStackTrace();
}
try {
if(conn!=null) {
conn.close();
}else {
conn=null;
}
} catch (SQLException e) {
e.printStackTrace();
} }//finally
}
}
设置为手动提交,运行下面的源码(替换try-catch部分代码),数据库数据刷新结果如下:
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
String sql = "update user set username = ? where id = ? ";
//在执行sql之前,设置事务为手动提交
conn.setAutoCommit(false);//手动提交事务,数据不会发生变化
ps = conn.prepareStatement(sql);
ps.setString(1,"hejh111");
ps.setInt(2, 1);
int i = ps.executeUpdate();
System.out.println("影响了:"+i+"行"); //影响了:1行
} catch (Exception e) {
e.printStackTrace();
}
设置为手动提交,并且在sql执行后,手动提交一下事务,运行下面的源码(替换try-catch部分代码),数据库数据刷新结果如下:
try {
Class.forName(driver);
conn = DriverManager.getConnection(url, username, password);
String sql = "update user set username = ? where id = ? ";
//在执行sql之前,设置事务为手动提交
conn.setAutoCommit(false);//手动提交事务,数据不会发生变化
ps = conn.prepareStatement(sql);
ps.setString(1,"hejh111");
ps.setInt(2, 1);
int i = ps.executeUpdate();
//sql语句执行后,手动提交事务,使sql生效
conn.commit();
System.out.println("影响了:"+i+"行"); //影响了:1行
} catch (Exception e) {
e.printStackTrace();
}
另外,用名为 conn 的连接回滚数据到数据库,
conn.rollback( );//可以放在catch块中
还原点:
新的 JDBC 3.0 还原点接口提供了额外的事务控制。大部分现代的数据库管理系统的环境都支持设定还原点,例如 Oracle 的 PL/SQL。当你在事务中设置一个还原点来定义一个逻辑回滚点。如果在一个还原点之后发生错误,那么可以使用 rollback 方法来撤消该还原点之后所做的修改。
Connection 对象有两个新的方法来管理还原点:
setSavepoint(String savepointName): 定义了一个新的还原点,返回一个 Savepoint 对象。
- releaseSavepoint(Savepoint savepointName): 删除一个还原点。请注意,参数是一个 Savepoint 对象,这个对象通常是由 setSavepoint() 方法生成的一个还原点。
有一个 rollback (String savepointName) 方法,该方法可以回滚到指定的还原点。下面的例子说明了如何使用 Savepoint 对象:
package com.hejh.day0508; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Savepoint; import org.junit.Test; public class SavePointTest { @Test
public void save() throws SQLException {
Connection conn = null;
PreparedStatement ps =null;
Savepoint beforeInsert = null;
try {
Class.forName("com.mysql.jdbc.Driver");
//prepareStatement插入的中文参数有可能会出现问号,可以在这里指定一下字符编码为utf-8
conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8",
"root", "root"); //设置一个还原点
beforeInsert = conn.setSavepoint(); String sql = "insert into user values(?,?,?)";
ps = conn.prepareStatement(sql);
ps.setInt(1,4);
ps.setString(2, "hejh222");
ps.setString(3, "男");
int i = ps.executeUpdate();
System.out.println("插入了:"+i+"行数据");
} catch (Exception e) {
//回滚到还原点BeforeInsert处
conn.rollback(beforeInsert);
e.printStackTrace();
}finally {
try {
if(ps!=null) {
ps.close();
}else {
ps = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if(beforeInsert!=null) {
conn.releaseSavepoint(beforeInsert);
}else {
beforeInsert=null;
} } catch (SQLException e) {
e.printStackTrace();
}
try {
if(conn!=null) {
conn.close();
}else {
conn=null;
} } catch (SQLException e) {
e.printStackTrace();
}
}
}
}
10.JDBC异常
异常:
异常处理可以允许你处理一个异常情况,例如可控方式的程序定义错误。当异常情况发生时,将抛出一个异常。抛出这个词意味着当前执行的程序停止,控制器被重定向到最近的适用的 catch 子句。如果没有适用的 catch 子句存在,那么程序执行被终止。JDBC 的异常处理是非常类似于 Java 的异常处理,但对于 JDBC,最常见的异常是 java.sql.SQLException。
SQLException:
SQLException 异常在驱动程序和数据库中都可能出现。当出现这个异常时,SQLException 类型的对象将被传递到 catch 子句。传递的 SQLException 对象具有以下的方法,以下的方法可用于检索该异常的额外信息:
方法 | 描述 |
---|---|
getErrorCode( ) | 获取与异常关联的错误号。 |
getMessage( ) | 获取 JDBC 驱动程序的错误信息,该错误是由驱动程序处理的,或者在数据库错误中获取 Oracl 错误号和错误信息。 |
getSQLState( ) | 获取 XOPEN SQLstate 字符串。对于 JDBC 驱动程序错误,使用该方法不能返回有用的信息。对于数据库错误,返回第五位的 XOPEN SQLstate 代码。该方法可以返回 null。 |
getNextException( ) | 获取异常链的下一个 Exception 对象。 |
printStackTrace( ) | 打印当前异常或者抛出,其回溯到标准的流错误。 |
printStackTrace(PrintStream s) | 打印该抛出,其回溯到你指定的打印流。 |
printStackTrace(PrintWriter w) | 打印该抛出,其回溯到你指定的打印写入。 |
通过利用可从 Exception 对象提供的信息,你可以捕获异常并继续运行程序。这是一个 try 块的一般格式:
try {
// 可能出现异常的代码
}
catch(Exception ex) {
//异常的捕捉和处理
}
finally {// 必须执行的操作,想数据库的资源关闭,
}
package com.hejh.day0508; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Savepoint; import org.junit.Test; public class ExceptionTest { @Test
public void save() throws SQLException {
Connection conn = null;
PreparedStatement ps =null;
Savepoint beforeInsert = null;
try {
Class.forName("com.mysql.jdbc.Driver");
//1.数据库用户名和密码不符(root,hejh),实际用户名密码为(root,root)
conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "hejh"); String sql = "insert into user values(?,?,?)";
ps = conn.prepareStatement(sql);
ps.setInt(1,4);
ps.setString(2, "hejh200");
ps.setString(3, "男");
int i = ps.executeUpdate();
System.out.println("插入了:"+i+"行数据");
} catch (Exception e) {
//2.在这里捕获异常,并将异常信息打印到控制台
e.printStackTrace();
}finally {
try {
if(ps!=null) {
ps.close();
}else {
ps = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if(beforeInsert!=null) {
conn.releaseSavepoint(beforeInsert);
}else {
beforeInsert=null;
} } catch (SQLException e) {
e.printStackTrace();
}
try {
if(conn!=null) {
conn.close();
}else {
conn=null;
} } catch (SQLException e) {
e.printStackTrace();
}
}
} }
出现以下异常:
java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES)
......
11.JDBC批处理
批处理:
批处理是指你将关联的 SQL 语句组合成一个批处理,并将他们当成一个调用提交给数据库。当你一次发送多个 SQL 语句到数据库时,可以减少通信的资源消耗,从而提高了性能。
JDBC 驱动程序不一定支持该功能。你可以使用 DatabaseMetaData.supportsBatchUpdates() 方法来确定目标数据库是否支持批处理更新。如果你的JDBC驱动程序支持此功能,则该方法返回值为 true。
Statement,PreparedStatement 和 CallableStatement 的 addBatch() 方法用于添加单个语句到批处理。
executeBatch() 方法用于启动执行所有组合在一起的语句。
executeBatch() 方法返回一个整数数组,数组中的每个元素代表了各自的更新语句的更新数目。
- 正如你可以添加语句到批处理中,你也可以用 clearBatch() 方法删除它们。此方法删除所有用 addBatch() 方法添加的语句。但是,你不能有选择性地选择要删除的语句。
Statement 对象执行批处理:
使用 Statement 对象来使用批处理所需要的典型步骤如下所示-
- 使用 createStatement() 方法创建一个 Statement 对象。
- 使用 setAutoCommit() 方法将自动提交设为 false。
- 被创建的 Statement 对象可以使用 addBatch() 方法来添加你想要的所有SQL语句。
- 被创建的 Statement 对象可以用 executeBatch() 将所有的 SQL 语句执行。
- 最后,使用 commit() 方法提交所有的更改。
批量执行3条insert语句,示例如下:
package com.hejh.day0508; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement; import org.junit.Test;
import org.omg.Messaging.SyncScopeHelper; //批处理
public class Batching { @Test
public void test() {
Connection conn = null;
Statement st = null;
try {
//注册驱动
Class.forName("com.mysql.jdbc.Driver"); //获取链接
conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root"); //设置为:手动提交事务
conn.setAutoCommit(false); //编写3个insert sql语句
String sql1 = "insert into user values(4,'sss','女')";
String sql2 = "insert into user values(5,'www','男')";
String sql3 = "insert into user values(6,'yyy','女')"; //获取statement对象
st = conn.createStatement(); //添加sql语句到批处理
st.addBatch(sql1);
st.addBatch(sql2);
st.addBatch(sql3); //执行批处理,返回一个整数数组,数组中的每个元素代表了各自的更新语句的更新数目
int[] arr = st.executeBatch(); //事务提交,使sql语句生效
conn.commit(); //处理数组
System.out.print("影响行数为:");
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");//影响行数为:1 1 1
} } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(st!=null) {
st.close();
}else {
st = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if(conn!=null) {
conn.close();
}else {
conn = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
} } }
批处理和 PrepareStatement 对象:
使用 prepareStatement 对象来使用批处理需要的典型步骤如下所示:
- 使用占位符创建 SQL 语句。
- 使用任一 prepareStatement() 方法创建 prepareStatement 对象。
- 使用 setAutoCommit() 方法将自动提交设为 false。
- 被创建的 Statement 对象可以使用 addBatch() 方法来添加你想要的所有 SQL 语句。
- 被创建的 Statement 对象可以用 executeBatch() 将所有的 SQL 语句执行。
- 最后,使用 commit() 方法提交所有的更改。
示例如下:
package com.hejh.day0508; import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException; import org.junit.Test; public class PrepareStatementBatching { @Test
public void test() {
Connection conn = null;
PreparedStatement ps = null;
try {
//注册驱动
Class.forName("com.mysql.jdbc.Driver"); //获取链接
conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root"); //设置为:手动提交事务
conn.setAutoCommit(false); //编写sql语句
String sql = "update user set username=? where id=?"; //获取statement对象
ps = conn.prepareStatement(sql); //添加第一个sql语句到批处理
ps.setString(1, "s");
ps.setInt(2, 4);
ps.addBatch();
//添加第二个sql语句到批处理
ps.setString(1, "w");
ps.setInt(2, 5);
ps.addBatch();
//添加第三个sql语句到批处理
ps.setString(1, "y");
ps.setInt(2, 6);
ps.addBatch(); //执行批处理,返回一个整数数组,数组中的每个元素代表了各自的更新语句的更新数目
int []arr = ps.executeBatch(); //提交事务,使sql语句生效
conn.commit(); //处理数组
System.out.print("分别影响了:");
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" "); //分别影响了:1行 1行 1行
} } catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(ps!=null) {
ps.close();
}else {
ps = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
try {
if(conn!=null) {
conn.close();
}else {
conn = null;
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
12.JDBC流数据
流数据:
PreparedStatement 对象必须具备使用输入和输出流来提供参数数据的能力。这使你能够将整个文件存储到数据库列中,这样数据库就能存储大型数据,例如 CLOB 和 BLOB 数据类型。
用于流数据有下列几种方法:
- setAsciiStream(): 该方法是用来提供较大的 ASCII 值。
- setCharacterStream(): 该方法是用来提供较大的 UNICODE 值。
- setBinaryStream(): 该方法是用来提供较大的二进制值。
setXXXStream()方法需要一个额外的参数,该参数是除了参数占位符的文件大小。这个参数通知驱动程序通过使用流有多少数据被发送到数据库中。
假如我们到要上传一个名为 hejh.xml 的 XML 文件到数据库的表中。下面是该 XML 文件的内容
<?xml version="1.0"?>
<hejh>
<id>1</id>
<username>hjh</username>
<gender>男</gender>
</hejh>
将该 xml_data.xml文件和要运行的示例保存在相同的目录的。这个示例将创建一个数据库表 xml_data ,然后 xml_data.xml 将被上传到该表中。
将下面的示例拷贝并粘帖到 JDBCStreamingDate.java 中,编译并运行它,如下所示:
package com.hejh.day0509; import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement; public class JDBCStreamingDate {
public static void main(String[] args)throws SQLException, IOException {
Connection conn = null;
Statement st = null;
PreparedStatement pps = null;
ResultSet rs = null;
try {
//注册驱动
Class.forName("com.mysql.jdbc.Driver");
//获取连接
conn = DriverManager.getConnection("jdbc:mysql://localhost/hejh?useUnicode=true&characterEncoding=UTF-8", "root", "root");
//获取 Statement 对象,来创建一张xml_data表
st = conn.createStatement();
createXMLTable(st);
//将xml_data.xml文件读取进来
File file = new File("src/xml_data.xml");
long fileLength = file.length();
FileInputStream fis = new FileInputStream(file);
//获取 对象,给表插入数据,并执行sql
String sql = "insert into xml_data values(?,?)";
pps = conn.prepareStatement(sql);
pps.setInt(1, 100);
pps.setAsciiStream(2, fis,(int)fileLength );
pps.execute();
//关闭输入流
fis.close();
String selectSql = "select data from xml_data where id =100";
rs = st.executeQuery(selectSql);
InputStream is = null;
ByteArrayOutputStream bos = null;
if(rs.next()) {
is = rs.getAsciiStream(1);
int c ;
//获取输出流,将带数据的hejh.xml文件输出
bos = new ByteArrayOutputStream();
while((c=is.read())!=-1) {
bos.write(c);
}
}
System.out.println(bos.toString());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally {//关闭资源
if(rs!=null) {
rs.close();
}else {
rs = null;
}
if(pps!=null) {
pps.close();
}else {
pps = null;
}
if(st!=null) {
st.close();
}else {
st = null;
}
if(conn!=null) {
conn.close();
}else {
conn = null;
}
}
} //创建一张表,表名xml_data
public static void createXMLTable(Statement st) throws SQLException {
//sql语句,创建一张表xml_data String createTable = "create table xml_data(id int,data long)";
//删除表xml_data
String dropTable = "drop table xml_data";
//在建表前,应该先删除表,如果存在相同的表名的话
try {
st.execute(dropTable);
} catch (SQLException e) {
e.printStackTrace();
}
//创建表
st.executeUpdate(createTable);
}
}
console输出为:
<?xml version="1.0" encoding="UTF-8"?>
<hejh>
<id>1</id>
<username>hjh</username>
<gender>男</gender>
</hejh>
数据库表现为:
本博文参考w3cschool网JDBC指南一文,附上网址:https://www.w3cschool.cn/jdbc/bgqu1my6.html
jdbc知识点(连接mysql)的更多相关文章
- Ubuntu jsp平台使用JDBC来连接MySQL数据库
Ubuntu 7.04 搭建Ubuntu jsp平台开发环境MySQL+tomcat+apache+j2sdk1.6在所有安装开始前先在Terminal中输入 rpm -q -a查看是否安装过rpm ...
- jmeter中通过jdbc方式连接mysql数据库的配置参考
jmeter中通过jdbc方式连接mysql数据库的配置参考: Database URL=jdbc:mysql://ip:port/dbname?useUnicode=true&allowMu ...
- Spark JDBC方式连接MySQL数据库
Spark JDBC方式连接MySQL数据库 一.JDBC connection properties(属性名称和含义) 二.spark jdbc read MySQL 三.jdbc(url: Str ...
- Android Studio使用JDBC远程连接mysql的注意事项(附示例)
JDBC为java程序访问各种类型的关系型数据库提供了统一的接口,用户不必针对不同数据库写出不同的代码,但是使用JDBC必须得下载相应的驱动,比如我这里是要连接mysql,于是就到mysql官网去下载 ...
- JDBC的连接mySql的基本知识
这只是我自己的随笔博客~,用于偶尔回忆知识,可能存在一些错误,如有错误,欢迎指正~ 首先对于JDBC连接MySQL,要了解基本的框架结构 画的比较烂,大约就是这样的结构 然后看一下具体实现的 代码:: ...
- JDBC Java 连接 MySQL 数据库
MySQL 版本:Server version: 5.7.17-log MySQL Community Server (GPL) 用于测试的 MySQL 数据库:game 查看数据库中的表 mysql ...
- jdbc 02: 连接mysql,并实现删除与更新
jdbc连接mysql,并实现删除与更新 package com.examples.jdbc.o2_删除与更新; import java.sql.*; //连接与插入 /* jdbc删除操作 */ p ...
- jdbc 01: 连接mysql,并实现数据插入
jdbc连接mysql,并实现数据插入 package com.examples.jdbc.o1_连接与插入; import java.sql.*; /* jdbc数据库连接六步 */ public ...
- JDBC中连接MySQL数据库
package qddx.JDBC; import java.sql.*; public class JDBC_Connection { static String driverName = &quo ...
- JAVA高级编程序——JDBC(连接mysql数据库)——(一)
java要想连接数据库,就要用JDBC(java database connection),用这个jar包 (mysql-connector-java-xxx-xx-bin.jar) sun公司为我们 ...
随机推荐
- MyBatis配置文件(四)--typeHandlers
typeHandlers又叫类型处理器,就像在JDBC中,我们在PreparedStatement中设置预编译sql所需的参数或执行sql后根据结果集ResultSet对象获取得到的数据时,需要将数据 ...
- 新闻内页 上一篇写一篇问题,ID不连续,不用链表
y要什么链表? 用sql查询上一篇 SELECT id,title FROM t_article WHERE id<10 ORDER BY id DESC LIMIT 1; 用sql查下一篇 S ...
- SpringData初探
前言 项目中用到这个,没有学过,手动搭建,测试执行流程, 理论的东西有时间再补充 Maven依赖 <?xml version="1.0" encoding="UTF ...
- Vue. 之 替换 左上角 title标签处的图标
Vue. 之 替换 左上角 title标签处的图标 1.icon命名为favicon.ico放在项目的位置:src/assets/favicon.ico 2.在index.html中写入: <l ...
- leetcode 847. Shortest Path Visiting All Nodes 无向连通图遍历最短路径
设计最短路径 用bfs 天然带最短路径 每一个状态是 当前的阶段 和已经访问过的节点 下面是正确但是超时的代码 class Solution: def shortestPathLength(self, ...
- hdu4565
#include<iostream> #include<cstdio> #include<queue> #include<algorithm> #inc ...
- LUOGU P2441 角色属性树
题目描述 绪萌同人社是一个有趣的组织,该组织结构是一个树形结构.有一个社长,直接下属一些副社长.每个副社长又直接下属一些部长--. 每个成员都有一个萌点的属性,萌点属性是由一些质数的萌元素乘积构成(例 ...
- java多线程三种方式
java多线程都有几种方式 有三种: (1)继承Thread类,重写run函数 创建: class xx extends Thread{ public void run(){ Thread.sleep ...
- Aspose Words、Excel导出等操作
/*Word先保存再输出-下载*/ strReportFilePath = Server.MapPath("~") + strReportFilePath; doc.Save(st ...
- JAVA读取文件操作时路径的斜杠问题
java中的路径一般用"/"windows中的路径用"\"linux,unix中的路径一般用"/"其中java中"/"等 ...