精华内容
下载资源
问答
  • Java操作数据库的步骤

    2017-03-25 10:46:48
    数据库访问几乎每一个稍微成型的程序都要用到的知识,怎么高效的访问数据库也是...提供了诸如查询和更新数据库中数据的方法,下面我们就具体来总结一下JDBC一:Java访问数据库的具体步骤:1 加载(注册)数据库 驱...


       数据库访问几乎每一个稍微成型的程序都要用到的知识,怎么高效的访问数据库也是我们学习的一个重点,今天的任务就是总结Java访问数据库的方法和有关APIjava访问数据库主要用的方法是JDBC,是java语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法,下面我们就具体来总结一下JDBC

    一:Java访问数据库的具体步骤:

    加载(注册)数据库 

     驱动加载就是把各个数据库提供的访问数据库的API加载到我们程序进来,加载JDBC驱动,并将其注册到DriverManager中,每一种数据库提供的数据库驱动不一样,加载驱动时要把jar包添加到lib文件夹下,下面看一下一些主流数据库的JDBC驱动加裁注册的代码

    //Oracle8/8i/9iO数据库(thin模式

    Class.forName("Oracle.jdbc.driver.OracleDriver").newInstance(); 

    //Sql Server7.0/2000数据库   Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver"); 

    //Sql Server2005/2008数据库   Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); 

    //DB2数据库 

    Class.froName("com.ibm.db2.jdbc.app.DB2Driver").newInstance();  

    //MySQL数据库  Class.forName("com.mysql.jdbc.Driver").newInstance(); 

    建立链接   

    建立数据库之间的连接是访问数据库的必要条件,就像南水北调调水一样,要想调水首先由把沟通的河流打通。建立连接对于不同数据库也是不一样的,下面看一下一些主流数据库建立数据库连接,取得Connection对象的不同方式:

     //Oracle8/8i/9i数据库(thin模式

      String url="jdbc:oracle:thin:@localhost:1521:orcl"; 

      String user="scott"; 

      String password="tiger"; 

      Connection conn=DriverManager.getConnection(url,user,password); 

      

      //Sql Server7.0/2000/2005/2008数据库 

      String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs"; 

      String user="sa"; 

      String password=""; 

      Connection conn=DriverManager.getConnection(url,user,password); 

      

      //DB2数据库 

      String url="jdbc:db2://localhost:5000/sample"; 

      String user="amdin" 

      String password=-""; 

      Connection conn=DriverManager.getConnection(url,user,password); 

      

    //MySQL数据库 

    String url="jdbc:mysql://localhost:3306/testDB?user=root&password=root&useUnicode=true&characterEncoding=gb2312"; 

    Connection conn=DriverManager.getConnection(url); 

    3. 执行SQL语句  

    数据库连接建立好之后,接下来就是一些准备工作和执行sql语句了,准备工作要做的就是建立Statement对象PreparedStatement对象,例如:

     //建立Statement对象 

     Statement stmt=conn.createStatement(); 

    做好准备工作之后就可以执行sql语句了,执行sql语句:

    String sql="select * from users"; 

    ResultSet rs=stmt.executeQuery(sql); 


     //建立PreparedStatement对象 

     String sql="select * from user where userName=? and password=?"; 

      PreparedStatement pstmt=Conn.prepareStatement(sql); 

      pstmt.setString(1,"admin"); 

      pstmt.setString(2,"liubin"); 

    //执行动态SQL查询 

    ResultSet rs=pstmt.executeQuery(); 

    //执行insert update delete等语句,先定义sql 

    stmt.executeUpdate(sql); 

    处理结果集  

     访问结果记录集ResultSet对象。例如: 

      while(rs.next()) 

      { 

      out.println("你的第一个字段内容为:"+rs.getString("Name")); 

      out.println("你的第二个字段内容为:"+rs.getString(2)); 

      } 

    关闭数据库 

     依次将ResultSetStatementPreparedStatementConnection对象关     闭,释放所占用的资源.例如

      rs.close(); 

      stmt.clost(); 

      pstmt.close(); 

      con.close(); 

    二:JDBC事务

    什么是事务:

    首先,说说什么事务。我认为事务,就是一组操作数据库的动作集合。

    事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行,我们称该组处理步骤为一个事务。当所有的步骤像一个操 作一样被完整地执行,我们称该事务被提交。由于其中的一部分或多步执行失败,导致没有步骤被提交,则事务必须回滚到最初的系统状态。

    事务是恢复和并发控制的基本单位。
    事务应该具有4个属性:原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性
    原子性(atomicity)。一个事务是一个不可分割的工作单位,事务中包括的诸操作要么都做,要么都不做。
    一致性(consistency)。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
    隔离性(isolation)。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的,并发执行的各个事务之间不能互相干扰。
    持久性(durability)。持久性也称永久性(permanence),指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

    JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式:自动提交和手工提交。 java.sql.Connection 提供了以下控制事务的方法: 
    public void setAutoCommit(boolean) 
    public boolean getAutoCommit() 
    public void commit() 
    public void rollback() 
    使用 
    JDBC 事务界定时,您可以将多个 SQL 语句结合到一个事务中。JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

    三:java操作数据库连接池

    在总结java操作数据库连接池发现一篇很好的文章,所以就不做具体总结了,直接上地址:

    http://www.blogjava.net/chunkyo/archive/2007/01/16/94266.html

    最后附一段比较经典的代码吧:

    import java.sql.Connection;
    import java.sql.DatabaseMetaData;
    import java.sql.Driver;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.Enumeration;
    import java.util.Vector;
    public class ConnectionPool {
    private String jdbcDriver = ""; // 数据库驱动
    private String dbUrl = ""; // 数据 URL
    private String dbUsername = ""; // 数据库用户名
    private String dbPassword = ""; // 数据库用户密码
    private String testTable = ""; // 测试连接是否可用的测试表名,默认没有测试表
    private int initialConnections = 10; // 连接池的初始大小
    private int incrementalConnections = 5;// 连接池自动增加的大小
    private int maxConnections = 50; // 连接池最大的大小
    private Vector connections = null; // 存放连接池中数据库连接的向量 , 初始时为 null
    
    // 它中存放的对象为 PooledConnection 型
    
    /**
    * 构造函数
    *
    * @param jdbcDriver String JDBC 驱动类串
    * @param dbUrl String 数据库 URL
    * @param dbUsername String 连接数据库用户名
    * @param dbPassword String 连接数据库用户的密码
    *
    */
    
    public ConnectionPool(String jdbcDriver,String dbUrl,String dbUsername,String dbPassword) {
             this.jdbcDriver = jdbcDriver;
             this.dbUrl = dbUrl;
             this.dbUsername = dbUsername; 
             this.dbPassword = dbPassword;
    }
    
    /**
    
    * 返回连接池的初始大小
    *
    * @return 初始连接池中可获得的连接数量
    */
    public int getInitialConnections() {
    
             return this.initialConnections;
    }
    
    /**
    
    * 设置连接池的初始大小
    
    *
    
    * @param 用于设置初始连接池中连接的数量
    
    */
    
    public void setInitialConnections(int initialConnections) {
             this.initialConnections = initialConnections;
    }
    
    /**
    
    * 返回连接池自动增加的大小 、
    *
    * @return 连接池自动增加的大小
    */
    public int getIncrementalConnections() {
    
             return this.incrementalConnections;
    
    }
    
    /**
    * 设置连接池自动增加的大小
    * @param 连接池自动增加的大小
    */
    
    public void setIncrementalConnections(int incrementalConnections) {
    
             this.incrementalConnections = incrementalConnections;
    
    }
    
    /**
    * 返回连接池中最大的可用连接数量
    * @return 连接池中最大的可用连接数量
    */
    
    public int getMaxConnections() {
             return this.maxConnections;
    }
    
    /**
    
    * 设置连接池中最大可用的连接数量
    
    *
    
    * @param 设置连接池中最大可用的连接数量值
    
    */
    
    public void setMaxConnections(int maxConnections) {
    
             this.maxConnections = maxConnections;
    
    }
    
    /**
    
    * 获取测试数据库表的名字
    *
    * @return 测试数据库表的名字
    */
    public String getTestTable() {
    
             return this.testTable;
    
    }
    
    /**
    * 设置测试表的名字
    * @param testTable String 测试表的名字
    */
    public void setTestTable(String testTable) {
             this.testTable = testTable;
    }
    
    /**
    
    *
    * 创建一个数据库连接池,连接池中的可用连接的数量采用类成员
    * initialConnections 中设置的值
    */
    public synchronized void createPool() throws Exception {
    
             // 确保连接池没有创建
      
             // 如果连接池己经创建了,保存连接的向量 connections 不会为空
      
             if (connections != null) {
      
              return; // 如果己经创建,则返回
      
             }
      
             // 实例化 JDBC Driver 中指定的驱动类实例
      
             Driver driver = (Driver) (Class.forName(this.jdbcDriver).newInstance());
      
             DriverManager.registerDriver(driver); // 注册 JDBC 驱动程序
      
             // 创建保存连接的向量 , 初始时有 0 个元素
      
             connections = new Vector();
      
             // 根据 initialConnections 中设置的值,创建连接。
      
             createConnections(this.initialConnections);
      
             System.out.println(" 数据库连接池创建成功! ");
    
    }
    
    /**
    
    * 创建由 numConnections 指定数目的数据库连接 , 并把这些连接
    
    * 放入 connections 向量中
    *
    * @param numConnections 要创建的数据库连接的数目
    */
    @SuppressWarnings("unchecked")
    private void createConnections(int numConnections) throws SQLException {
    
             // 循环创建指定数目的数据库连接
      
             for (int x = 0; x < numConnections; x++) {
      
              // 是否连接池中的数据库连接的数量己经达到最大?最大值由类成员 maxConnections
       
              // 指出,如果 maxConnections 为 0 或负数,表示连接数量没有限制。
       
              // 如果连接数己经达到最大,即退出。
       
              if (this.maxConnections > 0 && this.connections.size() >= this.maxConnections) {
       
               break;
       
              }
      
              //add a new PooledConnection object to connections vector
       
              // 增加一个连接到连接池中(向量 connections 中)
       
              try{
       
               connections.addElement(new PooledConnection(newConnection()));
       
              }catch(SQLException e){
       
               System.out.println(" 创建数据库连接失败! "+e.getMessage());
       
              throw new SQLException();
       
              }
       
              System.out.println(" 数据库连接己创建 ......");
       
             }
    }
    
    /**
    
    * 创建一个新的数据库连接并返回它
    *
    * @return 返回一个新创建的数据库连接
    */
    private Connection newConnection() throws SQLException {
    
             // 创建一个数据库连接
      
             Connection conn = DriverManager.getConnection(dbUrl, dbUsername, dbPassword);
      
             // 如果这是第一次创建数据库连接,即检查数据库,获得此数据库允许支持的
      
             // 最大客户连接数目
      
             //connections.size()==0 表示目前没有连接己被创建
      
             if (connections.size() == 0) {
      
              DatabaseMetaData metaData = conn.getMetaData();
       
              int driverMaxConnections = metaData.getMaxConnections();
       
              // 数据库返回的 driverMaxConnections 若为 0 ,表示此数据库没有最大
       
              // 连接限制,或数据库的最大连接限制不知道
       
              //driverMaxConnections 为返回的一个整数,表示此数据库允许客户连接的数目
       
              // 如果连接池中设置的最大连接数量大于数据库允许的连接数目 , 则置连接池的最大
       
              // 连接数目为数据库允许的最大数目
       
              if (driverMaxConnections > 0 && this.maxConnections > driverMaxConnections) {
       
               this.maxConnections = driverMaxConnections;
       
              }
             } 
             return conn; // 返回创建的新的数据库连接
    
    }
    
    /**
    
    * 通过调用 getFreeConnection() 函数返回一个可用的数据库连接 ,
    
    * 如果当前没有可用的数据库连接,并且更多的数据库连接不能创
    
    * 建(如连接池大小的限制),此函数等待一会再尝试获取。
    
    *
    
    * @return 返回一个可用的数据库连接对象
    
    */
    
    public synchronized Connection getConnection() throws SQLException {
    
             // 确保连接池己被创建
      
             if (connections == null) {
      
              return null; // 连接池还没创建,则返回 null
      
             }
      
             Connection conn = getFreeConnection(); // 获得一个可用的数据库连接
      
             // 如果目前没有可以使用的连接,即所有的连接都在使用中
      
             while (conn == null){
      
              // 等一会再试
       
              wait(250);
       
              conn = getFreeConnection(); // 重新再试,直到获得可用的连接,如果
       
              //getFreeConnection() 返回的为 null
       
              // 则表明创建一批连接后也不可获得可用连接
      
             }
      
             return conn;// 返回获得的可用的连接
    }
    
    /**
    
    * 本函数从连接池向量 connections 中返回一个可用的的数据库连接,如果
    
    * 当前没有可用的数据库连接,本函数则根据 incrementalConnections 设置
    
    * 的值创建几个数据库连接,并放入连接池中。
    
    * 如果创建后,所有的连接仍都在使用中,则返回 null
    
    * @return 返回一个可用的数据库连接
    
    */
    
    private Connection getFreeConnection() throws SQLException {
    
             // 从连接池中获得一个可用的数据库连接
      
             Connection conn = findFreeConnection();
      
             if (conn == null) {
      
              // 如果目前连接池中没有可用的连接
       
              // 创建一些连接
       
              createConnections(incrementalConnections);
       
              // 重新从池中查找是否有可用连接
       
              conn = findFreeConnection();
       
              if (conn == null) {
       
               // 如果创建连接后仍获得不到可用的连接,则返回 null
        
               return null;
       
              }
      
             }
      
             return conn;
    
    }
    
    /**
    
    * 查找连接池中所有的连接,查找一个可用的数据库连接,
    
    * 如果没有可用的连接,返回 null
    
    *
    
    * @return 返回一个可用的数据库连接
    
    */
    
    private Connection findFreeConnection() throws SQLException {
    
             Connection conn = null;
      
             PooledConnection pConn = null;
      
             // 获得连接池向量中所有的对象
      
             Enumeration enumerate = connections.elements();
      
             // 遍历所有的对象,看是否有可用的连接
      
             while (enumerate.hasMoreElements()) {
      
              pConn = (PooledConnection) enumerate.nextElement();
       
              if (!pConn.isBusy()) {
       
               // 如果此对象不忙,则获得它的数据库连接并把它设为忙
        
               conn = pConn.getConnection();
        
               pConn.setBusy(true);
        
               // 测试此连接是否可用
        
               if (!testConnection(conn)) {
        
                // 如果此连接不可再用了,则创建一个新的连接,
         
                // 并替换此不可用的连接对象,如果创建失败,返回 null
         
                try{
         
                 conn = newConnection();
         
                }catch(SQLException e){
         
                 System.out.println(" 创建数据库连接失败! "+e.getMessage());
         
                 return null;
         
                }
        
                pConn.setConnection(conn);
        
               }
        
               break; // 己经找到一个可用的连接,退出
       
              }
      
             }
      
             return conn;// 返回找到到的可用连接
    
    }
    
    /**
    
    * 测试一个连接是否可用,如果不可用,关掉它并返回 false
    
    * 否则可用返回 true
    
    *
    
    * @param conn 需要测试的数据库连接
    
    * @return 返回 true 表示此连接可用, false 表示不可用
    
    */
    
    private boolean testConnection(Connection conn) {
    
             try {
      
              // 判断测试表是否存在
       
              if (testTable.equals("")) {
       
               // 如果测试表为空,试着使用此连接的 setAutoCommit() 方法
        
               // 来判断连接否可用(此方法只在部分数据库可用,如果不可用 ,
        
               // 抛出异常)。注意:使用测试表的方法更可靠
        
               conn.setAutoCommit(true);
       
              } else {// 有测试表的时候使用测试表测试
       
               //check if this connection is valid
        
               Statement stmt = conn.createStatement();
        
               stmt.execute("select count(*) from " + testTable);
       
              }
      
             } catch (SQLException e) {
      
              // 上面抛出异常,此连接己不可用,关闭它,并返回 false;
      
              closeConnection(conn);
      
              return false;
      
             }
      
             // 连接可用,返回 true
      
             return true;
    
    }
    
    /**
    
    * 此函数返回一个数据库连接到连接池中,并把此连接置为空闲。
    
    * 所有使用连接池获得的数据库连接均应在不使用此连接时返回它。
    
    *
    
    * @param 需返回到连接池中的连接对象
    
    */
    
    public void returnConnection(Connection conn) {
    
             // 确保连接池存在,如果连接没有创建(不存在),直接返回
      
             if (connections == null) {
      
              System.out.println(" 连接池不存在,无法返回此连接到连接池中 !");
       
              return;
      
             }
    
             PooledConnection pConn = null;
      
             Enumeration enumerate = connections.elements();
      
             // 遍历连接池中的所有连接,找到这个要返回的连接对象
      
             while (enumerate.hasMoreElements()) {
    
              pConn = (PooledConnection) enumerate.nextElement();
       
              // 先找到连接池中的要返回的连接对象
       
              if (conn == pConn.getConnection()) {
       
               // 找到了 , 设置此连接为空闲状态
        
               pConn.setBusy(false);
        
               break;
       
              }
    
             }
    
    }
    
    /**
    
    * 刷新连接池中所有的连接对象
    
    *
    
    */
    
    public synchronized void refreshConnections() throws SQLException {
    
             // 确保连接池己创新存在
      
             if (connections == null) {
      
              System.out.println(" 连接池不存在,无法刷新 !");
      
              return;
      
             }
      
             PooledConnection pConn = null;
      
             Enumeration enumerate = connections.elements();
      
             while (enumerate.hasMoreElements()) {
    
              // 获得一个连接对象
       
              pConn = (PooledConnection) enumerate.nextElement();
       
              // 如果对象忙则等 5 秒 ,5 秒后直接刷新
       
              if (pConn.isBusy()) {
       
               wait(5000); // 等 5 秒
       
              }
       
              // 关闭此连接,用一个新的连接代替它。
       
              closeConnection(pConn.getConnection());
       
              pConn.setConnection(newConnection());
       
              pConn.setBusy(false);
       
             }
    
    }
    
    /**
    
    * 关闭连接池中所有的连接,并清空连接池。
    
    */
    
    public synchronized void closeConnectionPool() throws SQLException {
    
             // 确保连接池存在,如果不存在,返回
      
             if (connections == null) {
      
              System.out.println(" 连接池不存在,无法关闭 !");
      
              return;
      
             }
      
             PooledConnection pConn = null;
      
             Enumeration enumerate = connections.elements();
      
             while (enumerate.hasMoreElements()) {
      
              pConn = (PooledConnection) enumerate.nextElement();
      
              // 如果忙,等 5 秒
      
              if (pConn.isBusy()) {
      
               wait(5000); // 等 5 秒
      
              }
      
             //5 秒后直接关闭它
      
             closeConnection(pConn.getConnection());
      
             // 从连接池向量中删除它
      
             connections.removeElement(pConn);
      
             }
      
             // 置连接池为空
      
             connections = null;
    
    }
    
    /**
    
    * 关闭一个数据库连接
    
    *
    
    * @param 需要关闭的数据库连接
    
    */
    
    private void closeConnection(Connection conn) {
    
             try {
      
              conn.close();
      
             }catch (SQLException e) {
      
              System.out.println(" 关闭数据库连接出错: "+e.getMessage());
      
             }
    
    }
    
    /**
    
    * 使程序等待给定的毫秒数
    
    *
    
    * @param 给定的毫秒数
    
    */
    
    private void wait(int mSeconds) {
    
             try {
      
              Thread.sleep(mSeconds);
      
             } catch (InterruptedException e) {
      
             }
    
    }
    
    /**
    
    *
    
    * 内部使用的用于保存连接池中连接对象的类
    
    * 此类中有两个成员,一个是数据库的连接,另一个是指示此连接是否
    
    * 正在使用的标志。
    
    */
    
    class PooledConnection {
    
             Connection connection = null;// 数据库连接
      
             boolean busy = false; // 此连接是否正在使用的标志,默认没有正在使用
      
             // 构造函数,根据一个 Connection 构告一个 PooledConnection 对象
      
             public PooledConnection(Connection connection) {
      
              this.connection = connection;
      
             }
      
             // 返回此对象中的连接
      
             public Connection getConnection() {
      
              return connection;
    
             }
    
             // 设置此对象的,连接
      
             public void setConnection(Connection connection) {
      
              this.connection = connection;
       
             }
       
             // 获得对象连接是否忙
       
             public boolean isBusy() {
       
              return busy;
       
             }
       
             // 设置对象的连接正在忙
       
             public void setBusy(boolean busy) {
       
              this.busy = busy;
       
             }
    
    }
    
    }
    
    =======================================
    
    这个例子是根据POSTGRESQL数据库写的,
    请用的时候根据实际的数据库调整。
    
    调用方法如下:
    
    ① ConnectionPool connPool
                                         = new ConnectionPool("org.postgresql.Driver"
                                                                             ,"jdbc:postgresql://dbURI:5432/DBName"
                                                                             ,"postgre"
                                                                             ,"postgre");
    
    ② connPool .createPool();
      Connection conn = connPool .getConnection();




    文章来源http://blog.csdn.net/csh624366188

    展开全文
  • 1.加载驱动  Class.forName("com.mysql.jdbc.Driver"); 2.获取数据库连接  public java.sql.Connection  getConnection(){   if(conn ==null){   try {   conn=DriverManag
    1.加载驱动
    
         Class.forName("com.mysql.jdbc.Driver");

    2.获取数据库连接
         public java.sql.Connection 
    getConnection(){
            if(conn ==null){
               try {
                  conn=DriverManager.getConnection( "jdbc:mysql://localhost:3306/数据库名"            
    ,"root","密码" );
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
            return conn ;
       }

    3.数据库操作
         添加:
              public int addBookStoreBean(BookStoreBean bsb){
           java.sql.PreparedStatement pstmt=null;
            int result=0;
            try {
              pstmt= conn.prepareStatement("insert into t_bookStore values(?,?,?,?,?)");
              pstmt.setInt(1, bsb.getId());
              pstmt.setString(2, bsb.getName());
              pstmt.setString(3, bsb.getPrice());
              pstmt.setString(4,bsb.getPublish());
              pstmt.setString(5,bsb.getOther());
              result=pstmt.executeUpdate();
              System. out.println("添加信息成功!" );
           } catch (SQLException e) {
              e.printStackTrace();
           } finally{
               try {
                  pstmt.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
            return result;
       }
         删除:
              public void delBookStoreBean(int id){
           java.sql.PreparedStatement pstmt=null;
            try {
              pstmt= conn.prepareStatement("delete from t_bookStore where id=?");
              pstmt.setInt(1, id);
              pstmt.execute();
              System. out.println("删除成功!" );
           } catch (SQLException e) {
              e.printStackTrace();
           } finally{
               try {
                  pstmt.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
       }  
         更新:
              public void updateBookStoreBean(BookStoreBean bsb){
           java.sql.PreparedStatement pstmt=null;
            try {
              pstmt= conn.prepareStatement("update t_bookStore set name=? ,price=?,publish=?,other=? where id=?");
              pstmt.setInt(1, bsb.getId());
    .setString(2, bsb.getName());
              pstmt.setString(3, bsb.getPrice());
              pstmt.setString(4,bsb.getPublish());
              pstmt.setString(5,bsb.getOther());
              pstmt.executeUpdate();
           } catch (SQLException e) {
              e.printStackTrace();
           } finally{
               try {
                  pstmt.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
           
       }
         查询:
              public List<BookStoreBean> query(){
           java.sql.Statement stmt= null;
           java.sql.ResultSet rs= null;
           List<BookStoreBean> result= new ArrayList<BookStoreBean>();
            try {
              stmt= conn.createStatement();
              rs=stmt.executeQuery( "select * from t_bookStore");
               while(rs.next()){
                  BookStoreBean bsb= new BookStoreBean();
                  bsb.setId(rs.getInt( "id"));
                 bsb.setName(rs.getString( "name"));
                 bsb.setPrice(rs.getString( "price"));
                 bsb.setPublish(rs.getString( "publish"));
                 bsb.setOther(rs.getString( "other"));
                  result.add(bsb);
              }
           } catch (SQLException e) {
              e.printStackTrace();
           } finally{
               try {
                  rs.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
               try {
                  stmt.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
            return result;
       }

       
    4.关闭数据库
         public void closeConnection(){
            if(conn ==null){
               try {
                   conn.close();
              } catch (SQLException e) {
                  e.printStackTrace();
              }
           }
       }
    展开全文
  • 1.JDBC:Java DataBase Connectivity 可以为多种关系型数据库DBMS提供统一访问方式,用Java操作数据库 2.JDBC API 主要功能: 三件事,具体通过一下类/接口实现: DriverManager: 管理JDBC驱动 Connection: ...

    1.JDBC:Java DataBase Connectivity  可以为多种关系型数据库DBMS提供统一的访问方式,用Java来操作数据库

    2.JDBC API 主要功能:

    三件事,具体通过一下类/接口实现:

    DriverManager: 管理JDBC驱动

    Connection:  连接

    Statement(PreparedStatement): 增删改查

    CallableStatement: 调用数据库中的存储过程/存储函数

    Result: 返回的结果集

    3.JDBC访问数据库的具体步骤:

    a.导入驱动,加载具体的驱动类

    b.与数据库建立连接

    c.发送sql,执行

    d.处理结果集(查询)

    4.数据库驱动

    mysql    mysql-connector-java-x.jar

    具体代码如下

    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class JDBCDemo {
        private static final String URL = "jdbc:mysql://localhost:3306/world?characterEncoding=utf8&useSSL=false";
        private static final String USERNAME = "root";
        private static final String PWD = "root";
        public static void update() {
            Connection connection = null;
            Statement stmt = null;
            try {
                Class.forName("com.mysql.jdbc.Driver");
                connection = DriverManager.getConnection(URL,USERNAME,PWD);
                stmt = connection.createStatement();
                String sql = "insert into student values('ls',1)";
                int count = stmt.executeUpdate(sql);
                if(count > 0){
                    System.out.println("操作成功!");
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    if(stmt != null){
                        stmt.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
                try {
                    if(connection != null){
                        connection.close();
                    }
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        public static void main(String[] args){
            update();
        }
    }
    

     

    展开全文
  • JDBC操作数据库基本步骤,有导入jar包详细步骤

    操作数据库的基本步骤

    • 导入jar包,然后右键添加为库(具体操作在代码下面)
    • 注册驱动
    • 获取数据库连接对象
    • 定义sql语句
    • 获取执行sql的对象
    • 执行sql语句
    public class QuickWrite {
        public static void main(String[] args) throws Exception {
            //导入jar包,然后右键添加为库
            //注册驱动
            Class.forName("com.mysql.jdbc.Driver");
            //获取数据库连接对象
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "132580");
            //定义sql语句
            String sql = "update acccount set balance = 500 where id = 1";
            //获取执行sql的对象
            Statement stmt = conn.createStatement();
            //执行sql语句
            int count = stmt.executeUpdate(sql);//返回值是影响的数据条数
            System.out.println(count);
    
        }
    }
    

    导入jar包的具体操作:

    1. 在当前模块下建一个目录,名称为libs,并将jar包复制到libs文件夹下
      jar包下载地址:jar包点击下载

    2. 将导入的jar包添加为库,在jar包上右键,点击Add as library,此时jar包已导入完成

    展开全文
  • Java中JDBC操作数据库的步骤,今天给喜欢Java开发或者是想要参加Java培训学习的小伙伴们分享一些Java技能干货,那就是Java阐述jdba操作数据库的步骤,废话不多说了,随小编一起来看一下吧。下面的代码以连接本机的...
  • JDBC(Java Database Connectivity缩写,简称JDBC)就是java数据库连接,它是java程序连接和数据库操作应用程序API接口,说白了就是用Java语言来操作数据库。原来我们操作数据库是使用SQL语句来操作数据库,JDBC是...
  • 好程序员Java培训分享JDBC操作数据库的步骤,今天给喜欢Java开发或者是想要参加Java培训学习的小伙伴们分享一些Java技能干货,那就是Java阐述jdba操作数据库的步骤,废话不多说了,随小编一起来看一下吧。...
  • Java - 阐述JDBC操作数据库的步骤

    万次阅读 2019-03-16 10:47:30
    分享一个大牛的人工智能...下面的代码以连接本机的Oracle数据库为例,演示JDBC操作数据库的步骤。 加载驱动。 Class.forName("oracle.jdbc.driver.OracleDriver"); 创建连接。 Connection con = Dr...
  • 1、java数据库操作基本流程2、几个常用重要技巧:可滚动、更新记录集批量更新事务处理java数据库操作基本流程:取得数据库连接 - 执行sql语句 - 处理执行结果 - 释放数据库连接1、取得数据库连接1)用...
  • import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class JDBCTe...
  • java JDBC数据库连接步骤

    千次阅读 2019-03-05 11:26:12
    JDBC(java database connect)顾名思义:是一种java连接数据库的方式 1.定义驱动和数据库字符串 2.注册驱动 3.连接数据库 4.数据库操作 5.关闭数据库连接和数据集合 以上5点是连接数据库的一般步骤。 JDBC连接...
  • 一、数据库连接1、Drivermanager链接数据库String className,url,uid,pwd;className="oracle.jdbc.driver.OracleDriver";uid="scott";pwd="tiger";...//这里ora92是你的数据库实例名例子Class.forN...
  • 本次讲是用java连接sqlserver简单操作。 首先,导入JDBC(Java DateBase Connectivity) jar包在你所创建project项目中。 在java连接数据库中,有着6步操作: 1.注册驱动 2.获取数据库连接 3.获取数据库操作...
  • Java培训分享JDBC操作数据库的步骤,今天给喜欢Java开发或者是想要参加Java培训学习的小伙伴们分享一些Java技能干货,那就是Java阐述jdba操作数据库的步骤,废话不多说了,随小编一起来看一下吧。 下面的代码以连接...
  • Java操作数据库--JDBC

    2017-08-30 11:32:45
    Java操作数据库的步骤 导入oracl数据库驱动的jar包。jar包地址 加载驱动,Class.forName(“oracle.jdbc.driver.OracleDriver”); 获取连接,DriverManager.getConnection(url,username,password) 通过连接获取...
  • java操作mysql数据库的基本使用 第一步: 通过反射加载驱动: Class.forName("com.mysql.cj.jdbc.Driver"); 这时需要处理ClassNotFoundException 加载mysql数据库驱动:(向下兼容) mysql5:...
  • jdbc操作数据库的步骤

    2021-01-29 18:55:53
    JDBC(Java Data Base Connectivity,java...jdbc操作数据库的步骤 第一步:注册驱动 第二步:创建连接 第三步:创建执行数据库操作对象 第四步:执行sql语句 第五步:处理运行结果(针对查询) 第六步:释放资源 ...
  • jdbc操作数据库步骤

    2019-10-08 14:24:05
    jdbc java中用来操作数据库的技术 ...java操作数据库的步骤: 首先,保证在java项目中添加了数据库驱动(一个jar包) 1) 使用DriverManager获取Connection(连接)对象 Connection conn = DriverManag...
  • JDBC操作数据库的步骤

    千次阅读 2019-01-05 09:19:40
    JDBC操作数据库的步骤 1.加载JDBC驱动程序 在连接数据库前,首先要加载要连接数据库的驱动到Java虚拟机,通过java.lang.Class类的静态方法forName(String className)实现。例如,通过构造方法加载SQL Server2000: ...
  • package mysql;.../** JDBC操作数据库的步骤* 1.注册驱动* 告知JVM使用的是哪一个数据库驱动* 2.获得连接* 使用JDBC中的类,完成对Mysql数据库连接* 3.获得语句执行平台* 通过连接对象获取对SQL语句的执...
  • java 操作mysql数据库,需要在项目工程下添加mysql-connect-java-x.x.x.jar,然后引用该类,该类为本人封装好的操作数据库的类,操作步骤如下:1、新建Data对象 Data data=new Data();2、建立连接 data.connect();3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,389
精华内容 1,355
关键字:

java操作数据库的步骤

java 订阅