1、首先下载apache2.2 下载地址：http://mirrors.sohu.com/apache/httpd-2.2.16.tar.gz

2、然后下载SVN

a) 包：subversion-deps-1.6.12.tar.gz

i. 地址：http://subversion.tigris.org/downloads/subversion-deps-1.6.12.tar.gz

b) susubversion-1.6.12.tar.gz  地址：

i. http://subversion.tigris.org/downloads/subversion-1.6.12.tar.gz 

3、然后解析Apache2，安装

4、tar -zxvf httpd-2.2.16.tar.gz

5、安装Apache

a) ./configure -prefix=/opt/web/apache2 --enable-mods-shared=all --enable-so

b) Make

c) Make install

6、检查APACHE是否安装成功：

启动apache:/opt/web/apache2/bin/apachectl start

7、安装Svn

8、首先解压： tar -zxvf subversion-deps-1.6.12.tar.gz

9、然后解压：tar -zxvf susubversion-1.6.12.tar.gz 

10、安装命令：

a) ./configure --prefix=/opt/web/subversion --with-apxs=/opt/web/apache2/bin/apxs --with-apr=/opt/web/httpd-2.2.16/srclib/apr  --with-apr-util=/opt/web/httpd-2.2.16/srclib/apr-util

11、make  make install

1、首先检查一下linux下是有存在一下软件，如果不存在，必须将这些软件安装
rpm -q compat-libstdc++-33 elfutils-libelf elfutils-libelf-devel glibc glibc-common glibc-devel gcc- gcc-c++ libaio-devel libaio libgcc libstdc++ libstdc++-devel make sysstat unixODBC unixODBC-devel
2、以root方式登陆，修改/etc/sysctl.conf，在文件中增加一下参数
kernel.shmall = 2097152
kernel.shmmax = 2147483648
kernel.shmmni = 4096
kernel.sem = 250 32000 100 128
fs.file-max = 65536
net.ipv4.ip_local_port_range =1024 65000
net.core.rmem_default = 4194304
net.core.rmem_max = 4194304
net.core.wmem_default =262144
net.core.wmem_max =262144

然后创建数据库的所有者：
groupadd oinstall
groupadd dba
useradd -g oinstall -G dba Oracle 创建用户Oracle
passwd Oracle（修改Oracle的密码）
修改Oracle用户的限制
cd /etc/security
vi limits.conf
在该文件增加一下内容
Oracle soft nproc 2047
Oracle hard nproc 16384
Oracle soft nofile 1024
Oracle hard nofile 65536
在文件/etc/pam.d/login文件增加一下内容
session required /lib/security/pam_limits.so
session required pam_limits.so
在文件/etc/profile增加一下内容

if [$USER = "Oracle"] ; then
if [ $SHELL = " /bin/ksh" ]; then
ulimit -p 16384
ulimit -n 65535
else
ulimit -u 16384 -n 65536
fi
fi
创建安装目录：
mkdir -p /opt/app/oracle
chown -P Oracle:oinstall /opt/app
chmod -R 755 /opt/app
执行命令，解压安装文件 ：unzip linux_11gR1_database.zip
然后进入解压后的目录，执行
$ ./runInstaller

首先我们看看Directory 的类
public abstract class Directory {
volatile boolean isOpen = true;
/*** 持有一个LockFactory的实例（实现锁定这个目录实例）*/
protected LockFactory lockFactory;
/**返回该目录下的所有文件数组.如果这个目录下没有文件存在，或者存在权限问题不能访问，该方法可能返回Null*/
public abstract String[] list() throws IOException;
/** * 返回指定名称的文件是不是存在 */
public abstract boolean fileExists(String name)
throws IOException;
/**返回指定名称的文件最后修改的时间
public abstract long fileModified(String name) throws IOException;
/**设置指定文件名的文件最后的修改时间为当前时间*/
public abstract void touchFile(String name) throws IOException;

/**删除指定文件。 */
public abstract void deleteFile(String name)throws IOException;
/**返回指定文件的长度。 */
public abstract long fileLength(String name) throws IOException;
/** 在当前目录下使用给定的名称创建一个空的文件。并且返回一个流来写该文件。*/
public abstract IndexOutput createOutput(String name) throws IOException;
/** * Lucene使用该方法确保所有的针对该文件的写操作都会存储到Index。并且阻止machine/OS发生故障 破坏该index。*/
public void sync(String name) throws IOException {}
/**获取已经存在的一个文件的IndexInput流操作该文件。 */
public abstract IndexInput openInput(String name) throws IOException;
/** 返回已经存在的一个文件、并且使用指定大小的缓冲的IndexInput，但是当前目录也可能忽略该缓冲池的大小，
* 当前主要是考虑CompoundFileReader和FSDirectory对于次参数的需求。*/
public IndexInput openInput(String name, int bufferSize) throws IOException {
return openInput(name);
}
/** 创建一个指定名称的锁/
public Lock makeLock(String name) {
return lockFactory.makeLock(name);
}
/**
* 清除指定的锁定（强行解锁和删除）这不仅要求在这个时候当前的锁一定不在使用。 */
public void clearLock(String name) throws IOException {
if (lockFactory != null) {
lockFactory.clearLock(name);
}
}
/** 结束这个store. */
public abstract void close() throws IOException;

/**设置LockFactory，此目录实例应使其锁定执行。每个LockFactory实例只用于一个目录（即，不要共用一个实例在多个目录） */
public void setLockFactory(LockFactory lockFactory) {
this.lockFactory = lockFactory;
lockFactory.setLockPrefix(this.getLockID());
}

/** 获得LockFactory，此目录例实例使用其锁定执行。请注意，这可能是无效的目录执行，提供自己锁执行*/
public LockFactory getLockFactory() {
return this.lockFactory;
}
/**过去锁实例的唯一表示ID的字符串描述*/
public String getLockID() {
return this.toString();
}
/**// 拷贝源目录src下的文件，复制到目的目录dest下面，拷贝完成后关闭源目录src*/
public static void copy(Directory src, Directory dest, boolean closeDirSrc) throws IOException {
final String[] files = src.list();
if (files == null)
throw new IOException("cannot read directory " + src + ": list() returned null");
byte[] buf = new byte[BufferedIndexOutput.BUFFER_SIZE];
for (int i = 0; i < files.length; i++) {
IndexOutput os = null;
IndexInput is = null;
try {
// create file in dest directory
os = dest.createOutput(files[i]);
// read current file
is = src.openInput(files[i]);
// and copy to dest directory
long len = is.length();
long readCount = 0;
while (readCount < len) {
int toRead = readCount + BufferedIndexOutput.BUFFER_SIZE > len ? (int)(len - readCount) : BufferedIndexOutput.BUFFER_SIZE;
is.readBytes(buf, 0, toRead);
os.writeBytes(buf, toRead);
readCount += toRead;
}
} finally {
// graceful cleanup
try {
if (os != null)
os.close();
} finally {
if (is != null)
is.close();
}
}
}
if(closeDirSrc)
src.close();
}

从Directory抽象类的定义，我们可以得到如下几点：
1、管理锁工厂及其锁实例；
2、管理Directory目录实例的基本属性，主要是通过文件名称进行管理；
3、管理与操作该目录相关的一些流对象；
4、管理索引文件的拷贝。

2、我们首先看看IndexWriter的构造函数

public IndexWriter(String path, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(String path, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(File path, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(File path, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, boolean create, MaxFieldLength mfl)

public IndexWriter(Directory d, Analyzer a, boolean create)(废弃，不提倡使用)

public IndexWriter(String path, Analyzer a, MaxFieldLength mfl)

public IndexWriter(String path, Analyzer a)(废弃，不提倡使用)

public IndexWriter(File path, Analyzer a, MaxFieldLength mfl)

public IndexWriter(File path, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, MaxFieldLength mfl)

public IndexWriter(Directory d, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a)(废弃，不提倡使用)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, boolean create)（废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, IndexDeletionPolicy deletionPolicy, MaxFieldLength mfl)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, IndexDeletionPolicy deletionPolicy)（废弃，不提倡使用)

public IndexWriter(Directory d, Analyzer a, boolean create, IndexDeletionPolicy deletionPolicy, MaxFieldLength mfl)

public IndexWriter(Directory d, boolean autoCommit, Analyzer a, boolean create, IndexDeletionPolicy deletionPolicy)（废弃，不提倡使用)

细心的读者肯定会发现，废弃的构造函数与提倡使用的构造函数，多了一个MaxFieldLength参数。带有该参数的构造函数都是允许正常使用的。（注释：废弃的构造函数将在Lucene3.0中移除）

仔细查看其构造函数的实现呢，最终都转化成一个私有的构造函数：如图：

/**

* 该构造函数主要是创建一个IndexWrite对象

* d ：指定的存放建立索引文件的索引目录

* a ：Analyzer  分词分析器

* create ：是否要重新写入索引文件，如果为true，则重写索引文件；如果为false，则追加写入索引文件

* closeDir ：一个boolean型变量，表示是否关闭索引目录Directory d，与IndexWriter的一个成员变量相关

* deletionPolicy ：指定删除索引文件使用的策略

* autoCommit ：建立索引文件后，自动提交。

* maxFieldLength ： 表示索引中Field的最大长度。

*/

private void init(Directory d, Analyzer a, final boolean create, boolean closeDir, IndexDeletionPolicy deletionPolicy, boolean autoCommit, int maxFieldLength)

    throws CorruptIndexException, LockObtainFailedException, IOException {

    this.closeDir = closeDir;

    directory = d;

    analyzer = a;

    setMessageID(defaultInfoStream);//这里主要是指定infoStream，是一个PrintStream输出流对象

    this.maxFieldLength = maxFieldLength; //指定Field数据的最大长度

    if (create) {

      // 如果是重新创建索引文件，清除写锁文件write.lock

      directory.clearLock(WRITE_LOCK_NAME);

    }

    Lock writeLock = directory.makeLock(WRITE_LOCK_NAME);

    if (!writeLock.obtain(writeLockTimeout)) // 获取写锁文件

      throw new LockObtainFailedException("Index locked for write: " + writeLock);

    this.writeLock = writeLock;             //保存新的写锁文件

    try {

      if (create) {

        // 如果create为true，表示重写索引文件。重写索引文件之前，要先读取已经存在的索引文件，并且要清除掉历史写入的segment信息

        try {

          segmentInfos.read(directory);

          segmentInfos.clear();

        } catch (IOException e) {

        }

        segmentInfos.commit(directory);  // 向指定的索引存放目录中写入segment信息   

      } else {

        segmentInfos.read(directory); //读取segment信息

        // We assume that this segments_N was previously

        // properly sync'd:

        for(int i=0;i<segmentInfos.size();i++) {

          final SegmentInfo info = segmentInfos.info(i);

          List files = info.files();

          for(int j=0;j<files.size();j++)

            synced.add(files.get(j));

        }

      }

      this.autoCommit = autoCommit; //执行提交写入索引的标志 

      setRollbackSegmentInfos(segmentInfos); //克隆原来的segment状态信息，并且将信息保存到HashSet。

      docWriter = new DocumentsWriter(directory, this); //创建一个DocumentsWriter对象

      docWriter.setInfoStream(infoStream); //设置DocumentsWriter对象的infoStream信息

      docWriter.setMaxFieldLength(maxFieldLength); //设置DocumentsWriter对象的maxFieldLength信息

      //默认的删除策略实现类为KeepOnlyLastCommitDeletionPolicy，它只是保证将最近提交删除的索引文件，提交删除动作 

      // IndexFileDeleter deleter是IndexWriter类的一个私有的成员变量，它在org.apache.lucene.index包里面，主要对删除索引文件进行实现和管理 

      deleter = new IndexFileDeleter(directory,

                                     deletionPolicy == null ? new KeepOnlyLastCommitDeletionPolicy() : deletionPolicy,

                                     segmentInfos, infoStream, docWriter);

      pushMaxBufferedDocs(); //刷新DocsBuffer。

      if (infoStream != null) { //如果infoStream是null

        message("init: create=" + create);

        messageState();

      }

    } catch (IOException e) {

      this.writeLock.release();

      this.writeLock = null;

      throw e;

    }

  } 

  通过IndexWrite的构造函数，以及最终的实现方法的init分发，其主要是实现了根据指定的建立索引的方式(重写、追加写入)，通过create标志位来判断，从而指定一种在操作索引文件的过程中删除索引文件的策略。

在理解lucene的时间，必须熟悉其初始化IndexWrite的原理，才能深入了解该框架在创建索引的核心实现机制。

Filed类源代码解析
    首先Filed内部定义了三个静态类Store、Index、TermVector。
//定一个静态类Store ，主要为了设置Field的存储属性
public static final class Store extends Parameter implements Serializable {
    private Store(String name) {
      super(name);
    }
    //使用压缩的方式来存储Field的值
    public static final Store COMPRESS = new Store("COMPRESS");
    //在索引中存储Field的值
    public static final Store YES = new Store("YES");
    //在索引中不存贮Field的值
    public static final Store NO = new Store("NO");
  }
//定一个静态类Index ，主要为了设置Field的索引属性
public static final class Index extends Parameter implements Serializable {
    private Index(String name) {
      super(name);
 }
 //不对Field进行索引，所以这个Field就不能被检索到(一般来说，建立索引而使它不被检索，这是没有意义的)
 //如果对该Field还设置了Field.Store为Field.Store.YES或Field.Store.COMPRESS，则可以检索
    public static final Index NO = new Index("NO");

    //对Field进行索引，同时还要对其进行分词(由Analyzer来管理如何分词)
    public static final Index ANALYZED = new Index("ANALYZED");
//废弃的属性，使用ANALYZED 来替代
     public static final Index TOKENIZED = ANALYZED;
//对Field进行索引，但是不对该Field使用分词
    public static final Index NOT_ANALYZED = new Index("NOT_ANALYZED");
//废弃的属性，使用NOT_ANALYZED来替代
    public static final Index UN_TOKENIZED = NOT_ANALYZED;
//即不对Field索引，也不对其使用Analyzer来分词
    public static final Index NOT_ANALYZED_NO_NORMS = new  Index("NOT_ANALYZED_NO_NORMS");
//废弃的属性，有NOT_ANALYZED_NO_NORMS来替代
    public static final Index NO_NORMS = NOT_ANALYZED_NO_NORMS;
//对Field属性，使用分词，但是不是使用Analyzer来分词
    public static final Index ANALYZED_NO_NORMS = new Index("ANALYZED_NO_NORMS");
  }
这是一个与词条有关的类。因为在检索的时候需要指定检索关键字，通过为一个Field添加一个TermVector，就可以在检索中把该Field检索到。
public static final class TermVector  extends Parameter implements Serializable {
    private TermVector(String name) {
      super(name);
    }
    //不存储
    public static final TermVector NO = new TermVector("NO");
    //为每个Document都存储一个TermVector
    public static final TermVector YES = new TermVector("YES");
    //存储，并且存在位置信息
    public static final TermVector WITH_POSITIONS = new TermVector("WITH_POSITIONS");
    //存储，并且存贮偏移量信息
    public static final TermVector WITH_OFFSETS = new TermVector("WITH_OFFSETS");
    //存储位置、偏移量等所有信息
    public static final TermVector WITH_POSITIONS_OFFSETS = new TermVector("WITH_POSITIONS_OFFSETS");
  }

构造函数
 public Field(String name, String value, Store store, Index index)  
public Field(String name, String value, Store store, Index index, TermVector termVector)
public Field(String name, Reader reader)
public Field(String name, Reader reader, TermVector termVector)
public Field(String name, TokenStream tokenStream)
public Field(String name, TokenStream tokenStream, TermVector termVector)
 public Field(String name, byte[] value, Store store)
public Field(String name, byte[] value, int offset, int length, Store store)

流程：
首先检查name以及values不能为空以及Nnull。
然后检查是否是存储以及是否分词如果两者都是No，则抛出异常。
然后检查是否存储以及是否向量分词，如果两者都是No'，则抛出异常。
然后将该Filed的名称命令传递过来的名称源代码（this.name = name.intern）
表示获取JVM String常量池的地址
此时根据Store的值，来设置是否存储以及压缩的值
然后根据Index的值，来设置是否索引、是否分词、omitNorms  的值以及置是否是二进制
然后开始根据TermVector 的值，来设置是否存储向量、是否存储偏移量、是否存储位置等信息。


以上信息可能存在分析不正确，请大家给指证，本人英语有不怎么好，

Document是lucene自己定义的一种文件格式，lucene使用docement来代替对应的物理文件或者保存在数据库中的数据。因此Document只能作为数据源在Lucene中的数据存贮的一种文件形式。

Document只是负责收集数据源，因为不同的文件可以构建同一个Document。只要用户将不同的文件创建成Document类型的文件，Lucene就能快速找到查找并且使用他们。

对于一个Document文件，可以同时增加多个Field。Lucene中对于每个数据源是使用Field类来表示的。多个Field组成一个Document，多个Document组成一个索引文件。Document与Field关系如果一所示

此时，我们去看看Document这个类的源代码。Document采用默认不带参数的构造函数，但是我们他在创建的时间，
        产生两个变量：fields和 boost

其中fields是创建了一个arrayList,其主要是保存Field类

Boost主要是设置该doc的优先级

其方法：add（Fieldable field）增加一个field对象

    removeField(String name)  根据name移除一个ield对象（找到一个就返回）

removeFields(String name)  根据name移除所有的field对象

Field getField(String name)  根据名字找到该Field对象。

Fieldable getFieldable(String name)  根据名字找到Fieldable子类（Fieldable是 接口，具体有Filed来实现）

String get(String name) 根据名字，找到给Filed对象中包含的内容

public final byte[] getBinaryValue(String name) 主要查找Doc中包含有二进制field 数据（如果不存在，则返回null）
    public final List getFields() 直接返回该Doc中包含的Field。
    

import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.GenericObjectPool;
import org.apache.log4j.Logger;

/**
 * @author Administrator
 *
 */
public class DBConnectionFactory {
 /**
  * Logger for this class
  */
 private static final Logger logger = Logger
   .getLogger(DBConnectionFactory.class);

 private static ObjectPool connectionPool=null;
 private static String sqlJdbc = "";
    private static String sqlUser = "";
    private static String sqlPwd = "";
    @SuppressWarnings("unchecked")
 private static Class driverClass=null;

    public static void proDBConnectionFactory(){
     if(sqlJdbc.equals("")){
      sqlJdbc = "jdbc:jtds:sqlserver://27.0.0.1:1433/finance;tds=8.0;lastupdatecount=true";
     }
     if(sqlUser.equals("")){
      sqlUser = "sa";
     }
     if(sqlPwd.equals("")){
      sqlPwd = "11111";
     }
     initDataSource();
    }
     public synchronized static void initDataSource(){
      if(driverClass == null){
       try {
    driverClass = Class.forName("net.sourceforge.jtds.jdbc.Driver");
   } catch (ClassNotFoundException e) {
    logger.error("在注册驱动名称的时间发生错误："+e.getMessage(),e);
   }
      }
      if(connectionPool == null){
       setupDriver(sqlJdbc);
       //printDriverStats();
      }else{
       System.out.print("连接池已经存在");
      }
      try {
            // printDriverStats();
         } catch (Exception e) {
             e.printStackTrace();
         }  
     }
    
     public static Connection getConn(){
      proDBConnectionFactory();
      Connection conn = null;
      try {
             conn = DriverManager.getConnection("jdbc:apache:commons:dbcp:FinanceDBPool");
         } catch(SQLException e) {
             e.printStackTrace();
         }
         return conn;

     }
    
     public static void printDriverStats() throws Exception {
         PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
         ObjectPool connectionPool = driver.getConnectionPool("FinanceDBPool");
         System.out.println("活动的连接: " + connectionPool.getNumActive());
         System.out.println("空闲的连接: " + connectionPool.getNumIdle());
     }

    
     public static void setupDriver(String connectURI){
      try {
   connectionPool = new GenericObjectPool(null);
    ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(connectURI,sqlUser,sqlPwd);
    @SuppressWarnings("unused")
   PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory,connectionPool,null,null,false,true);
    Class.forName("org.apache.commons.dbcp.PoolingDriver");
    PoolingDriver driver = (PoolingDriver) DriverManager.getDriver("jdbc:apache:commons:dbcp:");
    //driver.registerPool("FinanceDBPool",connectionPool);
    driver.registerPool("FinanceDBPool",connectionPool);

  } catch (ClassNotFoundException e) {
   logger.error("注册连接池的时间发生错误:"+e.getMessage(),e);
  } catch (SQLException e) {
   logger.error("注册连接池的时间发生错误:"+e.getMessage(),e);
  }
     }
 

1. StringTokenizer(String str) ：构造一个用来解析str的StringTokenizer对象。java默认的分隔符是“空格”、“制表符(‘\t’)”、“换行符(‘\n’)”、“回车符(‘\r’)”。
2. StringTokenizer(String str, String delim) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符。
3. StringTokenizer(String str, String delim, boolean returnDelims) ：构造一个用来解析str的StringTokenizer对象，并提供一个指定的分隔符，同时，指定是否返回分隔符。

1. int countTokens() ：返回nextToken方法被调用的次数。如果采用构造函数1和2，返回的就是分隔符数量(例2)。
2. boolean hasMoreTokens() ：返回是否还有分隔符。
3. boolean hasMoreElements() ：结果同2。
4. String nextToken() ：返回从当前位置到下一个分隔符的字符串。
5. Object nextElement() ：结果同4。
6. String nextToken(String delim) ：与4类似，以指定的分隔符返回结果。

		String s = new String("The Java platform is the ideal platform for network computing");
		StringTokenizer st = new StringTokenizer(s);
		System.out.println( "Token Total: " + st.countTokens() );
		while( st.hasMoreElements() ){
			System.out.println( st.nextToken() );
　　　　　　　　　　　}
结果为：
Token Total: 10
The
Java
platform
is
the
ideal
platform
for
network
computing

		String s = new String("The=Java=platform=is=the=ideal=platform=for=network=computing");
		StringTokenizer st = new StringTokenizer(s,"=",true);
		System.out.println( "Token Total: " + st.countTokens() );
		while( st.hasMoreElements() ){
			System.out.println( st.nextToken() );
		}
结果为：
Token Total: 19
The
=
Java
=
platform
=
is
=
the
=
ideal
=
platform
=
for
=
network
=
computing

4．2安全保密设计
　　说明在数据库的设计中，将如何通过区分不同的访问者、不同的访问类型和不同的数据对象，进行分别对待而获得的数据库安全保密的设计考虑。

　　现在你正在设计其中的一个特性，已经发现了需求的一些问题。你可以用多种不同的方式解释需求15；需求9 的说明正好与需求21相反，你因该相信哪一个？需求24非常含糊，你根本不明白它的意思；你不得不花上一个小时与2位开发人员讨论需求30，只因为你们对其各有各的理解；并且，唯一能够澄清这些问题的客户没有给你们答复。你被迫破解众多需求的含义，并且你能预料到，如果你错了，你要做大量的重复工作。

　　许多软件需求说明书（SRS）写得非常糟糕。任何产品的质量需要其原始材料的质量保证，糟糕的软件需求说明书不可能产出优秀的软件。不幸的是，几乎没有开发人员受过与需求的抽象、分析、文档、质检有关的教育。而且，没有非常多的好需求可以借鉴学习，部分原因是很少有工程可以找到一个好的借鉴，其他原因是公司不愿意将其产品说明书放在公共区域。

　　这篇文章描述了高质量需求叙述和说明的几个特性（特点）。我们将用这些观点检查一些有缺陷的需求，带着痛楚重新编写。而且我会谈一些如何编写好的需求的提示。你也许想通过这些质量标准评估你的工程需求。对于修订，也许迟了，但你会学到一些有用的东西，并帮助你的小组在下次编写出更好的需求。

　　不要期望能够编写出一份能体现需求应具备的所有特性的SRS。无论你怎么细化、分析、评论和优化需求，都不可能达到完美。但是，如果你牢记这些特性，你就会编写出更好的需求，生产出更好的产品。

高质量需求叙述的特性

　　我们如何从一些有问题的需求中分辨出好的软件需求？这一节将分别介绍需求叙述应体现的6个特性，下一节将从整体上介绍SRS文档应具备的特性。判断每个需求是否具备应有的特性的一种方式是由持有不同观点的工程资金管理人所作的正规检查。另一种有力的方法是在编写代码前依据需求编写测试例子。测试例子能够明确显现在需求中描述的产品行为（特性），能够显现缺陷、冗余和含糊之处。

　　正确：每个需求必须精确描述要交付的功能。正确性依据于需求的来源，如真实的客户或高级别的系统需求说明书。一个软件需求与其对应的系统需求说明书相抵触是不正确的（当然，系统需求说明书本身可能不正确）。

　　只有用户的代表能够决定用户需求的正确性，这就是为什么在检查需求时，要包括他们或他们的代理的关键所在。不包括用户的需求检查就会导致开发人员的：“这是没意义的”，“这可能是他们的意思”等众所周知的猜测。

　　可行性：在已知的能力、有限的系统及其环境中每个需求必须是可实现的。为了避免需求的不可行性，在需求分析阶段应该有一个开发人员参与，在抽象阶段应该有市场人员参与。这个开发人员应能检查在技术上什么能做什么不能做，哪些需要需要额外的付出或者和其他的权衡。

　　必要性：每个需求应载明什么是客户确实需要的，什么要顺应于外部的需求，接口或标准。每个需求源于你认可、具有权说明需求的原始资料，这是考虑必需的另外情形（译注，此句翻译不顺，请参照原文：Another way to think of “necessary” is that each requirement originated from a source you recognize as having the authority to specify requirements）。跟踪每个需求回溯到出处，如用例，系统需求，规章，或来自其他用户的意见。如果你不能标识出处，可能需求只是个镀金的例子，没有真正的必须。

　　优先权：为了表明在一个详细的产品版本中应包含哪些要点，需要为每个需求，特征，或用例分配实现的优先权。客户或其代理都应有强烈的责任建立优先权。如果所有的需求都被视为同等重要，那么由于在开发中，预算削减，计划超时或组员的离开导致新的需求时， 项目经理将不能起到作用。优先权的作用是提供给客户的价值，实现的相关费用，实现相关联的有关技术风险。

　　我是用3种级别的优先权：高优先权表明需求必须体现在下一个产品版本中，中优先权表明需求是必须的，但是如果需要可以推迟到晚一些的产品版本中，低优先权表明有它很好，但我们必须认识到如果没有充足的时间或资源，它可以被放弃掉。

　　明确：需求叙述的读者应只能从其得到唯一的解释说明，同样，一个需求的多个读者也应达成共识。自然语言极易导致含糊。要避免使用一些对于SRS作者很清楚但对于读者不清楚的主观词汇，如：用户友好性，容易，简单，快速，有效，几个，艺术级，改善的，最大，最小等等。每写一个需要都应简洁，简单，直观的采用用户熟知的语言，不要采用计算机术语。检查需求模糊的有效方式包括需求说明书的正规检查，根据需求写测试，建立用户的假想来说明产品某个特定部分预期的特性。

　　可证实：看你是否能够做出测试计划或其他验证方式，如检查和实证，来决定在产品中每个需求是否正确的实现。如果需求是不可验证的，决定需求是不是正确的实现就成了判断的事。需求之间不一致，不可行，不明确也能导致不可证实。任何需求如果说产品将要支持什么也是不可证实的。

高质量需求说明的特征

　　一个完整的SRS不仅是包括长长的功能性需求列表，还包括外部接口描述和一些诸如质量属性，期望性能的非功能性需求。下面描述了高质量的SRS的一些特性。

　　完整：不应该遗漏要求和必需的信息。完整性也是一个需求应具备的。发现缺少的信息很难，因为根本不存在。在SRS中将需求以分层目录方式组织，将帮助评审人员理解功能性描述的结构，使他们很容易指出遗失的东西。

　　在需求抽象时，相对于系统功能，你过多的注意用户的业务，将导致在需求的全局观和引进不是真正必需的需求上显得不足。在需求抽象上，应用用例方法会发挥很好的作用。能够从不同角度察看需求的图形分析模型也可以检查出不完整性。

　　如果你知道已缺少一些信息，使用TBD（to be determined）标准标志可以突出这些缺陷，当你在构建产品的相关部分时，就可以从一个给定的需求集中解决所有的缺陷。

　　一致性：一致性需求就是不要于其他的软件需求或高级别的系统（商业）需求发生冲突。需求中的不一致必须在开发开始前得到解决。只有经过调研才能确定哪些是正确的。修改需求时一定要谨慎，如果只审定修改的部分，没有审定于修改相关的部分，就可能导致不一致性。

　　可修改性：当每个需求的要求修改了或维护其历史更改时，你必须能够审定SRS。也就是说每个需求必须相对于其他需求有其单独的标示和分开的说明，便于清晰的查阅。通过良好的组织可以使需求易于修改，如：将相关的需求分组，建立目录表，索引，以及前后参考（照）。

　　可追踪：你应能将一个软件与其原始材料相对应，如高级系统需求，用例，用户的提议等。也能够将软件需求与设计元素，源代码，用于构造实现和验证需求的测试相对应。可追踪的需求应该具有独立标示，细密和结构化的编写，不应过大，不应是叙述性的文字和公告式的列表。 需求质量的评审

　　这些有关需求质量的特性的描述在理论上都是非常好的，但一个好的需求到底是个什么样子的呢？为了体现得更切合实际，我们做个小练习。下面有几个从实际的工程选出的需求，依据上面的质量标准，评估每个需求，看看有什么问题，然后用更好的方式重写。我将对每个例子都提出自己的分析和改进的建议。也欢迎你提出不同的见解。我所占优的只是我知道每个需求的出处。因为你我都不是真正的客户，我们只能猜测每个需求的意图。

　　例1．“产品应在不少于每60秒的正常周期内提供状态信息”
　　这个需求是不完整的：状态信息是什么，如何显示给用户。这个需求有几处含糊。我们在谈论产品的哪部分？状态信息间隔真的假定为不少于60秒？，甚者每10年显示一条新的状态信息也可以？也许它的意图是消息间隔不应超过60秒，那么1毫秒是不是太短？“每”这个词导致了不确定性。问题的后果，就是需求的不可证实。
弥补缺陷，重写需求的一种方法：

　　1、状态信息
　　1．1后台任务管理器因该以误差上下不超过10秒的60秒间隔，在用户界面的指定位置显示状态信息
　　1．2如果后台进程处理正常，那么应该显示任务已完成的百分数/比
　　1．3任务完成时，应显示相关的信息
　　　1．4后台任务出错应该显示错误信息
　　为了分别测试和追踪，我将其分成了多个需求。如果将几个需求串接在一节中，在构造和测试时就很容易漏掉一个。

　　例2．“产品应瞬间在显示和隐藏不可打印字符间切换”
　　计算机在瞬间不能做任何事，所以这个需求不切实可行。它的不完整性表现在没有声明触发状态切换的条件。软件要在某些条件下更改自己？或者用户为了模仿更改要做一些动作？而且，在文档中改变显示的范围是多大：选中的文本，整个的文档，或其他的？这也是个模糊的问题。不可打印字符合隐藏字符一样吗？或者是一些属性标志或一些控制字符？问题的后果，就是需求的不可证实。

　　象这样编写需求也许更好一些：“用户能够在一个由特定触发条件激活处于编辑的文档中在显示和隐藏所有HTML标记间切换”。现在就很清楚，不可打印字符是HTML标记。由于没有定义触发条件，需求对设计没有约束力。只有设计人员选定了触发条件后，你才能编写测试验证触发的正确操作。

　　例3．“HTML分析器可以产生HTML标记错误报告，帮助HTML入门者快速解决错误”。单词“快速”使其模糊，没　　有加进错误报告的定义也是其部完整。我不知道，你怎么验证这个需求。找一个自称为HTML的入门者，看看能不能根据错误报告快速解决错误？

　　试试这个：“HTML分析器可以产生一个错误报告，错误报告包含有在被分析文件中出错的HTML文本和行号以及错误的描述。如果没有错误，就不会产生错误报告”。现在我们知道了，什么会被加到出错报告中，但是出错报告是个什么样子，则留由设计人员决定。我们还指定了一个例外：如果没有发现错误，不产生错误报告。

　　例4．“如果可能，主管号码应通过联机校验，而不是通过主全体主管号码列表校验”。真感到绝望，什么是“如果可能”：如果技术上可行？如果主全体主管号码列表可以联机获得？要避免象“应该”的这类不确切的词。客户是需要这个功能性还是不需要。我曾看过一些需求说明书，采用诸如：应，将，应该/将要等一些词描述优先级的细微差别。但我更喜欢用“应”清楚的说明需求的意图，指明优先级。这是修改后的：系统应校验输入的主管号码而不通过联机的主全体主官号码列表。如果在列表中没有发现主管号码，将会显示一条错误信息，也不接受指令。

　　在理解各个已完成的糟糕需求上，开发人员将会遇到的难题是：开发人员与客户将会在审核需求，未达成共识前发生激烈的争论。详细检查大的需求文档不是一件轻松的事情。我清楚有人做过，而且他们花在检查上的每一分钟都是值得的。相对于开发阶段和用户的抱怨电话，在这个阶段修补缺陷是便宜的，

编写质量需求的方针

　　编写优秀的需求是没有公式化的方法的。这需要大量的经验，要从你在过去的文档中发现的问题学习。请在组织软件需求文档时，严格遵从这些方针。

　　句子和段落要短。采用主动语气。使用正确的语法，拼写，标点。使用术语，要保持一致性，并在术语表或数据字典中定义它们

　　要看需求是否被有效的定义，可以以开发人员的观点看看。在内心将“当你们做完了找我”这句加到文档尾部，看看能不能是你紧张起来。换句话说，你是否需要SRS的编写者的额外解释帮助开发人员很好的理解需求，以便于设计和实现？如果是的话，在继续工作前，需求还需要细化。

　　需求编写者还要努力正确地把握细化程度。要避免包含多个需求的长的叙述段落。有帮助的提示是编写独立的可测试的需求。如果你认为一小部分测试可以验证一个需求的正确，那么它已经正确的细化了。如果你预想到多种不同类的测试，几个需求可能已挤到了一起，需要拆分开。

　　密切关注多个需求合成了单个需求。一个需求中的连接词“和”/“或”建议几个需求合并。不要在一个需求中使用“和”/“或”。

　　通篇文档细节上要保持一致。我曾看见过多个需求说明书前后不一致。如：“对于红色合法的颜色代码应是R”及“对于绿色合法的颜色代码应是G”就有可以以分散的需求分离开，而“产品应能对来自语音编辑指示做出反应”应作为一个子系统，不应作为单个的功能性需求。

　　避免在SRS中过多的申述需求。在多处包含相同的需求可以使文档更易于阅读，但也会给文档的维护增加困难。文档的多份文本要在同一时间内全部更新，避免不一致性。

　　如果你遵从了这些方针，你能够尽早地经常正式或非正式的审查需求，这些需求对于产品的构造，系统测试以及最后的客户满意，都会成为好的奠基石。并且要记住，没有高质量的需求，软件就象一盒巧克力，你永远不知道你会得到什么。