设计模式：是指在软件开发中，经过验证的，用于解决在特定环境下，重复出现的、特定问题的解决方案。

     在学习设计模式之前，我们要回顾一下接口的知识。java应用开发中，要“面向接口编程”。接口的核心思想就是“封装隔离”，使用接口的好处，由于外部调用和内部实现被接口隔离开了，那么只要接口不变，内部实现的变化不会影响到尾部应用，从而使得系统更灵活，具有更好的扩展性和可维护性，因此我们说，接口是系统可插拔性的保证。

     接口和抽象类的选择原则：1.优先选用接口；2.在既要定义子类的行为，又要为子类提供公共的功能时应选择抽象类。

简单工厂

定义：提供一个创建对象实例的功能，而无须关心其具体实现。被创建实例的类型可以是接口、抽象类，也可以是具体的实现。示例代码如下

定义接口：

对接口的实现：

Java代码  

1. package com.wxl.simplefactory;  
2. /** 
3.  * 对接口api的实现  
4.  */  
5. public class ImplB implements Api {  
6.   
7.     @Override  
8.     public void operation(String s) {  
9.         System.out.println("ImplB s == "+s);  
10.     }  
11. }  

工厂类：

说明：使用简单工厂的时候，通常不用创建简单工厂类的类实例，没有创建实例的必要。因此可以把简单工厂类实现成一个工具类，直接使用静态方法就可以了，也就是说简单工厂的方法通常都是静态的，所以也被称为静态工厂。如果要防止客户端无谓的创造简单工厂实例，还可以把简单工厂的构造方法私有化了。

     虽然从理论上讲，简单工厂什么都能造，但对于简单工厂可创建对象的范围，通常不要太大，建议控制在一个独立的组件级别或者一个模块级别，也就是一个组件或模块一个简单工厂。否则这个简单工厂类会职责不明，有点大杂烩的感觉。

     由于是从客户端在调用工厂的时候，传入选择的参数，这就说明客户端必须知道每个参数的含义，也需要理解每个参数对应的功能处理。这就要求必须在一定程度上，向客户暴露一定的内部实现细节。

     另外，我们可以把要创建的类的实现写到配置文件里，在工厂里利用反射机制(Class.forName(...).newInstance())选择要创建的类。

 客户端：

 运行结果：

 下面我们来看看工厂方法模式。

工厂方法模式

      首先我们回顾一下有关框架的知识简单点说：框架就是能完成一定功能的半成品软件。
      就其本质而言，框架是一个软件，而且是一个半成品的软件。所谓半成品，就是还不能完全实现用户需要的功能，框架只是实现用户需要的功能的一部分，还需要进一步加工，才能成为一个满足用户需要的、完整的软件。因此框架级的软件，它的主要客户是开发人员，而不是最终用户。

      如果没有框架，那么客户要求的所有功能都由开发人员自己来开发，没问题，同样可以实现用户要求的功能，只是开发人员的工作多点。
      如果有了框架，框架本身完成了一定的功能，那么框架已有的功能，开发人员就可以不做了，开发人员只需要完成框架没有的功能，最后同样是完成客户要求的所有功能，但是开发人员的工作就减少了。
      也就是说，基于框架来开发，软件要完成的功能并没有变化，还是客户要求的所有功能，也就是“事情还是那些事情”的意思。但是有了框架过后，框架完成了一部分功能，然后开发人员再完成一部分功能，最后由框架和开发人员合起来完成了整个软件的功能，也就是看这些功能“由谁做”的问题。基于框架开发，可以不去做框架所做的事情，但是应该明白框架在干什么，以及框架是如何实现相应功能的。

      接下来我们用工厂方法模式来做一个导出数据的小小框架。

示例代码：

Java代码  

1. <span style="font-size: x-small;"><p> 对接口的实现：</p>  
2. <pre class="java" name="code">package com.wxl.factorymethod;  
3. /** 
4.  * 导出成文本格式 
5.  */  
6. public class ExportTxtFile implements ExportFileApi {  
7.     @Override  
8.     public boolean export(String data) {  
9.         System.out.println("导出数据"+data+"到文本文件");  
10.         return true;  
11.     }  
12. }</pre>  
13. </span>  

 抽象类：

成功安装cvs后，用户默认为系统用户

在dos窗口下设置

set cvsroot=:pserver:主机名@115.24.161.33:/cvs仓库（主机名如：Administrator，cvs仓库如cvs_database）

cvs login（提示输入密码，就是电脑的开机密码）

cvs passwd -r 主机名 -a test（添加test用户）

添加用户后登陆test用户不成功，用IDE（eclipse）也无法正常连接test账户，但是在操作系统中创建test用户后eclipse就能成功连接test用户，有没有直接在cvs中配置的方法而不用在系统中创建新用户就能使用cvs的用户管理功能？

其他常用命令

   cvs lsacl 查看权限
   cvs ls     查看可访问的仓库
   cvs passwd -r administrator -a mini 添加用户mini并绑定到administrator mini是用户,随后会提示输入此用户密码

   添加新用户[aaa]:cvs passwd -a aaa 回车,设置密码,OK,完成.
   绑定[aaa]到[Administrator]: cvs passwd -r administrator aaa 回车,设置密码,OK,完成
   两次输入的密码可以不同,但以第二次输入的密码为最终密码.
   删除用户[aaa]: cvs passwd -x aaa 回车,OK,完成

2. 安装准备

将下载的压缩包解压缩并放置到你想放置的位置，在目录下建立一个叫做DB的文件夹和一个log.txt的文件

DB文件夹用于存储数据库

log.txt用于记录MongoDB的日志

3. 安装MongoDB

这里讲的方法是将MongoDB安装为Windows的服务的方式，打开windows的命令行（注意：请使用个管理员权限启动命令行）并移动到你MongoDB目录下的Bin文件夹，我这里演示的路径是d:\DEV\ENV\mongodb

输入下列命令可将MongoDB注册为Windows服务：

mongod.exe --install --logpath=D:\DEV\ENV\mongodb\log.txt --dbpath=D:\DEV\ENV\mongodb\DB

--install 参数是设定安装为服务器

--logpath 参数是设定日志文件的路径,log.txt是在上一步建立好的文件

--dbpath 参数是设定数据库文件的存放路径，DB文件夹在上一步骤已经创建好

net start mongodb

即可启动mongodb服务

启动后，再到命令行输入

mongo

看到MongoDB已经启动成功，安装就完成了，很简单。

依据List内部对象的某字段进行排序的方法

List内部对象类IntString，test为测试用例类

用Collections.sort方法，实现对List的排序，需要重写Comparator方法

代码如下：

List里存放的实体

Java代码  

1. package org.iti.wxl.listobjectsort;  
2.   
3. public class IntString {  
4.       
5.     private Integer no;  
6.       
7.     private String str;  
8.   
9.     public Integer getNo() {  
10.         return no;  
11.     }  
12.   
13.     public void setNo(Integer no) {  
14.         this.no = no;  
15.     }  
16.   
17.     public String getStr() {  
18.         return str;  
19.     }  
20.   
21.     public void setStr(String str) {  
22.         this.str = str;  
23.     }  
24.   
25.     @Override  
26.     public String toString() {  
27.         return "IntString [" + (no != null ? "no=" + no + ", " : "")  
28.                 + (str != null ? "str=" + str : "") + "]";  
29.     }  
30.   
31. }  

Java代码  

1. package org.iti.wxl.listobjectsort;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Collections;  
5. import java.util.Comparator;  
6. import java.util.List;  
7.   
8. public class Test {  
9.     public static void main(String[] args) {  
10.         List<IntString> islist = new ArrayList<IntString>();  
11.         IntString is1 = new IntString();  
12.         is1.setNo(1);  
13.         is1.setStr("计091");  
14.   
15.         IntString is3 = new IntString();  
16.         is3.setNo(3);  
17.         is3.setStr("计093");  
18.   
19.         IntString is2 = new IntString();  
20.         is2.setNo(2);  
21.         is2.setStr("计092");  
22.   
23.         islist.add(is1);  
24.         islist.add(is3);  
25.         islist.add(is2);  
26.           
27.         System.out.println(islist);  
28.         Collections.sort(islist, new MyComparator());  
29.         System.out.println(islist);  
30.     }  
31. }  
32.   
33. class MyComparator implements Comparator<Object> {  
34.     @Override  
35.     public int compare(Object o1, Object o2) {  
36.         IntString iso1 = (IntString)o1;  
37.         IntString iso2 = (IntString)o2;  
38.         String str1 = iso1.getStr();  
39.         String str2 = iso2.getStr();  
40.         return str1.compareTo(str2);  
41. //      Integer no1 = iso1.getNo();  
42. //      Integer no2 = iso2.getNo();  
43. //      if(no1 > no2){  
44. //          return 1;  
45. //      }else if(no1 < no2){  
46. //          return -1;  
47. //      }else{  
48. //          return 0;  
49. //      }  
50.     }  
51.   
52. }  

 如果是String类型的数据比较大小，Comparator方法里用str1.compareTo(str2) 方法，如果是数值比较大小，则用<,=,>比较，>返回1，=返回0，<返回-1。

代理模式 
   代理模式是常用的java设计模式，它的特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。 
   代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类对象的相关方法，来提供特定的服务。 
代理分类 
   静态代理：由程序员创建或特定工具自动生成源代码。在程序运行前，代理类的.class文件就已经存在了。 
   动态代理：在程序运行时，运用反射机制动态创建而成。 
静态代理代码示例

首先创建接口：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2. /** 
3.  * 接口 
4.  */  
5. public interface UserService {  
6.              public void saveUser();  
7.              public void deleteUser();  
8. }</span>  

对接口的实现：（这里就不连接数据库了，只做简单的实例）

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public void saveUser() {  
6.         System.out.println("==user saved!==");  
7.     }  
8.     @Override  
9.     public void deleteUser() {  
10.         System.out.println("==user deleted!==");  
11.     }  
12. }</span>  

代理类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class UserServiceImplProxy implements UserService {  
4.       
5.     private UserServiceImpl userServiceImpl;  
6.     public UserServiceImplProxy(UserServiceImpl userServiceImpl) {  
7.         this.userServiceImpl = userServiceImpl;  
8.     }  
9.   
10.     @Override  
11.     public void saveUser() {  
12.         System.out.println("save begin!");  
13.         userServiceImpl.saveUser();  
14.         System.out.println("save end!");  
15.     }  
16.       
17.     @Override  
18.     public void deleteUser() {  
19.         System.out.println("delete begin!");  
20.         userServiceImpl.deleteUser();  
21.         System.out.println("delete end!");  
22.     }  
23. }</span>  

      代理类同样实现了UserService接口，代理类持有UserServiceImpl，并且重写了UserService接口里的方法，在方法里添加了逻辑。

测试方法：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.staticproxy;  
2.   
3. public class StaticProxy {  
4.     //静态代理方法测试  
5.     public static void main(String[] args) {  
6.         UserServiceImpl userServiceImpl = new UserServiceImpl();  
7.         UserServiceImplProxy userServiceImplProxy =   
8.                 new UserServiceImplProxy(userServiceImpl);  
9.         userServiceImplProxy.saveUser();  
10.         System.out.println("=============");  
11.         userServiceImplProxy.deleteUser();  
12.     }  
13. }  
14. </span>  

把创建的UserServiceImpl交给代理类UserServiceImplProxy，由它的实例执行数据逻辑操作。

方法运行结果如下：

Java代码  

1. <span style="font-size: x-small;">save begin!  
2. ==user saved!==  
3. save end!  
4. =============  
5. delete begin!  
6. ==user deleted!==  
7. delete end!</span>  

  代理类中添加的逻辑在方法运行时被执行了。 

    观察代码可以发现每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理，而且，所有的代理操作除了调用的方法不一样之外，其他的操作都一样，则此时肯定是重复代码。

    解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

 jdk动态代理

    jdk动态代理中包含一个类和一个接口，用到了java的反射机制：

Java代码  

1. <span style="font-size: x-small;">public interface InvocationHandler {   
2. public Object invoke(Object proxy,Method method,Object[] args);  
3. }  
4. </span>  

  参数说明： 
      Object proxy：代理类对象。    
      Method method：要调用的方法   
      Object[] args：方法调用时所需要的参数

    下面用代码说明jdk动态代理的使用

接口类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. public interface UserService {  
4.     public void addUser();  
5.     public void deleteUSer();  
6. }</span>  

对接口的实现：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. public class UserServiceImpl implements UserService {  
4.     @Override  
5.     public void addUser() {  
6.         System.out.println("==add user==");  
7.     }  
8.     @Override  
9.     public void deleteUSer() {  
10.         System.out.println("==delete user==");  
11.     }  
12. }</span>  

代理类：

Java代码  

1. <span style="font-size: x-small;">package org.iti.wxl.dynamicproxy;  
2.   
3. import java.lang.reflect.InvocationHandler;  
4. import java.lang.reflect.Method;  
5. import java.lang.reflect.Proxy;  
6. public class UserServiceImplProxy implements InvocationHandler {  
7.     private Object target;  
8.       
9.     public Object bind(Object target){  
10.         this.target = target;  
11.         return Proxy.newProxyInstance(target.getClass().getClassLoader(),   
12.                 target.getClass().getInterfaces(), this);  
13.     }  
14.     @Override  
15.     public Object invoke(Object proxy, Method method, Object[] args)   
16.             throws Throwable {  
17.         Object result = null;  
18.         System.out.println("user add begin!");  
19.         result = method.invoke(target, args);  
20.         System.out.println("user add end!");  
21.         return result;  
22.     }  
23. 查看(576) 评论(0) 收藏 分享 管理

24. 养成良好的编程习惯，提高代码质量

    2013-03-21 11:35:50

    “不积跬步，无以至千里，不积小流，无以成江海”，程序员如何提高代码质量？我们不仅要知其然，还要知其所以然，我们要从点点滴滴的积累开始的。这篇帖子里记录了编程时的应该注意的一些细节，如有需要后续还会补充，希望通过不断的积累，提高编程质量。

    可序列化接口Serializable

    类实现Serializable接口的目的是为了可持久化，比如网络传输或本地存储，为系统的分布或异步部署提供先决支持条件。若没有序列化，现在我们熟悉的远程调用，对象数据库都不可能存在。

        序列化和反序列化是对应的，以下用代码描述实现了序列化接口Serializable的类在磁盘上的存储过程及反序列化，其在网络上的传输道理也是一样的。

     

    Java代码  

    1. package org.iti.wxl.serializable;  
    2.   
    3. import java.io.Serializable;  
    4.   
    5. /** 
    6.  * 实现了Serializable的实体类 
    7.  * 
    8.  */  
    9. public class Person implements Serializable{  
    10.       
    11.     private static final long serialVersionUID = 6388172609871883630L;  
    12.     private String name;  
    13.   
    14.     public String getName() {  
    15.         return name;  
    16.     }  
    17.   
    18.     public void setName(String name) {  
    19.         this.name = name;  
    20.     }  
    21.   
    22. }  

     为模拟序列化的过程我们创建序列化工具类，如下：

    Java代码  

    1. package org.iti.wxl.serializable;  
    2.   
    3. import java.io.FileInputStream;  
    4. import java.io.FileOutputStream;  
    5. import java.io.IOException;  
    6. import java.io.ObjectInput;  
    7. import java.io.ObjectInputStream;  
    8. import java.io.ObjectOutputStream;  
    9. import java.io.Serializable;  
    10.   
    11. public class SerializableUtils {  
    12.     private static String FILE_NAME="e:/obj.bin";  
    13.     //序列化数据保存到磁盘  
    14.     public static void writeObject(Serializable s){  
    15.         try {  
    16.             ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));  
    17.             oos.writeObject(s);  
    18.             oos.close();  
    19.         } catch (IOException e) {  
    20.             e.printStackTrace();  
    21.         }  
    22.     }  
    23.   
    24.     //反序列化从磁盘读取数据  
    25.     public static Object readObject(){  
    26.         Object obj = null;  
    27.         try {  
    28.             ObjectInput input = new ObjectInputStream(new FileInputStream(FILE_NAME));  
    29.             obj = input.readObject();  
    30.             input.close();  
    31.         } catch (Exception e) {  
    32.             // TODO Auto-generated catch block  
    33.             e.printStackTrace();  
    34.         }  
    35.         return obj;  
    36.     }  
    37. }  

    序列化保存数据到磁盘上

    Java代码  

    1. package org.iti.wxl.serializable;  
    2. public class Producer {  
    3.     public static void main(String[] args) {  
    4.         Person p = new Person();  
    5.         p.setName("小明");  
    6.         // 序列化保存到磁盘上  
    7.         SerializableUtils.writeObject(p);  
    8.     }  
    9. }  

    反序列化，从磁盘读取数据：

    Java代码  

    1. package org.iti.wxl.serializable;  
    2.   
    3. public class Consumer {  
    4.     public static void main(String[] args) {  
    5.         //反序列化  
    6.         Person p =(Person)SerializableUtils.readObject();  
    7.         System.out.println(p.getName());  
    8.     }  
    9. }  

    在反序列化时，若类的版本号serialVersionUID不一致，反序列化时会报一个InvalidClassexception异常，另外在反序列化时，类中的构造函数不会执行。

    奇偶校验用偶校验，避免使用奇校验

    JDK提供的奇偶校验代码模拟如下：

    Java代码  

    1. public class Remainder {  
    2.        //dividend被除数，divisor除数  
    3.     public static int remainder(int dividend, int divisor) {  
    4.         return dividend - dividend/divisor*divisor;  
    5.     }  
    6. }  

     当使用取模运算“%”做奇偶校验时，JDK会依照以上公式进行运算，此时dividend为要校验的数，divisor=2我们发现当被除数为负数且为奇数时，余数为-1，如果我们的奇偶校验公式为i%2 =1 ? "奇数":"偶数";那么当i为负奇数时结果判断会错误，因此我们做奇偶校验时要用偶校验，即：i%2 == 0 ? "偶数":"奇数"；

    java中的引用问题

    java中没有指针的概念，但我们要理解另一个名词“引用”。看下面的例子：

    实体类

     

    Java代码  

    1. public class IntString {  
    2.     private Integer no;  
    3.     private String str;  
    4.     public Integer getNo() {  
    5.         return no;  
    6.     }  
    7.     public void setNo(Integer no) {  
    8.         this.no = no;  
    9.     }  
    10.     public String getStr() {  
    11.         return str;  
    12.     }  
    13.     public void setStr(String str) {  
    14.         this.str = str;  
    15.     }  
    16.     @Override  
    17.     public String toString() {  
    18.         return "IntString [" + (no != null ? "no=" + no + ", " : "")  
    19.                 + (str != null ? "str=" + str : "") + "]";  
    20.     }  
    21. }  

    测试类：

    Java代码  查看(315) 评论(0) 收藏 分享 管理

25. 网站负载测试工具

    2013-03-21 11:35:00

    通常来说，负载测试可以采用手动和自动两种方式。手动测试会遇到很多问题，如无法模拟太多用户、测试者很难精确记录相应时间、连续测试和重复测试的工作量特别大等。因此对于负载测试，手动方式通常用于初级的负载测试。目前，绝大多数的负载测试都是通过自动化工具完成的。  
    
    
        负载测试的相关问题 
    
        从网站内容上看，每个网站都有自己的客户群和工作负载，不同网站其软硬件结构差异也很大。下图是一个网站的基本框架。 
    
        这种复杂性给负载测试带来了很大的挑战。一方面，由于一些设备的原因，有时我们不能直接进行负载测试，必须绕过某些设备，造成很大麻烦。另一方面，由于整个体系结构的复杂，也给寻找问题带来了一定的困难。例如防火墙常常阻止负载测试的进行，因此通常需要对防火墙进行调整，让它暂时支持负载测试; 有时服务器的应用程序采用加密方式与客户端进行交互，在这种情况下，还需要更改服务器应用程序。因此，负载测试人员需要对整个网络架构和应用系统非常熟悉。 
    
        另外，负载测试的成功与否，在很大程度上取决于自动化工具。在功能方面，主要考虑它所支持的协议、分析方式、监视目标种类等，以及该工具能否精确记录、回放用户的访问情况。在性能方面，则主要考虑它模拟虚拟用户的能力，例如在一定资源下可以模拟的用户的数量和速度。 
    
        负载测试的过程 
    
        负载测试是一项非常复杂的工作，一次测试常常要持续几天甚至几周。因此，在进行一次负载测试前，必须做好充分的准备，可以按照以下几个步骤来进行。 
    
        (1)系统分析 
    
        分析被测系统需要满足什么要求，例如支持多少人在线、支持连续多长时间的访问等。测试者的主要任务就是将系统的需求转换成测试目标，对系统进行全面的分析和评估，并结合测试的实际环境和条件以确保测试目标和测试计划的正确性。 
    
        (2)产生脚本 
    
        为了模拟多个用户访问服务器必须编写脚本。简单的脚本可以通过自动化工具提供的脚本编辑环境来编写。复杂的脚本则通常是通过记录单用户的活动生成最初的脚本，再在此基础上进行修改以保证该脚本可以支持多个用户。其中最主要的修改是关于数据池的，因为不同用户通常使用不同数据，例如用户名和密码等。因此，我们通常要将这些数据存储在数据库(或者数据池)中，以便在执行中被脚本程序调用。 
    
        (3)构造运行场景 
    
        有了脚本后，就可以通过一个场景来管理这些脚本的执行。场景是一个执行单位，可以通过场景来模拟一个工作负载。在场景中，我们将管理脚本的数量、执行次数、执行时间等，甚至还可以加上一些定时器、同步点等控制机制。另外，还可以将模拟用户分配到不同的计算机上。 
    
        (4)运行场景 
    
        设置好场景后，就可以运行了。通常，在运行场景的同时还要启动相关监控模块，监控服务器性能、网络状态、Web服务器性能和数据库性能等。自动化工具同时记录了各种客户端信息，包括相应时间、交易成功率等。 
    
        (5)分析报告 
    
        通常，在场景运行后，自动化工具会生成标准报告，可以通过分析这个报告来分析整个系统性能，找到系统瓶颈。这一步骤通常需要测试人员和开发人员共同完成。 
    
        负载测试市场和工具 
    
        负载测试市场的发展非常迅速，预计到2003年该市场将达到7亿美元。从目前来说，负载工具市场主要由一些大的软件公司分享，例如CA、Rational和Mercury Interactive。 
    
        (1) Load Runner 
    
        Load Runner是Mercury Interactive公司推出的专业负载测试工具，是目前世界上最强大的负载测试工具之一，它占领了负载测试工具市场的半壁江山。这是一个企业级的自动化工具，提供了非常强大的监视功能，能够监控各种软硬件模块。 
    
        从支持的协议来说，Load Runner支持HTTP(S)、WAP、i-Mode、 RealPlayer、LDAP、Winsock、RMI、FTP、POP3、SMTP、CORBA、COM/DCOM以及Tuxedo等。在监视器部分，它支持Windows NT/2000/XP、 SUN Solaris、HP UX、IBM AIX和Linux等操作系统，支持Apache、Web Logic等各种Web Server，还支持各种大型数据库。 
    
        (2) Astra LoadTest 
    
        Astra LoadTest也是Mercury Interactive 公司推出的负载测试工具。相对Load Runner来说，该工具更加容易使用，不需要使用者掌握复杂的编程语言，完全通过可视化界面进行操作。该工具支持大量HTML相关技术，例如 JavaScript、XML、ActiveX、Flash、DHTML以及SSL等，并支持大部分的浏览器。它的另外一个优点就是能够高效模拟更多虚拟用户，例如使用PIII 1G/512M机器最大可以支持100～250个用户。另外，Astra LoadTest 继承了LoadRunner的监视模块，可以监控所有LoadRunner支持的对象。 
    
        由于Astra LoadTest并不是定位在企业级用户，因此它对一些高级协议的支持不够充分，不能支持CORBA、LDAP、COM、WAP以及POP3等协议。 
    
        (3) Rational Robot 
    
        Rational在软件测试方面也有非常好的成绩。该公司推出的Robot工具支持SQABasic这种面向对象的记录语言。不过，在性能测试方面，Robot并不是很出名。但是Robot提供了一种新的脚本记录语言—VU语言，它基于传统的C语言，能够方便地访问Robot提供的环境变量。同时 Robot还提供了很多良好定义的库函数，调用通信函数更加方便。Robot还提供了其他许多相关测试技术，例如数据池(Datapool)、同步点等，并且通过TestManager可以对所有类型脚本进行管理。 
    
        从功能来说，Robot支持众多的网络协议，例如COM、DCOM、SOCKET、IIOP、Tuxedo等，并且可以对协议进行过滤，选取自己关心的协议。从操作方面来说，它对用户的要求也比较高，需要用户在整个访问过程中，对客户和服务器之间的交互类型和内容比较熟悉，同时对Robot也必须有足够的了解。 
    
        (4) WebLoad 
    
        WebLoad是RadView公司推出的专业负载测试软件。WebLoad提供了一种非常简单的脚本语言记录通信过程，同时它主要支持HTTP相关的技术和应用协议，例如JavaScript、XML、Java、EJB、ActiveX、WAP、HTTP、SNMP、Real以及 Microsoft Streaming Technologies等。该软件的操作非常容易，并且提供格式良好的分析报告。目前IBM公司大量采用该产品进行负载测试

    查看(1053) 评论(0) 收藏 分享 管理

26. 12款浏览器兼容性测试工具推荐

    2013-03-20 10:22:27

    对于前端开发工程师和WEB测试工程师来说，确保代码在各种主流浏览器的各个版本中都能正常工作是件很费时的事情，幸运的是，有很多优秀的工具可以帮助测试浏览器的兼容性，让我们一起看看这些很棒的工具。

    　　1. Spoon Browser Sandbox

    　　点击你需要测试的浏览器环境，安装插件就可以进行测试了。帮助你测试网页在Safari、Chrome、Firefox和Opera浏览器中是否正常，IE以前也有的，网站上说应微软的要求去掉了。

    

    　　2. Superpreview

    　　这是为微软自己发布的跨浏览器测试工具，您可以同时查看您的网页在多个浏览器的呈现情况，对页面排版进行直观的比较。

    

    　　3. IETester

    　　专门用于测试网页在IE浏览器各个版本中兼容性的工具，版本包含IE5.5至IE9的各个版本，很不错的一款工具，推荐。

    

     

    4. BrowserShots

    　　BrowserShots 是一款免费的跨浏览器测试工具，捕捉网站在不同浏览器中的截图。这是最有名，也是最古老的浏览器兼容性测试工具。

    

    　　5. Multiple IEs

    　　这款工具同样用于测试网页在IE浏览器各个版本的兼容性。

    

    　　6. IE netrenderer

    　　Netrenderer 也是用于检查你的网站在IE浏览器中的呈现情况，包括各个常用版本的检测。

    

    7. Viewlike.Us!

    　　Viewlike 是一款新推出的工具，帮助你检查浏览器在不同分辨率下得呈现情况。

    

    　　8. BrowserSeal

    　　这款工具的两个主要特色是独立的浏览器支持和带有自动化脚本的命令行界面。

    

    　　9. Browsera

    　　Browsera 是一个可测试您的网站的跨浏览器布局的工具，您会看到您网站上存在的兼容性错误。

    

    　10. WebDevLab

    　　这款工具专门用于测试你的网站在苹果Safari浏览器中是什么样子的。

    

    　　11. Litmus

    　　这个工具可以帮助你检查你的网站在多个浏览器中的呈现情况，跟踪Bug并创建报告。

    

    　　12. Browsercam

    　　最后这款工具是要付费的，可以帮助你检查 Javascript. 和 DHTML，提供不同的测试环境平台。

    

    查看(610) 评论(0) 收藏 分享 管理

27. 【转】分享对吞吐量、点击率、带宽大小等基础单位知识的总结

    2013-03-20 10:19:40

    一、位和字节
    1、 比特bit（b）  
    bit是字位（最小的存储单位，） 
    千位：Kbits（Kb，英文kilobit）
    计算机中的信息都是二进制的0和1来表示，其中每一个0或1被称作一个位。
    通常用bit来作数据传输的单位，因为物理层，数据链路层的传输对于用户是透明的，而这种通信传输是基于二进制的传输。
    
    2、 比特Byte（B）  
    Byte是字节（计算机储存容量大小的基本计算单位）
    千字节：Kbytes（KB，英文kilobyte）
    在应用层通常是用Byte来作单位，表示文件的大小，在用户看来就是可见的数据大小。比如一个字符就是1Byte,如果是汉字，则是2Byte。  
    我们所说的硬盘容量是40GB、80GB、100GB，这里的B指是的Byte也就是“字节”
    表示文件的大小单位，一般都使用字节（KB）来表示文件的大小。
    
    3、 兆（M，英文million=1000000）
    M是表示数值，不是单位，MB是量单位。 
    MB：一般指的是 兆字节，那个B是Byte而不是bit。
    Mb：一般指 兆位
    
    单位换算： 
    1Byte=8bit
    1KB=1024B=1024*8b 
    1kB=1000B=1000*8b 　　
    1Kb=1024b 
    1kb=1000b 
    1MB=1024KB
    1GB=1024MB
    1T=1024GB
    注意：小k通常表示1000，大K表示1024.
    
    二、传输速率
    1、带宽
    单位：Mbps(兆位/秒)，又可写成Mb/sec，或Mb/s，ps就是每秒的意思，
    Mbps的含义是兆比特每秒：指每秒传输的比特位数
    MBps的含义是兆字节每秒：指每秒传输的字节数量
    Mbps代表每秒传输1048576比特(1MB=1024*1024b)。该缩写用来描述数据传输速度。例如：4Mbps=每秒钟传输4M比特
    传输速率是指集线器的数据交换能力,目前主流的集线器带宽主要有10Mbps、54Mbps/100Mbps自适应型、100Mbps和1GMbps四种。 
    
    由于数据传输速率的单位，字母b是比特和字母B是字节，相应的MBPS也就有两个解释了, 分别是：
    1、每秒百万个位元组 (megabyte)； 　　
    2、每秒百万个位元(megebit)。
    通常说的Mbps是指第二个每秒百万个位元，也就是每秒百万个位。 
    
    由于在传输过程中为了保证信息传输的正确性需要在传输的每个字节之间增加仃码和校验码，因此如果换算成我们常用的MB单位就需要除以8，如下： 
    100Mbps=100/8=12.5MB/s　
    4Mbps = 4/8=0.5MB/s 
    
    常见的如： 　 
    一般主板仅仅能提供 100Mbps的接口 　
    SATA II硬盘 理论上可以达到 3000Mbps 的速度 　
    换算成我们常用的MB单位就是: 　 
    100Mbps=100/8=12.5MB/s 　
    3000Mbps=12.5*30=375MB/s 　 
    这样就能看到适用于日常习惯性的传输速度单位了。 　　
    在网络传输过程中还需要对信息进行打包，增加Ethernet Header, IP Header, TCP Header, ATM Header 等控制讯号，因此该数据的实际速率还需要再打些折扣，但最简单的估算方法除以10就可以了。
    
    在这里需要说明的问题是在单位换算上有一点是极其重要的，即：
    1Mb=1024kb=1024000b 
    1MB=1024KB=1024*1024B=1024*1024*8b=8388608b这在数量上差的很多
    1KB=1024B（大写K）
    1kB=1000B（小写k）
    1Mbps=1Mb=1024kb ,1024/8=128kb/s.
    
    KBps=1024Bps，kBps=1000Bps   也就是说KBps>kBps [1]
    小k代表kilo,千的意思，也就是1000，那么kBps就是1000Bps也就是一千字节每秒的意思。 　　　
    而KBps(K为大写字母)就等于1024Bps。而kBps（k为小写字母）的意思是千字节每秒。 　　
    千字节每秒(KBps）与一千字节每秒(kBps)是不同的。 　
    
    2、Kbps
    Kbps又称比特率，指的是数字信号的传输速率，也就是每秒钟传送多少个千位的信息。
    Kbps也可以表示网络的传输速度，为了在直观上显得网络的传输速度较快，一般公司都使用Kb（千位）来表示，即Kbps。如果是KBps，则表示每秒传送多少千字节。
    
    bps=bits per second = bits/s
    Bps=Bytes per second = Byte/s
    kbps=kilobits per second 千位/秒
    KBps=kilobytes per second 千字节/秒
    
    KBps表示的是每秒传送多少个千字节。
    换算的方式是：
    1KBps＝8Kbps。
    1KB=8Kb
    1KBps=8Kbps
    1MB=8Mb
    1MBps=8Mbps
    1Mbps=1024Kbps
    1Kbps=1024bps
    
    1MBps=1024KBps
    1KBps=8Kbps
    1Gbps=1024Mbps
    1GBps=1024MBps
    1Kb=1024b=1024/8B=128B
    1MB=1024KB=1024*1024B=1024*1024/128Kb=8192Kb
    1 Mbps = 1024 Kbps=1024/8KBps=128KBps因此，通常说的2M带宽（网速），其实是2Mbps,即2Mbps=2*1024Kbps=2048/8KBps=256KBps，虽然理论上能到250KBps,实际约200KBPS就不错了.
    USB2.0标准接口传输速率是480兆位/秒,即480Mbps。这里的b指的是bit（与传输相关，属于底层）
    ADSL上网时的网速是512Kbps,如果转换成字节，就是512/8＝64KBps(即64千字节每秒）。这里的64就是我们在下载软件中看到的下载速度。
    
    计算机存储单位一般用B，KB，MB，GB，TB，PB，EB，ZB，YB，BB来表示，它们之间的关系是：  
    1KB(Kilobyte 千字节)=1024B， 　　
    1MB (Megabyte 兆字节 简称“兆”)=1024KB， 　　
    1GB (Gigabyte 吉字节 又称“千兆”)=1024MB， 　　
    1TB(Trillionbyte 万亿字节 太字节)=1024GB，其中1024=2^10 ( 2 的10次方)

    查看(4377) 评论(0) 收藏 分享 管理

28. 【转】Web网站的性能测试工具

    2013-03-20 10:16:46

    随着Web 2.0技术的迅速发展，许多公司都开发了一些基于Web的网站服务，通常在设计开发Web应用系统的时候很难模拟出大量用户同时访问系统的实际情况，因此，当Web网站遇到访问高峰时，容易发生服务器响应速度变慢甚至服务中断。为了避免这种情况，需要一种能够真实模拟大量用户访问Web应用系统的性能测试工具进行压力测试，来测试静态HTML页面的响应时间，甚至测试动态网页（包括ASP、PHP、JSP等）的响应时间，为服务器的性能优化和调整提供数据依据。

    　　我推荐各位Web 2.0开发测试人员使用Microsoft 的Web Application Stress Tool这个工具软件，这个微软提供的小工具仅9.58M，很小巧且实用。虽然功能上比不了专业的LoadRunner，但LoadRunner体积庞大，价格不菲，一般的企业也不会花那么多钱去购买LoadRunner，而微软的WAS则是完全免费，并且主要的功能都有，够用就行。

    　　Microsoft Web Application Stress Tool能有效测试一个网站的负载性能，这个软件可以通过脚本模拟100个强并发用户的访问，并模拟实际用户的一些点击操作，WAS还可以连接上远程Windows网站服务器的性能计数器（Performance Counter），通过对服务器性能（CPU/内存等）的性能分析来找到系统的瓶颈。CPU使用百分比反映了处理器开销，CPU使用百分比持续地超过75%是性能瓶颈在于处理器的一个明显的迹象。

    　　每次测试运行结束后WAS会生成详细的报表，WAS报表可以从View菜单选择Reports查看。

    　　另外，CSDN也总结了一些其他的测试工具，包括性能测试工具和功能测试工具，前十大测试工具排名如下：

    　　业级自动化测试工具WinRunner

    　　Mercury Interactive公司的WinRunner是一种企业级的功能测试工具，用于检测应用程序是否能够达到预期的功能及正常运行。通过自动录制、检测和回放用户的应用操作，WinRunner能够有效地帮助测试人员对复杂的企业级应用的不同发布版进行测试，提高测试人员的工作效率和质量，确保跨平台的、复杂的企业级应用无故障发布及长期稳定运行。

    　　工业标准级负载测试工具Loadrunner

    　　LoadRunner 是一种预测系统行为和性能的负载测试工具。通过以模拟上千万用户实施并发负载及实时性能监测的方式来确认和查找问题，LoadRunner 能够对整个企业架构进行测试。通过使用LoadRunner ，企业能最大限度地缩短测试时间，优化性能和加速应用系统的发布周期。

    　　全球测试管理系统testdirector

    　　TestDirector 是业界第一个基于Web的测试管理系统，它可以在您公司内部或外部进行全球范围内测试的管理。通过在一个整体的应用系统中集成了测试管理的各个部分，包括需求管理，测试计划，测试执行以及错误跟踪等功能，TestDirector极大地加速了测试过程。

    　　功能测试工具Rational Robot

    　　IBM Rational Robot 是业界最顶尖的功能测试工具，它甚至可以在测试人员学习高级脚本技术之前帮助其进行成功的测试。它集成在测试人员的桌面 IBM Rational TestManager 上，在这里测试人员可以计划、组织、执行、管理和报告所有测试活动，包括手动测试报告。这种测试和管理的双重功能是自动化测试的理想开始。

    　　单元测试工具xUnit系列

    　　目前的最流行的单元测试工具是xUnit系列框架，常用的根据语言不同分为JUnit（java），CppUnit（C++），DUnit （Delphi ），NUnit（.net），PhpUnit（Php ）等等。该测试框架的第一个和最杰出的应用就是由Erich Gamma （《设计模式》的作者）和Kent Beck（XP（Extreme Programming）的创始人 ）提供的开放源代码的JUnit.

    　　功能测试工具SilkTest

    　　Borland SilkTest 2006属于软件功能测试工具，是Borland公司所提出软件质量管理解决方案的套件之一。这个工具采用精灵设定与自动化执行测试，无论是程序设计新手或资深的专家都能快速建立功能测试，并分析功能错误。

    　　性能测试工具WAS

    　　Microsoft Web Application Stress Tool 是由微软的网站测试人员所开发，专门用来进行实际网站压力测试的一套工具。透过这套功能强大的压力测试工具，您可以使用少量的Client端计算机仿真大量用户上线对网站服务所可能造成的影响。

    　　自动化白盒测试工具Jtest

    　　Jtest是parasoft公司推出的一款针对java语言的自动化白盒测试工具，它通过自动实现java的单元测试和代码标准校验，来提高代码的可靠性。parasoft同时出品的还有C++ test，是一款C/C++白盒测试工具。

    　　功能和性能测试的工具JMeter

    　　JMeter是Apache组织的开放源代码项目，它是功能和性能测试的工具，100%的用java实现。

    　　性能测试和分析工具WEBLODE

    　　webload是RadView公司推出的一个性能测试和分析工具，它让web应用程序开发者自动执行压力测试；webload通过模拟真实用户的操作，生成压力负载来测试web的性能。

    查看(306) 评论(0) 收藏 分享 管理

29. 【转】cookie和session 区别and 联系

    2013-03-20 10:13:26

    cookie和session机制之间的区别与联系 
    具体来说cookie机制采用的是在客户端保持状态的方案。它是在用户端的会话状态的存贮机制，他需要用户打开客户端的cookie支持。cookie的作用就是为了解决HTTP协议无状态的缺陷所作的努力. 
    而session机制采用的是一种在客户端与服务器之间保持状态的解决方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的。而session提供了方便管理全局变量的方式 
    
    session是针对每一个用户的，变量的值保存在服务器上，用一个sessionID来区分是哪个用户session变量,这个值是通过用户的浏览器在访问的时候返回给服务器，当客户禁用cookie时，这个值也可能设置为由get来返回给服务器。 
    
    就安全性来说：当你访问一个使用session 的站点，同时在自己机子上建立一个cookie，建议在服务器端的SESSION机制更安全些.因为它不会任意读取客户存储的信息。 
    
    正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie 
    
    从网络服务器观点看所有HTTP请求都独立于先前请求。就是说每一个HTTP响应完全依赖于相应请求中包含的信息状态管理机制克服了HTTP的一些限制并允许网络客户端及服务器端维护请求间的关系。在这种关系维持的期间叫做会话(session)。 
    
    Cookies是服务器在本地机器上存储的小段文本并随每一个请求发送至同一个服务器。IETF RFC 2965 HTTP State Management Mechanism 是通用cookie规范。网络服务器用HTTP头向客户端发送cookies，在客户终端，浏览器解析这些cookies并将它们保存为一个本地文件，它会自动将同一服务器的任何请求缚上这些cookies 
    
    
    
    cookie和session机制区别与联系 
    具体来说cookie机制采用的是在客户端保持状态的方案，而session机制采用的是在服务器端保持状态的方案。同时我们也看到，由于采用服务器端保持状态的方案在客户端也需要保存一个标识，所以session机制可能需要借助于cookie机制来达到保存标识的目的，但实际上它还有其他选择。 
    
    cookie机制。正统的cookie分发是通过扩展HTTP协议来实现的，服务器通过在HTTP的响应头中加上一行特殊的指示以提示浏览器按照指示生成相应的cookie。然而纯粹的客户端脚本如JavaScript或者VBScript也可以生成cookie。而cookie的使用是由浏览器按照一定的原则在后台自动发送给服务器的。浏览器检查所有存储的cookie，如果某个cookie所声明的作用范围大于等于将要请求的资源所在的位置，则把该cookie附在请求资源的HTTP请求头上发送给服务器。 
    cookie的内容主要包括：名字，值，过期时间，路径和域。路径与域一起构成cookie的作用范围。若不设置过期时间，则表示这个cookie的生命期为浏览器会话期间，关闭浏览器窗口，cookie就消失。这种生命期为浏览器会话期的cookie被称为会话cookie。会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。若设置了过期时间，浏览器就会把cookie保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式 
    session机制。session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。 
    
    当程序需要为某个客户端的请求创建一个session时，服务器首先检查这个客户端的请求里是否已包含了一个session标识（称为session id），如果已包含则说明以前已经为此客户端创建过session，服务器就按照session id把这个session检索出来使用（检索不到，会新建一个），如果客户端请求不包含session id，则为此客户端创建一个session并且生成一个与此session相关联的session id，session id的值应该是一个既不会重复，又不容易被找到规律以仿造的字符串，这个session id将被在本次响应中返回给客户端保存。 
    保存这个session id的方式可以采用cookie，这样在交互过程中浏览器可以自动的按照规则把这个标识发挥给服务器。一般这个cookie的名字都是类似于SEEESIONID。但cookie可以被人为的禁止，则必须有其他机制以便在cookie被禁止时仍然能够把session id传递回服务器。

    查看(746) 评论(0) 收藏 分享 管理