原文地址https://www.cnblogs.com/huguodong/p/5910859.html

JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系数据库提供统一访问，它由一组用java语言编写的类和接口组成。

有了JDBC，向各种关系数据发送SQL语句就是一件很容易的事。换言之，有了JDBC API，就不必为访问Sybase数据库专门写一个程序，为访问Oracle数据库又专门写一个程序，或为访问Informix数据库又编写另一个程序等等，程序员只需用JDBC API写一个程序就够了，它可向相应数据库发送SQL调用。

  1. /**
  2.  * JDBC:文件驱动
  3.  * 1.引入jar包 ojdbc.jar 在工程的目录下创建一个lib文件夹用来存放jar包
  4.  * 在ojdbc14.jar这个文件上右键==>build Path==> add to build Path
  5.  * 2.编写DB类
  6.  * a.加载驱动
  7.  * b.设置参数url user pwd
  8.  * c.连接数据库
  9.  * d.编写sql语句
  10.  * e.编译sql语句
  11.  * f.如果存在条件
  12.  * 设置条件后执行sql语句，如果没有条件直接执行sql语句 g.如果是增删改 那么sql执行结束 如果是查询，遍历结果集 f.关闭数据库
  13.  *
  14.  *
  15.  *
  16.  */

二、初始化

1.配置连接：在引入了ojdbc14.jar包之后，我们需要使用Class.forName方法加载驱动，然后通过DriverManager.getConnection来获取连接

  1.     // 初始化
  2.     public void init() {
  3.         // 不同的数据库有不同的驱动
  4.         String driverName = "oracle.jdbc.driver.OracleDriver";
  5.         String url = "jdbc:oracle:thin:@192.168.1.150:1521:XE";
  6.         String user = "hr";
  7.         String password = "123456";
  8.  
  9.         try {
  10.             // 加载驱动
  11.             Class.forName(driverName);
  12.             // 设置 配置数据
  13.             // 1.url(数据看服务器的ip地址 数据库服务端口号 数据库实例)
  14.             // 2.user
  15.             // 3.password
  16.             conn = DriverManager.getConnection(url, user, password);
  17.             // 开始连接数据库
  18.             System.out.println("数据库连接成功..");
  19.         } catch (ClassNotFoundException e) {
  20.             // TODO 自动生成的 catch 块
  21.             e.printStackTrace();
  22.         } catch (SQLException e) {
  23.             // TODO 自动生成的 catch 块
  24.             e.printStackTrace();
  25.         }
  26.  
  27.     }

2.初始化

  1.     Connection conn = null;
  2.  
  3.     public static void main(String[] args) {
  4.         DB db = new DB();
  5.         db.init();
  6. }

三、操作

如果我们需要操作数据，就需要一个容器来保存它，这里我们可以用javabean来保存他们。

  1. public class Student {
  2.  
  3.     private Integer id;
  4.     private String name;
  5.     private Integer age;
  6.     private Integer agestart;
  7.     private Integer ageend;
  8.     public Integer getAgestart() {
  9.         return agestart;
  10.     }
  11.  
  12.     public void setAgestart(Integer agestart) {
  13.         this.agestart = agestart;
  14.     }
  15.  
  16.     public Integer getAgeend() {
  17.         return ageend;
  18.     }
  19.  
  20.     public void setAgeend(Integer ageend) {
  21.         this.ageend = ageend;
  22.     }
  23.  
  24.     public Student() {
  25.         // TODO 自动生成的构造函数存根
  26.     }
  27.  
  28.     public Student(Integer id, String name, Integer age) {
  29.         super();
  30.         this.id = id;
  31.         this.name = name;
  32.         this.age = age;
  33.     }
  34.  
  35.     public Integer getId() {
  36.         return id;
  37.     }
  38.  
  39.     public void setId(Integer id) {
  40.         this.id = id;
  41.     }
  42.  
  43.     public String getName() {
  44.         return name;
  45.     }
  46.  
  47.     public void setName(String name) {
  48.         this.name = name;
  49.     }
  50.  
  51.     public Integer getAge() {
  52.         return age;
  53.     }
  54.  
  55.     public void setAge(Integer age) {
  56.         this.age = age;
  57.     }
  58. }

1.简单的查询

  1.     public List<Student> select() throws SQLException {
  2.  
  3.         List<Student> list = new ArrayList<Student>();
  4.         // *查询
  5.         // 创建sql语句
  6.         String sqlString = "select * from student";
  7.         // 编译sql语句
  8.         // 执行查询
  9.         pst = conn.prepareStatement(sqlString);
  10.         rSet = pst.executeQuery();
  11.         // 遍历结果
  12.         Student student = null;
  13.         while (rSet.next()) {
  14.             // System.out.print(rSet.getInt(1) + "\t");
  15.             // System.out.print(rSet.getString(2) + "\t");
  16.             // System.out.print(rSet.getInt(3) + "\t");
  17.             // System.out.print("\n");
  18.             student = new Student();
  19.             student.setId(rSet.getInt(1));
  20.             student.setName(rSet.getString(2));
  21.             student.setAge(rSet.getInt(3));
  22.             list.add(student);
  23.  
  24.         }
  25.  
  26.         return list;
  27.     }
  1. List<Student> students = null;
  2. students = db.select();
  3.  for (int i = 0; i < students.size(); i++) {
  4.              System.out.print(students.get(i).getId() + "\t");
  5.              System.out.print(students.get(i).getName() + "\t");
  6.              System.out.print(students.get(i).getAge());
  7.              System.out.println();
  8.              }

结果：

2.条件查询

  1.     public List<Student> selectByStu(int age) throws SQLException {
  2.         List<Student> students = new ArrayList<Student>();
  3.         String sql = "select * from student where sage=? ";
  4.  
  5.         pst = conn.prepareStatement(sql);
  6.         // 设置条件(相对于条件查询)
  7.         pst.setInt(1, age);
  8.         rSet = pst.executeQuery();
  9.         Student student = null;
  10.         while (rSet.next()) {
  11.             student = new Student();
  12.             student.setId(rSet.getInt(1));
  13.             student.setName(rSet.getString(2));
  14.             student.setAge(rSet.getInt(3));
  15.             students.add(student);
  16.         }
  17.  
  18.         return students;
  19.     }
  1.     students = db.selectByStu(20);
  2.         for (int i = 0; i < students.size(); i++) {
  3.              System.out.print(students.get(i).getId() + "\t");
  4.              System.out.print(students.get(i).getName() + "\t");
  5.              System.out.print(students.get(i).getAge());
  6.              System.out.println();
  7.              }

结果：

3.多个条件查询

  1.     public List<Student> selectByCondition(Student e) throws SQLException {
  2.         List<Student> students = new ArrayList<Student>();
  3.         String sql = "select * from student where sage>? and sage<? ";
  4.         pst = conn.prepareStatement(sql);
  5.         pst.setInt(1, e.getAgestart());
  6.         pst.setInt(2, e.getAgeend());
  7.         rSet = pst.executeQuery();
  8.         Student student = null;
  9.         while (rSet.next()) {
  10.             student = new Student();
  11.             student.setId(rSet.getInt(1));
  12.             student.setName(rSet.getString(2));
  13.             student.setAge(rSet.getInt(3));
  14.             students.add(student);
  15.         }
  16.         return students;
  17.     }
  1.              Student stu = new Student();
  2.              stu.setAgestart(20);
  3.              stu.setAgeend(22);
  4.              students = db.selectByCondition(stu);
  5.  
  6.              for (int i = 0; i < students.size(); i++) {
  7.              System.out.print(students.get(i).getId() + "\t");
  8.              System.out.print(students.get(i).getName() + "\t");
  9.              System.out.print(students.get(i).getAge());
  10.              System.out.println();
  11.              }

4.添加数据

  1.     public void save(Student student) throws SQLException {
  2.         String sql = "insert into student values (?,?,?,null,null,null,null,null)";
  3.  
  4.         pst = conn.prepareStatement(sql);
  5.         pst.setInt(1, student.getId());
  6.         pst.setString(2, student.getName());
  7.         pst.setInt(3, student.getAge());
  8.         pst.executeUpdate();
  9.         System.out.println("添加成功");
  10.     }

5.更新数据

  1.     public void update(Student student) throws SQLException {
  2.         String sql = "update student set sage=? where sid=?";
  3.  
  4.         pst = conn.prepareStatement(sql);
  5.         pst.setInt(1, student.getAge());
  6.         pst.setInt(2, student.getId());
  7.         pst.executeUpdate();
  8.         System.out.println("更新成功");
  9.     }

6.删除数据

  1. public void delete(Integer id) throws SQLException {
  2.         String sql = "delete student where sid=?";
  3.  
  4.         pst = conn.prepareStatement(sql);
  5.         pst.setInt(1, id);
  6.         pst.executeUpdate();
  7.         System.out.println("删除成功");
  8.     }

7.分页

  1.     public List<Student> findByPage(int start, int end) throws SQLException {
  2.         List<Student> students = new ArrayList<Student>();
  3.         String sql = "select s_.* from(select  s.*,rownum rn from (select * from student order by sid) s where rownum<=?) s_  where rn>?";
  4.  
  5.         pst = conn.prepareStatement(sql);
  6.         pst.setInt(1, end);
  7.         pst.setInt(2, start);
  8.         rSet = pst.executeQuery();
  9.         Student student = null;
  10.         while (rSet.next()) {
  11.             student = new Student();
  12.             student.setId(rSet.getInt(1));
  13.             student.setName(rSet.getString(2));
  14.             student.setAge(rSet.getInt(3));
  15.             students.add(student);
  16.         }
  17.         return students;
  18.     }

四、笔记

  1. package com.hgd.study.JDBC;
  2.  
  3. import java.net.CookieHandler;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.ResultSet;
  8. import java.sql.SQLException;
  9. import java.util.ArrayList;
  10. import java.util.List;
  11.  
  12. public class DB {
  13.     Connection conn = null;
  14.     PreparedStatement pst;
  15.     ResultSet rSet;
  16.  
  17.     public static void main(String[] args) {
  18.         DB db = new DB();
  19.  
  20.         List<Student> students = null;
  21.         try {
  22.             db.initConn();
  23.             //students = db.select();
  24.  
  25.             //students = db.selectByStu(20);
  26.  
  27.              Student stu = new Student();
  28.              stu.setAgestart(20);
  29.              stu.setAgeend(22);
  30.              students = db.selectByCondition(stu);
  31.  
  32.              for (int i = 0; i < students.size(); i++) {
  33.              System.out.print(students.get(i).getId() + "\t");
  34.              System.out.print(students.get(i).getName() + "\t");
  35.              System.out.print(students.get(i).getAge());
  36.              System.out.println();
  37.              }
  38.  
  39.             // Student stu = new Student(123, "李四", 23);
  40.             // db.save(stu);
  41.  
  42.             // Student stu=new Student();
  43.             // stu.setId(10003);
  44.             // stu.setAge(23);
  45.             // db.update(stu);
  46.  
  47.             // db.delete(123);
  48.  
  49.             /*
  50.              * 事物： 1.原子性：每一个事物都是一个单独的操作 2.一致性：事物中的所有操作，只要成功全部成功，一旦失败全部失败
  51.              * 3.隔离性：事物中的操作之间没不会产生影响他们都是一个独立的操作 4.持久性：事物一旦成功将被永久写入数据库
  52.              */
  53.             // conn.setAutoCommit(false);// 设置自动事物为false
  54.             // conn.setSavepoint();// 设置事物的回滚点
  55.             // conn.rollback();//事物回滚
  56.             // conn.commit();//事物提交
  57.             // db.setAutoCommit(false);
  58.             // db.setSavepoint();
  59.             // Student stu = new Student();
  60.             // stu.setId(10003);
  61.             // stu.setAge(0);
  62.             // db.update(stu);
  63.             // if (stu.getAge() <= 0) {
  64.             // db.rollback();
  65.             // System.out.println("取消了操作");
  66.             // } else {
  67.             // db.commit();
  68.             // }
  69.  
  70.         } catch (Exception e) {
  71.             // TODO 自动生成的 catch 块
  72.             e.printStackTrace();
  73.         } finally {
  74.             try {
  75.                 db.close();
  76.             } catch (Exception e) {
  77.                 // TODO 自动生成的 catch 块
  78.                 e.printStackTrace();
  79.             }
  80.         }
  81.     }
  82.  
  83.     // 初始化
  84.     public void init() {
  85.         // 不同的数据库有不同的驱动
  86.         String driverName = "oracle.jdbc.driver.OracleDriver";
  87.         String url = "jdbc:oracle:thin:@192.168.1.150:1521:XE";
  88.         String user = "hr";
  89.         String password = "123456";
  90.  
  91.         try {
  92.             // 加载驱动
  93.             Class.forName(driverName);
  94.             // 设置 配置数据
  95.             // 1.url(数据看服务器的ip地址 数据库服务端口号 数据库实例)
  96.             // 2.user
  97.             // 3.password
  98.             conn = DriverManager.getConnection(url, user, password);
  99.             // 开始连接数据库
  100.             System.out.println("数据库连接成功..");
  101.         } catch (ClassNotFoundException e) {
  102.             // TODO 自动生成的 catch 块
  103.             e.printStackTrace();
  104.         } catch (SQLException e) {
  105.             // TODO 自动生成的 catch 块
  106.             e.printStackTrace();
  107.         }
  108.  
  109.     }
  110.  
  111.     public void initConn() throws Exception {
  112.         if (conn == null || conn.isClosed()) {
  113.             this.init();
  114.         }
  115.     }
  116.  
  117.     public void close() throws Exception {
  118.         if (conn != null && !conn.isClosed()) {
  119.             conn.close();
  120.             conn = null;
  121.  
  122.         }
  123.     }
  124.  
  125.     public void setAutoCommit(boolean fals) throws Exception {
  126.         if (conn != null && !conn.isClosed()) {
  127.             conn.setAutoCommit(fals);
  128.         }
  129.     }
  130.  
  131.     public void setSavepoint() throws Exception {
  132.         if (conn != null && !conn.isClosed()) {
  133.             conn.setSavepoint();
  134.         }
  135.     }
  136.  
  137.     public void rollback() throws Exception {
  138.         if (conn != null && !conn.isClosed()) {
  139.             conn.rollback();
  140.         }
  141.     }
  142.  
  143.     public void commit() throws Exception {
  144.         if (conn != null && !conn.isClosed()) {
  145.             conn.commit();
  146.         }
  147.     }
  148.  
  149.     // 简单查询
  150.     public List<Student> select() throws SQLException {
  151.  
  152.         List<Student> list = new ArrayList<Student>();
  153.         // *查询
  154.         // 创建sql语句
  155.         String sqlString = "select * from student";
  156.         // 编译sql语句
  157.         // 执行查询
  158.         pst = conn.prepareStatement(sqlString);
  159.         rSet = pst.executeQuery();
  160.         // 遍历结果
  161.         Student student = null;
  162.         while (rSet.next()) {
  163.             // System.out.print(rSet.getInt(1) + "\t");
  164.             // System.out.print(rSet.getString(2) + "\t");
  165.             // System.out.print(rSet.getInt(3) + "\t");
  166.             // System.out.print("\n");
  167.             student = new Student();
  168.             student.setId(rSet.getInt(1));
  169.             student.setName(rSet.getString(2));
  170.             student.setAge(rSet.getInt(3));
  171.             list.add(student);
  172.  
  173.         }
  174.  
  175.         return list;
  176.     }
  177.  
  178.     // 条件查询
  179.     public List<Student> selectByStu(int age) throws SQLException {
  180.         List<Student> students = new ArrayList<Student>();
  181.         String sql = "select * from student where sage=? ";
  182.  
  183.         pst = conn.prepareStatement(sql);
  184.         // 设置条件(相对于条件查询)
  185.         pst.setInt(1, age);
  186.         rSet = pst.executeQuery();
  187.         Student student = null;
  188.         while (rSet.next()) {
  189.             student = new Student();
  190.             student.setId(rSet.getInt(1));
  191.             student.setName(rSet.getString(2));
  192.             student.setAge(rSet.getInt(3));
  193.             students.add(student);
  194.         }
  195.  
  196.         return students;
  197.     }
  198.  
  199.     // 多个条件值查询
  200.     public List<Student> selectByCondition(Student e) throws SQLException {
  201.         List<Student> students = new ArrayList<Student>();
  202.         String sql = "select * from student where sage>? and sage<? ";
  203.         pst = conn.prepareStatement(sql);
  204.         pst.setInt(1, e.getAgestart());
  205.         pst.setInt(2, e.getAgeend());
  206.         rSet = pst.executeQuery();
  207.         Student student = null;
  208.         while (rSet.next()) {
  209.             student = new Student();
  210.             student.setId(rSet.getInt(1));
  211.             student.setName(rSet.getString(2));
  212.             student.setAge(rSet.getInt(3));
  213.             students.add(student);
  214.         }
  215.         return students;
  216.     }
  217.  
  218.     // 添加数据
  219.     public void save(Student student) throws SQLException {
  220.         String sql = "insert into student values (?,?,?,null,null,null,null,null)";
  221.  
  222.         pst = conn.prepareStatement(sql);
  223.         pst.setInt(1, student.getId());
  224.         pst.setString(2, student.getName());
  225.         pst.setInt(3, student.getAge());
  226.         pst.executeUpdate();
  227.         System.out.println("添加成功");
  228.     }
  229.  
  230.     // 更新数据
  231.     public void update(Student student) throws SQLException {
  232.         String sql = "update student set sage=? where sid=?";
  233.  
  234.         pst = conn.prepareStatement(sql);
  235.         pst.setInt(1, student.getAge());
  236.         pst.setInt(2, student.getId());
  237.         pst.executeUpdate();
  238.         System.out.println("更新成功");
  239.     }
  240.  
  241.     // 删除数据
  242.     public void delete(Integer id) throws SQLException {
  243.         String sql = "delete student where sid=?";
  244.  
  245.         pst = conn.prepareStatement(sql);
  246.         pst.setInt(1, id);
  247.         pst.executeUpdate();
  248.         System.out.println("删除成功");
  249.     }
  250.  
  251.     // 分页
  252.     public List<Student> findByPage(int start, int end) throws SQLException {
  253.         List<Student> students = new ArrayList<Student>();
  254.         String sql = "select s_.* from(select  s.*,rownum rn from (select * from student order by sid) s where rownum<=?) s_  where rn>?";
  255.  
  256.         pst = conn.prepareStatement(sql);
  257.         pst.setInt(1, end);
  258.         pst.setInt(2, start);
  259.         rSet = pst.executeQuery();
  260.         Student student = null;
  261.         while (rSet.next()) {
  262.             student = new Student();
  263.             student.setId(rSet.getInt(1));
  264.             student.setName(rSet.getString(2));
  265.             student.setAge(rSet.getInt(3));
  266.             students.add(student);
  267.         }
  268.         return students;
  269.     }
  270.  
  271. }

Java jdbc 操作数据库详解的更多相关文章

  1. JAVA采用JDBC连接操作数据库详解

    JDBC连接数据库概述 一.JDBC基础知识 JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供 ...

  2. java jdbc操作数据库通用代码

    1.准备工作 1> 新建一个配置文件,名为jdbc.properties将其放入src中 2>在项目中导入jdbc驱动,注意连接不同的数据库,所用到的驱动是不一样的,这些在网上都能找到 具 ...

  3. JAVA连接各种数据库详解

    Java数据库连接(JDBC)由一组用 Java 编程语言编写的类和接口组成.JDBC 为工具/数据库开发人员提供了一个标准的 API,使他们能够用纯Java API 来编写数据库应用程序.然而各个开 ...

  4. jdbc 操作步骤详解

    package com.itheima.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql ...

  5. JAVA通过JDBC连接Oracle数据库详解【转载】

    JAVA通过JDBC连接Oracle数据库详解 (2011-03-15 00:10:03) 转载▼http://blog.sina.com.cn/s/blog_61da86dd0100q27w.htm ...

  6. Java笔记（第七篇 JDBC操作数据库）

    JDBC是连接数据库和java程序的桥梁,通过JDBC API可以方便地实现对各种主流数据库的操作.学习java语言,必须学习JDBC技术,因为JDBC技术实在java语言中被广泛使用的一种操作数据库 ...

  7. Java基础之原生JDBC操作数据库

    前言 日常开发中,我们都习惯了使用ORM框架来帮我们操作数据库,本文复习.记录Java如何使用原生JDBC操作数据库 代码编写 封装几个简单方法 find查询方法 findOne查询方法 update ...

  8. 《Tomcat与Java Web开发技术详解》思维导图

    越想构建上层建筑,就越觉得底层基础很重要.补课系列. 书是良心书,就是太基础了,正适合补课. [纯文字版] Tomcat与Java Web开发技术详解 Servlet Servlet的生命周期 初始化 ...

  9. Java编程配置思路详解

    Java编程配置思路详解 SpringBoot虽然提供了很多优秀的starter帮助我们快速开发,可实际生产环境的特殊性,我们依然需要对默认整合配置做自定义操作,提高程序的可控性,虽然你配的不一定比官 ...

随机推荐

  1. 【WEB前端开发最佳实践系列】高可读的HTML

    一.HTML语义化 HTML5中增加了很多标签都是基于此类原则设计的(article   nav  header  footer).页面标签语义化的优点是使得搜索引擎以及第三方抓包工具等更容易读懂页面 ...

  2. css案例 - 评分效果的星星✨外衣

    纳尼?什么星星外衣?好,直接上图比较能说清楚: 仔细看会发现规律:可以根据百分比/分值动态改变高亮星星的个数. 分步骤图: 这种效果,如果遇到一分一个星,没有半星(或者有也可以,直接加一个半星的类名) ...

  3. HDFS的客户端操作

    命令行操作: -help      功能:输出这个命令参数手册 -ls                   功能:显示目录信息 示例: hadoop fs -ls hdfs://hadoop-serv ...

  4. Android单例模式

    Android设计模式系列(3)--SDK源码之单例模式:http://www.cnblogs.com/qianxudetianxia/archive/2011/08/07/2130306.html ...

  5. Android 使用tomcat搭建HTTP文件下载服务器

    上一篇: Android 本地搭建Tomcat服务器供真机测试 1.假设需要下载的文件目录是D:\download1(注意这里写了个1,跟后面的名称区分) 2.设置 tomcat 的虚拟目录.在 {t ...

  6. java（9）并发编程

    整理自<java 并发编程的艺术> 1. 上下文切换 即使是单核处理器也支持多线程执行代码,CPU通过给每个线程分配CPU时间片来实现这个机制.时间片是CPU分配给各个线程的时间,因为时间 ...

  7. rman 中遇到 ORA-01861

    RMAN> run{ 2> sql 'alter session set nls_date_format="yyyy-mm-dd hh24:mi:ss"'; 3> ...

  8. sencha touch JsonP 自动提示消息 masked

    //公用类 Ext.define('app.util', { alternateClassName: 'util', statics: { /*为Ext.Viewport添加一个消息提示组件(需要初始 ...

  9. 如何启动、关闭和设置ubuntu防火墙

    如何启动.关闭和设置ubuntu防火墙 引自:http://www.cnblogs.com/jiangyao/archive/2010/05/19/1738909.html 就这句话就够了,下面的可以 ...

  10. parted分区脚本

    #!/bin/bash #Used to fomat 6 disks PATH=/bin:/sbin:/usr/bin:/usr/sbin export PATH disk_to_parted=&qu ...