文章目录
 
前言
一、JDBC是什么？
二、使用步骤
1.JDBC连接步骤
1. 导入数据库对应的jar包
2. 注册驱动
3. 获取数据库连接对象
4. 定义sql语句
5. 获取执行sql的对象 Statement
6. 执行sql
7. 对结果进行处理
8. 释放资源
   
   
2.准备工作
3.JDBC连接数据库步骤代码详解
1.导入数据库对应的jar包，并Add As Library
2.注册驱动
1.编写数据库配置文件jdbc.properties
2.编写JDBCUtils工具类读取配置文件，获取连接，关闭资源
3.编写测试类，测试JDBC连接的工具类，进行数据库连接
4.程序运行结果：
   
  
  
总结

 
 
前言
 
本文是自己关于使用JDBC 连接数据库的一些基本的总结，以及使用步骤的简单记录
 
一、JDBC是什么？
 
JDBC是Java数据库连接（Java Database Connectivity），是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。
 
二、使用步骤
 
1.JDBC连接步骤
 
1. 导入数据库对应的jar包
 
2. 注册驱动
 
3. 获取数据库连接对象
 
4. 定义sql语句
 
5. 获取执行sql的对象 Statement
 
6. 执行sql
 
7. 对结果进行处理
 
8. 释放资源
 
2.准备工作
 
在使用之前，需要有一些准备工作，先创建相应的数据库userdml，并且插入相应的数据，方便测试：
 
DROP TABLE IF EXISTS `userdml`;
CREATE TABLE `userdml` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `gender` varchar(5) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `address` varchar(20) DEFAULT NULL,
  `qq` varchar(20) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of userdml
-- ----------------------------
INSERT INTO `userdml` VALUES ('1', '张三', '男', '18', '陕西', '123455', 'zhangsan@itcast.cn');
INSERT INTO `userdml` VALUES ('2', '李四', '女', '27', '西藏', '8856658', 'ls@itcast.cn');
INSERT INTO `userdml` VALUES ('3', '叶辰', '男', '21', '上海', '1235475', 'zhangsan@itcast.cn');
INSERT INTO `userdml` VALUES ('4', '若雪', '女', '20', '贵州', '87898', 'ls@itcast.cn');

 
3.JDBC连接数据库步骤代码详解
 
1.导入数据库对应的jar包，并Add As Library
 
2.注册驱动
 
1.编写数据库配置文件jdbc.properties
 
url=jdbc:mysql://localhost:3306/test02?serverTimezone=Asia/Shanghai
user=root
password=123456
driver=com.mysql.cj.jdbc.Driver
 
2.编写JDBCUtils工具类读取配置文件，获取连接，关闭资源
 
import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

/**
 * JDBC工具类,加载驱动，获取连接
 */
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;

    /**
     * 配置文件的读取
     */
    static {
        // 读取资源文件，获取值。
        try {
            //1. 创建Properties集合类。
            Properties pro = new Properties();
            //2. 加载文件使用ClassLoader 类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL resource = classLoader.getResource("jdbc.properties");
            String path = resource.getPath();
            
            pro.load(new FileReader(path));

            url = pro.getProperty("url");
            user = pro.getProperty("user");
            password = pro.getProperty("password");
            driver = pro.getProperty("driver");

            Class.forName(driver);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取连接
     *
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 操作完成后，释放资源
     *
     * @param state
     * @param conn
     */
    public static void close(Statement state, Connection conn) {
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

    /**
     * 释放资源
     *
     * @param state
     * @param conn
     */
    public static void close(ResultSet rs, Statement state, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (state != null) {
            try {
                state.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }
}

 
3.编写测试类，测试JDBC连接的工具类，进行数据库连接
 
import com.syp.domain.Emp;
import com.syp.domain.User;
import com.syp.utils.JDBCUtils;

import java.io.PushbackReader;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

/**
 * @description:JDBC数据库连接步骤的基本使用
 * @return
 */

public class JDBCDemoTest {
    public static void main(String[] args) {
        //调用方法,以及方法的返回值
        List<User> list = new JDBCDemoTest().findAllUser();
        // 遍历打印结果
        for (User user : list) {
            System.out.println(user);
        }
    }

    private List<User> findAllUser() {
        //1、导入数据库对应的jar包，并Add As Library
        //2、注册驱动，将驱动封装为工具类JDBCUtils
        Connection connection = null;
        Statement statement = null;
        ResultSet resultSet = null;
        ArrayList<User> users = null;
        try {
            //3.获取连接
            connection = JDBCUtils.getConnection();
            //4.定义sql语句
            String sql = "select * from userdml";

            //5.获取执行sql的对象
            statement = connection.createStatement();
            //6.执行sql
            resultSet = statement.executeQuery(sql);
            //7.遍历结果集，封装对象，对集合进行装载
            users = new ArrayList<>();

            while (resultSet.next()) {
                //获取数据,对应数据库表
                long id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                String gender = resultSet.getString("gender");
                int age = resultSet.getInt("age");
                String address = resultSet.getString("address");
                String qq = resultSet.getString("qq");
                String email = resultSet.getString("email");
                // 创建user实体对象,并赋值
                User user = new User();
                user.setId(id);
                user.setName(name);
                user.setGender(gender);
                user.setAge(age);
                user.setAddress(address);
                user.setQQ(qq);
                user.setEmail(email);

                //装载集合
                users.add(user);
            }

        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            JDBCUtils.close(resultSet, statement, connection);
            //返回结果
            return users;
        }
    }
}


 
4.程序运行结果：
 
 
 
总结
 
以上就是个人关于JDBC连接数据库的步骤，方法的简单记录

JDBC是什么？
 
在java web中，数据库是不可缺少的一部分，而数据库的连接通常使用java完成，因此便有了JDBC技术（java database connectivity 数据库连接技术）。从此，数据库与网页之间便有了联系，变得密不可分。
 
这篇文章先从基础的开始，先不涉及网页，从一个Java应用的JDBC方法来入门，会更好地看清JDBC的操作，那就开始吧！
 
JDBC的编写流程
 
简介
 
通常来说JDBC的操作一般分为以下几步：
 1.导入需要操作的数据库jdbc驱动包和创建数据库
 2.将jdbc包加载至JVM中
 3.通过DriverManager类中getConnection方法获取到对应数据库连接对象
 4.编写需要操作的sql语句
 5.通过连接对象创建编译对象
 6.接受并处理返回的结果
 7.释放资源
 
看到上面的这些步骤，从来没有接触过JDBC的小伙伴可能就懵了，这些都是什么呀？别怕！其实JBDC是非常死板的别写格式，接下来博主就一步一步地来讲解这些步骤。
 
具体实现
 
1.第一步：导入需要操作的数据库jdbc驱动包和创建数据库
 
主要的数据库主要有SQL Server、MySQL、Oracle这样三种，需要去找寻对应的jdbc驱动jar包。
 
方法：推荐前往Maven仓库寻找，里面各个版本主流的ar包都能够找到，较为方便。链接为Maven中央仓库
 
博主使用的是MySQL8，所以接下来的演示就以此来进行。
 
 
输入后点击搜索。
 
 点击第一个链接
 
 便可以在下面的驱动包列表中选择自己需要的jar包了。
 
JDBC驱动包必须要和自己使用的数据库版本对应，否则会报错。
 
这里博主由于使用的是MySQL8，选择8.0.x中的版本
 
 然后点击进入选择下载
 
 下载完成就要把jar包导入项目啦！
 
博主使用的是IntelliJ IDEA，如果有使用eclipse的小伙伴，操作流程是一样的，也可以参考。
 
首先先创建一个新的Java项目，不需要勾选任何框架，直接Next
 
 一路Next，起好项目名称，点击Finish这个项目就算创建好啦！
 
 接下来找到刚刚下载的jar包，黏贴到项目的lib目录下（如果没有lib目录，就自己创建一个文件夹，命名为lib）
 
 最后一步，右击jar包选择Add as Library，然后JDBC的准备工作中Java的部分就算完成啦！
 
 博主就不多赘述建立数据库中建表的过程了，因为这是另外一项技术了，和JDBC关系不大，这里直接用博主已经建立好的数据库中的表来讲解。
 
这是一张用户表，接下来的编程演示就基于这张表
 
 2.第二步：代码实现
 
a.查询类功能
 
	import java.sql.*;
	
	public class JDBC {
    public static void main(String[] args) {
        //声明变量
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //将jdbc包加载至JVM中
            Class.forName("com.mysql.cj.jdbc.Driver");
            //声明连接数据库的url(本处使用的是本地的MySQL数据库)
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?serverTimezone=UTC", "root", "******");
            //编写需要操作的sql语句
            String sql = "select * from user";
            //通过连接对象创建编译对象
            preparedStatement = connection.prepareStatement(sql);
            //向编译对象发出sql指令
            resultSet = preparedStatement.executeQuery();
            //接受并处理返回的结果
            while (resultSet.next()) {
                System.out.println(resultSet.getInt("id")+ " " + resultSet.getString("username") + " " + resultSet.getString("password"));
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if(resultSet!=null){
                try{
                    resultSet.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try{
                    preparedStatement.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try{
                    connection.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }
    }
 
以上的代码可以总结为以下的模板,需要修改的地方博主帮大家用高亮打出，方便小伙伴阅读
 
import java.sql.*;
 
public class JDBC {
 public static void main(String[] args) {
 //声明变量
 Connection connection = null;
 PreparedStatement preparedStatement = null;
 ResultSet resultSet = null;
 
try {
 //将jdbc包加载至JVM中
 Class.forName(“驱动类名”);
 //声明连接数据库的url(本处使用的是本地的MySQL数据库)
 connection = DriverManager.getConnection(“需连接的数据库url”,“用户名”,“密码”);
 //编写需要操作的sql语句
 String sql = “编写需要操作的sql语句”;
 //通过连接对象创建编译对象
 preparedStatement = connection.prepareStatement(sql);
 //向编译对象发出sql指令
 resultSet = preparedStatement.executeQuery();
 //接受并处理返回的结果
 while (resultSet.next()) {
 System.out.println(输出要输出的值);
 }
 }catch(Exception e){
 e.printStackTrace();
 }finally {
 //释放资源
 if(resultSet!=null){
 try{
 resultSet.close();
 }catch(SQLException e){
 e.printStackTrace();
 }
 }
 if(preparedStatement!=null){
 try{
 preparedStatement.close();
 }catch(SQLException e){
 e.printStackTrace();
 }
 }
 if(connection!=null){
 try{
 connection.close();
 }catch(SQLException e){
 e.printStackTrace();
 }
 }
 }
 }
 b.插入修改类功能
 
import java.sql.*;

public class JDBC {
    public static void main(String[] args) {
        //声明变量
        Connection connection = null;
        Statement statement = null;

        try {
            //将jdbc包加载至JVM中
            Class.forName("com.mysql.cj.jdbc.Driver");
            //声明连接数据库的url(本处使用的是本地的MySQL数据库)
            connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?serverTimezone=UTC", "root", "******");
            //编写需要操作的sql语句
            String sql = "insert into user(id,username,password) values(6,'admin','admin')";
            //通过连接对象创建编译对象
            statement = connection.createStatement();
            //向编译对象发出sql指令
            statement.executeUpdate(sql);
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            //释放资源
            if(statement!=null){
                try{
                    statement.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try{
                    connection.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }
    }
}
 
以上的代码可以总结为以下的模板,需要修改的地方博主帮大家用高亮打出，方便小伙伴阅读
 import java.sql.*;
 
public class JDBC {
 public static void main(String[] args) {
 //声明变量
 Connection connection = null;
 Statement statement = null;
 try {
 //将jdbc包加载至JVM中
 Class.forName(“驱动类名”);
 //声明连接数据库的url(本处使用的是本地的MySQL数据库)
 connection = DriverManager.getConnection(“需连接的数据库url”,“用户名”,“密码”);
 //编写需要操作的sql语句
 String sql = “编写需要操作的sql语句”;
 //通过连接对象创建编译对象
 statement = connection.createStatement();
 //向编译对象发出sql指令
 statement.executeUpdate(sql);
 }catch(Exception e){
 e.printStackTrace();
 }finally {
 //释放资源
 if(statement!=null){
 try{
 statement.close();
 }catch(SQLException e){
 e.printStackTrace();
 }
 }
 if(connection!=null){
 try{
 connection.close();
 }catch(SQLException e){
 e.printStackTrace();
 }
 }
 }
 }
 }
 
这样一看，是不是发现每次编写JDBC只有这么一点点地方需要编写呢，其他的都是固定的模板，套用就完事了！
 所以说，JDBC并不难，准备上手的小伙伴也不要害怕呢，多多练习就OK啦！
 
附加资料
 
三种主流关系型数据库的驱动包名称和驱动类名
 
数据库
驱动类名
url
MySQL
com.mysql.jdbc.Driver (MySQL5及以下) com.mysql.cj.jdbc.Driver(MySQL6及以上)
jdbc:mysql://IP地址:端口号(默认3306)/数据库名字
SQL Sever
com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc:microsoft:sqlserver://IP地址:端口号(默认1433);DatabaseName=数据库名
Oracle
oracle.jdbc.driver.OracleDriver
dbc:oracle:thin:@IP地址:端口号(默认1521):数据库名
结语
 
这篇博客主要介绍了JDBC技术的实现，这项技术牵涉到了数据库中的sql查询语言以及编写代码使用的java语言，可能有的小伙伴想学java却没有学过数据库方面的相关知识，所以博主之后会更新关于数据库sql查询语句的讲解，如果说这篇文章有让你学到一定的知识的话，不妨点个赞和关注，让博主能够看到，如果讲解中有什么错误和疏忽，也劳烦在评论中指出或提问，博主会第一时间进行更新和答复，谢谢！

JDBC连接数据库，包含7个步骤
 
（1）加载JDBC驱动程序   
 
    在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），   这通过java.lang.Class类的静态方法forName(String className)实现，成功加载后，会将Driver类的实例注册到DriverManager类中。
 
代码如下：
 
static{
		try {
			Class.forName("com.mysql.jdbc.Driver");//加载数据库驱动
			}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
 
（2）提供JDBC连接的URL
 
    书写形式：协议：子协议：数据源标识   。 其中：
 
     协议：在JDBC中总是以jdbc开始 。子协议：是桥连接的驱动程序或是数据库管理系统名称。   数据源标识：标记找到数据库来源的地址与连接端口。
 
代码如下：
 
//连接MySql数据库，用户名和密码都是root   
     String url = "jdbc:mysql://localhost:3306/test" ;    
     String username = "root" ;   
     String password = "root" ;   
 
（3）创建数据库的连接   
 
代码如下：
 
 public static Connection getConn(){
    	 Connection conn = null;
    	 try {
    		conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root","root");//连接数据库	
    		 }
         catch(SQLException e){
    		 e.printStackTrace();
    	 }
    	 return conn;
 }
 
（4）创建一个Statement
 
    要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3 种类型：
 
    执行静态SQL语句。通常通过Statement实例实现。
    执行动态SQL语句。通常通过PreparedStatement实例实现。
    执行数据库存储过程。通常通过CallableStatement实例实现。
代码如下：
 
 public static Statement getStmt(Connection conn){
	   Statement stmt = null;
	   try {
		stmt = conn.createStatement();
	} catch (SQLException e) {
		e.printStackTrace();
	}
	   return stmt;
   }
 
（5）执行SQL语句
 
    Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate   和execute  
 
    ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句   ，返回一个结果集（ResultSet）对象。
    int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或   DELETE语句以及SQL DDL语句，如：CREATE TABLE和DROP TABLE等  
    execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的   语句。
代码如下：
 
 public static ResultSet executeQuery(Statement stmt,String sql){
	 ResultSet rs = null;
	 try {
		rs = stmt.executeQuery(sql);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return rs; 
 }
 
 
（6）处理结果   
 
    两种情况：  
 
    执行更新返回的是本次操作影响到的记录数。  
    执行查询返回的结果是一个ResultSet对象。  
     ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些行中数据的访问。
 
    使用结果集（ResultSet）对象的访问方法获取数据，代码如下：
 
while(rs.next()){             
    String name = rs.getString("name") ;        
    String pass = rs.getString(1) ; // 此方法比较高效         
}
 
（7）关闭JDBC对象
 
    操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源，关闭顺序和声明顺序相反：
 
    关闭记录集
    关闭声明  
    关闭连接对象
代码如下：
 
//关闭结果集
 public static void closeRs(ResultSet rs){
	   try {
			if(rs != null ){
				 rs.close();
				 rs = null;
			   }
		} catch (SQLException e) {
			e.printStackTrace();
		} 
 }
//关闭执行方法
 public static void closeStmt(Statement stmt){
	   try {
			if(stmt != null ){
				 stmt.close();
				 stmt = null;
			   }
		} catch (SQLException e) {
			e.printStackTrace();
		} 
	   
   }
//关闭连接
 public static void closeConn(Connection conn){
	   try {
		if(conn != null ){
			 conn.close();
			 conn = null;
		   }
	} catch (SQLException e) {
		e.printStackTrace();
	}
 }
 
JDBC连接数据库工具类代码
 
package com.njau.allnetitem;

import java.sql.*;

public class DB {
	static{
		try {
			Class.forName("com.mysql.jdbc.Driver");//加载数据库驱动
			}
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
 private DB() {}
 
 public static Connection getConn(){
    	 Connection conn = null;
    	 try {
    		conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db_baima", "root","123456");//连接数据库	
    		 }
         catch(SQLException e){
    		 e.printStackTrace();
    	 }
    	 return conn;
 }
 
 public static void closeConn(Connection conn){
	   try {
		if(conn != null ){
			 conn.close();
			 conn = null;
		   }
	} catch (SQLException e) {
		e.printStackTrace();
	}
 }
   
 public static Statement getStmt(Connection conn){
	   Statement stmt = null;
	   try {
		stmt = conn.createStatement();
	} catch (SQLException e) {
		e.printStackTrace();
	}
	   return stmt;
   }
   
 public static PreparedStatement getPStmt(Connection conn,String sql){
	   PreparedStatement pstmt = null;
	   try {
		pstmt = conn.prepareStatement(sql);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	   return pstmt;
   }
   
 public static void closeStmt(Statement stmt){
	   try {
			if(stmt != null ){
				 stmt.close();
				 stmt = null;
			   }
		} catch (SQLException e) {
			e.printStackTrace();
		} 
	   
   }
   
 public static ResultSet executeQuery(Statement stmt,String sql){
	 ResultSet rs = null;
	 try {
		rs = stmt.executeQuery(sql);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return rs; 
 }
 
 public static void closeRs(ResultSet rs){
	   try {
			if(rs != null ){
				 rs.close();
				 rs = null;
			   }
		} catch (SQLException e) {
			e.printStackTrace();
		} 
 } 
 
 public static ResultSet executeQuery(Connection conn,String sql){//重载
	 ResultSet rs = null;
	 try {
		rs = conn.createStatement().executeQuery(sql);
	} catch (SQLException e) {
		e.printStackTrace();
	}
	return rs;  
   } 
 }
 
工具类使用说明代码
 
//插入数据
public static void saveinfo(Object[] data) throws ParseException{
	Connection conn = null;
	PreparedStatement pstmt = null;
try {
    conn= DB.getConn();
	String sql = "insert into information value (null,?,?,?,?,?,?,?) ";
    pstmt = DB.getPStmt(conn, sql);
	pstmt.setString(1,(String) data[0]);
	pstmt.setString(2, (String) data[1]);
	pstmt.setString(3,(String) data[2]);
	pstmt.setString(4,(String) data[3]); 
	pstmt.setString(5,(String) data[4]);
	pstmt.setString(6,(String) data[5]);
	pstmt.setTimestamp(7 ,(Timestamp)data[6]);
	pstmt.executeUpdate();
	} 
	catch (SQLException e) {
		e.printStackTrace();
	}
    finally{
    	DB.closeStmt(pstmt);
    	DB.closeConn(conn);
    }
}
 
参考：
 
http://www.cnblogs.com/hongten/archive/2011/03/29/1998311.html
 
表示感谢！！

 
JDBC连接数据库
 
1、JDBC所需的四个参数（user，password，url，driverClass）
2、加载JDBC驱动程序
3、创建数据库的连接
4、创建一个preparedStatement
5、执行SQL语句
6、遍历结果集
7、处理异常，关闭JDBC对象资源
 

 
JDBC连接数据库，创建一个以JDBC连接数据库的程序，包含7个步骤：
 
1、JDBC所需的四个参数（user，password，url，driverClass）
 
（1）user用户名
 
（2）password密码
 
（3）URL定义了连接数据库时的协议、子协议、数据源标识，它们之间用冒号隔开。
 书写形式： 协议：子协议：数据源标识
 
 
 
协议：在JDBC中总是以jdbc开始
 子协议：是桥连接的驱动程序或是数据库管理系统名称。
 数据源标识：标记找到数据库来源的地址与连接端口。
 
 
例如：MySql的连接URL
 
jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=gbk ;    

useUnicode=true：表示使用Unicode字符集。
如果characterEncoding设置为gb2312或GBK，本参数必须设置为true 。
characterEncoding=gbk：字符编码方式。
 
（4）driverClass连接数据库所需的驱动。
 
2、加载JDBC驱动程序
 
在连接数据库之前，首先要加载想要连接的数据库的驱动到JVM（Java虚拟机），这通过java.lang.Class类的静态方法forName(String className)实现。
 
例如：
 
try{//加载MySql的驱动类    
         Class.forName("com.mysql.jdbc.Driver") ;    
    }catch(ClassNotFoundException e){    
         System.out.println("找不到驱动程序类 ，加载驱动失败！");    
         e.printStackTrace() ;    
    }   
 
成功加载后，会将Driver类的实例注册到DriverManager类中。
 
3、创建数据库的连接
 
（1）要连接数据库，需要向java.sql.DriverManager请求并获得Connection对象，该对象就代表一个数据库的连接。
 
（2）使用DriverManager的getConnectin(String url , String username , String password )方法传入指定的欲连接的数据库的路径、数据库的用户名和密码来获得。
 
例如：
 
//连接MySql数据库，用户名和密码都是root    
     String url = "jdbc:mysql://localhost:3306/test" ;     
     String username = "root" ;    
     String password = "root" ;    
     try{    
          Connection con = DriverManager.getConnection(url , username , password ) ;    
     }catch(SQLException se){    
          System.out.println("数据库连接失败！");    
          se.printStackTrace() ;    
     }    
 
4、创建一个preparedStatement
 
要执行SQL语句，必须获得java.sql.Statement实例，Statement实例分为以下3 种类型：
 
 
 
（1）执行静态SQL语句。通常通过Statement实例实现。
 （2）执行动态SQL语句。通常通过PreparedStatement实例实现。
 （3）执行数据库存储过程。通常通过CallableStatement实例实现。
 
 
具体的实现方式：
 
Statement stmt = con.createStatement() ;    

PreparedStatement pstmt = con.prepareStatement(sql) ;    

CallableStatement cstmt = con.prepareCall("{CALL demoSp(? , ?)}") ;    
 
5、执行SQL语句
 
Statement接口提供了三种执行SQL语句的方法：executeQuery 、executeUpdate和execute
 
 
 
（1）ResultSet executeQuery(String sqlString)：执行查询数据库的SQL语句，返回一个结果集（ResultSet）对象。
 （2）int executeUpdate(String sqlString)：用于执行INSERT、UPDATE或 DELETE语句以及SQL
 DDL语句，如：CREATE TABLE和DROP TABLE等
 （3）execute(sqlString):用于执行返回多个结果集、多个更新计数或二者组合的语句。
 
 
具体实现的代码：
 
ResultSet rs = stmt.executeQuery("SELECT * FROM ...") ;    

int rows = stmt.executeUpdate("INSERT INTO ...") ;    

boolean flag = stmt.execute(String sql) ;    
 
6、遍历结果集
 
两种情况：
 （1）执行更新返回的是本次操作影响到的记录数。
 
（2）执行查询返回的结果是一个ResultSet对象。
 
• ResultSet包含符合SQL语句中条件的所有行，并且它通过一套get方法提供了对这些行中数据的访问。    

• 使用结果集（ResultSet）对象的访问方法获取数据：    
 
//列是从左到右编号的，并且从列1开始    
 while(rs.next()){    
         String name = rs.getString("name") ;    
          String pass = rs.getString(1) ; // 此方法比较高效    
     }
 
7、处理异常，关闭JDBC对象资源
 
操作完成以后要把所有使用的JDBC对象全都关闭，以释放JDBC资源。
 
关闭顺序和声明顺序相反：
 
 
 
（1）先关闭requestSet
 （2）再关闭preparedStatement
 （3）最后关闭连接对象connection
 
 
if(rs !=null){   // 关闭记录集
    try {
       rs.close();
    } catch (SQLException e) {
       e.printStackTrace();   
    }
}

if(stmt !=null){   // 关闭声明
    try {
       stmt.close();
    } catch (SQLException e) {
       e.printStackTrace();
    }
}

if(conn !=null){  // 关闭连接对象
    try {
       conn.close();
     } catch (SQLException e) {
        e.printStackTrace();   
     }
}
 
转载自:https://www.cnblogs.com/liubin1988/p/7865907.html