亚洲邪恶天堂影院在线观看,亚洲热线99精品视频,亚洲欧洲精品久久

java jdbc

semovy — Thu, 14 Feb 2008 13:35:00 GMT

package com.semovy.service.impl;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;

import com.semovy.bean.Database;

public class SQLServerDatabase implements Database {

private String driver = null;
private String pwd = null;
private String user = null;
private String url = null;
private Connection connection = null;
public String getUrl() {
  return url;
}
public void setUrl(String url) {
  this.url = url;
}
public String getUser() {
  return user;
}
public void setUser(String user) {
  this.user = user;
}
public String getDriver() {
  return driver;
}
public String getPwd() {
  return pwd;
}
public void setDriver(String driver)
{
  this.driver = driver;
}
public void setPwd(String pwd)
{
  this.pwd = pwd;
}
public Connection getConnection()
{
  openConnection();
  return this.connection;
}
public void setConnection(Connection connection) {
  this.connection = connection;
}
public List getData() {

  return null;
}
public SQLServerDatabase(String driver,String url,String user,String pwd)
{
  this.driver = driver;
  this.url = url;
  this.user = user;
  this.pwd = pwd;
  try
  {
   System.out.println("start");
   Class.forName(this.getDriver()).newInstance();
   this.connection = DriverManager.getConnection(this.getUrl(), this.getUser(), this.getPwd());
   System.out.println("OK");
  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
  catch(ClassNotFoundException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
  catch(Exception e)
  {
   System.out.println(e.getLocalizedMessage());
  }
}
/**
*
* @return
*/
private Connection openConnection()
{
  if(this.connection != null)
  {
   return this.connection;
  }
  else
  {
   try
   {
    Class.forName(this.getDriver()).newInstance();
    this.connection = DriverManager.getConnection(this.getUrl(), this.getUser(), this.getPwd());
   }catch(SQLException e)
   {
    System.out.println(e.getLocalizedMessage());
   }
   catch(ClassNotFoundException e)
   {
    System.out.println(e.getLocalizedMessage());
   }
   catch(Exception e)
   {
    System.out.println(e.getLocalizedMessage());
   }
   return this.connection;
  }

}
public void closeConnection()
{
  try
  {
   if(this.getConnection() != null && !this.connection.isClosed())
   {
    this.connection.close();
   }
  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
}
public ResultSet executeQuery(String sqlExp)
{
  ResultSet rs = null;
  Statement stmt = null;
  try
  {
   stmt = this.getConnection().createStatement();
   rs = stmt.executeQuery(sqlExp);
  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
  return rs;
}
public void executeUpdate(String sqlExp)
{
  try
  {
   this.getConnection().createStatement().executeUpdate(sqlExp);
  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
}
public void executeBatchUpdate()
{
  try
  {
   long start = System.currentTimeMillis();
   Statement stmt = this.getConnection().createStatement();
   for(int i=0;i < 10000;i++)
   {
    stmt.addBatch("insert into item values(2,'item" + i + "')");
    if(i%500 == 0 && i>0)
     stmt.executeBatch();
   }
   stmt.executeBatch();
   this.getConnection().commit();
   stmt.close();
   stmt = null;
   long spendTime = System.currentTimeMillis() - start;
   System.out.println("向数据库插入一万条记录用去:" + spendTime*1.0/1000 + " s");
  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }
}
public void display(ResultSet rs)
{
  try
  {
   ResultSetMetaData rsmd = rs.getMetaData();
   int colLen = rsmd.getColumnCount();
   while(rs.next())
   {
    for(int i=0; i     {
     System.out.print(rsmd.getColumnName(i+1) + ": " + rs.getObject(i+1) + " ");
    }
    System.out.println();
   }

  }catch(SQLException e)
  {
   System.out.println(e.getLocalizedMessage());
  }

}
}

package com.semovy.test;

import com.semovy.service.impl.SQLServerDatabase;

public class TestHelloWorld {

public static void main(String[] args) {

  // ApplicationContext appContext = new
  // FileSystemXmlApplicationContext("classpath:config.xml");
  // Hello hello = (Hello)appContext.getBean("hello");
  // hello.saySaluation();
  // IoC Inversion of Control 反向控制.
  // 发明者新命名�?DI dipendency Injection 依赖注入.
  // 反向控制是实��C��赖抽�?不是抽象依赖实现.
  SQLServerDatabase sqlServerDB = new SQLServerDatabase(
    "com.microsoft.jdbc.sqlserver.SQLServerDriver", "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=test",
    "sa", "1234");
  sqlServerDB.executeUpdate("drop table item if exist create table item(id int not null identity(1,1) primary key,int categoryId not null,itemName varchar(255) default '')");
  sqlServerDB.executeUpdate("delete from item");
  sqlServerDB.executeBatchUpdate();
  sqlServerDB.display(sqlServerDB.executeQuery("select top 100 * from item"));
  sqlServerDB.closeConnection();
}

}

semovy 2008-02-14 21:35 发表评论

JDBC存取ORACLE大型数据对象LOB几种情况的示范类

semovy — Tue, 13 Mar 2007 09:29:00 GMT

import java.io.*;
import java.util.*;
import java.sql.*;

public class LobPros
{

    /**
     * orACLE驱动�E�序
     */
    private static final String DRIVER = "oracle.jdbc.driver.OracleDriver";

    /**
     * orACLE�q�接用URL
     */
    private static final String URL = "jdbc:oracle:thin:@test2000:1521:orac";

    /**
     * 用户�?br />     */
    private static final String USER = "user";

    /**
     * 密码
     */
    private static final String PASSWORD = "pswd";

    /**
     * 数据库连�?br />     */
    private static Connection conn = null;

    /**
     * SQL语句对象
     */
    private static Statement stmt = null;

    /**
     * @roseuid 3EDA089E02BC
     */
    public LobPros()
    {

    }

    /**
     * 往数据库中插入一个新的CLOB对象
     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA04A902BC
     */
    public static void clobInsert(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 插入一个空的CLOB对象 */
            stmt.executeUpdate("Insert INTO TEST_CLOB VALUES ('111', EMPTY_CLOB())");
            /* 查询此CLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select CLOBCOL FROM TEST_CLOB Where ID='111' FOR Update");
            while (rs.next()) {
                /* 取出此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 向CLOB对象中写入数据�?/
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 修改CLOB对象�Q�是在原CLOB对象基础上进行覆盖式的修改）
     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA04B60367
     */
    public static void clobModify(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询CLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select CLOBCOL FROM TEST_CLOB Where ID='111' FOR Update");
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* �q�行覆盖式修改�?/
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 替换CLOB对象�Q�将原CLOB对象清除�Q�换成一个全新的CLOB对象�Q?br />     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA04BF01E1
     */
    public static void clobReplace(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 清空原CLOB对象 */
            stmt.executeUpdate("Update TEST_CLOB SET CLOBCOL=EMPTY_CLOB() Where ID='111'");
            /* 查询CLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select CLOBCOL FROM TEST_CLOB Where ID='111' FOR Update");
            while (rs.next()) {
                /* 获取此CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 更新数据 */
                BufferedWriter out = new BufferedWriter(clob.getCharacterOutputStream());
                BufferedReader in = new BufferedReader(new FileReader(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * CLOB对象��d��
     *
     * @param outfile - 输出文�g�?br />     * @throws java.lang.Exception
     * @roseuid 3EDA04D80116
     */
    public static void clobRead(String outfile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询CLOB对象 */
            ResultSet rs = stmt.executeQuery("Select * FROM TEST_CLOB Where ID='111'");
            while (rs.next()) {
                /* 获取CLOB对象 */
                oracle.sql.CLOB clob = (oracle.sql.CLOB)rs.getClob("CLOBCOL");
                /* 以字�W��Ş式输出�?/
                BufferedReader in = new BufferedReader(clob.getCharacterStream());
                BufferedWriter out = new BufferedWriter(new FileWriter(outfile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                out.close();
                in.close();
            }
        } catch (Exception ex) {
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 向数据库中插入一个新的BLOB对象
     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA04E300F6
     */
    public static void blobInsert(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 插入一个空的BLOB对象 */
            stmt.executeUpdate("Insert INTO TEST_BLOB VALUES ('222', EMPTY_BLOB())");
            /* 查询此BLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select BLOBCOL FROM TEST_BLOB Where ID='222' FOR Update");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据�?/
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 修改BLOB对象�Q�是在原BLOB对象基础上进行覆盖式的修改）
     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA04E90106
     */
    public static void blobModify(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询BLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select BLOBCOL FROM TEST_BLOB Where ID='222' FOR Update");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据�?/
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 替换BLOB对象�Q�将原BLOB对象清除�Q�换成一个全新的BLOB对象�Q?br />     *
     * @param infile - 数据文�g
     * @throws java.lang.Exception
     * @roseuid 3EDA0505000C
     */
    public static void blobReplace(String infile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 清空原BLOB对象 */
            stmt.executeUpdate("Update TEST_BLOB SET BLOBCOL=EMPTY_BLOB() Where ID='222'");
            /* 查询此BLOB对象�q��定�?/
            ResultSet rs = stmt.executeQuery("Select BLOBCOL FROM TEST_BLOB Where ID='222' FOR Update");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 向BLOB对象中写入数据�?/
                BufferedOutputStream out = new BufferedOutputStream(blob.getBinaryOutputStream());
                BufferedInputStream in = new BufferedInputStream(new FileInputStream(infile));
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * BLOB对象��d��
     *
     * @param outfile - 输出文�g�?br />     * @throws java.lang.Exception
     * @roseuid 3EDA050B003B
     */
    public static void blobRead(String outfile) throws Exception
    {
        /* 讑֮�不自动提交�?/
        boolean defaultCommit = conn.getAutoCommit();
        conn.setAutoCommit(false);

        try {
            /* 查询BLOB对象 */
            ResultSet rs = stmt.executeQuery("Select BLOBCOL FROM TEST_BLOB Where ID='222'");
            while (rs.next()) {
                /* 取出此BLOB对象 */
                oracle.sql.BLOB blob = (oracle.sql.BLOB)rs.getBlob("BLOBCOL");
                /* 以二�q�制形式输出 */
                BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outfile));
                BufferedInputStream in = new BufferedInputStream(blob.getBinaryStream());
                int c;
                while ((c=in.read())!=-1) {
                    out.write(c);
                }
                in.close();
                out.close();
            }
            /* 正式提交 */
            conn.commit();
        } catch (Exception ex) {
            /* 出错回滚 */
            conn.rollback();
            throw ex;
        }

        /* 恢复原提交状态�?/
        conn.setAutoCommit(defaultCommit);
    }

    /**
     * 建立��试用表�?br />     * @throws Exception
     */
    public static void createTables() throws Exception {
        try {
            stmt.executeUpdate("Create TABLE TEST_CLOB ( ID NUMBER(3), CLOBCOL CLOB)");
            stmt.executeUpdate("Create TABLE TEST_BLOB ( ID NUMBER(3), BLOBCOL BLOB)");
        } catch (Exception ex) {

        }
    }

    /**
     * @param args - 命��o行参�?br />     * @throws java.lang.Exception
     * @roseuid 3EDA052002AC
     */
    public static void main(String[] args) throws Exception
    {
        /* 装蝲驱动,建立数据库连接�?/
        Class.forName(DRIVER);
        conn = DriverManager.getConnection(URL,USER,PASSWORD);
        stmt = conn.createStatement();

        /* 建立��试表格 */
        createTables();

        /* CLOB对象插入��试 */
        clobInsert("c:/clobInsert.txt");
        clobRead("c:/clobInsert.out");

        /* CLOB对象修改��试 */
        clobModify("c:/clobModify.txt");
        clobRead("c:/clobModify.out");

        /* CLOB对象替换��试 */
        clobReplace("c:/clobReplace.txt");
        clobRead("c:/clobReplace.out");

        /* BLOB对象插入��试 */
        blobInsert("c:/blobInsert.doc");
        blobRead("c:/blobInsert.out");

        /* BLOB对象修改��试 */
        blobModify("c:/blobModify.doc");
        blobRead("c:/blobModify.out");

        /* BLOB对象替换��试 */
        blobReplace("c:/blobReplace.doc");
        blobRead("c:/bolbReplace.out");

        /* 关闭资源退出�?/
        conn.close();
        System.exit(0);
    }
}

semovy 2007-03-13 17:29 发表评论

semovy — Sun, 15 Oct 2006 03:31:00 GMT

Java数据库连接（JDBC�Q�由一�l�用 Java �~�程语言�~�写的类和接口组成。JDBC 为工�?数据库开发�h员提供了一个标准的 API�Q��他们能够用纯Java API 来编写数据库应用�E�序。然而各个开发商的接口�ƈ不完全相同，所以开发环境的变化会带来一定的配置变化。本文主要集合了不同数据库的�q�接方式�?br />
　　一、连接各�U�数据库方式速查�?br />
　　下面�|�列了各�U�数据库使用JDBC�q�接的方式，可以作�ؓ一个手册��用�?

　　1、Oracle8/8i/9i数据库（thin模式�Q?/strong>
Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl"; //orcl为数据库的SID
String user="test";
String password="test";
Connection conn= DriverManager.getConnection(url,user,password);

　　2、DB2数据�?/strong>
Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample"; //sample��Z��的数据库�?
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);

　　3、Sql Server7.0/2000数据�?/strong>
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=mydb";
//mydb为数据库
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);

　　4、Sybase数据�?/strong>
Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/myDB";//myDB��Z��的数据库�?
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps);

5、Informix数据�?/strong>
Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url = "jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword"; //myDB为数据库�?
Connection conn= DriverManager.getConnection(url);

　　6、MySQL数据�?/strong>
Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/myDB?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//myDB为数据库�?
Connection conn= DriverManager.getConnection(url);

　　7、PostgreSQL数据�?/strong>
Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/myDB" //myDB为数据库�?
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);

　　8、access数据库直�q�用ODBC�?br />
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver") ;
String url="jdbc:odbc:Driver={MicroSoft Access Driver (*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb");
Connection conn = DriverManager.getConnection(url,"","");
Statement stmtNew=conn.createStatement() ;

　　二、JDBC�q�接MySql方式

　　下面是��用JDBC�q�接MySql的一个小的教�E?

　　1、查��N��动程�?/strong>

　　MySQL目前提供的java驱动�E�序为Connection/J�Q�可以从MySQL官方�|�站下蝲�Q��ƈ扑ֈ�mysql-connector-java-3.0.15-ga-bin.jar文�g�Q�此驱动�E�序为纯java驱动�E�序�Q�不需做其他配�|��?br />
2、动态指定classpath

　　如果需要执行时动态指定classpath�Q�就在执行时采用�Q�cp方式。否则将上面�?jar文�g加入到classpath环境变量中�?br />
　　3、加载驱动程�?/strong>
try{
　Class.forName(com.mysql.jdbc.Driver);
　System.out.println(Success loading Mysql Driver!);
}catch(Exception e)
{
　System.out.println(Error loading Mysql Driver!);
　e.printStackTrace();
}

　　4、设�|�连接的url

jdbc�Q�mysql�Q?/localhost/databasename[?pa=va][�Q�pa=va]

　　三、以下列��Z��在��用JDBC来连接Oracle数据库时可以使用的一些技�?/strong>

　　1、在客户端��Y件开发中使用Thin驱动�E�序

　　在开发Java软�g斚w��Q�Oracle的数据库提供了四�U�类型的驱动�E�序�Q�二�U�用于应用��Y件、applets、servlets�{�客��L��软�g�Q�另外二�U�用于数据库中的Java存储�q�程�{�服务器端��Y件。在客户机端软�g的开发中�Q�我们可以选择OCI驱动�E�序或Thin驱动�E�序。OCI驱动�E�序利用Java本地化接口（JNI�Q�，通过Oracle客户端��Y件与数据库进行通讯。Thin驱动�E�序是纯Java驱动�E�序�Q�它直接与数据库�q�行通讯。�ؓ了获得最高的性能�Q�Oracle��在客��L��软�g的开发中使用OCI驱动�E�序�Q�这��g��是正��的。但我徏议��用Thin驱动�E�序�Q�因为通过多次��试发现�Q�在通常情况下，Thin驱动�E�序的性能都超�q�了OCI驱动�E�序�?br />
　　2、关闭自动提交功能，提高�pȝ��性能

　　在第一�ơ徏立与数据库的�q�接�Ӟ��在缺省情况下�Q�连接是在自动提交模式下的。�ؓ了获得更好的性能�Q�可以通过调用带布��值false参数的Connection�cȝ��setAutoCommit()�Ҏ��关闭自动提交功能�Q�如下所�C�：
　　conn.setAutoCommit(false);

　　值得注意的是�Q�一旦关闭了自动提交功能�Q�我们就需要通过调用Connection�cȝ��commit()和rollback()�Ҏ��来�h工的方式对事务进行管理�?br />
3、在动态SQL或有旉��限制的命令中使用Statement对象

　　在执行SQL命��o�Ӟ��我们有二�U�选择�Q�可以��用PreparedStatement对象�Q�也可以使用Statement对象。无论多��次��C��用同一个SQL命��o�Q�PreparedStatement都只对它解析和编译一�ơ。当使用Statement对象�Ӟ��每次执行一个SQL命��o�Ӟ��都会对它�q�行解析和编译。这可能会��你认为，使用PreparedStatement对象比��用Statement对象的速度更快。然而，我进行的��试表明�Q�在客户端��Y件中�Q�情况�ƈ非如此。因此，在有旉��限制的SQL操作中，除非成批地处理SQL命��o�Q�我们应当考虑使用Statement对象�?br />
　　此外�Q��用Statement对象也��得编写动态SQL命��o更加��单，因�ؓ我们可以��字�W�串�q�接在一��P��建立一个有效的SQL命��o。因此，我认为，Statement对象可以使动态SQL命��o的创建和执行变得更加��单�?br />
　　4、利用helper函数对动态SQL命��o�q�行格式�?/strong>

　　在创��Z��用Statement对象执行的动态SQL命��o�Ӟ��我们需要处理一些格式化斚w��的问题。例如，如果我们惛_��Z��个将名字O'Reilly插入表中的SQL命��o�Q�则必须使用二个相连的�?'”号替换O'Reilly中的�?”号。完成这些工作的最好的�Ҏ��是创��Z��个完成替换操作的helper�Ҏ��Q�然后在�q�接字符串心服用公式表达一个SQL命��o�Ӟ��使用创徏的helper�Ҏ��。与此类似的是，我们可以让helper�Ҏ��接受一个Date型的��|��然后让它输出��Z��Oracle的to_date()函数的字�W�串表达式�?br />
　　5、利用PreparedStatement对象提高数据库的��M��效率

　　在��用PreparedStatement对象执行SQL命��o�Ӟ��命��o被数据库�q�行解析和编译，然后被放到命令缓冲区。然后，每当执行同一个PreparedStatement对象�Ӟ��它就会被再解析一�ơ，但不会被再次�~�译。在�~�冲��Z��可以发现预编译的命��o�Q��ƈ且可以重��C��用。在有大量用��L��企业�U�应用��Y件中�Q�经�怼�重复执行相同的SQL命��o�Q��用PreparedStatement对象带来的编译次数的减少能够提高数据库的��M��性能。如果不是在客户端创建、预备、执行PreparedStatement��d��需要的旉��长于Statement��d��Q�我会徏议在除动态SQL命��o之外的所有情况下使用PreparedStatement对象�?br />
　　6、在成批处理重复的插入或更新操作中��用PreparedStatement对象

　　如果成批地处理插入和更新操作�Q�就能够显著地减��它们所需要的旉��。Oracle提供的Statement�?CallableStatement�q�不真正地支持批处理�Q�只有PreparedStatement对象才真正地支持批处理。我们可以��用addBatch()和executeBatch()�Ҏ��选择标准的JDBC批处理，或者通过利用PreparedStatement对象的setExecuteBatch()�Ҏ��和标准的executeUpdate()�Ҏ��选择速度更快的Oracle专有的方法。要使用Oracle专有的批处理机制�Q�可以以如下所�C�的方式调用setExecuteBatch()�Q?br />
PreparedStatement pstmt3D null;
try {
　((OraclePreparedStatement)pstmt).setExecuteBatch(30);
　...
　pstmt.executeUpdate();
}

　　调用setExecuteBatch()时指定的值是一个上限，当达到该值时�Q�就会自动地引发SQL命��o执行�Q�标准的executeUpdate()�Ҏ��׃��被作为批处理送到数据库中。我们可以通过调用PreparedStatement�cȝ��sendBatch()�Ҏ��随时传输批处理�Q务�?br />
7、��用Oracle locator�Ҏ��插入、更新大对象�Q�LOB�Q?br />
　　Oracle的PreparedStatement�c�M��完全支持BLOB和CLOB�{�大对象的处理，��其是Thin驱动�E�序不支持利用PreparedStatement对象的setObject()和setBinaryStream()�Ҏ��讄��BLOB的��|��也不支持利用setCharacterStream()�Ҏ��讄��CLOB的倹{��只有locator本��n中的�Ҏ��才能够从数据库中获取LOB�c�d��的倹{��可以��用PreparedStatement对象插入或更新LOB�Q�但需要��用locator才能获取LOB的倹{��由于存在这二个问题�Q�因此，我徏议��用locator的方法来插入、更新或获取LOB的倹{�?br />
　　8、��用SQL92语法调用存储�q�程

　　在调用存储过�E�时�Q�我们可以��用SQL92或Oracle PL/SQL�Q�由于��用Oracle PL/SQL�q�没有什么实际的好处�Q�而且会给以后�l�护你的应用�E�序的开发�h员带来麻烦，因此�Q�我��在调用存储过�E�时使用SQL92�?br />
　　9、��用Object SQL��对象模式�{�U�d��数据库中

　　既然可以��Oracle的数据库作�ؓ一�U�面向对象的数据库来使用�Q�就可以考虑��应用程序中的面向对象模式�{到数据库中。目前的�Ҏ��是创建Java bean作�ؓ伪装的数据库对象�Q�将它们的属性映��到关系表中�Q�然后在�q�些bean中添加方法。尽��这样作在Java中没有什么问题，但由于操作都是在数据库之外进行的�Q�因此其他访问数据库的应用��Y件无法利用对象模式。如果利用Oracle的面向对象的技术，可以通过创徏一个新的数据库对象�c�d��在数据库中模仿其数据和操作，然后使用JPublisher�{�工��L��成自��q��Java bean�c�R��如果��用这�U�方式，不但Java应用�E�序可以使用应用软�g的对象模式，其他需要共享你的应用中的数据和操作的应用��Y件也可以使用应用软�g中的对象模式�?br />
　　10、利用SQL完成数据库内的操�?/strong>

　　我要向大家介�l�的最重要的经验是充分利用SQL的面向集合的�Ҏ��来解��x��据库处理需求，而不是��用Java�{�过�E�化的编�E�语�a��?br />
　　如果�~�程人员要在一个表中查找许多行�Q�结果中的每个行都会查找其他表中的数据，最后，�~�程人员创徏了独立的UPDATE命��o来成批地更新�W�一个表中的数据。与此类似的��d��可以通过在set子句中��用多列子查询而在一个UPDATE命��o中完成。当能够在单一的SQL命��o中完成�Q务，何必要让数据在网上流来流�ȝ��Q�我��用户认真学习如何最大限度地发挥SQL的功能�?

semovy 2006-10-15 11:31 发表评论