拈花微笑 » java

有关Java泛型的类型擦除（type erasing）

Jay — Thu, 02 Feb 2012 09:24:41 +0000

自从Java 5引入泛型之后，Java与C++对于泛型不同的实现的优劣便一直是饭后的谈资。在我之前的很多training中，当讲到Java泛型时总是会和C++的实现比较，一般得出的结论是

Java使用类型擦除（type erasing），泛型信息只在编译时供javac作类型检查用，在编译后便被javac擦除，因此无法被反射
C++使用代码模板实现泛型，即在预处理时会生成类似｢list_int｣，｢list_char｣等的泛型类，虽然解决Java的运行时伪泛型的问题，但是会导致编译后的代码呈线性增长
于是在一般情况下，Java的类型擦除实现较优

这三条已经比绝大多数的Java培训讲师讲得深刻了。但是如果下面有人问｢在什么情况下C++的实现方式较优｣时，除了无法被反射，我很难现抓一个有说服力的例子。今天，Spring的RestTemplate终于给了我这个例子

我遇到的问题如下（阅读需要有一些Spring MVC、REST基础）

有一个返回类型为List的MVC方法：

@RequestMapping(value = "...", method = RequestMethod.GET)
@ResponseBody
public List<DomainClass> doSomethingREST() {
List<DomainClass> domainObjs = ... ;
return domainObjs;
}

@RequestMapping(value = "...", method = RequestMethod.GET)
@ResponseBody
public List doSomethingREST() {
    List domainObjs = ... ;
    return domainObjs;
}

在运行时，Spring MVC会将List转换成JSON字符串并返回至客户端。但是如果我在另一个service中使用RestTemplate直接调用该REST接口，问题便来了：

List<DomainClass> domainObjs = this.restTemplate.getForObject(this.restURL, List.class);

List domainObjs = this.restTemplate.getForObject(this.restURL, List.class);

关键在于第二个参数，是返回值的类型，RestTemplate会根据此类型选择适当的MessageConverter将调用REST接口的返回值反序列化为与类型匹配的对象。由于List的泛型参数在编译时被擦除，于是RestTemplate便无法确定List中的内容。｢一般情况下｣（REST接口返回值不是List类型）不会有问题，但是巧合的是，如果服务器端使用JSON对REST结果进行序列化，返回值会被封装在List中，此时，Spring已无法判断开发人员是想直接获得List封装的JSON内容还是需要更进一步使用Jackson库将JSON反序列化为Java对象。现实情况下，Spring选择的前者，于是便会抛出ClassCastException

上网搜了一圈，已经有人向Spring提交了enhancement请求（这里和这里，其中第一个链接中的walkaround可以work），但是目前没有milestone

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 有关Java泛型的类型擦除（type erasing）

使用Spring LDAP ODM操作LDAP

Jay — Wed, 14 Dec 2011 15:10:16 +0000

Spring Source真的是个很神奇的开源社区，从《J2EE without EJB》开始为大家所知晓，到把IoC、AOP大范围地带到大家的开发模型中，再到和Hibernate、Struts组成每个Java函授学校必教的“SSH”组合，从此绿遍大江南北……

在国内，大马路上随便抓一个Java程序员，10个里有9个半知道Spring；有9个知道怎么把SSH“组装”到一起（是的，“组装”，和流水线上的蓝领熟练工没有本质区别）；有9个半知道IoC、AOP；有2个知道IoC和AOP的本质；有3个知道Spring其实分为core、context、orm、tx等不同子框架；有1个知道Spring 3之后可以用annotation取代之前版本大部分的xml配置；有2个知道Spring mvc和security；有半个知道其实Spring的子框架远不止这些……这就是我们当前Java码农们的实际情况。而造成这一局面的，我谓之三害——高校计算机系功利的培养模式、以北大青鸟为首的各种速成班的祸害和程序员们自己懒惰、人云亦云、拒绝思考的慢性自杀

牢骚发完，本文将通过介绍Spring的两个子框架：Spring LDAP和Spring LDAP ODM，来实现对LDAP的操作

项目主页：http://www.springsource.org/ldap，该框架通过提供和ORM中相似的机制对LDAP相关操作进行封装，主要包括：

类比SessionFactory的LdapContextSource
类比HibernateTemplate等的LdapTemplate
伪事务支持，能否与tx框架的TransactionManager混用未知
类比JPA的使用@Entry、@Attribute、@Id标注的ODM——Object Directory Mapping

本文（原先）目标：使用ODM将User类与LDAP中的实体进行映射，LDAP中的实体的objectClass包括inetOrgPerson，organizationalPerson，person，shadowAccount和top

相关配置文件、代码在http://static.springsource.org/spring-ldap/docs/1.3.x/reference/html/上已经很详细了，这里只是做一点旁注，全部来自于这几天和Spring LDAP的斗智斗勇

对于shadowAccount的shadowLastChange域，值是一个整形，至于具体含义网上没有找到解释，试了几次之后发现是从1970-1-1 00:00:00至今的天数，如果model里定义的是Date类型的话，需要自行实现org.springframework.ldap.odm.typeconversion.impl.Converter接口进行转换
对于@Entry标记，其中的objectClasses定义必须与objectClass完全一致。在新建和查询object时，ODM会根据此标记进行匹配，无需再指定objectClass
每个entry必须指定@Id字段，类型为javax.naming.Name，其实就是DN。但是若在LdapContextSource中指定了base，则DN将会按照base截取相对路径。比如，DN为cn=user,ou=users,dc=jayxu,dc=com，base为dc=jayxu,dc=com，则取出的user对象DN为cn=user,ou=users
如果使用Spring MVC对LDAP对象进行JSON序列化，必须注意javax.naming.Name中的某些字段无法被序列化，所以在转换成JSON之前需要将DN置null。一种方法是使用@JsonIgnoreProperties标记model类，比如：@JsonIgnoreProperties(“dn”)
对于不需要与LDAP进行映射的字段使用@Transient进行标记
考虑使用org.springframework.ldap.pool.factory.PoolingContextSource引入连接池
如果事务中需要与JDBC进行互操作，需要使用org.springframework.ldap.transaction.compensating.manager.ContextSourceAndDataSourceTransactionManager作为tx manager

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 使用Spring LDAP ODM操作LDAP

祝贺：发布《Java虚拟机规范（Java SE 7 中文版）》

Jay — Fri, 02 Dec 2011 08:14:53 +0000

原文转自：http://icyfenix.iteye.com/blog/1256329

《Java虚拟机规范（Java SE 7 中文版）》是一份根据《Java Virtual Machine Specification （Java SE 7）》翻译的、非官方的、以Open Document形式发布的文档。

本译文由ItEye社区三位水友IcyFenix、wupuyuan、langyu合作完成，我们的翻译工作完全基于技术研究目的，任何人也都可以在以技术研究为目的前提下任意阅读、传播、使用这份文档。但没有得到原文作者和译者授权，不得用于商业出版。

◎ 全文PDF下载地址：Download （@iteye.com）
◎ 如果没有ItEye账号的朋友，可在此下载：Download （@icyfenix.com）
◎ 译文勘误、更新地址：http://www.icyfenix.com/jvms_javase7_cn

翻译一本书，远远比读完一本书来的辛苦。不过回头看来，那些辛苦比起翻译过程中对自己的提升和认识到的朋友，收获是远远大于付出。如果这本书能再为其他人带来一点方便和用处，那我们就更加欣慰了。如果本书真的对您有用，希望您能：

◎ 向我们反馈本书中翻译的问题，以便我们能持续改进译文的质量。
◎ 向朋友传播本书（如帮我转发一下此微博），以便我们的工作能发挥更大的价值。

译者序

从1999年4月出版的《Java虚拟机规范（第二版）》至今，已经超过12年，虽然此规范在JDK 5发布的时候作了较大的更新，但却始终没有发布完整的规范。在今年6月28日，最新的《Java虚拟机规范（Java SE 7版）》终于完成并在7月份正式发布。对于想了解Java虚拟机的程序员来说，《Java虚拟机规范》是必须阅读的，对于想深入了解Java语言细节的程序员，阅读《Java虚拟机规范》也有极大好处，但是《Java虚拟机规范》、《Java语言规范》发布十余年，一直没有中文译本，这让中国不少对Java虚拟机感兴趣，但英语能力较弱的程序员都被拒之门外。

在2011年初，《Java虚拟机规范（Java SE 7版）》还是草稿状态时，我就开始关注这本书，并陆续对其中第1、2、6、7章进行了翻译，到2011年9月时完成了200余页的译稿。这时候又在国内著名Java社区ItEye中结识了另外两名译者吴璞渊和冶秀刚，我们在随后的两个多月的时间里共同完成了其余章节的翻译和校对。

《Java虚拟机规范》并非某一款虚拟机实现的说明书，它是一份保证各个公司的Java虚拟机实现具备统一外部接口的契约文档，书中的概念和细节描述曾经与Sun的早期虚拟机的实现高度吻合，但是随着技术的发展，高性能虚拟机真正的细节实现方式已经渐渐与虚拟机规范所描述的内容产生了越来越大的差距。原作者也在书中不同地方反复强调过：虚拟机规范中所提及的“Java虚拟机”皆为虚拟机的概念模型而非具体实现。实现只要保证与概念模型最终等效即可，而具体实现的方式无需受概念模型束缚。因此通过虚拟机规范去分析程序的执行语义问题（虚拟机会做什么）时，但分析程序的执行行为问题（虚拟机是怎样做的、性能如何）则意义不大，如需对具体虚拟机实现进行调优、性能分析等，我推荐在本书基础上继续阅读《Java Performance》和《Oracle JRockit The Definitive Guide》等书。

在翻译过程中，我们尽最大努力保证作品的准确性和可读性，力求在保证语义准确的前提下，尽可能使用通俗易懂的方式向给各位读者介绍Java虚拟机的约束与运作原理。为此目标，我们在专有技术名词、偏僻词中用括号保留了原文、专门在多处读者理解起来可能有困难的地方，添加了“译者注”加以解释。

囿于我们的水平和写作时间，书中难免存在不妥之处，大家如有任何意见或建议都欢迎通过以下邮件地址与我联系：icyfenix@gmail.com。本书的勘误与最新版本可以在以下网址中获取：http://www.icyfenix.com/jvms_javase7_cn/

最后，请允许我再介绍一下本书三位译者的技术背景与分工：

周志明（www.icyfenix.com & weibo.com/icyfenix）：远光软件平台开发部部门经理，平台架构师，不愿意脱离编码的一线码农。著有《深入理解Java虚拟机：JVM高级特性与最佳实践》。关注各种Java应用，略懂OSGi、Java虚拟机和工作流。在本书翻译工作中负责全文统稿；前言和第1、2、6、7章的翻译；第3、4、5章的校审工作。
吴璞渊（wupuyuan.iteye.com）：就职于西门子，偏向程序和工作流设计，喜好Java各种新技术并倒腾。在本书翻译工作中负责第3章以及第4章的1至7节。。
冶秀刚（langyu.iteye.com）：思科平台工程师，从事分布式系统的研究与开发，爱好Java平台技术且正在努力成长中。在本书翻译工作中负责第5章及第4章的9至11节。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 祝贺：发布《Java虚拟机规范（Java SE 7 中文版）》

X and XX Usgaes for Java

Jay — Mon, 26 Sep 2011 03:33:18 +0000

-X

-Xmixed	mixed mode execution (default)
-Xint	interpreted mode execution only
-Xbootclasspath:	set search path for bootstrap classes and resources
-Xbootclasspath/a:	append to end of bootstrap class path
-Xbootclasspath/p:	prepend in front of bootstrap class path
-Xnoclassgc	disable class garbage collection
-Xincgc	enable incremental garbage collection
-Xloggc:	log GC status to a file with time stamps
-Xbatch	disable background compilation
-Xms	set initial Java heap size
-Xmx	set maximum Java heap size
-Xss	set java thread stack size
-Xprof	output cpu profiling data
-Xfuture	enable strictest checks, anticipating future default
-Xrs	reduce use of OS signals by Java/VM (see documentation)
-Xcheck:jni	perform additional checks for JNI functions
-Xshare:off	do not attempt to use shared class data
-Xshare:auto	use shared class data if possible (default)
-Xshare:on	require using shared class data, otherwise fail.

-XX

-XX:-AllowUserSignalHandlers	Do not complain if the application installs signal handlers. (Relevant to Solaris and Linux only.)
-XX:AltStackSize=16384	Alternate signal stack size (in Kbytes). (Relevant to Solaris only, removed from 5.0.)
-XX:-DisableExplicitGC	Disable calls to System.gc(), JVM still performs garbage collection when necessary.
-XX:+FailOverToOldVerifier	Fail over to old verifier when the new type checker fails. (Introduced in 6.)
-XX:+HandlePromotionFailure	The youngest generation collection does not require a guarantee of full promotion of all live objects. (Introduced in 1.4.2 update 11) [5.0 and earlier: false.]
-XX:+MaxFDLimit	Bump the number of file descriptors to max. (Relevant to Solaris only.)
-XX:PreBlockSpin=10	Spin count variable for use with -XX:+UseSpinning. Controls the maximum spin iterations allowed before entering operating system thread synchronization code. (Introduced in 1.4.2.)
-XX:-RelaxAccessControlCheck	Relax the access control checks in the verifier. (Introduced in 6.)
-XX:+ScavengeBeforeFullGC	Do young generation GC prior to a full GC. (Introduced in 1.4.1.)
-XX:+UseAltSigs	Use alternate signals instead of SIGUSR1 and SIGUSR2 for VM internal signals. (Introduced in 1.3.1 update 9, 1.4.1. Relevant to Solaris only.)
-XX:+UseBoundThreads	Bind user level threads to kernel threads. (Relevant to Solaris only.)
-XX:-UseConcMarkSweepGC	Use concurrent mark-sweep collection for the old generation. (Introduced in 1.4.1)
-XX:+UseGCOverheadLimit	Use a policy that limits the proportion of the VM’s time that is spent in GC before an OutOfMemory error is thrown. (Introduced in 6.)
-XX:+UseLWPSynchronization	Use LWP-based instead of thread based synchronization. (Introduced in 1.4.0. Relevant to Solaris only.)
-XX:-UseParallelGC	Use parallel garbage collection for scavenges. (Introduced in 1.4.1)
-XX:-UseParallelOldGC	Use parallel garbage collection for the full collections. Enabling this option automatically sets -XX:+UseParallelGC. (Introduced in 5.0 update 6.)
-XX:-UseSerialGC	Use serial garbage collection. (Introduced in 5.0.)
-XX:-UseSpinning	Enable naive spinning on Java monitor before entering operating system thread synchronizaton code. (Relevant to 1.4.2 and 5.0 only.) [1.4.2, multi-processor Windows platforms: true]
-XX:+UseTLAB	Use thread-local object allocation (Introduced in 1.4.0, known as UseTLE prior to that.) [1.4.2 and earlier, x86 or with -client: false]
-XX:+UseSplitVerifier	Use the new type checker with StackMapTable attributes. (Introduced in 5.0.)[5.0: false]
-XX:+UseThreadPriorities	Use native thread priorities.
-XX:+UseVMInterruptibleIO	Thread interrupt before or with EINTR for I/O operations results in OS_INTRPT. (Introduced in 6. Relevant to Solaris only.)

-XX:+AggressiveOpts	Turn on point performance compiler optimizations that are expected to be default in upcoming releases. (Introduced in 5.0 update 6.)
-XX:CompileThreshold=10000	Number of method invocations/branches before compiling [-client: 1,500]
-XX:LargePageSizeInBytes=4m	Sets the large page size used for the Java heap. (Introduced in 1.4.0 update 1.) [amd64: 2m.]
-XX:MaxHeapFreeRatio=70	Maximum percentage of heap free after GC to avoid shrinking.
-XX:MaxNewSize=size	Maximum size of new generation (in bytes). Since 1.4, MaxNewSize is computed as a function of NewRatio. [1.3.1 Sparc: 32m; 1.3.1 x86: 2.5m.]
-XX:MaxPermSize=64m	Size of the Permanent Generation. [5.0 and newer: 64 bit VMs are scaled 30% larger; 1.4 amd64: 96m; 1.3.1 -client: 32m.]
-XX:MinHeapFreeRatio=40	Minimum percentage of heap free after GC to avoid expansion.
-XX:NewRatio=2	Ratio of new/old generation sizes. [Sparc -client: 8; x86 -server: 8; x86 -client: 12.]-client: 4 (1.3) 8 (1.3.1+), x86: 12]
-XX:NewSize=2.125m	Default size of new generation (in bytes) [5.0 and newer: 64 bit VMs are scaled 30% larger; x86: 1m; x86, 5.0 and older: 640k]
-XX:ReservedCodeCacheSize=32m	Reserved code cache size (in bytes) – maximum code cache size. [Solaris 64-bit, amd64, and -server x86: 48m; in 1.5.0_06 and earlier, Solaris 64-bit and and64: 1024m.]
-XX:SurvivorRatio=8	Ratio of eden/survivor space size [Solaris amd64: 6; Sparc in 1.3.1: 25; other Solaris platforms in 5.0 and earlier: 32]
-XX:TargetSurvivorRatio=50	Desired percentage of survivor space used after scavenge.
-XX:ThreadStackSize=512	Thread Stack Size (in Kbytes). (0 means use default stack size) [Sparc: 512; Solaris x86: 320 (was 256 prior in 5.0 and earlier); Sparc 64 bit: 1024; Linux amd64: 1024 (was 0 in 5.0 and earlier); all others 0.]
-XX:+UseBiasedLocking	Enable biased locking. For more details, see this tuning example. (Introduced in 5.0 update 6.) [5.0: false]
-XX:+UseFastAccessorMethods	Use optimized versions of GetField.
-XX:-UseISM	Use Intimate Shared Memory. [Not accepted for non-Solaris platforms.] For details, see Intimate Shared Memory.
-XX:+UseLargePages	Use large page memory. (Introduced in 5.0 update 5.) For details, see Java Support for Large Memory Pages.
-XX:+UseMPSS	Use Multiple Page Size Support w/4mb pages for the heap. Do not use with ISM as this replaces the need for ISM. (Introduced in 1.4.0 update 1, Relevant to Solaris 9 and newer.) [1.4.1 and earlier: false]
-XX:+UseStringCache	Enables caching of commonly allocated strings.
-XX:AllocatePrefetchLines=1	Number of cache lines to load after the last object allocation using prefetch instructions generated in JIT compiled code. Default values are 1 if the last allocated object was an instance and 3 if it was an array.
-XX:AllocatePrefetchStyle=1	Generated code style for prefetch instructions. 0 – no prefetch instructions are generated, 1 – execute prefetch instructions after each allocation, 2 – use TLAB allocation watermark pointer to gate when prefetch instructions are executed.
-XX:+UseCompressedStrings	Use a byte[] for Strings which can be represented as pure ASCII. (Introduced in Java 6 Update 21 Performance Release)
-XX:+OptimizeStringConcat	Optimize String concatenation operations where possible. (Introduced in Java 6 Update 20)

-XX:-CITime	Prints time spent in JIT Compiler. (Introduced in 1.4.0.)
-XX:ErrorFile=./hs_err_pid.log	If an error occurs, save the error data to this file. (Introduced in 6.)
-XX:-ExtendedDTraceProbes	Enable performance-impacting dtrace probes. (Introduced in 6. Relevant to Solaris only.)
-XX:HeapDumpPath=./java_pid.hprof	Path to directory or filename for heap dump. Manageable. (Introduced in 1.4.2 update 12, 5.0 update 7.)
-XX:-HeapDumpOnOutOfMemoryError	Dump heap to file when java.lang.OutOfMemoryError is thrown. Manageable. (Introduced in 1.4.2 update 12, 5.0 update 7.)
-XX:OnError=”;”	Run user-defined commands on fatal error. (Introduced in 1.4.2 update 9.)
-XX:OnOutOfMemoryError=”; ”	Run user-defined commands when an OutOfMemoryError is first thrown. (Introduced in 1.4.2 update 12, 6)
-XX:-PrintClassHistogram	Print a histogram of class instances on Ctrl-Break. Manageable. (Introduced in 1.4.2.) The jmap -histo command provides equivalent functionality.
-XX:-PrintConcurrentLocks	Print java.util.concurrent locks in Ctrl-Break thread dump. Manageable. (Introduced in 6.) The jstack -l command provides equivalent functionality.
-XX:-PrintCommandLineFlags	Print flags that appeared on the command line. (Introduced in 5.0.)
-XX:-PrintCompilation	Print message when a method is compiled.
-XX:-PrintGC	Print messages at garbage collection. Manageable.
-XX:-PrintGCDetails	Print more details at garbage collection. Manageable. (Introduced in 1.4.0.)
-XX:-PrintGCTimeStamps	Print timestamps at garbage collection. Manageable (Introduced in 1.4.0.)
-XX:-PrintTenuringDistribution	Print tenuring age information.
-XX:-TraceClassLoading	Trace loading of classes.
-XX:-TraceClassLoadingPreorder	Trace all classes loaded in order referenced (not loaded). (Introduced in 1.4.2.)
-XX:-TraceClassResolution	Trace constant pool resolutions. (Introduced in 1.4.2.)
-XX:-TraceClassUnloading	Trace unloading of classes.
-XX:-TraceLoaderConstraints	Trace recording of loader constraints. (Introduced in 6.)
-XX:+PerfSaveDataToFile	Saves jvmstat binary data on exit.
-XX:ParallelGCThreads=	Sets the number of garbage collection threads in the young and old parallel garbage collectors. The default value varies with the platform on which the JVM is running.
-XX:+UseCompressedOops	Enables the use of compressed pointers (object references represented as 32 bit offsets instead of 64-bit pointers) for optimized 64-bit performance with Java heap sizes less than 32gb.
-XX:+AlwaysPreTouch	Pre-touch the Java heap during JVM initialization. Every page of the heap is thus demand-zeroed during initialization rather than incrementally during application execution.
-XX:AllocatePrefetchDistance=	Sets the prefetch distance for object allocation. Memory about to be written with the value of new objects is prefetched into cache at this distance (in bytes) beyond the address of the last allocated object. Each Java thread has its own allocation point. The default value varies with the platform on which the JVM is running.
-XX:InlineSmallCode=	Inline a previously compiled method only if its generated native code size is less than this. The default value varies with the platform on which the JVM is running.
-XX:MaxInlineSize=35	Maximum bytecode size of a method to be inlined.
-XX:FreqInlineSize=	Maximum bytecode size of a frequently executed method to be inlined. The default value varies with the platform on which the JVM is running.
-XX:LoopUnrollLimit=	Unroll loop bodies with server compiler intermediate representation node count less than this value. The limit used by the server compiler is a function of this value, not the actual value. The default value varies with the platform on which the JVM is running.
-XX:InitialTenuringThreshold=7	Sets the initial tenuring threshold for use in adaptive GC sizing in the parallel young collector. The tenuring threshold is the number of times an object survives a young collection before being promoted to the old, or tenured, generation.
-XX:MaxTenuringThreshold=	Sets the maximum tenuring threshold for use in adaptive GC sizing. The current largest value is 15. The default value is 15 for the parallel collector and is 4 for CMS.

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: X and XX Usgaes for Java

Differences Among Greedy, Reluctant, and Possessive Quantifiers (for RexExp in Java)

Jay — Tue, 20 Sep 2011 02:53:26 +0000

There are subtle differences among greedy, reluctant, and possessive quantifiers.

Greedy quantifiers are considered “greedy” because they force the matcher to read in, or eat, the entire input string prior to attempting the first match. If the first match attempt (the entire input string) fails, the matcher backs off the input string by one character and tries again, repeating the process until a match is found or there are no more characters left to back off from. Depending on the quantifier used in the expression, the last thing it will try matching against is 1 or 0 characters.

The reluctant quantifiers, however, take the opposite approach: They start at the beginning of the input string, then reluctantly eat one character at a time looking for a match. The last thing they try is the entire input

Finally, the possessive quantifiers always eat the entire input string, trying once (and only once) for a match. Unlike the greedy quantifiers, possessive quantifiers never back off, even if doing so would allow the overall match to succeed.

To illustrate, consider the input string xfooxxxxxxfoo.

Enter your regex: .*foo // greedy quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text “xfooxxxxxxfoo” starting at index 0 and ending at index 13.

Enter your regex: .*?foo // reluctant quantifier
Enter input string to search: xfooxxxxxxfoo
I found the text “xfoo” starting at index 0 and ending at index 4.
I found the text “xxxxxxfoo” starting at index 4 and ending at index 13.

Enter your regex: .*+foo // possessive quantifier
Enter input string to search: xfooxxxxxxfoo
No match found.

The first example uses the greedy quantifier .* to find “anything”, zero or more times, followed by the letters “f” “o” “o”. Because the quantifier is greedy, the .* portion of the expression first eats the entire input string. At this point, the overall expression cannot succeed, because the last three letters (“f” “o” “o”) have already been consumed. So the matcher slowly backs off one letter at a time until the rightmost occurrence of “foo” has been regurgitated, at which point the match succeeds and the search ends.

The second example, however, is reluctant, so it starts by first consuming “nothing”. Because “foo” doesn’t appear at the beginning of the string, it’s forced to swallow the first letter (an “x”), which triggers the first match at 0 and 4. Our test harness continues the process until the input string is exhausted. It finds another match at 4 and 13.

The third example fails to find a match because the quantifier is possessive. In this case, the entire input string is consumed by .*+, leaving nothing left over to satisfy the “foo” at the end of the expression. Use a possessive quantifier for situations where you want to seize all of something without ever backing off; it will outperform the equivalent greedy quantifier in cases where the match is not immediately found

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Differences Among Greedy, Reluctant, and Possessive Quantifiers (for RexExp in Java)

关于『C++11 中值得关注的几大变化（详解）』

Jay — Thu, 01 Sep 2011 06:21:29 +0000

博客更新得越来越不频繁，一方面是忙+懒，另一方面围脖带来的写作习惯的变化，越来越多的想法使用140字以内的只字片语发布在围脖上。而WP上还没有像twitter tools一样的围脖反向更新工具，所有的围脖相关工具不是登录绑定就是发博同步至围脖。可见国内互联网产品业余开发人员的同质与乏善可陈，难道要我自己用PHP去写一个？

最近发现在team里的一些讨论邮件还是有点意思的，我发表了一些观点，也进行了一些讨论。这些邮件算是一个观点展示、碰撞的积累。今天开始转贴一些，当然前提是非IBM confidential的。以下是第一篇

C++11 中值得关注的几大变化（详解）

原文出自酷壳

Me：Like Java & C#, C++ started to introduce many language sugars into the new version 11 (to make the language up-to-date), esp. for Lambda grammar, which is deferred to Java 8. Another highlight is the standard thread lib, wonder if it supports multi-core architecture well.

Jacob：We took so long time to wait this new standard(1998–>2003–>2011); And we still need some times to wait the compiler to support them. It is a pity that we did not find new “Regular Expression” at C++11; I think it is a very useful specific. Maybe Boost still can be used for it. “wonder if it supports multi-core architecture well”,I am also wondering. Actually, There are some product can support it well: OpenMP(Intel), VS2010. I guess parallel computing especially GPU is a trend in desktop usage.

Me：Agree that more and more programmers have already moved their compute-intensive (C/C++) code to GPU – which provides much more throughput. Hope Java could provide such feature in the future release.

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 关于『C++11 中值得关注的几大变化（详解）』

Don’t Use Java 7, For Anything [zz]

Jay — Wed, 10 Aug 2011 08:08:36 +0000

From here. Shit happens, Oracle wanna risk the fame of Java?!

Java 7 GA was released today, but as noted by Uwe Schindler, there are some very frightening bugs in HotSpot Loop optimizations that are enabled by default. In the best case scenario, these bugs cause the JVM to crash. In the worst case scenario, they cause incorrect execution of loops.

Bottom Line: Don’t use Java 7 for anything (unless maybe you know you don’t have any loops in your java code)

From: Uwe Schindler
Date: Thu, 28 Jul 2011 23:13:36 +0200
Subject: [WARNING] Index corruption and crashes in Apache Lucene Core / Apache Solr with Java 7

Hello Apache Lucene & Apache Solr users,
Hello users of other Java-based Apache projects,

Oracle released Java 7 today. Unfortunately it contains hotspot compiler
optimizations, which miscompile some loops. This can affect code of several
Apache projects. Sometimes JVMs only crash, but in several cases, results
calculated can be incorrect, leading to bugs in applications (see Hotspot
bugs 7070134 [1], 7044738 [2], 7068051 [3]).

Apache Lucene Core and Apache Solr are two Apache projects, which are
affected by these bugs, namely all versions released until today. Solr users
with the default configuration will have Java crashing with SIGSEGV as soon
as they start to index documents, as one affected part is the well-known
Porter stemmer (see LUCENE-3335 [4]). Other loops in Lucene may be
miscompiled, too, leading to index corruption (especially on Lucene trunk
with pulsing codec; other loops may be affected, too – LUCENE-3346 [5]).

These problems were detected only 5 days before the official Java 7 release,
so Oracle had no time to fix those bugs, affecting also many more
applications. In response to our questions, they proposed to include the
fixes into service release u2 (eventually into service release u1, see [6]).
This means you cannot use Apache Lucene/Solr with Java 7 releases before
Update 2! If you do, please don’t open bug reports, it is not the
committers’ fault! At least disable loop optimizations using the
-XX:-UseLoopPredicate JVM option to not risk index corruptions.

Please note: Also Java 6 users are affected, if they use one of those JVM
options, which are not enabled by default: -XX:+OptimizeStringConcat or
-XX:+AggressiveOpts

It is strongly recommended not to use any hotspot optimization switches in
any Java version without extensive testing!

In case you upgrade to Java 7, remember that you may have to reindex, as the
unicode version shipped with Java 7 changed and tokenization behaves
differently (e.g. lowercasing). For more information, read
JRE_VERSION_MIGRATION.txt in your distribution package!

On behalf of the Lucene project,
Uwe

[1] http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7070134
[2] http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7044738
[3] http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7068051
[4] https://issues.apache.org/jira/browse/LUCENE-3335
[5] https://issues.apache.org/jira/browse/LUCENE-3346
[6] http://s.apache.org/StQ

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Don’t Use Java 7, For Anything [zz]

有关Character.isLetter()和Character.isLetterOrDigit()

Jay — Fri, 10 Dec 2010 03:27:40 +0000

在项目中有时候可能需要判断输入的是否全是英文或数字，如果你不善于使用正则，JDK中提供了Character类对字符进行操作，其中的 isLetter和isLetterOrDigit方法貌似可以做到这一点。但是如果你试下下面的代码，你会失望的：

System.out.println(Character.isLetter('中'));

System.out.println(Character.isLetter('中'));

很不幸地，Java天生提供了对unicode的支持，因此在她眼里中文也是“letter”，所以上面打印出的是true……。替代方案是，使用Apache Commons子项目中的lang库，CharUtils的isAsciiAlpha和isAsciiAlphanumberic可以帮助你只对英文字母进行判断

多说一句，commons项目是个大宝库，其中提供了大量对JDK的增强API，lang库就是对java.lang的增强，比如使用反射生成toString的ToStringBuilder，使用反射生成hashCode的HashCodeBuilder，使用反射生成equals的EqualsBuilder等等，大家可以慢慢自己发掘～

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 有关Character.isLetter()和Character.isLetterOrDigit()

如何在Hibernate中让SQLServer使用nvarchar代替varchar

Jay — Tue, 23 Nov 2010 08:19:38 +0000

有关SQLServer中varchar和nvarchar的区别可以直接去google。一般在中文系统中应该使用nvarchar作为字符串的对应类型，但是Hibernate中的默认实现SQLServerDialect使用了varchar。以下方法可以简单地转为使用nvarchar：

自己写一个dialect，继承SQLServerDialect，在构造器中将原先varchar类型的注册声明覆盖：

registerColumnType(Types.VARCHAR, "nvarchar($l)");

registerColumnType(Types.VARCHAR, "nvarchar($l)");

千万注意，“$”后面的是字段长度的占位符，是“l(ength)”，而不是数字“1”（因为看hibernate的doc时没分清“l”和“1”，浪费了我一上午去找原因）

然后在hibernate的配置文件中将hibernate.dialect的值设为你的dialect实现类就OK了

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何在Hibernate中让SQLServer使用nvarchar代替varchar

误区！double类型做加减法不会有误差？

Jay — Wed, 25 Aug 2010 02:36:08 +0000

如果你跟我一样以为Java的double类型只有在作乘除法时才会出现误差，那试一下在Java里执行一下下面的代码：

public static void main(String[] args) {
System.out.println(44.42 + 710.79 + 44.42 + 88.85);
}

public static void  main(String[] args) {
    System.out.println(44.42 + 710.79 + 44.42 +  88.85);
}

执行前先猜一下结果，是会输出888.48么？还是……？

建议：对于和钱有关的计算，不论加减乘除，统一使用 BigDecimal！

然而不多久之后同事告诉我另一个BigDecimal的问题，试一下下面的代码：

System.out.println(new BigDecimal(0.99).setScale(2, RoundingMode.DOWN).toString());

System.out.println(new BigDecimal(0.99).setScale(2, RoundingMode.DOWN).toString());

结果是令人发指的0.98！

看了一下 BigDecimal(double)的源码，其中使用位操作分别提取了0.99浮点值的整数部分和纯小数部分，或者说是2的正数次幂和负数次幂部分。而这样提取出来的值纯小数部分本身就是近似的，与直接使用double类型没有本质区别，这是浮点表示法决定的，再经过2位截取后就产生了误差

而当使用BigDecimal(String)的构造器时得到的是精确值，因为该构造器将数字使用科学计数法表示，即 0.99表示为99*10^-2，这样做运算时先对齐至相同的整数位再进行计算

因此，对上面的补充是：如果要获取最精确的结果，请使用BD+字符串类型的构造器

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 误区！double类型做加减法不会有误差？

Java程序员必看电影：Java 4-ever

Jay — Wed, 11 Aug 2010 12:08:47 +0000

.net算个毛！

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Java程序员必看电影：Java 4-ever

有关Runtime.addShutdownHook(Thread)

Jay — Mon, 29 Mar 2010 12:38:31 +0000

今天在JDK的javadoc里瞎转的时候无意间发现这么一个有趣的回调方法：

addShutdownHook
public void <b>addShutdownHookb>(<a href="http://download.oracle.com/javase/6/docs/api/java/lang/Thread.html" title="class in java.lang">Threada> hook)
public void addShutdownHook(Thread hook)
Registers a new virtual-machine shutdown hook.

The Java virtual machine shuts down in response to two kinds of events:

The program exits normally, when the last non-daemon thread exits or when the exit (equivalently, System.exit) method is invoked, or

The virtual machine is terminated in response to a user interrupt, such as typing ^C, or a system-wide event, such as user logoff or system shutdown.

A shutdown hook is simply an initialized but unstarted thread. When the virtual machine begins its shutdown sequence it will start all registered shutdown hooks in some unspecified order and let them run concurrently. When all the hooks have finished it will then run all uninvoked finalizers if finalization-on-exit has been enabled. Finally, the virtual machine will halt. Note that daemon threads will continue to run during the shutdown sequence, as will non-daemon threads if shutdown was initiated by invoking the exit method.

Once the shutdown sequence has begun it can be stopped only by invoking the halt method, which forcibly terminates the virtual machine.

Once the shutdown sequence has begun it is impossible to register a new shutdown hook or de-register a previously-registered hook. Attempting either of these operations will cause an IllegalStateException to be thrown.

Shutdown hooks run at a delicate time in the life cycle of a virtual machine and should therefore be coded defensively. They should, in particular, be written to be thread-safe and to avoid deadlocks insofar as possible. They should also not rely blindly upon services that may have registered their own shutdown hooks and therefore may themselves in the process of shutting down. Attempts to use other thread-based services such as the AWT event-dispatch thread, for example, may lead to deadlocks.

Shutdown hooks should also finish their work quickly. When a program invokes exit the expectation is that the virtual machine will promptly shut down and exit. When the virtual machine is terminated due to user logoff or system shutdown the underlying operating system may only allow a fixed amount of time in which to shut down and exit. It is therefore inadvisable to attempt any user interaction or to perform a long-running computation in a shutdown hook.

Uncaught exceptions are handled in shutdown hooks just as in any other thread, by invoking the uncaughtException method of the thread’s ThreadGroup object. The default implementation of this method prints the exception’s stack trace to System.err and terminates the thread; it does not cause the virtual machine to exit or halt.

In rare circumstances the virtual machine may abort, that is, stop running without shutting down cleanly. This occurs when the virtual machine is terminated externally, for example with the SIGKILL signal on Unix or the TerminateProcess call on Microsoft Windows. The virtual machine may also abort if a native method goes awry by, for example, corrupting internal data structures or attempting to access nonexistent memory. If the virtual machine aborts then no guarantee can be made about whether or not any shutdown hooks will be run.

Parameters:

hook – An initialized but unstarted Thread object

Throws:

IllegalArgumentException – If the specified hook has already been registered, or if it can be determined that the hook is already running or has already been run

IllegalStateException – If the virtual machine is already in the process of shutting down

SecurityException – If a security manager is present and it denies RuntimePermission("shutdownHooks")

Since:

1.3

See Also:

removeShutdownHook(java.lang.Thread), halt(int), exit(int)

即可以在runtime对象上注册一个回调方法，该方法会在JVM退出时执行传入的线程对象。在mac下试了一下，当调用System.exit()、使用系统kill命令杀掉java进程时该方法都会被调用。但是需要注意的是，当调用kill -9杀进程时，方法不被调用，JVM直接退出，Ｗindows下还没试过，不知道结果如何

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 有关Runtime.addShutdownHook(Thread)

植树节，写棵二叉树庆祝一下

Jay — Fri, 12 Mar 2010 09:41:49 +0000

今天下午看见一条推

RT: @rtmeme: RT @foxzzz RT @junyu: 看到 @windbreaker 老师在Buzz说：今天是植树节，写一棵二叉树庆祝之 (via @yangfannet)

于是兴起，花了半个多小时写了棵自认为（从工程而非算法上）比较牛逼的排序二叉树

package com.jayxu;

import java.util.Iterator;
import java.util.Random;
import java.util.Stack;

/**
 *
 * @author ijay
 */
public class BinaryTree> implements Iterable {
    private static final char[] FIRST_CHAR = {'B', 'C', 'K', 'F', 'D', 'G'};
    private static final char[] FOLLOWING_CHAR = {'a', 'k', 'l', 'p', 'r', 't',
        'n', 'm', 's', 'e'};
    private static Random r = new Random(System.currentTimeMillis());
    private TreeNode root;

    public void addNode(T value) {
        root = addToNode(root, value);
    }

    private TreeNode addToNode(TreeNode node, T value) {
        if (node == null) {
            node = new TreeNode();
            node.value = value;
        } else if (value.compareTo(node.value) <= 0) {
            node.left = addToNode(node.left, value);
        } else {
            node.right = addToNode(node.right, value);
        }

        return node;
    }

    public Iterator iterator() {
        return new PreOrderIterator();
    }

    private class TreeNode {
        TreeNode left;
        TreeNode right;
        T value;
    }

    private class PreOrderIterator implements Iterator {
        private Stack
 stack = new Stack
();

        private PreOrderIterator() {
            TreeNode current = root;

            while (current != null) {
                stack.push(current);
                current = current.left;
            }
        }

        public boolean hasNext() {
            return !stack.isEmpty();
        }

        public T next() {
            TreeNode n = stack.pop();

            TreeNode current = n.right;
            while (current != null) {
                stack.push(current);
                current = current.left;
            }

            return n.value;
        }

        public void remove() {
            throw new UnsupportedOperationException();
        }
    }

    public static void main(String[] args) {
        for (int i = 8; i < Integer.MAX_VALUE; i *= 2) {
            buildNTraverseTree(buildRawStrings(i), false);
        }
    }

    private static String[] buildRawStrings(int capacity) {
        String[] s = new String[capacity];

        s[0] = "Jay";
        s[1] = "Blader";
        s[2] = "Fred";
        s[3] = "Gavin";
        s[4] = "Alex";

        for (int i = 5; i < capacity; i++) {
            StringBuilder sb = new StringBuilder();

            sb.append(FIRST_CHAR[r.nextInt(FIRST_CHAR.length)]);

            int len = r.nextInt(10);
            for (int j = 0; j < len; j++) {
                sb.append(FOLLOWING_CHAR[r.nextInt(FOLLOWING_CHAR.length)]);
            }

            s[i] = sb.toString();
        }

        return s;
    }

    private static void buildNTraverseTree(String[] strings, boolean output) {
        System.out.print("Current capacity: " + strings.length + "\t");
        long start = System.currentTimeMillis();

        BinaryTree tree = new BinaryTree();

        for (String s : strings) {
            tree.addNode(s);
        }

        for (String s : tree) {
            if (output) {
                System.out.println(s);
            }
        }

        System.out.println("took " + (System.currentTimeMillis() - start)
                + " ms");
    }
}

该树特点：

使用泛型
实现Iterable接口从而能够使用增强for循环遍历
实现非递归中序遍历
生成随机数据测试

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 植树节，写棵二叉树庆祝一下

Snow Leopard下的JDK链接有问题

Jay — Tue, 26 Jan 2010 09:51:11 +0000

今天在SL下build JRex，在执行ant make的时候总是出现以下错误：

compile:
[javac] Compiling 86 source files to /Users/ijay/Projects/mozilla/embedding/JRex/classes
[javac] /Users/ijay/Projects/mozilla/embedding/JRex/src/java/netscape/javascript/JSObject.java:38: ?????? sun.plugin.javascript ??????
[javac] import sun.plugin.javascript.JSContext;
[javac] ^
[javac] /Users/ijay/Projects/mozilla/embedding/JRex/src/java/netscape/javascript/JSObject.java:172: ?????? sun.plugin.javascript ??????
[javac] if (c instanceof sun.plugin.javascript.JSContext)
[javac] ^
[javac] /Users/ijay/Projects/mozilla/embedding/JRex/src/java/netscape/javascript/JSObject.java:174: ?Ҳ???????
[javac] ???ţ? ?? JSContext
[javac] λ?ã? ?? netscape.javascript.JSObject
[javac] JSContext j = (JSContext) c;
[javac] ^
[javac] /Users/ijay/Projects/mozilla/embedding/JRex/src/java/netscape/javascript/JSObject.java:174: ?Ҳ???????
[javac] ???ţ? ?? JSContext
[javac] λ?ã? ?? netscape.javascript.JSObject
[javac] JSContext j = (JSContext) c;
[javac] ^
[javac] 4 ????

BUILD FAILED

检查了一下build.xml引入的JRex.properties，其中有一行内容如下：

classpath =${build};${java.home}/lib/plugin.jar;${java.home}/lib/deploy.jar;${java.home}/lib/jaws.jar

于是又挨个去找那几个jar包（其中“plugin.jar”最像），最终发现了问题：/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0/Home/lib/plugin.jar（即“${java.home}/lib/plugin.jar”）是一个符号链接，指向“/System/Library/Frameworks/JavaVM.framework/Versions/A/Resources/Deploy.bundle/Contents/Home/lib/plugin2.jar”，而plugin2.jar不存在……
把原先的符号链接删除，重建链接指向…/plugin.jar，问题解决
已向apple提交该bug

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Snow Leopard下的JDK链接有问题

java.net论坛被黑（有图有真相）

Jay — Tue, 15 Dec 2009 14:48:58 +0000

从今天中午开始java.net论坛被黑，所有标题、内容变成了“RED EYE OWNZ – by Z4i0n”，一直到现在都没恢复，Sun在干啥呢？

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: java.net论坛被黑（有图有真相）

Apache给EJB 3.1（JSR #318）投了否决票

Jay — Tue, 01 Dec 2009 16:49:51 +0000

刚才在Glassfish的Google Group上收到有关Apache在EJB 3.1 JSR表决上投了否决票的消息。过去看了一下，发现只有Apache投了否决票，Eclipse、Spring弃权，而且Apache的理由相当牛逼：

On 2009-11-30 Apache Software Foundation voted No with the following comment:
The Apache Software Foundation’s vote is based on the point of view that this spec lead – Sun – is in violation of the JSPA

http://www.apache.org/jcp/sunopenletter.html

and therefore shouldn’t be allowed to lead other JSRs until the above matter is resolved.

This vote is not a comment on the technical merits of the JSR. If not for the issue of the spec lead, the ASF would have otherwise voted “yes”.

于是又围观了一下那封公开信，不亏是Apache，邮件的口气都不一样，比如开头：

My name is Geir Magnusson Jr, and I’m the officer of the Apache Software Foundation (ASF), a 501(c)3 public charity, charged with matters relating to our participation in the Java Community Process (JCP). I am also the VP of the Apache Harmony project. In this matter I represent the ASF.

还有结尾：

We expect you to offer an acceptable, JSPA-compliant license to us within 30 days, or provide a public explanation of why you cannot do so.

继续关注EJB 3.1的相关发展……

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Apache给EJB 3.1（JSR #318）投了否决票

10 things all JAVA developers should know [zz]

Jay — Wed, 11 Nov 2009 04:06:08 +0000

原文在这里

Since JAVA (I know it’s not an acronym, but it stands out like that) was officially introduced in 1995, it has changed the way most of us look at the Operating System. Bill Gate (how ironic) once said that it was not about the hardware but the software which will be the future. A decade or more later, the fifth employee of SUN, John Gage said “The Network is the Computer”. Fast-forwarding to the 21st century and John seemed to be right. Anyway, JAVA was built not to depend on an Operating System and deployed through the network. JAVA through its applet technology gave birth to Rich Network Application aka Rich Internet Application (RIA). JAVA is not perfect; or we would not have various releases and more on the way, but JAVA has given birth to a wide range of programming language (just Google it to find out more). Without further ado, I am going to get back to subject. This is a brief
article on what I believe that every Java developers should know regardless of their experience. I do not personally believe that someone with 5 years experience is not as good as someone with 10 years experience. We all develop our own methods of working but as a developer you need to stay abreast of your technology. So, here are my top 10 not in order of importance (or?):

Remember the basic of JAVA language and OOP paradigm.Most experience developers seem to forget the theory behind the language. I am not saying that they are not good at their job but can they explain to junior developers why they have used interfaces instead of abstract classes or why implement a pattern over another one? As a programmer, you become very arrogant as you believe that you write the best code but in the real world, people work in teams with different skill set and experiences. It is important that you can backup your actions/ codes. A very simple question such as; when should I use a String object instead of a StringBuilder/ StringBuffer? You might take this question lightly but can you actually tell someone else the
difference?
Know your technology stackAll developers have to know their technology stack. What does it mean? JAVA is not like other languages; JAVA has subsets such J2ME and superset such as Java EE. We have our own area of expertise but it is important to know the differences between the various sets of JAVA. Some basic questions such as the differences between SWING, Applet,
Servlets, EJBs and JAVAFX will boost your confidence. Most developers do not know how to tweak the JVM and the differences between the JRE and the SDK environment. Do you know why you need the SDK to be installed to run Tomcat but you only need the JRE to run an application?
Experiment with various Java EE frameworkI am not asking you to be an expert in every single Java EE framework but it will make the difference if you are familiar with Spring and EJB. That should actually be the de facto framework that should be on every developers CV. Developers should know the difference between Java EE 5 (soon 6) and Spring. Hibernate is also brilliant and it’s used for data access but all developers should have moved to JPA by now. Hibernate also comply with JPA therefore there is no more excuses.
Know a scripting languageJAVA can be heavyweight for some simple tasks which can be implemented using a simple dynamic language such as Python, Perl(?) and others. I would also recommend to developers to learn shell scripting on their target OS.
Know how to develop web servicesThe network is the computer, therefore it is important to know the different web services framework available. Data are integrated through web services and opening your services to the “cloud”. SWING developers will probably not develop web services but I am sure that they will be connecting to data through web services clients. Understanding the difference between the standardised SOAP and non-standardised ReST will help you choose which is best to implement your services.
Know how and when to multithread your applicationI have to put that in there. Developers should know when and why to multithread an application, thread inter-communication and monitoring. All developers, junior or not, should know how to write a multi-threaded application.
Database development using JDBC and JPAThis should be a development law. All developers should know how to write SQL queries and how to create databases. All enterprise applications store data in some sort of relational database systems and it is therefore imperative that this knowledge should be of second nature. Java EE 5 introduced JPA (JDO was there before) but it is not
applicable to all situation. Hence, knowing the difference and when to implement one instead of the other is important.
Know a client side scripting language and what is AJAXThe network is the computer and Internet is the deployment platform. Java EE and its various framework are server side executiong which can put extra “load” on the server. If you are looking to move a cloud based system where the providers charges you per resources used, it might be wise to move some of the execution to the client side. AJAX
has been buzzing the scene for the last 3 years and more. This is not a technology but a new way of doing something that already existed. There are numerous JAVA AJAX framework such as GWT and DWR which makes it easy to develop AJAX based application which are compiled to JavaScript. Developers should also know what is the AJAX theories.
Know your competitors and do not take part on “what is the best IDE” discussionJAVA is not the only language that can do what it does. I think that JAVA is more mature and complete as opposed to other languages. Knowing the difference between JAVA and .NET or JAVA and Ruby is a good asset to have. You also need to know when and why to use one instead of the other. Please please please, do not get into “my IDE is better than x because…” discussion as it is good for the JAVA community to have multiple IDEs and framework available to use. Every tools have their place as for example JDeveloper is better than x if you are going to solely develop on an Oracle stack and etc…
Know ANT (MAVEN?), TOMCAT and any other mainstrean application serverANT is the de facto build script for JAVA and its IDE-based development. Maven is becoming popular and soon can be as popular as ANT (not sure of its popularity in the financial sector). TOMCAT should be immortalised as the based servlet container that all developers should be familiar with.

There are alot more to add but this is just some of the basics that I think all developers should have in their repertoire. Feel free to add to this list in the comments box. If I could had another one to this, would be; all developers not just JAVA, should know how to search the web and Google is your best friends (now support my advertisers by clicking on the links on the right ). I hope you enjoyed the entry and feel free to comments good or bad!!! are welcome.

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 10 things all JAVA developers should know [zz]

BlockingQueue与InterruptedException

Jay — Tue, 10 Nov 2009 05:10:00 +0000

感谢Blader同学的抛砖

首先，这段代码会编译成功吗，运行起来会有异常吗，他会打印什么？

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Foo {
public static void main(String[] args) throws InterruptedException {
BlockingQueue q = new LinkedBlockingQueue();
q.put(1);
Thread.currentThread().interrupt();
System.out.println(q.take());
}
}

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Foo {
   public static void main(String[] args) throws InterruptedException {
       BlockingQueue q = new LinkedBlockingQueue();
       q.put(1);
       Thread.currentThread().interrupt();
       System.out.println(q.take());
   }
}

运行后结果如下：

Exception in thread "main" java.lang.InterruptedException
at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1135)
at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:312)
at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:354)
at Foo.main(Foo.java:9)

Exception in thread "main" java.lang.InterruptedException
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1135)
	at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:312)
	at java.util.concurrent.LinkedBlockingQueue.take(LinkedBlockingQueue.java:354)
	at Foo.main(Foo.java:9)

看了一下源代码，阻塞队列的访问方法（take、put、poll、offer）会在执行之前检查Lock对象的中断标记，而Lock对象则是检查当前线程的中断标记

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: BlockingQueue与InterruptedException

Which GlassFish version is right for me? [zz]

Jay — Fri, 17 Jul 2009 17:57:55 +0000

GlassFish has several versions that you may have heard of. Each one attempts to address different needs. I’ve had several people in the last couple of weeks ask me which one they should use, so here’s a quick list of features and reasons to use one more than the other.

• GlassFish v2.1: current JavaEE 5-certified and supported product. Offers centralized admin, clustering. v2.0 was released in September 2007 and v2.1 in March 2009 with the Enterprise Manager value add. All major IDE’s (NetBeans, Eclipse, IntelliJ) have plugins to deploy to this version. GlassFish v2.1 update 3 is the latest version available for supported customers.

• GlassFish v3 Prelude: interesting if you want a lightweight Java EE 5 web container (no EJB, JMS, etc…) with admin tools. This is the first release using the modular OSGi architecture, IPS packaging format, and developer features such as preserve session across redeployments. This was released in November 2008 and is a supported product (although not a long-lived as traditional software at Sun). It also offers native deployment of Grails and Rails applications. Some people use this version in development and deploy to v2.1.

• GlassFish v3 Preview: while not yet a supported product, this is a more recent version building on the same foundation as the above “Prelude” version, only it now offers both a Web distribution and a full Java EE 6 (Preview) distribution. It has a number of improvements over the “Prelude” version (IPS and updatetool for instance) and certainly much closer to a fully-featured application server. The final version should ship in September 2009 and offer a JavaEE 6, single-instance architecture. At that point this will become a supported product. The centralized administration will come in the v3.1 release which will mean feature parity with v2.1. If you like bleeding edge stuff, promoted builds for v3 are here.

For more details on the releases, including sustaining (restricted) releases, please visit http://blogs.sun.com/GlassFishForBusiness/

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Which GlassFish version is right for me? [zz]

Sun 卖了……

Jay — Mon, 20 Apr 2009 14:06:15 +0000

刚刚得到的消息，Oracle收购了Sun，9.5刀一股，一共74亿

这里是Oracle的官方声明
这里是Sun的声明
这里是一篇国外新闻

接下来的时间就看Sun和Oracle的重复部分如何整合（或者舍弃）了

MySQL VS Oracle DB
GlassFish VS WebLogic（不知道之前为什么买了BEA）
JDK VS JRockit
JDeveloper VS Netbeans
红色 VS 蓝色

关注中……

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Sun 卖了……

遍历Map>的正确方法

Jay — Tue, 24 Mar 2009 14:10:24 +0000

对于value为集合的map，一般直觉上我们可能会选用下面的方式遍历map中所有collection的所有对象：

for(K key:map.keySet()){
    for(V value:map.get(key)){
        // do sth.
    }
}

实际上，这种方式在第二行上会因为对哈希表的查询浪费效率，正确的做法应该这样：

for(List<v> list:map.values()){
for(V o:list){
// do sth.
}
}

for(List list:map.values()){
    for(V o:list){
        // do sth.
    }
}

或者

for(Map.Entry<k,List<v>> entry:map.entrySet()){
for(V o:entry.getValue()){
// do sth.
}
}

for(Map.Entry> entry:map.entrySet()){
    for(V o:entry.getValue()){
        // do sth.
    }
}

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 遍历Map>的正确方法

慎用LinkedXxxx集合

Jay — Thu, 05 Mar 2009 08:58:00 +0000

这两天发现项目中有个模块有内存泄露，512 MB的堆内存大概在5个小时左右被耗尽。通过NB的profiler跟踪可以看到如下结果：
java.util.concurrent.LinkedBlockingQueue.Node对象尽然占了一多半。在实时profile中发现即使限定了list的capacity并且在不断调用take方法（相当于remove）时，Node的alive object数量仍在不断增长（照理说在某个时间节点后alive object数量应该增长得很缓慢，因为take的Node对象会被GC）。将LinkedBlockingQueue换成ArrayBlockingQueue后问题解决。继而发现LinkedList有同样的问题，于是得出结论：

LinkedXxxx集合的remove、take，甚至clear方法不会导致被挪出队列的node马上被标记为可GC，可能会经过一个很长的时间（generation数量相当大）
由1推测LinkedXxxx的实现可能有内存泄露，或者JVM的GC算法可能有缺陷
由1、2得出经验：在集合内容需要做频繁替换（不断add/remove或者put/take）且程序运行时间很长的情况下最好不要使用LinkedXxxx，应该用ArrayXxxx替代并且指定capacity

补：感谢blader的补充，这个问题果然是个bug：http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6460501

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 慎用LinkedXxxx集合

Java RMI中的NoSuchObjectException

Jay — Mon, 02 Mar 2009 03:08:17 +0000

最近项目里的RMI在Linux下运行老出问题，而且问题出得还很不稳定。那个程序启动时会分别在4个端口上绑定4个相同的对象，结果就是有时绑定成功3个，有时候才1个……查看log，抛出下面异常

java.rmi.NoSuchObjectException: no such object in table

上网搜了一下，这篇文章给出了原因和解决方法：我在代码中做RMI绑定的时候用的是局部变量：

registry.rebind(name, UnicastRemoteObject.exportObject(new RemoteObject(), 0));

registry.rebind(name, UnicastRemoteObject.exportObject(new RemoteObject(), 0));

该局部变量在服务器端被GC后客户端再远程调用方法便会抛出上述异常。解决方法很简单，使用对远程对象的强引用以防止对象被GC，比如把局部引用改为类静态引用

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Java RMI中的NoSuchObjectException

在Tomcat 6中使用log4j

Jay — Tue, 20 Jan 2009 04:15:00 +0000

Tomcat 6之前，在web应用中使用log4j还算容易，只要将log4j的jar包和相应的配置文件扔到项目的class path就齐活了。但是从6开始，一切变得如此复杂……
根据Tomcat 6 的官方文档，默认tomcat用的是JDK的logging框架，并配以“精简版”的common logging框架，即不支持common logging的底层框架自动切换功能，要使用log4j也就不可能了。要使用上述功能，需要使用“完整版”的common logging，而这个完整版的jar包apache上不提供下载，需要“自己编译tomcat代码”-_-|||，具体步骤如下：

当然，你必须得有JDK、ant、SVN（如果你直接下载源代码包，可以不需要SVN）
从http://svn.apache.org/repos/asf/tomcat/tc6.0.x/ check out代码
执行ant download
执行ant（这里提一句，源代码的编码为utf8，直接编译的话会扔一堆warning，只要改一下ant脚本里的javac task就好了，加上encoding=”utf8″）
执行ant -f extras.xml
将output/extras/tomcat-juli.jar覆盖到tomcat的bin目录下
将output/extras/tomcat-juli-adapters.jar拷到tomcat的lib目录下
在lib目录下写tomcat的全局log4j配置
在你的web项目中放入log4j.jar和log4j.properties(.xml)

附：
tomcat-juli.jar
tomcat-juli-adapters.jar
使用utf8编译的build.xml

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 在Tomcat 6中使用log4j

让Struts 2性能提升一个数量级的的5个步骤 [zz]

Jay — Tue, 06 Jan 2009 02:55:48 +0000

原文：http://dev.yingzhitech.com/2009/01/06/96

freemarker 升级为2.3.14
ognl 升级为 2.7.3（要附加javassis类库）
根包下增加freemarker.properties文件，内容为template_update_delay=60000
struts.xml增加和
把struts.xml中的默认拦截器定义为basicStack：
1. name="web" extends="tiles-default">
2. name="basicStack" />
3. >
```
    
```

执行了这几步之后，网站性能从5 req/s提升至70 req/s，请求处理时间从22s/req缩减至2s/req！
参考连接：
http://struts.apache.org/2.x/docs/performance-tuning.html
http://www.blogjava.net/usherlight/archive/2008/07/01/211869.html
http://www.blogjava.net/usherlight/archive/2008/07/12/214462.html
http://www.blogjava.net/usherlight/archive/2008/09/02/226501.html

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 让Struts 2性能提升一个数量级的的5个步骤 [zz]

如何使用J2D将一张图片灰度化

Jay — Wed, 10 Dec 2008 07:23:37 +0000

可使用以下代码：

Graphics2D g2d = source.createGraphics();
ColorSpace grayCS = ColorSpace.getInstance(ColorSpace.CS_GRAY);
ColorConvertOp colorConvertOp = new ColorConvertOp(grayCS, g2d.getRenderingHints());
colorConvertOp.filter(source, source);

Graphics2D g2d = source.createGraphics();

ColorSpace grayCS = ColorSpace.getInstance(ColorSpace.CS_GRAY);
ColorConvertOp colorConvertOp = new ColorConvertOp(grayCS, g2d.getRenderingHints());
colorConvertOp.filter(source, source);

其中source为BufferedImage对象

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何使用J2D将一张图片灰度化

How To Enable Anti-Aliased Globally Since JDK 5

Jay — Tue, 25 Nov 2008 09:51:56 +0000

I just read “Swing Hacks” and find it is that easy to enable anti-aliased since JDK 5. Just add a one-line code listed below at the very beginning of your whole application

System.setProperty("swing.aatext", "true");

System.setProperty("swing.aatext", "true");

That’s all

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: How To Enable Anti-Aliased Globally Since JDK 5

JFreeChart中的TimeSeries可能导致内存泄露

Jay — Tue, 25 Nov 2008 06:40:01 +0000

前段时间说到现在的项目里在用JFreeChart。昨天晚上走之前没把客户端关掉，今天中午到公司发现程序已经崩了，狂抛OutOfMemoryError。用NB的profiler跟了一下，发现是JFreeChart或者说是没有正确使用JFreeChart的TimeSeries导致的后果
TimeSeries有一个方法setMaximumItemAge：

public void setMaximumItemAge(long periods)

public void setMaximumItemAge(long periods)

该方法文档如下：

Sets the number of time units in the ‘history’ for the series. This provides one mechanism for automatically dropping old data from the time series. For example, if a series contains daily data, you might set the history count to 30. Then, when you add a new data item, all data items more than 30 days older than the latest value are automatically dropped from the series.

Parameters:

periods – the number of time periods.

maximumItemAge的默认值为Long.MAX_VALUE，因此如果不设置该值的话在可预见的未来过期数据将不会被丢弃，这样会导致TimeSeries的数据越来越大，尤其是在设置axis.setAutoRange(true);和axis.setFixedAutoRange(DATA_AGE);后（将横轴设为固定长度，图表只容纳限定数目个点，视觉上就是数据从右边“推入”图表，从左侧被“推出”）。虽然视觉上数据只有那么一点，但是从图表上消失的“旧”数据并没有从series里清除，导致最终的内存不足

未使用setMaximumItemAge的堆分布，才2分钟就开始深度GC，且堆大小已经开始扩大

未使用setMaximumItemAge的对象年龄（代），曲线很陡，说明很多对象没有被回收

使用setMaximumItemAge的堆分布，堆内存占用比较缓慢，堆大小未扩大，未进行深度GC

使用setMaximumItemAge的对象年龄（代），数值很高，是因为还没有进行深度GC的原因

在此提醒正在使用JFreeChart尤其是TimeSeries的给位，千万记得设置maximumItemAge

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: JFreeChart中的TimeSeries可能导致内存泄露

JFreeChart Developer Guide

Jay — Sat, 15 Nov 2008 13:09:53 +0000

互联网很强大，Google很强大

JFreeChart是个很强大的Java作图库，真的很强大，强大得不看文档都不知道该怎么用……JFC虽然遵循LGPL但文档是收费的，个人版45刀一份。刚才google了一下，找到一本1.0.4的PDF（最新为1.0.11），直接挂这里有点嚣张，谁要的给我mail

更新：到这儿下载吧~~

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: JFreeChart Developer Guide

如何cancel一个swing worker（续）

Jay — Fri, 14 Nov 2008 15:35:19 +0000

上一次谈到如何去cancel一个swing worker，今天在代码里又出了问题：即使使用swingWorker.cancel(true)仍然无法在sleep时中止线程。追了一下代码，最后在javax.swing.ImageIcon类里找到了原因：

protected void loadImage(Image image) {
    synchronized(tracker) {
        int id = getNextID();

        tracker.addImage(image, id);
	try {
	    tracker.waitForID(id, 0);
	} catch (InterruptedException e) {
	    System.out.println("INTERRUPTED while loading Image");
	}
        loadStatus = tracker.statusID(id, false);
	tracker.removeImage(image, id);

        width = image.getWidth(imageObserver);
	height = image.getHeight(imageObserver);
    }
}

其中第7行会抛出InterruptedException，而在第10行捕捉了该异常，导致InterruptedException无法抛到我的代码里。很典型的“eat-up exception”的例子。解决该问题可以在初始化ImageIcon前sleep一下，比如sleep(5)，让interrupted状态在sleep中触发InterruptedException

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何cancel一个swing worker（续）

JGraph中的deselect状态判断

Jay — Fri, 14 Nov 2008 10:30:49 +0000

JGraph是基于Java swing、Java 2D开发的纯Java图形库，很像Eclipse的EMF、JMF，可以很方便地帮助开发人员在Swing框架中实现组件的呈现、布局、拖拽、group等图形化操作。JGraph也是基于MVC模式实现，将整个框架分为cell（M层）、cell view（C层）和renderer（V层）。有一些设计思想很有趣，比如它的GraphConstants，将所有属性存在传入的map里，通过方法签名实现属性的意义化和类型限制，很有趣的思想
下面进入正题，如何判断一个cell view被deselect。JGraph现在已半商业化，文档很稀少，JavaDoc更是不堪入目，最好的研究方法还是读源代码，比如前两天为了正确设置cell view的虚线边框颜色就看了一晚上源代码
JGraph的事件监听写得很诡异，在cell view中需要通过以下方法添加监听器：

class MyCellView extends VertexView {
public CellHandle getHandle(GraphContext context) {
return new CellHandle(){
void paint(Graphics g);
void overlay(Graphics g);
void mouseMoved(MouseEvent event);
void mousePressed(MouseEvent event);
void mouseDragged(MouseEvent event);
void mouseReleased(MouseEvent event);
};
}
}

class MyCellView extends VertexView {
    public CellHandle getHandle(GraphContext context) {
        return new CellHandle(){
            void paint(Graphics g);

            void overlay(Graphics g);

            void mouseMoved(MouseEvent event);

            void mousePressed(MouseEvent event);

            void mouseDragged(MouseEvent event);

            void mouseReleased(MouseEvent event);
        };
    }
}

你可以通过JGraph对象的getSelectionCell()或getSelectionCells()获得被选中的cell，但是有一个问题，就是当你单击空白区域以取消选择一个cell view时，该方法依然返回非空的最后选择的对象。于是尝试从MouseEvent获得点击时鼠标的X、Y坐标，并调用getFirstCellForLocation(double x, double y)获得鼠标位置的cell（没有则返回null）。但这样还是有问题，当你通过框选选择一个（或若干个）cell时，getFirstCellForLocation(double x, double y)返回的对象取决于你实现的方法（是press、drag还是release）。最后，在通读了一下JGraph的JavaDoc后，发现可以使用如下方法解决这个问题：

graph.getSelectionModel().addGraphSelectionListener(new GraphSelectionListener() {
    public void valueChanged(GraphSelectionEvent e) {
        MachineCell[] cell = null;

        if (e.isAddedCell()) { // selected
            cell = new MachineCell[]{(MachineCell) e.getCell()};
        } else {
            cell = new MachineCell[0];
        }

        for (ActionListener l : listeners) {
            l.actionPerformed(new ActionEvent(cell, 0, ""));
        }
    }
});

其中第五行的isAddedCell()方法签名如下：

isAddedCell

public boolean <strong>isAddedCellstrong>()

public boolean isAddedCell()

Returns true if the first cell has been added to the selection, a return value of false means the first cell has been removed from the selection.

Returns:: whether or not the first cell has been added or removed

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: JGraph中的deselect状态判断

小心Derby的ResultSet陷阱

Jay — Sun, 09 Nov 2008 09:19:21 +0000

Derby作为一个纯Java实现的嵌入式DB一直很受Java社区的欢迎，在我们的项目中也用到了。但昨天晚上遇到的一个问题让我对Derby相当失望——Derby实现的ResultSet会将列名中的表名抹掉
具体代码：
SQL：

SELECT staff.staffid FROM staff WHERE ...

JDBC：

ResultSet rs = stmt.executeQuery(...);
if(rs.next()){
String id = rs.getString("staff.id");
}

ResultSet rs = stmt.executeQuery(...);
if(rs.next()){
    String id = rs.getString("staff.id");
}

运行时抛出异常：

Caused by: java.sql.SQLException: 列“staff.staffid”未找到。
at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.Util.newEmbedSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.Util.newEmbedSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.EmbedConnection.newSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.ConnectionChild.newSQLException(Unknown Source)
at org.apache.derby.impl.jdbc.EmbedResultSet.findColumnName(Unknown Source)
at org.apache.derby.impl.jdbc.EmbedResultSet.getString(Unknown Source)

Caused by: java.sql.SQLException: 列“staff.staffid”未找到。
	at org.apache.derby.impl.jdbc.SQLExceptionFactory.getSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.Util.newEmbedSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.Util.newEmbedSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.Util.generateCsSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.EmbedConnection.newSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.ConnectionChild.newSQLException(Unknown Source)
	at org.apache.derby.impl.jdbc.EmbedResultSet.findColumnName(Unknown Source)
	at org.apache.derby.impl.jdbc.EmbedResultSet.getString(Unknown Source)

如果将select语句中的“staff.staffid”改成“staffid”则不会抛出上述异常。在项目中为了保持数量庞大的SQL语句的正确性和可维护性，一般会将表名、列名定义为常量。这样对于Derby数据库就需要一套特殊的、不带表名的列名常量，给代码维护带来很大的麻烦。不知道Sun将Derby这样实现的原因是什么，这个功能点的实现也不是很麻烦，打算去提交bug

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 小心Derby的ResultSet陷阱

如何使用反射调用静态方法

Jay — Sun, 09 Nov 2008 09:04:55 +0000

其实很简单，真的，将invoke(Object o, Object… params)的第一个参数传入null即可

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何使用反射调用静态方法

如何cancel一个swingworker

Jay — Thu, 30 Oct 2008 08:04:37 +0000

最近在项目里一直在用jdesktop的swingworker（已经合入JDK 6），是个不错的swing线程库。今天需要在界面里cancel一个swingworker。研究了一下午，结合swingworker的文档、源代码和自己的代码实验，以下是两种安全cancel一个swingworker的方法

方法一，使用isCancelled：

protected Object doInBackground() throws Exception {
while (!isCancelled()) {
...
}
return null;
}

protected Object doInBackground() throws Exception {
    while (!isCancelled()) {
       ...
    }

    return null;
}

需要cencel时调用swingworker.cancel(false)，不中断线程，只置cancel标记。

方法二，使用sleep：

protected Object doInBackground() throws Exception {
while (running) {
...
sleep(30);
}
return null;
}

protected Object doInBackground() throws Exception {
    while (running) {
        ...
        sleep(30);
    }

    return null;
}

需要cencel时调用swingworker.cancel(true)，在sleep处中断线程。切记，不需要捕捉sleep抛出的InterruptedException，swingworker会处理该异常。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何cancel一个swingworker

JScrollBar的unitIncrement和blockIncrement

Jay — Wed, 08 Oct 2008 17:38:46 +0000

这两天在写swing的时候遇到一个问题，JScrollPane在相应鼠标滚轮的时候很慢，滚了一大段才移了一点点，给人的感觉就是鼠标很“硬”。刚才查了一下javadoc，看到JScrollbar有个方法：setUnitIncrement(int) 和 setBlockIncrement(int)。前一个是设置点击上下箭头的移动距离（也包括滚轮滚动），后一个是单击滚动条上空白处的移动距离，单位为像素。输出了一下unitIncrement的默认值，竟然是1 -_-|||。手动设为10，感觉鼠标终于灵活了……具体代码：

jScrollPane.getVerticalScrollBar().setUnitIncrement(10);

jScrollPane.getVerticalScrollBar().setUnitIncrement(10);

如果遇到和我相同问题的可以用上面的方法试一下。有点不爽的就是没有一个类似UIManager的全局变量可以设置，只能在各个JScrollBar上单独设置，有点麻烦。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: JScrollBar的unitIncrement和blockIncrement

如何在Java的enum中使用annotation

Jay — Mon, 22 Sep 2008 15:14:59 +0000

刚才在写一个方法的时候试图在enum上使用annotation：

public enum DataKey {
@Incremental
@FromProbe
@Transient(replacePolicy = ReplacePlolicy.REPLACE_IF_LATER_THAN)
VISIT_COUNT
}

public enum DataKey {
    @Incremental
    @FromProbe
    @Transient(replacePolicy = ReplacePlolicy.REPLACE_IF_LATER_THAN)
    VISIT_COUNT
}

然后在merge的时候使用annotation：

if (key.getClass().isAnnotationPresent(Transient.class)) {
...
}

if (key.getClass().isAnnotationPresent(Transient.class)) {
    ...
}

结果不进if，debug时发现key（DataKey的对象）的类型是DataKey（其实也挺顺理成章的），于是使用如下代码：

if (DataKey.class.getField(key.name()).isAnnotationPresent(Transient.class)) {
...
}

if (DataKey.class.getField(key.name()).isAnnotationPresent(Transient.class)) {
    ...
}

结果正确。
结论：在对enum类型使用FIELD一级annotation时需要使用第二种方法进行反射

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 如何在Java的enum中使用annotation

Deskzilla Cracked

Jay — Tue, 06 May 2008 16:32:20 +0000

最近破解上瘾了，昨天干到3点多，今天又花了一中午把deskzilla，一个bugzilla的桌面客户端）破解了。

这次破解花了很长时间，一是因为代码编译后被混淆了，找关键代码的时候着实花了不少时间。另一方面这个软件的license验证不是使用常见的布尔判断，而是用异常。这意味着必须仔细研究方法的调用栈，于是这次用了一个比较偷巧的方法：在代码中抛出并捕捉异常。在Java中，无论在代码何处抛出异常，JVM都会生成一个从程序入口到抛出异常方法的调用栈，这个机制在需要调用关系的场合非常有用，比如log4j，就是使用这种机制记录log的方法、行数、类名等等信息的。但是，这种机制是非常消耗资源的，因为调用栈里的每一个element都记录着方法、类、甚至行数（如果编译时打开“debug”开关）等信息，而这些信息都是通过反射机制从class文件里直接获得的。

通过对一堆类似huv、dww、dtg、gjt的混淆后的类的分析，终于找出了几个关键类：

package z;

public class dza extends hwn {

    // ...

    static  {
        l = epv.a("Application.License.FULL", "Single-user license");
        m = epv.a("Application.License.EVAL", "Evaluation license");
        n = epv.a("Application.License.EAP", "EAP license");
        o = epv.a("Application.License.OS", "License for open-source projects");
        p = epv.a("Application.License.INVALID", "License is INVALID");
        r = epv.a("Application.License.FLOATING", "Floating license");
        s = epv.a("Application.License.PERSONAL", "Personal license");
        t = epv.a("Application.License.ACADEMIC", "Academic license");
        u = epv.a("Application.License.SITE", "Site license");
        a = new dza("FULL", l);
        b = new dza("PERSONAL", s);
        c = new dza("FLOATING", r);
        d = new dza("ACADEMIC", t);
        e = new dza("SITE", u);
        f = new dza("OS", o);
        g = new dza("EAP", n);
        h = new dza("KLEVAL", m);
        i = new dza("EVAL", m);
        j = new dza("INVALID", p);
    }

    // ...
}

可以看出这是定义license类型的类

package z;

public class aef extends hwn {
    // ...

    public static final aef a = new gdo("UserName");
    public static final aef b = new gdo("UserCompany");
    public static final aef c = new fsf("CustomerID");
    public static final aef d = new fir("ExpirationDate");
    public static final aef e = new aef("LicenseType", dza.class);
    public static final aef f = new gdo("AdditionalInfo");
    public static final aef g = new fsf("MinBuild");
    public static final aef h = new fsf("MaxBuild");
    public static final aef i = new fsf("MaxLeaseCount");
    public static final aef m = new fsf("R");
    public static final Date j = new Date(0L);
    public static final Date k = new Date(1L);

    // ...
}

这个类定义了需要验证哪些内容，最后关键类的关键代码：

package z;

public class huv implements cud {
    // ...

    public String a(aef aef1) {
        String s;

        if (aef1 == aef.d) {
            Date time = new Date(System.currentTimeMillis() + 24 * 60 * 60 * 1000);
            Calendar cal = Calendar.getInstance();
            cal.setTime(time);
            int year = cal.get(Calendar.YEAR);
            int month = cal.get(Calendar.MONTH) + 1;
            int day = cal.get(Calendar.DAY_OF_MONTH);

            s = "" + year;
            if (month < 10) {
                s += ("0" + month);
            }
            if (day < 10) {
                s += ("0" + day);
            }
        } else if (aef1 == aef.b) {
            s = "Nazca";
        } else if (aef1 == aef.f) {
            s = "to memorize my Macbook...";
        } else if (aef1 == aef.e) {
            return dza.a.h();
        } else if (aef1 == aef.a) {
            return "Cracked by Jay";
        } else if (aef1 == aef.i) {
            return "20";
        } else if (aef1 == aef.c) {
            return "1";
        } else {
            s = "";
        }

        return s;
    }

    // ...
}

可以看出过期时间定为当前时间的后一天，这样就永远不会过期了。最后编译，打包，替换原先的jar包，就行了。

最后提一句，破解时选择切入点非常重要。比如这次，我选择的切入点是相当靠后的，仅仅在字符串被送入验证方法之前。如果切入点再往前的话会很麻烦，因为看了一下代码，deskzilla的license是一个经3DES加密的XML文件，XML还需要用MD5校验，如果切入点是生成XML文件，那我还得搞到3DES的密钥，以及保证MD5验证通过。所谓打蛇打七寸，选对了切入点，往往有事半功倍的效果。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Deskzilla Cracked

Synthetica破解

Jay — Mon, 17 Mar 2008 02:29:34 +0000

话说前段时间提到把Synthetica给破了，而网上关于破解的文章很少，所以今天就详细说说我是怎么破的。

准备知识

Synthetica是一套很漂亮的Java的look & feel，大家可以去主页上跑一下demo（JWS的，需要安装JRE）。可惜是commercial的，虽然有评估版下载，但是恶心的是，在评估版界面的最下方会有一块多余的区域（下图）

那这次破解的目的就是把这块区域给去了。

就我这几次破解来看，破解主要分以下几个步骤：
1. 反编译
2. 找关键代码（比如序列号校验算法）
3. 修改源代码
4. 编译打包

其中第1步是前提，在这点上Java的byte code的反编译是比较容易的了，因为毕竟是中间码，而且编译期采取的优化手段不多，反编译过来的基本就是源码。这里推荐DJ Compiler，一个相当老牌的Java反编译器。值得注意的是并不是所有的byte code都能顺利反编译，有些Java程序会使用所谓的“混淆”技术对编译后的代码就行破坏，混淆器一般采用以下方法破坏代码：
1. 不可反编译。这点其实基本不可能
2. 反编译后代码不可读。这点相当恶心，混淆器会把类名、方法名、字段名替换成没有意义的名字，当你打开编辑器放眼望去全是“class A”，“int _fld00043”，“void _mhd2314”的时候你就知道该有多痛苦了
3. 插入不可编译代码。这一点也比较恶心，说穿了就是直接修改byte code中的指令，使用合法的，但不可能从源代码编译到的指令替代原有的指令（比较拗口），比如使用“goto”替代循环。这样你的代码即使可以反编译成源代码但只能看不能改，除非你把goto再替换回去

这次Syn并没有使用混淆，所以用DJ很轻易地就反编了，接下来的活就是怎么找关键代码。一开始我以为评估版输入序列号校验成功后就升级成商业版，于是在那儿找了半天序列号的校验方法，没找到。后来凯子提供一条线索，Syn的商业版是要重新下的，于是猜测评估版和商业版不是一个版本（有时候破解也是要点推理的：-）），估计不会校验注册码。于是改变方向找加那一行字的代码，最后找到了：

public void paintBorder(Component component, Graphics g, int j, int k, int l, int i1){
...
g.setColor(UIManager.getColor("Panel.background"));
g.fillRect(j, i1, l, i1 + 16);
g.setColor(new Color(0xcc0000));
g.setFont(g.getFont().deriveFont(10F));
g.drawString("Synthetica - Unregistered Evaluation Copy!", 0, k + i1 + g.getFontMetrics().getAscent());
...
}

public void paintBorder(Component component, Graphics g, int j, int k, int l, int i1){
    ...
    g.setColor(UIManager.getColor("Panel.background"));
    g.fillRect(j, i1, l, i1 + 16);
    g.setColor(new Color(0xcc0000));
    g.setFont(g.getFont().deriveFont(10F));
    g.drawString("Synthetica - Unregistered Evaluation Copy!", 0, k + i1 + g.getFontMetrics().getAscent());
    ...
}

可以看出来它是通过Java 2D直接绘上去的，所以把这几句注了，编译，打包，就ok了，最终结果：

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Synthetica破解

思路有点乱，只想说

Jay — Sun, 15 Jul 2007 16:35:00 +0000

五年前，我是混进大学生队伍的痞子，在北京四年的摸爬滚打充分发掘出了我血液里山东人的那一份血气。一年前，我成了混入IT界的痞子，从此以code表达我的立场。那天强子开玩笑说如果当年方圆、老四他们软工挂科是在拍惊悚片的话，我们现在拍的就是毛片，别人看着很爽，coding的时候自己知道，委曲求全在心里。如果可以用Java我绝不会去用C++，如果可以用Swing我绝对不会选SWT，有netbeans这么好的IDE摆在那儿为什么还要用Eclipse这么一个操蛋玩意儿，有SVN了为什么还要用CVS，有Firefox为什么还要用IE，有thunder bird为什么还要用outlook，有搜狗为什么还要用微软拼音……

Eclipse代码看得越多越想骂街，才发现原来IBM里也有傻逼。累了，睡，明天还要上班。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 思路有点乱，只想说

相当随的笔

Jay — Fri, 08 Jun 2007 15:33:00 +0000

1. 今天一天基本没干其它事，一共面了5个人，虚脱了。要是技术强点的我还能忍受，妈的来了几个一问三不知的，他妈来面试干嘛啊！

2. SWT是傻逼，JFace是傻逼，Eclipse的RCP是傻逼，IBM是傻逼。写出来的东西文档巨少，没有OO概念，一堆整数常量（有时候还得对整数做逻辑与操作），一堆全局变量（虽然用方法调用封装），我现在一看ResourcePlugin.getWorkspace().getActiveWorkspaceWindow().getActivePage().getShell()就想抽丫挺的。还有就是一个IResource接口（和子接口）定义了二三十个方法，要自己实现基本没戏，然后还很贱地给了一堆实现类，像File（实现IFile），Project（实现IProject），却把实现类放在internal包下面（Eclipse的inernal包不推荐二次开发人员使用）。更贱的是一些方法的参数直接要实现类，拿到接口还得做向下转型。妈的IBM那帮人脑子进水了啊，你不会用类继承啊，不懂OO就别他妈在那儿装逼，回去写你的C去吧，别在这儿糟贱Java！

3. 北京的司机开车就他妈不知道谦让啊，今天晚上9点多打车到五道口，王庄路那个十字路口都堵上了四面八方的车还往里拥，你们他妈都急着投胎啊，幸亏的哥不错，让我下车，要不我现在还在车上呢！

4. Bootcamp 1.3 beta 发布了，正在下，不知道改进了什么，估计又是升级Windows下的驱动，玩Mac的朋友可以更新一下。Bootcamp一次比一次大，这次已经到280M了。Leopard快出来啊，iPhone快出来啊。

5. 上周末韬子回北京，跟丫爽了一把，喝完啤酒还去Pepper干了半瓶伏特加，虽然期间吐了几次，第二天胃也烧得慌，但难得一次，相当尽兴。强子的胃彻底废了，前车之鉴啊，要限酒了。

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 相当随的笔

中文编程语言？

Jay — Thu, 26 Apr 2007 15:49:00 +0000

大四的时候跟方圆和强子在阳台抽烟的时候突发奇想，想搞一个中文的编程语言，再仔细一琢磨，词法分析，语法分析上一点问题都没有，只是把标识符换成中文字符而已，但是真要写出来的话会比较诡异，恐怕广大灰领们短时间内接受不了（高亮为关键字）：

包包一;
导入爪哇.语言.系统.所有;
公有类类一继承类二实现接口三 {
公有静态无返回值主(字符串数组数组一) 会抛异常一 {
对于 (整型啊等于 0;啊小于 100;啊连加) {
若(数组一.长恒等 1) {
系统.输出.打印("你好");
} 否则 {
扔新异常一("参数过短");
}
}
}
}

包 包一;
导入 爪哇.语言.系统.所有;

公有 类 类一 继承 类二 实现 接口三 {
    公有 静态 无返回值 主(字符串 数组 数组一) 会抛 异常一 {
         对于 (整型 啊 等于 0;啊 小于 100;啊 连加) {
             若(数组一.长 恒等 1) {
                 系统.输出.打印("你好");
             } 否则 {
                 扔 新 异常一("参数过短");
             }
         }
    }
}

p.s. 现在javac已经开源了，有兴趣的同学只要自己定一套关键字，然后修改词法分析部分就行了。要真搞出这么一个东西别忘了把我放在鸣谢里哈：）

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 中文编程语言？

我是谁？（一）

Jay — Tue, 06 Feb 2007 17:05:00 +0000

本命年了，大学毕业了，工作了半年多了，在北京混了4年多了，天南海北的交了一帮朋友了。不知道他们是怎么看我，可能很多人其实并不了解我。这样吧，从今天开始自我审视一下，看一下或者说向各位展示一下我到底是个什么样的人。诸位看官，有空的评论一下，让我大概了解一下我在别人眼里的形象。大家是愿意评啊，是愿意评啊，是愿意评啊？

初中开始受韩寒的影响（他应该算是我的同龄人吧，当时只知道哥们儿挺牛逼，门门挂红灯却把当时半拉上海市尤其是所谓的“教育界”折腾得鸡犬不宁，天天研究“韩寒现象”），文章比较愤，看不惯的就开骂。当然了，当时骂得算是相当文明的，一是年纪太小，而且光在上海待着，粗口知道得不多，二是作文都是要交的，我还没到韩寒这么不要命的地步，不太敢得罪老师。如果照现在的情况，再写文章恐怕是粗口满篇，而且还都是京片子，搞不好生殖器都得扯上几个。后来到了大学发现这个性格并不是传说中的“青春期叛逆心理”，并没有随着青春期的结束而终止（或者说我现在还在发育期？），反而似乎有愈演愈烈之势。记忆中印象较深的在大学四年当面骂过三个人，其中两个老师，还有一个是老八。

第一个是张茂林（既然老师当到这个份上就不用留面子了），大一上的时候教计算机导论。因为那是大一唯一一门专业课，而且教材是全英文，所以预习得比较认真，天天在宿舍抱着字典啃。顺便插一句，在宿舍看书的时候发现其它省市的计算机普及教育做得太次了。虽然也是第一次看英文得计算机教材，但是很多词一查字典就能和脑子里的中文概念对起来，比如stack和list，buble sort和quick sort。而那帮哥们儿则查了字典只能知道字面意思。于是后来在宿舍里我开始给他们讲一些“计算机概论”。上课前原以为那门课应该很有趣，因为书里涵盖的范围相当广，从硬件到数据结构到算法到操作系统，心里想着就算用中文讲也应该获益匪浅。结果那门课让那个姓张的活活的给教成了英文课，每堂课的内容都是从书里摘出几段，然后翻译成中文讲一遍。于是再上课我都是带着walkman去的（大一年纪太轻，还不知道翘课）。有一节课我带着耳机在看书，在两首歌的间歇听见了那孙子在讲编程语言类型，有一种是“declarative language”，生生让丫译成了“宣告型语言”，于是我当时就骂了一句“我操，什么叫宣告型语言啊”。可能大家都有经验，一般听歌的时候说话会比较大声，结果整个班的同学顺着声音朝我投来了景仰的目光。当然了，大家景仰的是我当堂“我操”，而不是我指出了他的错误。我抬头看了丫一眼，结果孙子什么反应都没有，继续讲课……

第二个是刘超，现在好像是北航软件所的所长。他讲的是OO，大家可以在我的博客上找一下，2005年3月份我应该专门写过一篇博客，全文如下（http://scjp.spaces.live.com/blog/cns!8B55061AA378FE77!193.entry）：

程序员的信仰……不要误人子弟

这个学期大三（下），终于到了“熬出头”日子，因为全部是专业课，不用再上什么大物啊、数电啊、模电啊这些我一看了课表就想吐的课程，而且还有很多专业选修课可以上，再有就是我们学院的开课老师都挺有名气，像上操作系统的任爱华，上个人软件过程的吴超英……。

一拿到专业选修课的课表，我立马把“面向对象技术”列在选择范围之内，道理很简单，因为Java。第一节课，那老师看上去有快50的年纪，上得还算中规中矩，介绍了一下面向对象技术的历史。但从第二节课开始，他介绍Java基本知识，我的恶梦也开始了……

首先是类型介绍，他赫然把String和int、double一起作为Java的类型来介绍。然后，他竟然自做主张地把System类划分到了java.io包下，范例程序中每次从标准输出打印时都要import一下io包。在讲布尔类型时他的幻灯片里还出现了“!”（非操作）这样的语法。今天的课上，他把override译成了“重构”，还在Java的collention框架里添加了一个“dictionary”，结果听他一讲原来是map！还有其它的一些错误比如混用“boolean”和“Boolean”、“String”和“string”、“＝”和“＝＝”，真不知道他是不是科班出身。

前些天和同学聊天，我说程序员是有信仰的，对语言的执着、对技术的追求，那就是一种信仰。然而这个老师竟公然亵渎我的信仰，还将这么多的错误知识从讲台上传授下来，真的害人不浅。中国的计算机教育或者说大学计算机教育忽视教学质量，是不是滞后中国软件业发展的一个因素呢？

结果那哥们儿果真在他的期末考试卷里出了这么一道题“请阐述一下重载和重构的区别”。我当时压着火气写下的答案是先分析了一下重构的含义，再比较了一下重载和覆盖的区别，然后善意地提醒他题目出错了。要不是不想在毕业的时候因为没有毕业证去跳如心楼，我早把他妈捎上了。

下一个就是老八了。骂他主要是因为丫大四前太没出息，整天无所事事，看电视，玩游戏，就是不干正经事。每次跟我要Java书看，说要学，结果每次都坚持不了三天。于是大三过完寒假有一天我实在忍不住了，在宿舍（好像当时就我们两个人）劈头盖脸把丫臭骂了一顿，具体内容就不贴了，脏字较多，属于限制级。自那以后丫稍微好一点，有点上进心了，结果大四顺利考上了6系的公费。但现在有时还是来问我一些Java的东西，每次问我都先骂一句“孙子你早干嘛去了？”

好了，先写这么多吧，最后以高中发在榕树下的一篇文章（应该算Blog的雏形了）结尾，让大家看一下当时我的笔风（发于2002年8月，可惜的是，5年过去了，中国的动漫一点气色都没有，倒有另一帮孙子做出了《蓝猫》这么一个不伦不类的怪胎）：

国产动画，给我一个看你的理由

如今的上海荧幕，可谓灿烂，好片云集，佳作不断。而对我来说，大概只能用八个字来形容：“风起云涌，暗自心痛”，因为里面少了我爱看的动画片。有人可能会惊奇——如今动画片已经不少了，像前一阵子大红大紫而今又在重播的《我为歌狂》，还有《封神榜》，都是动辄几十集的国产大片，为何还如此不知足呢？而我想说的是，如果这种东西也可以称作是动画片的话，那可以说，我对中国的动画界彻底地丧失了信心。

先让我们回到1999年。《宝莲灯》，号称“耗时五年，精心打造的第一部国产巨片”，就像炫耀了五千年的中国悠久的历史一样，这一次，国人又凭这“五年”为老本大肆卖弄了一番。这部电影是我自己掏钱去看的，也是本人自懂事以来第二次自己掏钱上电影院，为了就是给这部中国动画界的“圣婴”捧个场。客观地讲，这部电影还过得去，画面应该可以和八十年代的日本货一较高下了，再加上不少明星担任配音以及滚石公司鼎力制作的主题曲和插曲，更是增加了可看性。然而一想到那些铺天盖地的广告，我就一阵心酸——一个孕育了五年的生命竟然还是如此地平庸？“历时五年精心打造”？五年就打造出这么一个马戏团里只能用来赚钱，供大家娱乐的，严重发育不良的——侏儒？我是《名侦探柯南》的忠实观众。就我掌握的资料，《柯南》一共出了252集30分钟的电视版以及5部120分钟的剧场版。而照中国这种120分钟/5年的速度得340年才能赶上别人一部动画片的量，而质则比别人整整落后了二十年。
再看电视荧屏。

《封神榜》以其极差的画面以及零内涵给我留下了很深的——坏印象。它那种背景与前景分开处理的手法以及能够在人物脸部的向光处打出阴影的技巧，着实让我叹为观止。其次它把最根本的内容置之度外，这种洒脱也让我折服。《封神演义》之所以能被列为中国古典名著之一，主要是因为其丰富的内涵以及对众多人物的刻画。照理来说，将这部文学巨作搬上荧幕，这些特色理应秉承。而这部动画片只是平淡地白描，对人物的刻画也粗糙至极，只是让观众分出起码的善恶。可能是因为它的观众群只是定格在儿童这一低年龄段而怕太深奥了小朋友们看不懂吧？如果真是这样，那我终于从它身上找到了一个优点——平易近人，体贴的人性化设计。然而这是不可能的。如今说许多大人长不大，二十岁的人了还在看动画片。我就属于这些“长不大”之辈，但我看的决不是国产动画。因为中国的动画片已经丧失了内涵，这本是国人最引以为傲的，如今连这个也没了，还凭什么吸引我去看？那样做只会降低我的身份。

还有《我为歌狂》，也是不堪入目。其画面只是重复的几张静止的幻灯片的播放穿插一些同样重复的诸如人物面部表情变化的GIF图片以及一些背景音乐。这种东西一台电脑加一个PowerPoint就能搞定。而它的内容也只是《灌篮高手》的翻版，只是将篮球队的故事搬到了乐队罢了。而我认为，一味地模仿，只能失去本属于自己的东西，更何况自己本来就没有多少东西。

没有灵魂的躯壳、蹩脚的克隆技术，除了这些，还有其它原因致使国产动画离我越来越远吗？我认为还有。

有人说，阻碍国产动画发展的，是因为盗版的泛滥，就像过去国产软件在市场上的大萧条一样。胡扯！自己不争气却怪外界环境，就好像葡萄长不成西瓜却怪光照不充分一样。你凭什么拉我们去买你的正版VCD？凭什么让我们去受你的视觉污染？还有人说国产动画的不成熟是因为没有经费上的支持。无稽之谈！《宝莲灯》上映以后从市场上赚了多少钱？光从我身上就榨走了35块钱。现在都已经3年了，怎么一点动静都没有，难道又难产了？

此外，就是主旨。国外动画片是以娱乐为主，而在轻松当中融入自己本民族的特色和作者自己的人生哲理。他们画出来的是娱乐，是智慧，而他们自己是学者，是大家，受人尊敬。比如《柯南》的作者青山冈昌，就在日本享有很高的知名度。而中国的动画片一开始就定下了“寓教于乐”的大方向，使动画片在娱乐性上的发挥受到了很大的限制。因此，国产动画只能成为教材，而且是幼稚园的教材，而他们的作者顶多只是个画家，只能得到小小孩们的一时的崇拜，而不是长久的社会的认可，就好像我到现在还不知道《宝莲灯》是哪一个画的。

还有，就是老掉牙的题材。中国人太讲究传统以至于那些“中华美德”、“中华成语”、“自古英雄出少年”天天挂在嘴边教育下一代的不够，还要一咕脑儿往银幕上搬，形成听觉、视觉双方面的攻势。而画这些东西的都是些不开化的中年人，这样能有什么创新？什么改革？如此下去，国产动画恐怕前途渺茫。

最后，就是优秀作品的选拔问题。日本有一个叫“小学馆漫画奖”已经举办了50多届，从中选拔出了许多诸如《柯南》、《浪客剑心》等优秀作品。而国内的漫画大奖赛去年好像只是第一届，这样就导致许多优秀的动漫作品不能与广大观众见面，只能作者与周遭的朋友分享。这不也是一种影响国产动画发展的障碍吗？

大家一定还记得那个老掉牙的笑话，说中国与韩国国家男足主教练在世界杯预选赛之前去向上帝预测球队的未来。结果上帝给车范根的回答只是让他老泪纵横地走出了教堂，而面对戚务生时，上帝自己却泣不成声。中国何时才能做出让我们这些大孩子抱着不放的动画片？我不打算去问上帝，因为，我不想天上下雨！

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 我是谁？（一）

Taste of Life

Jay — Tue, 16 May 2006 06:46:00 +0000

一个宁静的下午，刚用钟爱的爪哇解决了一个需求。现在坐在一家广式茶餐厅临街的窗口，点一份午餐。虽然三点半才吃午饭有些对不起胃，但至少时间是由我自由分配的。看着窗外匆匆的行人，突然发现这种生活是我向往的，不规律但很自由，经常有成就感，不用遵守规章制度，忙的时候可以连干几个通宵，闲的时候可以整天整天地发呆，不富但有心情小资一把看来我不适合上班，我应该去做SOHO。Sigh，我不是一个挣大钱的人……

[手机记于2006年5月15日下午3点半北航东南门金隆信]

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Taste of Life

Java 销魂落魄散 [zz]

Jay — Mon, 07 Nov 2005 09:39:00 +0000

引用

java 销魂落魄散

今天和徐某（一个学弟）一起coding，co着co着，徐某看起动漫来，还不停自言自语，说什么“姆斯唐”（mustang，java 6 的开发代号），然后非常热情地把笔记本转向我，然后说：“看，这就是姆斯唐”。原来是一个主角叫“姆斯唐”…当场晕倒…

平时就知道这人甚爱“爪哇”，可是也不至于因为某个主角的名称有点YY而对这部动画片狂热不已吧…唉

遂有了“徐某已身中巨毒，此毒乃java销魂落魄散也”；

可是又回头想想自己对mustang如此的的sensitive…

哈，可能原本就是我自己中了“java 销魂落魄散”了吧…哀哉乎？不悲矣，乐在其中：）

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Java 销魂落魄散 [zz]

Meet god father

Jay — Wed, 14 Sep 2005 13:44:00 +0000

今天是Java China 2005的最后一天，下午没有去各个分会场，而是去了长富宫饭店的“Java认证群英欢庆会”，目的只有一个：和Java之父James Gosling合影。

……

由于明天要交实习手册，拍照过程当中使用的个中手段先按下不表，总之合影是成功的，效果是令人满意的

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Meet god father

新学期，新气象

Jay — Wed, 31 Aug 2005 15:46:00 +0000

明天就回北京了，大四的学习生活马上就开始了。由于不想加入浩浩荡荡的考研大军，再加上我们系大四上一共才三节课，因此我可以说是闲得发慌，可以静下心来好好看看书，搞搞研究了。

在这里列两个list，好有个目标。

study list

研究一下eclipse的plugin机制，结合实验室现在的mipv6项目，继续实习时的工作
和师兄讨论一下，尽快定下毕设方向
争取一下保研的事
得花些时间在高老板那边，开始用户端的编码（突然发现struts是个好东东）
今天刚接了一个活儿，市场前景不错，得好好设计一下，还得找点人（毕竟几个以前得力的好搭档正准备考研），可能得先一个人扛一段时间

reading list

《Java与模式》看了大半了，这学期看完，然后总结一下
《The Object Primer》，系统整理一下oo知识
《UML参考手册》，UML 2.0推出了，得好好琢磨一下
《Expert One-on-One J2EE Development without EJB》
有时间的话看一下密码学

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 新学期，新气象

使用策略模式（Strategy）实现多关键字排序

Jay — Thu, 04 Aug 2005 04:37:00 +0000

｢策略模式｣的出现，是为了提供一套相互之间可灵活替换的算法，在不影响上层接口的情况下，用户可以自由选择不同的算法完成逻辑。策略模式的UML示意图如下：

其中算法的模型接口在｢抽象策略｣中定义，各具象策略实现不同的策略。｢消费API｣就是调用不同算法的类，在其内部根据不同需要选择不同的算法。有时需要将具象策略实例化后再传给其它类，这时可以使用｢简单工厂｣（Simple Factory）或｢工厂方法｣（Factory Method）生成所需的具象策略。下面就以我正在做的一个项目，简化一下后说明一下策略模式的使用。该项目是一个小型的商业网站，逻辑层由Servlet实现。用户有一个需求，需要从数据库调出商品信息后能够对记录按名称（name）、规格（standard）、价格（price）和注册日期（register date）进行排序。虽然可以考虑按不同的排序关键字使用不同的sql语句（即不同的order by）查询数据库。但这样做的网络数据流量太大，每次需要从数据库完整地取回一个数据集（ResultSet），所以我选择了将数据集一次取到客户端的一个List中，然后在客户端按不同的关键字对List进行排序。 java.util.Collections类中有一个public static void sort(List list, Comparator comparator)的方法，可以按照不同的Comparator对象对list进行排序，它使用的是快速排序，所以效率非常高。而java.util.Comparator是一个接口：

package java.util;
public abstract interface Comparator {
boolean equals(Object object);
int compare(Object object, Object object1);
}

package java.util;

public abstract interface Comparator {
    boolean equals(Object object);

    int compare(Object object, Object object1);
}

其中和排序有关的是compare方法，它返回一个整数，若第一个参数比第二个参数｢大｣，则返回一个正数，若｢小｣则返回一个负数，若｢相等｣则返回0，这里的｢大｣、｢小｣、｢相等｣是由compare方法具体实现定义的一种比较标准。由这个方法不禁想到C语言中qsort函数中使用的函数指针int *compare(*,*)，JAVA中之所以没有函数指针，就是用接口取代了（更详细的介绍见《Effective Java》中第22条｢用类和接口来代替函数指针｣）。很明显，Comparator接口就是我们的｢抽象策略｣，sort方法就是我们的｢消费API｣，而不同的｢具象策略｣就是我们从Comparator接口实现的根据不同关键字排序的类。整个排序模型的UML图如下，其中为了作图方便，我从Comparator继承了一个接口ItemComparator，根据不同的关键字从ItemComparator接口泛化了NameComparator类，PriceComparator类，RegisterDateComparator类和StandardComparator类。实际运用中不需要这个接口，四个类可以直接从Comparator泛化。ItemBean是一个封装了商品信息的bean，List中存放的就是这些bean。ItemSort和ItemComparator以及四个具体类实现了｢简单工厂｣模式，并封装了sort方法。

下面是具体的代码（StandardComparator类的代码与NameComparator类的代码大同小异，在这里不列出）：

NameComparator类

package com.lim.designpatterns.strategy;
public class NameComparator implements ItemComparator{
NameComparator(){} // 将构造器封装，包外的类欲得到Comparator实例只能通过简单工厂
public int compare(Object o1,Object o2){
String name1=((ItemBean)o1).getName();
String name2=((ItemBean)o2).getName();
return name1.compareTo(name2); // 调用String的CompareTo方法
}
}

package com.lim.designpatterns.strategy;

public class NameComparator implements ItemComparator{
    NameComparator(){} // 将构造器封装，包外的类欲得到Comparator实例只能通过简单工厂

    public int compare(Object o1,Object o2){
        String name1=((ItemBean)o1).getName();
        String name2=((ItemBean)o2).getName();

        return name1.compareTo(name2); // 调用String的CompareTo方法
    }
}

PriceComparator类

package com.lim.designpatterns.strategy;
public class PriceComparator implements ItemComparator{
PriceComparator(){}
public int compare(Object o1,Object o2){
Double price1=new Double(((ItemBean)o1).getPrice());
Double price2=new Double(((ItemBean)o2).getPrice());
return price1.compareTo(price2); // 调用Double的CompareTo方法
}
}

package com.lim.designpatterns.strategy;

public class PriceComparator implements ItemComparator{
    PriceComparator(){}

    public int compare(Object o1,Object o2){
        Double price1=new Double(((ItemBean)o1).getPrice());
        Double price2=new Double(((ItemBean)o2).getPrice());

        return price1.compareTo(price2); // 调用Double的CompareTo方法
    }
}

RegisterDateComparator类

package com.lim.designpatterns.strategy;
import java.util.*;
public class RegisterDateComparator implements ItemComparator{
RegisterDateComparator(){}
public int compare(Object o1,Object o2){
Date date1=((ItemBean)o1).getRegisterDate();
Date date2=((ItemBean)o2).getRegisterDate();
return date1.compareTo(date2); // 调用Date的CompareTo方法
}
}

package com.lim.designpatterns.strategy;

import java.util.*;

public class RegisterDateComparator implements ItemComparator{
    RegisterDateComparator(){}

    public int compare(Object o1,Object o2){
        Date date1=((ItemBean)o1).getRegisterDate();
        Date date2=((ItemBean)o2).getRegisterDate();

        return date1.compareTo(date2); // 调用Date的CompareTo方法
    }
}

ItemSort类

package com.lim.designpatterns.strategy;
import java.util.*;
public class ItemSort{
public static List sort(List items,ItemComparator c){
Collections.sort(items,c);
return items;
}
public static final ItemComparator NAME=new NameComparator(); // 简单工厂
public static final ItemComparator PRICE=new PriceComparator();
public static final ItemComparator STANDARD=new StandardComparator();
public static final ItemComparator REG_DATE=new RegisterDateComparator();
}

package com.lim.designpatterns.strategy;

import java.util.*;

public class ItemSort{
    public static List sort(List items,ItemComparator c){
        Collections.sort(items,c);
        return items;
    }

    public static final ItemComparator NAME=new NameComparator(); // 简单工厂

    public static final ItemComparator PRICE=new PriceComparator();

    public static final ItemComparator STANDARD=new StandardComparator();

    public static final ItemComparator REG_DATE=new RegisterDateComparator();
}

TestItemSort类

package com.lim.designpatterns.strategy;
import java.util.*;
public class TestItemSort{
public static void main(String[] args){
List items=new ArrayList();
// 向List添加条目
items=ItemSort.sort(items,ItemSort.NAME); // 按名称排序
items=ItemSort.sort(items,ItemSort.PRICE); // 按价格排序
items=ItemSort.sort(items,ItemSort.REG_DATE); // 按注册日期排序
items=ItemSort.sort(items,ItemSort.STANDARD); // 按规格排序
}
}

package com.lim.designpatterns.strategy;

import java.util.*;

public class TestItemSort{
    public static void main(String[] args){
        List items=new ArrayList();
        // 向List添加条目

        items=ItemSort.sort(items,ItemSort.NAME); // 按名称排序

        items=ItemSort.sort(items,ItemSort.PRICE); // 按价格排序

        items=ItemSort.sort(items,ItemSort.REG_DATE); // 按注册日期排序

        items=ItemSort.sort(items,ItemSort.STANDARD); // 按规格排序
    }
}

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 使用策略模式（Strategy）实现多关键字排序

IDEA，破解成功

Jay — Tue, 02 Aug 2005 15:15:00 +0000

今天在TSS上看到IntelliJ的IDEA 5.0终于release了，于是马上当了一个，还申请了一个30天的评估号。要知道IDEA可是个人程序员非常钟爱的IDE，界面很漂亮，使用 Alloy的Look and Feel，而且功能也相当强大，个人认为在中国这片没有license概念的土地上可以和JBuilder抗衡。但是上网站一看价格，竟然要$499！看来自己花钱买license是不可能的了。于是又找出Java反编译利器DJ，打算破解IDEA。

由于有了alloy的破解经验，这一次很快找到了关键代码，稍做修改后，评估版30天的限制被我破掉了，以后可以在一个“舒适”的IDE上开发了

Develop with pleasure

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: IDEA，破解成功

Java生日快乐

Jay — Tue, 12 Jul 2005 09:43:00 +0000

Java今年10岁了，虽然我接触他只有短短的5年，但是这5年我“矢志不渝”地扛着Java的大旗，包括到处鼓吹“Compile once, run anywhere”；包括“怂恿”同学学习Java；包括和.net阵营的fans面红耳赤地争论；包括对CPP的鄙视；包括对《Thinking in Java》的作者Bruce Eckel的顶礼膜拜（虽然他先写了《Thinking in C++》，但我“不记前嫌” ）；包括对GoF的抱怨，只因为他们的《Design Patterns》用CPP写示例（那时还没有Java）；包括床头不下20本Java相关书籍；包括写blog指责学院一位资深的教授，只因为他教“面向对象技术”时讲授的Java知识错误百出；包括因为Java去看《Java与模式》（16开，1024页）、《Object-Oriented Software Construction》（1254页，E文）；包括这次花250大洋参加Java 10周年大会…………

一直关注Java的成长，一直关注Java技术的发展。10年对人类来说可能很短暂，但对于一门计算机技术来说，10年兴盛的发展本身就是一个奇迹。我是幸运的，因为我亲眼目睹并且亲身经历了Sun创造的这个奇迹。再过20年，我会很自豪地对我儿子说“小子，这就是Java，老爸是看着他长大的”

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: Java生日快乐

二探Web service

Jay — Fri, 24 Jun 2005 09:43:00 +0000

复习了一天体系结构，打开JB玩玩Web service消遣消遣。发现WSDL的描述文件支持用户自定义类，但不支持JDK中的类库，应该是因为C#中没有相应的类与之对应，好像比较麻烦。如果要真正做到Java与.net无障碍协作的话得把JDK中所有的类在.net端映射一下。但如果是小范围应用的话可以考虑适配器模式（Adapter）

原创内容，转载请注明： 转载自拈花微笑

本文链接地址: 二探Web service

拈花微笑 » java

有关Java泛型的类型擦除（type erasing）

使用Spring LDAP ODM操作LDAP

祝贺：发布《Java虚拟机规范 （Java SE 7 中文版）》

X and XX Usgaes for Java

-X

-XX

Differences Among Greedy, Reluctant, and Possessive Quantifiers (for RexExp in Java)

关于『C++11 中值得关注的几大变化（详解）』

Don’t Use Java 7, For Anything [zz]

有关Character.isLetter()和Character.isLetterOrDigit()

如何在Hibernate中让SQLServer使用nvarchar代替varchar

误区！double类型做加减法不会有误差？

Java程序员必看电影：Java 4-ever

有关Runtime.addShutdownHook(Thread)

addShutdownHook

植树节，写棵二叉树庆祝一下

Snow Leopard下的JDK链接有问题

java.net论坛被黑（有图有真相）

Apache给EJB 3.1（JSR #318）投了否决票

10 things all JAVA developers should know [zz]

BlockingQueue与InterruptedException

Which GlassFish version is right for me? [zz]

Sun 卖了……

遍历Map>的正确方法

慎用LinkedXxxx集合

Java RMI中的NoSuchObjectException

在Tomcat 6中使用log4j

让Struts 2性能提升一个数量级的的5个步骤 [zz]

如何使用J2D将一张图片灰度化

How To Enable Anti-Aliased Globally Since JDK 5

JFreeChart中的TimeSeries可能导致内存泄露

JFreeChart Developer Guide

如何cancel一个swing worker（续）

JGraph中的deselect状态判断

isAddedCell

小心Derby的ResultSet陷阱

如何使用反射调用静态方法

如何cancel一个swingworker

JScrollBar的unitIncrement和blockIncrement

如何在Java的enum中使用annotation

Deskzilla Cracked

Synthetica破解

思路有点乱，只想说

相当随的笔

中文编程语言？

我是谁？（一）

Taste of Life

Java 销魂落魄散 [zz]

Meet god father

新学期，新气象

使用策略模式（Strategy）实现多关键字排序

IDEA，破解成功

Java生日快乐

二探Web service

祝贺：发布《Java虚拟机规范（Java SE 7 中文版）》