BlogJava-BaoYaEr-文章分类-java

mule事件驱动服务

大田斗 — Mon, 25 Jul 2011 08:17:00 GMT

摘要: @import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css); 面向服务的架构和事件驱动的架构天生就有着对分布式系统的适应性，这些架构都有着模块性、松散耦合，和适应性等特... 阅读全文

大田斗 2011-07-25 16:17 发表评论

JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介

大田斗 — Thu, 21 Jul 2011 09:22:00 GMT

@import url(http://www.blogjava.net/CuteSoft_Client/CuteEditor/Load.ashx?type=style&file=SyntaxHighlighter.css);@import url(/css/cuteeditor.css);

在多线程大师Doug Lea的贡献下，在JDK1.5中加入了许多对并发特性的支持，例如：线程池。
一、简介
线程池类为 java.util.concurrent.ThreadPoolExecutor，常用构造方法为：

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize,
                long keepAliveTime, TimeUnit unit,
                BlockingQueue workQueue,
                RejectedExecutionHandler handler)

   corePoolSize：线程池维护线程的最少数量，
   maximumPoolSize：线程池维护线程的最大数量
   keepAliveTime：线程池维护线程所允许的空闲时间
   unit：线程池维护线程所允许的空闲时间的单位
   workQueue：线程池所使用的缓冲队列
   handler：线程池对拒绝任务的处理策略

   一个任务通过 execute(Runnable)方法被添加到线程池，任务就是一个 Runnable类型的对象，任务的执行方法就是 Runnable类型对象的run()方法。
   当一个任务通过execute(Runnable)方法欲添加到线程池时：

   如果此时线程池中的数量小于corePoolSize，即使线程池中的线程都处于空闲状态，也要创建新的线程来处理被添加的任务。

   如果此时线程池中的数量等于 corePoolSize，但是缓冲队列 workQueue未满，那么任务被放入缓冲队列。

   如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量小于maximumPoolSize，建新的线程来处理被添加的任务。

   如果此时线程池中的数量大于corePoolSize，缓冲队列workQueue满，并且线程池中的数量等于maximumPoolSize，那么通过 handler所指定的策略来处理此任务。

   也就是：处理任务的优先级为：

   核心线程corePoolSize、任务队列workQueue、最大线程maximumPoolSize，如果三者都满了，使用handler处理被拒绝的任务。

   当线程池中的线程数量大于 corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止。这样，线程池可以动态的调整池中的线程数。

   unit可选的参数为java.util.concurrent.TimeUnit中的几个静态属性：
   NANOSECONDS、MICROSECONDS、MILLISECONDS、SECONDS。

   workQueue我常用的是：java.util.concurrent.ArrayBlockingQueue



   handler有四个选择：

   ThreadPoolExecutor.AbortPolicy()

   抛出java.util.concurrent.RejectedExecutionException异常

   ThreadPoolExecutor.CallerRunsPolicy()

   重试添加当前的任务，他会自动重复调用execute()方法

   ThreadPoolExecutor.DiscardOldestPolicy()

   抛弃旧的任务

   ThreadPoolExecutor.DiscardPolicy()

   抛弃当前的任务

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {

    private static int produceTaskSleepTime = 2;
    private static int consumeTaskSleepTime = 2000;
    private static int produceTaskMaxNumber = 10;

public static void main(String[] args) {

        //构造一个线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(2, 4, 3,
                TimeUnit.SECONDS, new ArrayBlockingQueue(3),
                new ThreadPoolExecutor.DiscardOldestPolicy());

        for(int i=1;i<=produceTaskMaxNumber;i++){
            try {
                //产生一个任务，并将其加入到线程池
                String task = "task@ " + i;
    System.out.println("put " + task);
    threadPool.execute(new ThreadPoolTask(task));

    //便于观察，等待一段时间
                Thread.sleep(produceTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
}

/**
  * 线程池执行的任务
  * @author hdpan
  */
    public static class ThreadPoolTask implements Runnable,Serializable{
     private static final long serialVersionUID = 0;
     //保存任务所需要的数据
        private Object threadPoolTaskData;

        ThreadPoolTask(Object tasks){
            this.threadPoolTaskData = tasks;
        }
        public void run(){
            //处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
   System.out.println("start .."+threadPoolTaskData);
         try {
             ////便于观察，等待一段时间
                Thread.sleep(consumeTaskSleepTime);
            } catch (Exception e) {
                e.printStackTrace();
            }
            threadPoolTaskData = null;
        }
        public Object getTask(){
            return this.threadPoolTaskData;
        }
    }
}

说明：

1、在这段程序中，一个任务就是一个Runnable类型的对象，也就是一个ThreadPoolTask类型的对象。

2、一般来说任务除了处理方式外，还需要处理的数据，处理的数据通过构造方法传给任务。

3、在这段程序中，main()方法相当于一个残忍的领导，他派发出许多任务，丢给一个叫 threadPool的任劳任怨的小组来做。

   这个小组里面队员至少有两个，如果他们两个忙不过来，任务就被放到任务列表里面。

   如果积压的任务过多，多到任务列表都装不下(超过3个)的时候，就雇佣新的队员来帮忙。但是基于成本的考虑，不能雇佣太多的队员，至多只能雇佣 4个。

   如果四个队员都在忙时，再有新的任务，这个小组就处理不了了，任务就会被通过一种策略来处理，我们的处理方式是不停的派发，直到接受这个任务为止(更残忍！呵呵)。

   因为队员工作是需要成本的，如果工作很闲，闲到 3SECONDS都没有新的任务了，那么有的队员就会被解雇了，但是，为了小组的正常运转，即使工作再闲，小组的队员也不能少于两个。

4、通过调整 produceTaskSleepTime和 consumeTaskSleepTime的大小来实现对派发任务和处理任务的速度的控制，改变这两个值就可以观察不同速率下程序的工作情况。

5、通过调整4中所指的数据，再加上调整任务丢弃策略，换上其他三种策略，就可以看出不同策略下的不同处理方式。

6、对于其他的使用方法，参看jdk的帮助，很容易理解和使用。

发邮件示例：
在普通的web应用中，发送邮件应该只能算小任务，而使用jms来发送邮件有点杀鸡用牛刀的味道，那么如果能建立一个线程池来管理这些小线程并重复使用他们，应该来说是一个简单有效的方案，我们可以使用concurrent包中的Executors来建立线程池，Executors是一个工厂，也是一个工具类，我把它的api的介绍简单的翻译了一下（如果翻译有误请大家不要吝啬手中的砖头）

/**
* 由spring管理的线程池类，返回的ExecutorService就是给我们来执行线程的
如果不交给spring管理也是可以的，可以使用单例模式来实现同样功能，但是poolSize   要hardcode了
* @author 张荣华(ahuaxuan)
* @version $Id$
*/
public class EasyMailExecutorPool implements InitializingBean {

  //线程池大小，spring配置文件中配置
  private int poolSize;
  private ExecutorService service;

  public ExecutorService getService() {
    return service;
  }

  public int getPoolSize() {
    return poolSize;
  }

  public void setPoolSize(int poolSize) {
    this.poolSize = poolSize;
  }

  /**
   * 在 bean 被初始化成功之后初始化线程池大小
   */
  public void afterPropertiesSet() throws Exception {
    service = Executors.newFixedThreadPool(poolSize);
  }
}

这样我们就初始化了线程池的大小，接下来就是如何使用这个线程池中的线程了，我们看看MailService是如何来使用线程池中的线程的，这个类中的代码我已经作了详细的解释
代码

/**
* 用来发送 mail 的 service, 其中有一个内部类专门用来供线程使用
* @author 张荣华(ahuaxuan)
* @since 2007-7-11
* @version $Id$
*/
public class EasyMailServieImpl implements EasyMailService{
  private static transient Log logger = LogFactory.getLog(EasyMailServieImpl.class);

  //注入MailSender
  private JavaMailSender javaMailSender;

  //注入线程池
  private EasyMailExecutorPool easyMailExecutorPool;

  //设置发件人
  private String from;

  public void setEasyMailExecutorPool(EasyMailExecutorPool easyMailExecutorPool) {
    this.easyMailExecutorPool = easyMailExecutorPool;
  }

  public void setJavaMailSender(JavaMailSender javaMailSender) {
    this.javaMailSender = javaMailSender;
  }

  public void setFrom(String from) {
    this.from = from;
  }

  /**
   * 简单的邮件发送接口，感兴趣的同学可以在这个基础上继续添加
   * @param to
   * @param subject
   * @param text
   */
  public void sendMessage(EmailEntity email){
    if (null == email) {
      if (logger.isDebugEnabled()) {
        logger.debug("something you need to tell here");
      }
      return;
    }
    SimpleMailMessage simpleMailMessage = new SimpleMailMessage();

    simpleMailMessage.setTo(email.getTo());
    simpleMailMessage.setSubject(email.getSubject());
    simpleMailMessage.setText(email.getText());
    simpleMailMessage.setFrom(from);

    easyMailExecutorPool.getService().execute(new MailRunner(simpleMailMessage));
  }

  /**
   * 发送复杂格式邮件的接口，可以添加附件，图片，等等，但是需要修改这个方法，
   * 如何做到添加附件和图片论坛上有例子了，需要的同学搜一下,
   * 事实上这里的text参数最好是来自于模板，用模板生成html页面，然后交给javamail去发送，
   * 如何使用模板来生成html见 {@link http://www.iteye.com/topic/71430 }
   *
   * @param to
   * @param subject
   * @param text
   * @throws MessagingException
   */
  public void sendMimeMessage(EmailEntity email) throws MessagingException {
    if (null == email) {
      if (logger.isDebugEnabled()) {
        logger.debug("something you need to tell here");
      }
      return;
    }
    MimeMessage message = javaMailSender.createMimeMessage();
    MimeMessageHelper helper = new MimeMessageHelper(message);

    helper.setTo(email.getTo());
    helper.setFrom(from);
    helper.setSubject(email.getSubject());

    this.addAttachmentOrImg(helper, email.getAttachment(), true);
    this.addAttachmentOrImg(helper, email.getImg(), false);

    //这里的text是html格式的, 可以使用模板引擎来生成html模板, velocity或者freemarker都可以做到
    helper.setText(email.getText(),true);

    easyMailExecutorPool.getService().execute(new MailRunner(message));
  }

  /**
   * 添加附件或者是图片
   * @param helper
   * @param map
   * @param isAttachment
   * @throws MessagingException
   */
  private void addAttachmentOrImg(MimeMessageHelper helper, Map map, boolean isAttachment) throws MessagingException {
    for (Iterator it = map.entrySet().iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry) it.next();
      String key = (String) entry.getKey();
      String value = (String) entry.getValue();
      if (StringUtils.isNotBlank(key) && StringUtils.isNotBlank(value)) {
        FileSystemResource file = new FileSystemResource(new File(value));
        if (!file.exists()) continue;
        if (isAttachment) {
          helper.addAttachment(key, file);
        } else {
          helper.addInline(key, file);
        }
      }
    }
  }

  /**
   * 用来发送邮件的 Runnable, 该类是一个内部类，之所以使用内部类，而没有使用嵌套类（静态内部类），
   * 是因为内部类可以之间得到 service 的 javaMailSender
   * 每次发送邮件都会从线程池中取一个线程, 然后进行发邮件操作
   * @author ahuaxuan
   */
  private class MailRunner implements Runnable {
    SimpleMailMessage simpleMailMessage;
    MimeMessage mimeMessage;

    /**
     * 构造简单文本邮件
     * @param simpleMailMessage
     */
    public MailRunner(SimpleMailMessage simpleMailMessage) {
      if (mimeMessage == null) {
        this.simpleMailMessage = simpleMailMessage;
      }
    }

    /**
     * 构造复杂邮件，可以添加附近，图片，等等
     * @param mimeMessage
     */
    public MailRunner(MimeMessage mimeMessage) {
      if (simpleMailMessage == null) {
        this.mimeMessage = mimeMessage;
      }
    }

    /**
     * 该方法将在线程池中的线程中执行
     */
    public void run() {
      try {
        if (simpleMailMessage != null) {
          javaMailSender.send(this.simpleMailMessage);
        } else if (mimeMessage != null) {
          javaMailSender.send(this.mimeMessage);
        }

            } catch (Exception e) {
              if (logger.isDebugEnabled()) {
                logger.debug("logger something here", e);
              }
            }
    }
  }
}

MailService中的EmailEntity是对邮件的抽象(我只使用了失血模型，事实上我们也可以让这个EmailEntity来实现Runnable接口，这样Service中的内部类就可以去掉了，同时service中的大部分代码就要搬到EmailEntity及其父类里了，大家更倾向于怎么做呢？)，代码如下:

代码

/**
* 该类是对邮件的抽象，邮件有哪些属性，这个类就有哪些属性显然这个只是一个例子，
* 这个例子中附带mimemessage发送所需的附件或者图片（如果有的话）
* 需要使用的同学自己扩展
*
* @author 张荣华(ahuaxuan)
* @version $Id$
*/
public class EmailEntity {

  String to;

  String subject;

  String text;

  //邮件附件
  Map

大田斗 2011-07-21 17:22 发表评论

在xml的汪洋中遨游之mule篇

大田斗 — Fri, 01 Jul 2011 03:52:00 GMT

摘要: mule号称开源ESB的最好实现，研究mule也有段时间了，在“浩如烟海”的xml配置中，保持清醒的头脑确实不容易。作为学习笔记之一，记录一下一个mule简单应用的实现。需求：给指定的email地址发送邮件. 一：基本实现： 1: 实现命令行输入发送email：为了能在命令行接受输入，需要配置一个输入输出连... 阅读全文

大田斗 2011-07-01 11:52 发表评论

linux下java运行脚本

大田斗 — Thu, 25 Feb 2010 06:39:00 GMT

/home/guest/java6/jdk1.6.0_14/bin/java -Xms10M -Xmx10M -Djava.ext.dirs=../lib/
-Dlog4j.configuration=./conf/log4j.properties
cn.cnnic.regstat.Main &

大田斗 2010-02-25 14:39 发表评论

深入浅出之正则表达式【zt】

大田斗 — Fri, 16 Oct 2009 02:43:00 GMT

摘要: 深入浅出之正则表达式（一）前言：半年前我对正则表达式产生了兴趣，在网上查找过不少资料，看过不少的教程，最后在使用一个正则表达式工具RegexBuddy时发现他的教程写的非常好，可以说是我目前见过最好的正则表达式教程。于是一直想把他翻译过来。这个愿望直到这个五一长假才得以实现，结果就有了这篇文章。关于... 阅读全文

大田斗 2009-10-16 10:43 发表评论

JavaClassLoader与Package机制

大田斗 — Wed, 11 Feb 2009 06:10:00 GMT

为了深入了解Java的ClassLoader机制，我们先来做以下实验：

package java.lang;
public class Test {
　public static void main(String[] args) {
　char[] c = "1234567890".toCharArray();
　String s = new String(0, 10, c);
　　}
}

String类有一个Package权限的构造函数String(int offset, int length, char[] array)，按照默认的访问权限，由于Test属于java.lang包，因此理论上应该可以访问String的这个构造函数。编译通过！执行时结果如下：
　　Exception in thread "main" java.lang.SecurityException: Prohibited package name:
　　java.lang
　　 at java.lang.ClassLoader.defineClass(Unknown Source)
　　 at java.security.SecureClassLoader.defineClass(Unknown Source)
　　 at java.net.URLClassLoader.defineClass(Unknown Source)
　　 at java.net.URLClassLoader.Access$100(Unknown Source)
　　 at java.net.URLClassLoader$1.run(Unknown Source)
　　 at java.security.AccessController.doPrivileged(Native Method)
　　 at java.net.URLClassLoader.findClass(Unknown Source)
　　 at java.lang.ClassLoader.loadClass(Unknown Source)
　　 at sun.misc.Launcher$AppClassLoader.loadClass(Unknown Source)
　　 at java.lang.ClassLoader.loadClass(Unknown Source)
　　 at java.lang.ClassLoader.loadClassInternal(Unknown Source)
　　希奇吧？要弄清为什么会有SecurityException，就必须搞清楚ClassLoader的机制。

Java的ClassLoader就是用来动态装载class的，ClassLoader对一个class只会装载一次，JVM使用的ClassLoader一共有4种：
　　启动类装载器，标准扩展类装载器，类路径装载器和网络类装载器。
　　这4种ClassLoader的优先级依次从高到低，使用所谓的“双亲委派模型”。确切地说，假如一个网络类装载器被请求装载一个java.lang.Integer，它会首先把请求发送给上一级的类路径装载器，假如返回已装载，则网络类装载器将不会装载这个java.lang.Integer，假如上一级的类路径装载器返回未装载，它才会装载java.lang.Integer。
　　类似的，类路径装载器收到请求后（无论是直接请求装载还是下一级的ClassLoader上传的请求），它也会先把请求发送到上一级的标准扩展类装载器，这样一层一层上传，于是启动类装载器优先级最高，假如它按照自己的方式找到了java.lang.Integer，则下面的ClassLoader 都不能再装载java.lang.Integer，尽管你自己写了一个java.lang.Integer，试图取代核心库的java.lang.Integer是不可能的，因为自己写的这个类根本无法被下层的ClassLoader装载。
　　
　　再说说Package权限。Java语言规定，在同一个包中的class，假如没有修饰符，默认为Package权限，包内的class都可以访问。但是这还不够准确。确切的说，只有由同一个ClassLoader装载的class才具有以上的Package权限。比如启动类装载器装载了java.lang.String，类路径装载器装载了我们自己写的java.lang.Test，它们不能互相访问对方具有Package权限的方法。这样就阻止了恶意代码访问核心类的Package权限方法。

大田斗 2009-02-11 14:10 发表评论

JTA事务初级研究

大田斗 — Thu, 25 Dec 2008 01:28:00 GMT

一般情况下，J2EE应用服务器支持JDBC事务、JTA事务、容器管理事务。这里讨论JTA和JDBC事务的区别。这2个是常用的DAO模式事务界定方式。
JDBC 事务
JDBC 事务是用 Connection 对象控制的。JDBC Connection 接口( java.sql.Connection )提供了两种事务模式：自动提交和手工提交。
★ 在jdbc中，事务操作缺省是自动提交。也就是说，一条对数据库的更新表达式代表一项事务操作，操作成功后，系统将自动调用commit()来提交，否则将调用rollback()来回滚。
★ 在jdbc中，可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用 rollback()进行回滚。这样做可以保持多次更新操作后，相关数据的一致性，示例如下：

try {
   conn = DriverManager.getConnection
   conn.setAutoCommit(false);//禁止自动提交，设置回滚点
   stmt = conn.createStatement();
   stmt.executeUpdate(“alter table …”); //数据库更新操作1
   stmt.executeUpdate(“insert into table …”); //数据库更新操作2
   conn.commit(); //事务提交
}catch(Exception ex) {
   ex.printStackTrace();
   try {
      conn.rollback(); //操作不成功则回滚
   }catch(Exception e) {
       e.printStackTrace();
   }
}

JDBC 事务的一个缺点是事务的范围局限于一个数据库连接。一个 JDBC 事务不能跨越多个数据库。

JTA事务
JTA(Java Transaction API) 为 J2EE 平台提供了分布式事务服务。
要用 JTA 进行事务界定，应用程序要调用 javax.transaction.UserTransaction 接口中的方法。例如：

      utx.begin();
      //
      DataSource ds = obtainXADataSource();
      Connection conn = ds.getConnection();
      pstmt = conn.prepareStatement("UPDATE MOVIES ");
      pstmt.setString(1, "Spinal Tap");
      pstmt.executeUpdate();
      //
      utx.commit();

“用 JTA 界定事务，那么就需要有一个实现 javax.sql.XADataSource 、 javax.sql.XAConnection 和 javax.sql.XAResource 接口的 JDBC 驱动程序。一个实现了这些接口的驱动程序将可以参与 JTA 事务。一个 XADataSource 对象就是一个 XAConnection 对象的工厂。 XAConnection s 是参与 JTA 事务的 JDBC 连接。”
要使用JTA事务，必须使用XADataSource来产生数据库连接，产生的连接为一个XA连接。
XA连接（javax.sql.XAConnection）和非XA（java.sql.Connection）连接的区别在于：XA可以参与JTA的事务，而且不支持自动提交。

Note:
Oracle, Sybase, DB2, SQL Server等大型数据库才支持XA, 支持分布事务。
My SQL 连本地都支持不好，更别说分布事务了。

JTA方式的实现过程：
用XADataSource产生的XAConnection它扩展了一个getXAResource()方法,事务通过这个方法把它加入到事务容器中进行管理.对于调用者来说,根本看不到事务是如果管理的,你只要声明开始事务,告诉容器我下面的操作要求事务参与了,最后告诉事务说到这儿可以提交或回滚了, 别的都是黑箱操作。
在使用JTA之前，你必须首先实现一个Xid类用来标识事务（在普通情况下这将由事务管理程序来处理）。Xid包含三个元素：formatID、gtrid（全局事务标识符）和bqual（分支修饰词标识符）。
下面的例子说明Xid的实现：

import javax.transaction.xa.*;
public class MyXid implements Xid {
   protected int formatId;
   protected byte gtrid[];
   protected byte bqual[];
   public MyXid() {
   }
   public MyXid(int formatId, byte gtrid[], byte bqual[]) {
    this.formatId = formatId;
    this.gtrid = gtrid;
    this.bqual = bqual;
   }

　public int getFormatId() {
    return formatId;
    }

　public byte[] getBranchQualifier() {
    return bqual;
    }

　public byte[] getGlobalTransactionId() {
    return gtrid;
    }
}

其次，你需要创建一个你要使用的数据库的数据源：

public DataSource getDataSource() throws SQLException {
SQLServerDataSource xaDS = new
com.merant.datadirect.jdbcx.sqlserver.SQLServerDataSource();
xaDS.setDataSourceName("SQLServer");
xaDS.setServerName("server");
xaDS.setPortNumber(1433);
xaDS.setSelectMethod("cursor");
return xaDS;
}

这个例子是用“两步提交协议”来提交一个事务分支：

XADataSource xaDS;
XAConnection xaCon;
XAResource xaRes;
Xid xid;
Connection con;
Statement stmt;
int ret;
xaDS = getDataSource();
xaCon = xaDS.getXAConnection("jdbc_user", "jdbc_password");
xaRes = xaCon.getXAResource();
con = xaCon.getConnection();
stmt = con.createStatement();
xid = new MyXid(100, new byte[]{0x01}, new byte[]{0x02});
try {
xaRes.start(xid, XAResource.TMNOFLAGS);
stmt.executeUpdate("insert into test_table values (100)");
xaRes.end(xid, XAResource.TMSUCCESS);
ret = xaRes.prepare(xid);
if (ret == XAResource.XA_OK) {
xaRes.commit(xid, false);
}
}
catch (XAException e) {
e.printStackTrace();
}
finally {
stmt.close();
con.close();
xaCon.close();
}

两阶段提交（Two-Phase-Commit）协议

首先，两阶段提交（Two-Phase-Commit）事务的启动与常规的单阶段提交（One-Phase-Commit）事务类似。接着，应用程序/客户机对该两阶段提交（Two-Phase-Commit）操作中所涉及的所有数据库执行其修改工作。现在，在最终提交该事务之前，客户机通知参与的数据库准备提交（第 1 阶段）。如果客户机从数据库收到一条“okay”，就发出命令向数据库提交该事务（第 2 阶段）。最后分布式事务（Distributed Transaction）结束。

在该应用程序中，如果一个事务分支报告了错误，您就要负责进行错误处理。但是“两阶段提交协议简介”小节中提到仍然存在一个问题，那就是如果第 2 阶段中一个事务分支发生故障，该怎么办呢？

如果再次查看程序代码，您可以看到在“第 1 阶段”和“第 2 阶段”之间有一个很小的时间间隔。在这一时间间隔中，出于某种理由，其中某一参与数据库可能崩溃。如果发生了，我们将陷入分布式事务已经部分提交的情形中。

假定下列情形：在“第 1 阶段”之后，您从 DB2 和 IDS 数据库中都收到了“okay”。在下一步中，应用程序成功提交了 DB2 的事务分支。接着，应用程序通知 DB2 事务分支提交事务。现在，在应用程序可以通知 IDS 事务分支提交它这一部分之前，IDS 引擎由于断电发生崩溃。这就是一种部分提交全局事务的情形。您现在该怎么办呢？

在重启之后，DB2 和 IDS 都将尝试恢复打开的事务分支。该引擎等待来自应用程序的提示如何做。如果应用程序没有准备重新发送“第 2 阶段”的提交，该事务分支将被引擎所启动的试探性回滚中止。这是非常糟糕的，因为这将使该全局事务处于不一致状态。

一种解决方案是用一个小型应用程序连接引擎中打开的事务分支，并通知引擎提交或回滚这一打开的事务。如果您使用 IDS 作为后端，那么还有一个隐藏的 onmode 标志，允许您结束打开的事务分支。（onmode -Z xid）。

在 DB2 UDB 中，您可以发出 LIST INDOUBT TRANSACTIONS 来获得打开的 XA 事务的有关信息。您必须查看 DB2 Information Center 中的描述来解决该问题。

上面描述的情形是一个很好的例子，也是使用应用程序服务器（Application Server）或事务监控器（Transaction Monitor）的理由。在使用一个中间层服务器时，就由该服务器负责保持事情正常。

大田斗 2008-12-25 09:28 发表评论

Spring2.5注释语法

大田斗 — Tue, 11 Nov 2008 03:36:00 GMT

摘要: Spring的IoC public class Foo {① private String name; private int age; public String toString(){ &... 阅读全文

大田斗 2008-11-11 11:36 发表评论

java annotation

大田斗 — Fri, 07 Nov 2008 08:44:00 GMT

Annotation简介：
Annotation提供一种机制，将程序中元素（如类、方法、属性等）和元数据联系起来。这样编译器可以将元数据保存的class文件中。代码分析工具就可以使用这些元数据执行的额外任务。注释采用“at”标记形式 ( @ )，后面是注释名称。

自定义 annotationDebug.java

package annotation.test;

import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.ElementType;
import java.lang.annotation.Target;

    /*
     * annotation类型是一种接口，能够通过java反射API的方式提供对其信息的访问
     */

    /*
     * Documented 产生Java Doc文件，这次可以看到文件中包括了@Debug的信息
     */
@Documented
    /*
     * 限定 annotation 使用对象 - Target
     * 在定义annotation时，使用java.lang.annotation.Target可以定义annotation使用的时机。
     * public enum ElementType {
     *   TYPE, // 适用 class, interface, enum
     *   FIELD, // 适用 field
     *   METHOD, // 适用 method
     *   PARAMETER, // 适用 method 上之 parameter
     *   CONSTRUCTOR, // 适用 constructor
     *   LOCAL_VARIABLE, // 适用区域变量
     *   ANNOTATION_TYPE, // 适用 annotation 型态
     *   PACKAGE // 适用 package
     *   }
     */
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})//指定目标
    /*
     * Retention 在你自定义的形态中，指定编译器如何处理自定义的annotation
     * 告知编译器如何处理 annotaion - Retention
     * RetentionPolicy
     *         SOURCE        编译器处理完Annotation信息后就没事了
     *         CLASS        编译器将Annotation储存于class档中，预设
     *         RUNTIME        编译器将Annotation储存于class檔中，可由VM读入
     *                     使用java设计的一个程序代码工具，从VM中读出Annotation信息，已在分析程序中使用。
     *                     搭配Reflection机制，就可以实现。
     *
     *         J2SE 5.0中新增了java.lang.reflect.AnnotatedElement这个接口，当中定义有四个方法：
     *                 public Annotation getAnnotation(Class annotationType);
     *                 public Annotation[] getAnnotations();
     *                 public Annotation[] getDeclaredAnnotations();
     *                 public boolean isAnnotationPresent(Class annotationType);
     *         Class、Constructor、Field、Method、Package等类别，都实作了 AnnotatedElement这个接口，
     *         所以您可以从这些类别的实例上，分别取得标示于其上的Annotation与其信息，
     *         如果 RetentionPolicy为RUNTIME的话。

     */

@Retention(RetentionPolicy.RUNTIME)//设置保持性
    /*
     * @Inherited 子类是否继承父类的 annotation
     */
@Inherited
public @interface Debug {
    //定义了value()方法，编译器在编译时会自动帮您产生一个value的变量成员，接着在使用Debug Annotation时要指定值
    //注释类型的数据成员被设置成使用有限信息进行工作
    //定义数据成员不需要分别定义访问和修改的方法，只需定义一个方法，以数据成员的名称命名它，数据类型应该是该方法返回值的类型．
    String value()default "windfree";//默认值的类型必需与成员变量的申明类型一置
    String name();
}

在程序中使用自定义的annotation
TestDebug.java

package annotation.test;

public class TestDebug {
    @Debug(
               name = "zgliu"
            )
     public void doSomething() {
        }
}

使用java中反射API读取class中的元数据的信息
DebugTool.java：

package annotation.test;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class DebugTool {
    public static void main(String []args)throws NoSuchMethodException {
        Class<TestDebug> c=TestDebug.class;
        Method method = c.getMethod("doSomething");
        if(method.isAnnotationPresent(Debug.class)) {
            System.out.println("@Debug is found.");
            Debug debug = method.getAnnotation(Debug.class);
            System.out.println("\tvalue = " + debug.value());
            System.out.println("\tname = " + debug.name());
        }
        else {
            System.out.println("@Debug is not found.");
        }

        Annotation[] annotations = method.getAnnotations();
        for(Annotation annotation : annotations) {
            System.out.println(
                    annotation.annotationType().getName());
        }
    }
}

Java标准Annotation
@Deprecated 相当于Javadoc的@deprecated，被@Deprecated标注的对象class, method等被注明为不推荐使用。主要用于javac等编译工具。
@Override 注明对象method重载了父类的方法。javac等编译工具编译时会根据此Annotation判断重载方法是否正确。
@SuppressWarnings 告诉javac等编译器忽略所指定的特定的警告信息。
@Target 被定义的annotation可以附加在那些对象上。
@Retention annotation的作用期间。

定义一个annotation

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {①定义一个注释
int init();
}

import java.lang.annotation.Annotation;
public class TestAnnotation {
  @MyAnnotation(init = 2)②使用注释
  public void print(){
     System.out.println(TestAnnotation.class.getName());
  }
  public static void main(String[] args) throws Exception{
     TestAnnotation ta = new TestAnnotation();
     Annotation[] annotations = ta.getClass().getMethod("print").getAnnotations();③
     for (Annotation annotation : annotations)  {
         System.out.println("MyAnnotation.init : " +
       ((MyAnnotation)annotation).init());④打印出init的值
        }
  }
}

我们定义了一个名为MyAnnotation的注释而这个注释中只有一个类型为int名为init的属性，我们在②处使用了我们刚刚定义的注释并且为init赋值为2，在③处我们通过反射机制获得print方法上定义的所有注释然后通过迭代将其值init打印至控制台。

最终在控制台输出以下信息：
MyAnnotation.init : 2

大田斗 2008-11-07 16:44 发表评论

J2SE5.0中最有趣的新特性：注释(annotation) [zt]

大田斗 — Fri, 01 Aug 2008 07:29:00 GMT

摘要: 本文将向你介绍J2SE5.0中的新特性之一：注释。本文将从什么是注释；J2SE5.0中预定义的注释；如何自定义注释；如何对注释进行注释以及如何在程序中读取注释5个方面进行讨论。一、什么是注释说起注释，得先提一提什么是元数据(metadata)。所谓元数据就是数据的数据。也就是说，元数据是描述数据的。就象数据表中的字... 阅读全文

大田斗 2008-08-01 15:29 发表评论

java nio 在探索

大田斗 — Thu, 12 Jun 2008 09:24:00 GMT

摘要: nio之所以为为新，在于它并没在原来I/O的基础上进行开发，而是提供了全新的类和接口，除了原来的基本功能之外，它还提供了以下新的特征： ► 多路选择的非封锁式I/O设施 ►支持文件锁和内存映射 &n... 阅读全文

大田斗 2008-06-12 17:24 发表评论

java 代码优化

大田斗 — Thu, 05 Jun 2008 02:49:00 GMT

Java程序中的内存管理机制是通过GC完成的，“一个对象创建后被放置在JVM的堆内存中，当永远不在应用这个对象的时候将会被JVM在堆内存中回收。被创建的对象不能再生，同时也没有办法通过程序语句释放”（这个是《Java的GC机制》中提到的定义，呵呵，还依稀记得）这就是GC对垃圾对象的定义。个人感觉这么解释或许会比较快理解：在运行环境中JVM会对两种内存进行管理，一种是堆内存（对象实例或者变量），一种是栈内存（静态或非静态方法），而JVM所管理的内存区域实际上就是堆内存＋栈内存（MS：对象实例＋实例化变量＋静态方法＋非静态方法），当JVM在其所管理的内存区域的中无法通过根集合到达对象的时候就会将此对象作为垃圾对象实施回收。

下面是我在项目中对代码进行优化的几点尝试，备忘

1.循环优化
缺：

List alist=uSvr.getUserinfoList();

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

}

此种方式会一直去执行alist.size()方法，带来性能消耗，改为

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

}

2.循环内不要创建对象
缺;

for(int i=1;i<=domainCount;i++){
.
AuditResult auditResult = new AuditResult();
..
}

这种做法会在内存中保存N份这个对象的引用//会浪费大量的内存空间，改为

AuditResult auditResult;
for(int i=1;i<=domainCount;i++){
.
auditResult=new AuditResult();
..
}

3. 什么样的对象可以将其认定为不可视阶段呢？举个例子吧，在try{...}catch(Exception){...}代码中，如果在try的代码块中声明了一个obj，那么当整个 try{...}catch(Exception){...}代码段执行完毕以后这个obj实际上就已经属于不可视阶段了。

所以，应该采用如下方式

try{

Object obj=new Object();
}catch(Excepione e){
obj=null;
}

4.少用new创建对象
用new关键词创建类的实例时，构造函数链中的所有构造函数都会被自动调用。但如果一个对象实现了Cloneable接口，我们可以调用它的clone()方法。clone()方法不会调用任何类构造函数。
缺：
在使用设计模式(Design Pattern)的场合，如果用Factory模式创建对象，则改用clone()方法创建新的对象实例非常简单。例如，下面是Factory模式的一个典型实现：

public static Credit getNewCredit()
　　{
return new Credit();

　　}

改为

private static Credit BaseCredit = new Credit();
　　public static Credit getNewCredit() 　{
　　　return (Credit) BaseCredit.clone();
　　}

当new创建对象不可避免时，注意避免多次的使用new初始化一个对象。尽量在使用时再创建该对象。
缺：

NewObject object = new NewObject();
int value;
if(i＞0 )
{
　value =object.getValue();
}

改为

int value;
if(i＞0 )
{
　NewObject object = new NewObject();
　Value =object.getValue();
}

5.乘法和除法考虑

缺：

　for (val = 0; val < 100000; val +=5) {
　　　alterX = val * 8;
　　　myResult = val * 2;
　　}

改为：

for (val = 0; val < 100000; val += 5) {
　　　alterX = val << 3;
　　　myResult = val << 1;
　　}

6.尽量多的使用stringbuffer
7清除Session
　　通常情况，当达到设定的超时时间时，同时有些Session没有了活动，服务器会释放这些没有活动的Session，.. 不过这种情况下，特别是多用户并访时，系统内存要维护多个的无效Session。
当用户退出时，应该手动释放，回收资源，实现如下：

HttpSession theSession = request.getSession();
// 获取当前Session
if(theSession != null){
　theSession.invalidate(); // 使该Session失效
}

NOTE：堆内存是在JVM启动的时候创建，堆内存分为新对象与老对象。对于新对象好像会分三个区域。当优先级最高的区域的堆栈满了以后JVM将会进行测试，测试内容是那些对象不可到达，不可到达的对象将会放入到老对象区域。同时JVM会将所有对象拷贝到另外两个区域中，然后经过一段时间依然没有引用的对象会进入老对象区域。对于老对象区域而言基本上就是等待被GC回收的对象了。（这些还是在大学时学.net时候的知识，直接换成java定义我想其中概念应该一样。

大田斗 2008-06-05 10:49 发表评论

SSO单点登录解决方案[转载]

大田斗 — Mon, 26 May 2008 05:26:00 GMT

SSO单点登录解决方案[转载]

1 什么是单点登陆
      单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一。SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统。
      较大的企业内部，一般都有很多的业务支持系统为其提供相应的管理和IT服务。例如财务系统为财务人员提供财务的管理、计算和报表服务；人事系统为人事部门提供全公司人员的维护服务；各种业务系统为公司内部不同的业务提供不同的服务等等。这些系统的目的都是让计算机来进行复杂繁琐的计算工作，来替代人力的手工劳动，提高工作效率和质量。这些不同的系统往往是在不同的时期建设起来的，运行在不同的平台上；也许是由不同厂商开发，使用了各种不同的技术和标准。如果举例说国内一著名的IT公司（名字隐去），内部共有60多个业务系统，这些系统包括两个不同版本的SAP的ERP系统，12个不同类型和版本的数据库系统，8个不同类型和版本的操作系统，以及使用了3种不同的防火墙技术，还有数十种互相不能兼容的协议和标准，你相信吗？不要怀疑，这种情况其实非常普遍。每一个应用系统在运行了数年以后，都会成为不可替换的企业IT架构的一部分，如下图所示。

      随着企业的发展，业务系统的数量在不断的增加，老的系统却不能轻易的替换，这会带来很多的开销。其一是管理上的开销，需要维护的系统越来越多。很多系统的数据是相互冗余和重复的，数据的不一致性会给管理工作带来很大的压力。业务和业务之间的相关性也越来越大，例如公司的计费系统和财务系统，财务系统和人事系统之间都不可避免的有着密切的关系。

      为了降低管理的消耗，最大限度的重用已有投资的系统，很多企业都在进行着企业应用集成（EAI）。企业应用集成可以在不同层面上进行：例如在数据存储层面上的“数据大集中”，在传输层面上的“通用数据交换平台”，在应用层面上的“业务流程整合”，和用户界面上的“通用企业门户”等等。事实上，还用一个层面上的集成变得越来越重要，那就是“身份认证”的整合，也就是“单点登录”。

      通常来说，每个单独的系统都会有自己的安全体系和身份认证系统。整合以前，进入每个系统都需要进行登录，这样的局面不仅给管理上带来了很大的困难，在安全方面也埋下了重大的隐患。下面是一些著名的调查公司显示的统计数据：

用户每天平均16分钟花在身份验证任务上 - 资料来源：IDS
频繁的IT用户平均有21个密码 - 资料来源：NTA Monitor Password Survey
49%的人写下了其密码，而67%的人很少改变它们
每79秒出现一起身份被窃事件 - 资料来源：National Small Business Travel Assoc
全球欺骗损失每年约12B - 资料来源：Comm Fraud Control Assoc
到2007年，身份管理市场将成倍增长至$4.5B - 资料来源：IDS

使用“单点登录”整合后，只需要登录一次就可以进入多个系统，而不需要重新登录，这不仅仅带来了更好的用户体验，更重要的是降低了安全的风险和管理的消耗。请看下面的统计数据：

提高IT效率：对于每1000个受管用户，每用户可节省$70K
帮助台呼叫减少至少1/3，对于10K员工的公司，每年可以节省每用户$75，或者合计$648K
生产力提高：每个新员工可节省$1K，每个老员工可节省$350 - 资料来源：Giga
ROI回报：7.5到13个月 - 资料来源：Gartner

      另外，使用“单点登录”还是SOA时代的需求之一。在面向服务的架构中，服务和服务之间，程序和程序之间的通讯大量存在，服务之间的安全认证是SOA应用的难点之一，应此建立“单点登录”的系统体系能够大大简化SOA的安全问题，提高服务之间的合作效率。
   2 单点登陆的技术实现机制
      随着SSO技术的流行，SSO的产品也是满天飞扬。所有著名的软件厂商都提供了相应的解决方案。在这里我并不想介绍自己公司（Sun Microsystems）的产品，而是对SSO技术本身进行解析，并且提供自己开发这一类产品的方法和简单演示。有关我写这篇文章的目的，请参考我的博客（http://yuwang881.blog.sohu.com/3184816.html）。

      单点登录的机制其实是比较简单的，用一个现实中的例子做比较。颐和园是北京著名的旅游景点，也是我常去的地方。在颐和园内部有许多独立的景点，例如“苏州街”、“佛香阁”和“德和园”，都可以在各个景点门口单独买票。很多游客需要游玩所有德景点，这种买票方式很不方便，需要在每个景点门口排队买票，钱包拿进拿出的，容易丢失，很不安全。于是绝大多数游客选择在大门口买一张通票（也叫套票），就可以玩遍所有的景点而不需要重新再买票。他们只需要在每个景点门口出示一下刚才买的套票就能够被允许进入每个独立的景点。
      单点登录的机制也一样，如下图所示，当用户第一次访问应用系统1的时候，因为还没有登录，会被引导到认证系统中进行登录（1）；根据用户提供的登录信息，认证系统进行身份效验，如果通过效验，应该返回给用户一个认证的凭据－－ticket（2）；用户再访问别的应用的时候（3，5）就会将这个ticket 带上，作为自己认证的凭据，应用系统接受到请求之后会把ticket送到认证系统进行效验，检查ticket的合法性（4，6）。如果通过效验，用户就可以在不用再次登录的情况下访问应用系统2和应用系统3了。

      从上面的视图可以看出，要实现SSO，需要以下主要的功能：

所有应用系统共享一个身份认证系统。
统一的认证系统是SSO的前提之一。认证系统的主要功能是将用户的登录信息和用户信息库相比较，对用户进行登录认证；认证成功后，认证系统应该生成统一的认证标志（ticket），返还给用户。另外，认证系统还应该对ticket进行效验，判断其有效性。
所有应用系统能够识别和提取ticket信息
要实现SSO的功能，让用户只登录一次，就必须让应用系统能够识别已经登录过的用户。应用系统应该能对ticket进行识别和提取，通过与认证系统的通讯，能自动判断当前用户是否登录过，从而完成单点登录的功能。

上面的功能只是一个非常简单的SSO架构，在现实情况下的SSO有着更加复杂的结构。有两点需要指出的是：

单一的用户信息数据库并不是必须的，有许多系统不能将所有的用户信息都集中存储，应该允许用户信息放置在不同的存储中，如下图所示。事实上，只要统一认证系统，统一ticket的产生和效验，无论用户信息存储在什么地方，都能实现单点登录。

统一的认证系统并不是说只有单个的认证服务器，如下图所示，整个系统可以存在两个以上的认证服务器，这些服务器甚至可以是不同的产品。认证服务器之间要通过标准的通讯协议，互相交换认证信息，就能完成更高级别的单点登录。如下图，当用户在访问应用系统1时，由第一个认证服务器进行认证后，得到由此服务器产生的ticket。当他访问应用系统4的时候，认证服务器2能够识别此ticket是由第一个服务器产生的，通过认证服务器之间标准的通讯协议（例如SAML）来交换认证信息，仍然能够完成SSO的功能。

    3 WEB-SSO的实现
      随着互联网的高速发展，WEB应用几乎统治了绝大部分的软件应用系统，因此WEB-SSO是SSO应用当中最为流行。WEB-SSO有其自身的特点和优势，实现起来比较简单易用。很多商业软件和开源软件都有对WEB-SSO的实现。其中值得一提的是OpenSSO （https://opensso.dev.java.net），为用Java实现WEB-SSO提供架构指南和服务指南，为用户自己来实现WEB-SSO提供了理论的依据和实现的方法。
      为什么说WEB-SSO比较容易实现呢？这是有WEB应用自身的特点决定的。
      众所周知，Web协议（也就是HTTP）是一个无状态的协议。一个Web应用由很多个Web页面组成，每个页面都有唯一的URL来定义。用户在浏览器的地址栏输入页面的URL，浏览器就会向Web Server去发送请求。如下图，浏览器向Web服务器发送了两个请求，申请了两个页面。这两个页面的请求是分别使用了两个单独的HTTP连接。所谓无状态的协议也就是表现在这里，浏览器和Web服务器会在第一个请求完成以后关闭连接通道，在第二个请求的时候重新建立连接。Web服务器并不区分哪个请求来自哪个客户端，对所有的请求都一视同仁，都是单独的连接。这样的方式大大区别于传统的（Client/Server）C/S结构,在那样的应用中，客户端和服务器端会建立一个长时间的专用的连接通道。正是因为有了无状态的特性，每个连接资源能够很快被其他客户端所重用，一台Web服务器才能够同时服务于成千上万的客户端。

      但是我们通常的应用是有状态的。先不用提不同应用之间的SSO，在同一个应用中也需要保存用户的登录身份信息。例如用户在访问页面1的时候进行了登录，但是刚才也提到，客户端的每个请求都是单独的连接，当客户再次访问页面2的时候，如何才能告诉Web服务器，客户刚才已经登录过了呢？浏览器和服务器之间有约定：通过使用cookie技术来维护应用的状态。Cookie是可以被Web服务器设置的字符串，并且可以保存在浏览器中。如下图所示，当浏览器访问了页面1时，web服务器设置了一个cookie，并将这个cookie和页面1一起返回给浏览器，浏览器接到cookie之后，就会保存起来，在它访问页面2的时候会把这个cookie也带上，Web服务器接到请求时也能读出cookie的值，根据cookie值的内容就可以判断和恢复一些用户的信息状态。

      Web-SSO完全可以利用Cookie结束来完成用户登录信息的保存，将浏览器中的Cookie和上文中的Ticket结合起来，完成SSO的功能。

      为了完成一个简单的SSO的功能，需要两个部分的合作：

统一的身份认证服务。
修改Web应用，使得每个应用都通过这个统一的认证服务来进行身份效验。

   3.1 Web SSO 的样例
      根据上面的原理，我用J2EE的技术（JSP和Servlet）完成了一个具有Web-SSO的简单样例。样例包含一个身份认证的服务器和两个简单的 Web应用，使得这两个 Web应用通过统一的身份认证服务来完成Web-SSO的功能。此样例所有的源代码和二进制代码都可以从网站地址http://gceclub.sun.com.cn/wangyu/下载。

      样例下载、安装部署和运行指南：

Web-SSO的样例是由三个标准Web应用组成，压缩成三个zip文件，从http://gceclub.sun.com.cn/wangyu/web-sso/中下载。其中SSOAuth（http://gceclub.sun.com.cn/wangyu/web-sso/SSOAuth.zip）是身份认证服务；SSOWebDemo1（http://gceclub.sun.com.cn/wangyu/web-sso/SSOWebDemo1.zip）和SSOWebDemo2（http://gceclub.sun.com.cn/wangyu/web-sso/SSOWebDemo2.zip）是两个用来演示单点登录的Web应用。这三个Web应用之所以没有打成war包，是因为它们不能直接部署，根据读者的部署环境需要作出小小的修改。样例部署和运行的环境有一定的要求，需要符合Servlet2.3以上标准的J2EE容器才能运行（例如Tomcat5,Sun Application Server 8, Jboss 4等）。另外，身份认证服务需要JDK1.5的运行环境。之所以要用JDK1.5是因为笔者使用了一个线程安全的高性能的Java集合类 “ConcurrentMap”，只有在JDK1.5中才有。
这三个Web应用完全可以单独部署，它们可以分别部署在不同的机器，不同的操作系统和不同的J2EE的产品上，它们完全是标准的和平台无关的应用。但是有一个限制，那两台部署应用（demo1、demo2）的机器的域名需要相同，这在后面的章节中会解释到cookie和domain的关系以及如何制作跨域的WEB-SSO
解压缩SSOAuth.zip文件，在/WEB-INF/下的web.xml中请修改“domainname”的属性以反映实际的应用部署情况， domainname需要设置为两个单点登录的应用（demo1和demo2）所属的域名。这个domainname和当前SSOAuth服务部署的机器的域名没有关系。我缺省设置的是“.sun.com”。如果你部署demo1和demo2的机器没有域名，请输入IP地址或主机名（如 localhost），但是如果使用IP地址或主机名也就意味着demo1和demo2需要部署到一台机器上了。设置完后，根据你所选择的J2EE容器，可能需要将SSOAuth这个目录压缩打包成war文件。用“jar -cvf SSOAuth.war SSOAuth/”就可以完成这个功能。
解压缩SSOWebDemo1和SSOWebDemo2文件，分别在它们/WEB-INF/下找到web.xml文件，请修改其中的几个初始化参数

SSOServiceURL

http://wangyu.prc.sun.com:8080/SSOAuth/SSOAuth

SSOLoginPage

http://wangyu.prc.sun.com:8080/SSOAuth/login.jsp

将其中的SSOServiceURL和SSOLoginPage修改成部署SSOAuth应用的机器名、端口号以及根路径（缺省是 SSOAuth）以反映实际的部署情况。设置完后，根据你所选择的J2EE容器，可能需要将SSOWebDemo1和SSOWebDemo2这两个目录压缩打包成两个war文件。用“jar -cvf SSOWebDemo1.war SSOWebDemo1/”就可以完成这个功能。
请输入第一个web应用的测试URL（test.jsp）,例如http://wangyu.prc.sun.com:8080/SSOWebDemo1/test.jsp，如果是第一次访问，便会自动跳转到登录界面，如下图。

使用系统自带的三个帐号之一登录（例如，用户名：wangyu,密码：wangyu），便能成功的看到test.jsp的内容：显示当前用户名和欢迎信息。

请接着在同一个浏览器中输入第二个web应用的测试URL（test.jsp）,例如http://wangyu.prc.sun.com:8080/SSOWebDemo2/test.jsp。你会发现，不需要再次登录就能看到test.jsp的内容，同样是显示当前用户名和欢迎信息，而且欢迎信息中明确的显示当前的应用名称（demo2）。

   3.2 WEB-SSO代码讲解
      3.2.1身份认证服务代码解析
      Web-SSO的源代码可以从网站地址http://gceclub.sun.com.cn/wangyu/web-sso/websso_src.zip下载。身份认证服务是一个标准的web应用，包括一个名为SSOAuth的Servlet，一个login.jsp文件和一个failed.html。身份认证的所有服务几乎都由SSOAuth的Servlet来实现了；login.jsp用来显示登录的页面（如果发现用户还没有登录过）； failed.html是用来显示登录失败的信息（如果用户的用户名和密码与信息数据库中的不一样）。

      SSOAuth的代码如下面的列表显示，结构非常简单，先看看这个Servlet的主体部分：
package DesktopSSO;

import java.io.*;
import java.net.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;

import javax.servlet.*;
import javax.servlet.http.*;

public class SSOAuth extends HttpServlet {

      static private ConcurrentMap accounts;
      static private ConcurrentMap SSOIDs;
      String cookiename="WangYuDesktopSSOID";
      String domainname;

      public void init(ServletConfig config) throws ServletException {
          super.init(config);
          domainname= config.getInitParameter("domainname");
          cookiename = config.getInitParameter("cookiename");
          SSOIDs = new ConcurrentHashMap();
          accounts=new ConcurrentHashMap();
          accounts.put("wangyu", "wangyu");
          accounts.put("paul", "paul");
          accounts.put("carol", "carol");
      }

      protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          PrintWriter ut = response.getWriter();
          String action = request.getParameter("action");
          String result="failed";
          if (action==null) {
              handlerFromLogin(request,response);
          } else if (action.equals("authcookie")){
              String myCookie = request.getParameter("cookiename");
              if (myCookie != null) result = authCookie(myCookie);
              out.print(result);
              out.close();
          } else if (action.equals("authuser")) {
             result=authNameAndPasswd(request,response);
              out.print(result);
              out.close();
          } else if (action.equals("logout")) {
              String myCookie = request.getParameter("cookiename");
              logout(myCookie);
              out.close();
          }
      }

.....

}

      从代码很容易看出，SSOAuth就是一个简单的Servlet。其中有两个静态成员变量：accounts和SSOIDs，这两个成员变量都使用了 JDK1.5中线程安全的MAP类： ConcurrentMap，所以这个样例一定要JDK1.5才能运行。Accounts用来存放用户的用户名和密码，在init()的方法中可以看到我给系统添加了三个合法的用户。在实际应用中，accounts应该是去数据库中或LDAP中获得，为了简单起见，在本样例中我使用了 ConcurrentMap在内存中用程序创建了三个用户。而SSOIDs保存了在用户成功的登录后所产生的cookie和用户名的对应关系。它的功能显而易见：当用户成功登录以后，再次访问别的系统，为了鉴别这个用户请求所带的cookie的有效性，需要到SSOIDs中检查这样的映射关系是否存在。

      在主要的请求处理方法processRequest()中，可以很清楚的看到SSOAuth的所有功能。

如果用户还没有登录过，是第一次登录本系统，会被跳转到login.jsp页面（在后面会解释如何跳转）。用户在提供了用户名和密码以后，就会用handlerFromLogin()这个方法来验证。
如果用户已经登录过本系统，再访问别的应用的时候，是不需要再次登录的。因为浏览器会将第一次登录时产生的cookie和请求一起发送。效验cookie的有效性是SSOAuth的主要功能之一。
SSOAuth还能直接效验非login.jsp页面过来的用户名和密码的效验请求。这个功能是用于非web应用的SSO，这在后面的桌面SSO中会用到。
SSOAuth还提供logout服务。

      下面看看几个主要的功能函数：
private void handlerFromLogin(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
          String username = request.getParameter("username");
          String password = request.getParameter("password");
          String pass = (String)accounts.get(username);
          if ((pass==null)||(!pass.equals(password)))
              getServletContext().getRequestDispatcher("/failed.html").forward(request, response);
          else {
              String gotoURL = request.getParameter("goto");
              String newID = createUID();
              SSOIDs.put(newID, username);
              Cookie wangyu = new Cookie(cookiename, newID);
              wangyu.setDomain(domainname);
              wangyu.setMaxAge(60000);
              wangyu.setValue(newID);
              wangyu.setPath("/");
              response.addCookie(wangyu);
              System.out.println("login success, goto back url:" + gotoURL);
              if (gotoURL != null) {
                  PrintWriter ut = response.getWriter();
                  response.sendRedirect(gotoURL);
                  out.close();
              }
          }
      }
      handlerFromLogin()这个方法是用来处理来自login.jsp的登录请求。它的逻辑很简单：将用户输入的用户名和密码与预先设定好的用户集合（存放在accounts中）相比较，如果用户名或密码不匹配的话，则返回登录失败的页面（failed.html），如果登录成功的话，需要为用户当前的session创建一个新的ID，并将这个ID和用户名的映射关系存放到SSOIDs中，最后还要将这个ID设置为浏览器能够保存的cookie 值。
      登录成功后，浏览器会到哪个页面呢？那我们回顾一下我们是如何使用身份认证服务的。一般来说我们不会直接访问身份服务的任何URL，包括 login.jsp。身份服务是用来保护其他应用服务的，用户一般在访问一个受SSOAuth保护的Web应用的某个URL时，当前这个应用会发现当前的用户还没有登录，便强制将也页面转向SSOAuth的login.jsp，让用户登录。如果登录成功后，应该自动的将用户的浏览器指向用户最初想访问的那个URL。在handlerFromLogin()这个方法中，我们通过接收“goto”这个参数来保存用户最初访问的URL，成功后便重新定向到这个页面中。
      另外一个要说明的是，在设置cookie的时候，我使用了一个setMaxAge(6000)的方法。这个方法是用来设置cookie的有效期，单位是秒。如果不使用这个方法或者参数为负数的话，当浏览器关闭的时候，这个cookie就失效了。在这里我给了很大的值（1000分钟），导致的行为是：当你关闭浏览器（或者关机），下次再打开浏览器访问刚才的应用，只要在1000分钟之内，就不需要再登录了。我这样做是下面要介绍的桌面SSO中所需要的功能。
      其他的方法更加简单，这里就不多解释了。

3.2.2具有SSO功能的web应用源代码解析 要实现WEB-SSO的功能，只有身份认证服务是不够的。这点很显然，要想使多个应用具有单点登录的功能，还需要每个应用本身的配合：将自己的身份认证的服务交给一个统一的身份认证服务－SSOAuth。SSOAuth服务中提供的各个方法就是供每个加入SSO的Web应用来调用的。

大田斗 2008-05-26 13:26 发表评论

超简单的 Web 爬虫程序

大田斗 — Mon, 26 May 2008 05:21:00 GMT

摘要: /** *//** * @author Jack.Wang * */ import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; import java.u... 阅读全文

大田斗 2008-05-26 13:21 发表评论

Java技术与Java虚拟机

大田斗 — Mon, 26 May 2008 05:10:00 GMT

　　说起Java，人们首先想到的是Java编程语言，然而事实上，Java是一种技术，它由四方面组成：Java编程语言、Java类文件格式、Java虚拟机和Java应用程序接口(Java API)。它们的关系如下图所示：

图1 Java四个方面的关系

　　运行期环境代表着Java平台，开发人员编写Java代码(.java文件)，然后将之编译成字节码(.class文件)。最后字节码被装入内存，一旦字节码进入虚拟机，它就会被解释器解释执行，或者是被即时代码发生器有选择的转换成机器码执行。从上图也可以看出Java平台由Java虚拟机和Java应用程序接口搭建，Java语言则是进入这个平台的通道，用Java语言编写并编译的程序可以运行在这个平台上。这个平台的结构如下图所示：

(点击查看原图)

　　在Java平台的结构中, 可以看出，Java虚拟机(JVM) 处在核心的位置，是程序与底层操作系统和硬件无关的关键。它的下方是移植接口，移植接口由两部分组成：适配器和Java操作系统, 其中依赖于平台的部分称为适配器；JVM 通过移植接口在具体的平台和操作系统上实现；在JVM 的上方是Java的基本类库和扩展类库以及它们的API，利用Java API编写的应用程序(application) 和小程序(Java applet) 可以在任何Java平台上运行而无需考虑底层平台, 就是因为有Java虚拟机(JVM)实现了程序与操作系统的分离，从而实现了Java 的平台无关性。

　　那么到底什么是Java虚拟机(JVM)呢？通常我们谈论JVM时，我们的意思可能是：

　　对JVM规范的的比较抽象的说明；
　　对JVM的具体实现；
　　在程序运行期间所生成的一个JVM实例。

　　对JVM规范的的抽象说明是一些概念的集合，它们已经在书《The Java Virtual Machine Specification》（《Java虚拟机规范》）中被详细地描述了；对JVM的具体实现要么是软件，要么是软件和硬件的组合，它已经被许多生产厂商所实现，并存在于多种平台之上；运行Java程序的任务由JVM的运行期实例单个承担。在本文中我们所讨论的Java虚拟机(JVM)主要针对第三种情况而言。它可以被看成一个想象中的机器，在实际的计算机上通过软件模拟来实现，有自己想象中的硬件，如处理器、堆栈、寄存器等，还有自己相应的指令系统。

　　JVM在它的生存周期中有一个明确的任务，那就是运行Java程序，因此当Java程序启动的时候，就产生JVM的一个实例；当程序运行结束的时候，该实例也跟着消失了。下面我们从JVM的体系结构和它的运行过程这两个方面来对它进行比较深入的研究。

Java虚拟机的体系结构

　　刚才已经提到，JVM可以由不同的厂商来实现。由于厂商的不同必然导致JVM在实现上的一些不同，然而JVM还是可以实现跨平台的特性，这就要归功于设计JVM时的体系结构了。

　　我们知道，一个JVM实例的行为不光是它自己的事，还涉及到它的子系统、存储区域、数据类型和指令这些部分，它们描述了JVM的一个抽象的内部体系结构，其目的不光规定实现JVM时它内部的体系结构，更重要的是提供了一种方式，用于严格定义实现时的外部行为。每个JVM都有两种机制，一个是装载具有合适名称的类(类或是接口)，叫做类装载子系统；另外的一个负责执行包含在已装载的类或接口中的指令，叫做运行引擎。每个JVM又包括方法区、堆、Java栈、程序计数器和本地方法栈这五个部分，这几个部分和类装载机制与运行引擎机制一起组成的体系结构图为：

图3 JVM的体系结构

　　JVM的每个实例都有一个它自己的方法域和一个堆，运行于JVM内的所有的线程都共享这些区域；当虚拟机装载类文件的时候，它解析其中的二进制数据所包含的类信息，并把它们放到方法域中；当程序运行的时候，JVM把程序初始化的所有对象置于堆上；而每个线程创建的时候，都会拥有自己的程序计数器和Java栈，其中程序计数器中的值指向下一条即将被执行的指令，线程的Java栈则存储为该线程调用Java方法的状态；本地方法调用的状态被存储在本地方法栈，该方法栈依赖于具体的实现。

　　下面分别对这几个部分进行说明。

　　执行引擎处于JVM的核心位置，在Java虚拟机规范中，它的行为是由指令集所决定的。尽管对于每条指令，规范很详细地说明了当JVM执行字节码遇到指令时，它的实现应该做什么，但对于怎么做却言之甚少。Java虚拟机支持大约248个字节码。每个字节码执行一种基本的CPU运算,例如,把一个整数加到寄存器,子程序转移等。Java指令集相当于Java程序的汇编语言。

　　Java指令集中的指令包含一个单字节的操作符,用于指定要执行的操作,还有0个或多个操作数,提供操作所需的参数或数据。许多指令没有操作数,仅由一个单字节的操作符构成。

　　虚拟机的内层循环的执行过程如下:

do{
取一个操作符字节;
根据操作符的值执行一个动作;
}while(程序未结束)

　　由于指令系统的简单性,使得虚拟机执行的过程十分简单,从而有利于提高执行的效率。指令中操作数的数量和大小是由操作符决定的。如果操作数比一个字节大,那么它存储的顺序是高位字节优先。例如,一个16位的参数存放时占用两个字节,其值为:

　　第一个字节*256+第二个字节字节码。

　　指令流一般只是字节对齐的。指令tableswitch和lookup是例外,在这两条指令内部要求强制的4字节边界对齐。

　　对于本地方法接口，实现JVM并不要求一定要有它的支持，甚至可以完全没有。Sun公司实现Java本地接口(JNI)是出于可移植性的考虑，当然我们也可以设计出其它的本地接口来代替Sun公司的JNI。但是这些设计与实现是比较复杂的事情，需要确保垃圾回收器不会将那些正在被本地方法调用的对象释放掉。

　　Java的堆是一个运行时数据区,类的实例(对象)从中分配空间，它的管理是由垃圾回收来负责的:不给程序员显式释放对象的能力。Java不规定具体使用的垃圾回收算法,可以根据系统的需求使用各种各样的算法。

　　Java方法区与传统语言中的编译后代码或是Unix进程中的正文段类似。它保存方法代码(编译后的java代码)和符号表。在当前的Java实现中,方法代码不包括在垃圾回收堆中,但计划在将来的版本中实现。每个类文件包含了一个Java类或一个Java界面的编译后的代码。可以说类文件是Java语言的执行代码文件。为了保证类文件的平台无关性,Java虚拟机规范中对类文件的格式也作了详细的说明。其具体细节请参考Sun公司的Java虚拟机规范。

　　Java虚拟机的寄存器用于保存机器的运行状态,与微处理器中的某些专用寄存器类似。Java虚拟机的寄存器有四种:

　　pc: Java程序计数器；
　　optop: 指向操作数栈顶端的指针；
　　frame: 指向当前执行方法的执行环境的指针；。
　　vars: 指向当前执行方法的局部变量区第一个变量的指针。

　　在上述体系结构图中，我们所说的是第一种，即程序计数器，每个线程一旦被创建就拥有了自己的程序计数器。当线程执行Java方法的时候，它包含该线程正在被执行的指令的地址。但是若线程执行的是一个本地的方法，那么程序计数器的值就不会被定义。

　　Java虚拟机的栈有三个区域:局部变量区、运行环境区、操作数区。

　　局部变量区

　　每个Java方法使用一个固定大小的局部变量集。它们按照与vars寄存器的字偏移量来寻址。局部变量都是32位的。长整数和双精度浮点数占据了两个局部变量的空间,却按照第一个局部变量的索引来寻址。(例如,一个具有索引n的局部变量,如果是一个双精度浮点数,那么它实际占据了索引n和n+1所代表的存储空间)虚拟机规范并不要求在局部变量中的64位的值是64位对齐的。虚拟机提供了把局部变量中的值装载到操作数栈的指令,也提供了把操作数栈中的值写入局部变量的指令。

　　运行环境区

　　在运行环境中包含的信息用于动态链接,正常的方法返回以及异常捕捉。

　　动态链接

　　运行环境包括对指向当前类和当前方法的解释器符号表的指针,用于支持方法代码的动态链接。方法的class文件代码在引用要调用的方法和要访问的变量时使用符号。动态链接把符号形式的方法调用翻译成实际方法调用,装载必要的类以解释还没有定义的符号,并把变量访问翻译成与这些变量运行时的存储结构相应的偏移地址。动态链接方法和变量使得方法中使用的其它类的变化不会影响到本程序的代码。

　　正常的方法返回

　　如果当前方法正常地结束了,在执行了一条具有正确类型的返回指令时,调用的方法会得到一个返回值。执行环境在正常返回的情况下用于恢复调用者的寄存器,并把调用者的程序计数器增加一个恰当的数值,以跳过已执行过的方法调用指令,然后在调用者的执行环境中继续执行下去。

　　异常捕捉

　　异常情况在Java中被称作Error(错误)或Exception(异常),是Throwable类的子类,在程序中的原因是:①动态链接错,如无法找到所需的class文件。②运行时错,如对一个空指针的引用。程序使用了throw语句。

　　当异常发生时,Java虚拟机采取如下措施:

　　检查与当前方法相联系的catch子句表。每个catch子句包含其有效指令范围,能够处理的异常类型,以及处理异常的代码块地址。

　　与异常相匹配的catch子句应该符合下面的条件:造成异常的指令在其指令范围之内,发生的异常类型是其能处理的异常类型的子类型。如果找到了匹配的catch子句,那么系统转移到指定的异常处理块处执行;如果没有找到异常处理块,重复寻找匹配的catch子句的过程,直到当前方法的所有嵌套的catch子句都被检查过。

　　由于虚拟机从第一个匹配的catch子句处继续执行,所以catch子句表中的顺序是很重要的。因为Java代码是结构化的,因此总可以把某个方法的所有的异常处理器都按序排列到一个表中,对任意可能的程序计数器的值,都可以用线性的顺序找到合适的异常处理块,以处理在该程序计数器值下发生的异常情况。

　　如果找不到匹配的catch子句,那么当前方法得到一个"未截获异常"的结果并返回到当前方法的调用者,好像异常刚刚在其调用者中发生一样。如果在调用者中仍然没有找到相应的异常处理块,那么这种错误将被传播下去。如果错误被传播到最顶层,那么系统将调用一个缺省的异常处理块。

　　操作数栈区

　　机器指令只从操作数栈中取操作数,对它们进行操作,并把结果返回到栈中。选择栈结构的原因是:在只有少量寄存器或非通用寄存器的机器(如Intel486)上,也能够高效地模拟虚拟机的行为。操作数栈是32位的。它用于给方法传递参数,并从方法接收结果,也用于支持操作的参数,并保存操作的结果。例如,iadd指令将两个整数相加。相加的两个整数应该是操作数栈顶的两个字。这两个字是由先前的指令压进堆栈的。这两个整数将从堆栈弹出、相加,并把结果压回到操作数栈中。

　　每个原始数据类型都有专门的指令对它们进行必须的操作。每个操作数在栈中需要一个存储位置,除了long和double型,它们需要两个位置。操作数只能被适用于其类型的操作符所操作。例如,压入两个int类型的数,如果把它们当作是一个long类型的数则是非法的。在Sun的虚拟机实现中,这个限制由字节码验证器强制实行。但是,有少数操作(操作符dupe和swap),用于对运行时数据区进行操作时是不考虑类型的。

　　本地方法栈，当一个线程调用本地方法时，它就不再受到虚拟机关于结构和安全限制方面的约束，它既可以访问虚拟机的运行期数据区，也可以使用本地处理器以及任何类型的栈。例如，本地栈是一个C语言的栈，那么当C程序调用C函数时，函数的参数以某种顺序被压入栈，结果则返回给调用函数。在实现Java虚拟机时，本地方法接口使用的是C语言的模型栈，那么它的本地方法栈的调度与使用则完全与C语言的栈相同。

Java虚拟机的运行过程

　　上面对虚拟机的各个部分进行了比较详细的说明，下面通过一个具体的例子来分析它的运行过程。

　　虚拟机通过调用某个指定类的方法main启动，传递给main一个字符串数组参数，使指定的类被装载，同时链接该类所使用的其它的类型，并且初始化它们。例如对于程序：

class HelloApp
{
　public static void main(String[] args)
　{
　　System.out.println("Hello World!");
　　for (int i = 0; i < args.length; i++ )
　　{
　　　System.out.println(args[i]);
　　}
　}
}

　　编译后在命令行模式下键入： java HelloApp run virtual machine

　　将通过调用HelloApp的方法main来启动java虚拟机，传递给main一个包含三个字符串"run"、"virtual"、"machine"的数组。现在我们略述虚拟机在执行HelloApp时可能采取的步骤。

　　开始试图执行类HelloApp的main方法，发现该类并没有被装载，也就是说虚拟机当前不包含该类的二进制代表，于是虚拟机使用ClassLoader试图寻找这样的二进制代表。如果这个进程失败，则抛出一个异常。类被装载后同时在main方法被调用之前，必须对类HelloApp与其它类型进行链接然后初始化。链接包含三个阶段：检验，准备和解析。检验检查被装载的主类的符号和语义，准备则创建类或接口的静态域以及把这些域初始化为标准的默认值，解析负责检查主类对其它类或接口的符号引用，在这一步它是可选的。类的初始化是对类中声明的静态初始化函数和静态域的初始化构造方法的执行。一个类在初始化之前它的父类必须被初始化。整个过程如下：

(点击查看原图)
图4：虚拟机的运行过程

　　结束语

　　本文通过对JVM的体系结构的深入研究以及一个Java程序执行时虚拟机的运行过程的详细分析，意在剖析清楚Java虚拟机的机理。

大田斗 2008-05-26 13:10 发表评论

Java接口妙用

大田斗 — Tue, 15 Jan 2008 02:05:00 GMT

1.回调
下面这个代码是模仿spring的HibernateTemplae.excute(HibernateCallback callback)的

package callback;

public interface Callee {
public Object doExecute();

}

package callback;

public class Caller {
    public static void main(String args[]) {
        CallerClass.execute(new Callee() {
            public Object doExecute() {
                String s = "this is callback runing";
                System.out.println(s);
                return s;

            }

        });
        CallerClass.execute(new Callee() {
            public Object doExecute() {
               System.out.println("i am can");
               return new Integer(2234234);
            }

        });

    }
    public static class CallerClass {
        public static void execute(Callee callee) {
            System.out.println("call back start");
            callee.doExecute();
            System.out.println("call back done");
        }
    }
}

运行结果：
call back start
this is callback runing
call back done
call back start
i am can
call back done

2: 有时候，每个类的实例只在某个地方用到，其它地方不会去调用，我们可以把这个实例放到某个函数内部调用

public static File[] listSubDirectories(String _dir) {
        File fDir = new File(_dir);
        FileFilter fileFilter = new FileFilter() {
            public boolean accept(File file) {
                return file.isDirectory();
            }
        };

        File[] files = fDir.listFiles(fileFilter);
        return files;
    }

大田斗 2008-01-15 10:05 发表评论

多线程编程——实战篇

大田斗 — Thu, 03 Jan 2008 09:38:00 GMT

摘要: [多线程编程的一般原则] 在进入实战篇以前,我们简单说一下多线程编程的一般原则。　　[安全性]是多线程编程的首要原则，如果两个以上的线程访问同一对象时，一个线程会损坏另一个线程的数据，这就是违反了安全性原则，这样的程序是不能进入实际应用的。　　安全性的保证可以通过设计安全的类和程序员的手工控制。如果多个线程对同一对象访问不会危及安全性，这样的类就是线程安全的类，在JAVA中比如Stri... 阅读全文

大田斗 2008-01-03 17:38 发表评论

Junit 结合spring+hibernate框架

大田斗 — Wed, 19 Dec 2007 06:52:00 GMT

spring + hibernate的Junit测试框架：

package test.trs;

import junit.framework.TestCase;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.core.io.FileSystemResource;

public class DreamFactoryTest extends TestCase {

    protected ApplicationContext factory;

    protected void setUp() throws Exception {
        String []location=new String[]{
                "D:/workspace/EmailSubScribe/webapp/WEB-INF/beans.xml",
                "D:/workspace/EmailSubScribe/webapp/WEB-INF/applicationContext.xml"};
        factory = new FileSystemXmlApplicationContext(location);

    }

    protected void tearDown() throws Exception {
        factory=null;
        super.tearDown();

    }

}

继承的子类

package test.trs.db.impl;

import test.trs.DreamFactoryTest;

import com.trs.db.dao.WebSiteConfigDao;
import com.trs.db.persistent.WebSiteConfig;

public class WebSiteConfigImplTest extends DreamFactoryTest {


   private WebSiteConfigDao manager;
   protected void setUp() throws Exception {
       super.setUp();
       manager=(WebSiteConfigDao)factory.getBean("WebSiteConfigDao");
   }

    public void testCascadeDelete() {
        .    }

}

大田斗 2007-12-19 14:52 发表评论

Tomcat6.0 || 5.5 中数据源的配置

大田斗 — Thu, 13 Dec 2007 03:08:00 GMT

Tomcat6.0 :

在$CATALINA_HOME/conf/server.xml文件中的标签之间加入如下的Context代码

    <Context path="/articlesystem" docBase="articlesystem" debug="5" reloadable="true" crossContext="true">
       <Resource name="jdbc/StrutsArticle" auth="Container" type="javax.sql.DataSource"
          maxActive="100" maxIdle="30" maxWait="10000"
          username="root" password="root" driverClassName="com.mysql.jdbc.Driver"
          url="jdbc:mysql://localhost:3306/strutsaritclecharacterEncoding=GBK&useUnicode=TRUE&autoReconnect=true"/>
    Context>

注意要把这段代码配置到Host>标签之间。

完成以上工作后，数据库就配置成功了。。也不必像官方文档说的那样在、在web应用的web.xml中配置标签的属性了。

另. Context元素代表一个web应用，运行在某个特定的虚拟主机上。你可以在一个Host元素中嵌套任意多的Context元素。每个Context的路径必须是惟一的，由path属性定义。

所有Context的实现支持如下属性：

属性	描述
`backgroundProcessorDelay`	`这个`值代表在context及其子容器（包括所有的wrappers）上调用backgroundProcess方法的延时，以秒为单位。如果延时值非负，子容器不会被调用，也就是说子容器使用自己的处理线程。如果该值为正，会创建一个新的线程。在等待指定的时间以后，该线程在主机及其子容器上调用backgroundProcess方法。context利用后台处理session过期，监测类的变化用于重新载入。如果没有指定，该属性的缺省值是－1，说明context依赖其所属的Host的后台处理。
`className`	实现的Java类名。该类必须实现`org.apache.catalina.Context`接口。如果没有指定，使用标准实现（在下面定义）。
`cookies`	如果想利用cookies来传递session identifier（需要客户端支持cookies），设为ture。否则为false，这种情况下只能依靠URL Rewriting传递session identifier。
`crossContext`	如果想在应用内调用ServletContext.getContext()来返回在该虚拟主机上运行的其他web application的request dispatcher,设为true。在安全性很重要的环境中，设为false，使得getContext()总是返回null。缺省值为false。
`docBase`	该web应用的文档基准目录（Document Base，也称为Context Root），或者是WAR文件的路径。可以使用绝对路径，也可以使用相对于context所属的Host的appBase路径。
`override`	如果想利用该Context元素中的设置覆盖DefaultContext中相应的设置，设为true。缺省情况下使用DefaultContext中的设置。
`privileged`	设为true，允许context使用container servlets，比如manager servlet。
`path`	web应用的context路径。catalina将每个URL的起始和context path进行比较，选择合适的web应用处理该请求。特定Host下的context path必须是惟一的。如果context path为空字符串（""），这个context是所属Host的缺省web应用,用来处理不能匹配任何context path的请求。
`reloadable`	如果希望Catalina监视/WEB-INF/classes/和/WEB-INF/lib下面的类是否发生变化，在发生变化的时候自动重载web application，设为true。这个特征在开发阶段很有用，但也大大增加了服务器的开销。因此，在发布以后，不推荐使用。但是，你可以使用Manager应用在必要的时候触发应用的重载。
`wrapperClass`	org.apache.catalina.Wrapper实现类的名称，用于该Context管理的servlets。如果没有指定，使用标准的缺省值。

java代码得到连接:

Context initCtx = new InitialContext();
         Context ctx = (Context)initCtx.lookup("java:comp/env");
         Object obj = (Object) ctx.lookup("jdbc/sqlserver");
         javax.sql.DataSource ds = (javax.sql.DataSource)obj;
         conn = ds.getConnection();

Hibernate得到连接:

在hibernate-cfg.xml中

<property name="connection.datasource">java:comp/env/jdbc/sqlserverproperty>

Spring中得到连接:

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName"><value>java:comp/env/jdbc/dermisvalue>property>
bean>

如果你用的是jboss服务器:
把java:comp/env 改成java:就足够了

           如果你用的是apache的dbcp包:
           1.type="org.apache.commons.dbcp.BasicDataSouce"
           2.driverClassName="net.sourceforge.jtds.jdbc.Driver"
           3.url="jdbc:jtds:sqlserver://127.0.0.1:1433/dataBasename"

如果你用的是MySQL:
            1.driverClassName="com.mysql.jdbc.Driver"
            2.url="jdbc:mysql://127.0.0.1:3306/dbname"
如果是Oracle:

            1.driverClassName="oracel.jdbc.driver.OracleDriver"
            2.url="jdbc:oracle:thin://127.0.0.1:1521/dbname"

Tomcat 5.5

首先编辑Server.xml，添加数据源代码

<Context path="/StudentManager" docbase="StudentManager" debug="5" reload="true" crossContext="true">
         <Resource name="jdbc/StudentManager" auth="Container" type="javax.sql.DataSource"/>
            <ResourceParams name="jdbc/StudentManager">
                <parameter>
                  <name>factoryname>
                  <values>org.apache.commons.dbcp.BasicDataSourceFactoryvalues>
                parameter>
                <parameter>
                  <name>urlname>
                  <values>jdbc:mysql://localhost:3306/studentmanagervalues>
                parameter>
                <parameter>
                  <name>driverclassnamename>
                  <values>com.mysql.jdbc.Drivervalues>
                parameter>
                <parameter>
                  <name>usernamename>
                  <values>rootvalues>
                parameter>
                <parameter>
                  <name>passwordname>
                  <values>rootvalues>
                parameter>
                <parameter>
                  <name>maxWaitname>
                  <values>3000values>
                parameter>
                <parameter>
                  <name>maxIdlename>
                  <values>10values>
                parameter>
                <parameter>
                  <name>maxActivename>
                  <values>100values>
                parameter>

            ResourceParams>
      Context>

在Web.xml中加入对jndi的引用

<resource-ref>
      <description>SqlServer   Datasource   exampledescription>
      <res-ref-name>jdbc/StudentManagerres-ref-name>
      <res-type>javax.sql.DataSourceres-type>
      <res-auth>Containerres-auth>
  resource-ref>

测试代码：

<%
    String jndi="java:comp/env/jdbc/StudentManager";
    DataSource ds=null;
     try{

          Context initCtx=new InitialContext();   //初始化上下文，可以读配置文件如：web.xml
          if(initCtx==null)
                  throw new Exception("Initial   Failed!");
          Context ctx=(Context)initCtx.lookup("java:comp/env");
          if(ctx!=null)
               ds=(DataSource)ctx.lookup("jdbc/StudentManager");
          if(ds==null)
                  throw new Exception("Look   up   DataSource   Failed!");
  }
  catch(Exception e){
          System.out.println(e.getMessage());
  }
    System.out.println(ds);
%>

大田斗 2007-12-13 11:08 发表评论

Java实现随机验证码功能实例

大田斗 — Thu, 13 Dec 2007 01:18:00 GMT

现在许多系统的注册、登录或者发布信息模块都添加的随机码功能，就是为了避免自动注册程序或者自动发布程序的使用。

验证码实际上就是随机选择一些字符以图片的形式展现在页面上，如果进行提交操作的同时需要将图片上的字符同时提交，如果提交的字符与服务器session保存的不同，则认为提交信息无效。为了避免自动程序分析解析图片，通常会在图片上随机生成一些干扰线或者将字符进行扭曲，增加自动识别的难度。

在这里，我们使用servlet来实现随机验证码的实现。

package com.servlet;

import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.util.Random;

import javax.imageio.ImageIO;
import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
* 生成随机验证码
* @author bitiliu
*
*/
public class ValidateCodeServlet extends HttpServlet
{

private static final long serialVersionUID = 1L;

//验证码图片的宽度。
private int width=60;
//验证码图片的高度。
private int height=20;
//验证码字符个数
private int codeCount=4;

private int x=0;
//字体高度
private int fontHeight;
private int codeY;

char[] codeSequence = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };

/**
* 初始化验证图片属性
*/
public void init() throws ServletException
{
//从web.xml中获取初始信息
//宽度
String strWidth=this.getInitParameter("width");
//高度
String strHeight=this.getInitParameter("height");
//字符个数
String strCodeCount=this.getInitParameter("codeCount");

//将配置的信息转换成数值
try
{
if(strWidth!=null && strWidth.length()!=0)
{
width=Integer.parseInt(strWidth);
}
if(strHeight!=null && strHeight.length()!=0)
{
height=Integer.parseInt(strHeight);
}
if(strCodeCount!=null && strCodeCount.length()!=0)
{
codeCount=Integer.parseInt(strCodeCount);
}
}
catch(NumberFormatException e)
{}

x=width/(codeCount+1);
fontHeight=height-2;
codeY=height-4;

}

protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, java.io.IOException {

//定义图像buffer
BufferedImage buffImg = new BufferedImage(
width, height,BufferedImage.TYPE_INT_RGB);
Graphics2D g = buffImg.createGraphics();

//创建一个随机数生成器类
Random random = new Random();

//将图像填充为白色
g.setColor(Color.WHITE);
g.fillRect(0, 0, width, height);

//创建字体，字体的大小应该根据图片的高度来定。
Font font = new Font("Fixedsys", Font.PLAIN, fontHeight);
//设置字体。
g.setFont(font);

//画边框。
g.setColor(Color.BLACK);
g.drawRect(0, 0, width - 1, height - 1);

//随机产生160条干扰线，使图象中的认证码不易被其它程序探测到。
g.setColor(Color.BLACK);
for(int i = 0; i ＜ 160; i++)
{
int x = random.nextInt(width);
int y = random.nextInt(height);
int xl = random.nextInt(12);
int yl = random.nextInt(12);
g.drawLine(x, y, x + xl, y + yl);
}

//randomCode用于保存随机产生的验证码，以便用户登录后进行验证。
StringBuffer randomCode = new StringBuffer();
int red = 0, green = 0, blue = 0;

//随机产生codeCount数字的验证码。
for (int i = 0; i ＜ codeCount; i++) {
//得到随机产生的验证码数字。
String strRand = String.valueOf(codeSequence[random.nextInt(36)]);
//产生随机的颜色分量来构造颜色值，这样输出的每位数字的颜色值都将不同。
red = random.nextInt(255);
green = random.nextInt(255);
blue = random.nextInt(255);

//用随机产生的颜色将验证码绘制到图像中。
g.setColor(new Color(red, green, blue));
g.drawString(strRand, (i + 1) * x, codeY);

//将产生的四个随机数组合在一起。
randomCode.append(strRand);
}
// 将四位数字的验证码保存到Session中。
HttpSession session = req.getSession();
session.setAttribute("validateCode", randomCode.toString());

// 禁止图像缓存。
resp.setHeader("Pragma", "no-cache");
resp.setHeader("Cache-Control", "no-cache");
resp.setDateHeader("Expires", 0);

resp.setContentType("image/jpeg");

//将图像输出到Servlet输出流中。
ServletOutputStream sos = resp.getOutputStream();
ImageIO.write(buffImg, "jpeg", sos);
sos.close();
}

}

需要在web.xml中声明servlet

＜servlet＞
＜servlet-name＞ValidateCodeServlet＜/servlet-name＞
＜servlet-class＞com.servlet.ValidateCodeServlet＜/servlet-class＞
＜init-param＞
＜param-name＞width＜/param-name＞
＜param-value＞200＜/param-value＞
＜/init-param＞
＜init-param＞
＜param-name＞height＜/param-name＞
＜param-value＞80＜/param-value＞
＜/init-param＞
＜init-param＞
＜param-name＞codeCount＜/param-name＞
＜param-value＞5＜/param-value＞
＜/init-param＞
＜/servlet＞

＜servlet-mapping＞
＜servlet-name＞ValidateCodeServlet＜/servlet-name＞
＜url-pattern＞/validateCodeServlet＜/url-pattern＞
＜/servlet-mapping＞

用户提交后就可以将用户输入的验证码与session中保存的字符串进行比对，达到验证的效果。

大田斗 2007-12-13 09:18 发表评论

排序算法复习（Java实现）(一）：插入，冒泡，选择，Shell,快速排序

大田斗 — Thu, 13 Dec 2007 01:13:00 GMT

为了便于管理，先引入个基础类：

package algorithms;

/**
* @author yovn
*
*/
public abstract class Sorter<E extends Comparable<E>> {

    public abstract void sort(E[] array,int from ,int len);

    public final void sort(E[] array)
    {
        sort(array,0,array.length);
    }
    protected final void swap(E[] array,int from ,int to)
    {
        E tmp=array[from];
        array[from]=array[to];
        array[to]=tmp;
    }

}

一插入排序
该算法在数据规模小的时候十分高效，该算法每次插入第K+1到前K个有序数组中一个合适位置，K从0开始到N-1,从而完成排序：

package algorithms;
/**
* @author yovn
*/
public class InsertSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    public void sort(E[] array, int from, int len) {
         E tmp=null;
          for(int i=from+1;i<from+len;i++)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j--)
              {
                  if(tmp.compareTo(array[j-1])<0)
                  {
                      array[j]=array[j-1];
                  }
                  else break;
              }
              array[j]=tmp;
          }
    }



}

二冒泡排序
这可能是最简单的排序算法了，算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。i从0一直到N-1从而完成排序。（当然也可以从数组开始端开始比较相邻两元素，把第i大的冒泡到数组的第N-i个位置。i从0一直到N-1从而完成排序。)

package algorithms;

/**
* @author yovn
*
*/
public class BubbleSorter<E extends Comparable<E>> extends Sorter<E> {

    private static  boolean DWON=true;

    public final void bubble_down(E[] array, int from, int len)
    {
        for(int i=from;i<from+len;i++)
        {
            for(int j=from+len-1;j>i;j--)
            {
                if(array[j].compareTo(array[j-1])<0)
                {
                    swap(array,j-1,j);
                }
            }
        }
    }

    public final void bubble_up(E[] array, int from, int len)
    {
        for(int i=from+len-1;i>=from;i--)
        {
            for(int j=from;j<i;j++)
            {
                if(array[j].compareTo(array[j+1])>0)
                {
                    swap(array,j,j+1);
                }
            }
        }
    }
    @Override
    public void sort(E[] array, int from, int len) {

        if(DWON)
        {
            bubble_down(array,from,len);
        }
        else
        {
            bubble_up(array,from,len);
        }
    }

}

三，选择排序
选择排序相对于冒泡来说，它不是每次发现逆序都交换，而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
相对与插入排序来说，选择排序每次选出的都是全局第i小的，不会调整前i个元素了。

package algorithms;
/**
* @author yovn
*
*/
public class SelectSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        for(int i=0;i<len;i++)
        {
            int smallest=i;
            int j=i+from;
            for(;j<from+len;j++)
            {
                if(array[j].compareTo(array[smallest])<0)
                {
                    smallest=j;
                }
            }
            swap(array,i,smallest);

        }

    }

}

四 Shell排序
Shell排序可以理解为插入排序的变种，它充分利用了插入排序的两个特点：
1）当数据规模小的时候非常高效
2）当给定数据已经有序时的时间代价为O(N)
所以，Shell排序每次把数据分成若个小块，来使用插入排序，而且之后在这若个小块排好序的情况下把它们合成大一点的小块，继续使用插入排序，不停的合并小块，知道最后成一个块，并使用插入排序。

这里每次分成若干小块是通过“增量” 来控制的，开始时增量交大，接近N/2,从而使得分割出来接近N/2个小块，逐渐的减小“增量“最终到减小到1。

一直较好的增量序列是2^k-1,2^(k-1)-1,.....7,3,1,这样可使Shell排序时间复杂度达到O(N^1.5)
所以我在实现Shell排序的时候采用该增量序列

package algorithms;

/**
* @author yovn
*/
public class ShellSorter<E extends Comparable<E>> extends Sorter<E>  {

    /* (non-Javadoc)
     * Our delta value choose 2^k-1,2^(k-1)-1,.7,3,1.
     * complexity is O(n^1.5)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {

        //1.calculate  the first delta value;
        int value=1;
        while((value+1)*2<len)
        {
            value=(value+1)*2-1;

        }

        for(int delta=value;delta>=1;delta=(delta+1)/2-1)
        {
            for(int i=0;i<delta;i++)
            {
                modify_insert_sort(array,from+i,len-i,delta);
            }
        }

    }

    private final  void modify_insert_sort(E[] array, int from, int len,int delta) {
          if(len<=1)return;
          E tmp=null;
          for(int i=from+delta;i<from+len;i+=delta)
          {
              tmp=array[i];
              int j=i;
              for(;j>from;j-=delta)
              {
                  if(tmp.compareTo(array[j-delta])<0)
                  {
                      array[j]=array[j-delta];
                  }
                  else break;
              }
              array[j]=tmp;
          }

    }
}

五快速排序
快速排序是目前使用可能最广泛的排序算法了。
一般分如下步骤：
1）选择一个枢纽元素（有很对选法，我的实现里采用去中间元素的简单方法）
2）使用该枢纽元素分割数组，使得比该元素小的元素在它的左边，比它大的在右边。并把枢纽元素放在合适的位置。
3）根据枢纽元素最后确定的位置，把数组分成三部分，左边的，右边的，枢纽元素自己，对左边的，右边的分别递归调用快速排序算法即可。
快速排序的核心在于分割算法，也可以说是最有技巧的部分。

package algorithms;

/**
* @author yovn
*
*/
public class QuickSorter<E extends Comparable<E>> extends Sorter<E> {

    /* (non-Javadoc)
     * @see algorithms.Sorter#sort(E[], int, int)
     */
    @Override
    public void sort(E[] array, int from, int len) {
        q_sort(array,from,from+len-1);
    }


    private final void q_sort(E[] array, int from, int to) {
        if(to-from<1)return;
        int pivot=selectPivot(array,from,to);



        pivot=partion(array,from,to,pivot);

        q_sort(array,from,pivot-1);
        q_sort(array,pivot+1,to);

    }

    private int partion(E[] array, int from, int to, int pivot) {
        E tmp=array[pivot];
        array[pivot]=array[to];//now to's position is available

        while(from!=to)
        {
            while(from<to&&array[from].compareTo(tmp)<=0)from++;
            if(from<to)
            {
                array[to]=array[from];//now from's position is available
                to--;
            }
            while(from<to&&array[to].compareTo(tmp)>=0)to--;
            if(from<to)
            {
                array[from]=array[to];//now to's position is available now
                from++;
            }
        }
        array[from]=tmp;
        return from;
    }

    private int selectPivot(E[] array, int from, int to) {

        return (from+to)/2;
    }

}

还有归并排序，堆排序，桶式排序，基数排序，下次在归纳。

大田斗 2007-12-13 09:13 发表评论

java --TreeMap,HashMap

大田斗 — Tue, 11 Dec 2007 01:23:00 GMT

1 /**
  2  * MapTest.java
  3  *
  4  * Provider: CoderDream's Studio
  5  *
  6  * History
  7  *    Date(DD/MM/YYYY)    Author          Description
  8  * ----------------------
  9  *    Oct 31, 2007        CoderDream        Created
10  */
11 package com.coderdream;
12
13 import java.util.HashMap;
14 import java.util.Iterator;
15 import java.util.Map;
16 import java.util.TreeMap;
17
18 /**
19  * @author CoderDream
20  */
21 public class MapTest {
22
23     /**
24      *



 25      *         使用HashMap使用1：

 26      *             用迭代器得到map.entrySet(),

 27      *             然后通过迭代得到Map.Entry对象，最后打印。

 28      *             打印结果未排序

 29      *

30      *
31      */
32     public void f1() {
33         Map map = new HashMap();
34         map.put("1", "Level 1");
35         map.put("2", "Level 2");
36         map.put("3", "Level 3");
37         map.put("4", "Level 4");
38         map.put("F", "Level F");
39         map.put("Q", "Level Q");
40         Iterator it = map.entrySet().iterator();
41         while (it.hasNext()) {
42             Map.Entry e = (Map.Entry) it.next();
43             System.out.println("Key: " + e.getKey() + "; Value: "
44                     + e.getValue());
45         }
46     }
47
48     /**
49      *



 50      * 使用泛型模式说明Map中存储的对象类型

 51      *

52      */
53     public void f2() {
54         Map<String, String> map = new HashMap<String, String>();
55         map.put("1", "Mon.");
56         map.put("1", "Monday");
57         map.put("one", "Monday");
58         Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
59
60         while (it.hasNext()) {
61             Map.Entry entry = it.next();
62             System.out.println(entry.getKey() + ":" + entry.getValue());
63         }
64     }
65
66     /**
67      *



 68      * 通过集合Set来得到HashMap中的对象

 69      *

70      *
71      */
72     public void f3() {
73         Map map = new HashMap();
74         map.put("1", "Mon.");
75         map.put("1", "Monday");
76         map.put("one", "Monday");
77         Iterator it = map.keySet().iterator();
78         String tmpKey = null;
79         while (it.hasNext()) {
80             tmpKey = (String) it.next();
81             System.out.println("Key: " + tmpKey
82                     + "; Value: " + map.get(tmpKey));
83         }
84     }
85
86     /**
87      *



 88      *     使用TreeMap代替HashMap，取得结果是排序后的结果

 89      *

90      */
91     public void f4() {
92         Map map = new TreeMap();
93         map.put("1", "Level 1");
94         map.put("2", "Level 2");
95         map.put("3", "Level 3");
96         map.put("4", "Level 4");
97         map.put("F", "Level F");
98         map.put("Q", "Level Q");
99         Iterator it = map.entrySet().iterator();
100         while (it.hasNext()) {
101             Map.Entry e = (Map.Entry) it.next();
102             System.out.println("Key: " + e.getKey()
103                     + "; Value: " + e.getValue());
104         }
105     }
106
107     /**
108      * @param args
109      */
110     public static void main(String[] args) {
111
112         MapTest mt = new MapTest();
113         System.out.println("----------f1()----------");
114         mt.f1();
115         System.out.println("----------f2()----------");
116         mt.f2();
117         System.out.println("----------f3()----------");
118         mt.f3();
119         System.out.println("----------f4()----------");
120         mt.f4();
121     }
122 }

输出结果：

----------f1()----------

Key: 3; Value: Level 3

Key: 2; Value: Level 2

Key: F; Value: Level F

Key: 1; Value: Level 1

Key: Q; Value: Level Q

Key: 4; Value: Level 4

----------f2()----------

1:Monday

one:Monday

----------f3()----------

Key: 1; Value: Monday

Key: one; Value: Monday

----------f4()----------

Key: 1; Value: Level 1

Key: 2; Value: Level 2

Key: 3; Value: Level 3

Key: 4; Value: Level 4

Key: F; Value: Level F

Key: Q; Value: Level Q

大田斗 2007-12-11 09:23 发表评论

Java泛型再学习

大田斗 — Wed, 31 Oct 2007 01:55:00 GMT

泛型引入java语言已经有很长一段时间了，在JDK5出来的时候也非常认真地学习过，不过学习的资料都是网上泛滥并且重复的教程。这几天下了《The Java Programming Language》的第4版，准备把jdk5引入的新东西再重新系统地学习一次，同时再次回顾下java基础。今天记录下学习泛型那一章的注意点。
一、泛型类型的声明
1.需要着重注意的一点，比如声明类Cell：

package net.rubyeye.javaprogramming.generic;

public class Cell<E> {
    private Cell<E> next;

    private E element;

    public Cell(E element) {
        this.element = element;
    }

    public Cell(E element, Cell<E> next) {
        this.next = next;
        this.element = element;
    }

    public E getElement() {
        return element;
    }

    public void setElement(E element) {
        this.element = element;
    }

    public Cell<E> getNext() {
        return next;
    }

    public void setNext(Cell<E> next) {
        this.next = next;
    }

}

然后如此使用：

Cell<String> strCell = new Cell<String>("Hello");
Cell<Integer> intCell = new Cell<Integer>(25);

那么Cell和Cell是两个类吗？不，他们是同一个类，通过下面的实验证明：

assertTrue(strCell.getClass() == intCell.getClass()));

java泛型的实现采用的“擦拭法”，Cell仍然是一个类，无论E被任何具体的类型所替代。

2.泛型的类型参数不能用于static变量、static方法和static初始化，比如下面的使用方式都不能编译通过：

public class Cell<E> {
    private static Cell<E> next;

    private static void test(E e){

    }

同样，静态方法是与类相关联的，调用也只能通过类，假设Cell有一个静态方法test，怎么调用才是正确的呢?

Cell<E>.test();  //编译错误
Cell<String>.test();  //同样编译错误
Cell.test();  //正确的方式

类似的，泛型的类型参数不能用于声明数组类型,比如下面的代码同样无法编译通过：

class SingleLinkQueue<E> {
    //
    public E[] toArray() {
    //
    }
}

3.类型参数可以继承其他的类和接口，如果有多个接口可以用&符号连接，通过extend参数限制了类型参数的范围，比如：

interface SortedCharSeqCollection<E extends Comparable<E>
& CharSequence> {
// sorted char sequence collection methods
}

SortedCharSeqCollection的类型参数E强制继承自Comparable和CharSequence接口，也就是替代的具体的类型参数必须实现这两个接口，从而限制了类型参数（type parameter)。

4.比较有趣的内部类的泛型，对于静态内部类的类型参数可以与外部类的类型参数名不一样，静态内部类的类型参数与外部类的类型参数其实没有一点关系，比如：

class SingleLinkQueue<E> {
    static class Cell<E> {
        private Cell<E> next;
        private E element;
        public Cell(E element) {
            this.element = element;
        }
        public Cell(E element, Cell<E> next) {
            this.element = element;
            this.next = next;
        }
        public E getElement() {
            return element;
        }
        /*  rest of Cell methods as before  */
    }

    protected Cell<E> head;
    protected Cell<E> tail;

    /*  rest of SingleLinkQueue methods as before  */
}

Cell类的声明和SingleLinkQueue 两个类中的E仅仅是名称相同，他们之间的关联是通过head和tail的声明才关联在一起，你可以将Cell中的E改成F也没关系，比如：

package net.rubyeye.javaprogramming.generic;

class AnotherSingleLinkQueue<E> {
    static class Cell<F> {
        private Cell<F> next;

        private F element;

        public Cell(F element) {
            this.element = element;
        }

        public Cell(F element, Cell<F> next) {
            this.element = element;
            this.next = next;
        }

        public F getElement() {
            return element;
        }
        /*  rest of Cell methods as before  */
    }

    protected Cell<E> head;

    protected Cell<E> tail;

    /*  rest of SingleLinkQueue methods as before  */
}

而一般的内部类就不一样了，内部类可以直接使用外部类的类型参数甚至隐藏。

二、子类型与通配符
今天读了第2节，泛型的使用比我原先所知的更为复杂，java语法本来以简洁优美著称，随着java5,java7的到来，语法是越来越复杂，甚至可以说丑陋!-_-

要知道一点，比如List不是List的子类，而是Collection的子类。因为List和List的类型是一样的，都是List。那么如何表示参数化类型是Number的子类呢？这就需要用到通配符：

List extends Number>

表示类型变量是Number或者Number的子类。这个就是所谓的上界通配符，同样，如果要表示类型变量是Number或者Number的super type，可以使用下界通配符：

List super Number>

而通配符List等价于：

List extends Object>

通配符只能用于变量、局部变量、参数类型和返回类型，不能用于命名类和接口。比如下面的代码将不能编译通过：

class MyList implements List{
//
}

通配符有另一个问题：因为通配符代表的是未知的类型，你不能在任何需要类型信息的地方使用它。比如下面的代码同样无法编译通过：

SingleLinkQueue strings =
    new SingleLinkQueue<String>();
strings.add("Hello");               // INVALID: 无法编译

SingleLinkQueue extends Number> numbers =
    new SingleLinkQueue<Number>();
numbers.add(Integer.valueOf(25));   // INVALID: 无法编译

三、泛型方法和类型推断
如果我们想参数化方法的参数和返回值的类型，这就引出了泛型方法的声明，声明一个泛型方法的方式如下：

<T> T passThrough(T obj) {
return obj;
}

这个方法限制传入的参数的类型与返回的参数类型将一致，可以看到，在方法签名前加上即可。我们可以这样调用这个方法：

String s1 = "Hello";
String s2 = this.<String>passThrough(s1);

这样的调用是不是比较奇怪？幸好提供了类型推断，根据参数的类型来自动判断方法的类型（比如返回值类型），因此可以直接调用：

String s1 = "Hello";
String s2 = this.passThrough(s1);

如果方法有两个类型变量，类型推断将怎么处理呢？比如：

<T> T passThrough(T obj1,T obj2) {
return (T)(obj1.toString()+obj2.toString());
}

然后我们传入两个参数，一个String，一个int，那么返回什么呢？

String s1="test";
String s3=this.passThrough(s1, 1); //编译出错

类型推断是比较复杂的，这里将返回的将是Object类型，是传入的参数类型的交集

大田斗 2007-10-31 09:55 发表评论

JVM启动参数

大田斗 — Tue, 30 Oct 2007 02:01:00 GMT

JVM启动参数

1.1 格式

java [jvmargs] class [arguments]

1.2 标准参数

1.-server

-client

虚拟机服务器模式/客户机模式，使用server模式可以提高性能，启动比client模式慢，长期运行则比client模式快。当该参数不指定时，虚拟机启动检测主机是否为服务器，如果是则以server模式启动，否则以client模式启动，J2SE5.0检测的根据是至少2个CPU和最低2GB内存

2.-agentlib:=

-agentpath:=

本地类库加载，当你的部分类包含一些本地方法时，需要自己编写本地代码并位于操作系统加载共享包(dll)的路径上，如果你不喜欢将该包放在操作系统识别的加载上，则可以通过指定这个参数来加载自己的本地共享包(dll)。不同之处在于-agentlib中仅指定包名，根据操作系统的不同虚拟机在一定路径上搜索该包，譬如对于windows平台虚拟机在PATH路径上搜索该包，而lib-path则是指定全路径，例如

-agentlib:hprof 在windows平台虚拟机会在启动时到PATH路径上搜索hprof.dll并加载

虚拟机在加载代理包之后有一个启动的操作（详细参见JDK参考），指的是代理包的启动参数

3.-classpath classpath

-c classpath

指定类路径，系统应用类加载器(ClassLoader)会到该路径下加载类

4.-Dproperty=value

设置系统属性，可以通过System.getProperty(property)获得

5.-enableassertions[:"..." | : ]

-ea[:"..." | : ]

-disableassertions[:"..." | :

-da[:"..." | : ]

启用和停用断言，默认是停用断言。断言指的是从JDK1.4开始在支持的关键字assert，assert(booleanvalue)，当booleanvalue为false时，抛出java.lang.AssertionError，必须指出的是，代码编译必须是1.4及其以上顺从的，即编译时使用如下参数

java -source 1.4

一般仅在开发阶段启用断言，而在运行阶段不使用

其使用包括如下几种情况

java -ea//启动断言

java -ea:pkname... //在包pkname及其子包下起用断言

java -ea:pkname.classname //对类 pkname.classname启用断言

停用断言与启用设置类似

6.-enablesystemassertions

-esa

-disablesystemassertions

-dsa

启用和停用系统类断言

7.-jar

运行包含在一个jar包里的程序，一般在jar包的/META-INF/MANIFEST.MF文件中指定Main-Class值为要运行的主函数，譬如 Main-Class:ayufox.ejb3.Test

8.-javaagent:[<=options>]

加载java语言代理，该功能是JDK5新增加的，可以通过该设置在JVM运行主函数(main)之前做一些预处理工作，其中classname中必须包含有静态方法

public static void premain(String agentArgs, Instrumentation inst) { ... }

上面的options即是传入该函数的代理参数agentArgs，关于Instrumentation详细参见包java.lang.instrument

9.-verbose

-verbose:class

-verbose:gc

-verbose:jni

在运行时

class:将类加载情况在控制台中打印出来

gc:将虚拟机的垃圾回收事件信息打印

jni:放本地方法调用信息打印

-verbose与-verbose:class一样

10.-version

-showversion

显示版本信息，不同在于第一种显示版本后虚拟机结束退出

11.-?

-help

显示帮助信息并退出

12.-X

显示非标准参数（见下面介绍）并退出

1.3 非标准参数（以-X开头）

1.-Xint

所有字节码以解析模式运行。第一代虚拟机即是以这种方式运行，由于需要Java解析器解析运行，所以效率比较低；第二代虚拟机则采用将字节码编译成本地代码的方式，效率大大提高；第三代虚拟机也叫自适应(HotSpot)虚拟机，通过监测代码的执行情况检测出代码被频繁执行的部分，将其尽量优化成本地代码方式运行，而对于普通部分，则采用解析的模式运行。

2.-Xbatch

禁止后台编译，一般HotSpot虚拟机在检测到一段代码为频繁执行代码需要将其编译成本地代码时，会启动一个后台线程完成这个工作，而同时采用解析的方式继续运行字节码。如果设置了该参数，则会停止继续执行字节码，先将其编译成本地代码，然后再继续执行。

3.-Xdebug

-Xnoagent

-Xrun

-Xrunjdwp

启用调试模式，见前面的《利用JPDA构建调试平台》这篇文章，后面将在一个独立的文章中详细介绍

4.-Xbootclasspath:bootclasspath

-Xbootclasspath/a:path

-Xbootclasspath/p:path

设置启动根Classpath，即使启动类加载器将在何处加载对象，关于类启动加载器，参见《JVM类加载器体系结构》说明，分号后面的值指定路径，以分号隔开。其区别在于，-Xbootclasspath:bootclasspath将新的根加载路径覆盖默认的路径（\jre\lib\rt.jar），-Xbootclasspath/a:path将新的根加载路径和原有的根加载路径相结合，-Xbootclaspath/p:path将新的根加载路径与原有的根加载路径相结合，加载类时优先搜索该加载路径

5.-Xcheck:jni

对本地调用（JNI）采用更严格的检测方式，在进行JNI调用之前检测数据和传入参数，如果碰到不合法的数据则强制结束掉虚拟机，对运行性能有损害

6.-Xfuture

对类格式(class文件格式)采用更严格的检测方式，以便向后兼容，最好在开发时采用该参数

7.-Xnoclassgc

不使用回收装载类的内存(转贴备注:按原文修改)

8.-Xloggc:file

与-verbose:gc功能一样，不同在于-Xloggc:file将信息记录到一个文件，而-verbose:gc将其输出到控制台

9.-Xincgc

-Xmsn

-Xmxn

-Xssn

跟内存分配和垃圾回收相关，-Xincgc表示采用渐进式垃圾回收，-Xmsn设置初始内存池大小，-Xmxn表示内存池允许的最大大小，-Xssn是线程栈大小，n是要设置的值，必须是1024的倍数，譬如

-Xms6291456 -Xmx83886080

-Xms6144k -Xmx81920k

-Xms6m -Xmx80m

该部分对虚拟机的性能非常重要，在后面将有独立的篇章详细介绍

10.-Xprof

-Xrunhprof[:help][:=,...]

在运行时剖析运行情况，并将剖析结果打印到控制台，其中后一个可以指定特定剖析对象，譬如cpu，堆(heap)等，可以运行java -Xrunhprof:help获得可以剖析的对象和取值

11.-Xrs

减少JVM对操作系统信号量的使用，J2SE1.3.1开始引入。

SUN在J2SE1.3.0中增加了Java应用程序关闭时的回调钩子(Hook)，以便当JVM意外终止时用户可以做一些资源清除工作。JVM监视控制台事件以实现JVM意外终止时的回调。JVM明确地注册了一个控制台控制处理器，当JVM接收到CTRL_C_EVENT, CTRL_CLOSE_EVENT, CTRL_LOGOFF_EVENT, 或CTRL_SHUTDOWN事件时，该处理器介入关闭回掉钩子(HOOK)的处理。

如果虚拟机以服务的方式运行（譬如WEB服务器）当其收到CTRL_LOGOFF_EVENT事件，由于系统并不会因此终止JVM进程，故JVM不可以进行终止的操作，然而这与如上产生了冲突（不结束却又调用关闭回调钩子），为了避免这个问题，从J2SE1.3.1使用-Xrs以使JVM不再监测控制台事件。

参考：JDK5.0参考文档http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/java.html

大田斗 2007-10-30 10:01 发表评论

多线程编程基础篇

大田斗 — Tue, 09 Oct 2007 06:34:00 GMT

摘要: [线程对象和线程的区别] 线程对象是可以产生线程的对象。比如在java平台中Thread对象，Runnable对象。线程，是指正在执行的一个指点令序列。在java平台上是指从一个线程对象的start()开始，运行run方法体中的那一段相对独立的过程。　让我们先从最简单的"单线程"来入手 class BeginClass{ &n... 阅读全文

大田斗 2007-10-09 14:34 发表评论

在java中利用动态编译实现eval

大田斗 — Tue, 09 Oct 2007 02:42:00 GMT

　我们知道,在很多脚本语言中都有eval函数,它可以把字符串转换为表达式并执行.如在javaScript中:

var str = aid.value + ".style.top = 10;"　

　
把一个id为"aid"的控制的值取出来加合并成一个字符串,如果aid的值是"axman",则

str = "axman.style.top = 10"　　
现在我们要让控制axman移动到顶部为10的位置:

eval(str);　　
这样这个字符串就变成了表达式或语句开始执行.这样的功能对于动态构造变量是有非常重要的
意义.

　　那么在java中,如果实现这个功能呢?其实我们可以用动态编译来实现。

动态编译实现eval
　　假设有一组方法实现不同的功能,现在要根据传进来的方法名调用相应的方法,假如没有eval功能,我们只能这么做:

MyClass mc = new MyClass();
if(str.equals("m1"))
   mc.m1();
else if(str.equals("m1"))
   mc.m2();
else if(str.equals("m3"))
   mc.m3();
else if(.........)
   .........();
　　如果有一百种情况呢?

　　如果我们用eval方法就可以直接这样:

String str = ...........;
eval("mc"+str+"();");　　
是不是非常方便?关键是如何实现eval()?

　　我们把要转换的字符串构造一个完整的类:如果方法是有返回值的.则:

public Object eval(String str){
   //生成java文件
   String s = "class Temp{";
s += "Object rt(){"
s += "MyClass mc = new MyClass();"
        s += " return mc."+str+"();";
        s += "}"
s +="}";
   File f = new File("Temp.java");
   PrintWriter pw = new PrintWriter(new FileWriter(f));
   pw.println(s);
   pw.close();
   //动态编译
   com.sun.tools.javac.Main javac = new com.sun.tools.javac.Main();
   String[] cpargs = new String[] {"-d", "所在目录","Temp.java"};
   int status = javac.compile(cpargs);
   if(status!=0){
      System.out.println("没有成功编译源文件!");
      return null;
   }
   //调用Temp的rt方法返回结果:
   MyClassLoader mc = new MyClassLoader();
   Class clasz = mc.loadClass("Test.class",true);
   Method rt = clasz.getMethod("rt", new Class[]{ String[].class });
   return rt.invoke(null, new Object[] { new String[0] });
   //如果方法没有返回就直接调用
}

　　我们可以先写好多个重载的eval,有返回值和没有返回值的.以及可以传递参数的.

　　这样我们就可以用字符串转换为java的语句来执行.

　　本文只是一个例子,说明了一个动态编译的思想,更好的实现请各位朋友自己来完成.

　　后记：关于动态编译的参数,补充说明一下:

String[] cpargs = new String[]
{"-d", "所在目录","Temp.java"}; 　　-d指明的目录应该是当前目录,因为生成的java文件是以当前目录为"/"然后在此目录下建立相应的包的."当前目录"应该用new File(".").getAbsoultPath()来确定.

　　java文件如果有package,在生成的时候应该建立相应的子目录.而这个参数应该是 java源文件的file对象的getAbsoultPath(), 如当前应用程序是在d:\debug目录运行,动态生成的java文件有个package 为temp;

　　则 String[] cpargs = new String[] {"-d", "d:\\debud","d:\\debug\\temp\\Temp.java"};这样生成的class文件应该和java源文件在同一目录d:\debug\\temp\下.

　　重载loadClass方法时应该注意能正确读取到class文件

完整的列子：

import java.io.File;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.lang.reflect.Method;

import com.sun.tools.javac.Main;

public class testJavac{
        public String getName(){
           return "刘凯毅";
        }
        public int getAvg(){
           return 24;
        }

        public Object eval(String str)throws Exception{
           //生成java文件
        String s = "class Temp{";
            s += "private testJavac tj = new testJavac();";
            s += "public String rt(){";
            s += " return  \"\"+tj."+str+"();"  ;
            s += "}";
            s +="}";

           File f = new File(System.getProperty("user.dir")+"\\Temp.java");
           PrintWriter pw = new PrintWriter(new FileWriter(f));
           pw.println(s);
           pw.close();
           //动态编译
           Main javac = new Main();
           String[] cpargs = new String[] {"-d", System.getProperty("user.dir") ,"Temp.java"};
           int status = javac.compile(cpargs);
           if(status!=0){
              System.out.println("没有成功编译源文件!");
              return null;
           }
           //调用Temp的rt方法返回结果:
           ClassLoader mc = this.getClass().getClassLoader();

           Class clasz = mc.loadClass("Temp");

           Method rt = clasz.getMethod("rt", new Class[]{});
           return rt.invoke(clasz.newInstance(), new Object[] { });
           //如果方法没有返回就直接调用
        }


    public static void main(String[]args)throws Exception{
        testJavac jj = new testJavac();
        System.out.println( jj.eval(args[0]) );
    }

}

大田斗 2007-10-09 10:42 发表评论

[转载]Tomcat类加载机制

大田斗 — Sat, 29 Sep 2007 01:08:00 GMT

Tomcat Server在启动的时候将构造一个ClassLoader树，以保证模块的类库是私有的
Tomcat Server的ClassLoader结构如下：

代码

    Bootstrap
       |
     System
       |
     Common
    /      \
Catalina  Shared
          /    \
       WebApp1  WebApp2

其中：
- Bootstrap - 载入JVM自带的类和$JAVA_HOME/jre/lib/ext/*.jar
- System - 载入$CLASSPATH/*.class
- Common - 载入$CATALINA_HOME/common/...，它们对TOMCAT和所有的WEB APP都可见
- Catalina - 载入$CATALINA_HOME/server/...，它们仅对TOMCAT可见，对所有的WEB APP都不可见
- Shared - 载入$CATALINA_HOME/shared/...，它们仅对所有WEB APP可见，对TOMCAT不可见（也不必见）
- WebApp - 载入ContextBase?/WEB-INF/...，它们仅对该WEB APP可见

每个运行中的线程都有一个成员contextClassLoader，用来在运行时动态地载入其它类，系统默认的contextClassLoader是systemClassLoader，所以一般而言java程序在执行时可以使用JVM自带的类、$JAVA_HOME/jre/lib/ext/中的类和$CLASSPATH/中的类，可以使用Thread.currentThread().setContextClassLoader(...);更改当前线程的contextClassLoader，来改变其载入类的行为

ClassLoader被组织成树形，一般的工作原理是：
1) 线程需要用到某个类，于是contextClassLoader被请求来载入该类
2) contextClassLoader请求它的父ClassLoader来完成该载入请求
3) 如果父ClassLoader无法载入类，则contextClassLoader试图自己来载入
注意：WebApp?ClassLoader的工作原理和上述有少许不同：
它先试图自己载入类（在ContextBase?/WEB-INF/...中载入类），如果无法载入，再请求父ClassLoader完成

由此可得：
- 对于WEB APP线程，它的contextClassLoader是WebApp?ClassLoader
- 对于Tomcat Server线程，它的contextClassLoader是CatalinaClassLoader

大田斗 2007-09-29 09:08 发表评论

JVM启动参数(转)

大田斗 — Tue, 21 Aug 2007 03:12:00 GMT

Posted on 2007-08-16 13:39 朱远翔-Apusic技术支持工程师阅读(426) 评论(0) 编辑收藏引用所属分类: Java世界

1.1格式

java[jvmargs]class[arguments]

1.2标准参数

1.-server

-client

虚拟机服务器模式/客户机模式，使用server模式可以提高性能，启动比client模式慢，长期运行则比client模式快。当该参数不指定时，虚拟机启动检测主机是否为服务器，如果是则以server模式启动，否则以client模式启动，J2SE5.0检测的根据是至少2个CPU和最低2GB内存。（编者注：使用server模式启动必须使用JDK，但是对于机器好像没有这个要求）

2.-agentlib:=

-agentpath:=

-agentlib:hprof在windows平台虚拟机会在启动时到PATH路径上搜索hprof.dll并加载

虚拟机在加载代理包之后有一个启动的操作（详细参见JDK参考），指的是代理包的启动参数

3.-classpathclasspath

-cclasspath

指定类路径，系统应用类加载器(ClassLoader)会到该路径下加载类

4.-Dproperty=value

设置系统属性，可以通过System.getProperty(property)获得

5.-enableassertions[:"..."|:]

-ea[:"..."|:]

-disableassertions[:"..."|:

-da[:"..."|:]

java-source1.4

一般仅在开发阶段启用断言，而在运行阶段不使用

其使用包括如下几种情况

java-ea//启动断言

java-ea:pkname...//在包pkname及其子包下起用断言

java-ea:pkname.classname//对类pkname.classname启用断言

停用断言与启用设置类似

6.-enablesystemassertions

-esa

-disablesystemassertions

-dsa

启用和停用系统类断言

7.-jar

运行包含在一个jar包里的程序，一般在jar包的/META-INF/MANIFEST.MF文件中指定Main-Class值为要运行的主函数，譬如Main-Class:ayufox.ejb3.Test

8.-javaagent:[<=options>]

加载java语言代理，该功能是JDK5新增加的，可以通过该设置在JVM运行主函数(main)之前做一些预处理工作，其中classname中必须包含有静态方法

publicstaticvoidpremain(StringagentArgs,Instrumentationinst){...}

上面的options即是传入该函数的代理参数agentArgs，关于Instrumentation详细参见包java.lang.instrument

9.-verbose

-verbose:class

-verbose:gc

-verbose:jni

在运行时

class:将类加载情况在控制台中打印出来

gc:将虚拟机的垃圾回收事件信息打印

jni:放本地方法调用信息打印

-verbose与-verbose:class一样

10.-version

-showversion

显示版本信息，不同在于第一种显示版本后虚拟机结束退出

11.-?

-help

显示帮助信息并退出

12.-X

显示非标准参数（见下面介绍）并退出

1.3非标准参数（以-X开头）

1.-Xint

2.-Xbatch

3.-Xdebug

-Xnoagent

-Xrun

-Xrunjdwp

启用调试模式，见前面的《利用JPDA构建调试平台》这篇文章，后面将在一个独立的文章中详细介绍

4.-Xbootclasspath:bootclasspath

-Xbootclasspath/a:path

-Xbootclasspath/p:path

5.-Xcheck:jni

对本地调用（JNI）采用更严格的检测方式，在进行JNI调用之前检测数据和传入参数，如果碰到不合法的数据则强制结束掉虚拟机，对运行性能有损害

6.-Xfuture

对类格式(class文件格式)采用更严格的检测方式，以便向后兼容，最好在开发时采用该参数

7.-Xnoclassgc

不使用回收装载类的内存(转贴备注:按原文修改)

8.-Xloggc:file

与-verbose:gc功能一样，不同在于-Xloggc:file将信息记录到一个文件，而-verbose:gc将其输出到控制台

9.-Xincgc

-Xmsn

-Xmxn

-Xssn

-Xms6291456-Xmx83886080

-Xms6144k-Xmx81920k

-Xms6m-Xmx80m

该部分对虚拟机的性能非常重要，在后面将有独立的篇章详细介绍

10.-Xprof

-Xrunhprof[:help][:=,...]

在运行时剖析运行情况，并将剖析结果打印到控制台，其中后一个可以指定特定剖析对象，譬如cpu，堆(heap)等，可以运行java-Xrunhprof:help获得可以剖析的对象和取值

11.-Xrs

减少JVM对操作系统信号量的使用，J2SE1.3.1开始引入。

SUN在J2SE1.3.0中增加了Java应用程序关闭时的回调钩子(Hook)，以便当JVM意外终止时用户可以做一些资源清除工作。JVM监视控制台事件以实现JVM意外终止时的回调。JVM明确地注册了一个控制台控制处理器，当JVM接收到CTRL_C_EVENT,CTRL_CLOSE_EVENT,CTRL_LOGOFF_EVENT,或CTRL_SHUTDOWN事件时，该处理器介入关闭回掉钩子(HOOK)的处理。

大田斗 2007-08-21 11:12 发表评论

Java中的UDP协议编程 [zt]

大田斗 — Fri, 17 Aug 2007 01:00:00 GMT

摘要: 一. UDP协议定义 UDP协议的全称是用户数据报，在网络中它与TCP协议一样用于处理数据包。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据报分组、组装和不能对数据包的排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。二. 使用UDP的原因它不属于连接型协议，因而具有资源消耗小，处理... 阅读全文

大田斗 2007-08-17 09:00 发表评论

深入HashCode方法

大田斗 — Thu, 02 Aug 2007 01:53:00 GMT

为什么HashCode对于对象是如此的重要?
　　一个对象的HashCode就是一个简单的Hash算法的实现，虽然它和那些真正的复杂的Hash算法相比还不能叫真正的算法，它如何实现它，不仅仅是程序员的编程水平问题，而是关系到你的对象在存取是性能的非常重要的关系.有可能，不同的HashCode可能会使你的对象存取产生，成百上千倍的性能差别。

　　我们先来看一下，在JAVA中两个重要的数据结构:HashMap和Hashtable，虽然它们有很大的区别，如继承关系不同，对的约束条件(是否允许null)不同，以及线程安全性等有着特定的区别，但从实现原理上来说，它们是一致的.所以，我们只以Hashtable来说明:

　　在java中，存取数据的性能，一般来说当然是首推数组，但是在数据量稍大的容器选择中，Hashtable将有比数组性能更高的查询速度.具体原因看下面的内容。

　　Hashtable在存储数据时，一般先将作为key的对象的HashCode和0x7FFFFFFF做与操作，因为一个对象的HashCode可以为负数，这样操作后可以保证它为一个正整数.然后以Hashtable的长度取模，得到值对象在Hashtable中的索引。

　　index = (o.hashCode() & 0x7FFFFFFF)%hs.length;这个值对象就会直接放在Hashtable的第index位置，对于写入，这和数组一样，把一个对象放在其中的第index位置，但如果是查询，经过同样的算法，Hashtable可以直接通过key得到index，从第index取得这个值对象，而数组却要做循环比较.所以对于数据量稍大时，Hashtable的查询比数据具有更高的性能。

　　虽然不同对象有不同的hashcode，但不同的hashCode经过与长度的取余，就很可能产生相同的index。

　　极端情况下会有大量的对象产生一个相同的索引.这就是关系Hashtable性能问题的最重要的问题:

　　Hash冲突。

　　常见的Hash冲突是不同key对象最终产生了相同的索引，而一种非常甚至绝对少见的Hash冲突是，如果一组对象的个数大过了int范围，而HashCode的长度只能在int范围中，所以肯定要有同一组的元素有相同的HashCode，这样无论如何他们都会有相同的索引.当然这种极端的情况是极少见的，可以暂不考虑，但是对于同的HashCode经过取模，则会产中相同的索引，或者不同的对象却具有相同的HashCode，当然具有相同的索引。

　　事实上一个设计各好的HashTable，一般来说会比较平均地分布每个元素，因为Hashtable的长度总是比实际元素的个数按一定比例进行自增(装填因子一般为0.75)左右，这样大多数的索引位置只有一个对象，而很少的位置会有几个元素.所以Hashtable中的每个位置存放的是一个链表，对于只有一个对象是位置，链表只有一个首节点(Entry)，Entry的next为null.然后有hashCode，key，属性保存了该位置的对象的HashCode，key和(对象本身)，如果有相同索引的对象进来则会进入链表的下一个节点.如果同一个索引中有多个对象，根据HashCode和key可以在该链表中找到一个和查询的key相匹配的对象。

　　从上面我看可以看到，对于HashMap和Hashtable的存取性能有重大影响的首先是应该使该数据结构中的元素尽量大可能具有不同的HashCode，虽然这并不能保证不同的HashCode产生不同的index，但相同的HashCode一定产生相同的index，从而影响产生Hash冲突。

　　对于一个象，如果具有很多属性，把所有属性都参与散列，显然是一种笨拙的设计.因为对象的HashCode()方法几乎无所不在地被自动调用，如equals比较，如果太多的对象参与了散列.那么需要的操作常数时间将会增加很大.所以，挑选哪些属性参与散列绝对是一个编程水平的问题。

　　从实现来说，一般的HashCode方法会这样:

　　return Attribute1.HashCode() + Attribute1.HashCode()..[+super.HashCode()]。

　　我们知道，每次调用这个方法，都要重新对方法内的参与散列的对象重新计算一次它们的HashCode的运算，如果一个对象的属性没有改变，仍然要每次都进行计算，所以如果设置一个标记来缓存当前的散列码，只要当参与散列的对象改变时才重新计算，否则调用缓存的hashCode，这可以从很大程度上提高性能。

　　默认的实现是将对象内部地址转化为整数作为HashCode，这当然能保证每个对象具有不同的HasCode，因为不同的对象内部地址肯定不同(废话)，但java语言并不能让程序员获取对象内部地址，所以，让每个对象产生不同的HashCode有着很多可研究的技术。

　　如果从多个属性中采样出能具有平均分布的hashCode的属性，这是一个性能和多样性相矛盾的地方，如果所有属性都参与散列，当然hashCode的多样性将大大提高，但牺牲了性能，而如果只能少量的属性采样散列，极端情况会产生大量的散列冲突，如对"人"的属性中，如果用性别而不是姓名或出生日期，那将只有两个或几个可选的hashcode值，将产生一半以上的散列冲突.所以如果可能的条件下，专门产生一个序列用来生成HashCode将是一个好的选择(当然产生序列的性能要比所有属性参与散列的性能高的情况下才行，否则还不如直接用所有属性散列)。

　　如何对HashCode的性能和多样性求得一个平衡，可以参考相关算法设计的书，其实并不一定要求非常的优秀，只要能尽最大可能减少散列值的聚集.重要的是我们应该记得HashCode对于我们的程序性能有着生要的影响，在程序设计时应该时时加以注意。

大田斗 2007-08-02 09:53 发表评论

BlogJava-BaoYaEr-文章分类-java

mule事件驱动服务

JDK1.5中的线程池(java.util.concurrent.ThreadPoolExecutor)使用简介

在xml的汪洋中遨游之mule篇

linux下java运行脚本

深入浅出之正则表达式【zt】

JavaClassLoader与Package机制

JTA事务初级研究

Spring2.5注释语法

java annotation

J2SE5.0中最有趣的新特性：注释(annotation) [zt]

java nio 在探索

java 代码优化

SSO单点登录解决方案[转载]

超简单的 Web 爬虫程序

Java技术与Java虚拟机

Java接口妙用

多线程编程——实战篇

Junit 结合spring+hibernate框架

Tomcat6.0 || 5.5 中数据源的配置

Java实现随机验证码功能实例

排序算法复习（Java实现）(一）： 插入，冒泡，选择，Shell,快速排序

java --TreeMap,HashMap

Java泛型再学习

JVM启动参数

1.1 格式

1.2 标准参数

1.3 非标准参数（以-X开头）

多线程编程 基础篇

在java中利用动态编译实现eval

[转载]Tomcat类加载机制

JVM启动参数(转)

1.1格式

1.2标准参数

1.-server

2.-agentlib:=

3.-classpathclasspath

4.-Dproperty=value

5.-enableassertions[:"..."|:]

6.-enablesystemassertions

7.-jar

8.-javaagent:[<=options>]

9.-verbose

10.-version

11.-?

12.-X

1.3非标准参数（以-X开头）

1.-Xint

2.-Xbatch

3.-Xdebug

4.-Xbootclasspath:bootclasspath

5.-Xcheck:jni

6.-Xfuture

7.-Xnoclassgc

8.-Xloggc:file

9.-Xincgc

10.-Xprof

11.-Xrs

Java中的UDP协议编程 [zt]

深入HashCode方法

排序算法复习（Java实现）(一）：插入，冒泡，选择，Shell,快速排序

多线程编程基础篇