BlogJava-梦想有多远我们就能走多远......-随笔分类-Java

Java测试规范

心随我动 — Sat, 19 Aug 2006 00:32:00 GMT

1 、未使用(死)代码

。存在未使用的私有静态字段

。带有不必要的修饰符的借口

。目前没有使用的私有字段

。未使用的变量

。无需的参数

。显示导入的java.lang包

。目前没有使用的私有方法

2 、编码标准

。一行语句中声明了多种类型的变量

。物理位置不在一起的同名小组成员。

。从一个抽象类库中的构造器调用的抽象方法

。包括大量case语句的switch语句

。除了第一个之外的main（）函数

。直接弹出的Exception类库

。catch语句中Exception或者RuntimeException

。直接弹出的Error

。没有在接口中定义的常量

。长整数应该使用‘L’代替小写字母‘l’

3 、初始化

。没有显式初始化的静态字段

。没有显式初始化每个数据成员的构造器

。编译代码中可能的漏洞

。存在错误的case的switch语句

。程序体为空的for语句

。程序体为空的if语句

。需要重载的方法

。应该使用等号代替==

。程序体为空的else语句

。强制转换为较低精度的主要数据类型

。在switch子句中的文本标识

。if条件中的变量赋值

。缺少default子句中的switch语句

。存在嵌套赋值

。比较浮点数

。循环控制变量在循环内部被突然改变

。方法参数名称和类成员名称冲突

。可能与字符串串联混淆的+操作符

4 、面向对象编程

。继承的静态成员函数被隐藏

。可能嵌套过深的类库

。继承的实例变量被隐藏

。被重载private方法

。内部的类库不可见或外部的类库不相关

。某个实列变量为public或在package中

。没有在一开始列出的public或package方法和数据

。不是abstract或实现比较通常的接口

。命名惯例

。一个类名称不符合标准

。一个接口名称不符合标准

。一个列外名称不符合标准

。一种方法名称不符合标准

。一个静态字段名称不符合标准

。一个静态方法名称不符合标准

。一种方法参数名称不符合标准

。一个实列字段不符合标准

。一个本地变量名称不符合标准

。一个最终静态字段中包含小写字母

。一个返回布尔值的方法使用"is"或者"has"前缀

。一个接口成员字段包含小写字母

。使用一个非惯例的变量名称

5 、优化

。一个finally模块中存在未关闭的流

。使用一个for循环代替System.arrarycopy()拷贝数组

。存在没有必要的instanceof

。存在没有必要的强制变量类型转换

。可以使用一个缩写的赋值语句

。常量字符串使用StringBuffer代替String

。循环条件过于复杂

。取反操作符使用过于频繁

6 、回收

。finalize()没有调用super.finally()

。最终方法的最后模块没有调用super.finalize()

。finalize()被显示调用

。在将主要类型转换成String时，使用了不必要的临时变量

。在应该使用long[]的位置使用了Date[]

7 、javadoc注释

。误用了Javadoc标签

。Javadoc和普通注释之间区分不明显

8 、线程

。使用synchronized，降低了性能

9 、全局静态分析

。过度访问package-private字段

。过度访问package-private方法

。过度访问package-private类库

。过度访问public/protected字段

。过度访问public/protected方法

。过度访问public/protected类库

。没有使用全局package-private字段

。没有使用全局package-private方法

。没有使用全局package-private类库

。没有使用全局public/protected字段

。没有使用全局public/protected方法

。没有使用全局public/protected类库

10 、企业版java beans(EJB)

。bean类库没有定义成为public

。bean类库被错误定义成为abstract

。bean类库被错误定义成为final

。bean类库实现一个ejbCreate()方法

。bean类库错误定义finalize方法

。ejbCreate()访问控制符没有定义成为public

。SessionBean中的ejbCreate()没有返回void

。定位方法的修饰符没有定义成为public

。定位方法的返回类型不是一个主键，也不是主键的类集

。ejbPostCreate()有一个非public的访问控制修饰符

。ejbPostCreate()没有返回类型void

11 、杂项

。成员字段隐藏在成员方法中

。循环记数器无法递增

。for循环中没有包含布尔条件

。存在的clone()方法没有调用super.clone()

。for语句缺少代码模块

。方法参数得到赋值

心随我动 2006-08-19 08:32 发表评论

Java服务器端编程安全必读

心随我动 — Thu, 17 Aug 2006 16:19:00 GMT

摘要: 一、概述　　　　　　编写安全的 Internet 应用并不是一件轻而易举的事情：只要看看各个专业公告板就可以找到连续不断的安全漏洞报告。你如何保证自己的 Internet 应用不象其他人的应用那样满是漏洞？你如何保证自己的名字不会出现在令人难堪的重大安全事... 阅读全文

心随我动 2006-08-18 00:19 发表评论

Java中的常用方法

心随我动 — Mon, 14 Aug 2006 04:40:00 GMT

摘要: 第一章字符串 1 、获取字符串的长度： length()2 、判断字符串的前缀或后缀与已知字符串是否相同前缀 startsWith(String s... 阅读全文

心随我动 2006-08-14 12:40 发表评论

一个理解wait()与notify()的例子

心随我动 — Sun, 06 Aug 2006 14:30:00 GMT

下面是我原来在CSDN论坛上看到的一个贴子，涉及到同步,wait(),notify()等概念的理解，我试着根据原来的一些回复和Think in Java上的相关概念将wait()和notify()这两个方法剖析了一下，欢迎指教.

　　问题如下：

// 分析这段程序，并解释一下，着重讲讲synchronized、wait(),notify 谢谢！
class ThreadA
{
public static void main(String[] args)
{
    ThreadB b=new ThreadB();
    b.start();
    System.out.println("b is start....");
    synchronized(b)//括号里的b是什么意思,起什么作用?
    {
      try
      {
System.out.println("Waiting for b to complete...");
b.wait();//这一句是什么意思，究竟让谁wait?
        System.out.println("Completed.Now back to main thread");
      }catch (InterruptedException e){}
    }
    System.out.println("Total is :"+b.total);
   }
}

class ThreadB extends Thread
{
int total;
public void run()
{
    synchronized(this)
    {
      System.out.println("ThreadB is running..");
      for (int i=0;i<100;i++ )
      {
        total +=i;
        System.out.println("total is "+total);
      }
      notify();
    }
}
}

　　要分析这个程序,首先要理解notify()和wait(),为什么在前几天纪录线程的时候没有纪录这两个方法呢,因为这两个方法本来就不属于Thread类,而是属于最底层的object基础类的,也就是说不光是Thread，每个对象都有notify和wait的功能，为什么？因为他们是用来操纵锁的,而每个对象都有锁,锁是每个对象的基础,既然锁是基础的,那么操纵锁的方法当然也是最基础了.

　　再往下看之前呢,首先最好复习一下Think in Java的14.3.1中第3部分内容：等待和通知,也就是wait()和notify了.

　　按照Think in Java中的解释:"wait()允许我们将线程置入“睡眠”状态，同时又“积极”地等待条件发生改变.而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒，并检查条件是否有变."

　　我们来解释一下这句话.
　　"wait()允许我们将线程置入“睡眠”状态",也就是说,wait也是让当前线程阻塞的,这一点和sleep或者suspend是相同的.那和sleep,suspend有什么区别呢?

　　区别在于"(wait)同时又“积极”地等待条件发生改变",这一点很关键,sleep和suspend无法做到.因为我们有时候需要通过同步（synchronized）的帮助来防止线程之间的冲突，而一旦使用同步,就要锁定对象，也就是获取对象锁,其它要使用该对象锁的线程都只能排队等着,等到同步方法或者同步块里的程序全部运行完才有机会.在同步方法和同步块中,无论sleep()还是suspend()都不可能自己被调用的时候解除锁定,他们都霸占着正在使用的对象锁不放.
　　而wait却可以,它可以让同步方法或者同步块暂时放弃对象锁,而将它暂时让给其它需要对象锁的人(这里应该是程序块,或线程)用,这意味着可在执行wait()期间调用线程对象中的其他同步方法!在其它情况下(sleep啊,suspend啊),这是不可能的.
　　但是注意我前面说的,只是暂时放弃对象锁,暂时给其它线程使用,我wait所在的线程还是要把这个对象锁收回来的呀.wait什么?就是wait别人用完了还给我啊！
　　好,那怎么把对象锁收回来呢?
　　第一种方法,限定借出去的时间.在wait()中设置参数,比如wait(1000),以毫秒为单位,就表明我只借出去1秒中,一秒钟之后,我自动收回.
　　第二种方法,让借出去的人通知我,他用完了,要还给我了.这时,我马上就收回来.哎,假如我设了1小时之后收回,别人只用了半小时就完了,那怎么办呢?靠!当然用完了就收回了,还管我设的是多长时间啊.

　　那么别人怎么通知我呢?相信大家都可以想到了,notify(),这就是最后一句话"而且只有在一个notify()或notifyAll()发生变化的时候，线程才会被唤醒"的意思了.
　　因此,我们可将一个wait()和notify()置入任何同步方法或同步块内部，无论在那个类里是否准备进行涉及线程的处理。而且实际上,我们也只能在同步方法或者同步块里面调用wait()和notify().

　　这个时候我们来解释上面的程序,简直是易如反掌了.

　　synchronized(b){...}；的意思是定义一个同步块,使用b作为资源锁。b.wait();的意思是临时释放锁，并阻塞当前线程,好让其他使用同一把锁的线程有机会执行,在这里要用同一把锁的就是b线程本身.这个线程在执行到一定地方后用notify()通知wait的线程,锁已经用完,待notify()所在的同步块运行完之后,wait所在的线程就可以继续执行.

心随我动 2006-08-06 22:30 发表评论

关于Java栈与堆的思考

心随我动 — Thu, 03 Aug 2006 14:04:00 GMT

    1. 栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
　　2. 栈的优势是，存取速度比堆要快，仅次于直接位于CPU中的寄存器。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。另外，栈数据可以共享，详见第3点。堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。
　　3. Java中的数据类型有两种。
　　一种是基本类型(primitive types), 共有8种，即int, short, long, byte, float, double, boolean, char(注意，并没有string的基本类型)。这种类型的定义是通过诸如int a = 3; long b = 255L;的形式来定义的，称为自动变量。值得注意的是，自动变量存的是字面值，不是类的实例，即不是类的引用，这里并没有类的存在。如int a = 3; 这里的a是一个指向int类型的引用，指向3这个字面值。这些字面值的数据，由于大小可知，生存期可知(这些字面值固定定义在某个程序块里面，程序块退出后，字段值就消失了)，出于追求速度的原因，就存在于栈中。
　　另外，栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义
　　int a = 3;
　　int b = 3；
　　编译器先处理int a = 3；首先它会在栈中创建一个变量为a的引用，然后查找有没有字面值为3的地址，没找到，就开辟一个存放3这个字面值的地址，然后将a指向3的地址。接着处理int b = 3；在创建完b的引用变量后，由于在栈中已经有3这个字面值，便将b直接指向3的地址。这样，就出现了a与b同时均指向3的情况。
　　特别注意的是，这种字面值的引用与类对象的引用不同。假定两个类对象的引用同时指向一个对象，如果一个对象引用变量修改了这个对象的内部状态，那么另一个对象引用变量也即刻反映出这个变化。相反，通过字面值的引用来修改其值，不会导致另一个指向此字面值的引用的值也跟着改变的情况。如上例，我们定义完a与 b的值后，再令a=4；那么，b不会等于4，还是等于3。在编译器内部，遇到a=4；时，它就会重新搜索栈中是否有4的字面值，如果没有，重新开辟地址存放4的值；如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。
　　另一种是包装类数据，如Integer, String, Double等将相应的基本数据类型包装起来的类。这些类数据全部存在于堆中，Java用new()语句来显示地告诉编译器，在运行时才根据需要动态创建，因此比较灵活，但缺点是要占用更多的时间。
　　4. String是一个特殊的包装类数据。即可以用String str = new String("abc");的形式来创建，也可以用String str = "abc"；的形式来创建(作为对比，在JDK 5.0之前，你从未见过Integer i = 3;的表达式，因为类与字面值是不能通用的，除了String。而在JDK 5.0中，这种表达式是可以的！因为编译器在后台进行Integer i = new Integer(3)的转换)。前者是规范的类的创建过程，即在Java中，一切都是对象，而对象是类的实例，全部通过new()的形式来创建。Java 中的有些类，如DateFormat类，可以通过该类的getInstance()方法来返回一个新创建的类，似乎违反了此原则。其实不然。该类运用了单例模式来返回类的实例，只不过这个实例是在该类内部通过new()来创建的，而getInstance()向外部隐藏了此细节。那为什么在String str = "abc"；中，并没有通过new()来创建实例，是不是违反了上述原则？其实没有。
　　5. 关于String str = "abc"的内部工作。Java内部将此语句转化为以下几个步骤：
　　(1)先定义一个名为str的对String类的对象引用变量：String str；
　　(2)在栈中查找有没有存放值为"abc"的地址，如果没有，则开辟一个存放字面值为"abc"的地址，接着创建一个新的String类的对象o，并将o 的字符串值指向这个地址，而且在栈中这个地址旁边记下这个引用的对象o。如果已经有了值为"abc"的地址，则查找对象o，并返回o的地址。
　　(3)将str指向对象o的地址。
　　值得注意的是，一般String类中字符串值都是直接存值的。但像String str = "abc"；这种场合下，其字符串值却是保存了一个指向存在栈中数据的引用！
　　为了更好地说明这个问题，我们可以通过以下的几个代码进行验证。
　　String str1 = "abc";
　　String str2 = "abc";
　　System.out.println(str1==str2);  //true
　　注意，我们这里并不用str1.equals(str2)；的方式，因为这将比较两个字符串的值是否相等。==号，根据JDK的说明，只有在两个引用都指向了同一个对象时才返回真值。而我们在这里要看的是，str1与str2是否都指向了同一个对象。
　　结果说明，JVM创建了两个引用str1和str2，但只创建了一个对象，而且两个引用都指向了这个对象。
　　我们再来更进一步，将以上代码改成：
　　String str1 = "abc";
　　String str2 = "abc";
　　str1 = "bcd";
　　System.out.println(str1 + "," + str2);  //bcd, abc
　　System.out.println(str1==str2);  //false
　　这就是说，赋值的变化导致了类对象引用的变化，str1指向了另外一个新对象！而str2仍旧指向原来的对象。上例中，当我们将str1的值改为"bcd"时，JVM发现在栈中没有存放该值的地址，便开辟了这个地址，并创建了一个新的对象，其字符串的值指向这个地址。
　　事实上，String类被设计成为不可改变(immutable)的类。如果你要改变其值，可以，但JVM在运行时根据新值悄悄创建了一个新对象，然后将这个对象的地址返回给原来类的引用。这个创建过程虽说是完全自动进行的，但它毕竟占用了更多的时间。在对时间要求比较敏感的环境中，会带有一定的不良影响。
　　再修改原来代码：
　　String str1 = "abc";
　　String str2 = "abc";
　　str1 = "bcd";
　　String str3 = str1;
　　System.out.println(str3);  //bcd
　　String str4 = "bcd";
　　System.out.println(str1 == str4);  //true
　　str3 这个对象的引用直接指向str1所指向的对象(注意，str3并没有创建新对象)。当str1改完其值后，再创建一个String的引用str4，并指向因str1修改值而创建的新的对象。可以发现，这回str4也没有创建新的对象，从而再次实现栈中数据的共享。
　　我们再接着看以下的代码。
　　String str1 = new String("abc");
　　String str2 = "abc";
　　System.out.println(str1==str2);  //false
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
　　String str1 = "abc";
　　String str2 = new String("abc");
　　System.out.println(str1==str2);  //false
　　创建了两个引用。创建了两个对象。两个引用分别指向不同的两个对象。
　　以上两段代码说明，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。
　　6. 数据类型包装类的值不可修改。不仅仅是String类的值不可修改，所有的数据类型包装类都不能更改其内部的值。
　　7. 结论与建议：
　　(1)我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，我们创建了String类的对象str。担心陷阱！对象可能并没有被创建！唯一可以肯定的是，指向 String类的引用被创建了。至于这个引用到底是否指向了一个新的对象，必须根据上下文来考虑，除非你通过new()方法来显要地创建一个新的对象。因此，更为准确的说法是，我们创建了一个指向String类的对象的引用变量str，这个对象引用变量指向了某个值为"abc"的String类。清醒地认识到这一点对排除程序中难以发现的bug是很有帮助的。
　　(2)使用String str = "abc"；的方式，可以在一定程度上提高程序的运行速度，因为JVM会自动根据栈中数据的实际情况来决定是否有必要创建新对象。而对于String str = new String("abc")；的代码，则一概在堆中创建新对象，而不管其字符串值是否相等，是否有必要创建新对象，从而加重了程序的负担。这个思想应该是享元模式的思想，但JDK的内部在这里实现是否应用了这个模式，不得而知。
　　(3)当比较包装类里面的数值是否相等时，用equals()方法；当测试两个包装类的引用是否指向同一个对象时，用==。
　　(4)由于String类的immutable性质，当String变量需要经常变换其值时，应该考虑使用StringBuffer类，以提高程序效率。

心随我动 2006-08-03 22:04 发表评论

Java是传值还是传引用

心随我动 — Wed, 02 Aug 2006 13:09:00 GMT

摘要: 1. 简单类型是按值传递的　　Java 方法的参数是简单类型的时候，是按值传递的 (pass by value)。这一点我们可以通过一个简单的例子来说明： /* 例 1 */ ... 阅读全文

心随我动 2006-08-02 21:09 发表评论

JDBC优化数据库连接-IBM

心随我动 — Tue, 25 Jul 2006 15:53:00 GMT

企业数据库连接性的恰当构建是非常重要的，并且在为有限连接设备配置（Connection Limited Device Configuration（CLDC））构建应用程序和编写特定于 MIDP（移动接口）的接口之间，哪一种是最佳选择取决于 J2ME 和 Java 技术。

　　方式
　　介绍在把企业数据桥接到无线移动设备时建立 JDBC 连接的一条简单原则，这可以帮助您使解决方案具有更好的可扩展性和更高效的性能。

　　连接池
　　任何应用程序都必须先访问活动的数据库连接，然后才能访问数据库。数据库连接是一个很占资源且 I/O 开销很大的操作，并且如果每次想使用数据库连接时都必须创建它，那么它将会成为您的性能瓶颈。

　　例如，如果您使用 Java servlet（Java servlet 通过 init() 方法创建并在其生命周期结束时被销毁（通过 destroy() 方法））的方式，您是虽然避免了每次 servlet 被实例化时重新建立连接。这样一种方式会明显地降低应用程序的性能。完成相同功能的更好的途径是使用“连接池（Connection Pool）”，您可以在连接池中初始化多个连接（并且参数可以从 XML 配置文件中读取）。

　　连接本身由一组集合对象和一个在整个请求过程中使连接保持打开的用户请求组成。创建连接池的关键是在数据库访问代码中使用如下一些块：try{}.. catch{}... finally{}..。然后您使用 close() 方法来确认连接确实被返回到了连接池而不是被彻底关闭了。在“finally{}”块中指定 close() 方法使得执行过程中发生的异常会被捕获到，并且该语句仍被执行 — 连接返回到连接池，这就防止了应用程序中“连接泄漏（connection leak）”的发生。

　　以下是构建一个 JDBC 连接的示例：

Connection con = null;
try { ds = (DataSource)myContext.lookup("");
pooledCon = ds.getConnection("scott", "tiger");
// Processing Code goes here
} catch (Exception ignored) {
// catch JNDI or JDBC exceptions here
} finally {
if(pooledCon != null)
pooledCon.close();
}

　　使用 PreparedStatement
　　人们认为 PreparedStatement 对象的效率比多个 Statement 对象更高，尤其是如果您必须多次执行同一条语句而差别仅在于参数不同时更是如此。PreparedStatement 允许您将 SQL 语句“编译”一次（尽管这种编译第一次要消耗较多的时间），然后将它保存在高速缓存中，从而实现有效的重用。同时它也提供了可读性更好的代码。

　　另一个额外的优势是由驱动程序完成的对用户传递给语句的字符串的自动转义。举例来说，这意味着当您试图将字符串“D'Marco”插入到一个基于字符的数据域（它可能是 VARCHAR, VARCHAR2, CHAR 等）中时，SQL 语句不会在遇到第一个撇号时就产生灾难性的失败。

　　使用 PreparedStatement 对象时的另一个良好习惯是调用对象自身的 close() 方法来“关闭对象”，这个方法将被用来运行 SQL 语句。这会关闭任何与正在执行的 SQL 语句相关联的游标，这样就能防止打开的游标把数据库弄得十分凌乱。

　　以下是一个创建 PreparedSatement 的示例：

PreparedStatement sqlstmt = dbCon.prepareStatement("select *
from table1 where field_1=?");
sqlstmt.setInt(1, 12);
ResultSet rs = sqlstmt.executeQuery();
// close the resultset statement to avoid hanging cursors in database
sqlstmt.close();
// processing of new statement
sqlstmt = dbCon.prepareStatement("select * from table2 where field_2 = ?");
// repeat creating the result set

　　恰当地利用事务
　　在更新动态数据库表和数据时常常会遗忘的一个方面，就是在向超过一个表示一个逻辑事务的表更新或插入数据时，这个事务应该反映到所有的表中，或者在碰到事务失败时，通过“回滚”该事务而在每一个表中都没有反映。

　　一些核心的 JDBC 包支持了四种事务隔离模式（transaction isolation mode），这些模式允许程序指定它们想事务表现出怎样的行为。大多数程序都至少支持两种模式：“读取提交（read committed）”（缺省值）和“可序列化的（serializable）”。当不可重复读取应该允许在多个查询之间由一个事务作出的修改对于另一个事务可见时，请使用“读取提交”；要使由另一个事务作出的修改在一个查询运行时成为可见的，请使用幻象读取（phantom read）。当您需要一个跨多个操作前后完全一致的数据库视图时，就应该使用更为严格的“可序列化的”设置。把连接的自动提交设置为“假”（autocommit = "false"），记住这一点是很有用的。

　　以下是构建一个连接并设置其各个属性参数的示例：

Connection con = null;
try {
dtsr = (DataSource ");
pConn = dtsr.getConnection("", "");
pConn.setAutoCommit(false); // transaction are not committed uponm execution

pConn.setTransactionIsolation(
Connection.TRANSACTION_SERIALIZABLE);
// pConn is pooled connection
pConn.commit();
} catch (Exception ignored) {
try { pConnn.rollback(); } catch (SQLException esgl) {}
} finally {
if(pConn != null) {
pConn.setAutoCommit(true); //reset autocommit
pConn.close();
}
}

　　您也可以利用一个可选的 JDBC 包 — JTA（Java Transaction API），它允许容易地和完全独立的事务服务器进行集成。

心随我动 2006-07-25 23:53 发表评论