玻璃杯中的花生壳 http://blogger.org.cn/blog/blog.asp?name=littcricket 玻璃杯中的花生壳的博客 blogger.org.cn W3CHINA Blog webmaster@blogger.org.cn <![CDATA[Java开发者的十大戒律]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=30041 littcricket 2007/11/27 18:26:08 　有许多标准和实践准则可适用于Java开发者，但此处要说的，是每个Java开发者需坚守的基本原则。

　　一、为代码加注释。虽然每个人都知道这点，但有时却不自觉忘了履行，今天你“忘了”加注释了吗?虽然注释对 程序的功能没什么“贡献”，但过一段时间，比如说两星期之后或者更长，回过头来看看自己的代码，说不定已经记不住它是干什么的了。如果这些代码是你个人 的，那还算是走运了，不幸的是，当然了，大多数时候都是别人的不幸，很多时候大家都是在为公司写代码，写代码的人也许早已经离开了公司，但别忘了一句古 话，有来有往嘛，为他人，也为我们自己，请为你的代码加上注释。

　　二、不要让事情复杂化。程序员有时候总是对简单问题想出复杂的解决方案，比如说，在只有五个用户的程序中引 入EJB、对程序实现了并不需要的框架(framework)，之类的还有属性文件、面向对象解决方案、多线程等等。为什么要这样做呢?也许我们并不知道 是否这样会更好，但这样做也许可以学到一些新东西，或者让自己更感兴趣一些。如果是不知道为什么这样做，建议多请教经验丰富的程序员，如果是为了个人的目 的，麻烦让自己更专业一点。

　　三、始终牢记——“少即是好(Less is more)并不总是对的”。代码效率虽然很重要，但在许多解决方案中，编写更少的代码并不能改善这些代码的效率，请看下面这个简单的例子：

      if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)>0)) ||
(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)<0))){
newStatusCode = "NYP";
}

　　能看明白if条件语句是干什么的吗?能想出来是谁写的这段代码吗?如果把它分成两段独立的if语句，是不是更容易理解呢，下面是修改后的代码：

      if(newStatusCode.equals("SD") && (sellOffDate == null ||
todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null &&
todayDate.compareTo(lastUsedDate)>0))){
newStatusCode = "NYP";
}else
if(newStatusCode.equals("OBS") && (OBSDate == null ||
todayDate.compareTo(OBSDate)<0))
{
newStatusCode = "NYP";
}

　　是不是读起来容易多了呢，在此只是多加了一个if和两个花括号，但代码的可读性与可理解性就一下子提高了一大截。

　　四、请不要硬编码。开发者经常有意“忘记”或忽略掉这点，因为有些时候开发日程逼得实在太紧。其实，多写一行定义静态变量的代码能花多少时间呢?

      public class A {
public static final String S_CONSTANT_ABC = "ABC";
public boolean methodA(String sParam1){
if (A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){
return true;
}
return false;
}
}

　　现在，每次需要将“ABC”与其他变量进行比较时，不必记住实际代码，直接引用A.S_CONSTANT_ABC就行了，而且在今后需要进行修改时，也可在一处修改，不会翻遍整个源代码逐个修改了。

　　五、不要“创造”自己的框架(framework)。确切来说，有数以千计的各种框架存在，而且大多数是开 源的，这些框架都是优秀的解决方案，可用于日常程序开发中，我们只需使用这些框架的最新版本就行了，至少表面上要跟上形势吧。被大家广为接受的最为明显的 一个例子就是Struts了，这个开源web框架非常适合用在基于web的应用程序中。是不是想开发出自己的Struts呢，还是省点力气吧，回头看看第 二条——不要让事情复杂化。另外，如果正在开发的程序只有3个窗口，就不要使用Struts了，对这种程序来说，不需要那么多的“控制”。

　　六、不要使用println及字符串连接。通常为了调试方便，开发者喜欢在可能的所有地方都加上 System.out.println，也许还会提醒自己回过头来再来删除，但有些时候，经常会忘了删除或者不愿意删除它们。既然使用 System.out.println是为了测试，那么测试完之后，为什么还要留着它们呢，因为在删除时，很可能会删除掉真正有用的代码，所以不能低估 System.out.println危害啊，请看下面的代码：

      public class BadCode {
public static void calculationWithPrint(){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
System.out.println(someValue = someValue + i);
}
}
public static void calculationWithOutPrint(){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
someValue = someValue + i;
}
}
public static void main(String [] n) {
BadCode.calculationWithPrint();
BadCode.calculationWithOutPrint();
}
}

　　从测试中可以发现，方法calculationWithOutPrint()执行用了0.001204秒，作为对比，方法calculationWithPrint()执行可是用了10.52秒。

　　要避免浪费CPU时间，最好的方法是引入像如下的包装方法：

      public class BadCode {
public static final int DEBUG_MODE = 1;
public static final int PRODUCTION_MODE = 2;
public static void calculationWithPrint(int logMode){
double someValue = 0D;
for (int i = 0; i < 10000; i++) {
someValue = someValue + i;
myPrintMethod(logMode, someValue);
}
}
public static void myPrintMethod(int logMode, double value) {
if (logMode > BadCode.DEBUG_MODE) { return; }
System.out.println(value);
}
public static void main(String [] n) {
BadCode.calculationWithPrint(BadCode.PRODUCTION_MODE);
}
}

　　另外，字符串连接也是浪费CPU时间的一个大头，请看下面的示例代码：

      public static void concatenateStrings(String startingString) {
for (int i = 0; i < 20; i++) {
startingString = startingString + startingString;
}
}
public static void concatenateStringsUsingStringBuffer(String startingString) {
StringBuffer sb = new StringBuffer();
sb.append(startingString);
for (int i = 0; i < 20; i++) {
sb.append(sb.toString());
}
}

　　在测试中可发现，使用StringBuffer的方法只用了0.01秒执行完毕，而使用连接的方法则用了0.08秒，选择显而易见了。

　　七、多关注GUI(用户界面)。再三强调，GUI对商业客户来说，与程序的功能及效率同等重要，GUI是一 个成功程序的最基本部分，而很多IT经理往往都没注意到GUI的重要性。在现实生活中，许多公司可能为了节省开支，没有雇用那些有着设计“用户友好”界面 丰富经验的网页设计者，此时Java开发者只能依赖他们自身的HTML基本功及在此领域有限的知识，结果，很多开发出来的程序都是“计算机友好”甚于“用 户友好”。很少有开发者同时精通软件开发及GUI设计，如果你在公司“不幸”被分配负责程序界面，就应该遵守下面三条原则：

　　1、 不要再发明一次轮子，即不做无用功。现有的程序可能会有类似的界面需求。

　　2、 先创建一个原型。这是非常重要一步，用户一般想看到他们将使用的东西，而且可以先利用这个原型征求用户的意见，再慢慢修改成用户想要的样子。

　　3、 学会换位思考。换句话来说，就是从用户的角度来审查程序的需求。举例来讲，一个汇总的窗口可以跨页或者不跨页，作为一个软件开发者，可能会倾向于不跨页，因为这样简单一些。但是，从用户的角度来看，可能不希望看到上百行数据都挤在同一页上。

　　八、文档需求不放松。每个商业需求都必须记录在案，这可能听上去像童话，似乎在现实生活中很难实现。而我们要做的是，不管开发时间多紧迫，不管最终期限多临近，对每个商业需求都必须记录在案。

　　九、单元测试、单元测试、单元测试。关于什么是单元测试的最好方法，在此不便细说，只是强调，单元测试一定要完成，这也是编程中最基本的原则。当然了，如果有人帮你做单元测试自然是最好，如果没有，就自己来做吧，当创建一个单元测试计划时，请遵守以下三条最基本的原则：

　　1、 先于编写类代码之前编写单元测试。

　　2、 记录单元测试中的代码注释。

　　3、 测试所有执行关键功能的公有方法，这里不是指set和get方法，除非它们是以自己独特方式执行set和get方法。

　　十、质量，而不是数量。有些时候因为产品问题、期限紧迫、或一些预料之外的事情，导致常常不能按时下班，但一般而言，公司不会因为雇员经常加班而对之表扬和奖励，公司只看重高质量的工作。如果遵守了前九条原则，你会发现自己写出的代码bug少且可维护性高，无形中质量提高了一大步。

]]> <![CDATA[配置Spring数据源]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=27916 littcricket 2007/9/7 9:41:12 　不管通过何种持久化技术，都必须通过数据连接访问数据库，在Spring中，数据连接是通过数据源获得的。在以往的应用中，数据源一般是Web应用服务器提供的。在Spring中，你不但可以通过JNDI获取应用服务器的数据源，也可以直接在Spring容器中配置数据源，此外，你还可以通过代码的方式创建一个数据源，以便进行无依赖的单元测试

配置一个数据源
    Spring在第三方依赖包中包含了两个数据源的实现类包，其一是Apache的DBCP，其二是 C3P0。可以在Spring配置文件中利用这两者中任何一个配置数据源。

 DBCP数据源
    DBCP类包位于 /lib/jakarta-commons/commons-dbcp.jar，DBCP是一个依赖 Jakarta commons-pool对象池机制的数据库连接池，所以在类路径下还必须包括/lib/jakarta- commons/commons-pool.jar。下面是使用DBCP配置MySql数据源的配置片断：

xml 代码
  1. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"       
  2.         destroy-method="close">       
  3.     <property name="driverClassName" value="com.mysql.jdbc.Driver" />      
  4.     <property name="url" value="jdbc:mysql://localhost:3309/sampledb" />      
  5.     <property name="username" value="root" />      
  6.     <property name="password" value="1234" />      
  7. </bean>  

BasicDataSource提供了close()方法关闭数据源，所以必须设定destroy-method=”close”属性， 以便Spring容器关闭时，数据源能够正常关闭。除以上必须的数据源属性外，还有一些常用的属性：
    defaultAutoCommit：设置从数据源中返回的连接是否采用自动提交机制，默认值为 true；
    defaultReadOnly：设置数据源是否仅能执行只读操作， 默认值为 false；
    maxActive：最大连接数据库连接数，设置为0时，表示没有限制；
    maxIdle：最大等待连接中的数量，设置为0时，表示没有限制；
    maxWait：最大等待秒数，单位为毫秒， 超过时间会报出错误信息；
    validationQuery：用于验证连接是否成功的查询SQL语句，SQL语句必须至少要返回一行数据， 如你可以简单地设置为：“select count(*) from user”；
    removeAbandoned：是否自我中断，默认是 false ；
    removeAbandonedTimeout：几秒后数据连接会自动断开，在removeAbandoned为true，提供该值；
    logAbandoned：是否记录中断事件， 默认为 false；

C3P0数据源
    C3P0是一个开放源代码的JDBC数据源实现项目，它在lib目录中与Hibernate一起发布，实现了JDBC3和JDBC2扩展规范说明的 Connection 和Statement 池。C3P0类包位于/lib/c3p0/c3p0-0.9.0.4.jar。下面是使用C3P0配置一个 Oracle数据源：

xml 代码
  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"       
  2.         destroy-method="close">      
  3.     <property name="driverClass" value=" oracle.jdbc.driver.OracleDriver "/>      
  4.     <property name="jdbcUrl" value=" jdbc:oracle:thin:@localhost:1521:ora9i "/>      
  5.     <property name="user" value="admin"/>      
  6.     <property name="password" value="1234"/>      
  7. </bean>  

ComboPooledDataSource和BasicDataSource一样提供了一个用于关闭数据源的close()方法，这样我们就可以保证Spring容器关闭时数据源能够成功释放。
    C3P0拥有比DBCP更丰富的配置属性，通过这些属性，可以对数据源进行各种有效的控制：
    acquireIncrement：当连接池中的连接用完时，C3P0一次性创建新连接的数目；
    acquireRetryAttempts：定义在从数据库获取新连接失败后重复尝试获取的次数，默认为30；
    acquireRetryDelay：两次连接中间隔时间，单位毫秒，默认为1000；
    autoCommitOnClose：连接关闭时默认将所有未提交的操作回滚。默认为false；
    automaticTestTable： C3P0将建一张名为Test的空表，并使用其自带的查询语句进行测试。如果定义了这个参数，那么属性preferredTestQuery将被忽略。你 不能在这张Test表上进行任何操作，它将中为C3P0测试所用，默认为null；
    breakAfterAcquireFailure：获取连接失败将会引起所有等待获取连接的线程抛出异常。但是数据源仍有效保留，并在下次调   用getConnection()的时候继续尝试获取连接。如果设为true，那么在尝试获取连接失败后该数据源将申明已断开并永久关闭。默认为 false；
    checkoutTimeout：当连接池用完时客户端调用getConnection()后等待获取新连接的时间，超时后将抛出SQLException，如设为0则无限期等待。单位毫秒，默认为0；
    connectionTesterClassName： 通过实现ConnectionTester或QueryConnectionTester的类来测试连接，类名需设置为全限定名。默认为 com.mchange.v2.C3P0.impl.DefaultConnectionTester； 
    idleConnectionTestPeriod：隔多少秒检查所有连接池中的空闲连接，默认为0表示不检查；
    initialPoolSize：初始化时创建的连接数，应在minPoolSize与maxPoolSize之间取值。默认为3；
    maxIdleTime：最大空闲时间，超过空闲时间的连接将被丢弃。为0或负数则永不丢弃。默认为0；
    maxPoolSize：连接池中保留的最大连接数。默认为15；
    maxStatements：JDBC的标准参数，用以控制数据源内加载的PreparedStatement数量。但由于预缓存的Statement属 于单个Connection而不是整个连接池。所以设置这个参数需要考虑到多方面的因素，如果maxStatements与 maxStatementsPerConnection均为0，则缓存被关闭。默认为0；
    maxStatementsPerConnection：连接池内单个连接所拥有的最大缓存Statement数。默认为0；
    numHelperThreads：C3P0是异步操作的，缓慢的JDBC操作通过帮助进程完成。扩展这些操作可以有效的提升性能，通过多线程实现多个操作同时被执行。默认为3；
    preferredTestQuery：定义所有连接测试都执行的测试语句。在使用连接测试的情况下这个参数能显著提高测试速度。测试的表必须在初始数据源的时候就存在。默认为null；
    propertyCycle： 用户修改系统配置参数执行前最多等待的秒数。默认为300；
    testConnectionOnCheckout：因性能消耗大请只在需要的时候使用它。如果设为true那么在每个connection提交的时候都 将校验其有效性。建议使用idleConnectionTestPeriod或automaticTestTable
等方法来提升连接测试的性能。默认为false；
    testConnectionOnCheckin：如果设为true那么在取得连接的同时将校验连接的有效性。默认为false。

读配置文件的方式引用属性：

  1. <bean id="propertyConfigurer"     
  2.         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">      
  3.     <property name="location" value="/WEB-INF/jdbc.properties"/>      
  4. </bean>      
  5. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"       
  6.         destroy-method="close">      
  7.     <property name="driverClassName" value="${jdbc.driverClassName}" />      
  8.     <property name="url" value="${jdbc.url}" />      
  9.     <property name="username" value="${jdbc.username}" />      
  10.     <property name="password" value="${jdbc.password}" />      
  11. </bean>   

    在jdbc.properties属性文件中定义属性值：
    jdbc.driverClassName= com.mysql.jdbc.Driver
    jdbc.url= jdbc:mysql://localhost:3309/sampledb
    jdbc.username=root
    jdbc.password=1234
    提示 经常有开发者在${xxx}的前后不小心键入一些空格，这些空格字符将和变量合并后作为属性的值。如： 的属性配置项，在前后都有空格，被解析后，username的值为“ 1234 ”，这将造成最终的错误，因此需要特别小心。

 获取JNDI数据源
    如果应用配置在高性能的应用服务器（如WebLogic或Websphere等）上，我们可能更希望使用应用服务器本身提供的数据源。应用服务器的数据源 使用JNDI开放调用者使用，Spring为此专门提供引用JNDI资源的JndiObjectFactoryBean类。下面是一个简单的配置：

xml 代码
  1. <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">      
  2.     <property name="jndiName" value="java:comp/env/jdbc/bbt"/>      
  3. </bean>  

通过jndiName指定引用的JNDI数据源名称。
    Spring 2.0为获取J2EE资源提供了一个jee命名空间，通过jee命名空间，可以有效地简化J2EE资源的引用。下面是使用jee命名空间引用JNDI数据源的配置：

xml 代码
  1. <beans xmlns=http://www.springframework.org/schema/beans    
  2. xmlns:xsi=http://www.w3.org/2001/XMLSchema-instance    
  3. xmlns:jee=http://www.springframework.org/schema/jee    
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans     
  5. http://www.springframework.org/schema/beans/spring-beans-2.0.xsd     
  6. http://www.springframework.org/schema/jee    
  7. http://www.springframework.org/schema/jee/spring-jee-2.0.xsd">      
  8. <jee:jndi-lookup id="dataSource" jndi-name=" java:comp/env/jdbc/bbt"/>      
  9. </beans>  

Spring的数据源实现类
    Spring本身也提供了一个简单的数据源实现类DriverManagerDataSource ，它位于org.springframework.jdbc.datasource包中。这个类实现了javax.sql.DataSource接口，但 它并没有提供池化连接的机制，每次调用getConnection()获取新连接时，只是简单地创建一个新的连接。因此，这个数据源类比较适合在单元测试 或简单的独立应用中使用，因为它不需要额外的依赖类。
     下面，我们来看一下DriverManagerDataSource的简单使用：当然，我们也可以通过配置的方式直接使用DriverManagerDataSource。

java 代码
  1. DriverManagerDataSource ds = new DriverManagerDataSource ();      
  2. ds.setDriverClassName("com.mysql.jdbc.Driver");      
  3. ds.setUrl("jdbc:mysql://localhost:3309/sampledb");      
  4. ds.setUsername("root");      
  5. ds.setPassword("1234");      
  6. Connection actualCon = ds.getConnection();  

 

小结

    不管采用何种持久化技术，都需要定义数据源。Spring附带了两个数据源的实现类包，你可以自行选择进行定义。在实际部署时，我们可能会直接采用应用服 务器本身提供的数据源，这时，则可以通过JndiObjectFactoryBean或jee命名空间引用JNDI中的数据源。

DBCP与C3PO配置的区别：

C3PO ：DBCP：

xml 代码
  1. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
  2.     <property name="driverClass">  
  3.         <value>oracle.jdbc.driver.OracleDriver</value>  
  4.     </property>  
  5.     <property name="jdbcUrl">             
  6.         <value>jdbc:oracle:thin:@10.10.10.6:1521:DataBaseName</value>  
  7.      </property>  
  8.     <property name="user">  
  9.         <value>testAdmin</value>  
  10.     </property>  
  11.     <property name="password">  
  12.         <value>123456</value>  
  13.     </property>  
  14. </bean>  

 

xml 代码
  1. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  2.     <property name="driverClassName">  
  3.         <value>oracle.jdbc.driver.OracleDriver</value>  
  4.     </property>  
  5.     <property name="url">             
  6.         <value>jdbc:oracle:thin:@10.10.10.6:1521:DataBaseName</value>  
  7.      </property>  
  8.     <property name="username">  
  9.         <value>testAdmin</value>  
  10.     </property>  
  11.     <property name="password">  
  12.         <value>123456</value>  
  13.     </property>  
  14. </bean>  
]]> <![CDATA[java多线程设计模式]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=27828 littcricket 2007/9/3 14:31:14 线程的创建和启动

java语言已经内置了多线程支持，所有实现Runnable接口的类都可被启动一个新线程，新线程会执行该实例的run()方法，当run()方法执行完毕后，线程就结束了。一旦一个线程执行完毕，这个实例就不能再重新启动，只能重新生成一个新实例，再启动一个新线程。

Thread类是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法：

Thread t = new Thread();
t.start();

start()方法是一个native方法，它将启动一个新线程，并执行run()方法。Thread类默认的run()方法什么也不做就退出了。注意：直接调用run()方法并不会启动一个新线程，它和调用一个普通的java方法没有什么区别。

因此，有两个方法可以实现自己的线程：

方法1：自己的类extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：

public class MyThread extends Thread {
    public run() {
        System.out.println("MyThread.run()");
    }
}

在合适的地方启动线程：new MyThread().start();

方法2：如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口：

public class MyThread extends OtherClass implements Runnable {
    public run() {
        System.out.println("MyThread.run()");
    }
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：

MyThread myt = new MyThread();
Thread t = new Thread(myt);
t.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：

public void run() {
    if (target != null) {
        target.run();
    }
}

线程还有一些Name, ThreadGroup, isDaemon等设置，由于和线程设计模式关联很少，这里就不多说了。

线程的同步

由于同一进程内的多个线程共享内存空间，在Java中，就是共享实例，当多个线程试图同时修改某个实例的内容时，就会造成冲突，因此，线程必须实现共享互斥，使多线程同步。

最简单的同步是将一个方法标记为synchronized，对同一个实例来说，任一时刻只能有一个synchronized方法在执行。当一个方法正在执行某个synchronized方法时，其他线程如果想要执行这个实例的任意一个synchronized方法，都必须等待当前执行synchronized方法的线程退出此方法后，才能依次执行。

但是，非synchronized方法不受影响，不管当前有没有执行synchronized方法，非synchronized方法都可以被多个线程同时执行。

此外，必须注意，只有同一实例的synchronized方法同一时间只能被一个线程执行，不同实例的synchronized方法是可以并发的。例如，class A定义了synchronized方法sync()，则不同实例a1.sync()和a2.sync()可以同时由两个线程来执行。


Java锁机制

多线程同步的实现最终依赖锁机制。我们可以想象某一共享资源是一间屋子，每个人都是一个线程。当A希望进入房间时，他必须获得门锁，一旦A获得门锁，他进去后就立刻将门锁上，于是B,C,D...就不得不在门外等待，直到A释放锁出来后，B,C,D...中的某一人抢到了该锁（具体抢法依赖于JVM的实现，可以先到先得，也可以随机挑选），然后进屋又将门锁上。这样，任一时刻最多有一人在屋内（使用共享资源）。

Java语言规范内置了对多线程的支持。对于Java程序来说，每一个对象实例都有一把“锁”，一旦某个线程获得了该锁，别的线程如果希望获得该锁，只能等待这个线程释放锁之后。获得锁的方法只有一个，就是synchronized关键字。例如：

public class SharedResource {
    private int count = 0;

    public int getCount() { return count; }

    public synchronized void setCount(int count) { this.count = count; }

}

同步方法public synchronized void setCount(int count) { this.count = count; } 事实上相当于：

public void setCount(int count) {
    synchronized(this) { // 在此获得this锁
         this.count = count;
    } // 在此释放this锁
}

红色部分表示需要同步的代码段，该区域为“危险区域”，如果两个以上的线程同时执行，会引发冲突，因此，要更改SharedResource的内部状态，必须先获得SharedResource实例的锁。

退出synchronized块时，线程拥有的锁自动释放，于是，别的线程又可以获取该锁了。

为了提高性能，不一定要锁定this，例如，SharedResource有两个独立变化的变量：

public class SharedResouce {
    private int a = 0;
    private int b = 0;

    public synchronized void setA(int a) { this.a = a; }

    public synchronized void setB(int b) { this.b = b; }
}

若同步整个方法，则setA()的时候无法setB()，setB()时无法setA()。为了提高性能，可以使用不同对象的锁：

public class SharedResouce {
    private int a = 0;
    private int b = 0;
    private Object sync_a = new Object();
    private Object sync_b = new Object();

    public void setA(int a) {
        synchronized(sync_a) {
            this.a = a;
        }
    }

    public synchronized void setB(int b) {
        synchronized(sync_b) {
            this.b = b;
        }
    }
}

wait/notify机制

通常，多线程之间需要协调工作。例如，浏览器的一个显示图片的线程displayThread想要执行显示图片的任务，必须等待下载线程downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。

以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如：

synchronized(obj) {
    while(!condition) {
        obj.wait();
    }
    obj.doSomething();
}

当线程A获得了obj锁后，发现条件condition不满足，无法继续下一处理，于是线程A就wait()。

在另一线程B中，如果B更改了某些条件，使得线程A的condition条件满足了，就可以唤醒线程A：

synchronized(obj) {
    condition = true;
    obj.notify();
}

需要注意的概念是：

# 调用obj的wait(), notify()方法前，必须获得obj锁，也就是必须写在synchronized(obj) {...} 代码段内。

# 调用obj.wait()后，线程A就释放了obj的锁，否则线程B无法获得obj锁，也就无法在synchronized(obj) {...} 代码段内唤醒A。

# 当obj.wait()方法返回后，线程A需要再次获得obj锁，才能继续执行。

# 如果A1,A2,A3都在obj.wait()，则B调用obj.notify()只能唤醒A1,A2,A3中的一个（具体哪一个由JVM决定）。

# obj.notifyAll()则能全部唤醒A1,A2,A3，但是要继续执行obj.wait()的下一条语句，必须获得obj锁，因此，A1,A2,A3只有一个有机会获得锁继续执行，例如A1，其余的需要等待A1释放obj锁之后才能继续执行。

# 当B调用obj.notify/notifyAll的时候，B正持有obj锁，因此，A1,A2,A3虽被唤醒，但是仍无法获得obj锁。直到B退出synchronized块，释放obj锁后，A1,A2,A3中的一个才有机会获得锁继续执行。

wait/sleep的区别

前面讲了wait/notify机制，Thread还有一个sleep()静态方法，它也能使线程暂停一段时间。sleep与wait的不同点是：sleep并不释放锁，并且sleep的暂停和wait暂停是不一样的。obj.wait会使线程进入obj对象的等待集合中并等待唤醒。

但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException。

如果线程A希望立即结束线程B，则可以对线程B对应的Thread实例调用interrupt方法。如果此刻线程B正在wait/sleep/join，则线程B会立刻抛出InterruptedException，在catch() {} 中直接return即可安全地结束线程。

需要注意的是，InterruptedException是线程自己从内部抛出的，并不是interrupt()方法抛出的。对某一线程调用interrupt()时，如果该线程正在执行普通的代码，那么该线程根本就不会抛出InterruptedException。但是，一旦该线程进入到wait()/sleep()/join()后，就会立刻抛出InterruptedException。

java多线程设计模式(6) GuardedSuspention

GuardedSuspention模式主要思想是：

当条件不满足时，线程等待，直到条件满足时，等待该条件的线程被唤醒。

我们设计一个客户端线程和一个服务器线程，客户端线程不断发送请求给服务器线程，服务器线程不断处理请求。当请求队列为空时，服务器线程就必须等待，直到客户端发送了请求。

先定义一个请求队列：Queue

package com.crackj2ee.thread;

import java.util.*;

public class Queue {
    private List queue = new LinkedList();

    public synchronized Request getRequest() {
        while(queue.size()==0) {
            try {
                this.wait();
            }
            catch(InterruptedException ie) {
                return null;
            }
        }
        return (Request)queue.remove(0);
    }

    public synchronized void putRequest(Request request) {
        queue.add(request);
        this.notifyAll();
    }

}

蓝色部分就是服务器线程的等待条件，而客户端线程在放入了一个request后，就使服务器线程等待条件满足，于是唤醒服务器线程。

客户端线程：ClientThread

package com.crackj2ee.thread;

public class ClientThread extends Thread {
    private Queue queue;
    private String clientName;

    public ClientThread(Queue queue, String clientName) {
        this.queue = queue;
        this.clientName = clientName;
    }

    public String toString() {
        return "[ClientThread-" + clientName + "]";
    }

    public void run() {
        for(int i=0; i<100; i++) {
            Request request = new Request("" + (long)(Math.random()*10000));
            System.out.println(this + " send request: " + request);
            queue.putRequest(request);
            try {
                Thread.sleep((long)(Math.random() * 10000 + 1000));
            }
            catch(InterruptedException ie) {
            }
        }
        System.out.println(this + " shutdown.");
    }
}

服务器线程：ServerThread

package com.crackj2ee.thread;
public class ServerThread extends Thread {
    private boolean stop = false;
    private Queue queue;

    public ServerThread(Queue queue) {
        this.queue = queue;
    }

    public void shutdown() {
        stop = true;
        this.interrupt();
        try {
            this.join();
        }
        catch(InterruptedException ie) {}
    }

    public void run() {
        while(!stop) {
            Request request = queue.getRequest();
            System.out.println("[ServerThread] handle request: " + request);
            try {
                Thread.sleep(2000);
            }
            catch(InterruptedException ie) {}
        }
        System.out.println("[ServerThread] shutdown.");
    }
}

服务器线程在红色部分可能会阻塞，也就是说，Queue.getRequest是一个阻塞方法。这和java标准库的许多IO方法类似。

最后，写一个Main来启动他们：

package com.crackj2ee.thread;

public class Main {

    public static void main(String[] args) {
        Queue queue = new Queue();
        ServerThread server = new ServerThread(queue);
        server.start();
        ClientThread[] clients = new ClientThread[5];
        for(int i=0; i<clients.length; i++) {
            clients[i] = new ClientThread(queue, ""+i);
            clients[i].start();
        }
        try {
            Thread.sleep(100000);
        }
        catch(InterruptedException ie) {}
        server.shutdown();
    }
}

我们启动了5个客户端线程和一个服务器线程，运行结果如下：

[ClientThread-0] send request: Request-4984
[ServerThread] handle request: Request-4984
[ClientThread-1] send request: Request-2020
[ClientThread-2] send request: Request-8980
[ClientThread-3] send request: Request-5044
[ClientThread-4] send request: Request-548
[ClientThread-4] send request: Request-6832
[ServerThread] handle request: Request-2020
[ServerThread] handle request: Request-8980
[ServerThread] handle request: Request-5044
[ServerThread] handle request: Request-548
[ClientThread-4] send request: Request-1681
[ClientThread-0] send request: Request-7859
[ClientThread-3] send request: Request-3926
[ServerThread] handle request: Request-6832
[ClientThread-2] send request: Request-9906
......

可以观察到ServerThread处理来自不同客户端的请求。

思考

Q: 服务器线程的wait条件while(queue.size()==0)能否换成if(queue.size()==0)?

A: 在这个例子中可以，因为服务器线程只有一个。但是，如果服务器线程有多个（例如Web应用程序有多个线程处理并发请求，这非常普遍），就会造成严重问题。

Q: 能否用sleep(1000)代替wait()?

A: 绝对不可以。sleep()不会释放锁，因此sleep期间别的线程根本没有办法调用getRequest()和putRequest()，导致所有相关线程都被阻塞。

Q: (Request)queue.remove(0)可以放到synchronized() {}块外面吗？

A: 不可以。因为while()是测试queue，remove()是使用queue，两者是一个原子操作，不能放在synchronized外面。

总结

多线程设计看似简单，实际上必须非常仔细地考虑各种锁定/同步的条件，稍不小心，就可能出错。并且，当线程较少时，很可能发现不了问题，一旦问题出现又难以调试。

所幸的是，已有一些被验证过的模式可以供我们使用，我们会继续介绍一些常用的多线程设计模式。


java多线程设计模式(7) Worker Pattern


 

前面谈了多线程应用程序能极大地改善用户相应。例如对于一个Web应用程序，每当一个用户请求服务器连接时，服务器就可以启动一个新线程为用户服务。

然而，创建和销毁线程本身就有一定的开销，如果频繁创建和销毁线程，CPU和内存开销就不可忽略，垃圾收集器还必须负担更多的工作。因此，线程池就是为了避免频繁创建和销毁线程。

每当服务器接受了一个新的请求后，服务器就从线程池中挑选一个等待的线程并执行请求处理。处理完毕后，线程并不结束，而是转为阻塞状态再次被放入线程池中。这样就避免了频繁创建和销毁线程。

Worker Pattern实现了类似线程池的功能。首先定义Task接口：

package com.crackj2ee.thread;
public interface Task {
    void execute();
}

线程将负责执行execute()方法。注意到任务是由子类通过实现execute()方法实现的，线程本身并不知道自己执行的任务。它只负责运行一个耗时的execute()方法。

具体任务由子类实现，我们定义了一个CalculateTask和一个TimerTask：

// CalculateTask.java
package com.crackj2ee.thread;
public class CalculateTask implements Task {
    private static int count = 0;
    private int num = count;
    public CalculateTask() {
        count++;
    }
    public void execute() {
        System.out.println("[CalculateTask " + num + "] start...");
        try {
            Thread.sleep(3000);
        }
        catch(InterruptedException ie) {}
        System.out.println("[CalculateTask " + num + "] done.");
    }
}

// TimerTask.java
package com.crackj2ee.thread;
public class TimerTask implements Task {
    private static int count = 0;
    private int num = count;
    public TimerTask() {
        count++;
    }
    public void execute() {
        System.out.println("[TimerTask " + num + "] start...");
        try {
            Thread.sleep(2000);
        }
        catch(InterruptedException ie) {}
        System.out.println("[TimerTask " + num + "] done.");
    }
}

以上任务均简单的sleep若干秒。

TaskQueue实现了一个队列，客户端可以将请求放入队列，服务器线程可以从队列中取出任务：

package com.crackj2ee.thread;
import java.util.*;
public class TaskQueue {
    private List queue = new LinkedList();
    public synchronized Task getTask() {
        while(queue.size()==0) {
            try {
                this.wait();
            }
            catch(InterruptedException ie) {
                return null;
            }
        }
        return (Task)queue.remove(0);
    }
    public synchronized void putTask(Task task) {
        queue.add(task);
        this.notifyAll();
    }
}

终于到了真正的WorkerThread，这是真正执行任务的服务器线程：

package com.crackj2ee.thread;
public class WorkerThread extends Thread {
    private static int count = 0;
    private boolean busy = false;
    private boolean stop = false;
    private TaskQueue queue;
    public WorkerThread(ThreadGroup group, TaskQueue queue) {
        super(group, "worker-" + count);
        count++;
        this.queue = queue;
    }
    public void shutdown() {
        stop = true;
        this.interrupt();
        try {
            this.join();
        }
        catch(InterruptedException ie) {}
    }
    public boolean isIdle() {
        return !busy;
    }
    public void run() {
        System.out.println(getName() + " start.");       
        while(!stop) {
            Task task = queue.getTask();
            if(task!=null) {
                busy = true;
                task.execute();
                busy = false;
            }
        }
        System.out.println(getName() + " end.");
    }
}

前面已经讲过，queue.getTask()是一个阻塞方法，服务器线程可能在此wait()一段时间。此外，WorkerThread还有一个shutdown方法，用于安全结束线程。

最后是ThreadPool，负责管理所有的服务器线程，还可以动态增加和减少线程数：

package com.crackj2ee.thread;
import java.util.*;
public class ThreadPool extends ThreadGroup {
    private List threads = new LinkedList();
    private TaskQueue queue;
    public ThreadPool(TaskQueue queue) {
        super("Thread-Pool");
        this.queue = queue;
    }
    public synchronized void addWorkerThread() {
        Thread t = new WorkerThread(this, queue);
        threads.add(t);
        t.start();
    }
    public synchronized void removeWorkerThread() {
        if(threads.size()>0) {
            WorkerThread t = (WorkerThread)threads.remove(0);
            t.shutdown();
        }
    }
    public synchronized void currentStatus() {
        System.out.println("-----------------------------------------------");
        System.out.println("Thread count = " + threads.size());
        Iterator it = threads.iterator();
        while(it.hasNext()) {
            WorkerThread t = (WorkerThread)it.next();
            System.out.println(t.getName() + ": " + (t.isIdle() ? "idle" : "busy"));
        }
        System.out.println("-----------------------------------------------");
    }
}

currentStatus()方法是为了方便调试，打印出所有线程的当前状态。

最后，Main负责完成main()方法：

package com.crackj2ee.thread;
public class Main {
    public static void main(String[] args) {
        TaskQueue queue = new TaskQueue();
        ThreadPool pool = new ThreadPool(queue);
        for(int i=0; i<10; i++) {
            queue.putTask(new CalculateTask());
            queue.putTask(new TimerTask());
        }
        pool.addWorkerThread();
        pool.addWorkerThread();
        doSleep(8000);
        pool.currentStatus();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        pool.addWorkerThread();
        doSleep(5000);
        pool.currentStatus();
    }
    private static void doSleep(long ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

main()一开始放入了20个Task，然后动态添加了一些服务线程，并定期打印线程状态，运行结果如下：

worker-0 start.
[CalculateTask 0] start...
worker-1 start.
[TimerTask 0] start...
[TimerTask 0] done.
[CalculateTask 1] start...
[CalculateTask 0] done.
[TimerTask 1] start...
[CalculateTask 1] done.
[CalculateTask 2] start...
[TimerTask 1] done.
[TimerTask 2] start...
[TimerTask 2] done.
[CalculateTask 3] start...
-----------------------------------------------
Thread count = 2
worker-0: busy
worker-1: busy
-----------------------------------------------
[CalculateTask 2] done.
[TimerTask 3] start...
worker-2 start.
[CalculateTask 4] start...
worker-3 start.
[TimerTask 4] start...
worker-4 start.
[CalculateTask 5] start...
worker-5 start.
[TimerTask 5] start...
worker-6 start.
[CalculateTask 6] start...
[CalculateTask 3] done.
[TimerTask 6] start...
[TimerTask 3] done.
[CalculateTask 7] start...
[TimerTask 4] done.
[TimerTask 7] start...
[TimerTask 5] done.
[CalculateTask 8] start...
[CalculateTask 4] done.
[TimerTask 8] start...
[CalculateTask 5] done.
[CalculateTask 9] start...
[CalculateTask 6] done.
[TimerTask 9] start...
[TimerTask 6] done.
[TimerTask 7] done.
-----------------------------------------------
Thread count = 7
worker-0: idle
worker-1: busy
worker-2: busy
worker-3: idle
worker-4: busy
worker-5: busy
worker-6: busy
-----------------------------------------------
[CalculateTask 7] done.
[CalculateTask 8] done.
[TimerTask 8] done.
[TimerTask 9] done.
[CalculateTask 9] done.

仔细观察：一开始只有两个服务器线程，因此线程状态都是忙，后来线程数增多，7个线程中的两个状态变成idle，说明处于wait()状态。

思考：本例的线程调度算法其实根本没有，因为这个应用是围绕TaskQueue设计的，不是以Thread Pool为中心设计的。因此，Task调度取决于TaskQueue的getTask()方法，你可以改进这个方法，例如使用优先队列，使优先级高的任务先被执行。

如果所有的服务器线程都处于busy状态，则说明任务繁忙，TaskQueue的队列越来越长，最终会导致服务器内存耗尽。因此，可以限制TaskQueue的等待任务数，超过最大长度就拒绝处理。许多Web服务器在用户请求繁忙时就会拒绝用户：HTTP 503 SERVICE UNAVAILABLE

java多线程设计模式(8) ReadWriteLock

多线程读写同一个对象的数据是很普遍的，通常，要避免读写冲突，必须保证任何时候仅有一个线程在写入，有线程正在读取的时候，写入操作就必须等待。简单说，就是要避免“写-写”冲突和“读-写”冲突。但是同时读是允许的，因为“读-读”不冲突，而且很安全。

要实现以上的ReadWriteLock，简单的使用synchronized就不行，我们必须自己设计一个ReadWriteLock类，在读之前，必须先获得“读锁”，写之前，必须先获得“写锁”。举例说明：

DataHandler对象保存了一个可读写的char[]数组：

package com.crackj2ee.thread;

public class DataHandler {
    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();

    private char[] doRead() {
        char[] ret = new char[buffer.length];
        for(int i=0; i<buffer.length; i++) {
            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }

    private void doWrite(char[] data) {
        if(data!=null) {
            buffer = new char[data.length];
            for(int i=0; i<buffer.length; i++) {
                buffer[i] = data[i];
                sleep(10);
            }
        }
    }

    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

doRead()和doWrite()方法是非线程安全的读写方法。为了演示，加入了sleep()，并设置读的速度大约是写的3倍，这符合通常的情况。

为了让多线程能安全读写，我们设计了一个ReadWriteLock：

package com.crackj2ee.thread;
public class ReadWriteLock {
    private int readingThreads = 0;
    private int writingThreads = 0;
    private int waitingThreads = 0; // waiting for write
    private boolean preferWrite = true;

    public synchronized void readLock() throws InterruptedException {
        while(writingThreads>0 || (preferWrite && waitingThreads>0))
            this.wait();
        readingThreads++;
    }

    public synchronized void readUnlock() {
        readingThreads--;
        preferWrite = true;
        notifyAll();
    }

    public synchronized void writeLock() throws InterruptedException {
        waitingThreads++;
        try {
            while(readingThreads>0 || writingThreads>0)
                this.wait();
        }
        finally {
            waitingThreads--;
        }
        writingThreads++;
    }

    public synchronized void writeUnlock() {
        writingThreads--;
        preferWrite = false;
        notifyAll();
    }
}

readLock()用于获得读锁，readUnlock()释放读锁，writeLock()和writeUnlock()一样。由于锁用完必须释放，因此，必须保证lock和unlock匹配。我们修改DataHandler，加入ReadWriteLock：

package com.crackj2ee.thread;
public class DataHandler {
    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();
    // lock:
    private ReadWriteLock lock = new ReadWriteLock();

    public char[] read(String name) throws InterruptedException {
        System.out.println(name + " waiting for read...");
        lock.readLock();
        try {
            char[] data = doRead();
            System.out.println(name + " reads data: " + new String(data));
            return data;
        }
        finally {
            lock.readUnlock();
        }
    }

    public void write(String name, char[] data) throws InterruptedException {
        System.out.println(name + " waiting for write...");
        lock.writeLock();
        try {
            System.out.println(name + " wrote data: " + new String(data));
            doWrite(data);
        }
        finally {
            lock.writeUnlock();
        }
    }

    private char[] doRead() {
        char[] ret = new char[buffer.length];
        for(int i=0; i<buffer.length; i++) {
            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }
    private void doWrite(char[] data) {
        if(data!=null) {
            buffer = new char[data.length];
            for(int i=0; i<buffer.length; i++) {
                buffer[i] = data[i];
                sleep(10);
            }
        }
    }
    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

public方法read()和write()完全封装了底层的ReadWriteLock，因此，多线程可以安全地调用这两个方法：

// ReadingThread不断读取数据：
package com.crackj2ee.thread;
public class ReadingThread extends Thread {
    private DataHandler handler;
    public ReadingThread(DataHandler handler) {
        this.handler = handler;
    }
    public void run() {
        for(;;) {
            try {
                char[] data = handler.read(getName());
                Thread.sleep((long)(Math.random()*1000+100));
            }
            catch(InterruptedException ie) {
                break;
            }
        }
    }
}

// WritingThread不断写入数据，每次写入的都是10个相同的字符：
package com.crackj2ee.thread;
public class WritingThread extends Thread {
    private DataHandler handler;
    public WritingThread(DataHandler handler) {
        this.handler = handler;
    }
    public void run() {
        char[] data = new char[10];
        for(;;) {
            try {
                fill(data);
                handler.write(getName(), data);
                Thread.sleep((long)(Math.random()*1000+100));
            }
            catch(InterruptedException ie) {
                break;
            }
        }
    }
    // 产生一个A-Z随机字符，填入char[10]:
    private void fill(char[] data) {
        char c = (char)(Math.random()*26+'A');
        for(int i=0; i<data.length; i++)
            data[i] = c;
    }
}

最后Main负责启动这些线程：

package com.crackj2ee.thread;
public class Main {
    public static void main(String[] args) {
        DataHandler handler = new DataHandler();
        Thread[] ts = new Thread[] {
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new ReadingThread(handler),
                new WritingThread(handler),
                new WritingThread(handler)
        };
        for(int i=0; i<ts.length; i++) {
            ts[i].start();
        }
    }
}

我们启动了5个读线程和2个写线程，运行结果如下：

Thread-0 waiting for read...
Thread-1 waiting for read...
Thread-2 waiting for read...
Thread-3 waiting for read...
Thread-4 waiting for read...
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-4 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-0 reads data: AAAAAAAAAA
Thread-5 wrote data: EEEEEEEEEE
Thread-6 wrote data: MMMMMMMMMM
Thread-1 waiting for read...
Thread-4 waiting for read...
Thread-1 reads data: MMMMMMMMMM
Thread-4 reads data: MMMMMMMMMM
Thread-2 waiting for read...
Thread-2 reads data: MMMMMMMMMM
Thread-0 waiting for read...
Thread-0 reads data: MMMMMMMMMM
Thread-4 waiting for read...
Thread-4 reads data: MMMMMMMMMM
Thread-2 waiting for read...
Thread-5 waiting for write...
Thread-2 reads data: MMMMMMMMMM
Thread-5 wrote data: GGGGGGGGGG
Thread-6 waiting for write...
Thread-6 wrote data: AAAAAAAAAA
Thread-3 waiting for read...
Thread-3 reads data: AAAAAAAAAA
......

可以看到，每次读/写都是完整的原子操作，因为我们每次写入的都是10个相同字符。并且，每次读出的都是最近一次写入的内容。

如果去掉ReadWriteLock：

package com.crackj2ee.thread;
public class DataHandler {

    // store data:
    private char[] buffer = "AAAAAAAAAA".toCharArray();

    public char[] read(String name) throws InterruptedException {
        char[] data = doRead();
        System.out.println(name + " reads data: " + new String(data));
        return data;
    }
    public void write(String name, char[] data) throws InterruptedException {
        System.out.println(name + " wrote data: " + new String(data));
        doWrite(data);
    }

    private char[] doRead() {
        char[] ret = new char[10];
        for(int i=0; i<10; i++) {
            ret[i] = buffer[i];
            sleep(3);
        }
        return ret;
    }
    private void doWrite(char[] data) {
        for(int i=0; i<10; i++) {
            buffer[i] = data[i];
            sleep(10);
        }
    }
    private void sleep(int ms) {
        try {
            Thread.sleep(ms);
        }
        catch(InterruptedException ie) {}
    }
}

运行结果如下：

Thread-5 wrote data: AAAAAAAAAA
Thread-6 wrote data: MMMMMMMMMM
Thread-0 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-4 reads data: AAAAAAAAAA
Thread-2 reads data: MAAAAAAAAA
Thread-3 reads data: MAAAAAAAAA
Thread-5 wrote data: CCCCCCCCCC
Thread-1 reads data: MAAAAAAAAA
Thread-0 reads data: MAAAAAAAAA
Thread-4 reads data: MAAAAAAAAA
Thread-6 wrote data: EEEEEEEEEE
Thread-3 reads data: EEEEECCCCC
Thread-4 reads data: EEEEEEEEEC
Thread-1 reads data: EEEEEEEEEE

可以看到在Thread-6写入EEEEEEEEEE的过程中，3个线程读取的内容是不同的。

思考

java的synchronized提供了最底层的物理锁，要在synchronized的基础上，实现自己的逻辑锁，就必须仔细设计ReadWriteLock。

Q: lock.readLock()为什么不放入try{ } 内？
A: 因为readLock()会抛出InterruptedException，导致readingThreads++不执行，而readUnlock()在finally{ } 中，导致readingThreads--执行，从而使readingThread状态出错。writeLock()也是类似的。

Q: preferWrite有用吗？
A: 如果去掉preferWrite，线程安全不受影响。但是，如果读取线程很多，上一个线程还没有读取完，下一个线程又开始读了，就导致写入线程长时间无法获得writeLock；如果写入线程等待的很多，一个接一个写，也会导致读取线程长时间无法获得readLock。preferWrite的作用是让读/写交替执行，避免由于读线程繁忙导致写无法进行和由于写线程繁忙导致读无法进行。

Q: notifyAll()换成notify()行不行？
A: 不可以。由于preferWrite的存在，如果一个线程刚读取完毕，此时preferWrite=true，再notify()，若恰好唤醒的是一个读线程，则while(writingThreads>0 || (preferWrite && waitingThreads>0))可能为true导致该读线程继续等待，而等待写入的线程也处于wait()中，结果所有线程都处于wait()状态，谁也无法唤醒谁。因此，notifyAll()比notify()要来得安全。程序验证notify()带来的死锁：

Thread-0 waiting for read...
Thread-1 waiting for read...
Thread-2 waiting for read...
Thread-3 waiting for read...
Thread-4 waiting for read...
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-0 reads data: AAAAAAAAAA
Thread-4 reads data: AAAAAAAAAA
Thread-3 reads data: AAAAAAAAAA
Thread-2 reads data: AAAAAAAAAA
Thread-1 reads data: AAAAAAAAAA
Thread-5 wrote data: CCCCCCCCCC
Thread-2 waiting for read...
Thread-1 waiting for read...
Thread-3 waiting for read...
Thread-0 waiting for read...
Thread-4 waiting for read...
Thread-6 wrote data: LLLLLLLLLL
Thread-5 waiting for write...
Thread-6 waiting for write...
Thread-2 reads data: LLLLLLLLLL
Thread-2 waiting for read...
（运行到此不动了）

注意到这种死锁是由于所有线程都在等待别的线程唤醒自己，结果都无法醒过来。这和两个线程希望获得对方已有的锁造成死锁不同。因此多线程设计的难度远远高于单线程应用。


]]> <![CDATA[java中switch的使用]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=26371 littcricket 2007/7/16 10:42:18 　java中switch的使用
关于java中switch使用的一些说明

switch(表达式)
{
case 常量表达式1:语句1;
....
case 常量表达式2:语句2;
default:语句;
}
default就是如果没有符合的case就执行它,default并不是必须的.
case后的语句可以不用大括号.
switch语句的判断条件可以接受int,byte,char,short,不能接受其他类型.
一旦case匹配,就会顺序执行后面的程序代码,而不管后面的case是否匹配,直到遇见break,利用这一特性可以让好几个case执行统一语句.

例如:

switch(x)

{

case 1:

case 2:

case3: System.out.println("haha");

break;

case4: System.out.println("hehe");

}

 
]]> <![CDATA[性格，编码，测试]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=26370 littcricket 2007/7/16 9:51:45 自己的性格是属于偏急的那种，什么事情到手上，恨不能马上做完，就开始享受生活了，结果就是在coding的过程中，遇到问题自己比较急，问题解决的不好，就求助于别人，而在心态好的情况下，自己未必也不能解决；然后就是在coding完以后，测试粗糙，以至于后来的bug很多，（在编码的过程中，coding是30%，测试是70%，觉得也是依照每个人的性格不一样，有的人习惯在coding比较细心，有得人比较粗心，自然在coding和测试中花的时间比例不同）对自己的信心也是一种打击，也是一种不成熟的表现，还是那句话，人才是磨出来的，自己慢慢用心体会吧。

]]> <![CDATA[突然想到的几句话！]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=26369 littcricket 2007/7/16 9:45:08 1.人才是磨出来的

  2.每天应该反省自己，做到了什么，没做到什么了，做错了什么

]]> <![CDATA[理解Spring AOP中的关键概念]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25980 littcricket 2007/7/4 13:42:41 　

这一周我都在用空余的时间来看Spring这个东西，突然觉得这个东西并没有想像中那么深不可测，最多只有AOP这方面的东西不是我所熟悉的，不过经过自己努力，也不是不可理解的。

AOP，面向切面的编程，是一种从各个方面对软件系统进行关注的开发方法，也就是说，可以把要实现的系统从多个方面进行理解和开发。比如一个系统，它包含了业务逻辑，日志管理，安全管理（认证管理）等，一般而言，我在开发包含这些方面的程序时，就很容易进入单面一维的操作去：比如下面是一个用户管理程序的部份：
1、验证用户是否已经登录
2、记录日志
3、进行操作，对重要的操作都可能要进行日志记录。
4、记录用户离开时间
......
由上面的步骤可以看到，真正的业务逻辑只有第3步，其它的都是附加的功能，或者是从另一方面加入的功能，他们和业务逻辑是相辅相成，可是业务逻辑并不需要知道这些附加的功能，又从另一方面来看，每一进行的操作都会触发附加的操作，而且这些应该是自动的，业务逻辑所不知道的。

所以就引进一个拦截器的概念，对用户的操作进行拦截，然后进行附加的操作。而用户的操作并不知道这些拦截器的存在，从而可以使开发业务逻辑的程序员可以专心地写他的业务逻辑，而其它程序员则专心写他的拦截器，从而就可以使程序员从多个方面进行关注，进行编程。而Spring AOP就起到了这个拦截器的作用，而这些就演化出很多的术语，也无非是拦截器而已，现在俗一点来理解这些个术语：

切面：宏观上要关注的编程方面，比如安全管理方面，日志记录方面，而这些都只是宏观上的，没有任何代码实现，就好像这样说：我这个系统要一个安全管理系统等等，就是大至上需要这个切面功能。

通知（Advice）：切面功能的代码实现，也就是说具体的切面功能。

连接点（Joinpoint）：程序运行中可以把通知道插入的所有地方，比如某方法前，后，或抛出异常，而所以这些方法的插入点都是连接点。

切入点（Pointcut）：定义了通知可以插入到哪些连接点。

Advisor：这里只有Spring才有，它包含了通知和切入点，以定义在什么连接点插入什么通知。

下面我用一个代码例子来说明：

文件：SayHelloService.java

1 package  com.bullonline.study.spring.ch03;
2 
3 public interface  SayHelloService {
4     public void  printMessage(String message);
5     public void  printInfomation(String info);
6  }
7  

文件：SayHelloServiceImpl.java
 1 package  com.bullonline.study.spring.ch03;
 2 
 3 public class SayHelloServiceImpl implements  SayHelloService {
 4 
 5     public void  printMessage(String message) {
 6         System.out.println("message:" +  message);
 7         System.out.println("---------------------------------\n" );
 8      }
 9 
10     public void  printInfomation(String info) {
11         System.out.println("..Infomation" );
12         System.out.println("=      love is good       =" );
13          System.out.println(info);
14         System.out.println("---------------------------------\n" );
15      }
16 
17  }
18  

文件：SayHelloAdvice.java
 1 package  com.bullonline.study.spring.ch03;
 2 
 3 import  java.lang.reflect.Method;
 4 
 5 import  org.springframework.aop.MethodBeforeAdvice;
 6 
 7 public class SayHelloAdvice implements  MethodBeforeAdvice {
 8 
 9     public void  before(Method method, Object[] args, Object target)
10             throws  Throwable {
11         System.out.println(method.toString() + ": say hello to you!!" );
12      }
13 
14 }

文件：MyClassFilter.java
 1 package  com.bullonline.study.spring.ch03;
 2 
 3 import  org.springframework.aop.ClassFilter;
 4 
 5 public class MyClassFilter implements  ClassFilter {
 6 
 7     public boolean  matches(Class target) {
 8         return true ;
 9      }
10 
11  }
12  

文件：MyMethodMatcher.java
 1 package  com.bullonline.study.spring.ch03;
 2 
 3 import  java.lang.reflect.Method;
 4 
 5 import  org.springframework.aop.MethodMatcher;
 6 
 7 public class MyMethodMatcher implements  MethodMatcher {
 8 
 9     public boolean  matches(Method method, Class target) {
10         String methodName =  method.getName();
11         if (methodName.equals("printMessage" )) {
12             return true ;
13         } else  {
14             return false ;
15          }
16      }
17 
18     public boolean  isRuntime() {
19         return false ;
20      }
21 
22     public boolean  matches(Method arg0, Class arg1, Object[] arg2) {
23         return false ;
24      }
25 
26  }
27  

文件：MyPointcut.java
 1 package com.bullonline.study.spring.ch03;
 2 
 3 import org.springframework.aop.ClassFilter;
 4 import org.springframework.aop.MethodMatcher;
 5 import org.springframework.aop.Pointcut;
 6 
 7 public class MyPointcut implements Pointcut {
 8     private ClassFilter filter;
 9     private MethodMatcher matcher;
10     
11     public void setClassFilter(ClassFilter filter) {
12         this.filter = filter;
13     }
14 
15     public void setMethodMatcher(MethodMatcher matcher) {
16         this.matcher = matcher;
17     }
18     
19     public ClassFilter getClassFilter() {
20         return this.filter;
21     }
22 
23     public MethodMatcher getMethodMatcher() {
24         return this.matcher;
25     }
26 
27 }
28 

文件：MyPointcutAdvisor.java
 1 package com.bullonline.study.spring.ch03;
 2 
 3 import org.aopalliance.aop.Advice;
 4 import org.springframework.aop.Pointcut;
 5 import org.springframework.aop.PointcutAdvisor;
 6 
 7 public class MyPointcutAdvisor implements PointcutAdvisor {
 8     private Pointcut pointcut;
 9     private Advice advice;
10     
11     public void setPointcut(Pointcut pointcut) {
12         this.pointcut = pointcut;
13     }
14     
15     public void setAdvice(Advice advice) {
16         this.advice = advice;
17     }
18 
19     public Pointcut getPointcut() {
20         return this.pointcut;
21     }
22 
23     public boolean isPerInstance() {
24         return false;
25     }
26 
27     public Advice getAdvice() {
28         return this.advice;
29     }
30 
31 }
32 

文件：TestApp.java
 1 package com.bullonline.study.spring.ch03;
 2 
 3 import org.springframework.beans.factory.BeanFactory;
 4 import org.springframework.beans.factory.xml.XmlBeanFactory;
 5 import org.springframework.core.io.ClassPathResource;
 6 
 7 public class TestApp {
 8     public static void main(String[] args) {
 9         BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
10         SayHelloService service = (SayHelloService) factory.getBean("sayHelloService");
11         service.printMessage("Hello, World!!");
12         service.printInfomation("haha..");
13         
14     }
15 
16 }
17 

文件：applicationContext.xml
 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
 3 
 4 <beans>
 5     <bean id="helloWorld" class="com.bullonline.study.spring.ch01.HelloWorld">
 6         <property name="message" value="Haha.Hello, World!!"></property>
 7     </bean>
 8     
 9     <bean id="sayHelloServiceImpl" class="com.bullonline.study.spring.ch03.SayHelloServiceImpl" />
10     <bean id="classFilter" class="com.bullonline.study.spring.ch03.MyClassFilter" />
11     <bean id="methodMatcher" class="com.bullonline.study.spring.ch03.MyMethodMatcher" />
12     <bean id="sayHelloAdvice" class="com.bullonline.study.spring.ch03.SayHelloAdvice" />
13     
14     <bean id="myPointcut" class="com.bullonline.study.spring.ch03.MyPointcut">
15         <property name="classFilter">
16             <ref bean="classFilter"/>
17         </property>
18         <property name="methodMatcher">
19             <ref bean="methodMatcher"/>
20         </property>
21     </bean>
22     
23     <bean id="myPointcutAdvisor" class="com.bullonline.study.spring.ch03.MyPointcutAdvisor">
24         <property name="pointcut">
25             <ref bean="myPointcut"/>
26         </property>
27         <property name="advice">
28             <ref bean="sayHelloAdvice"/>
29         </property>
30     </bean>
31     
32     <bean id="sayHelloService" class="org.springframework.aop.framework.ProxyFactoryBean">
33         <property name="proxyInterfaces">
 <![CDATA[Spring AOP四种创建通知(拦截器)类型实例]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25979 littcricket 2007/7/4 13:15:40 　

1、Spring只支持方法拦截，也就是说，只能在方法的前后进行拦截，而不能在属性前后进行拦截。
2、Spring支持四种拦截类型：目标方法调用前（before），目标方法调用后（after），目标方法调用前后（around），以及目标方法抛出异常（throw）。
3、前置拦截的类必须实现MethodBeforeAdvice接口，实现其中的before方法。
4、后置拦截的类必须实现AfterReturningAdvice接口，实现其中的afterReturning方法。
5、前后拦截的类必须实现MethodInterceptor接口，实现其中的invoke方法。前后拦截是唯一可以控制目标方法是否被真正调用的拦截类型，也可以控制返回对象。而前置拦截或后置拦截不能控制，它们不能印象目标方法的调用和返回。
但是以上的拦截的问题在于，不能对于特定方法进行拦截，而只能对某个类的全部方法作拦截。所以下面引入了两个新概念：“切入点”和“引入通知”。
6、”切入点“的定义相当于更加细化地规定了哪些方法被哪些拦截器所拦截，而并非所有的方法都被所有的拦截器所拦截。在ProxyFactoryBean的属性中，interceptorNames属性的对象也由拦截（Advice）变成了引入通知（Advisor），正是在Advisor中详细定义了切入点（PointCut）和拦截（Advice）的对应关系，比如常见的基于名字的切入点匹配（NameMatchMethodPointcutAdvisor类）和基于正则表达式的切入点匹配（RegExpPointcutAdvisor类）。这些切入点都属于”静态切入点“，因为他们只在代理创建的时候被创建一次，而不是每次运行都创建。

 

下面我们进行实例的开发

 

首先创建业务接口：

 

package AdvisorTest;

public interface Shopping {
  public String buySomething(String type);
  public String buyAnything(String type);
  public void testException();
}

 下面是业务实现类，我们的通知就是以这些实现类作为切面，在业务方法前后加入我们的通知代码

 

package AdvisorTest;

public class ShoppingImpl implements Shopping {
    private Customer customer;
    public Customer getCustomer() {
        return customer;
    }
    public void setCustomer(Customer customer) {
        this.customer = customer;
    }
    public String buySomething(String type) {
        System.out.println(this.getCustomer().getName()+" bye "+type+" success");
        return null;
    }
    
    public String buyAnything(String type) {
       System.out.println(this.getCustomer().getName()+" bye "+type+" success");
       return null;

     }
    public void testException(){
        throw new ClassCastException();
    }
}

 

（1）前置通知

        配置了前置通知的bean,在执行业务方法前，均会执行前置拦截器的before方法

package AdvisorTest;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;
//前置通知
public class WelcomeAdvice implements MethodBeforeAdvice {

    public void before(Method method, Object[] args, Object obj)
            throws Throwable {
        String type=(String)args[0];
        System.out.println("Hello welcome to bye "+type);

    }

}

 

（2）后置通知

配置了前置通知的bean,在执行业务方法前，均会执行前置拦截器的afterReturnning方法

 

package AdvisorTest;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
//后置通知
public class ThankYouAdvice implements AfterReturningAdvice {

    public void afterReturning(Object obj, Method method, Object[] arg1,
            Object arg2) throws Throwable {
        
         String type=(String)arg1[0];
         System.out.println("Hello Thankyou to bye "+type);
    }
    

}

 

（3）环绕通知

配置了前置通知的bean,在执行业务方法前后，均会执行前置拦截器的invoke方法

需要注意的是必须调用目标方法，如不调用，目标方法将不被执行

package AdvisorTest;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MethodAdvisor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {
        String str=(String)invocation.getArguments()[0];
        System.out.println("this is before"+str+" in MethodInterceptor");
        Object obj=invocation.proceed(); //调用目标方法，如不调用，目标方法将不被执行
        System.out.println("this is after"+str+" in MethodInterceptor");
        return null;
    }

}

 

（4）异常通知

ThrowsAdvice是一个标示接口，我们可以在类中定义一个或多个，来捕获定义异常通知的bean抛出的异常，并在抛出异常前执行相应的方法

public void afterThrowing(Throwable throwa){}

或者

public void afterThrowing(Method method,Object[] args,Object target,Throwable throwable){

package AdvisorTest;

import org.springframework.aop.ThrowsAdvice;

public  class ExceptionAdvisor implements ThrowsAdvice {
  public void afterThrowing(ClassCastException e){
      System.out.println("this is from exceptionAdvisor");
  }
}

 

配置文件

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd" >
<beans>
 <bean id="customer" class="AdvisorTest.Customer">
   <constructor-arg index="0">
     <value>gaoxiang</value>
   </constructor-arg>
    <constructor-arg index="1">
     <value>26</value>
   </constructor-arg>
 </bean>
 
 <bean id="shoppingImpl" class="AdvisorTest.ShoppingImpl">
   <property name="customer">
     <ref local="customer"/>
   </property>
 </bean>

<!-- 前置通知 -->
<bean id="welcomeAdvice" class="AdvisorTest.WelcomeAdvice"/>
<bean id="welcomeAdviceShop" class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="proxyInterfaces">
    <value>AdvisorTest.Shopping</value>
  </property>
  <property name="target">
    <ref local="shoppingImpl"/>
  </property>
  <property name="interceptorNames">
    < <![CDATA[xml的四种解析方法 比较 sax，dom，jdom，dom4j]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25635 littcricket 2007/6/20 14:42:50 　

在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。


预 备

    测试环境：
    AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server SP4、Sun JDK 1.4.1+Eclipse 2.1+Resin 2.1.8，在 Debug 模式下测试。
   
    XML 文件格式如下：
    <?xml version="1.0" encoding="GB2312"?>
      <RESULT>
        <VALUE>
          <NO>A1234</NO>
          <ADDR>四川省XX县XX镇XX路X段XX号</ADDR>
        </VALUE>
        <VALUE>
          <NO>B1234</NO>
          <ADDR>四川省XX市XX乡XX村XX组</ADDR>
        </VALUE>
      </RESULT>

    测试方法：
    采用 JSP 端调用Bean（至于为什么采用JSP来调用，请参考：http://blog.csdn.net/rosen/archive/2004/10/15/138324.aspx），让每一种方案分别解析10K、100K、1000K、10000K的 XML 文件，计算其消耗时间（单位:毫秒）。
   
    JSP 文件：
    <%@ page contentType="text/html; charset=gb2312" %>
    <%@ page import="com.test.*"%>

    <html>
        <body>
        <%
            String args[]={""};
            MyXMLReader.main(args);
        %>
        </body>
    </html>


测 试

    首先出场的是 DOM（JAXP Crimson 解析器）   

    DOM 是用与平台和语言无关的方式表示 XML 文档的官方 W3C 标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而 DOM 被认为是基于树或基于对象的。DOM 以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像 SAX 那样是一次性的处理。DOM 使用起来也要简单得多。
   
    另一方面，对于特别大的文档，解析和加载整个文档可能很慢且很耗资源，因此使用其他手段来处理这样的数据会更好。这些基于事件的模型，比如 SAX。

    Bean文件：
    package com.test;

    import java.io.*;
    import java.util.*;
    import org.w3c.dom.*;
    import javax.xml.parsers.*;

    public class MyXMLReader{

        public static void main(String arge[]){
            long lasting =System.currentTimeMillis();
            try{  
                File f=new File("data_10k.xml");
                DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
                DocumentBuilder builder=factory.newDocumentBuilder();
                Document doc = builder.parse(f);
                NodeList nl = doc.getElementsByTagName("VALUE");
                for (int i=0;i<nl.getLength();i++){
                    System.out.print("车牌号码:" +  doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
                    System.out.println(" 车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
                }
            }catch(Exception e){
                e.printStackTrace();
            }
            System.out.println("运行时间："+(System.currentTimeMillis() - lasting)+" 毫秒");
        }
    }

      10k消耗时间：265 203 219 172
    100k消耗时间：9172 9016 8891 9000
  1000k消耗时间：691719 675407 708375 739656
10000k消耗时间：OutOfMemoryError


    接着是 SAX
   
    这种处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX 还比它的替代者 DOM 快许多。

    选择 DOM 还是选择 SAX ？

    对于需要自己编写代码来处理 XML 文档的开发人员来说，选择 DOM 还是 SAX 解析模型是一个非常重要的设计决策。
    DOM 采用建立树形结构的方式访问 XML 文档，而 SAX 采用的事件模型。
    DOM 解析器把 XML 文档转化为一个包含其内容的树，并可以对树进行遍历。用 DOM 解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用 DOM 解析器的时候需要处理整个 XML 文档，所以对性能和内存的要求比较高，尤其是遇到很大的 XML 文件的时候。由于它的遍历能力，DOM 解析器常用于 XML 文档需要频繁的改变的服务中。
    SAX 解析器采用了基于事件的模型，它在解析 XML 文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX 对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX 这种扩展能力得到了更好的体现。但用 SAX 解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。
   
    Bean文件：
    package com.test;
    import org.xml.sax.*;
    import org.xml.sax.helpers.*;
    import javax.xml.parsers.*;

    public class MyXMLReader extends DefaultHandler {

        java.util.Stack tags = new java.util.Stack();

        public MyXMLReader() {
            super();
        }

        public static void main(String args[]) {
            long lasting = System.currentTimeMillis();
            try {
                SAXParserFactory sf = SAXParserFactory.newInstance();
                SAXParser sp = sf.newSAXParser();
                MyXMLReader reader = new MyXMLReader();
                sp.parse(new InputSource("data_10k.xml"), reader);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + " 毫秒");
        }

        public void characters(char ch[], int start, int length) throws SAXException {
            String tag = (String) tags.peek();
            if (tag.equals("NO")) {
                System.out.print("车牌号码：" + new String(ch, start, length));
            }
            if (tag.equals("ADDR")) {
                System.out.println("  地址:" + new String(ch, start, length));
            }
        }

        public void startElement(
            String uri,
            String localName,
            String qName,
            Attributes attrs) {
                tags.push(qName);
            }
        }

      10k消耗时间：110 47 109 78
    100k消耗时间：344 406 375 422
  1000k消耗时间：3234 3281 3688 3312
10000k消耗时间：32578 34313 31797 31890 30328


    然后是 JDOM http://www.jdom.org/

    JDOM 的目的是成为 Java 特定文档模型，它简化与 XML 的交互并且比使用 DOM 实现更快。由于是第一个 Java 特定模型，JDOM 一直得到大力推广和促进。正在考虑通过“Java 规范请求 JSR-102”将它最终用作“Java 标准扩展”。从 2000 年初就已经开始了 JDOM 开发。

    JDOM DOM与DOM类似，也是一组用于解析XML的API，它本身不是一个解析器，默认的它内置了Apache的Xerces解析器；JDOM与DOM不同的是，DOM是跨语言的一套API，Java世界中有很多DOM的解析器，同样的.Net中也一样内置了DOM的实现，但是JDOM是专门为Java打造的一批API，JDOM采用了Java中的Collection架构来封装集合，是Java爱好者更加熟悉的模式。

 

JDOM的核心类

JDOMException

Document <- DocType

         <- Comment

         <- ProcessingInstruction

         <- Element <- Attribute

                    <- Comment

                    <- ProcessingInstruction

                    <- CDATA

                    <- Text

                    <- EntityRef

 

JDOM对外都是具体类，无需工厂

Element、Attribute、ProcessingInstruction、Comment和其他类都可以直接通过new来声明实例，不需要工厂了，具有使用方便的一面，但同时也限制了扩展，这些暂且不做讨论，我们关心的如何使用，而不是如何优化它的设计。

    Eement rootElem = new Element("root");

    Document doc = new Document(rootElem);

就这么简单，一个JDOM的Document对象产生了。

 

JDOM的输入

JDOM的输入允许各种类型，如SAX事件、DOM文档、JDBC的ResultSet、文件、Stream、远程URI等等，这里先研究最简单也是最常用的两种（SAXBuilder，DOMBuilder）。

//SAXBuilder构建一个JDOM的Document

SAXBuilder builder = new SAXBuilder();

Document doc = builder.build(new FileInputStream("text.xml"));

//DOMBuilder构建一个JDOM的Document

DOMBuilder builder = new DOMBuilder();

Document doc = builder.build(aDOMDocument);

记住：只有当输入是一个DOM的Document的时候，才采用DOMBuilder，否则SAXBuilder是首选。原因不是DOMBuilder不能接受其他参数，而是性能问题。在实现中与SAXBuilder比起来，DOMBuilder绕了一个圈子，所以理论上说性能必有影响。

 

JDOM的输出

JDOM有专门的输入类XMLOutputer,SAXOutputer,DOMOutputer。与允许各种输入一样，JDOM通过这些类允许各种输出。如输出一个DOM的Document，输出XML文件，输入Stream等等，方法很简单，都是通过output()的重载方法来实现，具体产看JavaDoc即可。一个简单的例子：

XMLOutputer outputer = new XMLOutputer("  ",true,"UTF-8");

outputer.output(jdomDocument, new FileOutputStream("result.xml"));

这里的XMLOutputer的构造有几种：

    public XMLOutputer();

    public XMLOutputer(String indent);

    public XMLOutputer(String indent, boolean newLines);

    public XMLOutputer(String indent, boolean newLines,

                       String encoding);

其中indent为每行的缩进字符；newLines自动换行，如果为false则所有的输出都在一行，可读性很差；encoding为编码，即<?xml version=1.0 encoding="UTF-8">中的UTF-8。

 

JDOM的常用API

1. Document

doc.getContent()与doc.setContent(child)可以为Document添加任何类型的节点，其实不止是Document可以，其他可以有子节点的节点都可以，如Element。

2. Element

与DOM不同，Element下无需获得Text就可以直接获取元素文本，尽管JDOM的内部实现依然是存在Text节点的，但是从使用这个角度来说elem.getText()与elem.setText("val")这样的方式还是方便了很多。

与DOM一样，Element中可以不通过Attribute节点直接操作属性，elem.getAttribute("key")和elem.setAttribte("key","value")

3. 其他

其他的参照JavaDoc即可了，没有什么特别的。

 

-----值得注意的地方-----

1.关于添加节点的顺序

通过如下代码为根元素添加一个注释：

Element rootElem = new Element("Root");

Document doc = new Document(rootElem);

Comment comm = new Comment("This is a comment Test");

doc.addContent(comm);

表面看上去没什么问题，但是结果会是如下状况：

    <?xml version = "1.0 encoding="UTF-8">

    <Root>

        ...

    </Root>

    <!--This is a comment Test-->

问题应该可以看出来了，原因是doc.addContent(comm)，comm在doc之后。但是没有doc又无法添加comm，这似乎有些矛盾，怎么办呢？我们可以采用如下办法：

doc.getContent.add(0,comment);

这与ListXml技术简介
Xml文件有两种约束类型，包括文档类型定义（DTD）和Xml 模式（Schema）。Xml DTD被包含在xml1的标准里。Xml 模式被包含在W3C的标准中。在xml 数据和xml 模式两者之间有很多的区别。
A． xml模式支持的数据类型比xml DTD多；
B． xml模式在无序的情况下使用起来比xml DTD更方便；
C． xml模式支持名字空间，可以在不同的文件中定义相同的方法等。
D． xml模式形成的文档可以被多种标准解析，如dom，sax或者jdom等，而xml DTD方式下确不行。
SAX解析方式
上面我简要介绍了几种解析xml文件的技术，这里我们使用SAX技术给出一个小例子，大家可以从这个例子中发现如果你能够掌握一些开源软件包，你就可以很快掌握解析xml数据的技术。
制作一个简单的xml文件component.xml

<?xml version="1.0"?>
<XmlComponents>
        <XmlComponent>
               <ComNo>1</ComNo>
        </XmlComponent>
</XmlComponents>

下载xerces.jar软件包
在Apache网站上×××下载xerces.jar软件包，这个包中包含了上面我们列举的几种解析xml数据的API。然后将这个软件包加入到程序的classpath中。
制作解析类MySaxParser.java

import java.io.IOException;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class MySaxParser extends DefaultHandler {
  private static int INDENT = 2;

  // 运行主方法
public static void main(String[] argv) {
//    if (argv.length != 1) {
//      System.out.println("Usage: java ds.MySaxParser [URI]");
//      System.exit(0);
//    }
    System.setProperty("javax.xml.parsers.SAXParserFactory", "org.apache.xerces.jaxp.SAXParserFactoryImpl");
//    String uri = argv[0];
    String uri = "Components.xml";
    try {
      SAXParserFactory parserFactory = SAXParserFactory.newInstance();
      parserFactory.setValidating(false);
      parserFactory.setNamespaceAware(false);
      MySaxParser MySaxParserInstance = new MySaxParser();
      SAXParser parser = parserFactory.newSAXParser();
      parser.parse(uri, MySaxParserInstance);
    }
    catch(IOException ex) {
      ex.printStackTrace();
    }
    catch(SAXException ex) {
      ex.printStackTrace();
    }
    catch(ParserConfigurationException ex) {
      ex.printStackTrace();
    }
    catch(FactoryConfigurationError ex) {
      ex.printStackTrace();
    }

  }

  private int idx = 0; //indent
  // 处理各种分隔符号
  public void characters(char[] ch, int start, int length) throws SAXException {
    //instantiates s, indents output, prints character values in element
    String s = new String(ch, start, length);
    if (!s.startsWith("\n")) //空的value不打印
      System.out.println(getIndent()+ " Value: " + s);
  }

  // 处理文档尾
  public void endDocument() throws SAXException {
    idx -= INDENT;
    System.out.println(getIndent() + "end document");

    System.out.println("...PARSING ends");
  }

  // 处理标记尾
  public void endElement(String uri, String localName, String qName) throws SAXException {
    idx -= INDENT;
  }

  // 处理文档的起始点
  public void startDocument() throws SAXException {
    idx += INDENT;
    System.out.println("PARSING begins...");
    System.out.println(getIndent() + "start document: ");
  }

// 处理标记头
  public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    idx += INDENT;
    System.out.println('\n' + getIndent() + "start element: " + qName);

  }

  private String getIndent() {
    StringBuffer sb = new StringBuffer();
    for (int i = 0; i < idx; i++)
      sb.append(" ");
    return sb.toString();
  }

}



总结，虽然解析xml数据很复杂，因为涉及了很多的递归算法，但是我们可以使用业界比较成熟的解析API来进行xml数据处理。我现在只是给出了一个非常简单的例子，但是在真实系统中远比这个要复杂的多，大家以后在使用的使用会发现还是有很多的工作要做的。 


Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1592786

 

]]> <![CDATA[xml的dom解析过程详解]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25632 littcricket 2007/6/20 14:40:48 　

 一、        前言



用Java解析XML文档，最常用的有两种方法：使用基于事件的XML简单API（Simple API for XML）称为SAX和基于树和节点的文档对象模型（Document Object Module）称为DOM。Sun公司提供了Java API for XML Parsing（JAXP）接口来使用SAX和DOM，通过JAXP，我们可以使用任何与JAXP兼容的XML解析器。

JAXP接口包含了三个包：

（1）       org.w3c.dom  W3C推荐的用于XML标准规划文档对象模型的接口。

（2）       org.xml.sax   用于对XML进行语法分析的事件驱动的XML简单API（SAX）

（3）       javax.xml.parsers解析器工厂工具，程序员获得并配置特殊的特殊语法分析器。

二、        前提



DOM编程不要其它的依赖包，因为JDK里自带的JDK里含有的上面提到的org.w3c.dom、org.xml.sax 和javax.xml.parsers包就可以满意条件了。

三、        使用DOM解析XML文档



我们现在来看看DOM是如何解析XML的吧！同样的，我将从一个简单的不能再简单的例子来说明DOM是如何解析XML文档的，先让我们看看XML是什么内容吧：

<?xml version="1.0" encoding="gb2312"?>



<books>



  <book email="zhoujunhui">



        <name>rjzjh</name>



        <price>jjjjjj</price>



  </book>



</books>



简单的不能再简单了。但是该有的都有了，根元素、属性、子节点。好了，能反应问题就行了，下面来看看解析这个XML文件的Java代码吧！

1 public class DomParse {

2     public DomParse(){              

3            DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();

4            try {

5                   DocumentBuilder dombuilder=domfac.newDocumentBuilder();

6                   InputStream is=new FileInputStream("bin/library.xml");

7                   Document doc=dombuilder.parse(is);

8                   

9                   Element root=doc.getDocumentElement();

10                  NodeList books=root.getChildNodes();

11                  if(books!=null){

12                         for(int i=0;i<books.getLength();i++){

13                                Node book=books.item(i);

14                                if(book.getNodeType()==Node.ELEMENT_NODE){

15                  String email=book.getAttributes().getNamedItem("email").getNodeValue();

16                                       System.out.println(email);

17                  for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){

18                                              if(node.getNodeType()==Node.ELEMENT_NODE){

19                                                     if(node.getNodeName().equals("name")){

20                                                            String name=node.getNodeValue();

21                                                            String name1=node.getFirstChild().getNodeValue();

22                                                            System.out.println(name);

23                                                            System.out.println(name1);

24                                                     }

25                                                     if(node.getNodeName().equals("price")){

26                                                            String price=node.getFirstChild().getNodeValue();

27                                                            System.out.println(price);

28                                                     }

29                                              }

30                                       }

31                                }

32                         }

33                  }

34           } catch (ParserConfigurationException e) {

35                  e.printStackTrace();

36           } catch (FileNotFoundException e) {

37                  e.printStackTrace();

38           } catch (SAXException e) {

39                  e.printStackTrace();

40           } catch (IOException e) {

41                  e.printStackTrace();

42           }

43    }

44    public static void main(String[] args) {

45           new DomParse();

46    }

47 }

四、        代码解释



先看看这个程序引用类：

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStream;

import javax.xml.parsers.DocumentBuilder;

import javax.xml.parsers.DocumentBuilderFactory;

import javax.xml.parsers.ParserConfigurationException;

//下面主要是org.xml.sax包的类

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import org.xml.sax.SAXException;

上面那么简单的代码一看就明白了，但是为了介绍个DOM编程的大概还是来看看这个程序吧：

（1）       得到DOM解析器的工厂实例

                   DocumentBuilderFactory domfac=DocumentBuilderFactory.newInstance();

      得到javax.xml.parsers.DocumentBuilderFactory;类的实例就是我们要的解析器工厂

（2）       从DOM工厂获得DOM解析器

                          DocumentBuilder dombuilder=domfac.newDocumentBuilder();

      通过javax.xml.parsers.DocumentBuilderFactory实例的静态方法newDocumentBuilder()得到DOM解析器

（3）       把要解析的XML文档转化为输入流，以便DOM解析器解析它

                InputStream is=new FileInputStream("bin/library.xml");

InputStream是一个接口。

（4）       解析XML文档的输入流，得到一个Document

                    Document doc=dombuilder.parse(is);

由XML文档的输入流得到一个org.w3c.dom.Document对象，以后的处理都是对Document对象进行的

（5）       得到XML文档的根节点

                    Element root=doc.getDocumentElement();

在DOM中只有根节点是一个org.w3c.dom.Element对象。

（6）得到节点的子节点

               NodeList  books=root.getChildNodes();

             for(int i=0;i<books.getLength();i++){

                             Node book=books.item(i);

           }

这是用一个org.w3c.dom.NodeList接口来存放它所有子节点的，还有一种轮循子节点的方法，后面有介绍

（7） 取得节点的属性值

                    String email=book.getAttributes().getNamedItem("email").getNodeValue();

                                         System.out.println(email);

注意，节点的属性也是它的子节点。它的节点类型也是Node.ELEMENT_NODE

（8）轮循子节点

                 for(Node node=book.getFirstChild();node!=null;node=node.getNextSibling()){

                                             if(node.getNodeType()==Node.ELEMENT_NODE){

                                                    if(node.getNodeName().equals("name")){
                                                           String name=node.getNodeValue();

                                                           String name1=node.getFirstChild().getNodeValue();

                                                           System.out.println(name);

                                                           System.out.println(name1);

                                                    }

                                                     if(node.getNodeName().equals("price")){

                                                           String price=node.getFirstChild().getNodeValue();

                                                           System.out.println(price);
                                                    }

                                              }

这段代码的打印输出为：

null



alterrjzjh



jjjjjj

从上面可以看出

                         String name=node.getNodeValue();   是一个空值。而

                         String name1=node.getFirstChild().getNodeValue();  才是真正的值，这是因为DOM把<name>rjzjh</name>也当作是两层结构的节点，其父节点为<name>节点本身，且它只有一个子节点（如果有属性的话就不止一个了！），子节点是它的值“rjzjh”，所以我们看到上面的结果。

还有，子节点的节点类型也是Node.ELEMENT_NODE型的，node.getNextSibling()方法是取下一个相邻的节点。

五、        DOM结点



DOM是一些节点的集合，由于文档中可能包含有不同类型的信息，所以定义了几种不同类型的节点。DOM中最常见的节点类型有：

（1）元素：

元素是XML的基本构件。元素的子节点可以是其它元素、文本节点或两者都有。元素节点还可以只含有属性这一唯一类型的节点。

（2）属性：

     属性节点包含关于元素节点的信息，但它不是元素的子节点

（3）文本：

     文本节点文本信息，或干脆是空白的文本。

（4）文档：

     文档节点是整个文档中所有其它节点的父节点

元素是一种很重要的类型节点，元素节点可以是其他节点的容器。

六、DOM解析XML文档的步骤：



主要几步见第四点的（1），（2），（3），（4）步骤

]]> <![CDATA[使用SAX解析XML]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25631 littcricket 2007/6/20 14:39:01 　

                      使用SAX解析XML

一、        前言

用Java解析XML文档，最常用的有两种方法：使用基于事件的XML简单API（Simple API for XML）称为SAX和基于树和节点的文档对象模型（Document Object Module）称为DOM。Sun公司提供了Java API for XML Parsing（JAXP）接口来使用SAX和DOM，通过JAXP，我们可以使用任何与JAXP兼容的XML解析器。

JAXP接口包含了三个包：

（1）       org.w3c.dom  W3C推荐的用于XML标准规划文档对象模型的接口。

（2）       org.xml.sax   用于对XML进行语法分析的事件驱动的XML简单API（SAX）

（3）       javax.xml.parsers解析器工厂工具，程序员获得并配置特殊的特殊语法分析器。

二、        前提

DOM编程不要其它的依赖包，因为JDK里自带的JDK里含有的上面提到的org.w3c.dom、org.xml.sax 和javax.xml.parsers包就可以满意条件了。

三、        使用SAX解析XML文档

SAX是基于事件的简单API，同样的我们也是用一个最简单的例子来看看SAX是如何解析XML的

先来看看我们要解析的XML代码吧

<?xml version="1.0" encoding="gb2312"?>

<books>

  <book email="zhoujunhui">

             <name addr="address">rjzjh</name>

             <price>jjjjjj</price>

  </book>

</books>

简单的不能再简单了。但是该有的都有了，根元素、属性、子节点。好了，能反应问题就行了，下面来看看解析这个XML文件的Java代码吧！

1 public class SaxParse {

2     public SaxParse(){

3            SAXParserFactory saxfac=SAXParserFactory.newInstance();

4            try {

5                   SAXParser saxparser=saxfac.newSAXParser();

6                   InputStream is=new FileInputStream("bin/library.xml");

7                   saxparser.parse(is,new MySAXHandler());

8            } catch (ParserConfigurationException e) {

9                   e.printStackTrace();

10           } catch (SAXException e) {

11                  e.printStackTrace();

12           } catch (FileNotFoundException e) {

13                  e.printStackTrace();

14           } catch (IOException e) {

15                  e.printStackTrace();

16           }

17    }

18    public static void main(String[] args) {

19           new SaxParse();

20    }

21  }

这段代码比较短，因为SAX是事件驱动的，它的大部分实现在在另一个Java文件中，先别管另一个文件，我们来一个个地分析吧！

（1）得到SAX解析器的工厂实例

3            SAXParserFactory saxfac=SAXParserFactory.newInstance();

这是一个javax.xml.parsers.SAXParserFactory类的实例

（2）从SAX工厂实例中获得SAX解析器

5            SAXParser saxparser=saxfac.newSAXParser();

使用javax.xml.parsers.SAXParserFactory工厂的newSAXParser()方法

（3）把要解析的XML文档转化为输入流，以便DOM解析器解析它

6                   InputStream is=new FileInputStream("bin/library.xml");

InputStream是一个接口。

（4）解析XML文档

7                   saxparser.parse(is,new MySAXHandler());

后面就不用看了，都是些没用的代码（相对而言），够简单的吧！

注意了，我们新建了一个实例new MySAXHandler()这个实例里面又有什么东西呢？

这个实例就是SAX的精华所在。我们使用SAX解析器时，必须实现内容处理器ContentHandler接口中的一些回调方法，然而我们不须要全部地实现这些方法，还好，我们有org.xml.sax.helpers.DefaultHandler类，看它的类申明：

public class DefaultHandler

implements EntityResolver, DTDHandler, ContentHandler, ErrorHandler

实现了这么多接口啊，其它的先不管了，至少它实现了ContentHandler这一接口。

好了，看看这个类有些什么吧？下面是它的Java代码！

public class MySAXHandler extends DefaultHandler {

       boolean hasAttribute=false;

       Attributes attributes=null;

       /* （非 Javadoc）

        * @see org.xml.sax.helpers.DefaultHandler#startDocument()

        */

       public void startDocument() throws SAXException {

               System.out.println("文档开始打印了");

       }

       /* （非 Javadoc）

        * @see org.xml.sax.helpers.DefaultHandler#endDocument()

        */

       public void endDocument() throws SAXException {

              System.out.println("文档打印结束了");

       }

       /* （非 Javadoc）

        * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)

        */

       public void startElement(String uri, String localName, String qName,

                     Attributes attributes) throws SAXException {

              if(qName.equals("books")){

                     return;

              }

              if(qName.equals("book")){

                     System.out.println(attributes.getQName(0)+attributes.getValue(0));

              }

              if(attributes.getLength()>0){

                     this.attributes=attributes;

                     this.hasAttribute=true;

              }

       }

       /* （非 Javadoc）

        * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)

        */

       public void endElement(String uri, String localName, String qName)

                     throws SAXException {

              if(hasAttribute&&(attributes!=null)){

                     for(int i=0;i<attributes.getLength();i++){

                            System.out.println(attributes.getQName(0)+attributes.getValue(0));

                     }

              }

       }

       /* （非 Javadoc）

        * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)

        */

       public void characters(char[] ch, int start, int length)

                     throws SAXException {

              System.out.println(new String(ch,start,length));

       }

 

 

}

不要看它一大堆，我一一分解给大家看。我们说SAX是基于事件的API，我们这个类实到了ContentHandler接口中的如下方法：

（1）startDocument()  用于处理文档解析开始事件

     public void startDocument() throws SAXException {

               System.out.println("文档开始打印了");

        }

（2）endDocument()  用于处理文档解析结束事件

      public void endDocument() throws SAXException {

              System.out.println("文档打印结束了");

        }

（3）startElement  用于处理元素开始事件

     public void startElement(String uri, String localName, String qName,

                     Attributes attributes) throws SAXException {

              if(qName.equals("books")){

                     return;

              }

              if(qName.equals("book")){

                     System.out.println(attributes.getQName(0)+attributes.getValue(0));

              }

              if(attributes.getLength()>0){

                     this.attributes=attributes;

                     this.hasAttribute=true;

              }

       }

第二个参数String qName表示这个元素的名字，如：

根节点  <books></books>  它的]]> <![CDATA[【低调朋友和我聊架构师】中国架构师，名符其实有多少？]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=25605 littcricket 2007/6/19 13:56:18 一个多月前，我在博客上发布了一篇阐述编程心得的原创文章——“十年编程经验凝结 与新人们分享”，该文在网上被广为转载，这让我感叹：虽然互联网上信息浩如烟海，但真正原创的有分量的文章却极其少见。这篇原创的最大功劳自不属于我，而是文中那位低调的朋友，朋友跟我说“一般情况下技术人员是不太愿意接受那种很正规的采访的，做人要低调，呵呵”，但很多人因这篇文章对朋友产生了浓厚的兴趣，想与其有更多更深入的交流。

然而朋友说，“不要单独采访我个人，但若有合适的话题，我可以告诉你我的理解”。恰好，我们CSDN最近在策划一个名为“架构师”的栏目；更恰好，朋友最近技术领域稍微转了下，开始朝企业软件架构方向迈进。于是我找到朋友聊起了架构师。。。

架构师，听起来一个响当当的头衔，但是你能分得清它跟项目经理，产品经理，项目负责人，CTO等头衔的细微区别吗？参加什么技术活动，一看人家名片亮出来，卡！系统架构师！自己都不好意思回赠名片了，因为自己才印着一软件工程师啊！以后一定换成个“高级软件工程师”再说！要说架构师这词也是翻译过来的，英文是Architect，那么中国的架构师和国外的架构师相比到底怎么样呢？不妨听听我朋友的说法吧（我特地进行了摘录）： 

“系统架构师不是科学家。科学家的工作可以说是非常难得的工作（技术含量高），而架构师的工作主要是非常庞杂，在庞杂的技术要求中寻求最优雅，简洁的解决方案。”
 
“架构师的面临的问题通常有下面几个特征：1）要解决的问题非常庞杂2）技术实践的途径非常庞杂3）系统环境与约束比较复杂。在这一系列凌乱又庞大的要求中，有能力分辨问题的本质，并能给出大家认可的——简洁且具有伸缩性的解决方案的人通常被称为架构师。”
 
“现在web应用服务器这一块比较火，涉及的技术内容非常多，所以这个领域顶着系统架构师头衔的人特别多。”
 
“不能说国内的架构师的总体素质不如国外。关键是国内公司所面临的问题与国外公司面临的问题差距太大。你不能指望在小河里面游泳的人去穿越英吉利海峡。”
 
“不能说国内架构师的能力与‘架构师’这个头衔名不符实。其实是名符其实的，只不过符合的是国内现状的‘实’。”
 
“架构师的职责是提出最佳实践的解决方案。所以有时候需要验证方案的可实践性。只不过大多时候，在熟悉的领域，‘验证方案的可实践性’通过对方案的论述足以证明。”
 
“架构师的另外一个职责是保证‘解决方案’的实践过程不走样。这个需要架构师在团队工作中提供协作。至于协作方式，未必需要编程。但是不排除出现较困难的问题时，动手编程解决的情况。”
 
“从某种意义上说，最下层的架构师和以前的技术负责人差不太多。或者另一种情况，或者架构师的地位相当高，下面的是技术负责人。技术负责人需要负责技术工作的质量因素，需要参与细节；架构师更多负责方案质量，很多时候不需要过多的参与细节。”
 
“架构师也要从技术负责人过渡而来，不可能不参与细节直接成为架构师。没有足够的细节工作积累，不能保证方案的可实践度。提解决方案时就容易出现空中楼阁，看着好看，实施起来特别困难。”
 
“说白了，架构师和技术负责人到底有多大。更多取决于公司的安排，不取决于这个架构师和技术负责人的Title。”
 
“CTO是和技术有关系的最高负责人，要承担与公司技术相关问题的行政责任。”
 
总而言之，朋友把这个“架构师”的定义是剖析得淋漓尽致了，就看大家如何对号入座了：）
 
（完）
]]> <![CDATA[学习JavaEE所必需的]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=24568 littcricket 2007/5/9 13:57:31 　1.你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该十分了解UML，尤其是class，object，interaction以及statediagrams。

　　2.你需要学习JAVA语言的基础知识以及它的核心类库(collections，serialization，streams，networking， multithreading，reflection，event，handling，NIO，localization，以及其他)。

　　3.你应该了解JVM，classloaders，classreflect，以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。

　　4.如果你将要写客户端程序，你需要学习WEB的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING，AWT， SWT。你还应该对UI部件的JAVABEAN组件模式有所了解。JAVABEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。

　　5.你需要学习java数据库技术，如JDBCAPI并且会使用至少一种persistence/ORM构架，例如Hibernate，JDO， CocoBase，TopLink，InsideLiberator(国产JDO红工厂软件)或者iBatis。

　　6.你还应该了解对象关系的阻抗失配的含义，以及它是如何影响业务对象的与关系型数据库的交互，和它的运行结果，还需要掌握不同的数据库产品运用，比如:oracle，mysql，mssqlserver。

　　7.你需要学习JAVA的沙盒安全模式(classloaders，bytecodeverification，managers，policyandpermissions，
codesigning， digitalsignatures，cryptography，certification，Kerberos，以及其他)还有不同的安全/认证 API，例如JAAS(JavaAuthenticationandAuthorizationService)，JCE (JavaCryptographyExtension)，JSSE(JavaSecureSocketExtension)，以及JGSS (JavaGeneralSecurityService)。

　　8.你需要学习Servlets，JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。

　　9.你需要熟悉主流的网页框架，例如JSF，Struts，Tapestry，Cocoon，WebWork，以及他们下面的涉及模式，如MVC/MODEL2。

　　10.你需要学习如何使用及管理WEB服务器，例如tomcat，resin，Jrun，并且知道如何在其基础上扩展和维护WEB程序。

　11.你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。
　　12.你需要掌握各种流行中间件技术标准和与java结合实现，比如Tuxedo、CROBA，当然也包括javaEE本身。

　　13.你需要学习最少一种的XMLAPI，例如JAXP(JavaAPIforXMLProcessing)，JDOM(JavaforXMLDocumentObjectModel)，DOM4J，或JAXR(JavaAPIforXMLRegistries)。

　　14.你应该学习如何利用JAVAAPI和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC)，SAAJ (SOAPwithAttachmentsAPIforJava)，JAXB(JavaArchitectureforXMLBinding)，JAXM(JavaAPIforXMLMessaging)， JAXR(JavaAPIforXMLRegistries)，或者JWSDP(JavaWebServicesDeveloperPack)。

　　15.你需要学习一门轻量级应用程序框架，例如Spring，PicoContainer，Avalon，以及它们的IoC/DI风格(setter，constructor，interfaceinjection)。

　　16.你需要熟悉不同的J2EE技术，例如JNDI(JavaNamingandDirectoryInterface)，JMS (JavaMessageService)，JTA/JTS(JavaTransactionAPI/JavaTransactionService)，JMX (JavaManagementeXtensions)，以及JavaMail。

　　17.你需要学习企业级JavaBeans(EJB)以及它们的不同组件模式：Stateless/StatefulSessionBeans，EntityBeans(包含Bean- ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL)，或者 Message-DrivenBeans(MDB)。

　　18.你需要学习如何管理与配置一个J2EE应用程序服务器，如WebLogic，JBoss等，并且利用它的附加服务，例如簇类，连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。

　　19.你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩写为AOP)，以及他们的主流JAVA规格和执行。例如AspectJ和AspectWerkz。

　　20.你需要熟悉对不同有用的API和frame work等来为你服务。例如Log4J(logging/tracing)，Quartz (scheduling)，JGroups(networkgroupcommunication)，JCache(distributedcaching)， Lucene(full-textsearch)，JakartaCommons等等。

21.如果你将要对接或者正和旧的系统或者本地平台，你需要学习JNI (JavaNativeInterface) and JCA (JavaConnectorArchitecture)。

　　22.你需要熟悉JINI技术以及与它相关的分布式系统，比如掌握CROBA。

　　23.你需要JavaCommunityProcess(JCP)以及他的不同JavaSpecificationRequests(JSRs)，例如Portlets(168)，JOLAP(69)，DataMiningAPI(73)，等等。

　　24.你应该熟练掌握一种JAVAIDE例如sunOne，netBeans，IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了：)

　　25.JAVA(精确的说是有些配置)是冗长的，它需要很多的人工代码(例如EJB)，所以你需要熟悉代码生成工具，例如XDoclet。

　　26.你需要熟悉一种单元测试体系(JNunit)，并且学习不同的生成、部署工具(Ant，Maven)。

　　27.你需要熟悉一些在JAVA开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。

　　28.你需要能够深入了解加熟练操作和配置不同的操作系统，比如GNU/linux，sunsolaris，macOS等，做为跨平台软件的开发者。

　　29.你还需要紧跟java发展的步伐，比如现在可以深入的学习javaME，以及各种java新规范，技术的运用，如新起的web富客户端技术。

　　30.你必需要对opensource有所了解，因为至少java的很多技术直接是靠开源来驱动发展的，如java3D技术。

]]> <![CDATA[高效读书心得(转)]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=24566 littcricket 2007/5/9 13:26:22 五、高效读书心得

   刚好Head First系列开头都有一段教人如何读书的话，再加工整理如下：

1.尽量阅读中文版
  虽然有人英文很强，有的翻译很差，但AnyWay 中文阅读与理解的时间，略读与快速定位的速度还是要快一些。
 
2.即时批注、总结笔记与交流
  虽然爱书，但发现最有效的读书方式还是不断的制造脂批本，读书时在重要的文字下划线，把自己的心得写在页旁。
  在明天复习一次批注，最好可以有空重新整理笔记，或者拿来与人讨论。 
 
3.大量思考或重复记忆
  看书最郁闷的事情就是看完之后脑袋空空了。技术书还好点，虽然看的时候可能很辛苦，但就像学会了骑单车，之后再骑的时候总是会的；而偏设计与管理的书，最容易的事情就是看的时候很快，看完没什么留下到实践中。
  所以，我们不能以看小说的速度来看设计书，要寻找思考的机会，思考是最好的记忆。
  又或者，大量的重复记忆，重复多遍直到无意识的记忆。 
 
4.人体工学
  那些见缝插针的时间与地点不是看这个书单的好地方。
  环境不要有电视，音乐等强输入源，而微风阳光鸟语等弱输入源则有助活跃大脑。
  看书时大量的喝水。
  如果发现自己的大脑已经疲累，已经在浮光掠影的翻看，就要休息。
  留给大脑消化的时间，看完书不要接着看其他有难度的书或事情。

]]> <![CDATA[文章收藏:十年编程经验凝结 与新人们分享]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=24564 littcricket 2007/5/9 10:37:03 　
有天和朋友聊天，朋友是国内一家大型互联网企业的一位技术主管，朋友把他将近十年研发工作积累的心血总结成两点，这两点朋友刚一提出来我并没有马上明白，只是大约有这么一个概念，我还没达到朋友在技术领域的那种高度，不能彻底领悟他深刻的思想。但我想与众多刚刚踏入IT技术研发领域的新人们分享一下这位朋友的思想，我尽全力来解释阐述朋友的话语，希望能给大家带来一些启发。
 
第一点是：不断抽象已知的东西。现实生活总是包括很多零散的东西，待解决的问题不会只有一面，所以抽取零散东西的共同属性，聚合不同角度的同一面向，成为从问题领域进入编程领域的第一步。抽象的层次越高，你架构设计就越简单。
 
第二点是：面对未知的东西用已有的抽象经验来模拟体验，从而不断调整直至达到可以控制未知东西的程度。有了上面第一点的基础，才可能到达这第二点的境界。现实问题总是不断变化着的推陈出新的，从未知到半知到已知，是人认识客观世界的一个过程，恰如人生从天真到懵懂到成熟的过程。
 
天才是什么？聊着聊着我们突然说到比尔盖茨，说到那些天才黑客，朋友和我都很兴奋。我问朋友，从他总结的两点来看天才是怎么实践这两点的？朋友想了一下说，天才就是生来就有那种抽象的能力，他并不一定局限于计算机领域的空间来看待问题，他拥有从这个世界其他领域来模拟体验计算机领域的天赋，他甚而可以抽象整个世界。
 
朋友的思想太博大高深，如我这般入行不久的初级程序员怎能领会？但我还是装作深有体会的不断点头，同时把朋友从山巅拉到山脚下。我说：“你说得太抽象了，不如你告诉一个起步阶段的程序员应该怎么慢慢通过实践来逐步达到这种境界吧。”我知道朋友在这方面颇有体会，他以前曾跟我提起他毕业后在第一家公司是怎么接受锤炼的。果然朋友很快开始阐述：“很简单，起步阶段就是专心的模仿。切记不要被那些乱七八糟的东西晃花了眼，什么j2ee与.net之争，什么soa的革命等等，你不要去关心这些东西。当你在公司上班时，会有这样一个矛盾，当你完成公司交待的一个任务时，你可能为了尽快完成任务用了很多别人现成的框架。这本身没问题，但何谓专心的模仿？就是说你在工作之余，需要来研究这些框架，你可以不用这些框架，而是用最原始的方式来写，你会慢慢体会到框架的约束，进而有对框架进行改进的欲望。但是最终你也会发现：其实任何一个框架都比你自己写的要好。然而在你不断模仿的同时你就得到不断的提高。”朋友越讲越起劲，又开始分析高手和低手在起步阶段的差异，“其实所谓学得快，所谓高手，就是说他在模仿的过程中不断比较自己写的东西和框架本身的差异，不断发现问题，想尽办法解决问题，思考得越多，你碰到的问题就会越多，这是一个正向循环，最终你的技术能力就会螺旋式的上升；而低手只会被动的等待问题，一旦问题自己觉得解决得差不多就放下了，这样自然就不会产生更多的问题，最终技术能力就始终停留在那个菜鸟阶段。”
 
朋友的话让我惭愧不已，我就是典型的不求甚解啊，问题解决得差不多就行，能运行就万岁，总是不去深究，这样给系统留下多大的隐患啊，而且也是对自己极大的不负责任。
 
聊完了技术方面的东西，我们想聊点轻松的，但是话题仍然离不开那些搞技术的新人们。朋友正好最近替公司招聘人才，面试了很多名校的计算机相关专业的一些毕业生。朋友说他们技术功底不够扎实，我说他们除了这个，心态也很浮躁，恨不得一参加工作就拿大几千的工资，一进公司就做项目经理，太眼高手低。朋友也深有同感，说面试的时候就有一种怪怪的感觉，而且朋友进一步将这种心态问题提升到编程提升到认识论的高度，“其实我觉得他们本质上是一个不能够正确认识自己的问题。认识论其实很简单，首先认识问题，然后解决问题。你说你想做项目经理，那么你需要具备哪些技能，技术上的，管理上的等，你需要多长时间来磨炼这些技能等。编程不也就是这样嘛，认识问题，抽象问题，进行设计编码最终解决问题，其实做所有的事情都是如此。”
 
跟朋友的这番聊天让我受益匪浅，而让我感受最深的不是上面提及的这些关于编程和心态两方面的道理，而是我体会到：技术人员并不像人们想象中的那么呆板，每个人都在以自己的方式活着，不断参悟人生的玄妙，而技术人员以一种更为奇特的方式和电脑搏斗，付出了更多的心血，当然体悟得也更加深刻，然而最终每个人都会殊途同归。

 

]]> <![CDATA[《设计模式》学习笔记--桥接Bridge]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=23554 littcricket 2007/3/30 11:01:19 　

《设计模式》学习笔记--桥接Bridge

   欢迎转载，请注明出处。

1、核心意图：

将抽象部分和实现部分分离，使它们都可以独立的变化。

该模式的目标是通过把高层的抽象和底层的实现分开，分别构建自己的类层次结构，并通过实现部分的接口将两部分进行桥接，从而达到高层抽象和底层实现可以独立的方便扩展的目的。其核心是分离，和委托。

 

2、身边实例：

Java语言的一个非常重要的特点是平台的无关性，对于一般的高级语言所编写的程序，如果要在不同的平台上运行，为了适应不同平台所带来的指令集及数据类型等所带来的差异，至少需要编译成不同的目标代码。

Java语言通过Java虚拟机实现了平台的无关性，虚拟机通过对底层平台指令集及数据类型等进行统一的抽象，针对不同的平台用不同的虚拟机进行实现，这样Java应用程序就可以通过编译成符合虚拟机规范的字节码文件，而在不同的平台上都能正确运行。

这里的虚拟机正是桥接模式一个很好的展示，它隔离了底层实现（指令/数据类型等）和高层的应用程序，对于新开发的每个Java应用程序，都只需要编译一次；而对于一个新平台的支持，也仅需提供一个相应的Java虚拟机，就可以使所有应用系统正确运行。

Java应用程序及虚拟机的大体结构图如下：

 

3、动机简述：

在该模式的动机中，描述了一个平台可移植的用户界面工具箱，在该工具箱中会有多种窗口Window类型，为了实现平台的可移植性，把窗口的实现部分从窗口类型中抽取出来，构成一个独立的窗口实现WindowImp类层次，从而使得抽象窗口和窗口实现都可以独立变化，以便于支持新的窗口类型和平台实现。

 

4、模式效果：

桥接Bridge模式有两个主要效果：1）通过分离抽象部分和实现部分，使两者可以独立变化；2）向客户隐藏了实现部分，从而当需要扩展/更改实现部分时，不需要重新编译客户代码。

对于效果1），当抽象部分和实现部分比较多样时，可以显著的减少类的种类，并提高代码的灵活性。假定高层抽象和底层实现分别有5种类型，如果不采用桥接模式，而用继承实现，那么就需要5*5=25个类（另有一个抽象类）；如果采用桥接模式，将抽象部分和实现部分分离，就只需要5+5=10个类就可以（另有两个抽象类），两种实现的类如以下表格中所示：

 

继承方式实现：

 

Implementor

Imp1

Imp2

Imp3

Imp4

Imp5

Abstraction

Abs1

Abs1Imp1

Abs1Imp2

Abs1Imp3

Abs1Imp4

Abs1Imp5

Abs2

Abs2Imp1

Abs2Imp2

Abs2Imp3

Abs2Imp4

Abs2Imp5

Abs3

Abs3Imp1

Abs3Imp2

Abs3Imp3

Abs3Imp4

Abs3Imp5

Abs4

Abs4Imp1

Abs4Imp2

Abs4Imp3

Abs4Imp4

Abs4Imp5

Abs5

Abs5Imp1

Abs5Imp2

Abs5Imp3

Abs5Imp4

Abs5Imp5

 

桥接模式实现：

 

Implementor

Imp1

Imp2

Imp3

Imp4

Imp5

Abstraction

Abs1

通过桥接关联

Abs2

Abs3

Abs4

Abs5

 

5、Java代码示例：

下面代码演示了一个支持不同平台的图形对象应用，图形Shape有多种类型，如三角形正方形等，为了在不同平台中实现图形的绘制，把实现部分进行了分离，构成了ShapeImp类层次结构，包括在Windows中的ShapeImpWin，和Unix中的ShapeImpUnix，类结构图如下：

 

代码清单如下：

类Point，同上一篇文章依赖是比关联弱的关系，关联代表一种结构化的关系，体现在生成的代码中，以java为例：  
  若类A单向关联指向类B，则在类A中存在一个属性B   b。  
  若类A依赖类B，则不会有这个属性，类B的实例可能存在于某个方法调用的参数中，或某个方法的局部变量中。

关联会对关系的类增加属性  
  依赖则并不对关系的类增加属性  

从业务角度来讲：关联表示的是“拥有”关系（根据拥有的程度又可分为一般关联，聚合，合成），依赖表示的是“涉及”关系。如汽车跟轮子，车身的关系是关联，但跟汽油、公路的关系就是依赖。  
 

关联关系就是两个类谁都知道谁，可以相互通信，也就是说只要存在相互通信的连接，就是关联。关联关系分为7类：普通、递归、限定、或、有序、三元、聚合关联。如人类和计算机类，“使用”就是他们的关联。  
  依赖：类A是独立的，若类A的改变将导致类B的改变，则说明类B依赖于类A，他们是依赖关系。

在建立对象模型时，很容易把依赖、关联和聚集关系混淆。当对象A和对象B之间存在依赖、关联或聚集关系时，对象A都有可能调用对象B的方法，这是三种关系之间的相同之处，除此之外，它们有着不同的特征。

1．依赖关系的特征


对于两个相对独立的系统，当一个系统负责构造另一个系统的实例，或者依赖另一个系统的服务时，这两个系统之间主要体现为依赖关系，例如生产零件的机器和零件，机器负责构造零件对象。再例如充电电池和充电器，充电电池通过充电器来充电。再例如自行车Bicycle和打气筒Pump，自行车通过打气筒来充气。图1-39为Bicycle类与Pump类的类框图。



图1-39 Bicycle类与Pump类的依赖关系

Bicycle类和Pump类之间是依赖关系，在Bicycle类中无需定义Pump类型的变量。Bicycle类的定义如下：

public class Bicycle{
/** 给轮胎充气 */
public void expand(Pump pump){
pump.blow();
}
}


在现时生活中，通常不会为某一辆自行车配备专门的打气筒，而是在需要充气的时候，从附近某个修车棚里借个打气筒打气。在程序代码中，表现为Bicycle类的expand()方法有个Pump类型的参数。以下程序代码表示某辆自行车先后到两个修车棚里充气：

myBicycle.expand(pumpFromRepairShed1); //到第一个修车棚里充气
myBicycle.expand(pumpFromRepairShed2); //若干天后，到第二个修车棚里充气

2．关联关系的特征
对于两个相对独立的系统，当一个系统的实例与另一个系统的一些特定实例存在固定的对应关系时，这两个系统之间为关联关系。例如客户和订单，每个订单对应特定的客户，每个客户对应一些特定的订单；再例如公司和员工，每个公司对应一些特定的员工，每个员工对应一特定的公司；再例如自行车和主人，每辆自行车属于特定的主人，每个主人有特定的自行车，图1-40显示了主人和自行车的关联关系。而充电电池和充电器之间就不存在固定的对应关系，同样自行车和打气筒之间也不存在固定的对应关系。

图1-40 主人和自行车的关联关系


Person类与Bicycle类之间存在关联关系，这意味着在Person类中需要定义一个Bicycle类型的成员变量。以下是Person类的定义：

public class Person{
private Bicycle bicycle; //主人的自行车

public Bicycle getBicycle(){
return bicycle;
}
public void setBicycle(Bicycle bicycle){
this.bicycle=bicycle;
}
/** 骑自行车去上班 */
public void goToWork(){
bicycle.run();
}
}


在现时生活中，当你骑自行车去上班时，只要从家里推出自己的自行车就能上路了，不象给自行车打气那样，在需要打气时，还要四处去找修车棚。因此，在Person类的goToWork()方法中，调用自身的bicycle对象的run()方法。假如goToWork()方法采用以下的定义方式：

/** 骑自行车去上班 */
public void goToWork(Bicycle bicycle){
bicycle.run();
}

那就好比去上班前，还要先四处去借一辆自行车，然后才能去上班。

]]> <![CDATA[如何正确使用Java I/O输出和读入数据]]> http://blogger.org.cn/blog/more.asp?name=littcricket&id=23537 littcricket 2007/3/29 13:32:59 前言
Java的I/O系统使用“流”来处理各种类型的输入、输出数据的任务。
在传输数据的过程中，我们需要判断流中传输的数据何时结束这样的问题。这对于我们正确地发送和接收数据是非常关键的。
如何判断流的末尾和批数据的末尾，是解决这个问题的关键。本文就是要深入地分析Java I/O输入输出的工作原理，保证我们能够正确地执行数据的发送和接收！
Java I/O任务
一个Java的I/O任务，创建了一个连接两个系统的数据传输管道。它分为两个部分：输入流和输出流。
输入流，指的是通过流向本系统的内存传输数据的单向数据传输通道。
输出流，指的是通过流向外部系统传输数据的单向数据传输通道。
 
输入流
 
InputStream类是表示字节输入流的所有类的超类。这是一个抽象类。
我们看它提供的读入数据的方法：
read
public abstract int read()
                  throws IOException
从输入流读取下一个数据字节。返回 0 到 255 范围内的 int 字节值。如果因已到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。
子类必须提供此方法的一个实现。
返回：
下一个数据字节，如果到达流的末尾，则返回 -1。
抛出：
IOException - 如果发生 I/O 错误。
read
public int read(byte[] b)
         throws IOException
从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。以整数形式返回实际读取的字节数。在输入数据可用、检测到文件末尾或者抛出异常前，此方法一直阻塞。
如果 b 为 null，将抛出 NullPointerException。如果 b 的长度为 0，则无字节可读且返回 0；否则，要尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。
将读取的第一个字节存储在元素 b[0] 中，下一个存储在 b[1] 中，依次类推。读取的字节数最多等于 b 的长度。让 k 为实际读取的字节数；这些字节将存储在元素 b[0] 至 b[k-1] 之间，不影响元素 b[k] 至 b[b.length-1]。
如果不是因为流位于文件末尾而无法读取读取第一个字节，则抛出 IOException。特别是，如果输入流已关闭，则抛出 IOException。
类 InputStream 的 read(b) 方法的效果等同于：
 read(b, 0, b.length)
参数：
b - 读入数据的缓冲区。
返回：
读入缓冲区的总字节数，如果由于流末尾已到达而不再有数据，则返回 -1。
抛出：
IOException - 如果发生 I/O 错误。
NullPointerException - 如果 b 为 null。
另请参见：
read
public int read(byte[] b,
                int off,
                int len)
         throws IOException
将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。
在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。
如果 b 为 null，则抛出 NullPointerException。
如果 off 为负，或 len 为负，或 off+len 大于数组 b 的长度，则抛出 IndexOutOfBoundsException。
如果 len 为 0，则没有字节可读且返回 0；否则，要尝试读取至少一个字节。如果因为流位于文件末尾而没有可用的字节，则返回值 -1；否则，至少可以读取一个字节并将其存储在 b 中。
将读取的第一个字节存储在元素 b[off] 中，下一个存储在 b[off+1] 中，依次类推。读取的字节数最多等于 len。让 k 为实际读取的字节数；这些字节将存储在元素 b[off] 至 b[off+k-1] 之间，其余元素 b[off+k] 至 b[off+len-1] 不受影响。
在任何情况下，元素 b[0] 至 b[off] 和元素 b[off+len] 至 b[b.length-1] 都不会受到影响。
如果不是因为流位于文件末尾而无法读取第一个字节，则抛出 IOException。特别是，如果输入流已关闭，则抛出 IOException。
类 InputStream 的 read(b, off, len) 方法只重复调用方法 read()。如果第一个这样的调用导致 IOException，则从对 read(b, off, len) 方法的调用中返回该异常。如果对 read() 的任何后续调用导致 IOException，则该异常会被捕获并将发生异常时的位置视为文件的末尾；到达该点时读取的字节存储在 b 中并返回发生异常之前读取的字节数。建议让子类提供此方法的更有效的实现。
参数：
b - 读入数据的缓冲区。
off - 在其处写入数据的数组 b 的初始偏移量。
len - 要读取的最大字节数。
返回：
读入缓冲区的总字节数，如果由于已到达流末尾而不再有数据，则返回 -1。
抛出：
IOException - 如果发生 I/O 错误。
NullPointerException - 如果 b 为 null。
另请参见：
 
 
read方法解读
这些方法的核心。实际上就是read()方法。
这个方法的JavaDoc中指出：
“如果因已到达流末尾而没有可用的字节，则返回值 -1。如果因已到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。”
 
1，read方法会在能够返回流中的字节之前，一直阻塞线程。这就是说，read方法是一个低消耗的监听和读取I/O传输的好方法。
这个方法的实现，具有非常高的性能。
 
2，如果输入流的I/O系统在执行这个read方法时抛出异常，那么显然这个方法会非正常结束，这个也是毫无疑问的。
 
3，“如果因已到达流末尾而没有可用的字节，则返回值 -1。”
这句话看似没有问题，但实际上有非常大的歧义！什么是流的末尾？只有流的末尾才能返回-1吗？
 
InputStream类和SocketInputStream类的源码解读
通过查看InputStream类的源码，我发现实际上，流，就好比是双向2车道的高速公路。它传输数据是一批一批的。我把它叫做“批数据”。
假设A=======B两个系统通过一个I/O流来连接。
那么，从B端通向A端的车道，就叫作A的“输入流”。同一条车道，在B这边，叫作B的“输出流”。
同理，从A端通向B端的车道，就叫作A的“输出流”。同一条车道，在B这边，就叫作B的“输入流”。
 
数据在这条高速公路上，不是一条一条跑的，而是一批一批跑。
 
OutputStream类，此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。 
 
OutputStream类的write方法，每执行一次，就向这条高速公路上发送了一批数据。OutputStream类的一些子类，它们并不是在每次write()方法执行之后立刻把这批数据发送到数据高速公路上的。而是只有在执行flush()方法之后，才把之前write的多批数据真正地发送到数据通道中。
这样，多个write()方法发送的数据就变为了一批数据了！
 
通过read()方法读入时，当读完该批数据之后，如果再一次执行read()方法，就会立刻返回-1。
实际上，这是并没有到达流的末尾！仅仅是读完了一批发送的数据而已！
 
如果我们又一次执行read()方法，那么，如果：
1，流没有结束。也就是说，对面的发送端可能还会发送下一批数据时，就会进入阻塞状态。当前线程暂停，直到读取到输入流中下一批数据的第一个字节。
2，流结束了。也就是说，对面的发送端不再发送任何数据，也即：这条数据通道已经没有用了，这时，可以说“到达流的末尾”了！返回-1。
    
所以，InputStream及其子类的read()方法的注释是不完整的！
Read()方法的注释，应该这么说：
read
public abstract int read()
                  throws IOException
从输入流读取下一个数据字节。返回 0 到 255 范围内的 int 字节值。
如果在读完一批数据后首次调用read()方法，那么返回-1。表示这批数据已经读完了！
如果因已到达流末尾而没有可用的字节，则返回值 -1。在输入数据可用、检测到流的末尾或者抛出异常前，此方法一直阻塞。
子类必须提供此方法的一个实现。
返回：
下一个数据字节；
如果刚读完一批数据，则返回-1；
如果到达流的末尾，则返回 -1。
抛出：
IOException - 如果发生 I/O 错误。
 
 
如何正确使用Java I/O输出和读入数据
明白了Java的I/O流的工作机理和read方法的执行结果，我们就能够正确地使用Java I/O系统输出和读入数据了。
 
如何分批输出数据
由于read(…)方法是分批读取数据的，所以，我们应该在输出端正确地分批输出数据。
Write(…)方法，然后执行flush()方法能够将多批数据合并成一批数据输出。
尽管OutputStream这个基类的flush()方法是无用的，但是由于我们得到的OutputStream类型的输出对象都是这个类的子类的对象，所以，我们还是应该尽量使用flush()方法强制向输出流中物理输出数据，以避免错误。
 
如何分批读取数据
    我们常常使用public int read(byte[] b,
                int off,
                int len)
         throws IOException
这个方法来读取一批数据。
查看这个方法的源代码，我们可以发现，它在读取完一批数据时，又执行了一次read()方法，由于前面论述的原因，这个方法立刻返回-1，然后这个方法退出，返回这次读取的字节数。
因此，如果我们要读取一批数据，可以采用如下几种方法：
使用read()判断-1来读完一批数据：
    代码示例：
Int byte;
While((byte=inputStream.read())!=-1 ){
    Byte就是返回的字节。
 
}
如果读完一批数据后再一次执行read方法，将会立刻返回-1，表示这批数据已经读完。
 
使用read(byte[] buffer)判断是否返回小于buffer.length或者-1来判断是否读完一批数据
上面那样一个一个字节读取数据比较麻烦，我们通常使用一个字节数组来读取数据。
read(byte[] buffer)方法返回：
1，buffer.length，表示从输入流中读取到的数据塞满了这个字节数组。此时，可能已经读完了这批数据，也可能没有读完这批数据。
    如果刚好读完，那么再执行一次read()方法，就会返回-1，表示这批数据已经读完，而不是表示流已经结束。
2，小于buffer.length。表示读完了该批数据。并且执行了一次read()方法，返回-1，表示这批数据已经读完。
3，-1。这批数据已经读完了。 不可能是表示流已经结束。因为之前就会退出while循环。
   
代码示例：
Byte[] buffer=new byte[1024];
int size=buffer.length;
While(size!=-1 || size>=buffer.length){
Size=inputStream.read(buffer));
将数据读到数组buffer中。
如果读到了-1，或者 读出的数据少于buffer的尺寸，表示已经读完该批数据，不再循环读取数据了！
 
 
}
 
 
读入一批数据的操作必须对应输出一批数据的操作
读入一批数据的操作必须对应输出一批数据的操作。否则，读入数据的线程会一直阻塞，等待输出端输出下一批数据。
如果对方也需要我们提供输出数据，那么就可能会使整个流的两端的线程互相等待，死锁住。并且这个I/O流也会永远不释放，这样就会使系统的资源耗尽。
 
后记：
在前两天的工作中，我使用Socket在服务器和客户端执行操作时，出现了死锁的现象。为了找出问题的根源，我仔细查看了InputStream类和SocketInputStream类的源代码。找出了造成输入、输出流误用的原因。
希望这篇文章能够帮助饱受I/O输入、输出流问题困扰的Java程序员！
]]>