BlogJava-庄周梦蝶，孰蝶是我，我是孰蝶？一梦至今，蝶我已难分-随笔分类-java

两段代码的比较

dennis — Sat, 31 May 2008 09:25:00 GMT

第一个程序：

import java.util.ArrayList;
import java.util.List;

public class TailRecursionTest {
    public static void main(String[] args) {
        TailRecursionTest t = new TailRecursionTest();
        for (int i = 0; i < 10000; i++)
            t.a(0);
    }

    public void a(int j) {
        j++;
        List list = new ArrayList<Integer>(100000);
        // 对list进行处理
    }
}

没啥特殊的，仅仅是为了测试，我们将a方法调用10000次，a方法创建一个有100000个元素的list的局部变量。
第二个程序：

import java.util.ArrayList;
import java.util.List;

public class TailRecursionTest2 {
    public static void main(String[] args) {
        TailRecursionTest2 t = new TailRecursionTest2();
        t.a(0);
    }

    public void a(int j) {
        System.out.println(j);
        j++;
        if (j == 10000)
            return;
        List list = new ArrayList<Integer>(100000);
        // 对list进行处理
        a(j);
    }
}

也没啥特殊的，就是将循环换成了递归，a方法做的事情没变。两个都跑一下，程序1顺利结束，程序2出问题了，啥问题？如下：

161
162
163
164
165
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at java.util.ArrayList.<init>(Unknown Source)
    at TailRecursionTest2.a(TailRecursionTest2.java:17)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)
    at TailRecursionTest2.a(TailRecursionTest2.java:20)

我倒，才运行166次了，heap就满了。问题在哪呢？oh,yep，你肯定想到了，是不是重复创建list这个大集合引起的呢？它不是局部变量吗？怎么也会溢出？是的，list是局部变量，在a的方法栈里引用着，指向heap上的大对象，更关键的问题在于，java是没有尾递归优化的，递归方法是不会使用同一个栈帧，每一次递归调用，都将压入新的栈帧，并且这个栈帧上又new了一个list变量，引用着heap上新的一个大集合。随着栈深度的增加，jvm里维持着一条长长的方法调用轨迹以便你能回来，在方法没有返回之前，这些list变量一直被各自的栈帧引用着，不能被GC，你说，能不OOM吗？
也许，你想到了个补救方法来挽救程序2，就是每次在处理完list后，我把它设置为null，不让栈帧继续引用着它，咱编写对gc友好的代码，这不就行了，试试：

得意洋洋，我跑一下看看，这次跑到4000多次，但是：

......
4289
4290
4291
4292
java.lang.StackOverflowError
    at sun.nio.cs.ext.DoubleByteEncoder.encodeArrayLoop(Unknown Source)
    at sun.nio.cs.ext.DoubleByteEncoder.encodeLoop(Unknown Source)
    at java.nio.charset.CharsetEncoder.encode(Unknown Source)

没办法啊，人家sun的jdk就是不支持尾递归优化，很不给你面子的栈溢出了。ibm的jdk据说支持尾递归优化，上面这个程序在ibm的jdk上可能可以正常结束，未经测试。

总结：在java里，递归最好咱还是别用，老老实实地while、for；就算递归了，最好递归方法不要new太大的对象，除非你能确定递归的深度不是那么大。

dennis 2008-05-31 17:25 发表评论

Insect Workflow

dennis — Wed, 21 May 2008 07:09:00 GMT

今天整理代码，发现一个去年写的简单的工作流引擎，基于petri网（参考这里的笔记)，实现了顺序、并行、循环和选择四种路由，资源也实现了人工驱动和定时、延迟时间驱动；目前只实现了将工作流数据保存在内存的版本，然后就换工作，折腾着就忘了这个事儿，本来是计划加入数据库存储的。尽管只是个toy，可能对工作流感兴趣，或者想自己实现一个玩玩的朋友有参考价值，放到了google code上，svn地址：
http://insectworkflow.googlecode.com/svn/trunk/ 源码中有在example包下给了个请假的例子，流程定义文件就是processes包下的leave.xml，实现大概是这么个流程：填写假单-》提交假单-and-split节点-》项目经理审批-》and-join节点-》结束 -》部门经理审批-》其中项目经理审批和部门经理审批是并行路由。xml配置大概这样：

<node type="and-split" name="and-split" id="2">
        <inputs>
            <place id="3" />
        inputs>
        <outputs>
            <place id="4" />
            <place id="5" />
        outputs>
    node>
    <node name="dept_manager_confirm" id="3">
        <resource class="com.google.code.insect.workflow.impl.Group" id="2"
            name="dept_manager">
        resource>
        <conditions type="and">
            <condition
                class="com.google.code.insect.workflow.impl.NullHandler" value="false"
                variable-name="LeaveInfo" />
        conditions>
        <handler
            class="com.google.code.insect.workflow.example.leave.SendRemindHandler" />
        <inputs>
            <place id="4" />
        inputs>
        <outputs>
            <place id="6" />
        outputs>
    node>
    <node name="project_manager_confirm" id="4">
        <resource class="com.google.code.insect.workflow.impl.Group" id="3"
            name="project_manager">
        resource>
        <conditions type="and">
            <condition
                class="com.google.code.insect.workflow.impl.NullHandler" value="false"
                variable-name="LeaveInfo" />
        conditions>
        <handler
            class="com.google.code.insect.workflow.example.leave.SendRemindHandler" />
        <inputs>
            <place id="5" />
        inputs>
        <outputs>
            <place id="7" />
        outputs>
    node>
    <node type="and-join" name="and-join" id="5">
        <handler
            class="com.google.code.insect.workflow.example.leave.ResultHandler" />
        <inputs>
            <place id="6" />
            <place id="7">place>
        inputs>
        <outputs>
            <place id="8" />
        outputs>
    node>

其中的place就是各个Transition的输入或者输出库所，所谓node其实就是变迁（transition)，每个变迁对应一个handler，执行具体的业务操作，比如这里的com.google.code.insect.workflow.example.leave.SendRemindHandler 用于发送提醒消息给经理们。具体调用和工作项的人工触发：

//初始化工作流管理器
WorkFlowManager wm = new BasicWorkflowManager();
wm.setConfiguration(new DefaultConfiguration());

//启动一个案例
Token token = wm.startWorkFlow("leave");
token.setAttribute("LeaveInfo", leaveInfo);

//提交假单
wm.doAction(token.getId(), this.dennis, "给领导发送消息："
+ leaveInfo.getStaff_name() + "申请请假，请批准!");
//将token的id传递给后续节点做处理。。token的id就是案例id

processes包下面的流程定义文件和test包下的TestUnit，分别测试了四种路由和定时、延时触发，有兴趣的可以看一下。

dennis 2008-05-21 15:09 发表评论

使用Rope来高效处理长字符串

dennis — Mon, 05 May 2008 10:41:00 GMT

前段时间看了这篇文章《Ropes：理论与实践》。这两天为了提高工作中某个系统对外接口的效率，才认真学习了一番。本质上Ropes是将字符串表示为一棵二叉树，特别适用于长字符串的处理，貌似c++ STL库中也有这么个实现。具体实现和原理还是看这篇paper。《Ropes：理论与实践》一文中给出的测试数据相当惊人，Ropes比之String和StringBuffer在append,insert,delete等操作上的效率都有一个数量级以上的差距。跑下作者给出的测试程序，其实在测试的字符串不是很长的情况下，这个差距并没有那么大，这也从侧面说明了Rope的应用范围：即只有在大量修改大型字符串的应用程序中才能看到明显的性能提升。那么是否可以用Rope替代StringBuffer做append生成字符串（比如我要的生成xml)。作者也说啦：
“由于 Rope 的附加性能通常比 StringBuffer 好，这时使用 rope 是否有意义呢？答案还是否。不论何时将输入的数据组合在一起形成格式化输出时，最漂亮最有效的方法是使用模板引擎（例如 StringTemplate 或 FreeMarker）。这种方法不仅能干净地将表示标记与代码分开，而且模板只进行一次编译（通常编译为 JVM 字节码），以后可以重用，从而使它们拥有极佳的性能特征。”

我用Rope for java替代了StringBuffer做XML生成，效率提升在5%-30%左右，xml字符串不是很长，这个提升显然有限，也带来了不必要的复杂度。因此最后还是用Velocity模板引擎来生成XML，测试的结果效率并没有多少改善，但是显然更容易维护和开发了。回到Rope的话题，我用Ruby实现了个版本，Rubyforge上有一个Rope的实现，但是看了源码，与paper所述算法有点差异，因此照着Rope for java也实现了一个Rope4r。测试的结果证明在长字符串的累积操作上，Rope4r的append比之String的+=性能可以快上3倍左右，而如果采用String的<<操作，不是immutable的，当然是最快了；比较郁闷的是slice和insert操作都比String的慢上几倍，因为Ruby的String、Array的内建对象都是直接用c写成并做了优化的，我猜测原因在这。

dennis 2008-05-05 18:41 发表评论

一切为了跨平台

dennis — Tue, 22 Apr 2008 10:12:00 GMT

推荐两篇blog：
《java NIO 类库selector机制解析（上）》
《java NIO 类库selector机制解析（下）》

有一个奇怪的现象引出的话题，为了Selector.wakeup功能做到跨平台，每个Selector.open()时，在Windows会建立一对自己和自己的loopback的TCP连接；在Linux上会开一对pipe（pipe在Linux下一般都是成对打开）。java为了跨平台真是无所不用其极，此中冷暖谁知啊。

dennis 2008-04-22 18:12 发表评论

使用jprofiler监控jruby脚本

dennis — Mon, 24 Mar 2008 07:26:00 GMT

jruby本质上也是启动一个jvm，然后去读Ruby脚本并解释执行（也可以编译），因此jprofiler理所当然也可以去监控jruby脚本的执行。
执行

jruby hello.rb

等价于执行：

java -Xmx378m -Xss1024k -Djruby.home=/usr/local/jruby
-Djruby.lib=/usr/local/jruby/lib Djruby.script=jruby org.jruby.Main hello.rb

这一点，你可以通过ps aux |grep jruby 看到。因此配置jprofiler就简单了，在VM arguments加上这些参数（可以包括jruby的参数），比如我的VM arguments配置如下：

-server -Xmx378m -Xss1024k -Djruby.script=jruby -Djruby.thread.pooling=true
-Djruby.jit.threshold=0 -Djruby.compile.fastest=true
-Djruby.home=D:\jruby\jruby-1.1RC2 -Djruby.lib=D:\jruby\jruby-1.1RC2\lib

Main class or executable JAR填上：org.jruby.Main。然后就是Arguments一栏填上你的脚本位置：

D:\ruby\lib\hello.rb

最后，别忘了将jruby/lib目录下的bsf.jar和jruby.jar加入Class Path。

大功告成，你可以用jprofiler去观察GC、线程和锁、Heap等等了。

dennis 2008-03-24 15:26 发表评论

Grizzly——不走寻常路的nio框架

dennis — Sat, 23 Feb 2008 11:13:00 GMT

    在《程序员》最新一期有个专题介绍java开源nio框架，其中谈到了mina和grizzly。mina我还算比较熟悉，写过一些代码，也尝试去读过源码。而grizzly是第一次听说，这个项目是sun的一个开源nio框架，是2004年在GlassFish项目中诞生的，一开始是一个http web server，用于取代Tomcat的Coyote Connector和Sun WebServer，2007年7月1.5版本发布并宣布成为开源项目，项目主页在https://grizzly.dev.java.net
    grizzly与mina的性能比较（基于2007年JavaOne会议上的ppt)

    GlassFish vs Tomcat


     grizzly的设计与一般的nio框架相比是比较不同的，主要不同点在于读和写都是采用blocking方式，并且使用临时selector；线程模型可配置，不过据作者介绍在跑一个selector主线程处理ACCEPT，用线程池处理read和write性能表现最好，这点不出意料。

dennis 2008-02-23 19:13 发表评论

保持java线程间可见性的5种方式

dennis — Sat, 23 Feb 2008 02:44:00 GMT

Primitive	Writes up to and including…	...are made visible to…
Object	the end of a synchronized block or method	a thread entering a synchronized block or method for the same object.
Volatile field	a write to a volatile field	any thread reading that volatile field.
Thread	a call to `Thread.start`	the newly started thread.
Thread	the final write made by a dying thread	any thread which successfully calls `Thread.join` on that thread.
Final field	the initialization of a final field (but only those writes affecting the field and any object it references)	any thread, provided that the constructor of the object containing the field doesn’t write the value of `this` anywhere eventually visible to other threads

这些在《java并发编程实践》一书中已经有详细解释，特别是对于ReentrantLock、volatile域以及final域的讨论。今天在MenTaLguY的blog上看到这张表，摘录下。

dennis 2008-02-23 10:44 发表评论

java nio之Buffer(一)

dennis — Fri, 22 Feb 2008 06:31:00 GMT

Buffer是一个包装了基本数据元素数组的对象，它以及它的子类定义了一系列API用于处理数据缓存。

一、属性
Buffer有四个基本属性：
1、capacity 容量，buffer能够容纳的最大元素数目，在Buffer创建时设定并不能更改
2、limit buffer中有效位置数目
3、position 下一个读或者写的位置
4、mark 用于记忆的标志位，配合reset()使用，初始值未设定，调用mark后将当前position设为值

四者关系：0 <= mark <= position <= limit <= capacity

二、API

package java.nio;
public abstract class Buffer {
public final int capacity( )
public final int position( )
public final Buffer position (int newPosition)
public final int limit( )
public final Buffer limit (int newLimit)
public final Buffer mark( )
public final Buffer reset( )
public final Buffer clear( )
public final Buffer flip( )
public final Buffer rewind( )
public final int remaining( )
public final boolean hasRemaining( )
public abstract boolean isReadOnly( );
}

支持链式调用，如：buffer.mark().position(5).reset( );
注意isReadOnly()方法决定了buffer是否可写。

三、操作
以ByteBuffer为例，
1、访问，通过get(),get(index),其中get()从当前position位置读取，get(index)从index位置读取，不改变当前position,下面要说到的put也一样。
2、填充，通过put(byte),put(index,byte)，按照绝对位置填充也是不改变当前position属性

3、flipping，试想，我们将填充完毕的buffer传递给socket输出，那么socket读取是依据position属性确定，就会从结尾后一位开始读，这样肯定是不正确的，如果要正确的读取我们先要：
buffer.limit(buffer.position( )).position(0);
将limit设为position, 将position设为0，这个操作就叫flipping，API直接提供了这个操作：
buffer.flip( );
特别注意，flip()方法会改变limit属性，将limit属性从capacity设置为当前position。rewind()方法与flip()类似，但是仅将position设为0，而不改变limit，通常用于重新读取已经被flip的buffer。flip()另一个注意点是，两次调用buffer的flip方法，将使得position和limit属性都为0。

4、迭代取元素：

for (int i = 0; buffer.hasRemaining( ), i++) {
myByteArray [i] = buffer.get( );
}

int count = buffer.remaining( );
for (int i = 0; i < count, i++) {
myByteArray [i] = buffer.get( );
}

ByteBuffer不是线程安全的，前一种方式适合并发访问，后一种方式效率更高。这两种方式都是一个一个取，效率都比批量取低。

5.clear()方法，将buffer重设为空状态，也就是设置limit=capacity,position=0，以便重复利用。

6.compact()方法，用于压缩buffer，这个方法在多次重复调用时是比较低效。

7.mark(),初始是未定义的，这适合如果调用reset将抛出InvalidMarkException。调用makr()后，将当前position设为mark以便reset时返回。注意，rewind( ), clear( ), and flip( )方法都将丢弃已经创建的mark。调用limit(index),positioon(index)，如果index的值小于当前mark，mark也将被丢弃。

8.比较，可以通过equals()和compateTo()方法来比较两个buffer，前一个返回boolean，后一个返回0，-1，1。两个buffer equal的条件是：
1）类型相同
2）剩余元素的数目相等
3）剩余元素也一一相等

9、批量移动数据，为了更有效地进行数据传送，批量的数据存取肯定是不能少的，Buffer及其子类都有提供类似的方法，比如CharBuffer:

public CharBuffer get (char [] dst)
public CharBuffer get (char [] dst, int offset, int length)
public final CharBuffer put (char[] src)
public CharBuffer put (char [] src, int offset, int length)
public CharBuffer put (CharBuffer src)
public final CharBuffer put (String src)
public CharBuffer put (String src, int start, int end)

四、创建Buffer
Buffer以及其子类都无法直接new，而必须把通过他们提供的工厂方法来创建。通常有两种方式：
1、allocate，例如
CharBuffer charBuffer = CharBuffer.allocate (100);
将在堆上分配一个可以存储100个字符的数组作为backing store。

2、wrap，包装一个已有的数组：
char [] myArray = new char [100];
CharBuffer charbuffer = CharBuffer.wrap (myArray);
注意,这样的方式创建的Buffer，将不会在堆上创建新的数组，而是直接利用myArray做backing store，这意味着任何对myArray或者buffer的修改都将影响到buffer或者myArray。可以通过public final boolean hasArray( )方法来判断是否拥有一个数组，通过array()方法取得这个数组。

五、复制Buffer
其实这个复制也是“浅拷贝”，通过duplicate()方法将返回一个新创建的buffer，这个新buffer与原来的Buffer共享数据，一样的capacity，但是有自己的position、limit和mark属性。通过asReadOnlyBuffer()方法复制的buffer与duplicate()类似，但是是只读的，不能调用put。比较特别的是slice()方法，故名思议，类似切割一个Buffer出来，与duplicate类似，但是它将从原来Buffer的当前position开始，并且capacity等于原来Buffer的剩余元素数目，也就是(limit-position)。

dennis 2008-02-22 14:31 发表评论

JRuby 1.1 RC2 Released

dennis — Mon, 18 Feb 2008 01:43:00 GMT

修正了很多bug，我关注的 JRUBY-1686也得到了修正，距离1.1的发布不远了。

The JRuby community is pleased to announce the release of JRuby 1.1 RC 2

Homepage: http://www.jruby.org/
Download: http://dist.codehaus.org/jruby/

JRuby 1.1RC2 is the second release candidate of JRuby 1.1. JRuby 1.1
represents a concerted focus on speed and refinement. ruby code can
completely compile in an Ahead Of Time (AOT) or Just In Time (JIT) mode;
yielding a faster ruby! It also uses less memory than our previous releases.

We need people to download JRuby 1.1RC2 and give us feedback. Test your
applications and help us make JRuby 1.1 a great release.

Highlights:
- 260 issues resolved since JRuby 1.1RC1
- Large IO refactoring
- Memory improvements for JIT'd methods:
- Control total number of methods JIT'd
- Support a JIT cache between runtimes to return permgen
- Reduce codesize of generated methods (50-70% reduction)

dennis 2008-02-18 09:43 发表评论

JRuby中使用接口和抽象类

dennis — Fri, 15 Feb 2008 06:34:00 GMT

要在JRuby中实现java接口，接口include进来，实现接口方法即可，例如实现java.lang.Runnable接口做线程处理：

require 'java'
include_class 'java.lang.Runnable'
class TestRunnable
    include Runnable
    def initialize(name)
      @name=name
    end
    def run
      puts "hello,"+@name
    end
end

要在JRuby中继承抽象类，实现其中的抽象方法，方法稍微麻烦点，需要cglib，到这里下载cglib-nodep-2.1_3.jar，写个通用库abstract_class.rb方便处理:

load 'cglib-nodep-2.1_3.jar'

class Object
  include Java
  include_class "net.sf.cglib.proxy.Enhancer"
  include_class "net.sf.cglib.proxy.NoOp"

  class <<self
    def method_missing(mname, *args, &block)
      unless mname == :abstract_impl and respond_to?(:java_class) and JavaLang::reflect::Modifier.isAbstract(JavaLang::Class.for_name(java_class.name).modifiers)
        super
      else
        generate_abstract_impl(args, &block)
      end
    end

    private

    def generate_abstract_impl(args, &block)
      factory = Enhancer.new
      factory.setSuperclass(java_class)
      factory.setInterfaces(java_class.interfaces.to_java("java.lang.Class"))
      factory.setCallback(NoOp::INSTANCE)

      object_args = args.map { |arg| Java.ruby_to_java(arg) }
      class_arguments = object_args.map {|arg| arg.java_class}.to_java("java.lang.Class")
      generated_class = factory.create(class_arguments, object_args.to_java("java.lang.Object"))

      ruby_class = Class.new(generated_class.class)
      ruby_class.class_eval(&block)

      return ruby_class.new(*args)
    end
  end

end

使用的话，require一下abstract_class，例如我们要继承java.util.TimerTask，实现其中的run方法：

$:.unshift File.join(File.dirname(__FILE__),'.')
require 'java'
require 'abstract_class'
import java.util.TimerTask
import java.util.Timer
timer_task = TimerTask.abstract_impl do
  def run
    puts "timer task"
  end
end

Timer.new.schedule(timer_task, 1000, 1000)

dennis 2008-02-15 14:34 发表评论

JRuby的性能优化(update)

dennis — Thu, 31 Jan 2008 10:58:00 GMT

越来越觉的JRuby是个很有前途的项目，结合Ruby的性感语法和java极其丰富的类库，况且有团队持续不断地修正bug、改进性能，这样的玩意完全有成为“少男杀手”的潜质。JRuby wiki上列出了性能优化的四条建议：
1、调优编译器，JRuby早就弃暗投明跟随XRuby走上了编译这条牛B的道路，将Ruby Script编译成字节码，因此这个环节是断断不能忽略的。
两种编译方式：
AOT模式：直接生成class文件，脱了Ruby这层皮，咱就是人见人“爱”的java了。
JIT模式：充分利用成熟的jit技术，咱不全脱，朦胧美才是真的美。默认从0.9.9版本开始就是开启的，关闭的话（要我说还不如全脱）

jruby -J-Djruby.jit.enabled=false

2、关闭ObjectSpace
ObjectSpace是Ruby用来操作所有运行时对象的模块，这个功能相当牛x。这个的实现在c ruby里是比较容易的，但是对于JRuby代价就比较昂贵了，其实就大部分情况下你基本用不到这个东东，那么最好就是关闭它，JRuby提供了

jruby -J-Djruby.objectspace.enabled=false

选项来关闭它。

3、开启线程池
我们知道，在c ruby中的线程是绿色的轻量级线程，因此运行时就动不动开个百来十个“线程”跑一跑充下款爷；然而在JRuby中，线程的实现那可是实打实的本地线程（也就是Ruby线程与java线程一比一），你这么动不动上百个线程那不慢才怪了。因此JRuby提供了线程池选项，运行时尽可能地满足你的要求开线程，但是当短命的Ruby线程重复创建的时候，这些线程将被复用，这在大多数情况下能提高性能表现，特别是在每次调用都启动一个线程的情况下。不过具体效果还是要测试的实际数据说话。

jruby -J-Djruby.thread.pooling=true

4、使用Java "server"模式虚拟机，地球淫都知道

jruby -J-server myscript.rb

5、尽量使用最新的jdk，在我的测试中，jdk6跑jruby是效率最高的。

dennis 2008-01-31 18:58 发表评论

介绍下smartclient

dennis — Tue, 08 Jan 2008 07:48:00 GMT

smartclient是一个企业级的ajax框架，包括非常出色的UI库、工具库和客户端服务端数据绑定等功能。smartclient本来是一个商业产品， 2007年11月7号才以LGPL协议开源。除了一些所见即所得的构建工具和企业级的可选组件外，其他都开源了。这个记的javaeye和infoq都有报道。
在接触smartclient以前，我还没有使用过类似的ajax ui库，比如现在很火的ext。smartclient给我的第一印象是非常漂亮的ui效果，有兴趣可以去它的官方demo看看。smartclient的demo和文档做的非常出色，入手开发也非常容易。
第一步：下载LGPL版本，并解压缩
第二步：运行解压后目录下的\SmartClient_60_LGPL\smartclientSDK\start_embedded_server.bat，SDK自带了一个内嵌的tomcat
第三步：访问 http://localhost:8080

你将见到：

这些demo本身就是用smartclient制作的。开发过程中你需要做就是查看examples和文档中的reference（api文档），基本没有解决不了的问题。

人见人爱的Hello World例子：

isc.Label.create({
    height: 50,
    styleName: "helloWorldText",
    padding: 4,
    backgroundColor: "#ffffd0",
    align: "center",
    valign: "center",
    wrap: false,
    showEdges: true,
    showShadow: true,
    contents: "Hello world!"
})

效果：

smartclient除了完整的UI组件，还包括丰富的动态效果库以及可选的皮肤等高级主题，不再展开了，毕竟贴图是在是挺麻烦的事情：）还不如有兴趣的自己翻demo。说了这么多优点，那么缺点是啥？你可能猜到了，性能！所有js UI库无法避免的问题，不过我没有其他UI库的使用经验，倒是不能给出个比较数据。我们写的东西的性能也只是堪堪能够接受。
smartclient跟dwr可以说是天生一对，smartclient UI组件的数据源可以是xml也可以是json，如果采用json做交换格式，可以与dwr无缝结合，真正实现One Page,One Application（我们就是这样做的^_^)。

dennis 2008-01-08 15:48 发表评论

介绍一个轻量级java的swf处理库

dennis — Fri, 04 Jan 2008 03:46:00 GMT

提取swf文件元信息、压缩swf、解压swf都可以处理，来自于http://www.brooksandrus.com/blog/category/java/，或者直接这里下载。

一个小例子：

         SWFHeader header = new SWFHeader("G:\\mplayer\\test.swf");
        System.out.println("signature:   " + header.getSignature());
        System.out.println("version:     " + header.getVersion());
        System.out.println("compression: " + header.getCompressionType());
        System.out.println("size:        " + header.getSize());
        System.out.println("nbits:       " + header.getNbits());
        System.out.println("xmax:        " + header.getXmax());
        System.out.println("ymax:        " + header.getYmax());
        System.out.println("width:       " + header.getWidth());
        System.out.println("height:      " + header.getHeight());
        System.out.println("frameRate:   " + header.getFrameRate());
        System.out.println("frameCount:  " + header.getFrameCount());

压缩、解压缩，需要注意生成的文件将覆盖原文件：

//压缩
SWFCompressor compressor=new SWFCompressor("G:\\mplayer\\test.swf");
//解压缩
SWFDecompressor decompressor=new SWFDecompressor("G:\\mplayer\\test.swf");

dennis 2008-01-04 11:46 发表评论

PPT转图片(更新）

dennis — Fri, 04 Jan 2008 03:26:00 GMT

update:2008-05-05，POI已经可以处理这个需求：

package net.rubyeye.test;

import java.io.FileOutputStream;

import org.apache.poi.hslf.HSLFSlideShow;
import org.apache.poi.hslf.model.Picture;
import org.apache.poi.hslf.usermodel.PictureData;
import org.apache.poi.hslf.usermodel.SlideShow;

public class PPTToImageConverter {
    public static void main(String[] args) throws Exception {
        SlideShow ppt = new SlideShow(new HSLFSlideShow("D:/test.ppt"));

        // extract all pictures contained in the presentation
        PictureData[] pdata = ppt.getPictureData();
        for (int i = 0; i < pdata.length; i++) {
            PictureData pict = pdata[i];

            // picture data
            byte[] data = pict.getData();

            int type = pict.getType();
            String ext;
            switch (type) {
            case Picture.JPEG:
                ext = ".jpg";
                break;
            case Picture.PNG:
                ext = ".png";
                break;
            case Picture.WMF:
                ext = ".wmf";
                break;
            case Picture.EMF:
                ext = ".emf";
                break;
            case Picture.PICT:
                ext = ".pict";
                break;
            default:
                continue;
            }
            FileOutputStream out = new FileOutputStream("D:/test/pict_" + i + ext);
            out.write(data);
            out.close();

        }
    }
}

   原文：
   小结下最近做的东西吧。因为是做一个素材管理的东西，因此需要处理各种各样的素材，音频、视频、图片、pdf、ppt等等。遇到一个需求就是将PPT转成图片组，google一下，在java里是可以jcom之类的开源库实现，本质上都是通过jni调用office的COM接口来实现。我们就需要这么一个小功能，拖这么大个开源库进来实在没有必要。最后决定自己写个动态链接库，通过jni来调用。
    先写工具类，

public class PPTUtils {
    public PPTUtils() {
    }

    public static native void convertPPT2IMG(String pptFileName, String tmpDir);

    public static void loadLibrary() {//加载动态库
        String dllFileName = "pptDll";
        try {
            String OsName = System.getProperty("os.name");
            if (OsName.contains("Windows")) {
                dllFileName += ".dll";
            } else {
                dllFileName += ".so";
            }
            //加载动态链接库
            System.load(dllFileName);

        }
        catch (Exception e) {
         //   LOG.error("can not load " + dllFileName + ", " + e.getMessage());
            e.printStackTrace();
        }
     }
}

编译一下，执行javah PPTUtils生成头文件PPTUtils.h。接下来用vc写个动态链接库，记的将MSPPT.OLB（在office安装目录下）加入工程，新建一个ppt2img.cpp：

#include "stdafx.h"
#include "PPTUtils.h"
#include "msppt.h"

JNIEXPORT void JNICALL Java_com_starnet_dmb_util_PPTUtils_convertPPT2IMG(JNIEnv *env,
      jclass clazz, jstring pptFileName, jstring tmpDir){
   //初始化com
    if (CoInitialize( NULL ) == E_INVALIDARG)
    {
       AfxMessageBox(_T("初始化Com失败!"));
       return;
    }
    _Application   app;
    Presentations   prsts;
    _Presentation   prst;
    //jstring转成char *
   const char *ppt;
   ppt = env->GetStringUTFChars(pptFileName,0);
   const char *tmp;
   tmp=env->GetStringUTFChars(tmpDir,0);

   if(!app.CreateDispatch(_T("PowerPoint.Application"))){
      AfxMessageBox(_T("初始化PowerPoint失败!"));
       return;
   }
   prsts   =   app.GetPresentations();
   prst   =   prsts.Open(_T(ppt),false,false,false);
   prst.SaveAs(_T(tmp),17,false);
   app.ReleaseDispatch();
   app.Quit();
   env->ReleaseStringUTFChars(pptFileName,ppt);
   env->ReleaseStringUTFChars(tmpDir,tmp);
   CoUninitialize();
}

dennis 2008-01-04 11:26 发表评论

视频站点的搭建

dennis — Wed, 19 Dec 2007 08:46:00 GMT

挺久没动笔写blog了，换了新工作比较忙是一个原因。最近的工作是做一个素材管理的系统，其中有个要求做视频预览，将用户上传的视频转换并在网页上预览。在网页上看视频，现在大多数视频网站都是采用flv流媒体文件，用flash做的播放器播放，我们也采用了这种方式。流程大概主要：用户上传文件->后台转换文件成flv格式->flv播放器调用flv文件。
转换视频、音频文件到flv格式可以使用mencoder或者ffmpeg，我们采用了mencoder，在linux上的安装参考这里,安装结束后记的设置环境变量：export LD_LIBRARY_PATH=/usr/local/lib:LD_LIBRARY_PATH
java调用的话就是通过Process：

Process process = runtime.exec(cmd);

mencoder转换视频音频成flv命令：
mencoder 源文件 -o 目标文件.flv -of lavf    -lavfopts i_certify_that_my_video_stream_does_not_use_b_frames -oac mp3lame -lameopts abr:br=56 -ovc lavc -lavcopts vcodec=flv:vbitrate=400:mbd=2:mv0:trell:v4mv:cbp:last_pred=3:dia=4:cmp=6:vb_strategy=1 -vf scale=200:-3 -ofps 12 -srate 22050

取视频元信息命令（视频比特率、长宽等信息）：
mplayer -identify 文件名 -ao null -vo null -frames 0

切割视频命令：
mencoder -ss 开始时间 -oac copy -ovc copy -endpos 终止时间文件名 -o 目标文件名

    操作flv文件（给视频打上信息、切割之类）可以采用flvtool2。

    需要注意的是通过java调用的话，一定要处理标准输出和标准错误输出，不然进程会挂在那结束不了，可以开个线程取处理。在网页播放的话，可以考虑用这个播放器，具体参数看它的说明。最后一个问题，IE6的flash控件需要激活，这个问题的解决可以采用swfobject.js。
    有兴趣的老大们可以考虑自己搭个“土豆网”，说不定哪天拿了风投.....浮云

dennis 2007-12-19 16:46 发表评论

抽取网页数据的不同思路

dennis — Thu, 22 Nov 2007 04:35:00 GMT

    客户要求从Internet上的网页上抽取一定的数据，用来显示或者其他用户，这个需求很常见。这两天我们也遇到了这个需求，本来我一开始想是试用正则表达式去匹配需要的文本数据，后来经验丰富的经理给出了一个更好的思路，就是使用jtidy将不符合xhtml的HTML文件转化成标准的xhtml文件——本质上就是XML文件，然后利用xsl抽取并转换成我们所需要的数据的一定格式的xml文件。这样做其实就是将XSL模板当正则表达式来用，不过更清晰，当网页改变时也不需要重新编译代码，仅仅修改XSL模板就够了。过程如下：
     html->xhtml--xsl-->数据xml

    做的过程中，初次使用了xsl,xpath等技术，网上找了不少好资料，共享下：
jtidy:

思路来源
http://www.ibm.com/developerworks/cn/xml/x-wbdm/

项目地址
http://jtidy.sourceforge.net/

参考，解决中文问题使用
http://www.blogjava.net/jhengfei/archive/2006/03/25/37312.html

xsl,非常系统教程和实践:

http://www.cnblogs.com/goody9807/category/36016.html

xpath:

http://www.yesky.com/201/171201.shtml

dennis 2007-11-22 12:35 发表评论

再谈java的内存泄露

dennis — Sun, 11 Nov 2007 12:18:00 GMT

    这两天看了一本老书《bitter java》，第一次系统地了解了所谓“反模式”。就书的内容来说已经过于陈旧，书中提到的magic servlet、复合jsp等等反模式已经是早就熟知的编程禁忌，而如web页面不能有太多元素这样的反模式也因为ajax的出现（异步加载）变的不是那么“反模式”了，其中又讲述了很多ejb的反模式，这些在轻量级框架流行的今天也早已经过时。不过书中有一个章节倒是挺有价值，讲述的是java的内存泄露问题，我认为是我目前读的关于这方面问题比较有价值的介绍。
    网上关于java内存泄露的资料都过于玄乎，其实java导致内存泄露的原因很明确：长生命周期的对象持有短生命周期对象的引用就很可能发生内存泄露，尽管短生命周期对象已经不再需要，但是因为长生命周期对象持有它的引用而导致不能被回收，这就是java中内存泄露的发生场景。作者在书中提到了3个场景：
1。流失监听器问题，在awt、swing编程中，给组件添加了事件监听器，这些组件的生命周期如果很长的话，监听器对象将不能被正确回收。关于GUI编程我不是很熟悉，这一点存有疑问，因为显然你触发一个按钮的事件，当然是一直期待同样的行为发生，如果删除了监听器或者使用弱引用让JVM回收不符合业务逻辑和用户体验。

2。集合类，集合类仅仅有添加元素的方法，而没有相应的删除机制，导致内存被占用。这一点其实也不明确，这个集合类如果仅仅是局部变量，根本不会造成内存泄露，在方法栈退出后就没有引用了会被jvm正常回收。而如果这个集合类是全局性的变量（比如类中的静态属性，全局性的map等），那么没有相应的删除机制，很可能导致集合所占用的内存只增不减，因此提供这样的删除机制或者定期清除策略非常必要。

3。单例模式。不正确使用单例模式是引起内存泄露的一个常见问题，单例对象在被初始化后将在JVM的整个生命周期中存在（以静态变量的方式），如果单例对象持有外部对象的引用，那么这个外部对象将不能被jvm正常回收，导致内存泄露，考虑下面的例子：
class A{
    public A(){
           B.getInstance().setA(this);
   }
   ....
}
//B类采用单例模式
class B{
     private A a;
     private static B instance=new B();
     public B(){}
     public static B getInstance(){
         return instance;
    }
    public void setA(A a){
          this.a=a;
    }
   //getter...
}

显然B采用singleton模式，他持有一个A对象的引用，而这个A类的对象将不能被回收。想象下如果A是个比较大的对象或者集合类型会发生什么情况。

    上面所讲的这些也启发我们如何去查找内存泄露问题，第一选择当然是利用工具，比如jprofiler，第二就是在代码复审的时候关注长生命周期对象：全局性的集合、单例模式的使用、类的static变量等等。

dennis 2007-11-11 20:18 发表评论

写一个简单的工作流（四）资源的处理

dennis — Sat, 13 Oct 2007 09:15:00 GMT

    昨天晚上搞到深夜，终于将资源模块搞定。到今天已经完成的功能包括：
1.四种基本路由：顺序、选择、并行、循环
2.流程定义文件和系统配置文件的读取和解析
3.使用内存作为流程数据和案例数据存储的MemoryWorkFlowDAO的开发
4.资源模块的开发
5.并发情况下的正确性测试等

    计划中的功能：
1.一个GUI的流程定义工具，这个不急，也还没想好用什么做，web还是桌面？
2.各个数据库版本的WorkFlowDAO的开发，将流程数据和案例数据保存在数据库中。
3.更多的测试和example试验。

    回到资源这个概念，工作流中工作项（work item）的由资源来驱动的，这个资源(resource)可能是用户、角色、定时时间或者某个事件消息。在标准petri网中，工作项对应于transition(变迁），变迁都是自动的，不需要所谓资源来驱动，显然，这与工作流系统不同。具体到insect workflow(我取的名字，小巧之意），每个transition都有一个resource，用于驱动自身的firing，所有的resource都实现Resource接口：

public interface Resource extends Serializable {

    public void start(Transition transition, Token token, Object args);

    public ResourceType getType();

    public long getId();

}

每个资源都有一个类型，以及这个类型中独一无二的id，start方法用于驱动transtion的firing。一般情况下，你不需要实现这个接口，只要继承这个接口的抽象实现类AbstractResource，AbstractResource的start方法默认实现是首先调用模板方法doAction（稍后解释）,然后检查触发条件，如果通过就直接调用transition的fire方法：

public abstract class AbstractResource implements Resource {

    public void start(Transition transition, Token token, Object args) {
        doAction(transition, token, args);

        if (transition.getCondition() != null
                && !transition.getCondition().check(token))
            throw new ConditionException(transition.getName()
                    + " transition没有满足触发条件");
        transition.fire(token, args);
    }
    public abstract void doAction(Transition transition, Token token,
            Object args) ;

}

Transtion类的fire方法有三个操作组成：从输入库所移走token，往输出库所放入token，回调handler：

    public void fire(Token token, Object args) {
        removeTokenFromInputs(token);
        addTokenToOutputs(token);
        invokeHandler(token, args);
    }

那么具体的资源显然要实现AbstractResource中的doAction抽象方法，系统内置了五种资源：自动资源（AutoResource）、用户(User)、用户组(Group)、定时器(TimerResource)和事件监听器（ObserverResource）。显然，AutoResource、User和Group的doAction方法不需要做任何事情：

public class User extends AbstractResource {
    protected Group group;

    @Override
    public void doAction(Transition transition, Token token, Object arg){
    }

}

而TimerResource就需要做特殊处理了，比如我们要达到这样的效果：节点1状态已经处于就绪，可以被触发，可我们希望在就绪后延迟半分钟再触发，或者在晚上10点触发等等。这样的定时需求很常见，我采用了jdk5引入的ScheduledExecutorService来处理。系统中启动这样一个线程池，每个类似上面的请求都提交给这个线程池来处理，那么TimerResource就需要进行相应的修改：

public abstract class TimerResource extends AbstractResource {

    protected int pool_size;

    protected static ScheduledExecutorService scheduledExecutorService;

    @Override
    public long getId() {
        // TODO Auto-generated method stub
        return Common.TIMER_RESOURCE_ID;
    }

    public TimerResource() {
        this.pool_size = 5;
        scheduledExecutorService = Executors.newScheduledThreadPool(pool_size);
    }

    public static void shutdownPool() {
        if (scheduledExecutorService != null)
            scheduledExecutorService.shutdown();
    }

    public final void start(Transition transition, Token token, Object args)
            throws InterruptedException {
        if (transition.getCondition() != null
                && !transition.getCondition().check(token))
            throw new ConditionException(transition.getName()
                    + " transition没有满足触发条件");
        transition.removeTokenFromInputs(token);
        doAction(transition, token, args);
    }

    protected class ChangeRunner implements Runnable {
        private Transition transition;

        private Token token;

        private Object[] args;

        public ChangeRunner(Transition transition, Token token, Object args) {
            this.transition = transition;
            this.token = token;
            this.args = args;
        }

        public void run() {
            if (transition.getCondition() != null
                    && !transition.getCondition().check(token))
                throw new ConditionException(transition.getName()
                        + " transition没有满足触发条件");
            transition.addTokenToOutputs(token);
            Object real_args[] = new Object[args.length - 2];
            for (int i = 0; i < real_args.length; i++)
                real_args[i] = args[i + 2];
            transition.invokeHandler(token, real_args);
            try {
                // 回调
                ((WorkFlowAlgorithm) args[1]).enabledTraversing(token
                        .getWorkFlow());
                ((WorkFlowManager) args[0]).doAction(token.getId());

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

注意到，start方法不再是直接调用transition的fire方法，而仅仅是进行了第一步操作：移除输入库所的place防止重复提交。后两步操作都延迟到了提交给线程池的任务中，也就是代码中的ChangeRunner类中的run方法。例如TimerResource的子类DelayTimerResource用于处理延迟的触发，doAction就像这样：

public class DelayTimerResource extends TimerResource {

    @Override
    public void doAction(Transition transition, Token token, Object args){
        scheduledExecutorService.schedule(new ChangeRunner(transition, token,
                args), this.delay, this.timeUnit);

    }
}

延迟的时间，时间单位这些信息都可以在流程定义文件中设置。事件监听器资源与此类似，ObserverResource实现了java.util.Observer接口，往输出库所放入token和回调handler两步操作被放在了update方法中提供给Subject回调。

dennis 2007-10-13 17:15 发表评论

写一个简单的工作流（二）

dennis — Thu, 11 Oct 2007 08:51:00 GMT

hoho，今天完成了选择路由的实现，完成了配置文件的读写和解析，流程定义文件还是决定采用xml文件，不过与其他工作流引擎采用的xml完全不同，因为是基于petri网的，因此引入了place的概念，比如下面这个4个节点的顺序路由的流程：

<workflow maxCases="100">
    <node type="start" name="start" id="0">
        <inputs>
            <place id="1" />
        inputs>
        <outputs>
            <place id="2" />
        outputs>
    node>
    <node name="hello" id="1" resource="user">
        <conditions type="and">
            <condition
                class="net.rubyeye.insect.workflow.impl.NullHandler" value="false"
                variable-name="name" />
        conditions>
        <handler
            class="net.rubyeye.insect.workflow.test.HelloWorldHandler" />
        <inputs>
            <place id="2" />
        inputs>
        <outputs>
            <place id="3" />
        outputs>
    node>
    <node name="calc" id="2" resource="user">
        <conditions type="and">
            <condition variable-name="num">
                <exp>
                    num<=1000]]>
                exp>
            condition>
            <conditions type="or">
                <condition variable-name="num">
                    <exp>
                        num>=10]]>
                    exp>
                condition>
                <condition
                    class="net.rubyeye.insect.workflow.impl.NullHandler" value="false"
                    variable-name="name" />
            conditions>
        conditions>
        <handler
            class="net.rubyeye.insect.workflow.test.CalculateHandler" />
        <inputs>
            <place id="3" />
        inputs>
        <outputs>
            <place id="4" />
        outputs>
    node>
    <node type="end" name="hello" id="3">
        <inputs>
            <place id="4" />
        inputs>
        <outputs>
            <place id="5" />
        outputs>
    node>
workflow>

并行路由和选择路由引入了and-split,and-join,or-split,or-join四种transition，比如and-split，它就有多个输出place：

<node name="split" type="and-split" id="1" resource="user">
        <inputs>
            <place id="2" />
        inputs>
        <outputs>
            <place id="3" />
            <place id="4" />
        outputs>
    node>

Place和Transition都有条件，用于决定操作是否执行，Transition额外指定了驱动的资源以及回调的handler，这一点非常重要，资源可能是用户、用户组、某个时间点定时事件、特定消息等等。
今天额外发现的一个好处就是，引入Place之后，我可以轻易地将不同的流程连接起来组织成一个更复杂的流程，仅仅是需要修改各个流程的开始和结束的节点的输入输出库所,从而实现了层次化的Petri网,，类似代码：

WorkFlow sequence = wm.getWorkFlow("sequence");
        WorkFlow concurrency = wm.getWorkFlow("concurrency");
        WorkFlow choose = wm.getWorkFlow("choose");

        //组合流程
        composite = new WorkFlow();
        composite.setName("composite");
        composite.setId(100);

        wm.saveWorkFlow(composite);

        //修改开始结束节点的输入输出库所
        sequence.getEnd().setType(TransitionType.NORMAL);
        sequence.getEnd().setOutputs(concurrency.getStart().getInputs());

        concurrency.getEnd().setType(TransitionType.NORMAL);
        concurrency.getEnd().setOutputs(choose.getStart().getInputs());

        composite.setStart(sequence.getStart());
        composite.setEnd(choose.getEnd());
        List<Transition> transitions = new ArrayList<Transition>();
        transitions.addAll(sequence.getTransitions());
        transitions.addAll(concurrency.getTransitions());
        transitions.addAll(choose.getTransitions());
        composite.setTransitions(transitions);

dennis 2007-10-11 16:51 发表评论

写一个简单的工作流，基于petri网

dennis — Wed, 10 Oct 2007 10:03:00 GMT

写一个简单的工作流一直停留在我的“计划”中，最近趁改造绩效系统的机会，决定自己写一个基于petri网原理的工作流来改写绩效考核流程部分。基于petri网的工作流的基本算法，就是当每一个firing发生后，应当遍历整个流程重新改变transition的enable，那么当资源驱动某个transition其实就是将它的输入place中的token转移到输出place。大概的接口类似：

WorkFlowManager wm = new BasicWorkflowManager(this.workFlowDAO);
Token token1 = wm.startWorkFlow(0); //为流程0新启动一个案例
wm.doAction(token1,resource,args); //传入资源和参数以驱动firing

今天完成了顺序路由和并行路由的实现，选择和循环也准备加入。暂时只实现了内存存储案例数据和流程数据，显然，应当实现一个数据库版本，慢慢来吧。

dennis 2007-10-10 18:03 发表评论

简单LRU算法实现缓存-update2

dennis — Sat, 29 Sep 2007 09:49:00 GMT

update1:第二个实现，读操作不必要采用独占锁，缓存显然是读多于写，读的时候一开始用独占锁是考虑到要递增计数和更新时间戳要加锁，不过这两个变量都是采用原子变量，因此也不必采用独占锁，修改为读写锁。
update2:一个错误，老是写错关键字啊，LRUCache的maxCapacity应该声明为volatile，而不是transient。

最简单的LRU算法实现，就是利用jdk的LinkedHashMap，覆写其中的removeEldestEntry(Map.Entry)方法即可，如下所示：

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.Map;

/**
* 类说明：利用LinkedHashMap实现简单的缓存，必须实现removeEldestEntry方法，具体参见JDK文档
*
* @author dennis
*
* @param
* @param
*/
public class LRULinkedHashMap<K, V> extends LinkedHashMap<K, V> {
    private final int maxCapacity;

    private static final float DEFAULT_LOAD_FACTOR = 0.75f;

    private final Lock lock = new ReentrantLock();

    public LRULinkedHashMap(int maxCapacity) {
        super(maxCapacity, DEFAULT_LOAD_FACTOR, true);
        this.maxCapacity = maxCapacity;
    }

    @Override
    protected boolean removeEldestEntry(java.util.Map.Entry<K, V> eldest) {
        return size() > maxCapacity;
    }
    @Override
    public boolean containsKey(Object key) {
        try {
            lock.lock();
            return super.containsKey(key);
        } finally {
            lock.unlock();
        }
    }


    @Override
    public V get(Object key) {
        try {
            lock.lock();
            return super.get(key);
        } finally {
            lock.unlock();
        }
    }

    @Override
    public V put(K key, V value) {
        try {
            lock.lock();
            return super.put(key, value);
        } finally {
            lock.unlock();
        }
    }

    public int size() {
        try {
            lock.lock();
            return super.size();
        } finally {
            lock.unlock();
        }
    }

    public void clear() {
        try {
            lock.lock();
            super.clear();
        } finally {
            lock.unlock();
        }
    }

    public Collection<Map.Entry<K, V>> getAll() {
        try {
            lock.lock();
            return new ArrayList<Map.Entry<K, V>>(super.entrySet());
        } finally {
            lock.unlock();
        }
    }
}

如果你去看LinkedHashMap的源码可知，LRU算法是通过双向链表来实现，当某个位置被命中，通过调整链表的指向将该位置调整到头位置，新加入的内容直接放在链表头，如此一来，最近被命中的内容就向链表头移动，需要替换时，链表最后的位置就是最近最少使用的位置。
LRU算法还可以通过计数来实现，缓存存储的位置附带一个计数器，当命中时将计数器加1，替换时就查找计数最小的位置并替换，结合访问时间戳来实现。这种算法比较适合缓存数据量较小的场景，显然，遍历查找计数最小位置的时间复杂度为O(n)。我实现了一个，结合了访问时间戳，当最小计数大于MINI_ACESS时(这个参数的调整对命中率有较大影响），就移除最久没有被访问的项：

package net.rubyeye.codelib.util.concurrency.cache;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
*
* @author dennis 类说明：当缓存数目不多时，才用缓存计数的传统LRU算法
* @param
* @param
*/
public class LRUCache<K, V> implements Serializable {

    private static final int DEFAULT_CAPACITY = 100;

    protected Map<K, ValueEntry> map;

    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    private final Lock readLock = lock.readLock();

    private final Lock writeLock = lock.writeLock();

    private final volatile int maxCapacity; //保持可见性

    public static int MINI_ACCESS = 5;

    public LRUCache() {
        this(DEFAULT_CAPACITY);
    }

    public LRUCache(int capacity) {
        if (capacity <= 0)
            throw new RuntimeException("缓存容量不得小于0");
        this.maxCapacity = capacity;
        this.map = new HashMap<K, ValueEntry>(maxCapacity);
    }

    public boolean ContainsKey(K key) {
        try {
            readLock.lock();
            return this.map.containsKey(key);
        } finally {
            readLock.unlock();
        }
    }

    public V put(K key, V value) {
        try {
            writeLock.lock();
            if ((map.size() > maxCapacity - 1) && !map.containsKey(key)) {
                // System.out.println("开始");
                Set<Map.Entry<K, ValueEntry>> entries = this.map.entrySet();
                removeRencentlyLeastAccess(entries);
            }
            ValueEntry new_value = new ValueEntry(value);
            ValueEntry old_value = map.put(key, new_value);
            if (old_value != null) {
                new_value.count = old_value.count;
                return old_value.value;
            } else
                return null;
        } finally {
            writeLock.unlock();
        }
    }

    /**
     * 移除最近最少访问
     */
    protected void removeRencentlyLeastAccess(
            Set<Map.Entry<K, ValueEntry>> entries) {
        // 最小使用次数
        long least = 0;
        // 访问时间最早
        long earliest = 0;
        K toBeRemovedByCount = null;
        K toBeRemovedByTime = null;
        Iterator<Map.Entry<K, ValueEntry>> it = entries.iterator();
        if (it.hasNext()) {
            Map.Entry<K, ValueEntry> valueEntry = it.next();
            least = valueEntry.getValue().count.get();
            toBeRemovedByCount = valueEntry.getKey();
            earliest = valueEntry.getValue().lastAccess.get();
            toBeRemovedByTime = valueEntry.getKey();
        }
        while (it.hasNext()) {
            Map.Entry<K, ValueEntry> valueEntry = it.next();
            if (valueEntry.getValue().count.get() < least) {
                least = valueEntry.getValue().count.get();
                toBeRemovedByCount = valueEntry.getKey();
            }
            if (valueEntry.getValue().lastAccess.get() < earliest) {
                earliest = valueEntry.getValue().count.get();
                toBeRemovedByTime = valueEntry.getKey();
            }
        }
        // System.out.println("remove:" + toBeRemoved);
        // 如果最少使用次数大于MINI_ACCESS，那么移除访问时间最早的项(也就是最久没有被访问的项）
        if (least > MINI_ACCESS) {
            map.remove(toBeRemovedByTime);
        } else {
            map.remove(toBeRemovedByCount);
        }
    }

    public V get(K key) {
        try {
            readLock.lock();
            V value = null;
            ValueEntry valueEntry = map.get(key);
            if (valueEntry != null) {
                // 更新访问时间戳
                valueEntry.updateLastAccess();
                // 更新访问次数
                valueEntry.count.incrementAndGet();
                value = valueEntry.value;
            }
            return value;
        } finally {
            readLock.unlock();
        }
    }

    public void clear() {
        try {
            writeLock.lock();
            map.clear();
        } finally {
            writeLock.unlock();
        }
    }

    public int size() {
        try {
            readLock.lock();
            return map.size();
        } finally {
            readLock.unlock();
        }
    }

    public long getCount(K key) {
        try {
            readLock.lock();
            ValueEntry valueEntry = map.get(key);
            if (valueEntry != null) {
                return valueEntry.count.get();
            }
            return 0;
        } finally {
            readLock.unlock();
        }
    }

    public Collection<Map.Entry<K, V>> getAll() {
        try {
            readLock.lock();
            Set<K> keys = map.keySet();
            Map<K, V> tmp = new HashMap<K, V>();
            for (K key : keys) {
                tmp.put(key, map.get(key).value);
            }
            return new ArrayList<Map.Entry<K, V>>(tmp.entrySet());
        } finally {
            readLock.unlock();
        }
    }

    class ValueEntry implements Serializable {
        private V value;

        private AtomicLong count;

        private AtomicLong lastAccess;

        public ValueEntry(V value) {
            this.value = value;
            this.count = new AtomicLong(0);
            lastAccess = new AtomicLong(System.nanoTime());
        }

        public void updateLastAccess() {
            this.lastAccess.set(System.nanoTime());
        }

    }
}

dennis 2007-09-29 17:49 发表评论

ReentrantLock和内部锁的性能对比（update)

dennis — Fri, 14 Sep 2007 09:15:00 GMT

ReentrantLock是jdk5引入的新的锁机制，它与内部锁（synchronize）相同的并发性和内存语义，比如可重入加锁语义。在中等或者更高负荷下，ReentrantLock有更好的性能，并且拥有可轮询和可定时的请求锁等高级功能。这个程序简单对比了ReentrantLock公平锁、ReentrantLock非公平锁以及内部锁的性能，从结果上看，非公平的ReentrantLock表现最好。内部锁也仅仅是实现统计意义上的公平，结果也比公平的ReentrantLock好上很多。这个程序仅仅是计数，启动N个线程，对同一个Counter进行递增，显然，这个递增操作需要同步以保证原子性，采用不同的锁来实现同步，然后查看结果。
Counter接口：

package net.rubyeye.concurrency.chapter13;

public interface Counter {
public long getValue();

public void increment();

}

然后，首先使用我们熟悉的synchronize来实现同步：

package net.rubyeye.concurrency.chapter13;

public class SynchronizeBenchmark implements Counter {
    private long count = 0;

    public long getValue() {
        return count;
    }

    public synchronized void increment() {
        count++;
    }
}

采用ReentrantLock的版本，切记要在finally中释放锁，这是与synchronize使用方式最大的不同，内部锁jvm会自动帮你释放锁，而ReentrantLock需要你自己来处理。

package net.rubyeye.concurrency.chapter13;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockBeanchmark implements Counter {

    private volatile long count = 0;

    private Lock lock;

    public ReentrantLockBeanchmark() {
        // 使用非公平锁，true就是公平锁
        lock = new ReentrantLock(false);
    }

    public long getValue() {
        // TODO Auto-generated method stub
        return count;
    }

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }

}

写一个测试程序，使用CyclicBarrier来等待所有任务线程创建完毕以及所有任务线程计算完成，清单如下：

package net.rubyeye.concurrency.chapter13;

import java.util.concurrent.CyclicBarrier;

public class BenchmarkTest {
    private Counter counter;

    private CyclicBarrier barrier;

    private int threadNum;

    public BenchmarkTest(Counter counter, int threadNum) {
        this.counter = counter;
        barrier = new CyclicBarrier(threadNum + 1); //关卡计数=线程数+1
        this.threadNum = threadNum;
    }

    public static void main(String args[]) {
        new BenchmarkTest(new SynchronizeBenchmark(), 5000).test();
//new BenchmarkTest(new ReentrantLockBeanchmark(), 5000).test();
        //new BenchmarkTest(new ReentrantLockBeanchmark(), 5000).test();
    }

    public void test() {
        try {
            for (int i = 0; i < threadNum; i++) {
                new TestThread(counter).start();
            }
    long start = System.currentTimeMillis();
            barrier.await(); // 等待所有任务线程创建
            barrier.await(); // 等待所有任务计算完成
            long end = System.currentTimeMillis();
            System.out.println("count value:" + counter.getValue());
            System.out.println("花费时间:" + (end - start) + "毫秒");
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    class TestThread extends Thread {
        private Counter counter;

        public TestThread(final Counter counter) {
            this.counter = counter;
        }

        public void run() {
            try {
                barrier.await();
                for (int i = 0; i < 100; i++)
                    counter.increment();
                barrier.await();
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    }
}

分别测试一下，

将启动的线程数限定为500，结果为：
公平ReentrantLock:      210 毫秒
非公平ReentrantLock :   39 毫秒
内部锁:                          39 毫秒

将启动的线程数限定为1000，结果为：
公平ReentrantLock:      640 毫秒
非公平ReentrantLock :   81 毫秒
内部锁:                           60 毫秒

线程数不变，test方法中的循环增加到1000次，结果为：
公平ReentrantLock:      16715 毫秒
非公平ReentrantLock :   168 毫秒
内部锁:                           639 毫秒

将启动的线程数增加到2000,结果为：
公平ReentrantLock:      1100 毫秒
非公平ReentrantLock:   125 毫秒
内部锁:                           130 毫秒

将启动的线程数增加到3000,结果为：
公平ReentrantLock:      2461 毫秒
非公平ReentrantLock:   254 毫秒
内部锁:                           307 毫秒

启动5000个线程，结果如下：
公平ReentrantLock:      6154 毫秒
非公平ReentrantLock:   623 毫秒
内部锁:                           720 毫秒

非公平ReentrantLock和内部锁的差距，在jdk6上应该缩小了，据说jdk6的内部锁机制进行了调整。

dennis 2007-09-14 17:15 发表评论

利用Doug Lea的并发包实现带超时机制的线程池

dennis — Sun, 09 Sep 2007 06:23:00 GMT

jdk5引入的concurrent包来自于Doug Lea的卓越贡献。最近我在查找服务器OOM的原因之后，决定采用这个包重写应用中一个servlet，这个servlet调用了一个阻塞方法，当被阻塞之后，服务器中的线程数（因为阻塞了，后续请求不断地新增线程）突然增加导致了服务器当机，因此决定采用一个线程池，并且设置超时，如果阻塞方法超过一定时间就取消线程。因为我们的项目仍然跑在jdk 1.4.2上面，短期内不可能升级到jdk5，还是要利用这个并发包。去这里下载源码并自己打包成jar，加入项目的lib，然后利用PooledExecutor和TimedCallable来实现我们的需求。首先是线程池，相当简单：

import EDU.oswego.cs.dl.util.concurrent.BoundedBuffer;
import EDU.oswego.cs.dl.util.concurrent.PooledExecutor;
/**
*

类说明：线程池

注意事项：

创建日期：Sep 7, 2007 1:25:33 PM

* @author:dennis zane
* @version $Id:$
*/
public class MyThreadPool{
    private static PooledExecutor exec = new PooledExecutor(new BoundedBuffer(
            20), 30);
    static {
        exec.setKeepAliveTime(1000 * 60 * 5);
        exec.createThreads(5);
        exec.setMinimumPoolSize(4);
    }

    public static void execute(final Runnable r) throws InterruptedException{
        exec.execute(r);
    }

    public static void shutdown() {
        exec.shutdownAfterProcessingCurrentlyQueuedTasks();
        exec = null;
    }

}

静态初始化并设置一个PoolExecutor，设置空闲线程的存活时间为5分钟，设置最小线程数为4，最大线程数为30,一开始创建5个线程以待使用（根据各自的应用调整这些参数），另外提供了shutdown方法以供ServeltContextListener的contextDestroyed方法调用以关闭线程池。那么，结合TimedCallable来实现提交线程的超时机制,调用类似：

           //设置超时时间
   private static final long timeout = 1000;
           ......
           ......
       try{
           Callable callable = new Callable() {
                public Object call() {
                    return new YourProgram().run();
                }
            };
            TimedCallable timedCallable = new TimedCallable(callable, timeout);
            FutureResult future = new FutureResult();
            Runnable cmd = future.setter(timedCallable);
            //提交给线程池来执行
            MyThreadPool.execute(cmd);
            //获取任务结果
            YourObject obj= (YourObject) future.get();
            ......
            ......
         } catch (InterruptedException e) {
           if (e instanceof TimeoutException) {
                 log.error("任务超时");
                  ...
             }
         }catch(InvocationTargetException e)
         {
            //清理任务..
         }
         ......

如果不是很理解这段代码，那么也许你应该先看看jdk5引入的Future、FutureTask等类，或者看看这里的文档。对于超时时间的大小估算，你应当在生产环境中计算该阻塞方法的调用时间，正常运行一段时间，利用脚本语言（比如ruby、python）分析日志以得到一个调用花费时间的最大值作为timeout，这里的单位是毫秒。而线程池大小的估算，要看你提交给线程执行的任务的类型：如果是计算密集型的任务，那么线程池的大小一般是（cpu个数+1）；如果是IO密集型的任务（一般的web应用皆是此类），那么估算有一个公式,
假设N-cpu是cpu个数，U是目标CPU使用率，W/C是任务的等待时间与计算时间的比率，那么最优的池大小等于：
N-threads=N-cpu*U*(1+W/C)

dennis 2007-09-09 14:23 发表评论

PIPE2——Petri网编辑工具

dennis — Wed, 05 Sep 2007 08:51:00 GMT

最近重新拿起《工作流管理-模型、方法和系统》，需要一个Petri网画图、分析的工具，google一把，在sourceforge上找到PIPE2项目。按它的描述是：Platform Independent Petri Net Editor 2。看了下源码是用swing写的。已经基本满足我的要求了。
项目地址：http://pipe2.sourceforge.net/

下图是对书中习题七的过程定义

dennis 2007-09-05 16:51 发表评论

线程任务的取消

dennis — Mon, 03 Sep 2007 07:50:00 GMT

当外部代码能够在活动自然完成之前，把它的状态更改为完成状态，那么这个活动被称为可取消（cancellable）。取消任务是一个很常见的需求，无论是由于用户请求还是系统错误引起的服务关闭等等原因。最简单的任务取消策略就是在线程中维持一个bool变量，在run方法中判断此变量的bool值来决定是否取消任务。显然，这个bool变量需要声明为volatile，以保持多线程环境下可见性（所谓可见性，就是当一个线程修改共享对象的某个状态变量后，另一个线程可以马上看到修改结果）。下面是一个来自《java并发编程实践》的例子：

package net.rubyeye.concurrency.chapter7;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

public class PrimeGenerator implements Runnable {
    private final List<BigInteger> primes = new ArrayList<BigInteger>();

    private volatile boolean cancelled;
    public void run() {
        BigInteger p = BigInteger.ONE;
        while (!cancelled) {
            p = p.nextProbablePrime();
            synchronized (this) {
                primes.add(p);
            }
        }
    }
    public void cancel() {
        cancelled = true;
    }
    public synchronized List<BigInteger> get() {
        return new ArrayList<BigInteger>(primes);
    }

    public static void main(String args[]) throws InterruptedException {
        PrimeGenerator generator = new PrimeGenerator();
        new Thread(generator).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } finally {
            generator.cancel();
        }
    }
}

main中启动一个素数生成的任务，线程运行一秒就取消掉。通过线程中的cancelled变量来表征任务是否继续执行。既然是最简单的策略，那么什么是例外情况？显然，阻塞操作下（比如调用join,wait,sleep方法)，这样的策略会出问题。任务因为调用这些阻塞方法而被阻塞，它将不会去检查volatile变量，导致取消操作失效。那么解决办法是什么？中断！考虑我们用BlockingQueue去保存生成的素数，BlockingQueue的put方法是阻塞的（当BlockingQueue满的时候，put操作会阻塞直到有元素被take），让我们看看不采用中断，仍然采用简单策略会出现什么情况：

package net.rubyeye.concurrency.chapter7;

import java.math.BigInteger;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class BrokenPrimeProducer extends Thread {
    static int i = 1000;

    private final BlockingQueue<BigInteger> queue;

    private volatile boolean cancelled = false;

    BrokenPrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    public void run() {
        BigInteger p = BigInteger.ONE;
        try {
            while (!cancelled) {
                p = p.nextProbablePrime();
                queue.put(p);
            }
        } catch (InterruptedException cusumed) {
        }
    }

    public void cancel() {
        this.cancelled = false;
    }

    public static void main(String args[]) throws InterruptedException {
        BlockingQueue<BigInteger> queue = new LinkedBlockingQueue<BigInteger>(
                10);
        BrokenPrimeProducer producer = new BrokenPrimeProducer(queue);
        producer.start();
        try {
            while (needMorePrimes())
                queue.take();
        } finally {
            producer.cancel();
        }
    }

    public static boolean needMorePrimes() throws InterruptedException {
        boolean result = true;
        i--;
        if (i == 0)
            result = false;
        return result;
    }
}

我们在main中通过queue.take来消费产生的素数（虽然仅仅是取出扔掉），我们只消费了1000个素数，然后尝试取消产生素数的任务，很遗憾，取消不了，因为产生素数的线程产生素数的速度大于我们消费的速度，我们在消费1000后就停止消费了，那么任务将被queue的put方法阻塞，永远也不会去判断cancelled状态变量，任务取消不了。正确的做法应当是使用中断(interrupt）：

package net.rubyeye.concurrency.chapter7;

import java.math.BigInteger;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class PrimeProducer extends Thread {
    static int i = 1000;

    private final BlockingQueue<BigInteger> queue;

    private volatile boolean cancelled = false;

    PrimeProducer(BlockingQueue<BigInteger> queue) {
        this.queue = queue;
    }

    public void run() {
        BigInteger p = BigInteger.ONE;
        try {
            while (!Thread.currentThread().isInterrupted()) {
                p = p.nextProbablePrime();
                queue.put(p);
            }
        } catch (InterruptedException cusumed) {
        }
    }

    public void cancel() {
        interrupt();
    }

    public static void main(String args[]) throws InterruptedException {
        BlockingQueue<BigInteger> queue = new LinkedBlockingQueue<BigInteger>(
                10);
        PrimeProducer producer = new PrimeProducer(queue);
        producer.start();
        try {
            while (needMorePrimes())
                queue.take();
        } finally {
            producer.cancel();
        }
    }

    public static boolean needMorePrimes() throws InterruptedException {
        boolean result = true;
        i--;
        if (i == 0)
            result = false;
        return result;
    }
}

   在run方法中，通过Thread的isInterrupted来判断interrupt status是否已经被修改，从而正确实现了任务的取消。关于interrupt，有一点需要特别说明，调用interrupt并不意味着必然停止目标线程的正在进行的工作，它仅仅是传递一个请求中断的信号给目标线程，目标线程会在下一个方便的时刻中断。而对于阻塞方法产生的InterruptedException的处理，两种选择：要么重新抛出让上层代码来处理，要么在catch块中调用Thread的interrupt来保存中断状态。除非你确定要让工作线程终止（如上所示代码），否则不要仅仅是catch而不做任务处理工作（生吞了InterruptedException)，更详细可以参考这里。如果不清楚外部线程的中断策略，生搬硬套地调用interrupt可能产生不可预料的后果，可参见书中7.1.4例子。

   另外一个取消任务的方法就是采用Future来管理任务,这是JDK5引入的，用于管理任务的生命周期，处理异常等。比如调用ExecutorService的sumit方法会返回一个Future来描述任务，而Future有一个cancel方法用于取消任务。
   那么，如果任务调用了不可中断的阻塞方法，比如Socket的read、write方法，java.nio中的同步I/O，那么该怎么处理呢？简单地，关闭它们！参考下面的例子：

package net.rubyeye.concurrency.chapter7;

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

/**
* 展示对于不可中断阻塞的取消任务通过关闭socket引发异常来中断
*
* @author Admin
*
*/
public abstract class ReaderThread extends Thread {
    private final Socket socket;

    private final InputStream in;

    public ReaderThread(Socket socket) throws IOException {
        this.socket = socket;
        this.in = socket.getInputStream();
    }

    // 重写interrupt方法
    public void interrupt() {
        try {
            socket.close();
        } catch (IOException e) {
        } finally {
            super.interrupt();
        }
    }

    public void run() {
        try {
            byte[] buf = new byte[1024];
            while (true) {
                int count = in.read(buf);
                if (count < 0)
                    break;
                else if (count > 0)
                    processBuff(buf, count);
            }
        } catch (IOException e) {
        }
    }

    public abstract void processBuff(byte[] buf, int count);
}

Reader线程重写了interrupt方法，其中调用了socket的close方法用于中断read方法，最后，又调用了super.interrupt()，防止当调用可中断的阻塞方法时不能正常中断。

dennis 2007-09-03 15:50 发表评论

简单的web server性能测试

dennis — Wed, 29 Aug 2007 10:10:00 GMT

摘要: 简单的web server性能测试，一般多线程方式与采用jdk5线程池的比较。阅读全文

dennis 2007-08-29 18:10 发表评论

java求字符串型逻辑表达式的bool值

dennis — Mon, 06 Aug 2007 04:37:00 GMT

摘要: 这是最近在项目中的一个需求，已知a=3，求字符串"a<=2"的值，也就是应该返回false。这个问题可大可小，就我们的应用场景也就是用来让用户自定义变量区间，比如类似下面这样的规则：a<=2 返回积分系数1.025 ... 阅读全文

dennis 2007-08-06 12:37 发表评论

portal学习（二）portlet开发之hello world

dennis — Sun, 15 Jul 2007 13:02:00 GMT

portal开发的一个重要工作就是portlet的开发，网上一大堆hello world，都是最简单的，用PrintWriter输出字符串。今天介绍一下稍微复杂的，用户转到portlet的edit Model，该页面是有一个输入框和一个按钮，输入你的名字，然后提交，将转到此portlet的view Model并输出hello,your name。
portlet与servlet非常相似，因为portlet就是在servlet规范的基础上扩展的，并且portlet容器也是在servlet容器的基础上扩展，同serlvet一样，我们的HelloWorldPorlet需要强制继承自GenericPortlet类，GenericPortlet实现了Portlet接口,看看完整代码：

package net.rubyeye.portlets;
import javax.portlet.ActionResponse;
import javax.portlet.GenericPortlet;
import javax.portlet.PortletException;
import javax.portlet.PortletRequestDispatcher;
import javax.portlet.RenderRequest;
import javax.portlet.RenderResponse;

public class HelloWorldPortlet extends GenericPortlet {

        @Override
        protected void doEdit(RenderRequest req, RenderResponse res)
                        throws PortletException, IOException {
                res.setContentType("text/html");
                //获取初始参数，在init-param中定义
                String jspName = getPortletConfig().getInitParameter("edit-jsp");
                PortletRequestDispatcher rd = getPortletContext().getRequestDispatcher(
                                jspName);
                rd.include(req, res);
        }

        @Override
        protected void doView(RenderRequest req, RenderResponse res)
                        throws PortletException, IOException {
                res.setContentType("text/html");
                //执行完processAction后设置了renderParamter，这里得到
                String msg = req.getParameter("msg");

                PrintWriter out = res.getWriter();
                System.out.println(msg);
                //有就输出
                if (msg != null)
                        out.write(msg);
                //默认输出是Hello World
                else
                        out.write("Hello World!View!");

        }
        //actionURL调用的processAction
        @Override
        public void processAction(ActionRequest req, ActionResponse res)
                        throws PortletException, IOException {
                // TODO Auto-generated method stub
                String name = req.getParameter("name");
                System.out.println(name);
                res.setRenderParameter("msg", "hello," + name);
        }
}

    解释下代码,portlet默认有三种Model：view、edit和help，顾名思义分别对照浏览、编辑和帮助状态，其中只有view是必须的，当然还可以自定义model。在portlet就有相应的doXXX方法用于呈现相应的片段，portlet还有一个render(RenderRequest，RenderResponse),这个方法与doView等方法的关系类似serlvet中service与doGet、doHelp的关系，一般我们都不直接覆写render，而是实现具体的doXXX方法。回到这个例子,HelloWorldPortlet有两个Model：view和edit。
    在doView方法中很简单，首先需要设置ContentType，然后获取前面processAction设置的renderParamter，当然，一开始进入portlet是view，这个值根本没有，默认就用PrintWriter输出Hello World。
    processAction用于处理ActionRequest的方法，和一般的servlet编程没有什么不同，请注意，processAction执行之后才是执行相应的render方法，并且与render不共享parameter，因此为了在doView中获得msg参数，我们需要通过ActionResponse的setRenderParameter来设定RenderRequest的Parameter。
    doEdit方法就比较简单了，通过PortletConfig的getInitParameter(与ServletConfig一样了）获得属性edit-jsp的值——编辑页面的位置，然后将该页面include进portlet。
    portlet需要一个配置文件来告诉portlets容器具体信息，这个文件同样放在WEB-INF目录下，并且名为portlet.xml：

xml version="1.0" encoding="UTF-8"?>
<portlet-app version="1.0"
        xmlns="http://java.sun.com/xml/ns/portlet/portlet-app_1_0.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

        <portlet>
                <portlet-name>HelloWorldPorlet_1portlet-name>
                <portlet-class>
                        net.rubyeye.porlets.HelloWorldPorlet
                portlet-class>
                <init-param>
                        <name>edit-jspname>
                        <value>/portlets/edit.jspvalue>
                init-param>
                <supports>
                        <mime-type>text/htmlmime-type>
                        <portlet-mode>viewportlet-mode>
                        <portlet-mode>editportlet-mode>
                supports>
                <portlet-info>
                        <title>HelloWorldtitle>
                portlet-info>
        portlet>
portlet-app>

信息非常清楚，就不多做解释了，edit-jsp的值是/portlets/edit.jsp，portlets容器就会去portlets目录下寻找edit.jsp。supports元素指定了portlet支持的Model以及Mime类型。更详细的配置请参考官方规范
最后就是edit.jsp，需要用到portlets规范规定的标签，我们这里用到了actionURL，该标签用于form的action的生成，触发带有参数的request请求的processAction调用，当然还有一个renderURL，顾名思义仅是用于呈现，而非action的触发。请注意，form的method必须是post，因为portlets容器可能将一些状态信息写在url，使用post提交避免冲突。

<%@taglib uri="http://java.sun.com/portlet" prefix="portlet" %>
<portlet:defineObjects/>
<div>
<form method="post" action="view" windowState="normal"/>" >
please input your name:
<input type="text" name="name" size="10"/>
<input type="submit" value="submit"/>
form>

在使用portlet规范规定的标签前，一定要先使用标签，以便定义下列变量让jsp使用：
renderRequest
renderResponse
portletConfig

我们通过actionURL标签产生指向本portlet的url，并且指定没有错误发生时这个portlet应该具有的Model是view，窗口大小为normal。最后部署并运行，因为不同的portal的部署方式和所需要的其他配置文件各不相同，这里就不详细介绍了。下面是在Bea Portal 10.0上的效果图：

1.一开始看到的是view Model，输出Hello World!View!:

2.点击左上角的edit链接进入edit model:

3.输入dennis,提交，转到view model:

dennis 2007-07-15 21:02 发表评论

portal学习（一）抄书

dennis — Sun, 15 Jul 2007 12:16:00 GMT

这两天将网上下载的《JSR168 porlet标准手册汉化整理》和《Liferay Portal二次开发指南》认认真真地看了几遍，看了BEA站点上portal的getting start，写了hello world，算是正式开始学习portal了。感谢这么多人无私地分享知识。抄书。

第一节 Portal 规范
随着Portal 的兴起，越来越多的公司开始涉足Portal 产品开发，并组建各自的Portal 组
件和基于其的产品，比如IBM、BEA、MicroSoft、SAP、Apache 等。各个厂商的接口互不
兼容，给软件开发商以及开发人员带来诸多不便。
1.1.1 JSR168
为此，JCP 组织发布了JSR168(Java Specification Request)，Portlet Specification V1.0，
用来提供不同的Portal 和Portlet 之间的互通性。只要开发的Portlet 遵循JSR168，则就可以
在所有遵循JSR168 的Portal 上部署运行。
JSR168 中定义了Portal 的实现规范和接口，并对理想的Portlet 进行了详细的规划和描
述。
1.1.2 WSRP
WSRP 是OASIS Web Service for Remote Portlet 的缩写。WSRP 是Web Service 的一种新
的商业应用，一种新的标准，主要用来简化Portal 对于各种资源或者程序整合的复杂度，可
以避免编程带来的整合麻烦和问题。而且Portal 管理员可以从海量的WSRP 服务中选择需
要的功能用以整合到目前所用的Portal 中。它有三种角色：
①、生产者 􀃆 提供Portlet
②、消费者 􀃆 使用Portlet
③、终端用户 􀃆 最终用户
它的特点在于生产者将消费者所需要的信息通过WSRP 返回给消费者，这些信息是相对
标记片断，例如HTML、XHTML 等，可以直接嵌入用户的页面中，而不用像Web Service
一样开发用户端接口。
实现这个规范，Portal 可以跟各式各样的数据源打交道，彻底终结信息孤岛的窘境。
第二节什么是Portal
Portal 是基于Web 的，以“应用整合”和“消除信息孤岛”为最终目的，提供单点登
录、内容聚合、个性化门户定制等功能的综合信息系统。
完整的Portal 通常由Portal 服务器、Portlet 容器、Portlet 构成。
1.2.1 Portal 服务器
Portal 服务器是容纳Portlet 容器，支持Portlet 呈现的普通或者特殊Web 服务器。
Portal 服务器通常会提供个性化设置、单点登录、内容聚合、信息发布、权限管理等功能，
支持各种信息数据来源，并将这些数据信息放在网页中组合而成，提供个性化的内容定制，
不同权限的浏览者能够浏览不同的信息内容。通常，Portal 提供以下功能:
单点登录：Portal 通常采用ACL、SSL、LDAP 等业界标准的安全技术，提供对所有现有
应用系统的安全集成，只需在Portal 的唯一入口上登录一次，就可以访问所有应用系统和
数据。对于安全性要求较高的应用系统，如电子商务平台、交易系统等，通过扩展接口传递
用户身份信息，如数字证书信息、数字签名信息等，进行二次身份认证，保证单点登陆的安
全性。
权限控制:系统采用LDAP 对用户资源进行统一的管理，同时提供二次开发接口，可以
与其他应用系统的用户管理模块对接，并能随相关业务系统实时更新访问权限。通过完善的
授权机制及存取控制，用户访问权限控制到字段级别，确保用户只能访问具有权限的应用系
统及相关信息。
内容管理: 实现应用系统之间实时交换信息。采用多种缓存机制，保证内容交换的性能
和准确性。采用基于XML 的Rich Site Summary (RSS)标准，迅速在各应用系统之间传播最
新变化。
信息发布: 实现信息门户内容的动态维护。动态网站系统可与OA 协同办公系统、知识
管理系统等集成，网站信息须经OA 系统的审批流程流转通过后或知识管理平台设置具有外
部共享权限后才可正式发布，真正实现内外信息发布的同步。
文件管理: 系统实现无缝集成多种数据源，包括：数据库、文档（Office 文档、PDF、
AutoCAD、甚至ZIP 文档）、Web 网页、FTP 站点等，并对数据按业务要求和职务特点加以分
析整理，通过统一Web 界面主动推送(Push)至用户的门户桌面，帮助用户做出及时、正确的
决策。
1.2.2 Portlet 容器
Portlet 容器提供Portlet 执行的环境，包含很多Portlet 并管理它们的生命周期，保
存Portlet 的定制信息。
一个Portal 容器接收到来自Portal 的请求后，接着将这个请求传递给存在Portal 容
器的Portlet 执行。Portlet 容器没有义务去组合Portlet 产生的信息內容，这个工作必
须由Portal 来处理。Portal 和 Portal 容器可以放在一起视为同一个系统的组件，或者分
开成为两个独立的组件。
Portlet 容器是普通Web Servlet 容器的扩展，所以一个Portlet 容器可以构建于一个
已经存在的Servlet 容器或者可能实现全部Web Servlet 容器的全部功能。无论Portlet
容器怎么实现，它的运行环境总是假定它支持Servlet2.3 规范。

通常，Portlet 容器扩展自普通的Servlet 容器。
第三节什么是Portlet
Portlet 是Portal 中最重要的组件，负责在Portal 中呈现信息内容，有相应的生命周
期。通过自定义Portlet，用户很容易定义个性化的Portal 页面。Portlet 由Portlet 容器
负责管理、处理请求并返回动态页面，可以作为Portal 的可即插即用的界面组件。
1.3.1 Portlet
一个Portlet是以Java技术为技术的Web组件，由Portlet容器所管理，专门处理客户的
信息请求以及产生各种动态的信息内容。Portlet 为可插式的客户界面组件，提供呈现层成
为一个信息系统。
这些由Portlet产生的内容也被称为片段，而片段是具有一些规则的标记( HTML、XHTML、
WML )，而且可以和其他的片段组合而成一个复杂的文件。一个或多个 Portlet 的内容聚合
而成为一个 Portal 网页。而 Portlet 的生命周期是被 Portlet 容器所管理控制的。
客户端和Portlet的互动是由Portal通过典型的请求/响应方式实现，正常来说，客户会
和Portlet所产生的内容互动，举例来说，根据下一步的连接或者是确认送出的表单，结果
Portal将会接收到Portlet的动作，将这个处理状况转向到目标Portlet。这些Portlet 内容
的产生可能会因为不同的使用者而有不同的变化，完全是根据客户对于这个Portlet的设置。
1.3.2 Portlet 与Servlet 的关系
Portlet 被定义成为一个新的组件，具有新的明确的界面与行为。为了尽可能与现有的
Servlet 结合达到重复使用的目的，Portlet 的规范利用了 Servlet 的规范，许多观念都
很相似的，结合 Portlet、Servlet 及 Jsp 在同一个网站系统中，我们称为Portlet 应用。
在同一个 Portlet 应用中，他们将分享同一个类加载器(ClassLoader)，上下文(Context)
及 Session。
①、Portlet 和 Servlet 的相似之处
@ Portlet 也是 Java 技术的 web 组件
@ Portlet 也是有特定的 container 在管理
@ Portlet 可以动态产生各种内容
@ Portlet 的生命周期由 container 所管理
@ Portlet 和客户端的互动是通过 request/response 的机制
②、Portlet 和 Servlet 也有一些不同
8
@ Portlet 只产生 markup 信息片段，不是完整的网页文件。而 Portal 会将所有的
Portlet markup 信息片段放到一个完整的 Portal 网页。
@ Portlet 不会和 URL 有直接的关系
@ 客户端必须通过 portal 系统才能和 Portlet 互动
@ Portlet 有一些定义好的 request 处理，action request 以及 render request。
@ Portlet 默认定义 Portlet modes 及窗口状态可以指出在网页中该 Portlet 的哪个功
能正在执行及现在的状态。
@ Portlet 可以在同一个 portal 网页之中存在多个。
③、Portlet 有一些附加的功能是 Servlet 所没有的
@ Portlet 能够存取及储存永久配置文件及定制资料。
@ Portlet 可以存取使用者数据
@ Portlet 具有 URL 的重写功能在文件中去动态建立连结，允许 portal server 不用去
知道如何在网页的片段之中建立连结及动作。
@ Portlet 可以储存临时性的数据在 Portlet session 之中，拥有两个不同的范围：
application-wide scope 及 Portlet private scope 。
④、Portlet 不具有一些功能，但是 Servlet 却有提供
@ Servlet 具有设置输出的文字编码( character set encoding)方式
@ Servlet 可以设置 HTTP 输出的 header
@ Servlet 才能够接收客户对于 portal 发出的 URL 请求
1.3.3 Portlet 的生命周期
一个Portlet有着良好的生命周期管理，定义了怎样装载，实例化和初始化，怎样响应来
自客户端的请求及怎样送出服务。这个Portlet生命周期由Portlet接口的init，processAction，
render和destroy方法来表达。
载入和实例化:Portlet 容器负责载入和实例化Portlet。当Portlet 容器运行Portlet 应用或
者延迟到Portlet 需要服务使用者的请求时，Portlet 就会被载入并实例化。载入Portlet 类后，
Portlet 类随即被实例化。
初始化:Portlet 类实例化后，Portlet 容器还需要初始化Portlet。以调用Portlet 去响应客
户端的请求。Portlet 容器呼叫Portlet 接口中的init 方法初始化Portlet。扩展自PortletConfig
的类可以取出定义在部署描述文件中的初始化参数，以及Resource Bundle。
初始化异常:在 Portlet 初始化期间，Portlet 可能会丟出 UnavailableException 或
PortletException 异常。此时，Portlet 容器不能把 Portlet 置入已启动的服务，并且 Portlet
容器必需释放这个 Portlet。 destory 方法不能被呼叫，因为初始化被认为执行失败。发生失
败后，Portlet 容器会尝试着重新实例化及初始化 Portlet。这个异常处理的规则是：由一个
UnavailableException 指定一个不能执行的最小时间，当此异常发生时，Portlet 容器必需等
到指定时间过去后才产生并且初始化一个新的 Portlet。
在初始化过程中所丟出的 Runtime Exception 异常，被当作 PortletException 来处理。

dennis 2007-07-15 20:16 发表评论

如何设置一个基本的OpenLDAP Server(转载）

dennis — Sat, 14 Jul 2007 08:08:00 GMT

如何设置一个基本的OpenLDAP Server
本文出自:http://www.linuxforum.net 作者:吴阿亭 Jephe wu (2001-09-04 15:00:01)

一. 目的

      本文旨在介绍如何安装OpenLDAP并且设置一个公司内部的集中化的邮件地址薄服务器供客
      户端查询。
      基本上，OpenLDAPg还应用在其它许多方面，象集中化的用户帐号验证服务器,但邮件地址
      薄查询是最常用的。

二. 安装

从www.openldap.org下载最新的openldap软件包，按照编译和安装的步骤，依次运行：

      #tar cvfz openldap-stable-20010524.tgz
      #cd openldap-2.0.11
      #./configure
      #make depend
      #make
      #make test
      #make install

      我的操作环境是redhat 6.1，如果没有遇到任何错误，最后默认安装LDAP后台程序slapd
      到目录/usr/local/libexec;配置文件在目录/usr/local/etc/openldap/ 并且放各种
      OpenLDAP工具
      ldapadd,ldapdelete,ldapmodify,ldapmodrdn,ldappasswd,ldapsearch 在目录
      /usr/local/bin,运行时数据库在/usr/local/var/openldap-ldbm 。

三. 设置

      1) 更改配置文件/usr/local/etc/openldap/slapd.conf
      在include /usr/local/etc/openldap/schema/core.schema这行后面加上下面的行，
      包括所有的方案。

      include /usr/local/etc/openldap/schema/corba.schema
      include /usr/local/etc/openldap/schema/cosine.schema
      include /usr/local/etc/openldap/schema/inetorgperson.schema
      include /usr/local/etc/openldap/schema/java.schema
      include /usr/local/etc/openldap/schema/krb5-kdc.schema
      include /usr/local/etc/openldap/schema/misc.schema
      include /usr/local/etc/openldap/schema/nadf.schema
      include /usr/local/etc/openldap/schema/nis.schema
      include /usr/local/etc/openldap/schema/openldap.schema

2) 在文件slapd.conf的"ldbm database definitions"部分更改相应的
suffix,rootdn行如下

      database ldbm
      suffix "o=yourdomain,c=us"
      rootdn "cn=root,o=yourdomain,c=us"
      rootpw secret
      directory /usr/local/var/openldap-ldbm

      有各种格式你可以用，这里我用的是o=yourdomain,c=us 说明你的公司域名和所在的国
      家或地区
      rootdn的格式安装后默认为cn=Manager,这里改为root完全是自己的喜好,这样符合
      Unix/Linux中root具有最高权限的传统。

3) 现在可以启动slapd了，运行/usr/local/libexec/slapd 。

      可以考虑把/usr/local/bin and /usr/local/libexec加到搜索路径中，即加到
      /etc/profile
      中的PATH行:
      PATH="$PATH:/usr/X11R6/bin:/usr/local/bin:/usr/local/libexec"
      这样下次登录后只需键入 slapd 。

4) 测试ldap server是否正常工作。
运行下面的命令检查是否有相应的输出。

#ldapsearch -x -b 'o=yourdomain,c=us' '(objectclass=*)'

5) 编辑.ldif文本文件，用ldapadd添加记录进入LDAP数据库。
文件内容如下：

      dn: o=yourdomain,c=us
      objectclass: dcobject
      objectclass: organization
      o: yourdomain
      dc: yourdomain

      dn: cn=Jephe Wu,o=yourdomain,c=us
      objectclass: inetorgperson
      cn: Jephe Wu
      sn: Wu
      mail: jephe_wu@yourdomain.com

......more users......

      依次类推，添加每个人的记录进入该文件中，注意对象类型 inetorgperson 至少必须要
      有cn和sn
      ,这里我们用cn,sn,mail三项定义,这对我们的邮件地址薄功能来说已经足够。你还可以
      定义象
      mobile, homephone,pager......等等。

然后用下面的命令添加上面的.ldif文件进入LDAP数据库

#ldapadd -x -D "cn=root,o=yourdomain,c=us" -w secret -f
"yourldiffilename"

注：上面的文件的第一部分"dn: o=yourdomain,c=us"是必须的，否则不能添加数据。
用你的公司的域名替换上面的"yourdomain"。

6) 设置Outlook Express, 允许用LDAP服务器查询邮件地址。

      "工具/帐号/添加--目录服务"，填入你的服务器的IP地址或者主机全称域名，在下一个屏
      幕中选yes以允许用目录服务来查询地址，最后在"目录服务"栏中选中刚才设置的项目击
      “属性/高级",在"搜索库"中填入
      "o=yourdomain,c=us" 。
      Netscape请根据上面的信息设置相应的选项。

四. 常见使用问题

      1) 能启动slapd 没有问题，但不能添加数据库，运行ldapadd添加时出错 "ldap_bind:
      cannot contact LDAP Server" 。
      答: 最可能的原因是在/etc/hosts中没有127.0.0.1 localhost项目。

2) 注意查询顺序: 如果在Outlook Express的地址薄中有内容，则检查地址时地址薄优
先，如果在本地地址薄中找不到相应记录，然后再查询LDAP服务器。

3) 用下面的命令确信客户端与LDAP服务器有通讯,在服务器运行下面的命令，然后在OE中
测试检查地址，你将会得到查询LDAP数据库的连接过程的输出。

# tcpdump port 389

dennis 2007-07-14 16:08 发表评论