try {
   Class.forName("oracle.jdbc.driver.OracleDriver");
}
catch(ClassNotFoundException ex) {
   System.out.println("Error: unable to load driver class!");
   System.exit(1);
}

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);
}

String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);

import java.util.*;
String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" );
​
Connection conn = DriverManager.getConnection(URL, info);

conn.close();

 Statement stmt = null;
 try {
    stmt = conn.createStatement( );
    . . .
 }
 catch (SQLException e) {
    . . .
 }
 finally {
    . . .
 }

Statement stmt = null;
try {
   stmt = conn.createStatement( );
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   stmt.close();
}

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   . . .
}

PreparedStatement pstmt = null;
try {
   String SQL = "Update Employees SET age = ? WHERE id = ?";
   pstmt = conn.prepareStatement(SQL);
   . . .
}
catch (SQLException e) {
   . . .
}
finally {
   pstmt.close();
}

try {
   Statement stmt = conn.createStatement(
                           ResultSet.TYPE_FORWARD_ONLY,
                           ResultSet.CONCUR_READ_ONLY);
}
catch(Exception ex) {
   ....
}
finally {
   ....
}

// Import required packages
import java.sql.*;
import java.io.*;
import java.util.*;
​
public class JDBCExample {
   // JDBC driver name and database URL
   static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";
   static final String DB_URL = "jdbc:mysql://localhost/EMP";
​
   //  Database credentials
   static final String USER = "username";
   static final String PASS = "password";
   public static void main(String[] args) {
   Connection conn = null;
   PreparedStatement pstmt = null;
   Statement stmt = null;
   ResultSet rs = null;
   try{
      // Register JDBC driver
      Class.forName("com.mysql.jdbc.Driver");
      // Open a connection
      System.out.println("Connecting to database...");
      conn = DriverManager.getConnection(DB_URL,USER,PASS);
​
      //Create a Statement object and build table
      stmt = conn.createStatement();
      createXMLTable(stmt);
​
      //Open a FileInputStream
      File f = new File("XML_Data.xml");
      long fileLength = f.length();
      FileInputStream fis = new FileInputStream(f);
​
      //Create PreparedStatement and stream data
      String SQL = "INSERT INTO XML_Data VALUES (?,?)";
      pstmt = conn.prepareStatement(SQL);
      pstmt.setInt(1,100);
      pstmt.setAsciiStream(2,fis,(int)fileLength);
      pstmt.execute();
​
      //Close input stream
      fis.close();
​
      // Do a query to get the row
      SQL = "SELECT Data FROM XML_Data WHERE id=100";
      rs = stmt.executeQuery (SQL);
      // Get the first row
      if (rs.next ()){
         //Retrieve data from input stream
         InputStream xmlInputStream = rs.getAsciiStream (1);
         int c;
         ByteArrayOutputStream bos = new ByteArrayOutputStream();
         while (( c = xmlInputStream.read ()) != -1)
            bos.write(c);
         //Print results
         System.out.println(bos.toString());
      }
      // Clean-up environment
      rs.close();
      stmt.close();
      pstmt.close();
      conn.close();
   }catch(SQLException se){
      //Handle errors for JDBC
      se.printStackTrace();
   }catch(Exception e){
      //Handle errors for Class.forName
      e.printStackTrace();
   }finally{
      //finally block used to close resources
      try{
         if(stmt!=null)
            stmt.close();
      }catch(SQLException se2){
      }// nothing we can do
      try{
         if(pstmt!=null)
            pstmt.close();
      }catch(SQLException se2){
      }// nothing we can do
      try{
         if(conn!=null)
            conn.close();
      }catch(SQLException se){
         se.printStackTrace();
      }//end finally try
   }//end try
   System.out.println("Goodbye!");
}//end main
​
public static void createXMLTable(Statement stmt)
   throws SQLException{
       System.out.println("Creating XML_Data table..." );
       //Create SQL Statement
       String streamingDataSql = "CREATE TABLE XML_Data " +
                                 "(id INTEGER, Data LONG)";
       //Drop table first if it exists.
       try{
          stmt.executeUpdate("DROP TABLE XML_Data");
       }catch(SQLException se){
       }// do nothing
       //Build table.
       stmt.executeUpdate(streamingDataSql);
    }//end createXMLTable
}//end JDBCExample

package javase.demo26.db.util;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
public class CommonJdbcLoadUtil {
    private static String DBDRIVER;
    private static String DBURL;
    private static String DBUSER;
    private static String DBPASS;
    private static final Properties PROPERTIES = new Properties();
    static {
        try {
            // idea中如果进行了模块化处理后，则所有的文件的路径实际上都不是相对原来的项目根路径了，而是相对于最顶层的项目路径了，因为原来myeclipse中的项目可能在idea中已经变成了模块了，所以要加上自己的模块的路径。
            PROPERTIES.load(new FileInputStream("myjavaSE/resource/jdbc.properties"));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        DBDRIVER = PROPERTIES.getProperty("jdbc.driver", "oracle.jdbc.driver.OracleDriver");
        DBURL = PROPERTIES.getProperty("jdbc.url", "jdbc:oracle:thin:@localhost:1521:orcl");
        DBUSER = PROPERTIES.getProperty("jdbc.username", "oracle");
        DBPASS = PROPERTIES.getProperty("jdbc.password", "oracle1234");
    }
    public static String getDbdriver() {
        return DBDRIVER;
    }
    public static String getDburl() {
        return DBURL;
    }
    public static String getDbuser() {
        return DBUSER;
    }
    public static String getDbpass() {
        return DBPASS;
    }
 }

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
/**
 * jdbc学习-DriverManager类就是加载jdbc驱动程序的管理类。
 * 如果不加载驱动程序，则DriverManager类将无法正常使用。
 * 加载jdbc驱动。
 * 如果该程序未报错，说明数据库oracle的驱动程序加载成功。
 *
 */
public class Demo01DriverManager {
    public static void main(String args[]) {
        try {
            //jdbc操作第一步：通过反射加载jdbc接口的驱动实现包
            Class.forName(CommonJdbcLoadUtil.getDbdriver());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println("程序正常执行，oracle驱动程序加载成功...");
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
 * jdbc学习
 * jdbc常见操作-通过DriverManager类取得Connection接口对象。
 */
public class Demo02Connection {
    public static void main(String args[]) {
        Connection con = null;
        try {
            // 1.加载驱动程序
            Class.forName(CommonJdbcLoadUtil.getDbdriver());
            // 2.连接oracle数据库服务器，返回连接对象。注意连接数据库服务器时用户名和密码一定要正确。
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        System.out.println("连接对象：" + con);
        try {
            con.close();// 6.连接完毕后一定要关闭数据库连接
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * jdbc学习
 * jdbc操作-利用statement对象执行建表操作。
 * 保存数据库连接信息的实体bean。
 */
class DbBean {
    // 建表sql，原生jdbc实现的sql硬编码。
    private static final String SQL = "create table person(id number(12),name varchar(21),age number(12),sex varchar(12),birthday Date)";
    public static String getSql() {
        return SQL;
    }
}
class DbHandel {
    public static void service() {
        Connection con = null;
        Statement statement = null;
        try {
            // 1.加载数据库驱动
            Class.forName(CommonJdbcLoadUtil.getDbdriver());
            // 2.建立数据库连接
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 连接数据，并取得连接对象
            // 3.创建statement对象
            statement = con.createStatement();// 取得Statement对象
            // 4.通过statement对象执行sql语句。
            statement.execute(DbBean.getSql());// 执行sql语句，创建表person
            System.out.println("创建表操作执行完毕....");
            // 5.处理返回结果，此处没有该步骤。
            // 6.倒序关闭statement对象和Connection对象
            statement.close();
            con.close();// 按照倒序关闭statement对象和con对象，也可直接关闭con对象，注意关闭顺序，先打开的后关闭
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层
 */
public class Demo03CreateTable {
    public static void main(String args[]) {
        DbHandel.service();// 处理主程序
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * jdbc-执行insert语句。
 * 保存数据库信息的实体bean。
 * 注意插入语句的日期格式。
 */
class DbBean04 {
    //原生jdbc实现的sql硬编码。
    private static final String SQL = "insert into person values(1001,'赵二虎',25,'男',to_date('1992-10-13','yyyy-mm-dd'))";
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 *
 * @author zhaoeh
 */
class DbInsertService {
    public static void insertService() {
        Connection con = null;
        Statement state = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 1.加载oracle驱动程序。
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 2.建立数据库连接
            state = con.createStatement();// 3.创建Statement对象
            state.execute(DbBean04.getSql());// 4.执行目标sql语句
            /**
             * 5.上述sql语句执行完毕后没有返回结果可处理
             */
            state.close();
            con.close();// 6.按照逆序关闭连接对象
            System.out.println("数据插入成功...");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口
 */
public class Demo04InsertData {
    public static void main(String args[]) {
        DbInsertService.insertService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * jdbc执行insert语句。
 * 定义数据实体的bean。
 */
class Person {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String birthday;
    public Person(int id, String name, int age, String sex, String birthday) {
        this.setId(id);
        this.setName(name);
        this.setAge(age);
        this.setSex(sex);
        this.setBirthday(birthday);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
/**
 * 保存数据库信息的实体bean
 * 注意插入语句的日期格式
 */
class DbBean05 {
    //通过实体对象封装数据信息
    private static final Person per = new Person(123, "于瑞", 23, "女",
            "1992-07-25");
    //通过实体对象动态拼接SQL语句
    private static final String SQL = "insert into person values("
            + DbBean05.per.getId() + ",'" + DbBean05.per.getName() + "',"
            + DbBean05.per.getAge() + ",'" + DbBean05.per.getSex()
            + "',to_date('" + DbBean05.per.getBirthday() + "','yyyy-mm-dd'))";
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 */
class Db05InsertService {
    public static void insertService() {
        Connection con = null;
        Statement state = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 1.加载oracle驱动程序
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 2.建立数据库连接对象
            state = con.createStatement();// 3.创建Statement对象
            System.out.println(DbBean05.getSql());
            state.execute(DbBean05.getSql());// 4.执行目标sql语句
            /**
             * 5.上述sql语句执行完毕后没有返回结果可处理
             */
            state.close();
            con.close();// 6.按照逆序关闭连接对象
            System.out.println("----数据插入成功----");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口
 */
public class Demo05InsertBeanData {
    public static void main(String args[]) {
        Db05InsertService.insertService();
    }
}    

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * jdbc学习
 * jdbc操作-更新数据。
 * 定义数据实体bean。
 */
class Person06 {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String birthday;
    public Person06(int id, String name, int age, String sex, String birthday) {
        this.setId(id);
        this.setName(name);
        this.setAge(age);
        this.setSex(sex);
        this.setBirthday(birthday);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
/**
 * 保存数据库信息的实体bean
 * 注意更新语句的日期格式
 */
class DbBean06 {
    //通过对象实体封装数据
    private static final Person06 per = new Person06(1223, "变更", 100, "男",
            "1992-10-15");
    //动态拼接SQL语句
    private static final String SQL = "update person set id="
            + DbBean06.per.getId() + ",name='" + DbBean06.per.getName()
            + "',age=" + DbBean06.per.getAge() + ",sex='"
            + DbBean06.per.getSex() + "',birthday=to_date('"
            + DbBean06.per.getBirthday() + "','yyyy-mm-dd') where name='于瑞'";
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 */
class Db06UpdateService {
    public static void insertService() {
        Connection con = null;
        Statement state = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 1.加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 2.建立连接
            state = con.createStatement();// 3.创建Statement对象
            System.out.println(DbBean06.getSql());
            state.executeUpdate(DbBean06.getSql());// 4.执行目标update sql语句
            /**
             * 5.上述sql语句执行完毕后没有返回结果可处理
             */
            state.close();
            con.close();// 6按照逆序关闭对象
            System.out.println("数据更新成功...");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口程序
 */
public class Demo06UpdateData {
    public static void main(String args[]) {
        Db06UpdateService.insertService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
/**
 * jdbc操作-删除数据。
 * 定义数据实体bean。
 */
class Person07 {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String birthday;
    public Person07(int id, String name, int age, String sex, String birthday) {
        this.setId(id);
        this.setName(name);
        this.setAge(age);
        this.setSex(sex);
        this.setBirthday(birthday);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
/**
 * 保存数据库信息的实体bean
 * 注意插入语句的日期格式
 */
class DbBean07 {
    private static final Person07 per = new Person07(456, "变更", 100, "男",
            "1992-10-15");
    private static final String SQL = "delete from person where name='"
            + DbBean07.per.getName() + "'";
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 */
class Db07DeleteService {
    public static void insertService() {
        Connection con = null;
        Statement state = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 1.加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 2.建立连接
            state = con.createStatement();// 3.创建Statement对象
            System.out.println(DbBean07.getSql());
            state.executeUpdate(DbBean07.getSql());// 4.执行目标delete sql语句
            /**
             * 5.上述sql语句执行完毕后没有返回结果可处理
             */
            state.close();
            con.close();// 6.按照逆序关闭对象
            System.out.println("数据删除成功...");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口程序
 */
public class Demo07DeleteData {
    public static void main(String args[]) {
        Db07DeleteService.insertService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.*;
import java.util.Date;
/**
 * jdbc操作-查询数据。
 */
class DbBean08 {
    private static final String SQL = "select id,name,age,sex,birthday from person";
    public static String getSql() {
        return SQL;
    }
}
/**
 * Service层，执行sql操作sql的select操作，是指上述数据的反持久化，将库中持久化的数据重新读取到内存中并进行处理开发中不建议使用select * 替代全部的字段，这样会使得查询出来的列名不明显
 */
class Demo08SelectService {
    public static void selectService() {
        Connection con = null;
        Statement state = null;
        ResultSet result = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 1.加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 2.建立连接
            state = con.createStatement();// 3.创建Statement对象
            result = state.executeQuery(DbBean08.getSql());// 4.执行目标sql语句，并返回查询语句
            /*
             * 5.处理查询数据。resultSet是游标对象，next()方法将游标指向下一行，从0还是计数，所以第一次的next()方法将指向第一行数据行。当resultSet对象没有下一行数据时，next()方法返回false。
             */
            System.out.println("result.next():" + result.next());
            while (result.next()) {
                int id = result.getInt("id");
                String name = result.getString("name");
                int age = result.getInt("age");
                String sex = result.getString("sex");
                Date birthday = result.getDate("birthday");
                System.out.println("id=" + id + ";name=" + name + ";age=" + age
                        + ";sex=" + sex + ";birthday=" + birthday);
                System.out.println("........................");
            }
            result.close();
            state.close();
            con.close();// 6.按照逆序关闭对象
            System.out.println("执行的sql语句:" + DbBean08.getSql());
            System.out.println("数据查询成功...");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口程序
 */
public class Demo08SelectData {
    public static void main(String args[]) {
        Demo08SelectService.selectService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.*;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
 * jdbc学习
 * jdbc执行insert语句，使用 PreparedStatement 对象执行sql语句的预编译，所以执行效率比Statement快
 * 定义数据实体bean
 */
class Person09 {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String birthday;
    public Person09(int id, String name, int age, String sex, String birthday) {
        this.setId(id);
        this.setName(name);
        this.setAge(age);
        this.setSex(sex);
        this.setBirthday(birthday);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
/**
 * 保存数据库信息的实体bean
 * 注意插入语句的日期格式
 */
class DbBean09 {
    private static final String SQL = "insert into person values(?,?,?,?,?)";
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 */
class Db09InsertService {
    public static void insertService() {
        Connection con = null;
        PreparedStatement state = null;
        Person09 per = new Person09(1234, "Eric", 26, "男", "1992-10-13");
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 建立连接
            state = con.prepareStatement(DbBean09.getSql());// 创建PreparedStatement对象
            state.setInt(1, per.getId());
            state.setString(2, per.getName());
            state.setInt(3, per.getAge());
            state.setString(4, per.getSex());
            try {
                state.setDate(
                        5,
                        new Date((new SimpleDateFormat("yyyy-mm-dd").parse(per
                                .getBirthday())).getTime()));
            } catch (ParseException e) {
                e.printStackTrace();
            }
            state.executeUpdate();// 执行目标insert sql语句
            /**
             * 上述sql语句执行完毕后没有返回结果可处理
             */
            state.close();
            con.close();// 按照顺序关闭对象
            System.out.println(DbBean09.getSql());
            System.out.println("数据插入成功....");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口
 */
public class Demo09InsertDataPreparedStatement {
    public static void main(String args[]) {
        Db09InsertService.insertService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import java.sql.*;
import java.util.Date;
/**
 * jdbc学习
 * jdbc执行select语句，使用PreparedStatement对象执行sql语句的预编译，所以执行效率比Statement快
 * 使用模糊查询,Statement往往需要用户手动拼接sql，容易出错，开发中建议使用PreparedStatement操作sql，这样可以预先占位，然后设置指定占位值
 * 定义数据实体bean
 */
class Person10 {
    private int id;
    private String name;
    private int age;
    private String sex;
    private String birthday;
    public Person10(int id, String name, int age, String sex, String birthday) {
        this.setId(id);
        this.setName(name);
        this.setAge(age);
        this.setSex(sex);
        this.setBirthday(birthday);
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getBirthday() {
        return birthday;
    }
    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}
/**
 * 保存数据库信息的实体bean
 * 注意插入语句的日期格式
 */
class DbBean10 {
    private static final String SQL = "select id,name,age,sex,birthday from person where name like ?";// 使用sql通配符
    public static String getSql() {
        return SQL;
    }
}
/**
 * 控制层，执行sql操作
 */
class Db10InsertService {
    public static void insertService() {
        Connection con = null;
        PreparedStatement state = null;
        ResultSet result = null;
        Person10 per = new Person10(1234, "赵", 26, "男", "1992-10-13");
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 建立连接
            state = con.prepareStatement(DbBean10.getSql());// 创建PreparedStatement对象
            state.setString(1, "%" + per.getName() + "%");
            result = state.executeQuery();// 执行指定的预sql语句
            while (result.next()) {
                int id = result.getInt("id");
                String name = result.getString("name");
                int age = result.getInt("age");
                String sex = result.getString("sex");
                Date birthday = result.getDate("birthday");
                System.out.println("id=" + id + ";name=" + name + ";age=" + age
                        + ";sex=" + sex + ";birthday=" + birthday);
                System.out.println("..............................");
            }
            state.close();
            con.close();// 按照顺序关闭对象
            System.out.println(DbBean10.getSql());
            System.out.println("模糊查询成功....");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口
 */
public class Demo10SelectDataPreparedStatement {
    public static void main(String args[]) {
        Db10InsertService.insertService();
    }
}

package javase.demo26.db.jdbc;
import javase.demo26.db.util.CommonJdbcLoadUtil;
import javase.demo38.common.FileHandleUtil;
import javase.demo38.common.HandelTxtUtil;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.sql.*;
import java.util.Iterator;
import java.util.Set;
/**
 * jdbc学习
 * jdbc操作-查询数据
 * 保存数据库信息的实体bean
 * 注意插入语句的日期格式
 */
class DbBean11 {
    // 下面是最传统的jdbc方式，将数据源信息硬编码到代码中，很不合适，每次改动需要修改源码
    // 目前流行的方式，1，将数据源配置在文件中，通过自己解析文件或者交给spring等框架进行自动解析；
    // 2，将数据源信息配置在web服务器（tomcat或者weblogic服务器中绑定JNDI），然后通过框架或者自己手动调用JNDI相关接口获取数据源信息
    private static final String SQL = "select * from user_tables";
    public static String getSql() {
        return SQL;
    }
}
/**
 * Service层，执行sql操作
 * sql的select操作，是指上述数据的反持久化，将库中持久化的数据重新读取到内存中并进行处理，开发中不建议使用select * 替代全部的字段，这样会使得查询出来的列名不明显
 */
class Db08SelectService {
    public static void selectService() throws FileNotFoundException {
        Connection con = null;
        Statement state = null;
        ResultSet result = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 建立连接
            state = con.createStatement();// 创建Statement对象
            result = state.executeQuery(DbBean11.getSql());// 执行目标sql语句，并返回查询语句
            File f = new File("table" + File.separator + "tableName.txt");
            FileHandleUtil.checkFile(f, true);
            PrintStream out = new PrintStream(new FileOutputStream(f));
            /*
             * 处理查询数据
             */
            while (result.next()) {
                //
                String tableName = result.getString(1);
                out.println(tableName);
            }
            result.close();
            state.close();
            con.close();// 按照顺序关闭对象
            System.out.println("----执行的sql语句:" + DbBean11.getSql());
            System.out.println("----数据输出到文件----");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    public static void selectService2() throws FileNotFoundException {
        Connection con = null;
        Statement state = null;
        ResultSet result = null;
        try {
            Class.forName(CommonJdbcLoadUtil.getDbdriver());// 加载oracle驱动
            con = DriverManager.getConnection(CommonJdbcLoadUtil.getDburl(),
                    CommonJdbcLoadUtil.getDbuser(),
                    CommonJdbcLoadUtil.getDbpass());// 建立连接
            state = con.createStatement();// 创建Statement对象
            File f = new File("table" + File.separator + "tableName.txt");
            Set<String> set = HandelTxtUtil.getMore(f);
            Iterator<String> it = set.iterator();
            while (it.hasNext()) {
                String tableName = it.next();
                File file = new File("compare" + File.separator + tableName
                        + ".txt");
                FileHandleUtil.checkFile(file, true);
                PrintStream out = new PrintStream(new FileOutputStream(file));
                String sql = "select * from " + tableName;
                System.out.println(sql);
                result = state.executeQuery(sql);// 执行目标sql语句，并返回查询语句
                /*
                 * 处理查询结果
                 */
                int columnCount = result.getMetaData().getColumnCount();
                while (result.next()) {
                    for (int i = 1; i <= columnCount; i++) {
                        String re = result.getString(i);
                        out.print(re + "\t");
                    }
                    out.println();
                }
            }
            result.close();
            state.close();
            con.close();// 按照顺序关闭对象
            System.out.println("执行的sql语句:" + DbBean11.getSql());
            System.out.println("数据输出到文件...");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 应用层入口程序
 */
public class Demo11SelectDataMain {
    public static void main(String args[]) throws FileNotFoundException {
        Db08SelectService.selectService();
        Db08SelectService.selectService2();
    }
}