BlogJava-stone2083-随笔分类-java

Camunda学习点滴

stone2083 — Mon, 16 May 2022 02:10:00 GMT

摘要: 1. 主要包括：
架构总览、核心概念关系、场景例子、源码分析
2. 建议阅读顺序
2.1 从架构总览，了解整体camunda概念，包括DB表结构，内心有概念和底层存储的关系映射
2.2 再解核心概念关系，建立业务概念、代码模型、表结构的映射关系
2.3 通过场景例子，了解不同概念的使用场景，配置
2.4 通过源码分析，了解底层实现，方便必要时对其做扩展阅读全文

stone2083 2022-05-16 10:10 发表评论

获得Java对象内存占用大小

stone2083 — Sat, 08 Jun 2013 09:32:00 GMT

懒惰，直接上代码，用法见JAVA DOC.

1 package com.alibaba.stonelab.javalab.jvm.sizeof;
  2
  3 import java.lang.instrument.Instrumentation;
  4 import java.lang.reflect.Array;
  5 import java.lang.reflect.Field;
  6 import java.lang.reflect.Modifier;
  7 import java.util.IdentityHashMap;
  8 import java.util.Map;
  9 import java.util.Stack;
10
11 /**
12  *


 13  * 1. MANIFEST.MF
 14  *      Premain-Class: xxx.yyy.zzz.JavaSizeOf
 15  * 
 16  * 2. MAIN.JAVA
 17  *         System.out.println(JavaSizeOf.sizeof(new ConcurrentHashMap()));
 18  *         System.out.println(JavaSizeOf.sizeof(new String("1234567")));
 19  *         System.out.println(JavaSizeOf.sizeof(new String("1234")));
 20  *         System.out.println(JavaSizeOf.sizeof(new Object()));
 21  *         System.out.println(JavaSizeOf.sizeof(new int[] { 1, 2, 3 }));
 22  *         System.out.println(JavaSizeOf.sizeof(new CopyOnWriteArrayList()));
 23  *         System.out.println(JavaSizeOf.sizeof(null));
 24  *         
 25  * 3. USAGE:
 26  *      java -javaagent:sizeof.jar xxx.yyy.zzz.Main
 27  *

28 *
29 * @author

Stone.J 2013-6-8

30  */
31 public class JavaSizeOf {
32
33     private static Instrumentation inst;
34
35     public static void premain(String agentArgs, Instrumentation inst) {
36         JavaSizeOf.inst = inst;
37     }
38
39     /**
40      * get size of java object.
41      *
42      * @param o
43      * @return
44      */
45     public static long sizeof(Object o) {
46         assert inst != null;
47         Map visited = new IdentityHashMap();
48         Stack visiting = new Stack();
49         visiting.add(o);
50         long size = 0;
51         while (!visiting.isEmpty()) {
52             size += analysis(visiting, visited);
53         }
54         return size;
55     }
56
57     /**
58      * analysis java object size recursively.
59      *
60      * @param visiting
61      * @param visited
62      * @return
63      */
64     protected static long analysis(Stack visiting, Map visited) {
65         Object o = visiting.pop();
66         if (skip(o, visited)) {
67             return 0;
68         }
69         visited.put(o, null);
70         // array.
71         if (o.getClass().isArray() && !o.getClass().getComponentType().isPrimitive()) {
72             if (o.getClass().getName().length() != 2) {
73                 for (int i = 0; i < Array.getLength(o); i++) {
74                     visiting.add(Array.get(o, i));
75                 }
76             }
77         }
78         // object.
79         else {
80             Class clazz = o.getClass();
81             while (clazz != null) {
82                 Field[] fields = clazz.getDeclaredFields();
83                 for (Field field : fields) {
84                     if (Modifier.isStatic(field.getModifiers())) {
85                         continue;
86                     }
87                     if (field.getType().isPrimitive()) {
88                         continue;
89                     }
90                     field.setAccessible(true);
91                     try {
92                         visiting.add(field.get(o));
93                     } catch (Exception e) {
94                         assert false;
95                     }
96                 }
97                 clazz = clazz.getSuperclass();
98             }
99         }
100         return inst.getObjectSize(o);
101     }
102
103     /**
104      *


105      * skip statistics.
106      *

107      *
108      * @param o
109      * @param visited
110      * @return
111      */
112     protected static boolean skip(Object o, Map visited) {
113         if (o instanceof String) {
114             if (o == ((String) o).intern()) {
115                 return true;
116             }
117         }
118         return o == null || visited.containsKey(o);
119     }
120
121 }
122

stone2083 2013-06-08 17:32 发表评论

Spring Data JPA 代码分析

stone2083 — Thu, 25 Aug 2011 08:28:00 GMT

背景
接上文：Spring Data JPA 简单介绍
本文将从配置解析，Bean的创建，Repository执行三个方面来简单介绍下Spring Data JPA的代码实现

友情提醒：
图片均可放大

配置解析
1. parser类

Spring通过Schema的方式进行配置，通过AbstractRepositoryConfigDefinitionParser进行解析。其中包含对NamedQuery的解析。
解析的主要目的，是将配置文件中的repositories和repository元素信息分别解析成GlobalRepositoryConfigInformation和SingleRepositoryConfigInformation。
详见下图

2. Information

CommonRepositoryConfigInformation:
xml中repositories的通用配置，一般对应其中的attributes
SingleRepositoryConfigInformation:
xml中repository的配置信息，对应其中的attributes
GlobalRepositoryCOnfigInformation:
一组SingleRepositoryConfigInfomation信息，包含所有的Single信息
在JPA实现中，针对Single，有两份实现，一份是自动配置信息，一份是手动配置信息，分别对应图中的Automatic和Manual。
SimpleJpaRepositoryConfiguration是JPA中的所有配置信息，包含所有的Jpa中的SingleRepositoryConfigInformation。

3. Query Lookup Strategy

CreateQueryLookupStrategy:对应repositories元素

query-lookup-strategy的create值，主要针对method query方式
DeclaredQueryLookupStrategy:对应use-declared-query值，主要针对带有@Query注解的查询方式
CreateIfNotFoundQueryLookupStrategy:对应create-if-not-found值（default值），结合了上述两种方式

Bean的创建

主要包含两个类
RepositoryFactoryBeanSupport, Spring Factory Bean，用于创建Reposiory代理类。其本身并不真正做代理的事情，只是接受Spring的配置，具体交由RepositoryFactorySupport进行代理工作
RepositoryFactorySupport, 真正做Repository代理工作，根据JpaRepositoryFactoryBean的定义找到TargetClass：SimpleJpaRepository实现类，中间加入3个拦截器，一个是异常翻译，一个是事务管理，最后一个是QueryExecutorMethodInterceptor。
QueryExecutorMethodInterceptor是个重点，主要做特定的Query（查询语句）的操作。

Repository执行
1. 主要执行类

在看上面Bean定义的时候，其实已经明白了执行过程：
1. 将JPA CRUD规范相关的方法交给SimpleJpaRepository这个类执行
2. 将特殊查询相关的交给QueryExecutorMethodInterceptor执行。主要做自定义实现的部分，method query部分和named query部分。
具体查询类详见下图。

2. 查询相关

主要支持NamedQuery和JPA Query。

主要执行代码

QueryExecutorMethodInterceptor#invoke(MethodInvocation invocation)

1 public Object invoke(MethodInvocation invocation) throws Throwable {
2
3             Method method = invocation.getMethod();
4
5             if (isCustomMethodInvocation(invocation)) {
6                 Method actualMethod = repositoryInformation.getTargetClassMethod(method);
7                 makeAccessible(actualMethod);
8                 return executeMethodOn(customImplementation, actualMethod,
9                         invocation.getArguments());
10             }
11
12             if (hasQueryFor(method)) {
13                 return queries.get(method).execute(invocation.getArguments());
14             }
15
16             // Lookup actual method as it might be redeclared in the interface
17             // and we have to use the repository instance nevertheless
18             Method actualMethod = repositoryInformation.getTargetClassMethod(method);
19             return executeMethodOn(target, actualMethod,
20                     invocation.getArguments());
21         }

主要分3个步骤：
1. 如果配置文件中执行了接口类的实现类，则直接交给实现类处理
2. 判断是查询方法的，交给RepositoryQuery实现，具体又分:NamedQuery,SimpleJpaQuery,PartTreeJpaQuery
3. 不属于上述两个，则直接将其交给真正的targetClass执行，在JPA中，就交给SimpleJpaRepository执行。

本文并没有做详细的分析，只是将核心的组件类一一点到，方便大家自行深入了解代码。

stone2083 2011-08-25 16:28 发表评论

Spring Data JPA 简单介绍

stone2083 — Thu, 25 Aug 2011 07:18:00 GMT

背景
考虑到公司应用中数据库访问的多样性和复杂性，目前正在开发UDSL（统一数据访问层），开发到一半的时候，偶遇SpringData工程。发现两者的思路惊人的一致。
于是就花了点时间了解SpringData，可能UDSL II期会基于SpringData做扩展

SpringData相关资料
介绍：针对关系型数据库，KV数据库，Document数据库，Graph数据库，Map-Reduce等一些主流数据库，采用统一技术进行访问，并且尽可能简化访问手段。
目前已支持的数据库有（主要）：MongoDB，Neo4j，Redis，Hadoop，JPA等

SpringData官方资料（强烈推荐，文档非常详细）
SpringData主页：http://www.springsource.org/spring-data
SpringDataJPA 指南文档：http://static.springsource.org/spring-data/data-jpa/docs/current/reference/html/ （非常详细）
SpringDataJPA Examples： https://github.com/SpringSource/spring-data-jpa-examples （非常详细的例子）

Spring-Data-Jpa简介
Spring Data Jpa 极大简化了数据库访问层代码，只要3步，就能搞定一切
1. 编写Entity类，依照JPA规范，定义实体
2. 编写Repository接口，依靠SpringData规范，定义数据访问接口（注意，只要接口，不需要任何实现）
3. 写一小陀配置文件（Spring Scheme配置方式极大地简化了配置方式）

下面，我依赖Example中的例子，简单地介绍下以上几个步骤
User.java

User.java

没什么技术，JPA规范要求怎么写，它就怎么写

Repository.java

SimpleUserRepository.java

需要关注它继承的接口，我简单介绍几个核心接口

Repository：仅仅是一个标识，表明任何继承它的均为仓库接口类，方便Spring自动扫描识别

CrudRepository：继承Repository，实现了一组CRUD相关的方法

PagingAndSortingRepository：继承CrudRepository，实现了一组分页排序相关的方法

JpaRepository：继承PagingAndSortingRepository，实现一组JPA规范相关的方法

JpaSpecificationExecutor：比较特殊，不属于Repository体系，实现一组JPA Criteria查询相关的方法

不需要写任何实现类，Spring Data Jpa框架帮你搞定这一切。

Spring Configuration

Configuration.xml

核心代码只要配置一行：即可。上面的仅仅是数据源，事务的配置而已。

至此，大功告成，即可运行

Sample.java

其中，写操作相对比较简单，我不做详细介绍，针对读操作，我稍微描述下：
Method Query: 方法级别的查询，针对

findBy, find, readBy, read,

getBy等前缀的方法，解析方法字符串，生成查询语句，其中支持的关键词有：

Named Query：针对一些复杂的SQL，支持原生SQL方式，进行查询，保证性能
Criteria Query：支持JPA标准中的Criteria Query

备注：
本文只是简单介绍SpringDataJpa功能，要深入了解的同学，建议直接传送到官方网站

stone2083 2011-08-25 15:18 发表评论

推荐：Eclipse全屏插件

stone2083 — Sat, 09 Apr 2011 13:12:00 GMT

推荐一个eclipse插件--全屏插件（显示器整个屏幕）。
发觉这个东东还是挺不错的，尤其对于本本的同学，特别实用。
在我自己的本本上，发现一旦使用全屏，能多显示8行代码，多了21%左右，挺可观的。

插件地址：http://code.google.com/p/eclipse-fullscreen/

给个图：

stone2083 2011-04-09 21:12 发表评论

HttpClient使用过程中的安全隐患

stone2083 — Sat, 09 Apr 2011 12:46:00 GMT

HttpClient使用过程中的安全隐患，这个有些标题党。因为这本身不是HttpClient的问题，而是使用者的问题。

安全隐患场景说明：
一旦请求大数据资源，则HttpClient线程会被长时间占有。即便调用了org.apache.commons.httpclient.HttpMethod#releaseConnection()方法，也无济于事。
如果请求的资源是应用可控的，那么不存在任何问题。可是恰恰我们应用的使用场景是，请求资源由用户自行输入，于是乎，我们不得不重视这个问题。

我们跟踪releaseConnection代码发现：
org.apache.commons.httpclient.HttpMethodBase#releaseConnection()

1 public void releaseConnection() {
2     try {
3         if (this.responseStream != null) {
4             try {
5                 // FYI - this may indirectly invoke responseBodyConsumed.
6                 this.responseStream.close();
7             } catch (IOException ignore) {
8             }
9         }
10     } finally {
11         ensureConnectionRelease();
12     }
13 }

org.apache.commons.httpclient.ChunkedInputStream#close()

1 public void close() throws IOException {
2     if (!closed) {
3         try {
4             if (!eof) {
5                 exhaustInputStream(this);
6             }
7         } finally {
8             eof = true;
9             closed = true;
10         }
11     }
12 }

org.apache.commons.httpclient.ChunkedInputStream#exhaustInputStream(InputStream inStream)

1 static void exhaustInputStream(InputStream inStream) throws IOException {
2     // read and discard the remainder of the message
3     byte buffer[] = new byte[1024];
4     while (inStream.read(buffer) >= 0) {
5         ;
6     }
7 }

看到了吧，所谓的丢弃response，其实是读完了一次请求的response，只是不做任何处理罢了。

想想也是，HttpClient的设计理念是重复使用HttpConnection，岂能轻易被强制close呢。

怎么办？有朋友说，不是有time out设置嘛，设置下就可以下。
我先来解释下Httpclient中两个time out的概念：
1.public static final String CONNECTION_TIMEOUT = "http.connection.timeout";
即创建socket连接的超时时间:java.net.Socket#connect(SocketAddress endpoint, int timeout)中的timeout

2.public static final String SO_TIMEOUT = "http.socket.timeout";
即read data过程中，等待数据的timeout：java.net.Socket#setSoTimeout(int timeout)中的timeout

而在我上面场景中，这两个timeout都不满足，确实是由于资源过大，而占用了大量的请求时间。

问题总是要解决的，解决思路如下：
1.利用DelayQueue，管理所有请求
2.利用一个异步线程监控，关闭超长时间的请求

演示代码如下：

  1 public class Misc2 {
  2
  3     private static final DelayQueue<Timeout> TIMEOUT_QUEUE = new DelayQueue<Timeout>();
  4
  5     public static void main(String[] args) throws Exception {
  6         new Monitor().start(); // 超时监控线程
  7
  8         new Request(4).start();// 模拟第一个下载
  9         new Request(3).start();// 模拟第二个下载
10         new Request(2).start();// 模拟第三个下载
11     }
12
13     /**
14      * 模拟一次HttpClient请求
15      *
16      * @author

Stone.J 2011-4-9

17      */
18     public static class Request extends Thread {
19
20         private long delay;
21
22         public Request(long delay){
23             this.delay = delay;
24         }
25
26         public void run() {
27             HttpClient hc = new HttpClient();
28             GetMethod req = new GetMethod("http://www.python.org/ftp/python/2.7.1/Python-2.7.1.tgz");
29             try {
30                 TIMEOUT_QUEUE.offer(new Timeout(delay * 1000, hc.getHttpConnectionManager()));
31                 hc.executeMethod(req);
32             } catch (Exception e) {
33                 System.out.println(e);
34             }
35             req.releaseConnection();
36         }
37
38     }
39
40     /**
41      * 监工：监控线程，通过DelayQueue，阻塞得到最近超时的对象，强制关闭
42      *
43      * @author

Stone.J 2011-4-9

44      */
45     public static class Monitor extends Thread {
46
47         @Override
48         public void run() {
49             while (true) {
50                 try {
51                     Timeout timeout = TIMEOUT_QUEUE.take();
52                     timeout.forceClose();
53                 } catch (InterruptedException e) {
54                     System.out.println(e);
55                 }
56             }
57         }
58
59     }
60
61     /**
62      * 使用delay queue，对Delayed接口的实现根据请求当前时间+该请求允许timeout时间，和当前时间比较，判断是否已经超时
63      *
64      * @author

Stone.J 2011-4-9

65      */
66     public static class Timeout implements Delayed {
67
68         private long                  debut;
69         private long                  delay;
70         private HttpConnectionManager manager;
71
72         public Timeout(long delay, HttpConnectionManager manager){
73             this.debut = System.currentTimeMillis();
74             this.delay = delay;
75             this.manager = manager;
76         }
77
78         public void forceClose() {
79             System.out.println(this.debut + ":" + this.delay);
80             if (manager instanceof SimpleHttpConnectionManager) {
81                 ((SimpleHttpConnectionManager) manager).shutdown();
82             }
83             if (manager instanceof MultiThreadedHttpConnectionManager) {
84                 ((MultiThreadedHttpConnectionManager) manager).shutdown();
85             }
86         }
87
88         @Override
89         public int compareTo(Delayed o) {
90             if (o instanceof Timeout) {
91                 Timeout timeout = (Timeout) o;
92                 if (this.debut + this.delay == timeout.debut + timeout.delay) {
93                     return 0;
94                 } else if (this.debut + this.delay > timeout.debut + timeout.delay) {
95                     return 1;
96                 } else {
97                     return -1;
98                 }
99             }
100             return 0;
101         }
102
103         @Override
104         public long getDelay(TimeUnit unit) {
105             return debut + delay - System.currentTimeMillis();
106         }
107
108     }
109
110 }

本来还想详细讲下DelayQueue，但是发现同事已经有比较纤细的描述，就加个链接吧（人懒，没办法）
http://agapple.iteye.com/blog/916837
http://agapple.iteye.com/blog/947133

备注：
HttpClient3.1中，SimpleHttpConnectionManager才有shutdown方法，3.0.1中还存在：）

stone2083 2011-04-09 20:46 发表评论

HtmlParser疑似Bug

stone2083 — Fri, 08 Apr 2011 12:50:00 GMT

最近的项目中，使用到了HtmlParser（1.5版本）.在使用过程中（如访问url为：http://athena2002.vip.china.alibaba.com/ ），遇到了异常：

Exception in thread "main" java.lang.IllegalArgumentException: invalid cookie name: Discard
    at org.htmlparser.http.Cookie.<init>(Cookie.java:136)
    at org.htmlparser.http.ConnectionManager.parseCookies(ConnectionManager.java:1126)
    at org.htmlparser.http.ConnectionManager.openConnection(ConnectionManager.java:621)
    at org.htmlparser.http.ConnectionManager.openConnection(ConnectionManager.java:792)
    at org.htmlparser.Parser.<init>(Parser.java:251)
    at org.htmlparser.Parser.<init>(Parser.java:261)

检查代码，发现：
org.htmlparser.http.Cookie

1 public Cookie (String name, String value)
2     {
3         if (!isToken (name) || name.equalsIgnoreCase ("Comment") // rfc2019
4                 || name.equalsIgnoreCase ("Discard") // 2019++
5                 || name.equalsIgnoreCase ("Domain")
6                 || name.equalsIgnoreCase ("Expires") // (old cookies)
7                 || name.equalsIgnoreCase ("Max-Age") // rfc2019
8                 || name.equalsIgnoreCase ("Path")
9                 || name.equalsIgnoreCase ("Secure")
10                 || name.equalsIgnoreCase ("Version"))
11             throw new IllegalArgumentException ("invalid cookie name: " + name);
12         mName = name;
13         mValue = value;
14         mComment = null;
15         mDomain = null;
16         mExpiry = null; // not persisted
17         mPath = "/";
18         mSecure = false;
19         mVersion = 0;
20     }

一旦发现name值为“Discard”，则抛异常。

而在org.htmlparser.http.ConnectionManager.parseCookies (URLConnection connection) 解析cookie的代码中，见代码片段

if (key.equals ("domain"))
                            cookie.setDomain (value);
                        else
                            if (key.equals ("path"))
                                cookie.setPath (value);
                            else
                                if (key.equals ("secure"))
                                    cookie.setSecure (true);
                                else
                                    if (key.equals ("comment"))
                                        cookie.setComment (value);
                                    else
                                        if (key.equals ("version"))
                                            cookie.setVersion (Integer.parseInt (value));
                                        else
                                            if (key.equals ("max-age"))
                                            {
                                                Date date = new Date ();
                                                long then = date.getTime () + Integer.parseInt (value) * 1000;
                                                date.setTime (then);
                                                cookie.setExpiryDate (date);
                                            }
                                            else
                                            {   // error,? unknown attribute,
                                                // maybe just another cookie not separated by a comma
                                                cookie = new Cookie (name, value); //出问题的地方
                                                cookies.addElement (cookie);
                                            }

没有对Discard做特殊处理。
无奈之下，覆写了此方法，加上对Discard的处理--直接continue ：）

今天在写blog的时候，拿了1.6的代码测试，发现没有问题，分析代码后发现
1. ConnectionManager parserCookie之前，加了条件判断

if (getCookieProcessingEnabled ())
parseCookies (ret);

默认情况下，条件为false
2. parserCookie的时候，catch了异常

1 // error,? unknown attribute,
2 // maybe just another cookie
3 // not separated by a comma
4 try
5 {
6     cookie = new Cookie (name,
7         value);
8     cookies.addElement (cookie);
9 }
10 catch (IllegalArgumentException iae)
11 {
12     // should print a warning
13     // for now just bail
14     break;
15 }

虽然解决了问题，但是明显还没有意识到Discard的问题。

从我的理解看，最合理的解决方案是:
1. org.htmlparser.http.Cookie中添加 boolean discard方法
2. org.htmlparser.http.ConnectionManager parserCookies()方法，对Discard做处理，如有值，则设置cookie.discard=true

关于discard的解释，见http://www.faqs.org/rfcs/rfc2965.html：

Discard

OPTIONAL.  The Discard attribute instructs the user agent to

discard the cookie unconditionally when the user agent terminates

stone2083 2011-04-08 20:50 发表评论

语言杂谈（shell/python/java）

stone2083 — Mon, 08 Nov 2010 09:24:00 GMT

背景：
公司产品一直使用Java作为开发语言，平时常用Shell脚本进行文本的处理，最近自学了Python.
感觉这3门语言挺具代表性，故对其分析了自己对它们的理解。
由于是部门分享，考虑避免重复劳动力，就把PPT转成图片放上来。

内容：

结束语：
一家之言，属于个人观点

备注：
ubuntu下convert命令挺强悍的，支持PDF和图片的互转

附上PDF文档：
分享文档

stone2083 2010-11-08 17:24 发表评论

关于cookie特殊字符的一点理解

stone2083 — Wed, 03 Nov 2010 05:27:00 GMT

背景：
加密的cookie信息中带有特殊字符（“=”），导致读cookie的时候，特殊符号丢失，解密失败

看了同事“关于cookie特殊字符”的说明邮件，和网上对cookie特殊字符问题的解释：

我们在实际使用Cookie过程中要注意一些问题：

　　1. Cookie的兼容性问题

　　Cookie的格式有2个不同的版本，第一个版本，我们称为Cookie Version 0，是最初由Netscape公司制定的，也被几乎所有的浏览器支持。而较新的版本，Cookie Version 1，则是根据RFC 2109文档制定的。为了确保兼容性，JAVA规定，前面所提到的涉及Cookie的操作都是针对旧版本的Cookie进行的。而新版本的Cookie目前还不被Javax.servlet.http.Cookie包所支持。

　　2. Cookie的内容

　　同样的Cookie的内容的字符限制针对不同的Cookie版本也有不同。在Cookie Version 0中，某些特殊的字符，例如：空格，方括号，圆括号，等于号（=），逗号，双引号，斜杠，问号，@符号，冒号，分号都不能作为Cookie的内容。这也就是为什么我们在例子中设定Cookie的内容为“Test_Content”的原因。

　　虽然在Cookie Version 1规定中放宽了限制，可以使用这些字符，但是考虑到新版本的Cookie规范目前仍然没有为所有的浏览器所支持，因而为保险起见，我们应该在Cookie的内容中尽量避免使用这些字符。

摘自：http://swingchen.bokee.com/6200015.html
类似这样的解释，搜索出来的结果，挺多。

但是，我去看了RFC2109（http://www.faqs.org/rfcs/rfc2109.html）,其说明如下：

value中的token，是有一组非特殊字符，非空白字符。而它是在RFC 2068（http://www.faqs.org/rfcs/rfc2068.html）中制定的（是对Header的规范），请看：

也就是说，所谓的Cookie1,同样有特殊字符的限制。
同样，在Cookie2（RFC2965）中，也如此。

想想也是啊，如果没有特殊字符的限制，解析Header的时候，还不乱套了？

看了RFC之后，我们再来看看Tomcat中的实现（6.0.29版本），请看：
org.apache.tomcat.util.http.Cookies

1.类注释：

A collection of cookies - reusable and tuned for server side performance.
Based on RFC2965 ( and 2109 )

是基于RFC2965/RFC2109规范来实现的

2.特殊字符的定义

/*
    List of Separator Characters (see isSeparator())
    Excluding the '/' char violates the RFC, but
    it looks like a lot of people put '/'
    in unquoted values: '/': ; //47
    '\t':9 ' ':32 '\"':34 '(':40 ')':41 ',':44 ':':58 ';':59 '<':60
    '=':61 '>':62 '?':63 '@':64 '[':91 '\\':92 ']':93 '{':123 '}':125
    */
    public static final char SEPARATORS[] = { '\t', ' ', '\"', '(', ')', ',',
        ':', ';', '<', '=', '>', '?', '@', '[', '\\', ']', '{', '}' };

根据规范，定义了特殊字符。除了“/”这个符号。因为大多数人会直接使用“/”。

3.针对“=”特殊处理

/**
* If true, cookie values are allowed to contain an equals character without
* being quoted.
*/
public static final boolean ALLOW_EQUALS_IN_VALUE;

static {
    ALLOW_EQUALS_IN_VALUE = Boolean.valueOf(System.getProperty(
            "org.apache.tomcat.util.http.ServerCookie.ALLOW_EQUALS_IN_VALUE",
            "false")).booleanValue();
}

可以在catalina.properties中，添加这个配置项（或者启动过程中加上-D参数），使得cookie value中允许存在“=”符号。
所以本文开头提到的问题，可以使用这个方法得到解决

4.解析过程

/**
* Parses a cookie header after the initial "Cookie:"
* [WS][$]token[WS]=[WS](token|QV)[;|,]
* RFC 2965
* JVK
*/
public final void processCookieHeader(byte bytes[], int off, int len){
//详细代码，省略
}

备注：
RFC没有仔细看（时间有限，并且看E文挺累的），如理解有误，请告知。

stone2083 2010-11-03 13:27 发表评论

爬取交通违章信息的脚本

stone2083 — Fri, 29 Oct 2010 10:30:00 GMT

摘要: 会开车了，也慢慢不规矩起来了，于是乎，违章信息也慢慢多起来了，但是无法第一时间通知到自己。虽说，有个网站：http://www.hzti.com/service/qry/violation_veh.aspx?pgid=&type=1&node=249 可以查询非现场违章情况，不过： 1.我是懒人，主动去查询的时候不太乐意做 2.车辆识别码，永远记不住 3.每次输验证... 阅读全文

stone2083 2010-10-29 18:30 发表评论

java反射效率

stone2083 — Wed, 15 Sep 2010 06:04:00 GMT

摘要: java反射效率到底如何,花了点时间,做了一个简单的测试.供大家参考. 测试背景: 1. 测试简单Bean(int,Integer,String)的set方法 2. loop 1亿次 3. 测试代码尽可能避免对象的创建,复发方法的调用,仅仅测试set方法的耗时测试结果: 场景 &... 阅读全文

stone2083 2010-09-15 14:04 发表评论

IBatis下DAO单元测试另类思路

stone2083 — Thu, 12 Aug 2010 01:03:00 GMT

在说另类思路之前,先说下传统的测试方法:
0.准备一个干净的测试数据库环境
这个是前提
1.测试数据准备
使用文本,excel,或者wiki等,准备测试sql以及测试数据
利用dbfit,dbutil等工具将准备的测试数据导入到数据库中
2.执行dao方法
执行被测试的dao方法
3.测试结果断言
利用dbfit,dbutil等工具,断言测试结果数据和预计是否一致
4.所有数据回滚

其实,对于这个流程来说,目前的dao测试框架,支持的已经比较完美了
但是此类测试方法,也有明显的缺点(或者不能叫缺点,叫使用比较麻烦的地方)
如下:
1.背上了一个数据库环境.
不轻量
这是一个共享环境,谁也无法确保环境数据是否真正的干净
2.测试数据准备是一件麻烦的事情
新表,10几个字段毫不为奇;老表,50几个字段甚至百来个字段,也偶有可见;无论是使用文本,excel,wiki,准备工作量,都是巨大的.
准备的数据,部分字段内容可以是无意义的,部分字段内容又是需要符合测试意图(testcase设计目的),部分字段还是其他表的关联字段.从而导致后续维护人员无法了解准备数据意图.
(实践中,也出现过,一同事在维护他人单元测试时,由于无法了解测试数据准备意图,宁可重新删除,自己准备一份)
3.预计结果数据准备也是一件麻烦的事情
理由如上

所以,理论上是完美的测试方案,在实践过程中,却是一件麻烦的事情.导致DAO单元测试维护困难.

分析了现状,我们再来分析下,IBatis下DAO,程序员主要做了哪些编码:
1. 写了一份sqlmap.xml配置文件
2. 通过getSqlMapClientTemplate.doSomething($sqlID,$param), 执行语句
(当然,没有使用spring的同学,也是使用了类似sqlMapClient.doSomething($sqlID,$param)方法)

而步骤2其实是框架替我们做了的事情,按照MOCK的思想,其实这部分代码可以被MOCK的,那么我们是否可以做如下假设:
只要sqlmap.xml中配置信息(主要包括resultmap和statement)是正确的,那么执行结果也应该是正确的.

而我所谓的另类思路,就是基于这个假设,得出的:
IBatis下,DAO单元测试,我们抛弃背负的数据库环境,只要根据不同的条件,断言不同的sql即可.

于是乎,封装了一个IbatisSqlTester,可以根据sqlmap中的statement和传入的条件参数,生成sql语句.
那么,DAO单元测试就简单了,脱离下数据库环境:

public class ScoreDAOTest extends TestCase {

    @SpringBeanByName
    private IbatisSqlTester ibatisSqlTester; //通过spring配置,需要注入sqlmapclient对象

    @Test
    public void testListTpScores() {
        Map<String, Object> param = new HashMap<String, Object>(1);
        param.put("memberIds", new String[] { "stone", "stone2083" });
        SqlStatement sql = ibatisSqlTester.test("MS-LIST-SCORES", param);
        // sql全部匹配
        SqlAssert.isEqual("select * from score where member_id in ('stone','stone2083')", sql.toString());
        // sql包含member_id,athena2002,stone关键词
        SqlAssert.keyWith(sql.toString(), "member_id", "stone", "stone2083");
        // sql符合某个正则
        SqlAssert.regexWith(".* where member_id in .*", sql.toString());

        //其中,SqlAssert也可以换成want.string()中的方法.
    }
}

优势:
脱离了数据库环境
脱离了表结构数据准备
脱离了预计结果数据准备
让单元测试变成sql的断言,编写相对更简单
缺点:
row mapper过程无法被测试

最后,附上两个核心的代码类(还未完成),供大家参考:
SqlStatement.java

/**
*



 * SqlStatement:Sql语句对象.

 * 包含:

 *  1.sql语句,类似  select * from offer where id = ? and member_id = ?

 *  2.参数值,类似 [1,stone2083]

 *  

 *  toString方法,返回执行的sql语句,如:

 *  select * from offer where id = '1' and member_id = 'stone2083'

 *

*
* @author Stone.J 2010-8-9 下午02:55:36
*/
public class SqlStatement {

    //sql
    private String   sql;
    //sql参数
    private Object[] param;

    /**
     *



     * 输出最终执行的sql内容.

     * 将sql和param进行merge,产生最终执行的sql语句

     *

     */
    @Override
    public String toString() {
        return merge();
    }

    /**
     *



     * 将sql进行格式化.

     * 

     * 目前只是简单进行格式化.去除前后空格,已经重复空格

     * TODO:请使用统一格式化标准规,建议使用SqlFormater类,进行处理

     *

     *
     * @param sql
     * @return
     */
    protected String format(String sql) {
        if (sql == null) {
            return null;
        }
        return sql.toLowerCase().trim().replaceAll("\\s{1,}", " ");
    }

    /**
     *



     * 将sql和param进行merge.

     * TODO:请严格按照SQL标准,进行merge sql内容

     *

     */
    protected String merge() {
        if (param == null || param.length == 0) {
            return this.sql;
        }
        String ret = sql;
        for (Object p : param) {
            ret = ret.replaceFirst("\\?", "'" + p.toString() + "'");
        }
        return ret;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = format(sql);
    }

    public Object[] getParam() {
        return param;
    }

    public void setParam(Object[] param) {
        this.param = param;
    }
}

IbatisSqlTester.java

/**
*



 * IBtatis SQL 测试

 * 一般IBatis DAO单元测试,主要就是在测试ibatis的配置文件.

 * IbatisSqlTester将根据提供的Sql Map Id 和 对应的参数,返回 {@link SqlStatement}对象,提供最终执行的sql语句

 * 通过外部SqlAssert对象,将预计Sql和实际产生的Sql进行对比,判断是否正确

 *

*
* @author Stone.J 2010-8-9 下午02:58:46
*/
public class IbatisSqlTester {

    // sqlMapClient
    private ExtendedSqlMapClient sqlMapClient;

    /**
     * 根据提供的SqlMap ID,得到 {@link SqlStatement}对象
     *
     * @param sqlId: sql map id
     * @return @see {@link SqlStatement}
     */
    public SqlStatement test(String sqlId) {
        //得到MappedStatement对象
        MappedStatement ms = sqlMapClient.getMappedStatement(sqlId);
        if (ms == null) {
            //TODO:建议封转自己的异常对象
            throw new RuntimeException("can't find MappedStatement.");
        }

        //按照Ibatis代码,得到Sql和Param信息
        RequestScope request = new RequestScope();
        ms.initRequest(request);
        Sql sql = ms.getSql();
        String sqlValue = sql.getSql(request, null);

        //组转返回对象
        SqlStatement ret = new SqlStatement();
        ret.setSql(sqlValue);
        return ret;
    }

    /**
     * 根据提供的SqlMap ID和对应的param信息,得到 {@link SqlStatement}对象
     *
     * @param sqlId: sql map id
     * @param param: 参数内容
     * @return @see {@link SqlStatement}
     */
    public SqlStatement test(String sqlId, Object param) {
        //得到MappedStatement对象
        MappedStatement ms = sqlMapClient.getMappedStatement(sqlId);
        if (ms == null) {
            //TODO:建议封转自己的异常对象
            throw new RuntimeException("can't find MappedStatement.");
        }

        //按照Ibatis代码,得到Sql和Param信息
        RequestScope request = new RequestScope();
        ms.initRequest(request);
        Sql sql = ms.getSql();
        String sqlValue = sql.getSql(request, param);
        Object[] sqlParam = sql.getParameterMap(request, param).getParameterObjectValues(request, param);

        //组转返回对象
        SqlStatement ret = new SqlStatement();
        ret.setSql(sqlValue);
        ret.setParam(sqlParam);
        return ret;
    }

    /**
     * 设置SqlMapClient对象
     */
    public void setSqlMapClient(ExtendedSqlMapClient sqlMapClient) {
        this.sqlMapClient = sqlMapClient;
    }

    /**
     *



     * 不推荐使用

     * 推荐使用: {@link IbatisSqlTester#setSqlMapClient(ExtendedSqlMapClient)}

     * TODO:请去除这个方法,或者增加初始化的方式

     *

     *
     * @param sqlMapConfig sqlMapConfig xml文件
     */
    public void setSqlMapConfig(String sqlMapConfig) {
        InputStream in = null;
        try {
            File file = ResourceUtils.getFile(sqlMapConfig);
            in = new FileInputStream(file);
            this.sqlMapClient = (ExtendedSqlMapClient) SqlMapClientBuilder.buildSqlMapClient(in);
        } catch (Exception e) {
            throw new RuntimeException("sqlMapConfig init error.", e);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                }
            }
        }
    }

}

最后的最后附上所有代码(通过单元测试代码,可以看如何使用).欢迎大家的讨论.
sqltester
builder

stone2083 2010-08-12 09:03 发表评论

扫描classpath下类资源

stone2083 — Fri, 23 Jul 2010 06:55:00 GMT

很早之前,为了简化配置信息,自己写了一坨代码,基于classpath扫描类信息,加载.
其实,在spring中,已经提供了类似组件(后知后觉了...):

org.springframework.core.io.support.PathMatchingResourcePatternResolver 资源解析器(基于路径的正则表达式)
org.springframework.core.type.classreading.MetadataReader ClassMeta信息解读器

于是乎,代码就非常简单了:

1 public class Test {
2
3     /* 资源路径 */
4     private static final String                  PATH           = "classpath*:com/alibaba/javalab/t*/**/*.class";
5     /* 资源解析器 */
6     private static final ResourcePatternResolver RESOLVER       = new PathMatchingResourcePatternResolver();
7     /* Meta信息Reader Factory.用于创建MetaReader */
8     private static final MetadataReaderFactory   READER_FACTORY = new SimpleMetadataReaderFactory();
9
10     public static void main(String[] args) throws Exception {
11         //根据正则表达式,得到资源列表
12         Resource[] resources = RESOLVER.getResources(PATH);
13         for (Resource res : resources) {
14             //通过 MetadataReader得到ClassMeta信息,打印类名
15             MetadataReader meta = READER_FACTORY.getMetadataReader(res);
16             System.out.println(meta.getClassMetadata().getClassName());
17         }
18     }
19 }

输出结果:
com.alibaba.javalab.tool.fetion.protocol.Config
com.alibaba.javalab.tool.fetion.protocol.Fetion
com.alibaba.javalab.tool.fetion.protocol.FetionHelper
com.alibaba.javalab.tool.fetion.protocol.LoginSession
com.alibaba.javalab.tool.trace.TimeTrace
...

挺好使的一个工具 :)

stone2083 2010-07-23 14:55 发表评论

初识InheritableThreadLocal

stone2083 — Fri, 23 Jul 2010 01:17:00 GMT

一直来只知道ThreadLocal,直到最近看slf4j MDC实现代码的时候,才认识了InheritableThreadLocal.
InheritableThreadLocal顾名思义,可继承的ThreadLocal.
看类描述:

This class extends <tt>ThreadLocaltt> to provide inheritance of values
* from parent thread to child thread: when a child thread is created, the
* child receives initial values for all inheritable thread-local variables
* for which the parent has values.

测试代码:

1 public class Test {
2
3     public static void main(String[] args) {
4         //使用ThreadLocal,父子线程之间,不共享Value
5         final ThreadLocal<String> tl = new ThreadLocal<String>();
6         tl.set("ThreadLocal-VAL");
7         System.out.println("Main-1:" + tl.get());
8         new Thread() {
9             public void run() {
10                 System.out.println("Child-1:" + tl.get());
11             };
12         }.start();
13
14         //使用InheritableThreadLocal,父线程Value可让子线程共享
15         final ThreadLocal<String> itl = new InheritableThreadLocal<String>();
16         itl.set("InheritableThreadLocal-VAL");
17         System.out.println("Main-2:" + itl.get());
18         new Thread() {
19             public void run() {
20                 System.out.println("Child-2:" + itl.get());
21             };
22         }.start();
23
24     }
25 }

输出内容:
Main-1:ThreadLocal-VAL
Main-2:InheritableThreadLocal-VAL
Child-1:null
Child-2:InheritableThreadLocal-VAL

......分隔符号......

顺带着简单说下MDC.(Mapped Diagnostic Context). 中文直译太恶心了,我理解的意思是,和环境相关的上下文信息.
比如在web应用中,我们可以把用户的ip,访问url等放入到这个上下文中,log打印的时候,就能得到这个信息.

在slf4j BasicMDCAdapter实现中,就是用了InheritableThreadLocal

1 public class BasicMDCAdapter implements MDCAdapter {
2
3   private InheritableThreadLocal inheritableThreadLocal = new InheritableThreadLocal();
4
5   //.
6
7 }

stone2083 2010-07-23 09:17 发表评论

小谈PropertyPlaceholderConfigurer

stone2083 — Fri, 23 Jul 2010 00:51:00 GMT

背景:让应用在一个环境下,以多实例的方法运行.
Log问题,可以通过Log4j占位符实现(见前文:http://www.blogjava.net/stone2083/archive/2010/07/01/324935.html)
其他Java组件代码依赖了本地环境资源,怎么解决呢?

对于使用Spring的组件来说,PropertyPlaceholderConfigurer能帮我们解决这一问题.

PropertyPlaceholderConfigurer除了支持配置的properties文件外,还支持系统属性(System.getProperties()).当然,它有三种模式:

1/** Never check system properties. */
2public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;
3
4/**
5 * Check system properties if not resolvable in the specified properties.
6 * This is the default.
7 */
8public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;
9
10/**
11 * Check system properties first, before trying the specified properties.
12 * This allows system properties to override any other property source.
13 */
14public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;

对于使用本地环境资源的bean来说,只要配置:

1 <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
2     <property name="systemPropertiesModeName" value="SYSTEM_PROPERTIES_MODE_OVERRIDE" />
3     <property name="locations">
4         <list>
5             <value>classpath*:spring/env.propertiesvalue>
6         list>
7     property>
8 bean>
9
10 <bean id="javaBean" class="com.alibaba.javalab.spring.JavaBean">
11      <property name="lockFile" value="/home/stone/base/${node}/lock" />
12 bean>

在启动脚本中,只要加入-Dnode=instanceX即可.

总结:
PropertyPlaceholderConfigurer支持properties文件和系统属性.并且存在三种覆盖策略.

stone2083 2010-07-23 08:51 发表评论

Java Exception性能问题

stone2083 — Fri, 09 Jul 2010 06:30:00 GMT

摘要: 背景: 大学里学java,老师口口声声,言之凿凿,告诫我们,Java千万别用异常控制业务流程,只有系统级别的问题,才能使用异常; (当时,我们都不懂为什么不能用异常,只知道老师这么说,我们就这么做,考试才不会错 :) ) 公司里,有两派.异常拥护者说,使用业务异常,代码逻辑更清晰,更OOP;反之者说,使用异常,性能非常糟糕; (当然,我是拥护者) 论坛上,争论得更多,仁者见仁智者见智,口... 阅读全文

stone2083 2010-07-09 14:30 发表评论

让log4j支持占位符

stone2083 — Thu, 01 Jul 2010 00:52:00 GMT

目标:让log4j.xml配置文件中允许使用占位符(${key}).

使用场景:
在运行期决定一些动态的配置内容.
比如在我们项目中,希望一台物理机同一个应用跑多个实例.
因为多进程操作同一份log文件存在并发问题(打印,DailyRolling等),所以我希望配置如下:${loggingRoot}/${instance}/project.log
在运行脚本中,通过加入-Dinstance=instance1参数,来动态指定实例名.让同一份应用在不同的运行实例下,日志打印到不同的路径

Log4j分析:
我以为,Log4j天生就支持占位符的.请见:org.apache.log4j.helpers.OptionConverter.substVars(String val, Properties props)就有对占位符的处理.
org.apache.log4j.PropertyConfigurator (log4j.properties文件解析).默认就支持对占位符的处理.
org.apache.log4j.xml.DOMConfigurator挺怪异的.明明也有对占位符的处理.但是我们就是无法对其属性props进行赋值.
(当然,有可能是我误解了其props的用法--还没有完整读过他的源码)

处理方案:
继承org.apache.log4j.xml.DOMConfigurator,实现自己的DOMConfigurator.

public class PlaceHolderDOMConfigurator extends org.apache.log4j.xml.DOMConfigurator {

    private Properties props;

    public PlaceHolderDOMConfigurator(Properties props){
        this.props = props;
    }

    public static void configure(String filename, Properties props) {
        new PlaceHolderDOMConfigurator(props).doConfigure(filename, LogManager.getLoggerRepository());
    }

    //主要是覆写这个方案.传入properties对象
    protected String subst(String value) {
        try {
            return OptionConverter.substVars(value, props);
        } catch (IllegalArgumentException e) {
            LogLog.warn("Could not perform variable substitution.", e);
            return value;
        }
    }
}

测试代码:
log4j.xml片段:

<appender name="PROJECT" class="org.apache.log4j.DailyRollingFileAppender">
        <param name="file" value="${loggingRoot}/${instance}/project.log"/>
        <param name="append" value="false"/>
        <param name="encoding" value="GB2312"/>
        <param name="threshold" value="info"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%d [%X{requestURIWithQueryString}] %-5p %c{2} - %m%n"/>
        layout>
    appender>

Run.java:

public static void main(String[] args) {
        Properties props = new Properties();
        props.setProperty("loggingRoot", "d:/tmp");
        props.setProperty("instance", "instance1");

        PlaceHolderDOMConfigurator.configure(LOG4J_PATH, props);
        Logger rootLogger = LogManager.getRootLogger();
        FileAppender fileAppender = (FileAppender) rootLogger.getAppender("PROJECT");
        System.out.println(fileAppender.getFile());
    }

输出结果:
d:/tmp/instance1/project.log

当然,你也可以通过在启动参数中加 -DloggingRoot=xxxx -Dinstance=yyyy动态指定内容.

特别说明:
本文:log4j版本为1.2.14
log4j 1.2.15测试不通过,原因见:https://issues.apache.org/bugzilla/show_bug.cgi?id=43325

stone2083 2010-07-01 08:52 发表评论

单元测试下简易性能测试工具

stone2083 — Thu, 10 Jun 2010 01:13:00 GMT

背景:
1.团队成员对质量意识逐渐提升;单元测试意识提升;
2.性能意识不足,往往到最后提交性能测试的时候,才发现性能问题;在开发阶段忽视对性能的考虑.
尤其在做对外服务的需求中,危害特别明显.

基于这两个原因,希望有一个在单元测试下的性能测试工具.提供最简单的性能指标报表.在开发阶段让开发对性能情况有个感性的认识.

设计思路:

概念说明:

类名	方法	说明
Statistics 说明:性能统计信息	tps()	提供tps
	average()	提供平均响应时间,单位毫秒
	total()	提供总耗时,单位毫秒
Job 说明:测试单元逻辑	execute()	性能测试逻辑
Warn 说明:性能未达标警告
PerformanceTester (核心) 说明:性能测试工具,根据制定的并发数和单个并发循环次数,进行性能测试;根据提供的平均响应时间,分析是否达标	test(Job job)	性能测试,打印性能报表,分析是否达标
JTesterxPerformance 说明:基于JTester的性能测试基类,统一执行性能测试计划备注: JTester是我们公司同事编写的一套单元测试框架.我们同样可以提供基于JUnit的实现,比如JUnitPerformance	performance()	根据提供的性能策略,指标和测试逻辑,进行性能测试
	job()	需要子类覆写,提供测试逻辑
	testers()	需要子类覆写,提供性能测试策略和指标要求

User Guide:

Step1:

    创建一个性能测试类,继承com.alibaba.tpsc.common.test.jtesterx.JTesterxPerformance
    在类名标注@Test (org.testng.annotations.Test),表明需要进行TestNG的单元测试
    备注:如果是在其他单元测试框架下,请自行扩展类似JUnitPerformacne实现

Step2:

覆写public Job job()方法.提供性能测试名和性能测试逻辑

@Override
public Job job() {
    return new Job("SampleService.hello") {
        @Override
        public void execute() {
            SampleService.hello();
        }
    };
}

Step3:

覆写public Collection testers().提供一组性能测试策略(并发数,单个并发循环次数) 和性能测试指标(平均响应时间)
性能测试工具会根据提供策略和指标,依次进行性能测试.

public Collection<PerformanceTester> testers() {
    Collection<PerformanceTester> testers = new ArrayList<PerformanceTester>();
    // 20个并发,单个并发循环1000次,平均响应时间阀值10ms
    testers.add(new PerformanceTester(20, 1000, 10));
    // 10个并发,单个并发循环1000次,平均响应时间阀值5ms
    testers.add(new PerformanceTester(10, 1000, 5));
    return testers;
}

Step4:

    右键点击Eclipse->Run As->TestNG Test.
    如果测试通过,则显示Green Bar
    如果测试未通过,则在Red Bar中显示:java.lang.AssertionError: performance expected is 1ms,but actual is 2.938ms.

工具代码和演示代码如下:
Demo下载

stone2083 2010-06-10 09:13 发表评论

编程方式实现SpringBean LazyInit

stone2083 — Thu, 03 Jun 2010 04:46:00 GMT

Tags:
Spring LazyInit DocumentDefaultsDefinition ReaderEventListener AbstractXmlApplicationContext

背景:
工程单元测试希望和生产环境应用共用一份Spring配置文件.
生产环境应用为了客户体验使用非LazyInit模式,但是单元测试下为了当前测试提高响应时间,希望设置LazyInit.

分析源代码,得知,Spring在解析XML时,会将Bean默认配置,放入到DocumentDefaultsDefinition对象中,其中包含lazyInit.
DocumentDefaultsDefinition注释如下:
Simple JavaBean that holds the defaults specified at the level in a standard Spring XML bean definition document: default-lazy-init, default-autowire, etc

Spring是否提供了入口点,进行DocumentDefaultsDefinition的修改呢?
详见:ReaderEventListener,注释如下:
Interface that receives callbacks for component, alias and import registrations during a bean definition reading process
在BeanDefinition分析过程中,对component,alias,import registrations,defaults registrations提供一组callbacks.

接口代码如下:

1 public interface ReaderEventListener extends EventListener {
2
3     /**
4      * Notification that the given defaults has been registered.
5      * @param defaultsDefinition a descriptor for the defaults
6      * @see org.springframework.beans.factory.xml.DocumentDefaultsDefinition
7      */
8     void defaultsRegistered(DefaultsDefinition defaultsDefinition);
9
10     /**
11      * Notification that the given component has been registered.
12      * @param componentDefinition a descriptor for the new component
13      * @see BeanComponentDefinition
14      */
15     void componentRegistered(ComponentDefinition componentDefinition);
16
17     /**
18      * Notification that the given alias has been registered.
19      * @param aliasDefinition a descriptor for the new alias
20      */
21     void aliasRegistered(AliasDefinition aliasDefinition);
22
23     /**
24      * Notification that the given import has been processed.
25      * @param importDefinition a descriptor for the import
26      */
27     void importProcessed(ImportDefinition importDefinition);
28
29 }

接下去分析,ReaderEventListener是在哪个入口点,提供了回调.答案是XmlBeanDefinitionReader.
在AbstractXmlApplicationContext,创建了XmlBeanDefinitionReader对象,见:

1 public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {
2
3     /**
4      * Loads the bean definitions via an XmlBeanDefinitionReader.
5      * @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader
6      * @see #initBeanDefinitionReader
7      * @see #loadBeanDefinitions
8      */
9     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
10         // Create a new XmlBeanDefinitionReader for the given BeanFactory.
11         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
12
13         // Configure the bean definition reader with this context's
14         // resource loading environment.
15         beanDefinitionReader.setResourceLoader(this);
16         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
17
18         // Allow a subclass to provide custom initialization of the reader,
19         // then proceed with actually loading the bean definitions.
20         initBeanDefinitionReader(beanDefinitionReader);
21         loadBeanDefinitions(beanDefinitionReader);
22     }
23
24 }

我们只需要去复写这个方法,在创建XmlBeanDefinitionReader的时候,去注入EventListener即可.

扩展代码如下:
LazyInitListener.java (不管配置文件如何配置,设置默认的LazyInit为true)

public class LazyInitListener implements ReaderEventListener {

    private static final String LAZY_INIT = "true";

    @Override
    public void defaultsRegistered(DefaultsDefinition defaultsDefinition) {
        //set lazy init true
        if (defaultsDefinition instanceof DocumentDefaultsDefinition) {
            DocumentDefaultsDefinition defaults = (DocumentDefaultsDefinition) defaultsDefinition;
            defaults.setLazyInit(LAZY_INIT);
        }
    }

    @Override
    public void aliasRegistered(AliasDefinition aliasDefinition) {
        //no-op
    }

    @Override
    public void componentRegistered(ComponentDefinition componentDefinition) {
        //no-op
    }

    @Override
    public void importProcessed(ImportDefinition importDefinition) {
        //no-op
    }

}

LazyInitClasspathXmlApplicationContext.java (复写AbstractXmlApplicationContext,创建XmlBeanDefinitionReader的时候注入LazyInitListener)

1 public class LazyInitClasspathXmlApplicationContext extends ClassPathXmlApplicationContext {
2
3     public LazyInitClasspathXmlApplicationContext(String location) {
4         super(location);
5     }
6
7     @Override
8     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
9         // Create a new XmlBeanDefinitionReader for the given BeanFactory.
10         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
11
12         // Configure the bean definition reader with this context's
13         // resource loading environment.
14         beanDefinitionReader.setResourceLoader(this);
15         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
16
17         // 添加的代码,设置LazyInitListener
18         beanDefinitionReader.setEventListener(new LazyInitListener());
19
20         // Allow a subclass to provide custom initialization of the reader,
21         // then proceed with actually loading the bean definitions.
22         initBeanDefinitionReader(beanDefinitionReader);
23         loadBeanDefinitions(beanDefinitionReader);
24     }
25
26 }

演示代码如下:
TestBean:一个Spring Bean对象

public class TestBean {

    public void init() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            //ignore
            System.out.println(e);
        }
        System.out.println("TestBean Init");
    }
}

Spring配置文件:

1 xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
5
6     <bean id="testBean" class="com.alibaba.javalab.spring.lazy.TestBean" init-method="init" />
7 beans>

测试代码:

1 public class Run {
2
3     private static final String CONFIG = "classpath:spring/bean.xml";
4
5     public static void main(String[] args) {
6         testInit();
7         System.out.println("===============================");
8         testLazyInit();
9     }
10
11     public static void testInit() {
12         new ClassPathXmlApplicationContext(CONFIG);
13     }
14
15     public static void testLazyInit() {
16         new LazyInitClasspathXmlApplicationContext(CONFIG);
17     }
18 }

大功告成.收工. :)

stone2083 2010-06-03 12:46 发表评论

Tomcat(6.0.14) Session创建机制简介

stone2083 — Fri, 26 Feb 2010 08:12:00 GMT

背景:
公司的一个web应用,提交给测试部门做压力测试(由于不是我负责的,不清楚如何做的压力测试,以及测试指标),结果没压多久,就出现OutOfMemory.
接手协助原因查找,通过监控工具,发现StandardSession(org.apache.catalina.session.StandardSession)对象不断增长,毫无疑问,肯定是在不断创建Session对象.
备注:一般做压力测试,每次请求都不会指定JESSESIONID值,导致Web容器认为每次请求都是新的请求,于是创建Session对象.
同事负责代码Review,发现应用没有任何一个地方存放Session内容.困惑之...

问题:Tomcat容器何时创建Session对象?
想当然认为,只有动态存放Session内容的时候,才会创建Session对象.但是事实真得如此吗?

先看Servlet协议描述:
请看:
getSession(boolean create)方法:

javax.servlet.http.HttpServletRequest.getSession(boolean create)

Returns the current HttpSession associated with this request or, if if there is no current session and create is true, returns a new session.

If create is false and the request has no valid HttpSession, this method returns null.

To make sure the session is properly maintained, you must call this method before the response is committed.

简单地说:当create变量为true时,如果当前Session不存在,创建一个新的Session并且返回.

getSession()方法:

javax.servlet.http.HttpSession getSession();

Returns the current session associated with this request, or if the request does not have a session, creates one.

简单的说:当当前Session不存在,创建并且返回.

所以说,协议规定,在调用getSession方法的时候,就会创建Session对象.

既然协议这么定了,我们再来看看Tomcat是如何实现的:(下面的描述,是基于Tomcat6.0.14版本源码)
先看一张简单的类图:

ApplicationContext:Servlet规范中ServletContext的实现
StandardContext:Tomcat定义的Context默认实现.维护了一份SessionManager对象,管理Session对象.所有的Session对象都存放在Manager定义的Map容器中.
StanardManager:标准的Session管理,将Session存放在内容,Web容器关闭的时候,持久化到本地文件
PersistentManager:持久化实现的Session管理,默认有两种实现方式:
--持久化到本地文件
--持久化到数据库

了解了大概的概念后,回头再来看看org.apache.catalina.connector.Request.getSession()是如何实现的.
最终调用的是doGetSession(boolean create)方法,请看:

protected Session doGetSession(boolean create) {

        // There cannot be a session if no context has been assigned yet
        if (context == null)
            return (null);

        // Return the current session if it exists and is valid
        if ((session != null) && !session.isValid())
            session = null;
        if (session != null)
            return (session);

        // Return the requested session if it exists and is valid
        Manager manager = null;
        if (context != null)
            manager = context.getManager();
        if (manager == null)
            return (null);      // Sessions are not supported
        if (requestedSessionId != null) {
            try {
                session = manager.findSession(requestedSessionId);
            } catch (IOException e) {
                session = null;
            }
            if ((session != null) && !session.isValid())
                session = null;
            if (session != null) {
                session.access();
                return (session);
            }
        }

        // Create a new session if requested and the response is not committed
        if (!create)
            return (null);
        if ((context != null) && (response != null) &&
            context.getCookies() &&
            response.getResponse().isCommitted()) {
            throw new IllegalStateException
              (sm.getString("coyoteRequest.sessionCreateCommitted"));
        }

        // Attempt to reuse session id if one was submitted in a cookie
        // Do not reuse the session id if it is from a URL, to prevent possible
        // phishing attacks
        if (connector.getEmptySessionPath()
                && isRequestedSessionIdFromCookie()) {
            session = manager.createSession(getRequestedSessionId());
        } else {
            session = manager.createSession(null);
        }

        // Creating a new session cookie based on that session
        if ((session != null) && (getContext() != null)
               && getContext().getCookies()) {
            Cookie cookie = new Cookie(Globals.SESSION_COOKIE_NAME,
                                       session.getIdInternal());
            configureSessionCookie(cookie);
            response.addCookieInternal(cookie, context.getUseHttpOnly());
        }

        if (session != null) {
            session.access();
            return (session);
        } else {
            return (null);
        }

    }

至此,简单地描述了Tomcat Session创建的机制,有兴趣的同学要深入了解,不妨看看Tomcat源码实现.

补充说明,顺便提一下Session的过期策略.
过期方法在:
org.apache.catalina.session.ManagerBase(StandardManager基类) processExpires方法:

public void processExpires() {

        long timeNow = System.currentTimeMillis();
        Session sessions[] = findSessions();
        int expireHere = 0 ;

        if(log.isDebugEnabled())
            log.debug("Start expire sessions " + getName() + " at " + timeNow + " sessioncount " + sessions.length);
        for (int i = 0; i < sessions.length; i++) {
            if (sessions[i]!=null && !sessions[i].isValid()) {
                expireHere++;
            }
        }
        long timeEnd = System.currentTimeMillis();
        if(log.isDebugEnabled())
             log.debug("End expire sessions " + getName() + " processingTime " + (timeEnd - timeNow) + " expired sessions: " + expireHere);
        processingTime += ( timeEnd - timeNow );

    }

其中,Session.isValid()方法会做Session的清除工作.

在org.apache.catalina.core.ContainerBase中,会启动一个后台线程,跑一些后台任务,Session过期任务是其中之一:

protected void threadStart() {

        if (thread != null)
            return;
        if (backgroundProcessorDelay <= 0)
            return;

        threadDone = false;
        String threadName = "ContainerBackgroundProcessor[" + toString() + "]";
        thread = new Thread(new ContainerBackgroundProcessor(), threadName);
        thread.setDaemon(true);
        thread.start();

    }

OVER :)

stone2083 2010-02-26 16:12 发表评论

布隆过滤器（BloomFilter）

stone2083 — Sat, 30 Jan 2010 07:00:00 GMT

资料：
wikipedia--bloom filter

使用场景，原理简介之中文资料：
数学之美系列二十一－布隆过滤器（Bloom Filter）

核心内容（摘自Google黑板报文章内容）：

BloomFilter简易实现：

public class SimpleBloomFilter {

    private static final int   DEFAULT_SIZE = 2 << 24;
    private static final int[] seeds        = new int[] { 7, 11, 13, 31, 37, 61, };

    private BitSet             bits         = new BitSet(DEFAULT_SIZE);
    private SimpleHash[]       func         = new SimpleHash[seeds.length];

    public static void main(String[] args) {
        String value = "stone2083@yahoo.cn";
        SimpleBloomFilter filter = new SimpleBloomFilter();
        System.out.println(filter.contains(value));
        filter.add(value);
        System.out.println(filter.contains(value));
    }

    public SimpleBloomFilter() {
        for (int i = 0; i < seeds.length; i++) {
            func[i] = new SimpleHash(DEFAULT_SIZE, seeds[i]);
        }
    }

    public void add(String value) {
        for (SimpleHash f : func) {
            bits.set(f.hash(value), true);
        }
    }

    public boolean contains(String value) {
        if (value == null) {
            return false;
        }
        boolean ret = true;
        for (SimpleHash f : func) {
            ret = ret && bits.get(f.hash(value));
        }
        return ret;
    }

    public static class SimpleHash {

        private int cap;
        private int seed;

        public SimpleHash(int cap, int seed) {
            this.cap = cap;
            this.seed = seed;
        }

        public int hash(String value) {
            int result = 0;
            int len = value.length();
            for (int i = 0; i < len; i++) {
                result = seed * result + value.charAt(i);
            }
            return (cap - 1) & result;
        }

    }

}

stone2083 2010-01-30 15:00 发表评论

httpclient ssl support

stone2083 — Sat, 30 Jan 2010 06:39:00 GMT

手头上一些工作，需要经常访问公司内网的数据，为了减少重复的劳动力，就考虑程序帮忙爬取信息数据。
apache下httpclient是一个很好的工具，不过公司内网是使用HTTPS协议的，于是乎，就需要考虑如何让httpclient支持https。
支持ssl的关键，在于如何创建一个SSLSocket，幸好，httpclient提供了支持。

请看：
org.apache.commons.httpclient.protocol.ProtocolSocketFactory
javadocs:A factory for creating Sockets.

实现一个简单的EasySSLProtocolSocketFactory，详见代码：

public class EasySSLProtocolSocketFactory implements ProtocolSocketFactory {

    private SSLContext sslcontext = null;

    private String     ksfile;
    private String     tksfile;
    private String     kspwd;
    private String     tkspwd;

    public EasySSLProtocolSocketFactory(String ks, String kspwd, String tks, String tkspwd){
        this.ksfile = ks;
        this.kspwd = kspwd;
        this.tksfile = tks;
        this.tkspwd = tkspwd;
    }

    public Socket createSocket(String host, int port, InetAddress clientHost, int clientPort) throws IOException,
                                                                                             UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port, clientHost, clientPort);
    }

    public Socket createSocket(final String host, final int port, final InetAddress localAddress, final int localPort,
                               final HttpConnectionParams params) throws IOException, UnknownHostException,
                                                                 ConnectTimeoutException {
        if (params == null) {
            throw new IllegalArgumentException("Parameters may not be null");
        }
        int timeout = params.getConnectionTimeout();
        SocketFactory socketfactory = getSSLContext().getSocketFactory();
        if (timeout == 0) {
            return socketfactory.createSocket(host, port, localAddress, localPort);
        } else {
            Socket socket = socketfactory.createSocket();
            SocketAddress localaddr = new InetSocketAddress(localAddress, localPort);
            SocketAddress remoteaddr = new InetSocketAddress(host, port);
            socket.bind(localaddr);
            socket.connect(remoteaddr, timeout);
            return socket;
        }
    }

    public Socket createSocket(String host, int port) throws IOException, UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(host, port);
    }

    public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException,
                                                                                       UnknownHostException {
        return getSSLContext().getSocketFactory().createSocket(socket, host, port, autoClose);
    }

    private SSLContext createEasySSLContext() {
        try {
            SSLContext context = SSLContext.getInstance("SSL");

            KeyManagerFactory kmf = KeyManagerFactory.getInstance("SunX509");
            TrustManagerFactory tmf = TrustManagerFactory.getInstance("SunX509");

            KeyStore ks = KeyStore.getInstance("JKS");
            KeyStore tks = KeyStore.getInstance("JKS");

            ks.load(new FileInputStream(ksfile), kspwd.toCharArray());
            tks.load(new FileInputStream(tksfile), tkspwd.toCharArray());

            kmf.init(ks, kspwd.toCharArray());
            tmf.init(tks);

            context.init(kmf.getKeyManagers(), tmf.getTrustManagers(), null);
            return context;
        } catch (Exception e) {
            throw new HttpClientError(e.toString());
        }
    }

    private SSLContext getSSLContext() {
        if (this.sslcontext == null) {
            this.sslcontext = createEasySSLContext();
        }
        return this.sslcontext;
    }

}

备注：
至于ssl相关的知识，和如何创建java key store，可见：
SSL双向认证java实现

如何使用，也简单：
Protocol.registerProtocol("https", new Protocol("https", new EasySSLProtocolSocketFactory(KS_FILE, KS_PWD, TKS_FILE, TKS_PWD), 443))

官方资料：
http://hc.apache.org/httpclient-3.x/sslguide.html

演示代码：
httpclient-ssl.zip

stone2083 2010-01-30 14:39 发表评论

Struts2.1.6--想用通配符，不容易

stone2083 — Sat, 26 Sep 2009 06:06:00 GMT

初次使用Struts2，老老实实为每个action method配置url mapping文件。
时间长了，难为觉得繁琐，为何不使用COC的方式呢？终于，想到了使用通配符。
查看Struts2 Docs，找到相关配置方法：

<package name="alliance" namespace="/alliance" extends="struts-default">
        <action name="*/*" class="cn.zeroall.cow.web.alliance.action.{1}Action" method="{2}">
            <result name="target" type="velocity">/templates/alliance/{1}/${target}.vmresult>
            <result name="success" type="velocity">/templates/alliance/{1}/{2}.vmresult>
            <result name="input" type="velocity">/templates/alliance/{1}/{2}.vmresult>
            <result name="fail" type="velocity">/templates/common/error.vmresult>
        action>
package>

恩，非常方便，可是启动jetty，发现满足正则的url，就是找不到Action。
无奈，debug代码，找到原因，需要在struts.properties中，配置：
struts.enable.SlashesInActionNames = true
见注释：

### Set this to true if you wish to allow slashes in your action names. If false,
### Actions names cannot have slashes, and will be accessible via any directory
### prefix. This is the traditional behavior expected of WebWork applications.
### Setting to true is useful when you want to use wildcards and store values
### in the URL, to be extracted by wildcard patterns, such as
### <action name="*/*" method="{2}" class="actions.{1}"> to match "/foo/edit" or
### "/foo/save".

启动，COC终于成功。

但是（又冒出一个但是），针对*/*正则的url mapping，如何做validation呢？
按照struts2的约定，是通过：
[package/]ActionName-${配置中的action name=""中的名字}-validation.xml

如何把"/"这个符号放入到${配置中的action name=""中的名字}呢？
"/"可不是一个合法的文件名。

比如，我要为AlliedMemberAction/doRegister做validation，那么约定的校验文件名应该是：
cn/zeroall/cow/web/alliance/action/AlliedMemberAction-AlliedMember/doRegister-validation.xml
这个特殊符号，可难刹我也。

无奈，继续debug，发现在代码：
xwork框架中的，AnnotationActionValidatorManager：

private  List<ValidatorConfig> buildAliasValidatorConfigs(Class aClass, String context, boolean checkFile) {
        String fileName = aClass.getName().replace('.', '/') + "-" + context + VALIDATION_CONFIG_SUFFIX;

        return loadFile(fileName, aClass, checkFile);
}

这个context就是action name=""中的url表达式。

思想斗争后，由于我不喜欢使用*-*的pattern,更喜欢使用*/*pattern，只好修改了源码：

private  List<ValidatorConfig> buildAliasValidatorConfigs(Class aClass, String context, boolean checkFile) {
        String fileName = aClass.getName().replace('.', '/') + "-" + context.replace("/", "-") + VALIDATION_CONFIG_SUFFIX;

        return loadFile(fileName, aClass, checkFile);
}

将context中的“/”变成"-"解决这个问题。

不清楚struts2官方怎么看待这个问题。

大家是否有更好的方案，请指教

stone2083 2009-09-26 14:06 发表评论

支付宝接口demo代码读后感

stone2083 — Fri, 18 Sep 2009 05:10:00 GMT

最近在帮朋友做一个支付功能，用到了支付宝。
从支付宝管理界面，下载到商户合作文档，看了demo程序后，心是拔凉拔凉的。
说说review代码后的问题吧:
CheckURL.java

public static String check(String urlvalue ) {

      String inputLine="";

        try{
                URL url = new URL(urlvalue);

                HttpURLConnection urlConnection  = (HttpURLConnection)url.openConnection();

                BufferedReader in  = new BufferedReader(
                        new InputStreamReader(
                                urlConnection.getInputStream()));

                inputLine = in.readLine().toString();
            }catch(Exception e){
                e.printStackTrace();
            }
            //System.out.println(inputLine);  系统打印出抓取得验证结果

        return inputLine;
  }

＊Inputstream不需要close？
＊知道e.printStackTrace()的性能代价？

Md5Encrypt.java
＊是采用什么编码的？我下载的是UTF8编码版本的，请问Md5Encrypt.java是什么编码？

Payment.java

public static String CreateUrl(String paygateway,String service,String sign_type,String out_trade_no,

                  String input_charset,String partner,String key,String seller_email,

                  String body,String subject,String price,String quantity,String show_url,String payment_type,

                  String discount,String logistics_type,String logistics_fee,String logistics_payment,

                  String return_url) {

                   //String notify_url,需要的请把参数加入以上的createurl

        Map params = new HashMap();

        params.put("service", service);

        params.put("out_trade_no", out_trade_no);

        params.put("show_url", show_url);

        params.put("quantity", quantity);

        params.put("partner", partner);

        params.put("payment_type", payment_type);

        params.put("discount", discount);

        params.put("body", body);

       // params.put("notify_url", notify_url);

        params.put("price", price);

        params.put("return_url", return_url);

        params.put("seller_email", seller_email);

        params.put("logistics_type", logistics_type);

        params.put("logistics_fee", logistics_fee);

        params.put("logistics_payment", logistics_payment);

        params.put("subject", subject);

        params.put("_input_charset", input_charset);

        String prestr = "";

        prestr = prestr + key;

        //System.out.println("prestr=" + prestr);

        String sign = com.alipay.util.Md5Encrypt.md5(getContent(params, key));

        String parameter = "";

        parameter = parameter + paygateway;

        //System.out.println("prestr="  + parameter);

        List keys = new ArrayList(params.keySet());

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

              String value =(String) params.get(keys.get(i));

            if(value == null || value.trim().length() ==0){

                continue;

            }

            try {

                parameter = parameter + keys.get(i) + "="

                    + URLEncoder.encode(value, input_charset) + "&";

            } catch (UnsupportedEncodingException e) {

                e.printStackTrace();

            }

        }

        parameter = parameter + "sign=" + sign + "&sign_type=" + sign_type;

        return sign;

    }

＊多少个参数啊？超过3，4个参数，都不使用ParameterClass吗？方便client调用吗？
＊这个方法做什么？createUrl?得到url。可事实上呢？return sign。sign是什么？是参数的加密窜。
方法中的parameter不知道要来干吗用？
＊又看到e.printStackTrace();

SignatureHelper.java
哇，总算看到一个过得去的代码，可以eclipse上，发现一个warning：import java.io.UnsupportedEncodingException;
有用到UnsupportedEncodingException这个吗？

SignatureHelper_return.java
＊看看这个类名，符合java类名的规范吗？
＊和SignatureHelper.java有什么区别？

SetCharacterEncodingFilter.java
哇塞，总算看到非常标准的代码了。可是：@author Craig McClanahan，原来是copy过来的。呜呼。

并且整个demo工程，是用myeclipse的。哎。。。

看不下去了，实在看不下去了。
我不清楚支付宝公司提供的demo程序的目的是什么？
－－提供的java文件是允许打成lib包使用的？
－－仅仅提供学习的？

就算是提供学习的，写得标准些，行不？

最后，我真希望，是我自己下错了demo程序－－这个demo程序不是支付宝官方的demo。希望如此吧，阿门～

备注：
除了demo，那份接口文档，写得还是非常规范的。

stone2083 2009-09-18 13:10 发表评论

Struts2.1.6 StrutsPrepareAndExecuteFilter bug

stone2083 — Mon, 08 Jun 2009 12:37:00 GMT

在用strust2.1.6做小项目，结果居然发现在post数据的时候，居然有乱码。
自认为对编码也算了解，立马check应用的content type，struts2配置的struts.locale，struts.i18n.encoding，没错，都是统一使用了UTF-8。
那是为什么呢？没办法，只能debug应用，结果发现：

public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {

        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) res;

        try {
            prepare.createActionContext(request, response);
            prepare.assignDispatcherToThread();
            prepare.setEncodingAndLocale(request, response);
            request = prepare.wrapRequest(request);
            ActionMapping mapping = prepare.findActionMapping(request, response);
            if (mapping == null) {
                boolean handled = execute.executeStaticResourceRequest(request, response);
                if (!handled) {
                    chain.doFilter(request, response);
                }
            } else {
                execute.executeAction(request, response, mapping);
            }
        } finally {
            prepare.cleanupRequest(request);
        }
    }

看到没？
1） prepare.createActionContext(request, response);
2） prepare.setEncodingAndLocale(request, response);
setEncodingAndLocale居然在createActionContext之后，在没有设置正确的encoding之前，解析request中的parameters，能成吗？

无奈之下，只能暂时用CharacterEncodingFilter这个filter设置request的character，猥琐地临时解决问题。

今天打算向Struts提交bug的时候，发现该bug在2.1.7版本中被修复，详见：https://issues.apache.org/struts/browse/WW-3075%3Bjsessionid=3EAC5B44A949CA77B4471AA0D45754E9?page=com.atlassian.jira.plugin.ext.subversion%3Asubversion-commits-tabpanel

哎，在使用2.1.7之前，先用CharacterEncodingFilter吧：）

stone2083 2009-06-08 20:37 发表评论

事件消息通知系统

stone2083 — Thu, 07 May 2009 13:49:00 GMT

在SOA架构中，JMS协议中的“点对点”消息方式，已经能够很好的支持1对1系统之间的通讯；
但是，类似事件消息的通知（应用产生一个事件消息，其他多个系统做相应处理），理论上JMS协议中的“订阅”方式，能够支持此类场景，不过协议说：在消息产生通知订阅者的时候，如果某个订阅者系统不在线，则消息丢失－－此订阅者接受不到消息。
并且，始终抱着对客户端简单，友好的态度，我希望client（应用）本身只要发出事件消息，并不需要去关注消息通知哪些订阅者，而这一切，应该由“事件消息通知系统”，代为完成。

经过昨天晚上空闲时间的思考，大概设计了“事件消息通知系统”的概念模型。（此概念模型，基于IP，路由，DNS思考得来）
详见下图：

概念解释：
1）Application：业务应用，一旦有事件消息产生，不再关注需要发送到哪些目的地，只需要统一发送到Event Message Center；

2）Event Message Center：一切事件消息的暂存地；

3）Event Message Router：事件消息路由器，根据Event Message Configuration Center（事件消息配置中心，即事件消息路由配置中心），将不同的消息，路由分发到不同的订阅者目的地；

4）Event Message Configuration Center：事件消息配置中心，即事件消息路由配置中心；

5）Event Message Registrar：事件消息登记中心，通过GUI界面，将Event Message Configuration Center中的路由信息展现给用户，并且允许用户进行事件消息路由信息的配置；

6）Event Message Subscription：事件消息订阅中心，同一类事件消息的暂存地；

7）Event Message Subscription Distributer：事件消息订阅分发者，根据Event Message Subscription Configuration Center（事件消息订阅配置中心）的配置信息，讲事件消息分发到不同的订阅者目的地；

8）Event Message Subscription Configuration Center：事件消息订阅配置中心，即事件消息订阅分发路由信息配置；

9）Event Message Subscription Registrar：事件消息订阅登记中心，通过GUI界面，将 Event Message Subscription Configuration Center中的分发路由信息展现给用户，并且允许用户进行事件消息订阅路由信息的配置；

10）Event Message Destination:事件消息目的地；

11）Event Message Consumer:不同订阅者的消费端

写下此随笔，仅仅把把自己对“事件消息系统”的感观认识记录。
由于思考和整理时间很短，此概念模型存在很多缺陷之处，还望大家多多指点。

stone2083 2009-05-07 21:49 发表评论

Velocity之EventHandler

stone2083 — Thu, 05 Feb 2009 14:26:00 GMT

Velocity在渲染页面的时候，提供了不同的EventHanlder，供开发者callback。
本文简要说明下，在Velocity1.6.1版本下，不同EventHanlder的作用：

EventHandler（接口）：
Base interface for all event handlers
仅仅是一个事件侦听标志

IncludeEventHandler（接口）：
Event handler for include type directives (e.g. #include(), #parse()) Allows the developer to modify the path of the resource returned.
在使用#include(),#parse()语法的时候，允许开发修改include或者parse文件的路径（一般用于资源找不到的情况）
IncludeNotFound（IncludeEventHandler实现类）：

Simple event handler that checks to see if an included page is available. If not, it includes a designated replacement page instead.By default, the name of the replacement page is "notfound.vm", however this page name can be changed by setting the Velocity property eventhandler.include.notfound, for example:

eventhandler.include.notfound = error.vm

当使用#include(),#parse()语法的时候，如果提供的资源文件找不到，则默认使用notfound.vm模板代替。

开发者可以通过设置eventhandler.include.notfound属性，修改替代模板的路径。

IncludeRelativePath（IncludeEventHandler实现类）：

Event handler that looks for included files relative to the path of the current template. The handler assumes that paths are separated by a forward slash "/" or backwards slash "\".

使用相对路径方式，寻找#include或者#parse()中指定的资源文件

InvalidReferenceEventHandler（接口）：

Event handler called when an invalid reference is encountered. Allows the application to report errors or substitute return values

当渲染页面的时候，一旦遇到非法的reference，就会触发此事件。开发者可以侦听此事件，用于错误的报告，或者修改返回的内容。

ReportInvalidReferences（InvalidReferenceEventHandler实现类）：

Use this event handler to flag invalid references.

使用这个实现类用于标志非法的references。修改eventhandler.invalidreference.exception属性，可以在捕捉到第一个非法references的时候，停止模板的渲染。

MethodExceptionEventHandler（接口）：

Event handler called when a method throws an exception. This gives the application a chance to deal with it and either return something nice, or throw. Please return what you want rendered into the output stream.

渲染模板，一旦发现调用的方法抛出异常的时候，就会触发此事件。允许开发者处理这个异常，输出友好信息或者抛出异常。必须返回一个值用于模板的渲染。

PrintExceptions（MethodExceptionEventHandler实现类）：

Simple event handler that renders method exceptions in the page rather than throwing the exception. Useful for debugging.

By default this event handler renders the exception name only. To include both the exception name and the message, set the property eventhandler.methodexception.message to true. To render the stack trace, set the property eventhandler.methodexception.stacktrace to true.

模板渲染时，遇到方法异常，输出异常名，而不是抛出这个异常。对于调式，非常有帮助。

通过eventhandler.methodexception.message和eventhandler.methodexception.stacktrace属性的设置，可以输出异常message和stacktrace.

NullSetEventHandler（接口）：

Event handler called when the RHS of #set is null. Lets an app approve / veto writing a log message based on the specific reference.

当使用#set()语法，设置一个null值的时候，会触发此事件。－－目前Velocity官方没有提供默认实现。

ReferenceInsertionEventHandler（接口）：

Reference 'Stream insertion' event handler. Called with object that will be inserted into stream via value.toString(). Please return an Object that will toString() nicely

当渲染变量（reference）的时候，就会触发此事件。允许开发者返回更加友好的值－－一般用于内容的escape，比如HtmlEscape等。

EscapeHtmlReference（ReferenceInsertionEventHandler实现类）：

html escape

EscapeJavaScriptReference（ReferenceInsertionEventHandler实现类）：

javascript escape

EscapeSqlReference（ReferenceInsertionEventHandler实现类）：

sql escape

EscapeXmlReference（ReferenceInsertionEventHandler实现类）：

xml escape

以上是Velocity组件中提供的EventHandler介绍。下面写一个简单的例子来说明EventHandler的使用。

模拟需求，假如输出的内容带有html标签，而输出的内容需要过滤这些标签。如果我们手工对输出变量通过StringEscapeUtils.escapeHtml()来实现，则太过繁琐。所以，我们就可以使用Velocity中的EscapeHtmlReference。demo代码如下：

VelocityEngine ve = new VelocityEngine();
EventCartridge eventCartridge = new EventCartridge();
eventCartridge.addEventHandler(new EscapeHtmlReference());

Context context = new VelocityContext();
context.put("name", "

");
eventCartridge.attachToContext(context);

StringWriter writer = new StringWriter();
ve.mergeTemplate(VM_LOCATION, "utf-8", context, writer);
System.out.println("================================");
System.out.println(writer.toString());
System.out.println("================================");

模板文件中，仅仅为 $name

则输出内容如下：

================================
<table></table>
================================

stone2083 2009-02-05 22:26 发表评论

ibatis支持枚举类型

stone2083 — Wed, 05 Nov 2008 15:08:00 GMT

很多应用中，数据库表结构都会存在一些状态字段。在关系性数据库中，一般会用VARCHAR类型。使用ibatis的应用，传统做法，往往会使用String的属性，与之对应。
例如一张member表，结构设计如下：

其中status为状态字段。

ibatis中，使用class MemberPO 与之mapping，设计往往如下：

public class MemberPO implements Serializable {
    private Integer id;
    private String loginId;
    private String password;
    private String name;
    private String profile;
    private Date gmtCreated;
    private Date gmtModified;
    private String status;

    //getter/setters
｝

缺点：
1）不直观，没人会知道status具体有哪些值。在缺乏文档，并且历史悠久的系统中，只能使用“select distinct(status) from member”，才能得到想要的数据。如果是在千万级数据中，代价太大了；
2）类型不安全，如果有人不小心拼写错误，将会导致错误状态。假设上面列子中，status只允许ENABLED／DISABLED，如果一不小心，memberPO.setStatus("ENABLEDD"),那么将会造成脏数据。

既然jdk5之后，引入了enum，是否可以让ibatis支持enum类型呢？事实上，最新的ibatis版本，已经支持enum类型（本文使用的是2.3.4.726版本－－mvn repsitory上最新的版本）。
以上代码可以修改成：
1）Status类：

public enum Status {

    /** enabled */
    ENABLED,

    /** disabled */
    DISABLED;

｝

2）MemberPO类：

除此之外，其他均无需改动。
为什么呢？ibatis如何知道VARCHAR／Enum的mapping呢？
看过ibatis源码的同学，知道，ibatis是通过jdbcType/javaType得到对应的TypeHandler做mapping处理的。ibatis有基本类型的TypeHandler，比如StringTypeHandler,IntegerTypeHandler等等。在最新版本中，为了支持enum，增加了一个EnumTypeHandler。

并且在TypeHandlerFactory中，加了对enum类型的判断，请看：

public TypeHandler getTypeHandler(Class type, String jdbcType) {
    Map jdbcHandlerMap = (Map) typeHandlerMap.get(type);
    TypeHandler handler = null;
    if (jdbcHandlerMap != null) {
      handler = (TypeHandler) jdbcHandlerMap.get(jdbcType);
      if (handler == null) {
        handler = (TypeHandler) jdbcHandlerMap.get(null);
      }
    }
    if (handler == null && type != null && Enum.class.isAssignableFrom(type)) {
      handler = new EnumTypeHandler(type);
    }
    return handler;
  }

ibatis使用了取巧的方法，当取不到基本类型的handler时候，判断javaType是否是Enum类型－－Enum.class.isAssignableFrom(type)，如果是，则使用 EnumTypeHandler进行mapping处理。

为什么说它取巧，原因是早期ibatis设计过程中，自定义的接口无法得到具体的java class type。故早期的ibatis中，要实现对enmu的支持，非常苦难。而新版本中，为了达到这个功能，作者直接修改了TypeHandlerFactory的实现，打了一个补丁，如下：

if (handler == null && type != null && Enum.class.isAssignableFrom(type)) {
handler = new EnumTypeHandler(type);
}

这个设计有悖于和早前的设计思想。早期，TypeHandler都是通过public void register(Class type, String jdbcType, TypeHandler handler)方式事先注册到factory中的，而这次，是在运行期，通过new方法动态得到EnumTypeHandler。
当然，新版本ibatis能支持enum，已经是一件开心的事情了。

Status枚举类除了描述状态，就足够了吗？回想起很多应用，我是做web开发的，在view层（velocity，jsp，等），见多了类似这样的代码：

#if($member.getStatus()==Status.ENABLED)开通#elseif($member.getStatus()==Status.DISABLED)关闭#end

<select>
<option value="ENABLED" #if($member.getStatus()==Status.ENABLED) selected="selected"#end >开通option>
<option value="DISABLED" #if($member.getStatus()==Status.DISABLED) selected="selected"#end >关闭option>
select>

web层需要多少个页面，就需要维护多少份这样的代码；以后每添加／删除一种状态，多个地方都需要修改，还要担心逻辑不一致。

而事实上，关于状态的信息描述，按照职责分，就应该由枚举类来维护：
1）制定一个接口，EnumDescription.java

public interface EnumDescription {

public String getDescription();

}

2）写一个ResourceBundleUtil.java，通过Properties文件得到描述信息：

public class ResourceBundleUtil {

    private ResourceBundle resourceBundle;

    public ResourceBundleUtil(String resource) {
    this.resourceBundle = ResourceBundle.getBundle(resource);
    }

    public ResourceBundleUtil(String resource, Locale locale) {
    this.resourceBundle = ResourceBundle.getBundle(resource, locale);
    }

    public String getProperty(String key) {
    return resourceBundle.getString(key);
    }

}

3）Status等枚举类实现EnumDescription：

public enum Status implements EnumDescription {

    /** enabled */
    ENABLED,

    /** disabled */
    DISABLED;

    private static ResourceBundleUtil util = new ResourceBundleUtil(Status.class.getName());

    public String getDescription() {
        return util.getProperty(this.toString());
    }

}

这样，有什么好处：
1）通过Properties文件，支持国际化。
2）描述信息统一由自己来维护，方便维护，并且显示层逻辑简化，如：

$member.getStatus().getDescription()

<select>
  #foreach($status in $Status.values())
    <option value="$status" #if($member.getStatus()==$status)selected="selected"#end >$status.getDescription()option>
  #end
select>

##############################################################################
那么使用老版本ibatis的客户怎么办呢？就像我们公司使用ibatis 2.3.0，难道只能眼馋着？解决方案：
1）升级到最新版本。：）
2）ibatis提供了TypeHandler/TypeHandlerCallback接口，针对每种枚举类型，写相应的TypeHandler/TypeHandlerCallback的接口实现即可－－工作量大，重复的劳动力。
主要是早期ibatis TypeHandler无法得到javaType类型，无法从jdbc value转成对应的枚举。在我看来，TypeHandler是作mapping用的，它至少有权知道javaType。
3）实现伪枚举类型（允许继承）来实现状态类型安全，而抛弃jdk5的方式－－不方便日后升级。

不知道大家是否还有更好的方案？

本文涉及演示代码如下：
演示代码
workspace file encoding：utf-8
build tool: maven
repository:spring/2.5.5;ibatis/2.3.4.726

stone2083 2008-11-05 23:08 发表评论

ajax原理简介以及简单demo演示

stone2083 — Sun, 21 Sep 2008 11:05:00 GMT

如今web应用上，ajax技术是大行其道。
ajax框架层出不穷，prototype，dojo，jquery，mootools，dwr，buffalo，ext，yui，spry。。。
ajax框架的出现，在提升开发生产效率的同时，也让不少同学不明其内在原理，仅仅成为了某些框架的使用者。
（对于产品生产是好事，对于技术追求是坏事）

本文不涉及任何ajax框架的使用，本文仅通过一个模拟需求，在不使用任何ajax框架的前提下，以demo演示的方式，
向大家介绍ajax的原理以及应用场景。

ajax全称是：Asynchronous JavaScript And XML。
其本意是，通过javascript技术（JavaScript），通过异步http请求方式（Asynchronous），得到XML文本内容（XML）之后，通过javascript技术局部刷新web页面内容。
从广义的概念看，只要符合“异步请求，局部刷新web页面”的技术，都可以成为ajax。
未必一定要使用javascript，一般情况下，大多数client端脚本代码都可以；返回内容也未必一定要是xml，目前json格式，更为流行。

如何异步请求内容呢？
以javascript代码作演示，如下：

参数一，url：表明异步请求的资源地址
参数二，func：表明请求结束后，采用什么函数对请求结果内容进行回调处理

其实，这一个js代码，就诠释了ajax的全部含义－－异步请求资源，将得到的资源内容，使用指定的function进行处理。
所以，ajax很简单，大家千万别被如今层出不穷的ajax框架给吓怕了。要了解ajax的原理，就只要参看这段代码即可。
如今的一些框架，仅仅在此基础上，是封装了一些公用的函数，方便开发人员调用。（当然，说说简单，其实所谓的这些函数，大大方便了开发人员使用ajax技术。具体请参看ajax framework的官方介绍。）

特别说明：这个xmlhttpost方法改进了simple-ajax。在原基础上，将回调方法作为参数传递。

解释了原理性的内容之后，接下来，以一个模拟的应用场景，demo说明ajax的使用，以及它的主要应用场景。
模拟场景：
目录选择，即当选择一个目录的时候，需要显示这个目录下的所有子目录。

首先，我们来虚拟一个目录结构，如下：

那么，要实现目录选择，有三个方式：
1）页面初始化的时候，服务端将所有的目录信息都put到页面中。
   优点：选择操作简单，有了全部的目录信息，做选择操作，都可以使用js完成，无需和服务端进行交互
   缺点：当目录信息很大的时候，比如有上万个节点，整个目录信息有1m左右大小，那么要渲染这个页面，估计得20秒左右（视网速）
并且，很可能用户仅仅只要选择有限的几个节点就可以，比如上万个节点中选择6－7个节点，那么浪费太大了；
2）页面初始化的时候，服务端将当前需要的节点信息put到页面上，一旦有选择操作，重新刷新页面。
   优点：选择操作简单，对于节点信息，每次取需要的内容，不存在浪费现象
   缺点：每次都要刷新整个页面，除节点信息外，其他不变的东西都需要重新从服务端取，增加无谓的消耗。
3）页面初始化的时候，服务端将当前需要的节点信息put到页面上，一旦有选择操作，只刷新节点相关的内容；
   优点：每次只load需要的信息，局部刷新页面内容，不存在任何浪费现象
   缺点：需要异步请求数据，每次请求都需要和服务器交互，选择操作稍显复杂（异步请求，局部刷新）

通过这三种方式做对比，发现ajax主要适用的场景如下：
1）整体内容量大（几百k，几m，甚至几十m），而页面只需要其中一小部分信息即可；
2）数据显示，只涉及一个页面中部分数据信息的变动；

特别说明：至于使用ajax性能如何，需要对1，3两个情况做性能测试，权衡使用。

针对第三种方案，
首先需要一个取节点资源的url，
演示代码中，为了演示方便，使用php语言，而非使用主要语言java；
tree_node.php

php
$id =  $_GET['id'];
if("1" == $id) {
  echo("{\"id\":1,\"parentId\":-1,\"name\":\"1-1\",\"children\":[{\"id\":2,\"name\":\"2-1\"},{\"id\":3,\"name\":\"2-2\"},{\"id\":4,\"name\":\"2-3\"}]}");
} else if("2" == $id) {
  echo("{\"id\":2,\"parentId\":1,\"name\":\"2-1\",\"children\":[]}");
} else if("3" == $id) {
  echo("{\"id\":3,\"parentId\":1,\"name\":\"2-2\",\"children\":[]}");
} else if("4" == $id) {
  echo("{\"id\":4,\"parentId\":1,\"name\":\"2-3\",\"children\":[{\"id\":5,\"name\":\"3-1\"},{\"id\":6,\"name\":\"3-2\"}]}");
} else if("5" == $id) {
  echo("{\"id\":5,\"parentId\":4,\"name\":\"3-1\",\"children\":[]}");
} else if("6" == $id) {
  echo("{\"id\":6,\"parentId\":4,\"name\":\"3-2\",\"children\":[{\"id\":7,\"name\":\"4-1\"}]}");
} else if("7" == $id) {
  echo("{\"id\":7,\"parentId\":6,\"name\":\"4-1\",\"children\":[]}");
} else {
  echo("");
}
?>

该文件中，写死了目录结构（一般情况下，往往根据树对象，动态取得需要的节点）。

通过js，动态请求节点信息，部分刷新页面内容：

nodeSelectAjax，异步请求节点资源
nodeSelect，回调函数，根据请求信息，局部刷新页面

至于请求资源信息格式，任何方式都可以，只要client端能解析就行。
目前json格式，比较流行。
最后，附上java使用json库，生成json格式的方法：

JSONObject node = new JSONObject();
node.put("id", 1);
node.put("parentId", -1);
node.put("name", "1-1");
JSONArray children = new JSONArray();
JSONObject c1 = new JSONObject();
c1.put("id", 2);
c1.put("name", "2-1");
JSONObject c2 = new JSONObject();
c2.put("id", 3);
c2.put("name", "2-2");
children.put(c1);
children.put(c2);
node.put("children", children);
System.out.println(node.toString());

ajax demo
工程文件编码：utf－8
工程运行：http server with php supported
ubuntu firefox下测试通过

其他：
不知道是不是ie的bug，居然不支持 select.innerHTML = value的方式
只能通过select.options.add(new Option("content","value") 动态往select中添加选项。

stone2083 2008-09-21 19:05 发表评论

单元测试分享

stone2083 — Thu, 17 Jul 2008 14:04:00 GMT

最近，在小组内部做了一次关于“单元测试”的分享。把自己两年来做单元测试遇到的问题和对单元测试的认识做了一次总结和讨论。

本文不会详细地讲述分享的内容，仅仅是ppt的大纲显示：

使用单元测试前提：
最小的成本，换来最大的收益

单元测试目的：
1）测试代码错误(?) －－不是主要目的
2）便于重构时的测试
3）改善既有代码的设计

分享核心：
1）如何脱离“webx“－－做隔离测试
2）dal／biz／web 层如何做单元测试
3）如何通过改善代码设计，更方便测试

dal层（数据库访问层）特点：
1)独立，逻辑单一，对表做操作
2)业务相对比较稳定
3)采用ibatis，写sql的方式

dal层测试方式：
1）压根儿就不需要测试
2）仅仅配置spring bean，通过日志打印的方式（无法达到自检）
3) 自检方式 -- AbstractTransactionalDataSourceSpringContextTests （高成本，不轻易使用）
需要权衡

biz层（业务层）测试方式－－分BO和AO：
BO：（即所谓的Service／Manager）
AO：（一个UseCase对应的业务流）
隔离＋设计（主要通过代码演示－－见附件）

单元测试的缺点：
专注于单一业务测试，衔接点容易出错

解决方案：
接口输入输出明确
集成测试

web层：
集成测试的入口

分享文档和演示代码（ppt是在ubuntu下制作，可能效果并不是很好）

备注：
自己对单元测试了解也比较肤浅，欢迎一起探讨

stone2083 2008-07-17 22:04 发表评论