1、在客户端软件开发中使用Thin驱动程序 

　　在开发Java软件方面，Oracle数据库提供了四种类型的驱动程序，其中两种用于应用软件、applets、servlets等客户端软件，另外二种用于数据库中的Java存储过程等服务器端软件。在客户机端软件的开发中，我们可以选择OCI驱动程序或Thin驱动程序。OCI驱动程序利用 Java本地化接口（JNI），通过Oracle客户端软件与数据库进行通讯。Thin驱动程序是纯Java驱动程序，它直接与数据库进行通讯。为了获得最高的性能，Oracle建议在客户端软件的开发中使用OCI驱动程序，这似乎是正确的。但我建议使用Thin驱动程序，因为通过多次测试发现，在通常情况下，Thin驱动程序的性能都超过了OCI驱动程序。 

　　2、关闭自动提交功能，提高系统性能 

　　在第一次建立与数据库的连接时，在缺省情况下，连接是在自动提交模式下的。为了获得更好的性能，可以通过调用带布尔值false参数的Connection类的setAutoCommit（）方法关闭自动提交功能，如下所示： 

　　conn.setAutoCommit（false）； 

　　值得注意的是，一旦关闭了自动提交功能，我们就需要通过调用Connection类的commit（）和rollback（）方法来人工的方式对事务进行管理。 

　　3、在动态SQL或有时间的命令中使用Statement对象 

　　在执行SQL命令时，我们有二种选择：可以使用PreparedStatement对象，也可以使用Statement对象。无论多少次地使用同一个SQL命令，PreparedStatement都只对它解析和编译一次。当使用Statement对象时，每次执行一个SQL命令时，都会对它进行解析和编译。这可能会使你认为，使用PreparedStatement对象比使用Statement对象的速度更快。然而，我进行的测试表明，在客户端软件中，情况并非如此。因此，在有时间的SQL操作中，除非成批地处理SQL命令，我们应当考虑使用Statement对象。 

　　此外，使用Statement对象也使得编写动态SQL命令更加简单，因为我们可以将字符串连接在一起，建立一个有效的SQL命令。因此，我认为，Statement对象可以使动态SQL命令的创建和执行变得更加简单。 

　　4、利用helper函数对动态SQL命令进行格式化 

　　在创建使用Statement对象执行的动态SQL命令时，我们需要处理一些格式化方面的问题。例如，如果我们想创建一个将名字 O'Reilly插入表中的SQL命令，则必须使用二个相连的“''”号替换O'Reilly中的“'”号。完成这些工作的最好的方法是创建一个完成替换操作的helper方法，然后在连接字符串心服用公式表达一个SQL命令时，使用创建的helper方法。与此类似的是，我们可以让helper方法接受一个Date型的值，然后让它输出基于Oracle的to_date（）函数的字符串表达式。 

　　5、利用PreparedStatement对象提高数据库的总体效率 

　　在使用PreparedStatement对象执行SQL命令时，命令被数据库进行解析和编译，然后被放到命令缓冲区。然后，每当执行同一个 PreparedStatement对象时，它就会被再解析一次，但不会被再次编译。在缓冲区中可以发现预编译的命令，并且可以重新使用。在有大量用户的企业级应用软件中，经常会重复执行相同的SQL命令，使用PreparedStatement对象带来的编译次数的减少能够提高数据库的总体性能。如果不是在客户端创建、预备、执行PreparedStatement任务需要的时间长于Statement任务，我会建议在除动态SQL命令之外的所有情况下使用PreparedStatement对象。 

　　6、在成批处理重复的插入或更新操作中使用PreparedStatement对象 

　　如果成批地处理插入和更新操作，就能够显着地减少它们所需要的时间。Oracle提供的Statement和 CallableStatement并不真正地支持批处理，只有PreparedStatement对象才真正地支持批处理。我们可以使用 addBatch（）和executeBatch（）方法选择标准的JDBC批处理，或者通过利用PreparedStatement对象的 setExecuteBatch（）方法和标准的executeUpdate（）方法选择速度更快的Oracle专有的方法。要使用Oracle专有的批处理机制，可以以如下所示的方式调用setExecuteBatch（）： 

PreparedStatement pstmt3D null; 

try { 

((OraclePreparedStatement) 

pstmt).setExecuteBatch(30); 

... 

pstmt.executeUpdate(); 

} 

　　调用setExecuteBatch（）时指定的值是一个上限，当达到该值时，就会自动地引发SQL命令执行，标准的executeUpdate（）方法就会被作为批处理送到数据库中。我们可以通过调用PreparedStatement类的sendBatch（）方法随时传输批处理任务。 

　　7、使用Oracle locator方法插入、更新大对象（LOB） 

　　Oracle的PreparedStatement类不完全支持BLOB和CLOB等大对象的处理，尤其是Thin驱动程序不支持利用 PreparedStatement对象的setObject（）和setBinaryStream（）方法设置BLOB的值，也不支持利用 setCharacterStream（）方法设置CLOB的值。只有locator本身中的方法才能够从数据库中获取LOB类型的值。可以使用 PreparedStatement对象插入或更新LOB，但需要使用locator才能获取LOB的值。由于存在这二个问题，因此，我建议使用 locator的方法来插入、更新或获取LOB的值。 

　　8、使用SQL92语法调用存储过程 

　　在调用存储过程时，我们可以使用SQL92或Oracle PL/SQL，由于使用Oracle PL/SQL并没有什么实际的好处，而且会给以后维护你的应用程序的开发人员带来麻烦，因此，我建议在调用存储过程时使用SQL92. 

　　9、使用Object SQL将对象模式转移到数据库中 

　　既然可以将Oracle的数据库作为一种面向对象的数据库来使用，就可以考虑将应用程序中的面向对象模式转到数据库中。目前的方法是创建 Java bean作为伪装的数据库对象，将它们的属性映射到关系表中，然后在这些bean中添加方法。尽管这样作在Java中没有什么问题，但由于操作都是在数据库之外进行的，因此其他访问数据库的应用软件无法利用对象模式。如果利用Oracle的面向对象的技术，可以通过创建一个新的数据库对象类型在数据库中模仿其数据和操作，然后使用JPublisher等工具生成自己的Java bean类。如果使用这种方式，不但Java应用程序可以使用应用软件的对象模式，其他需要共享你的应用中的数据和操作的应用软件也可以使用应用软件中的对象模式。 

　　10、利用SQL完成数据库内的操作 

　　我要向大家介绍的最重要的经验是充分利用SQL的面向集合的方法来解决数据库处理需求，而不是使用Java等过程化的编程语言。 

　　如果编程人员要在一个表中查找许多行，结果中的每个行都会查找其他表中的数据，最后，编程人员创建了的UPDATE命令来成批地更新第一个表中的数据。与此类似的任务可以通过在set子句中使用多列子查询而在一个UPDATE命令中完成。当能够在单一的SQL命令中完成任务，何必要让数据在网上流来流去的？我建议用户认真学习如何最大限度地发挥SQL的功能 

JAVA反射机制

    JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 

Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。 

1. 得到某个对象的属性 

1 public Object getProperty(Object owner, String fieldName) throws Exception { 

2     Class ownerClass = owner.getClass(); 

3 

4     Field field = ownerClass.getField(fieldName); 

5 

6     Object property = field.get(owner); 

7 

8     return property; 

9 } 

Class ownerClass = owner.getClass()：得到该对象的Class。 

Field field = ownerClass.getField(fieldName)：通过Class得到类声明的属性。 

Object property = field.get(owner)：通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException。 

2. 得到某个类的静态属性 

1 public Object getStaticProperty(String className, String fieldName) 

2             throws Exception { 

3     Class ownerClass = Class.forName(className); 

4 

5     Field field = ownerClass.getField(fieldName); 

6 

7     Object property = field.get(ownerClass); 

8 

9     return property; 

10 } 

Class ownerClass = Class.forName(className) ：首先得到这个类的Class。 

Field field = ownerClass.getField(fieldName)：和上面一样，通过Class得到类声明的属性。 

Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class里取。 

3. 执行某对象的方法 

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception { 

2 

3     Class ownerClass = owner.getClass(); 

4 

5     Class[] argsClass = new Class[args.length]; 

6 

7     for (int i = 0, j = args.length; i < j; i++) {

8         argsClass[i] = args[i].getClass(); 

9     } 

10 

11     Method method = ownerClass.getMethod(methodName, argsClass); 

12 

13     return method.invoke(owner, args); 

14 } 

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class。 

5～9行：配置参数的Class数组，作为寻找Method的条件。 

Method method = ownerClass.getMethod(methodName, argsClass)：通过Method名和参数的Class数组得到要执行的Method。 

method.invoke(owner, args)：执行该Method，invoke方法的参数是执行这个方法的对象，和参数数组。返回值是Object，也既是该方法的返回值。 

4. 执行某个类的静态方法 

1 public Object invokeStaticMethod(String className, String methodName, 

2             Object[] args) throws Exception { 

3     Class ownerClass = Class.forName(className); 

4 

5     Class[] argsClass = new Class[args.length]; 

6 

7     for (int i = 0, j = args.length; i < j; i++) {

8         argsClass[i] = args[i].getClass(); 

9     } 

10 

11     Method method = ownerClass.getMethod(methodName, argsClass); 

12 

13     return method.invoke(null, args); 

14 } 

基本的原理和实例3相同，不同点是最后一行，invoke的一个参数是null，因为这是静态方法，不需要借助实例运行。 

5. 新建实例 

1 

2 public Object newInstance(String className, Object[] args) throws Exception { 

3     Class newoneClass = Class.forName(className); 

4 

5     Class[] argsClass = new Class[args.length]; 

6 

7     for (int i = 0, j = args.length; i < j; i++) {

8         argsClass[i] = args[i].getClass(); 

9     } 

10 

11     Constructor cons = newoneClass.getConstructor(argsClass); 

12 

13     return cons.newInstance(args); 

14 

15 } 

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance()来实现。 

Class newoneClass = Class.forName(className)：第一步，得到要构造的实例的Class。 

第5～第9行：得到参数的Class数组。 

Constructor cons = newoneClass.getConstructor(argsClass)：得到构造子。 

cons.newInstance(args)：新建实例。 

6. 判断是否为某个类的实例 

1 public boolean isInstance(Object obj, Class cls) { 

2     return cls.isInstance(obj); 

3 } 

7. 得到数组中的某个元素 

1 public Object getByArray(Object array, int index) { 

2     return Array.get(array,index); 

3 } 

一个Java程序员应该掌握的10项技能

来源：javaeye博客

1、语法：必须比较熟悉，在写代码的时候IDE的编辑器对某一行报错应该能够根据报错信息知道是什么样的语法错误并且知道任何修正。 

2、命令：必须熟悉JDK带的一些常用命令及其常用选项，命令至少需要熟悉：appletviewer、 HtmlConverter、jar、 java、javac、javadoc、javap、javaw、native2ascii、serialver，如果这些命令你没有全部使用过，那么你对java实际上还很不了解。 

3、工具：必须至少熟练使用一种IDE的开发工具，例如Eclipse、Netbeans、JBuilder、Jdeveloper、IDEA、JCreator或者Workshop，包括进行工程管理、常用选项的设置、插件的安装配置以及进行调试。 

4、API：Java的核心API是非常庞大的，但是有一些内容笔者认为是必须熟悉的，否则不可能熟练的运用Java，包括： 

◆java.lang包下的80％以上的类的功能的灵活运用。 

◆java.util包下的80％以上的类的灵活运用，特别是集合类体系、规则表达式、zip、以及时间、随机数、属性、资源和Timer. 

◆java.io包下的60％以上的类的使用，理解IO体系的基于管道模型的设计思路以及常用IO类的特性和使用场合。 

◆java.math包下的100％的内容。 

◆java.net包下的60％以上的内容，对各个类的功能比较熟悉。 

◆java.text包下的60％以上的内容，特别是各种格式化类。 

◆熟练运用JDBC. 8）、java.security包下40％以上的内容，如果对于安全没有接触的话根本就不可能掌握java. 

◆AWT的基本内容，包括各种组件事件、、布局管理器、常用组件、打印。 

◆Swing的基本内容，和AWT的要求类似。 

◆XML处理，熟悉SAX、DOM以及JDOM的优缺点并且能够使用其中的一种完成XML的解析及内容处理。 

5、测试：必须熟悉使用junit编写测试用例完成代码的自动测试。 

6、管理：必须熟悉使用ant完成工程管理的常用任务，例如工程编译、生成javadoc、生成jar、版本控制、自动测试。 

7、排错：应该可以根据异常信息比较快速的定位问题的原因和大致位置。 

8、思想：必须掌握OOP的主要要求，这样使用Java开发的系统才能是真正的Java系统。 

9、规范：编写的代码必须符合流行的编码规范，例如类名首字母大写，成员和方法名首字母小写，方法名的第一个单词一般是动词，包名全部小写等，这样程序的可读性才比较好。 

10、博学：掌握J2EE 、Oracle 、WebLogic、Jboss、Spring、Struts、Hibernate 等流行技术，掌握软件架构设计思想、搜索引擎优化、缓存系统设计、网站负载均衡、系统性能调优等实用技术。

1.import java.sql.Connection;   

2.import java.sql.DriverManager;   

3.import java.sql.ResultSet;   

4.import java.sql.SQLException;   

5.import java.sql.Statement;   

6.import java.util.Date;   

7.  

8./**  

9.* 用JDBC连接Oracle并读取数据的例子。  

10.*  

11.*   

12.*/  

13.public class jdbc {   

14.String dbUrl = "jdbc:oracle:thin:@127.0.0.1:1521:orcl";   

15.  

16.String theUser = "scott";   

17.  

18.String thePw = "tiger";   

19.  

20.Connection c = null;   

21.  

22.Statement conn;   

23.  

24.ResultSet rs = null;   

25.  

26.public jdbc() {   

27.    try {   

28.      Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();   

29.      c = DriverManager.getConnection(dbUrl, theUser, thePw);   

30.      conn = c.createStatement();   

31.    } catch (Exception e) {   

32.      e.printStackTrace();   

33.    }   

34.}   

35.  

36.public boolean executeUpdate(String sql) {   

37.    try {   

38.      conn.executeUpdate(sql);   

39.      return true;   

40.    } catch (SQLException e) {   

41.      e.printStackTrace();   

42.      return false;   

43.    }   

44.}   

45.  

46.public ResultSet executeQuery(String sql) {   

47.    rs = null;   

48.    try {   

49.      rs = conn.executeQuery(sql);   

50.    } catch (SQLException e) {   

51.      e.printStackTrace();   

52.    }   

53.    return rs;   

54.}   

55.  

56.public void close() {   

57.    try {   

58.      conn.close();   

59.      c.close();   

60.    } catch (Exception e) {   

61.      e.printStackTrace();   

62.    }   

63.}   

.  

65.public static void main(String[] args) {   

66.    ResultSet rs;   

67.    jdbc conn = new jdbc();   

68.    rs = conn.executeQuery("select * from test");   

69.    try {   

70.      while (rs.next()) {   

71.        System.out.println(rs.getString("id"));   

72.        System.out.println(rs.getString("name"));   

73.      }   

74.    } catch (Exception e) {   

75.      e.printStackTrace();   

76.    }   

77.}   

78.}  下载本文