csusky

数据库的事务 JDBC

TRANSACTION_NONE:
  正式地讲，TRANSACTION_NONE不是一个有效的事务级别。
  根据java.sql Connection API文件，这个级别表示事务是
  不被支持的，因此理论上说你不能使用TRANSACTION_NONE作
  为一个自变量赋给Connection.setTransactionIsolation()
  方法。事实上，虽然一些数据库实施了这个事务级别，但是
  Oracle9i却没有实施。

脏读取(TRANSACTION_READ_UNCOMMITTE):
（允许的操作       读-读读-写写-读     （脏数据，不可重复读，虚读））
   表示,这个事务级别
  允许读取脏数据,什么是脏数据?就是指还没有提交的数据.
  因为这个级别,是允许一个事务(A)读取另一个事务(B)
  还没有提交的数据.一旦事务B发生异常退出.而修改了的数据
  却还没提交,或者新插入的数据和删除了的数据都还没有
  提交,导致事务A拿到了一些脏数据,或者错误数据;
  因此在这个事务级别里是会发生脏读,重复读,错误读取;

禁止脏读(TRANSACTION_READ_COMMITTED):
（允许的操作       读-读读-写（不可重复读，虚读））
在这个级别中,事务A
  只能读取一些提交的数据,如事务B添加了一条记录,但是
  如果事务B没有提交,那么事务A是读不到的,所以该事务级别,
  把脏读给屏蔽掉了.---却允许重复读取,和错误读取.

  什么是重复读取呢?譬如,事务A读取了一个数据,这个数据
  的值为"helloworld",事务A准备利用这个数据来更新一下
  其他数据,但这个时候事务B开始对这个数据进行修改,并且
  提交---"hello 无名氏",由于是已经提交了,所以事务A是可以
  看到这个数据的,当事务A在没提交事务之前,它想看下数据
  是否正确,这个时候它发现,新读出的数据已经和原来的数据
  不一样了(这就是重复读取);

允许重复读取(TRANSACTION_REPEATABLE_READ):
（允许的操作       读-读读-写（仅允许插入，不允许删除和修改）（虚读））
在这个级别中,
  是禁止了脏读,和取消了不可重复读取,但是没有禁止错误读取;
  这个级别的事务比较严格,当一个事务A在读取一个值的时候
  是不允许另一个事务对该值进行修改的;
  为了允许重复读取,可以选用该级别,因为TRANSACTION_READ_
  COMMITED这个事务级别,是允许重复读取提交的数据的,如果
  事务A在读取一个数值的时候,值为"Hello World!",但这个时
  候事务B对"Hello World"值进行修改了,改为"Hello EveryOne"
  然后提交,当事务A再次去读取这个值的时候,去发现原来读到
  的值改变了,变成了"Hello EveryOne",为了防止出现这种情况
  可以禁止重复提交,目的是为了重复读取不会出错!那么这个
  时候就可以选择
TRANSACTION_REPEATABLE_READ这个级别,
  这个级别就是用来禁止重复提交的.
（实际上是加了行锁，锁定了选中的数据，不允许修改，但是允许插入新的数据）
  虽然这个时候是禁止了重复提交,但却可以添加删除,
  比如事务A,作了个查询语句"select * from 无名氏 "; 这个时候是允许事务B做这样的操作的:
  "insert into 无名氏 values(2,'aaa')"; 这个时候,
  事务A再次做读取操作的时候,却发现数据莫名其妙的
  多了一条,这就是所谓的---幻影读取;

禁止幻读(TRANSACTION_SERIALIZABLE):
事务的最高级别(串行化  操作)事务级别最高,所耗费的性能也越多.
  禁止幻读禁止了脏读,禁止了重复提交和幻读.
  也就是当事务A在按条件查询的时候,事务A一旦没有提
  交,任何事务都不能对事务A的资源进行操作--- 保证
  事务A的操作真正的原子性!

注意:在Oracle中只支持两种级别:

TRANSACTION_READ_COMMITTED(默认的级别)(只有提交后
才可以读取)而每一个终端进行自己的DML操作都自动开启了一个事务

TRANSACTION_SERIALIZABLE(窜行化操作)

posted @ 2008-03-05 09:34 晓宇阅读(308) | 评论 (0) | 编辑收藏

字符串池

Java运行环境有一个字符串池，由String类维护。执行语句String str="abc"时，首先查看字符串池中是否存在字符串"abc"，如果存在则直接将"abc"赋给str，如果不存在则先在字符串池中新建一个字符串"abc"，然后再将其赋给str。执行语句String str=new String("abc")时，不管字符串池中是否存在字符串"abc"，直接新建一个字符串"abc"（注意：新建的字符串"abc"不是在字符串池中），然后将其付给str。前一语句的效率高，后一语句的效率低，因为新建字符串占用内存空间。String str = new String()创建了一个空字符串，与String str=new String("")相同。

public String intern()

返回字符串对象的规范化表示形式。

一个初始为空的字符串池，它由类 String 私有地维护。

当调用 intern 方法时，如果池已经包含一个等于此 String 对象的字符串（用 equals(Object) 方法确定），则返回池中的字符串。否则，将此 String 对象添加到池中，并返回此 String 对象的引用。

它遵循以下规则：对于任意两个字符串 s 和 t，当且仅当 s.equals(t) 为 true 时，s.intern() == t.intern() 才为 true。

String.intern();
再补充介绍一点：存在于.class文件中的常量池，在运行期间被jvm装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，java查找常量池中是否有相同unicode的字符串常量，如果有，则返回其引用，如果没有，则在常量池中增加一个unicode等于str的字符串并返回它的引用。
例3：
String s0=”kvill”;
String s1=new String(“kvill”);
String s2=new String(“kvill”);
System.out.println(s0==s1);
S1.intern();
S2=s2.intern();
System.out.println(s0==s1);
System.out.prntln(s0==s1.intern());
System.out.println(s0==s2);
结果为：
False
False //虽然执行了s1.intern()，但它的返回值没有赋给s1
True
True
最后再破除一个错误的理解：
有人说，“使用String.intern()方法可以将一个String类保存到一个全局的String表中，如果具有相同值的unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中”如果把这个全局的String表理解为常量吃的话，最后一句话“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的。
例4：
String s1=new String(“kvill”);
String s2=s1.intern();
System.out.println(s1==s1.intern());
System.out.println(s1+” ”+s2);
System.out.println(s2==s1.intern());
结果是：
False
Kvill kvill
True
我们没有声明一个”kvill”常量，所以常量池中一开始没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“把自己的地址注册到常量池中”了。
例5：
String str1=”java”;
String str2=”blog”;
String s=str1+str2;
System.out.println(s==”javablog”);
结果是false。Jvm确实对型如String str1=”java”;的String对象放在常量池里，但是它是在编译时那么做的，而String s=str1+str2;是在运行时刻才能知道，也就是说str1+str2是在堆里创建的，所以结果为false了。

比较两个已经存在于字符串池中字符串对象可以用"=="进行，拥有比equals操作符更快的速度

posted @ 2008-03-04 09:40 晓宇阅读(831) | 评论 (0) | 编辑收藏

JAVA中的异常处理

在JAVA中，如果某个方法不能够按照正常的途径完成它的任务，就可以通过另外一个途径退出方法。在这种情况下，方法并不立刻返回，而是抛出一个封装了错误信息的对象。需要注意的是，这个方法将会立刻退出，且并不返回正常情况下的值。此外，调用这个方法的代码也将无法执行，取而代之的是，异常处理机制开始搜索能够处理这种错误条件的异常处理器。

如果在子类中覆盖了超类的一个方法，那么子类方法声明的已检查异常不能超过超类方法中声明的异常围。（也就是说子类中抛出的异常范围更小或者根本不抛出异常）。需要说明的是，如果超类方法没有抛出任何异常，子类也不能抛出任何已检查异常。例如，如果覆盖JComponent.paintComponent()方法，那么由于超类中没有抛出任何异常，所以自定义的paintComponent()方法也不能抛出任何异常。

如何抛出异常：
譬如在读一个输入流时，如果期待的字节数为1024，而当读到700字节的时候遇到一个EOF信号，这是我们未预期的，正是我们要抛出的异常，下面就是抛出改异常的语句

1

String readData() throws EOFException {
2

while (

) {
3

if(!in.hasNext()) {
4

if(n<len)
5

throw new EOFException();
6

}
7

}
8

}

这是抛出已存在标准的异常，步骤为：
1.找到一个合适的异常类
2.创建该类的对象
3.将异常抛出
一旦抛出异常，该方法就不可能返回到调用者，这就意味着不必为返回的默认值或错误代码担忧了。

在程序中可能会遇到任何标准异常都无法正确描述清楚的问题，这时候就需要定义自己的异常类，定义自己的异常类需要继承自Exception 或者其子类，如继承自IOException 一般要为自定义的Exception定义两个构造函数，一个是默认的无参的构造函数，另一个是带一个描述详细错误信息String的构造函数（超类的toString（）方法会打印出这些详细信息。

1

public class MyException extends IOException {
2

3

MyException () {}
4

5

MyException (String info) {
6

super(info);
7

}
8

}

现在就可以像使用标准Exception类一样使用自定义的Exception类了

1

String readData() throws MyException {
2

while () {
3

if(!in.hasNext()) {
4

if(n<len)
5

throw new MyException();
6

}
7

}
8

}

可以用超类Throwable类的getMessage方法得到详细的错误描述信息。或者toString()方法打印该信息。

捕获异常：
如果语句exp1有可能抛出一个异常，或者说是调用了能够抛出一个异常的方法，那么我们可以在程序中捕获该异常

1

try {
2

exp1;
3

exp2;
4

.
5

6

} catch(Exception e) {
7

e.
8

}
9

或者是并不捕获，再次抛出该异常

再次抛出异常，异常链：
可以在catch块中再次抛出新的异常，这样可以隐藏原始的错误细节

1

} catch(SQLException sqle) {
2

throw new ServletException("caused by SQLException "+e.getMessage());
3

}

另一种更好的方法
既抛出高级的异常，又不会丢失原始的异常信息。

1

}catch(SQLException sqle) {
2

Throwable ta=new ServletException("caused by SQLException");
3

ta.setCause(e);
4

throw ta;
5

}
6

当捕获抛出的异常ta时，可以用ta.getCause(),得到原始的异常

finally子句，发生三种情况时，会执行finally子句
1.try代码正常执行
2.try代码抛出一个在catch子句中捕获的异常
3.try代码抛出一个未在catch子句中捕获的异常
就是说无论异常如何，finally子句中的代码都会执行
一般把一些资源回收的工作交给finally子句

最好把try-catch块和try-finally块分开，这样可以提高代码的清晰度

1

try {
2

try {
3

//可能抛出IOException的语句
4

} finally {
5

is.close();
6

}
7

} catch(IOExceotion e) {
8

9

}
10

这样的另外一个好处是，可以catch到finally子句中抛出的异常。这也就引发了另外一个问题，如果在try和finally中都抛出了异常，而且是不同类型的，那么最后返回的是那一个呢？答案是finally中抛出的异常会覆盖try中抛出的异常。从而丢失了try当中抛出的异常信息，让抛出该方法的使用者不能跟踪异常信息。所以，在finally中执行的语句最好是不要抛出异常，但是不幸的是我们有时候不得不在finally中执行一些清楚操作如：关闭输入流InputStream,但是InputStream类的设计者并没有这么设计（将会抛出异常）。

由于finally子句总是会执行，所以在finally中包含return值时，是很危险的。假设我们利用return语句从try中返回，在方法返回之前finally子句的内容将会被执行。如果finally子句当中也包含一个return 语句，那么这个return语句所返回的值，将会覆盖原先return的值。

1

public int f(int n) {
2

try {
3

return n*n;
4

} finally {
5

if(n==2)
6

return 2;
7

}
8

}

在这里如果调用i=f(2);那么i的值将会是2而不是期望的2*2=4

最后最重要的一点，关于一个方法是捕获一个异常还是抛出给调用他的方法
有一点规则
早抛出，晚捕获，尽量把异常抛出给调用它的函数

posted @ 2008-02-26 14:05 晓宇阅读(516) | 评论 (0) | 编辑收藏

JAVA 的字符编码的问题

首先讲一讲字符集
JDK1.4版本引入了java.nio包加入了Charset类来统一字符集的转换，字符集给出了双字节Unicode码序列与本地字符编码中采用的字节序列之间的映射
字符集的名称不区分大小写，可以用官方名称或者任何一个别名调用静态方法forName来获得Charset

1

Charset charset=Charset.forName("GBK");

Charset的aliases()方法返回一个Set<String>集合，表示该字符集所具有的所有别名

Set<String> aliases=charset.aliases();

查看虚拟机所支持的字符集以及名字可用Charset的静态方法availableCharsets()返回一个SortedMap

1

Map<String,Charset> map=Charset.availableCharsets();
2

for(String setname:map.keySet()) {
3

System.out.println(setname);
4

}

一旦有了字符集，就可以用他在本地字符串和Unicode字节序列之间转换
如下将一个字符串编码为gbk charset.encode(str)函数返回一个ByteBuffer对象

1

String str=new String("晓宇");
2

ByteBuffer buff = charset.encode(str);
3

byte[] bytes=buff.array();

同样，可以将刚才按照GBK方式编码的字节流解码为正确的字符流

1

ByteBuffer by=ByteBuffer.wrap(bytes, 0, bytes.length);
2

CharBuffer cb=charset.decode(by);//返回一个CharBuffer对象，已经将字节数组转化为字符数组
3

System.out.println(" "+cb.toString());

实际上String类中集成了Charset对象的使用，String类有两个用于编码和解码的函数

1

byte[] bytes = str.getBytes("CharsetName"); //将字符串str按照指定名称的Charset进行编码成字节数组
2

String str2=new String(bytes,"CharsetName"); //将字节数组按照指定名称的Charset解码为字符串

在输入输出流中有两个用于将字节流转化为指定编码格式的字符流的类 InputStreamReader/OutputStreamReader
这两个类是读写流和读写器的桥梁用法如下

1

InputStreamReader isr = new InputStreamReader(in, "charsetname");
2

BufferedReader br = new BufferedReader(isr);//加入一个BufferedReader，可以用到该类的readLine()

该用法在我的另外一篇socket备忘的里面体现了，可将网络传过来的utf-8格式编码的字节流正确的解码，以至于显示的时候不会出现乱码

posted @ 2008-02-24 16:44 晓宇阅读(484) | 评论 (0) | 编辑收藏

SOCKET基础学习笔记

摘要: 1package com; 2 3import java.io.BufferedReader; 4import java.io.ByteArrayOutputStream; 5import java.io.Filte... 阅读全文

posted @ 2008-02-22 16:26 晓宇阅读(210) | 评论 (0) | 编辑收藏

字节数组和其他类型的转换

//整数到字节数组的转换
   public byte[] intToByte(int intValue) {
O R-v0OS&{;u0    byte[] result = new byte[4];
e!sm#DN0    result[0] = (byte) ( (intValue & 0xFF000000) >> 24);
    result[1] = (byte) ( (intValue & 0x00FF0000) >> 16);
    result[2] = (byte) ( (intValue & 0x0000FF00) >> 8);
d"TS)ro;L`;A:eI0    result[3] = (byte) ( (intValue & 0x000000FF));
    return result;
}

//字节数组到整数的转换
public static int byteToInt(byte[] b) {
public static int byteToInt(byte[] byteVal) {
2X/cH bIM0      int result = 0;
      for (int i = 0; i < byteVal.length; i++) {
1i {T q a2eT V_.^!Q0        int tmpVal = (byteVal[i] << (8 * (3 - i)));
&?x%pQ4_9T7k0        switch (i) {
          case 0:
            tmpVal = tmpVal & 0xFF000000;
            break;
piL/jY)lkZ?0          case 1:
            tmpVal = tmpVal & 0x00FF0000;
            break;
          case 2:
6j3t1F;iX+K4{0            tmpVal = tmpVal & 0x0000FF00;
            break;
]5b:h MMa!K0          case 3:
)^~_.\A0            tmpVal = tmpVal & 0x000000FF;
t2}8J f7A E~eH2[0            break;
        }
MJ:c.rxWE0X"e"^*@0        result = result | tmpVal;
      }
      return result;
    }

//字符到字节转换
Q N"P6tq.b@~0 public static byte[] charToByte(char ch){
    int temp=(int)ch;
    byte[] b=new byte[2];
    for (int i=b.length-1;i>-1;i--){
'C3^]_V:qz0      b = new Integer(temp&0xff).byteValue();      //将最高位保存在最低位
      temp = temp >> 8;       //向右移8位
    }
    return b;
}

//字节到字符转换
public static char byteToChar(byte[] b){
    int s=0;
ZuYw~ac0    if(b[0]>0)
      s+=b[0];
    else
      s+=256+b[0];
#iCo0kd+|i0    s*=256;
    if(b[1]>0)
      s+=b[1];
+{`z$m a R0    else
      s+=256+b[1];
    char ch=(char)s;
    return ch;
}

//浮点到字节转换
de4w8L-MpD8{\0 public static byte[] doubleToByte(double d){
    byte[] b=new byte[8];
    long l=Double.doubleToLongBits(d);
ar8f3|"@b(g'L0    for(int i=0;i<b.length;i++){
%t4roUTU;zgxI0      b=new Long(l).byteValue();
      l=l>>8;
E$^+\"u!h!Y3^0    }
    return b;
n`(]3K k`0 }

//字节到浮点转换
KwV!^Kt2q#p j0 public static double byteToDouble(byte[] b){
:C.}9o GI9r0 long l;

    l=b[0];
    l&=0xff;
    l|=((long)b[1]<<8);
    l&=0xffff;
u;A&Vs3n.p]*K/B0    l|=((long)b[2]<<16);
)_ ^,F\ n3o0    l&=0xffffff;
` z3~*PIe aMK0    l|=((long)b[3]<<24);
DM!ldb&|U(A*J0    l&=0xffffffffl;
'i)k yh\0    l|=((long)b[4]<<32);
    l&=0xffffffffffl;

    l|=((long)b[5]<<40);
    l&=0xffffffffffffl;
,gJ&o'u N7\Sp0    l|=((long)b[6]<<48);
:m@s7\WCt+B0    l&=0xffffffffffffffl;
,x)T:eO e2d![0    l|=((long)b[7]<<56);
}^MS.x%_7P0    return Double.longBitsToDouble(l);
}

posted @ 2008-02-22 15:06 晓宇阅读(723) | 评论 (0) | 编辑收藏

TREEMAP的排序机制

摘要: 1package com.sf; 2 3import java.text.CollationKey; 4import java.text.Collator; 5import java.util.Comparator; 6import java.util.Map; 7... 阅读全文

posted @ 2008-02-19 15:16 晓宇阅读(2083) | 评论 (1) | 编辑收藏

HASHTABLE的内部实现

public class TestHashtable {

public static void main(String[] args){

Hashtable ht = new Hashtable();

ht.put("sichuan","chengdu"); //改变以下四行代码的顺序，可能会改变输出内容的顺序

ht.put("hunan","changsha");

ht.put("beijing","beijing");

ht.put("anhui","hefei");

Enumeration e = ht.keys();

while(e.hasMoreElements()) {

Object key = e.nextElement();

Object value = ht.get(key);

System.out.println(key + " " + value + " " + key.hashCode() + " " + value.hashCode());

}

为了讲述Hashtable键排序的问题，我们先来看Hashtable的结构图：

从上面的结构图可以看出，Hashtable的实质就是一个数组＋链表。图中的Entry就是链表的实现，Entry的结构中包含了对自己的另一个实例的引用next，用以指向另外一个Entry。而图中标有数字的部分是一个Entry数组，数字就是这个Entry数组的index。那么往Hashtable增加键值对的时候，index会根据键的hashcode、Entry数组的长度共同决定，从而决定键值对存放在Entry数组的哪个位置。从这种意义来说，当键一定，Entry数组的长度一定的情况下，所得到的index肯定是相同的，也就是说插入顺序应该不会影响输出的顺序才对。然而，还有一个重要的因素没有考虑，就是计算index出现相同值的情况。譬如代码中 "sichuan" 和 "anhui"，所得到的index是相同的，在这个时候，Entry的链表功能就发挥作用了：put方法通过Entry的next属性获得对另外一个Entry的引用，然后将后来者放入其中。根据debug得出的结果，"sichuan", "anhui"的index同为2，"hunan"的index为6，"beijing"的index为1，在输出的时候，会以index递减的方式获得键值对。很明显，会改变的输出顺序只有"sichuan"和"anhui"了，也就是说输出只有两种可能："hunan" - "sichuan" - "anhui" - "beijing"和"hunan" - "anhui" - "sichuan" - "beijing"。以下是运行了示例代码之后，Hashtable的结果：

        以上的讨论基于Java展开的，在C#中的Hashtable实现会有所不同，但是我相信两者的设计应该是差不多的。感谢叶漂和quitgame，给了我思考的机会，也让我感到了基础知识的匮乏，看来是要补补基础知识了。

        [补充]：在Hashtable的实现代码中，有一个名为rehash的方法用于扩充Hashtable的容量。很明显，当rehash方法被调用以后，每一个键值对相应的index也会改变，也就等于将键值对重新排序了。这也是往不同容量的Hashtable放入相同的键值对会输出不同的键值对序列的原因。在Java中，触发rehash方法的条件很简单：hahtable中的键值对超过某一阀值。默认情况下，该阀值等于hashtable中Entry数组的长度×0.75

posted @ 2008-02-19 11:07 晓宇阅读(1654) | 评论 (0) | 编辑收藏

JDBC中的连接方式 thin模式和 DataSource方式

一、最常用的是thin模式利用DriverManager得到Connection

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

二、JDBC的另外一种方式是三层结构，就是在应用服务器(tomcat/weblogic)上面建立DataSource

1

Context ctx=new InitiaContext(Hashtable env);
2

DataSource ds=(DataSource)ctx.lookUp("jdbc/OraDB");
3

Connection con=ds.getConnection();

应用中配置如下：未测试，仅转载。

一、配置server.xml

找到配置发布应用程序的地方：<Context path=”” docBase=”d:\_webs”/>

将这个改为：

<!—声明一个数据源,程序通过JNDI找到该数据源。

name指出数据源的名称为jdbc/OraDB,

auth表明连接池管理的权限，

type指出该数据源的类型-->

<!—配置该数据源的属性

name指出数据源的名称

-->

<!—连接数据库的用户名-->

<name>username</name>

<value>chenws</value>

</parameter>

<!—连接数据库的密码-->

<name>password</name>

<value>admin</value>

</parameter>

<!—连接数据库的jdbc驱动程序-->

<name>driverClassName</name>

<value>oracle.jdbc.driver.OracleDriver</value>

</parameter>

<!—连接数据库的url-->

<value>jdbc:oracle:thin:@192.168.39.215:1521:jetchin</value>

</parameter>

</ResourceParams>

</Context>

实际上，配置数据源的属性不止以上那些，还有其他的比如连接时间的限制，连接数量的限制等等。这里我们并没有给出，只是使用了tomcat提供的默认属性罢了。

注意：要让该数据源有效，必须将oracle的classes12.zip改名为classes12.jar，然后拷贝到

tomcat安装目录下的/common/lib中。

二、配置web.xml

到web应用程序目录下的web-inf中，打开web.xml，加入如下的配置：

定义数据源参照：

<resource-ref>

<!—数据源描述，可有可无-->

<description>Oracle Datasource example</description>

<res-ref-name>jdbc/OraDB</res-ref-name>

<!—数据源类型-->

<res-type>javax.sql.DataSource</res-type>

<!—连接池管理权限-->

<res-auth>SERVLET</res-auth>

</resource-ref>

另外在weblogic中进行配置可参考如下文章：

WebLogic Server7.0中Oracle的JDBC Pool/DataSource配置指南

第一步，去oracle下载最新的 oracle JDBC driver。

一共2个文件，ojdbc14.jar和nls_charset12.zip。
第一个文件是驱动程序所在，第二个是支持国际化的包。

接下来，把这两个文件加入 WLS 的 classpath。
修改 Bea\Weblogic\server\bin\startWLS.cmd（或者相应的Unix启动文件，.sh结尾的），

在文件开头加入 PRE_CLASSPATH=C:\ojdbc14.jar;C:\nls_charset12.zip。注意文件的路径。

最后可以考虑把Bea\Weblogic\server\lib\classes12.zip删除，我不保证正确性，只是怕有兼容性问题。

最后，启动weblogic server，进入console，在Connection Pool里边，填入一下资料。

General栏目：

Name：MyOracle_CP

URL：jdbc:oracle:thin:@server:port:sid （自己按照情况修改！）
比如：jdbc:oracle:thin:@192.168.0.2:1521:Crystal

DriverName：oracle.jdbc.driver.OracleDriver

Properties
user=SYS （这里是用户，最好不要用SYS，SYSTEM等系统用户）

ACL Name：（空）

password：用户密码

如图：

Connection栏目：

CapacityIncrement = 50
MaxCapacity = 100
Capacity Increment: 5
Login Delay Seconds: 0 seconds
Refresh Period: 10 minutes
Supports Local Transaction 不要打勾
Allow Shrinking 打勾
Shrink Period: 15 minutes
Prepared Statement Cache Size: 5

如图：

Test栏目：

TestTableName：SCOTT.EMP （这里需要改动，适应你自己的表，wls用来做连接测试用的）
TestConnectionsOnReleasetrue 打勾
TestConnectionsOnReservetrue 打勾

最后，点击Apply，然后去Targets，选中你的server，点右箭头，使你的server进入Chosen栏目，最后Apply。（如图）

查看dos窗口，是否有错误，如果没有则继续，如果有的话，自己查看填写的内容。

至此，Connection Pool已经配置完毕。

接下来，该配置(TX)DataSource了。

从昨天的panel里边，单击DataSources/TX DataSources，进入配置界面。

1。单击Configure a new JDBC Tx Data Source..配置新的datasource

2。填入以下数据：
Name: MyDataSource （自己随便起的）
JNDI: jdbc/OracleDS （这里就是你lookup的时候填入的名字，自己想吧。
Pool Name: MyOracle_CP （一定要对应你的Connection Pool的 Name）

把后边两项打上勾。

第一个是模拟2阶提交模式，如果数据库driver本身不支持的话。（就是XA标准，分布式提交）

第二个是行预读。如图：

点击Create，然后去Targets里边，把你的 server放入chosen，点击apply。。

配置完成。。。

最后检查你的DataSource是否已经成功部属：

进入你的server的JNDI Tree，很容易就可以看到的。：）。如图：

posted @ 2008-02-19 10:22 晓宇阅读(3674) | 评论 (0) | 编辑收藏

JDBC中的批处理

JDBC中有两个批处理函数 addBatch(String) 和 executeBatch();

有两种方法可以进行批处理第一种是用Statement 另外一种是PreparedStatement

一、使用Statement

1

Statement sm=con.createStatement();
2

String sql="insert into errbills values()";
3

sm.addBatch(sql);
4

sql="delete from errbills where bno='124'";
5

sm.addBatch(sql);
6

sm.executeBatch();

二、使用PreparedStatement

1

String sql="delete from errblls where bno=?";
2

PreparedStatement ps=con.prepareStatement(sql);
3

for(int i=0;i<10;i++) {
4

ps.setString(i);
5

ps.addBatch();
6

}
7

ps.executeBatch();
8

注意使用Statement和PreparedStatement的区别 Statement的addBatch(String s)是带参数的(所要执行的SQL语句) 而PreparedStatement是不带参数的

在JDBC中使用批处理可以提高执行速度，因为我们不需要维护多条语句，所有的操作都是在一条语句里面完成，这样数据库服务器不必要为每条语句都分配和维护资源(指针等)，可以减轻数据库服务器的压力

posted @ 2008-02-19 09:50 晓宇阅读(514) | 评论 (1) | 编辑收藏

导航

留言簿(2)

随笔分类

随笔档案

阅读排行榜

评论排行榜

常用链接

统计

最新评论

数据库的事务 JDBC

字符串池

JAVA中的异常处理

JAVA 的字符编码的问题

SOCKET基础学习笔记

字节数组和其他类型的转换

TREEMAP的排序机制

HASHTABLE的内部实现

JDBC中的连接方式 thin模式和 DataSource方式

JDBC中的批处理