Jdbc标准编程

最新推荐文章于 2022-07-13 17:48:05 发布
最新推荐文章于 2022-07-13 17:48:05 发布
阅读量461 收藏
点赞数
分类专栏： 数据库 文章标签： jdbc 编程 null oracle string scroll
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langzi1105/article/details/2769398
版权
  1. package com.yelang;
  3. import java.sql.*;
  5. public class TestJdbc
  6. {
  7.     public static void main(String[] args)
  8.     {
  9.         Connection conn = null;
  10.         Statement stmt = null;
  11.         ResultSet rs = null;
  12.         try
  13.         {
  14.             // Class.forName("com.mysql.jdbc.Driver").newInstance();
  15.             // new com.mysql.jdbc.Driver();
  16.             Class.forName("com.mysql.jdbc.Driver");
  17.             conn = DriverManager.getConnection(
  18.                     "jdbc:mysql://localhost:3306/shiyan", "root", "111");
  19.             stmt = conn.createStatement();
  20.             rs = stmt.executeQuery("select * from user");
  21.             while (rs.next())
  22.             {
  23.                 System.out.println(rs.getString("username"));
  24.                 System.out.println(rs.getString("password"));
  25.             }
  26.         }
  27.         catch (ClassNotFoundException e)
  28.         {
  29.             e.printStackTrace();
  30.         }
  31.         catch (SQLException e)
  32.         {
  33.             e.printStackTrace();
  34.         }
  35.         finally
  36.         {
  37.             try
  38.             {
  39.                 if (rs != null)
  40.                 {
  41.                     rs.close();
  42.                     rs = null;
  43.                 }
  44.                 if (stmt != null)
  45.                 {
  46.                     stmt.close();
  47.                     stmt = null;
  48.                 }
  49.                 if (conn != null)
  50.                 {
  51.                     conn.close();
  52.                     conn = null;
  53.                 }
  54.             }
  55.             catch (SQLException e)
  56.             {
  57.                 e.printStackTrace();
  58.             }
  60.         }
  61.     }
  62. }

 PreparedStatement

 

  1. import java.sql.*;
  3. public class TestPrepStmt
  4. {
  6.     public static void main(String[] args)
  7.     {
  8.         if (args.length != 3)
  9.         {
  10.             System.out.println("Parameter Error! Please Input Again!");
  11.             System.exit(-1);
  12.         }
  14.         int deptno = 0;
  16.         try
  17.         {
  18.             deptno = Integer.parseInt(args[0]);
  19.         }
  20.         catch (NumberFormatException e)
  21.         {
  22.             System.out
  23.                     .println("Parameter Error! Deptno should be Number Format!");
  24.             System.exit(-1);
  25.         }
  27.         String dname = args[1];
  28.         String loc = args[2];
  30.         PreparedStatement pstmt = null;
  31.         Connection conn = null;
  32.         try
  33.         {
  34.             Class.forName("oracle.jdbc.driver.OracleDriver");
  35.             // new oracle.jdbc.driver.OracleDriver();
  36.             conn = DriverManager.getConnection(
  37.                     "jdbc:oracle:thin:@192.168.0.1:1521:SXT", "scott", "tiger");
  38.             pstmt = conn.prepareStatement("insert into dept2 values (?, ?, ?)");
  39.             pstmt.setInt(1, deptno);
  40.             pstmt.setString(2, dname);
  41.             pstmt.setString(3, loc);
  42.             pstmt.executeUpdate();
  43.         }
  44.         catch (ClassNotFoundException e)
  45.         {
  46.             e.printStackTrace();
  47.         }
  48.         catch (SQLException e)
  49.         {
  50.             e.printStackTrace();
  51.         }
  52.         finally
  53.         {
  54.             try
  55.             {
  56.                 if (pstmt != null)
  57.                 {
  58.                     pstmt.close();
  59.                     pstmt = null;
  60.                 }
  61.                 if (conn != null)
  62.                 {
  63.                     conn.close();
  64.                     conn = null;
  65.                 }
  66.             }
  67.             catch (SQLException e)
  68.             {
  69.                 e.printStackTrace();
  70.             }
  71.         }
  72.     }
  74. }

 

存储过程

 

SQL>create or replace procedure p
  2    (v_a in number,v_b number,v_ret out number,v_temp in out number)
  3 is
  4
  5 begin
  6    if(v_a > v_b) then
  7   v_ret := v_a;
  8    else
  9   v_ret := v_b;
  10   end if;
  11   v_temp := v_temp + 1;
  12 end;

 

  1. import java.sql.*;
  3. public class TestProc
  4. {
  5.     public static void main(String[] args)
  6.     {
  8.         Connection conn = null;
  9.         CallableStatement cstmt = null;
  10.         try
  11.         {
  12.             Class.forName("oracle.jdbc.driver.OracleDriver");
  13.             conn = DriverManager.getConnection(
  14.                     "jdbc:oracle:thin:@192.168.0.1:1521:SXT", "scott", "tiger");
  15.             cstmt = conn.prepareCall("{call p(?, ?, ?, ?)}");
  16.             cstmt.registerOutParameter(3, Types.INTEGER);
  17.             cstmt.registerOutParameter(4, Types.INTEGER);
  18.             cstmt.setInt(1, 3);
  19.             cstmt.setInt(2, 4);
  20.             cstmt.setInt(4, 5);
  21.             cstmt.execute();
  22.             System.out.println(cstmt.getInt(3));
  23.             System.out.println(cstmt.getInt(4));
  24.         }
  25.         catch (Exception e)
  26.         {
  27.             e.printStackTrace();
  28.         }
  29.         finally
  30.         {
  31.             try
  32.             {
  33.                 if (cstmt != null)
  34.                 {
  35.                     cstmt.close();
  36.                     cstmt = null;
  37.                 }
  38.                 if (conn != null)
  39.                 {
  40.                     conn.close();
  41.                     conn = null;
  42.                 }
  43.             }
  44.             catch (SQLException e)
  45.             {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.     }
  50. }

 

批处理

  1. import java.sql.*;
  3. public class TestBatch
  4. {
  6.     public static void main(String[] args)
  7.     {
  8.         Connection conn = null;
  10.         PreparedStatement ps = null;
  11.         try
  12.         {
  13.             Class.forName("oracle.jdbc.driver.OracleDriver");
  14.             conn = DriverManager.getConnection(
  15.                     "jdbc:oracle:thin:@192.168.0.1:1521:SXT", "scott", "tiger");
  16.             ps = conn.prepareStatement("insert into dept2 values (?, ?, ?)");
  17.             ps.setInt(1, 61);
  18.             ps.setString(2, "haha");
  19.             ps.setString(3, "bj");
  20.             ps.addBatch();
  21.             ps.setInt(1, 62);
  22.             ps.setString(2, "haha");
  23.             ps.setString(3, "bj");
  24.             ps.addBatch();
  25.             ps.setInt(1, 63);
  26.             ps.setString(2, "haha");
  27.             ps.setString(3, "bj");
  28.             ps.addBatch();
  29.             ps.executeBatch();
  30.         }
  31.         catch (Exception e)
  32.         {
  33.             e.printStackTrace();
  34.         }
  35.         finally
  36.         {
  37.             try
  38.             {
  39.                 if (ps != null)
  40.                 {
  41.                     ps.close();
  42.                     ps = null;
  43.                 }
  44.                 if (conn != null)
  45.                 {
  46.                     conn.close();
  47.                     conn = null;
  48.                 }
  49.             }
  50.             catch (Exception e)
  51.             {
  52.                 e.printStackTrace();
  53.             }
  54.         }
  55.     }
  56. }

 

Transaction，事务处理

  1. import java.sql.*;
  3. public class TestTransaction
  4. {
  6.     public static void main(String[] args)
  7.     {
  9.         Connection conn = null;
  10.         Statement stmt = null;
  12.         try
  13.         {
  14.             Class.forName("oracle.jdbc.driver.OracleDriver");
  15.             conn = DriverManager.getConnection(
  16.                     "jdbc:oracle:thin:@127.0.0.1:1521:SXT", "scott", "tiger");
  17.             conn.setAutoCommit(false);
  18.             stmt = conn.createStatement();
  19.             stmt.addBatch("insert into dept2 values (51, '500', 'haha')");
  20.             stmt.addBatch("insert into dept2 values (52, '500', 'haha')");
  21.             stmt.addBatch("insert into dept2 values (53, '500', 'haha')");
  22.             stmt.executeBatch();
  23.             conn.commit();
  24.             conn.setAutoCommit(true);
  25.         }
  26.         catch (ClassNotFoundException e)
  27.         {
  28.             e.printStackTrace();
  29.         }
  30.         catch (SQLException e)
  31.         {
  33.             e.printStackTrace();
  35.             try
  36.             {
  37.                 if (conn != null)
  38.                 {
  39.                     conn.rollback();
  40.                     conn.setAutoCommit(true);
  41.                 }
  42.             }
  43.             catch (SQLException e1)
  44.             {
  45.                 e1.printStackTrace();
  46.             }
  47.         }
  48.         finally
  49.         {
  50.             try
  51.             {
  52.                 if (stmt != null)
  53.                     stmt.close();
  54.                 if (conn != null)
  55.                     conn.close();
  56.             }
  57.             catch (SQLException e)
  58.             {
  59.                 e.printStackTrace();
  60.             }
  61.         }
  62.     }
  63. }

 

JDBC处理可滚动的结果集

 

  1. import java.sql.*;
  3. public class TestScroll
  4. {
  5.     public static void main(String args[])
  6.     {
  7.         Connection conn = null;
  8.         Statement stmt = null;
  9.         ResultSet rs = null;
  10.         try
  11.         {
  12.             Class.forName("oracle.jdbc.driver.OracleDriver");
  13.             String url = "jdbc:oracle:thin:@192.168.0.1:1521:SXT";
  14.             conn = DriverManager.getConnection(url, "scott", "tiger");
  15.             stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
  16.                     ResultSet.CONCUR_READ_ONLY);
  17.             rs = stmt.executeQuery("select * from emp order by sal");
  18.             rs.next();
  19.             System.out.println(rs.getInt(1));
  20.             rs.last();
  21.             System.out.println(rs.getString(1));
  22.             System.out.println(rs.isLast());
  23.             System.out.println(rs.isAfterLast());
  24.             System.out.println(rs.getRow());
  25.             rs.previous();
  26.             System.out.println(rs.getString(1));
  27.             rs.absolute(6);
  28.             System.out.println(rs.getString(1));
  29.         }
  30.         catch (ClassNotFoundException e)
  31.         {
  32.             e.printStackTrace();
  33.         }
  34.         catch (SQLException e)
  35.         {
  36.             e.printStackTrace();
  37.         }
  38.         finally
  39.         {
  40.             try
  41.             {
  42.                 if (rs != null)
  43.                 {
  44.                     rs.close();
  45.                     rs = null;
  46.                 }
  47.                 if (stmt != null)
  48.                 {
  49.                     stmt.close();
  50.                     stmt = null;
  51.                 }
  52.                 if (conn != null)
  53.                 {
  54.                     conn.close();
  55.                     conn = null;
  56.                 }
  57.             }
  58.             catch (SQLException e)
  59.             {
  60.                 e.printStackTrace();
  61.             }
  62.         }
  63.     }
  64. }

 

JDBC处理可更新的结果集

 

  1. import java.sql.*;
  3. public class TestUpdataRs
  4. {
  5.     public static void main(String args[])
  6.     {
  8.         Connection conn = null;
  9.         Statement stmt = null;
  10.         ResultSet rs = null;
  11.         try
  12.         {
  13.             Class.forName("oracle.jdbc.driver.OracleDriver");
  14.             String url = "jdbc:oracle:thin:@192.168.0.1:1521:SXT";
  15.             conn = DriverManager.getConnection(url, "scott", "tiger");
  16.             stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
  17.                     ResultSet.CONCUR_UPDATABLE);
  18.             rs = stmt.executeQuery("select * from emp2");
  19.             rs.next();
  20.             // 更新一行数据
  21.             rs.updateString("ename", "AAAA");
  22.             rs.updateRow();
  24.             // 插入新行
  25.             rs.moveToInsertRow();
  26.             rs.updateInt(1, 9999);
  27.             rs.updateString("ename", "AAAA");
  28.             rs.updateInt("mgr", 7839);
  29.             rs.updateDouble("sal", 99.99);
  30.             rs.insertRow();
  31.             // 将光标移动到新建的行
  32.             rs.moveToCurrentRow();
  34.             // 删除行
  35.             rs.absolute(5);
  36.             rs.deleteRow();
  38.             // 取消更新
  39.             // rs.cancelRowUpdates();
  41.         }
  42.         catch (ClassNotFoundException e)
  43.         {
  44.             e.printStackTrace();
  45.         }
  46.         catch (SQLException e)
  47.         {
  48.             e.printStackTrace();
  49.         }
  50.         finally
  51.         {
  52.             try
  53.             {
  54.                 if (rs != null)
  55.                 {
  56.                     rs.close();
  57.                     rs = null;
  58.                 }
  59.                 if (stmt != null)
  60.                 {
  61.                     stmt.close();
  62.                     stmt = null;
  63.                 }
  64.                 if (conn != null)
  65.                 {
  66.                     conn.close();
  67.                     conn = null;
  68.                 }
  69.             }
  70.             catch (SQLException e)
  71.             {
  72.                 e.printStackTrace();
  73.             }
  74.         }
  75.     }
  76. }

 

 

langzi1105
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA 数据库编程
11-20
JDBC本身提供的是一套数据库操作标准，而这些标准又需要各个数据库厂商实现，所以针对于每一个数据库厂商都会提供一个JDBC的驱动程序，目前比较常见的JDBC驱动程序可分为以下四类： JDBC-ODBC桥驱动 JDBC本地驱动 ...
JDBC的标准实现
weixin_43761642的博客
04-21 108
package JDBCTest; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCtest { public st...
JDBC入门三：一个标准的JDBC范例；（JDBC引入，一个标准的例子）
小枯林的博客
04-10 362
目测JDBC和JavaScript一样，都是很重要而且基础性的东西。本篇博客，提供了相当于是JDBC初体验，是一个JDBC的范例，一个标准的流程。 目录 1：准备数据库 2.创建一Java工程 3.引入MySQL的驱动： 4.JDBC标准的代码范例（必须要牢记每个步骤） 1：准备数据库 字符集选择【utf8mb4】；这儿的【utf8】对应的是3字节的编码，即其在表达汉字或其他复杂字符的时候，最多能用3个字节来表示，即如果要存储复杂的生僻汉字或者Emoji这种表情符号的时候（这些字符是用
Java连接数据库规范——JDBC
鑫仔的记忆
07-13 622
Java连接数据库规范——JDBC
JDBC标准
qq_33672321的博客
09-02 216
导入JDBC包：使用Java语言的import语句在Java代码开头位置导入所需的类。 注册JDBC驱动程序：使JVM将所需的驱动程序实现加载到内存中，从而可以满足JDBC请求。 数据库URL配置：创建一个正确格式化的地址，指向要连接到的数据库(如：MySQL,Oracle和MSSQL等等)。 创建连接对象：最后，调用DriverManager对象的getConnection()方法来建立实...
JDBC标准写法
weixin_43184936的博客
05-01 541
JDBC //一个标准的JDBC程序 public void demo1(){ Connection conn=null; Statement statement=null; ResultSet resultSet=null; try { //1.加载驱动 // DriverManage...
JDBC基础知识
01-21
JDBC(Java DataBase connectivity， Java数据库连接)，是一种标准Java应用编程接口（JAVA API），用来连接 Java 编程语言和广泛的数据库。 　JDBC API 库包含下面提到的每个任务，都是与数据库相关的常用用法： 　...
sql server jdbc 4.2驱动
06-16
Microsoft JDBC Driver for SQL Server 是一个 Type 4 JDBC 驱动程序，它通过 Java 平台中可用的标准 JDBC 应用程序编程接口 (API) 提供数据库连接。 所有用户都可以免费下载驱动程序。 通过这些程序，用户可以从...
JDBC与Java数据库编程
09-23
JDBC与Java数据库编程 标准学习课件
JDBC连接数据库的标准步骤
10-05
JDBC连接数据库的标准步骤 1. 载入JDBC驱动程序(dbDriver) 2. 定义URL 3. 建立连接 4 创建Statement对象 5 执行查询或更新 6. 处理结果 7 关闭连接 实例java方式获取连接的一个方法
二、JDBC规范
天行健，君子以自强不息
06-06 193
JDBC规范
java- JDBC规范
weixin_45387943的博客
09-15 203
一。jar包: 1) 存放class文件的文件夹 2）可以在不同的项目中，使用同一组Java中class文件，避免java命令重复开发 二。接口的作用： 指定行为规范 interface 雷锋接口{ defalut 扶老人过马路(){return...} 为困难人士捐款() } class Person implements 雷锋接口{ 打游
JDBC之通过DatabaseMetaData对象了解数据库的信息
翔宇的blog.....
11-09 1213
原文链接：http://dev.csdn.net/develop/article/35/article/35/article/34/article/34/34864.shtmJSP通过JDBC对数据库管理系统进行连接以后，得到一个Connection 对象，可以从这个对象获得有关数据库管理系统的各种信息，包括数据库中的各个表，表中的各个列，数据类型，触发器，存储过程等各方面的信息。根据这些信息
标准JDBC连接
flood
06-14 780
import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; public class Test { /** * @param args */ public static void main(String
JDBC规范
m0_49364743的博客
11-19 1387
1、在说JDBC规范前先来了解两个概念JavaSE与JavaEE规范的区别 JavaSE规范：指Java类在单独运行，单独处理业务时需要遵守的语法规则。 JavaEE规范：指Java类在进行商业开发时需要遵守的语法规则，由于在商业开发时需要与13种不同的服务器进行沟通，所以sun公司根据这13中不同的服务器的特性制定了13套接口，这13套接口统称JavaEE规范，sun公司相当于汽车制造厂，负责提供接口，但不负责接口实现类，接口实现类由不同的服务器厂商来提供。服务器厂商将接口实现类以ja...
JDBC 常用函数实例说明
07-05 1145
对JDBC中常用到的一些函数
JDBC(规范和封装jdbc代码)
Akagiii的博客
04-17 905
主程序package zucc.edu.cn.jdbc; import java.sql.Connection; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Base { public static void main(String[] arg...
JDBC编程
最新发布
05-26
JDBC（Java Database Connectivity）是一种Java语言访问关系型数据库的API，它允许Java应用程序通过标准SQL语句访问数据库。在Java应用程序中使用JDBC可以实现对数据的增、删、改、查等操作。 以下是使用JDBC进行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值