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

使用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的性能优化

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

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 发表评论