二。伪零拷贝(zero copy)方式文件下载示范

outputstream out = response.getoutputstream();
writablebytechannel outchannel = channels.newchannel(out);

public static writablebytechannel newchannel(final outputstream out) {
 if (out == null) {
     throw new nullpointerexception();
 }

        if (out instanceof fileoutputstream &&
     fileoutputstream.class.equals(out.getclass())) {
                return ((fileoutputstream)out).getchannel();
        }

 return new writablebytechannelimpl(out);
    }

private static class writablebytechannelimpl
        extends abstractinterruptiblechannel // not really interruptible
        implements writablebytechannel
    {
        outputstream out;
        private static final int transfer_size = 8192;
        private byte buf[] = new byte[0];
        private boolean open = true;
        private object writelock = new object();

        writablebytechannelimpl(outputstream out) {
            this.out = out;
        }

        public int write(bytebuffer src) throws ioexception {
            int len = src.remaining();
            int totalwritten = 0;
            synchronized (writelock) {
                while (totalwritten < len) {
                    int bytestowrite = math.min((len - totalwritten),
                                                transfer_size);
                    if (buf.length < bytestowrite)
                        buf = new byte[bytestowrite];
                    src.get(buf, 0, bytestowrite);
                    try {
                        begin();
                        out.write(buf, 0, bytestowrite);
                    } finally {
                        end(bytestowrite > 0);
                    }
      totalwritten  = bytestowrite;
                }
                return totalwritten;
            }
        }

        protected void implclosechannel() throws ioexception {
            out.close();
            open = false;
        }
    }

不过那是一个php版本，我下载到本地php但无法部署成功；还好有一个示范，还提供一个在线版，试用之后，再下载源代码，ruby sinatra mvc结构，看的流口水，代码那般简洁。

为体验redis，同时也为对比ruby代码，因此诞生了retwis-java，retwis-rb的山寨版，因此其逻辑和html资源一致，再次表示对原作者的感谢。

retwis-java，基于servlet 3.0 urlrewrite freemarker jedis。示范运行在tomcat 7中，redis为最新的2.22版本，jedis为redis的java客户端操作框架。在servlet 3.0规范中，对url映射处理依然没有进步，因此只能使用urlrewrite框架让部分url看起来友好一些。另外，项目没有使用ioc容器框架，没有使用mvc框架，代码量稍微多些，代码相对耦合一些。若使用struts2 spring 代码量会少一些。

对涉及到的redis存储结构，大致如下：

涉及到的两个对象很简单：

序列化后以二进制数据保存到redis中：

获取用户的timeline时，redis的lrange命令提供对list类型数据提供分页操作：

很显然，lrange取出了status对象的id，然后我们需要再次根据id获取对应的status对象二进制数据，然后反序列化：

以上使用jdk内置的序列化支持；更多序列化，可参考hessian、google protobuf等序列化框架，后者提供业界更为成熟的跨平台、更为高效的序列化方案。更多代码请参见附件。

一些总结和思考：

1. 不仅仅是缓存，替代sql数据库已完全成为可能，更高效，更经济；虽然只是打开了一扇小的窗户，但说不准以后人们会把大门打开。
2. 实际环境中，可能最佳方式为sql nosql配合使用，互相弥补不足；还好，redis指令不算多，可速查，简单易记。
3. java和ruby代码相比，有些重

另：

在线版，请参考 http://retwisrb.danlucraft.com/。那个谁谁，要运行范例，保证redis运行才行。

参考资料：

若一个servlet对应多个url映射，那么将会生成一个还是多个servlet实例呢？

最好的办法就是动手体验一下

@webservlet({ "/demoservlet1", "/demoservlet2" })

public class demoservlet extends httpservlet {

private static final long serialversionuid = 1l;



protected void doget(httpservletrequest request,

httpservletresponse response) throws servletexception, ioexception {

printwriter out = response.getwriter();

out.println(request.getservletpath()   "["   this   "]");

out.flush();

out.close();

}

}

输出结果：

/demoservlet1[com.learn.servlet3.thread.demoservlet@1320a41]
/demoservlet2[com.learn.servlet3.thread.demoservlet@9abce9]

输出结果可以看到映射/demoservlet1和/demoservlet2对应servlet实例是不同的。

结果证明：servlet将为每一个url映射生成一个实例;一个servlet可能存在多个示例，但每一个实例都会对应不同的url映射。

下面讨论单个servlet、多线程情况下保证数据线程同步的几个方法。

1. synchronized：代码块，方法
   大家都会使用的方式，不用详细介绍了。
   建议优先选择修饰方法。
2. volatile
   轻量级的锁，可以保证多线程情况单线程读取所修饰变量时将会强制从共享内存中读取最新值，但赋值操作并非原子性。
   一个具有简单计数功能servlet示范：
   

   /**
   
       * 使用volatile作为轻量级锁作为计数器
   
       * 
   
       * @author yongboy
   
       * @date 2011-3-12
   
       * @version 1.0
   
       */
   
       @webservlet("/volatilecountdemo")
   
       public class volatilecountservlet extends httpservlet {
   
       private static final long serialversionuid = 1l;
   
       
   
       private volatile int num = 0;
   
       
   
       protected void doget(httpservletrequest request,
   
       httpservletresponse response) throws servletexception, ioexception {
   
       addone();
   
       response.getwriter().write("now access num : "   getnum());
   
       }
   
       
   
       /**
   
       * 读取开销低
   
       */
   
       private int getnum() {
   
       return num;
   
       }
   
       
   
       /**
   
       * 其写入为非线程安全的，赋值操作开销高
   
       */
   
       private synchronized void addone() {
   
       num   ;
   
       }
   
       }
   
       

   我们在为volatile修饰属性赋值时，还是加把锁的。
3. threadlocal
   可以保证每一个线程都可以独享一份变量副本，每个线程可以独立改变副本，不会影响到其它线程。
   这里假设多线程环境一个可能落显无聊的示范，初始化一个计数，然后循环输出：

   @webservlet("/threadlocalservlet")
   
       public class threadlocalservlet extends httpservlet {
   
       private static final long serialversionuid = 1l;
   
       
   
       private static threadlocal threadlocal = new threadlocal() {
   
       @override
   
       protected integer initialvalue() {
   
       return 0;
   
       }
   
       };
   
       
   
       protected void doget(httpservletrequest request,
   
       httpservletresponse response) throws servletexception, ioexception {
   
       response.setheader("connection", "keep-alive");
   
       
   
       printwriter out = response.getwriter();
   
       out.println("start... "    " ["   thread.currentthread()   "]");
   
       out.flush();
   
       
   
       for (int i = 0; i < 20; i  ) {
   
       out.println(threadlocal.get());
   
       out.flush();
   
       
   
       threadlocal.set(threadlocal.get()   1);
   
       }
   
       
   
       // 手动清理，当然随着当前线程结束，亦会自动清理调
   
       threadlocal.remove();
   
       out.println("finish... ");
   
       out.flush();
   
       out.close();
   
       }
   
       } 

   若创建一个对象较为昂贵，但又是非线程安全的，在某种情况下要求仅仅需要在线程中独立变化，不会影响到其它线程。选择使用threadlocal较好一些，嗯，还有，其内部使用到了weakhashmap，弱引用，当前线程结束，意味着创建的对象副本也会被垃圾回收。
   hibernate使用threadlocal创建session;spring亦用于创建对象会使用到一点。
   嗯，请注意这不是解决多线程共享变量的钥匙，甚至你想让某个属性或对象在所有线程中都保持原子性，显然这不是凯发天生赢家一触即发官网的解决方案。
4. lock
   没什么好说的，现在jdk版本支持显式的加锁，相比synchronized，添加与释放更加灵活，功能更为全面。

   @webservlet("/lockservlet")
   
       public class lockservlet extends httpservlet {
   
       private static final long serialversionuid = 1l;
   
       
   
       private static int num = 0;
   
       private static final lock lock = new reentrantlock();
   
       
   
       protected void doget(httpservletrequest request, httpservletresponse response) throws servletexception, ioexception {
   
       try{
   
       lock.lock();
   
       num   ;
   
       response.getwriter().println(num);
   
       }finally{
   
       lock.unlock();
   
       }
   
       }
   
       }
   
       

   必须手动释放锁，否则将会一直锁定。
5. wait/notify
   较老的线程线程同步方案，较之lock，不建议再次使用。
6. 原子操作
   原子包装类，包括一些基本类型(int, long, double, boolean等)的包装，对象属性的包装等。

   @webservlet("/atomicservlet")
   
       public class atomicservlet extends httpservlet {
   
       private static final long serialversionuid = 1l;
   
       private static final atomicinteger num = new atomicinteger(0);
   
       
   
       protected void doget(httpservletrequest request,
   
       httpservletresponse response) throws servletexception, ioexception {
   
       printwriter out = response.getwriter();
   
       out.println(num.incrementandget());
   
       out.flush();
   
       out.close();
   
       }
   
       }
   
       

   包装类提供了很多的快捷方法，比如上面的incrementandget方法，自身增加1,然后返回结果值，并且还是线程安全的，省缺了我们很多手动、笨拙的编码实现。
   更多原子类，请参见 java.util.concurrent.atomic包。
7. 一些建议
   尽量不要在servlet中单独启用线程
   使用尽可能使用局部变量
   尽可能避免使用锁
8. 数据结构小结
   在平常环境下使用的一些数据结构，在多线程并发环境下可选择使用java.util.concurrent里内置替代品。下面有一个小结，仅供参考。

servlet线程安全有很太多的话题要说，以上仅仅为蜻蜓点水，真正需要学习和实践的还有一段长路要学习。另，话说，这里已和servlet版本无关，是知识积累和分享。

1. 隐藏iframe(hidden iframe)
   服务器端一般会输出一段javascript脚本
   
   好处在于各个浏览器都支持iframe，目前在ie、firefox下面效果最好，页面不再显示正在加载中的讨厌的提示（见）
2. xmlhttprequest
   很可怜，目前支持情况最好的是火狐浏览器、ie8以及safari
   参考文章：
   
   。

1. xhr方式长轮询（xmlhttprequest long polling)
   服务器端可以返回原始的数据，也可以返回格式化的json、xml、javascript信息，相比iframe形式流推送，更自由一些。使用形式和传统意义上的ajax get方式大致一样，只不过下一次的轮询需要等到有数据返回处理完方可。
   默认不支持跨域，实践中会打折扣。
2. javascript标签轮询（script tag long polling）
   可能翻译不太准确，主要使用类似于如下形式：
   使用跨域的js脚本，可能会有安全方面隐患，或许这个间接风险是可控的。
   也可以使用用以规避这个风险。
   进阶阅读：
   代码写的很巧妙，也很简短，思路不错，推荐一看。
   参考文章：
   
   

bigpipe是一个重新设计的基础动态网页服务体系。大体思路是，分解网页成叫做pagelets的小块，然后通过web服务器和浏览器建立管道并管理他们在不同阶段的运行。这是类似于大多数现代微处理器的流水线执行过程：多重指令管线通过不同的处理器执行单元，以达到性能的最佳。虽然bigpipe是对现有的服务网络基础过程的重新设计，但它却不需要改变现有的网络浏览器或服务器，它完全使用php和javascript来实现。

1. 请求解析：web服务器解析和完整性检查的http请求。
2. 数据获取：web服务器从存储层获取数据。
3. 标记生成：web服务器生成的响应的html标记。
4. 网络传输：响应从web服务器传送到浏览器。
5. css的下载：浏览器下载网页的css的要求。
6. dom树结构和css样式：浏览器构造的dom文档树，然后应用它的css规则。
7. javascript中下载：浏览器下载网页中javascript引用的资源。
8. javascript执行：浏览器的网页执行javascript代码。

1. ajax方式请求长轮询
   
   服务器端可以返回原始的数据，或格式化的json、xml、javascript信息，客户端可拥有更多的处理自由。在形式上和传统意义上的ajax get方式大致一样，只不过下一次的轮询需要等到上一次的轮询数据返回处理完方可进行。
   这里给出客户端的小示范：
   
   基于jquery 1.5,事件链，比以往更简洁明了，尤其是在done方法中又一次调用自身，棒极了。
   服务器端很简单，每1秒输出一次当前系统时间:
   

   /**
    * 简单模拟每秒输出一次当前系统时间，精细到毫秒
    * 
    * @author yongboy
    * @date 2011-2-11
    * @version 1.0
    */
   @webservlet("/getnexttime")
   public class getnexttimeservlet extends httpservlet {
    private static final long serialversionuid = 1l;
   
    protected void doget(httpservletrequest request,
      httpservletresponse response) throws servletexception, ioexception {
     try {
      thread.sleep(1000l);
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
   
     response.setcontenttype("text/plain");
     printwriter out = response.getwriter();
   
     out.print(dateformatutils.format(system.currenttimemillis(),
       "yyyy-mm-dd hh:mm:ss sss"));
     out.flush();
   
     out.close();
    }
   }
   

2. javascript标签轮询（script tag long polling）
   
   引用的javascript脚本文件是可以跨域的，再加上,更为强大了。
   这里给出一个演示，实现功能类似上面。
   客户端清单：
   
   
   服务器端清单:
   

   /**
    * jsonp形式简单模拟每秒输出一次当前系统时间，精细到毫秒
    * @author yongboy
    * @date 2011-2-11
    * @version 1.0
    */
   @webservlet("/getnexttime2")
   public class getnexttimeservlet2 extends httpservlet {
    private static final long serialversionuid = 1l;
   
    protected void doget(httpservletrequest request,
      httpservletresponse response) throws servletexception, ioexception {
     try {
      thread.sleep(1000l);
     } catch (interruptedexception e) {
      e.printstacktrace();
     }
   
     string callback = request.getparameter("callback");
     
     if(stringutils.isblank(callback)){
      callback = "showresult";
     }
   
     printwriter out = response.getwriter();
   
     stringbuilder resultbuilder = new stringbuilder();
     resultbuilder
       .append(callback)
       .append("('")
       .append(dateformatutils.format(system.currenttimemillis(), "yyyy-mm-dd hh:mm:ss sss"))
       .append("');");
   
     out.print(resultbuilder);
     out.flush();
   
     out.close();
    }
   }
   

   
   每次请求时，都会在html头部生成一个js网络地址(实现跨域):
   

   http://192.168.0.99:8080/servlet3/getnexttime2?callback=jquery150832738454006945_1297761629067&_=1297761631777

   我们不用指定，jquery会自动生成一个随机的函数名。
   请求上面地址服务器端在有新的数据输出时，生成的回调js函数：
   

   jquery150832738454006945_1297761629067('2011-02-15 17:20:33 921');

   从下面截图可以看到这一点。
   
   生成相应内容：
   
   
    不过，长连接情况下，浏览器认为当前js文件还没有加载完，会一直显示正在加载中。

    
    








loading ...

/**
 * jsonp获取最新信息
 * 
 * @author yongboy
 * @date 2011-2-17
 * @version 1.0
 */
@webservlet(urlpatterns = "/getjsonpnew", asyncsupported = true)
public class getnewjsonpblogposts extends httpservlet {
 private static final long serialversionuid = 565698895565656l;
 private static final log log = logfactory.getlog(getnewjsonpblogposts.class);

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  response.setheader("cache-control", "private");
  response.setheader("pragma", "no-cache");
  response.setheader("connection", "keep-alive");
  response.setheader("proxy-connection", "keep-alive");
  response.setcontenttype("text/javascript;charset=utf-8");
  response.setcharacterencoding("utf-8");

  string timeoutstr = request.getparameter("timeout");

  long timeout;

  if (stringutils.isnumeric(timeoutstr)) {
   timeout = long.parselong(timeoutstr);
  } else {
   // 设置1分钟
   timeout = 1l * 60l * 1000l;
  }

  log.info("new request ...");
  final httpservletresponse finalresponse = response;
  final httpservletrequest finalrequest = request;
  final asynccontext ac = request.startasync(request, finalresponse);
  // 设置成长久链接
  ac.settimeout(timeout);
  ac.addlistener(new asynclistener() {
   public void oncomplete(asyncevent event) throws ioexception {
    log.info("oncomplete event!");
    newblogjsonplistener.async_ajax_queue.remove(ac);
   }

   public void ontimeout(asyncevent event) throws ioexception {
    // 尝试向客户端发送超时方法调用，客户端会再次请求/blogpush，周而复始
    log.info("ontimeout event!");

    // 通知客户端再次进行重连
    final printwriter writer = finalresponse.getwriter();

    string outstring = finalrequest.getparameter("callback")
      "({state:0,error:'timeout is now'});";
    writer.println(outstring);
    writer.flush();
    writer.close();
    
    newblogjsonplistener.async_ajax_queue.remove(ac);
   }

   public void onerror(asyncevent event) throws ioexception {
    log.info("onerror event!");
    newblogjsonplistener.async_ajax_queue.remove(ac);
   }

   public void onstartasync(asyncevent event) throws ioexception {
    log.info("onstartasync event!");
   }
  });

  newblogjsonplistener.async_ajax_queue.add(ac);
 }
}

/**
 * 监听器单独线程推送到客户端
 * 
 * @author yongboy
 * @date 2011-2-17
 * @version 1.0
 */
@weblistener
public class newblogjsonplistener implements servletcontextlistener {
 private static final log log = logfactory.getlog(newbloglistener.class);
 public static final blockingqueue blog_queue = new linkedblockingqueue();
 public static final queue async_ajax_queue = new concurrentlinkedqueue();

 public void contextdestroyed(servletcontextevent arg0) {
  log.info("context is destroyed!");
 }

 public void contextinitialized(servletcontextevent servletcontextevent) {
  log.info("context is initialized!");
  // 启动一个线程处理线程队列
  new thread(runnable).start();
 }

 private runnable runnable = new runnable() {
  public void run() {
   boolean isdone = true;

   while (isdone) {
    if (!blog_queue.isempty()) {
     try {
      log.info("async_ajax_queue size : "
          async_ajax_queue.size());
      micblog blog = blog_queue.take();

      if (async_ajax_queue.isempty()) {
       continue;
      }

      string targetjson = buildjsonstring(blog);

      for (asynccontext context : async_ajax_queue) {
       if (context == null) {
        log.info("the current async_ajax_queue is null now !");
        continue;
       }
       log.info(context.tostring());
       printwriter out = context.getresponse().getwriter();

       if (out == null) {
        log.info("the current async_ajax_queue's printwriter is null !");
        continue;
       }

       out.println(context.getrequest().getparameter(
         "callback")
           "("   targetjson   ");");
       out.flush();

       // 通知，执行完成函数
       context.complete();
      }
     } catch (exception e) {
      e.printstacktrace();
      isdone = false;
     }
    }
   }
  }
 };

 private static string buildjsonstring(micblog blog) {
  map info = new hashmap();
  info.put("state", 1);
  info.put("content", blog.getcontent());
  info.put("date",
    dateformatutils.format(blog.getpubdate(), "hh:mm:ss sss"));

  jsonobject jsonobject = jsonobject.fromobject(info);

  return jsonobject.tostring();
 }
}

apache决定不在tomcat中添加对java ee 6 web profile的完整支持，至少在眼下是这样的。因此tomcat 7中只是简单地增加了（java ee 6中引入的）的支持以及。新版本要求使用java se 6或更高版本。

tomcat 7中的改进也不是全都针对servlet 3.0 api的，其中还有不少重要的安全性改进。现在针对基于脚本的访问、基于web的访问、jmx代理访问和状态页访问有了独立的角色，允许做更具体的访问控制。为了避免跨站请求伪造（csrf）攻击，所有的非幂等性请求（即多次执行不会产生相同结果的操作）都要求生成一个随机数。tomcat 7还针对会话固定攻击（session fixation attack）采取了一些防御措施。会话固定攻击就是将客户端的会话id强制设置为一个明确的已知值。

以前的实现

/**
 * 自定义会话cookie属性
 * @author yongboy
 * @date 2011-1-19
 * @version 1.0
 */
@webfilter(dispatchertypes = { dispatchertype.request }, urlpatterns = { "/*" })
public class customcookiefilter implements filter {
 private static final log log = logfactory.getlog(customcookiefilter.class);
 private static final string custom_session_id = "yongboyid";
 private static final string http_only = "httponly";
 private static final string set_cookie = "set-cookie";

 public void destroy() {
 }

 public void dofilter(servletrequest req, servletresponse rep,
   filterchain chain) throws ioexception, servletexception {
  httpservletrequest request = (httpservletrequest) req;
  httpservletresponse response = (httpservletresponse) rep;

  if (response.containsheader(set_cookie)) {
   log.info("haha,we have one new user visit the site ...");

   string sessionid = request.getsession().getid();
   string cookievalue = custom_session_id   "="   sessionid   ";path="
       request.getcontextpath()   ";"   http_only;

   log.info(set_cookie   ":"   cookievalue);
   
   response.setheader(set_cookie, cookievalue);
  }

  chain.dofilter(req, response);
 }

 public void init(filterconfig fconfig) throws servletexception {
 }
}

新的规范api

1. setname(string name)
   修改session id的名称，默认为"jsessionid"
2. setdomain(string domain)
   设置当前cookie所处于的域
3. setpath(string path)
   设置当前cookie所处于的相对路径
4. sethttponly(boolean httponly)
   设置是否支持httponly属性
5. setsecure(boolean secure)
   若使用https安全连接,则需要设置其属性为true
6. setmaxage(int maxage)
   设置存活时间，单位为秒

/** 全局设置session-cookie相交互部分属性
 * 
 * @author yongboy
 * @date 2011-1-19
 * @version 1.0
 */
@weblistener
public class sessioncookieinitialization implements servletcontextlistener {
 private static final log log = logfactory
   .getlog(sessioncookieinitialization.class);

 public void contextinitialized(servletcontextevent sce) {
  log.info("now init the session cookie");

  servletcontext servletcontext = sce.getservletcontext();

  sessioncookieconfig sessioncookie = servletcontext
    .getsessioncookieconfig();
  sessioncookie.setname("yongboyid");
  sessioncookie.setpath(servletcontext.getcontextpath());
  sessioncookie.sethttponly(true);
  sessioncookie.setsecure(false);

  log.info("name : "   sessioncookie.getname()   "\n"   "domain:"
      sessioncookie.getdomain()   "\npath:"
      sessioncookie.getpath()   "\nage:"
      sessioncookie.getmaxage());

  log.info("ishttponly : "   sessioncookie.ishttponly());
  log.info("issecure : "   sessioncookie.issecure());
 }

 public void contextdestroyed(servletcontextevent sce) {
  log.info("the context is destroyed !");
 }
}

不同浏览器平台上测试

1. 在safari、ie8、opera 11 一切都很正常
2. firefox 3.6、chrome 9.0，jsessionid会继续存在:
   

   yongboyid=601a6c82d535343163b175a4fd5376ea; jsessionid=aa78738ab1ead1f9c649f705ec64d92d; ajstat_ok_times=6; jsessionid=abcpxyjmipbvz6whvo_1s; bayeux_browser=439-1vyje1gmqt8y8giva7pqsu1

3. 在所有浏览器中，session id等于新设置的yongboyid值（若不相等，问题就严重了！）
4. 在客户端js无法获得正确的sessioni id了。

...

http://localhost/servlet3/sessioncookietest;yongboyid=19b94935d50245270060e49c9e69f5b6

进阶阅读：

1. startasync(servletrequest, servletresponse) 传入指定的request和response对象，便于在asynccontext中重复使用（这样被filter、servlet包装过的请求、相应对象才会在异步的环境下继续生效）。
2. startasync() 若request或者response被包装，将失去预期的效果。
3. isasyncsupported() 和 isasyncstarted()
   辅助性的方法，用于判断当前请求是否支持异步或者异步已经开始。
4. getasynccontext()
   需要在异步启动之后才能够访问，否则会报异常。

1. asynccontext.dispatch()
   若当前asynccontext由servletrequest.startasync(servletrequest, servletresponse)方法启动，返回的地址可以通过httpservletrequest.getrequesturi()得到。
   否则，分发的地址则是当前url request对象最后一次分发的地址。
   虽有些拗口，两者分发的地址大部分情况下一致;但尽量使用带有参数的异步上下文启动器。
   如本例中请求/asyncdispatch2async?disurl=self，执行dispatch()方法之后，自身会再次分发到自身，包括传递的参数。
2. asynccontext.dispatch(string path)
   等同于servletrequest.getrequestdispatcher(string)，算是一个快捷方法。
   可以转向一个同步或异步的servlet，或者jsp，或其它资源地址等。
   
3. asynccontext.dispatch(servletcontext context, string path)
   请求的地址将在给定的上下文里面（servletcontext），有有可能传入的上下文与当前站带你应用的上下文有所区别。
   

/**
 * 异步上下文的转向分发
 * 
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
@webservlet(urlpatterns = { "/asyncdispatch2async" }, asyncsupported = true)
public class asynccontextdispatch2asyncservlet extends httpservlet {
 private static final long serialversionuid = 46172233331022236l;
 private static final log log = logfactory
   .getlog(asynccontextdispatch2asyncservlet.class);

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  response.setheader("cache-control", "private");
  response.setheader("pragma", "no-cache");
  response.setheader("connection", "keep-alive");
  response.setheader("proxy-connection", "keep-alive");
  response.setcontenttype("text/html;charset=utf-8");

  printwriter out = response.getwriter();
  out.println("

start ...

");
  out.flush();

  if (!request.isasyncsupported()) {
   log.info("the servlet is not supported async");
   return;
  }

  request.startasync(request, response);

  if (request.isasyncstarted()) {
   asynccontext asynccontext = request.getasynccontext();
   asynccontext.settimeout(1l * 60l * 1000l);// 60sec

   new counterthread(asynccontext).start();
  } else {
   log.error("the ruquest is not asyncstarted !");
  }
 }

 private static class counterthread extends thread {
  private asynccontext asynccontext;

  public counterthread(asynccontext asynccontext) {
   this.asynccontext = asynccontext;
  }

  @override
  public void run() {
   int interval = 1000 * 20; // 20sec

   try {
    log.info("now sleep 20s, just as do some big task ...");
    thread.sleep(interval);
    log.info("now dispatch to another async servlet");

    servletrequest request = asynccontext.getrequest();

    string disurl = request.getparameter("disurl");

    if (stringutils.isblank(disurl)) {
     disurl = "/demoasynclink";
    }

    if (disurl.endswith(".jsp")) {
     request.setattribute("datestr", dateformatutils.format(
       system.currenttimemillis(), "yyyy-mm-dd hh:mm:ss"));
    }

    log.info("disurl is ： "   disurl);

    // 将当前异步上下文所持有的request, response分发给servlet容器
    if (stringutils.equals("self", disurl)) {
     // 将分发到自身，即当前异步请求地址
     asynccontext.dispatch();
    } else {
     // 将分发到指定的路径
     asynccontext.dispatch(disurl);
    }
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }
 }
}

http://localhost/servlet3/asyncdispatch2async?disurl=self
一个视图：

1. 需要添加multipartconfig注解
2. 从request对象中获取part文件对象

/**
 * 上传文件测试 location为临时文件保存路径
 * 
 * @author yongboy
 * @date 2011-1-13
 * @version 1.0
 */
@multipartconfig(location = "/home/yongboy/tmp/", maxfilesize = 1024 * 1024 * 10)
@webservlet("/upload")
public class uploadfileaction extends httpservlet {
 private static final long serialversionuid = 92166165626l;
 private static final log log = logfactory.getlog(uploadfileaction.class);
 // 得到注解信息
 private static final multipartconfig config;

 static {
  config = uploadfileaction.class.getannotation(multipartconfig.class);
 }

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  request.getrequestdispatcher("/upload.jsp").forward(request, response);
 }

 protected void dopost(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  // 为避免获取文件名称时出现乱码
  request.setcharacterencoding("utf-8");

  part part = null;
  try {
   // 
   part = request.getpart("file");
  } catch (illegalstateexception ise) {
   // 上传文件超过注解所标注的maxrequestsize或maxfilesize值
   if (config.maxrequestsize() == -1l) {
    log.info("the part in the request is larger than maxfilesize");
   } else if (config.maxfilesize() == -1l) {
    log.info("the request body is larger than maxrequestsize");
   } else {
    log.info("the request body is larger than maxrequestsize, or any part in the request is larger than maxfilesize");
   }

   forwarderrorpage(request, response, "上传文件过大，请检查输入是否有误！");
   return;
  } catch (ioexception ieo) {
   // 在接收数据时出现问题
   log.error("i/o error occurred during the retrieval of the requested part");
  } catch (exception e) {
   log.error(e.tostring());
   e.printstacktrace();
  }

  if (part == null) {
   forwarderrorpage(request, response, "上传文件出现异常，请检查输入是否有误！");
   return;
  }
  
  // 得到文件的原始名称，eg ：测试文档.pdf
  string filename = uploadutils.getfilename(part);

  log.info("contenttype : "   part.getcontenttype());
  log.info("filename : "   filename);
  log.info("filesize : "   part.getsize());
  log.info("header names : ");
  for (string headername : part.getheadernames()) {
   log.info(headername   " : "   part.getheader(headername));
  }

  string savename = system.currenttimemillis()   "."
      filenameutils.getextension(filename);

  log.info("save the file with new name : "   savename);

  // 因在注解中指定了路径，这里可以指定要写入的文件名
  // 在未执行write方法之前，将会在注解指定location路径下生成一临时文件
  part.write(savename);

  request.setattribute("filename", filename);
  request.getrequestdispatcher("/uploadresult.jsp").forward(request,
    response);
 }

 private void forwarderrorpage(httpservletrequest request,
   httpservletresponse response, string errmsg)
   throws servletexception, ioexception {
  request.setattribute("errmsg", errmsg);

  request.getrequestdispatcher("/upload.jsp").forward(request, response);
 }
}

 /**
  * 如何得到上传的文件名, api没有提供直接的方法，只能从content-disposition属性中获取
  * 
  * @param part
  * @return
  */
 protected static string getfilename(part part) {
  if (part == null)
   return null;

  string filename = part.getheader("content-disposition");
  if (stringutils.isblank(filename)) {
   return null;
  }

  return stringutils.substringbetween(filename, "filename=\"", "\"");
 }

/**
 * 多文件上传支持
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
@multipartconfig(
  location = "/home/yongboy/tmp/", 
  maxfilesize = 1024l * 1024l, // 每一个文件的最大值
  maxrequestsize = 1024l * 1024l * 10l // 一次上传最大值，若每次只能上传一个文件，则设置maxrequestsize意义不大
)
@webservlet("/uploadfiles")
public class uploadfilesaction extends httpservlet {
 private static final long serialversionuid = 2304820820384l;
 private static final log log = logfactory.getlog(uploadfilesaction.class);

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  request.getrequestdispatcher("/uploads.jsp").forward(request, response);
 }

 protected void dopost(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  request.setcharacterencoding("utf-8");

  collection parts = null;
  try {
   parts = request.getparts();
  } catch (illegalstateexception ise) {
   // 可能某个文件大于指定文件容量maxfilesize，或者提交数据大于maxrequestsize
   log.info("maybe the request body is larger than maxrequestsize, or any part in the request is larger than maxfilesize");
  } catch (ioexception ioe) {
   // 在获取某个文件时遇到拉io异常错误
   log.error("an i/o error occurred during the retrieval of the part components of this request");
  } catch (exception e) {
   log.error("the request body is larger than maxrequestsize, or any part in the request is larger than maxfilesize");
   e.printstacktrace();
  }

  if (parts == null || parts.isempty()) {
   doerror(request, response, "上传文件为空！");
   return;
  }

  // 前端具有几个file组件，这里会对应几个part对象
  list filenames = new arraylist();
  for (part part : parts) {
   if (part == null) {
    continue;
   }
   // 这里直接以源文件名保存
   string filename = uploadutils.getfilename(part);

   if (stringutils.isblank(filename)) {
    continue;
   }

   part.write(filename);
   filenames.add(filename);
  }

  request.setattribute("filenames", filenames);
  request.getrequestdispatcher("/uploadsresult.jsp").forward(request,
    response);
 }

 private void doerror(httpservletrequest request,
   httpservletresponse response, string errmsg)
   throws servletexception, ioexception {
  request.setattribute("errmsg", errmsg);

  this.doget(request, response);
 }
}

严重: servlet.service() for servlet [com.learn.servlet3.async.demoasynclinkservlet] in context with path [/servlet3] threw exceptionjava.lang.illegalstateexception: not supported.

2

/**
 * 模拟长连接实现，每秒输出一些信息
 * 
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
@webservlet(
 urlpatterns = { "/demoasynclink", "/demoasynclink2" }, 
 asyncsupported = true
)
public class demoasynclinkservlet extends httpservlet {
 private static final long serialversionuid = 4617227991063927036l;

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  response.setheader("cache-control", "private");
  response.setheader("pragma", "no-cache");
  response.setheader("connection", "keep-alive");
  response.setheader("proxy-connection", "keep-alive");
  response.setcontenttype("text/html;charset=utf-8");

  printwriter out = response.getwriter();
  out.println("
start ...
");
  out.flush();

  asynccontext asynccontext = request.startasync(request, response);

  new counterthread(asynccontext).start();
 }

 private static class counterthread extends thread {
  private asynccontext asynccontext;
  public counterthread(asynccontext asynccontext) {
   this.asynccontext = asynccontext;
  }

  @override
  public void run() {
   int num = 0;
   int max = 100;
   int interval = 1000;

   // 必须设置过期时间，否则将会出连接过期，线程无法运行完毕异常
   asynccontext.settimeout((max   1) * interval);
   printwriter out = null;

   try {
    try {
     out = asynccontext.getresponse().getwriter();
    } catch (ioexception e) {
     e.printstacktrace();
    }

    while (true) {
     out.println("
"   (num  )   "
");
     out.flush();

     if (num >= max) {
      break;
     }

     thread.sleep(interval);
    }
   } catch (interruptedexception e) {
    e.printstacktrace();
   }

   if (out != null) {
    out.println("
done !
");
    out.flush();
    out.close();
   }

   asynccontext.complete();
  }
 }
}

2

/**
 * 异步拦截器
 * 
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
@webfilter(
 dispatchertypes = {
   dispatchertype.request, 
   dispatchertype.forward,
   dispatchertype.include
 }, 
 urlpatterns = { "/demoasynclink" }, 
 asyncsupported = true //支持异步servlet
)
public class asyncservletfilter implements filter {
 private log log = logfactory.getlog(asyncservletfilter.class);

 public asyncservletfilter() {
 }

 public void destroy() {
 }

 public void dofilter(servletrequest request, servletresponse response,
   filterchain chain) throws ioexception, servletexception {

  log.info("it was filted now");

  markwapperedresponse wapper = new markwapperedresponse(
    (httpservletresponse) response);

  chain.dofilter(request, wapper);
 }

 public void init(filterconfig fconfig) throws servletexception {
 }
}

/**
 * httpservletresponse简单包装器，逻辑简单
 * 
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
public class markwapperedresponse extends httpservletresponsewrapper {
 private printwriter writer = null;
 private static final string marked_string = "";

 public markwapperedresponse(httpservletresponse resp) throws ioexception {
  super(resp);
  
  writer = new markprintwriter(super.getoutputstream());
 }

 @override
 public printwriter getwriter() throws unsupportedencodingexception {
  return writer;
 }

 private static class markprintwriter extends printwriter{

  public markprintwriter(outputstream out) {
   super(out);
  }

  @override
  public void flush() {
   super.flush();

   super.println(marked_string);
  }
 }
}

1. ie浏览器最佳实践是使用htmlfile activexobject，以及创建隐藏iframe组件，可以跨越ie6-ie8;虽ie 8支持xdomainrequest支持http streaming，但仅仅是ie 8。
2. firefox 浏览器相当棒，支持xmlhttprequest streaming 和隐藏的iframe组件。
3. safari 浏览器支持xmlhttprequest streaming。
4. chrome有些无奈，算不上支持xmlhttprequest streaming，使用iframe的话会一直出现正在加载中的标志。
5. opera也不支持xmlhttprequest streaming，使用iframe的话会一直出现正在加载中的标志。

/**
 * 一个典型的长连接实现
 * 
 * @author yongboy
 * @date 2011-1-14
 * @version 1.0
 */
@webservlet("/demolonglink")
public class demolonglinkservlet extends httpservlet {
 private static final long serialversionuid = 4617227991063927036l;

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {

  response.setheader("cache-control", "private");
  response.setheader("pragma", "no-cache");
  response.setheader("connection", "keep-alive");
  response.setheader("proxy-connection", "keep-alive");
  response.setcontenttype("text/html;charset=utf-8");

  printwriter out = response.getwriter();
  out.println("
start ...
");
  out.flush();

  int num = 0;
  int max = 100;
  while (true) {
   out.println("
"   (num  )   "
");
   out.flush();

   if (num >= max) {
    break;
   }

   try {
    thread.sleep(1000);
   } catch (interruptedexception e) {
    e.printstacktrace();
   }
  }

  out.println("
done !
");
  out.flush();
  out.close();
 }
}

1. ie（ie6-ie7），只有在请求的内容不再发生变化时以及 readystate = 4 的时候才会获取到返回的responsetext内容，因此不支持长连接。
2. ie8：以取代activexobject对象，也算是一个进步，但在服务器端有邀请，必须在头部设置 access-control-allow-origin值，若不知道客户端调用js所处的域名，设置成星号，通用即可。
3. opera：貌似只有在readystate=3时才会触发一次onreadystatechange函数，不支持长连接。
4. firefox 3.6 和safari 4：默认支持xmlhttprequest streaming。
5. chrome 4.1版本:只有在请求内容不再发生变化才会达到readystate=2状态，所以支持情况不太好。

x-ua-compatible" content="ie=8" />
content-type" content="text/html;charset=utf-8" />
author" content="yongboy@gmail.com" />
keywords" content="servlet3, comet, ajax" />
description" content="" />
text/css" rel="stylesheet" href="css/main.css" />

margin: 0; overflow: hidden" onload="">
showdiv" class="inputstyle">

/**
 * xhr获取最新信息
 * 
 * @author yongboy
 * @date 2011-1-10
 * @version 1.0
 */
@webservlet(urlpatterns = "/getnew", asyncsupported = true)
public class getnewblogposts extends httpservlet {
 private static final long serialversionuid = 5656988888865656l;
 private static final log log = logfactory.getlog(getnewblogposts.class);

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  response.setheader("cache-control", "private");
  response.setheader("pragma", "no-cache");
  response.setheader("connection", "keep-alive");
  response.setheader("proxy-connection", "keep-alive");
  response.setheader("access-control-allow-origin", "*");
  response.setcontenttype("text/html;charset=utf-8");
  response.setcharacterencoding("utf-8");
  printwriter writer = response.getwriter();

  // 若当前输出内容较少情况下，需要产生大约2kb的垃圾数据，诸如下面产生一些空格
  for (int i = 0; i < 10; i  ) {
   writer.print("                                   ");
  }

  writer.println("
waiting for ......
");
  writer.flush();

  final asynccontext ac = request.startasync();
  // 设置成长久链接
  ac.settimeout(10 * 60 * 1000);
  ac.addlistener(new asynclistener() {
   public void oncomplete(asyncevent event) throws ioexception {
    newblogxhrlistener.async_xhr_queue.remove(ac);
   }

   public void ontimeout(asyncevent event) throws ioexception {
    newblogxhrlistener.async_xhr_queue.remove(ac);
   }

   public void onerror(asyncevent event) throws ioexception {
    newblogxhrlistener.async_xhr_queue.remove(ac);
   }

   public void onstartasync(asyncevent event) throws ioexception {
    log.info("now add the asynccontext");
   }
  });

  newblogxhrlistener.async_xhr_queue.add(ac);
 }
}

response.setheader("access-control-allow-origin", "*");

1. 在注解处标记上 asyncsupported = true;
2. final asynccontext ac = request.startasync();

 protected void dopost(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  micblog blog = new micblog();

  blog.setauthor("发布者");
  blog.setid(system.currenttimemillis());
  blog.setcontent(iso2utf8(request.getparameter("content")));
  blog.setpubdate(new date());

  // 放到博文队列里面去
  newbloglistener.blog_queue.add(blog);

  request.setattribute("message", "博文发布成功!");

  request.getrequestdispatcher("/web-inf/pages/write.jsp").forward(
    request, response);
 }
 
 private static string iso2utf8(string str){
  try {
   return new string(str.getbytes("iso-8859-1"), "utf-8");
  } catch (unsupportedencodingexception e) {
   e.printstacktrace();
  }
  return null;
 }

/**
 * 客户端comet js 渲染部分 
 * @author yongboy@gmail.com
 * @date 2010-10-18
 * @version 1.0
 */
string.prototype.template=function(){
    var args=arguments;
    return this.replace(/\{(\d )\}/g, function(m, i){
        return args[i];
    });
}
var html = '
'
   '
{0}
'
      '
last date : {1}
'
      '
 
'
      '
';

function showcontent(json) {
 $("#showdiv").prepend(html.template(json.content, json.date));
}
var server = 'blogpush';
var comet = {  
    connection   : false,  
    iframediv    : false, 
    
    initialize: function() {
        if (navigator.appversion.indexof("msie") != -1) { 
            comet.connection = new activexobject("htmlfile");  
            comet.connection.open();  
            comet.connection.write("");  
            comet.connection.write("");
  writer.flush();

  final asynccontext ac = request.startasync();
  ac.settimeout(10 * 60 * 1000);// 10分钟时间;tomcat7下默认为10000毫秒

  ac.addlistener(new asynclistener() {
   public void oncomplete(asyncevent event) throws ioexception {
    log.info("the event : "   event.tostring()
        " is complete now !");
    newbloglistener.async_ajax_queue.remove(ac);
   }

   public void ontimeout(asyncevent event) throws ioexception {
    log.info("the event : "   event.tostring()
        " is timeout now !");

    // 尝试向客户端发送超时方法调用，客户端会再次请求/blogpush，周而复始
    log.info("try to notify the client the connection is timeout now ...");
    string alertstr = "";
    writer.println(alertstr);
    writer.flush();
    writer.close();

    newbloglistener.async_ajax_queue.remove(ac);
   }

   public void onerror(asyncevent event) throws ioexception {
    log.info("the event : "   event.tostring()   " is error now !");
    newbloglistener.async_ajax_queue.remove(ac);
   }

   public void onstartasync(asyncevent event) throws ioexception {
    log.info("the event : "   event.tostring()
        " is start async now !");
   }
  });

  newbloglistener.async_ajax_queue.add(ac);
 }
}

/**
 * 监听器单独线程推送到客户端
 * @author yongboy  
 * @date 2011-1-13
 * @version 1.0
 */
@weblistener
public class newbloglistener implements servletcontextlistener {
 private static final log log = logfactory.getlog(newbloglistener.class);
 public static final blockingqueue blog_queue = new linkedblockingdeque();
 public static final queue async_ajax_queue = new concurrentlinkedqueue();
 private static final string target_string = "";
 
 private string getformatcontent(micblog blog) {
  return string.format(target_string, buildjsonstring(blog));
 }

 public void contextdestroyed(servletcontextevent arg0) {
  log.info("context is destroyed!");
 }

 public void contextinitialized(servletcontextevent servletcontextevent) {
  log.info("context is initialized!");
  // 启动一个线程处理线程队列
  new thread(runnable).start();
 }

 private runnable runnable = new runnable() {
  public void run() {
   boolean isdone = true;

   while (isdone) {
    if (!blog_queue.isempty()) {
     try {
      log.info("async_ajax_queue size : "
          async_ajax_queue.size());
      micblog blog = blog_queue.take();

      if (async_ajax_queue.isempty()) {
       continue;
      }

      string targetjson = getformatcontent(blog);

      for (asynccontext context : async_ajax_queue) {
       if (context == null) {
        log.info("the current async_ajax_queue is null now !");
        continue;
       }
       log.info(context.tostring());
       printwriter out = context.getresponse().getwriter();

       if (out == null) {
        log.info("the current async_ajax_queue's printwriter is null !");
        continue;
       }

       out.println(targetjson);
       out.flush();
      }
     } catch (exception e) {
      e.printstacktrace();
      isdone = false;
     }
    }
   }
  }
 };

 private static string buildjsonstring(micblog blog) {
  map info = new hashmap();
  info.put("content", blog.getcontent());
  info.put("date",
    dateformatutils.format(blog.getpubdate(), "hh:mm:ss sss"));

  jsonobject jsonobject = jsonobject.fromobject(info);

  return jsonobject.tostring();
 }
}

1. 客户端请求 blog.html
2. blog.html的comet.js开始注册启动事件
3. js产生一个iframe，在iframe中请求/blogpush，注册异步连接，设定超时为10分钟，注册异步监听器
4. 服务器接收到请求，添加异步连接到队列中
5. 客户端处于等待状态（长连接一直建立），等待被调用
6. 后台发布新的博客文章
7. 博客文章被放入到队列中
8. 一直在守候的独立线程处理博客文章队列；把博客文章格式化成json对象，一一轮询推送到客户端
9. 客户端js方法被调用，进行json对象解析，组装html代码，显示在当前页面上
10. 超时发生时，/blogpush通知客户端已经超时，调用超时（timeout）方法；同时从异步连接队列中删除
11. 客户端接到通知，对iframe进行操作，再次进行连接请求，重复步骤2

/**
 * 简单示范
 * @author yongboy  
 * @date 2011-1-16
 * @version 1.0
 */
@webservlet("/jarhome")
public class hellojarservlet extends httpservlet {
 private static final long serialversionuid = 6177346686921106540l;

 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  request.setattribute("date", new date());
  request.getrequestdispatcher("/jarpage/jarhome.jsp").forward(request, response);
 }
}

<%@ page language="java" contenttype="text/html; charset=utf-8"
    pageencoding="utf-8"%>












now date : <%=((java.util.date)request.getattribute("date")).tostring()%>

/**
 * 演示jardemo
 * 
 * @author yongboy
 * @date 2011-1-16
 * @version 1.0
 */
@webservlet("/jardemo")
public class demowebinfpagesservlet extends httpservlet {
 private static final long serialversionuid = -1040850432869481349l;
 private static final log log = logfactory
   .getlog(demowebinfpagesservlet.class);

 @suppresswarnings("deprecation")
 @override
 protected void doget(httpservletrequest request,
   httpservletresponse response) throws servletexception, ioexception {
  log.info("the /jardemo is accessed now!");

  log.info("getrealpath : "   request.getrealpath("/"));
  log.info("servletcontext : getrealpath : "
      getservletcontext().getrealpath("/"));
  log.info("getpathtranslated : "   request.getpathtranslated());

  log.info("get jar's resource:");

  inputstream is = getservletcontext().getresourceasstream(
    "/jarfile/demo.txt");
  log.info("the jar/meta-inf/resources/jarfile/demo.txt's content is :\n"
      ioutils.tostring(is));

  request.getrequestdispatcher("/web-inf/pages/notaccess.jsp");
 }
}

@restsupport("/book/*/chapter/*")

但耦合性较强，每写一个servlet都要添加上一个注解，想降低耦合或者url经常变动者，可以试试使用xml进行配置：

  <filter>
    <filter-name>restfilterfilter-name>
    <filter-class>com.servlet.rest.restfilterfilter-class>
    <init-param>
      <param-name>scanpackageparam-name>
      <param-value>/servlets.xml,/servlets2.xmlparam-value>
    init-param>    
  filter>
  <filter-mapping>
    <filter-name>restfilterfilter-name>
    <url-pattern>/*url-pattern>
  filter-mapping>

为scanpackage参数添加需要传入的ｘｍｌ文件即可，多个ｘｍｌ配置文件之间需要使用逗号隔开

我们再看看servlets.xml配置文件内容:

xml version="1.0" encoding="utf-8"?>
<servlets>
	<servlet>
		<class>com.yong.test.servlet.xml.welcomeservletclass>
		<url>/url>
		<url>/home/url>
		<url>/welcome/url>
	servlet>
	<servlet>
		<class>com.yong.test.servlet.xml.userhomeactionclass>
		<url>/user/url>
	servlet>
servlets>

具体到单个servlet配置为

	<servlet>
		<class>servlet 类路径class>
		<url>对应url1url>
              <url>对应url2url>
	servlet>

其实很简单的说，嗯，不要忘记xml一定要放在classpath相应位置。

说这个很轻、很微小的框架，一点都不过分，只有10个java文件，只是用注解的话，那就可以减少为7个java文件。

说这个小东西目标明确，一点不掺假，就是为现有的servlet增加rest风格的url支持，仅此而已。

我们表示一个具有结构形式的url为:

/book/head first java/chapter/12 看图说故事

传统的servlet在url处怎么映射呢 ？

/book/*

那么chapter怎么办 ？

/chapter/*（这里假设/book/*排在较上位置）

显然上面的链接地址则很难到达 /chapter/*。当然会有兄弟跳出来说，这一切可以交给 /book/*进行处理，嗯，book也一并处理了chapter部分，当然是可以的，带来了责任不单一的问题了，混杂在一起，造成代码管理的混乱。

那么怎么在servletrest里面怎么做呢 ？

@restsupport("/book/*/chapter/*")

其风格完全是以往的servlet映射的风格，只不过支持的参数多了些。

更重要的是以往的servlet编程经验一点都没有舍弃，都还保留着。在servletrest里没有强迫人们按照新的继承格式创造一个处理类，还是和以往一样，创建一个需要继承 httpservlet 的servlet，重写get、post、delete、put等方法，在类的合适位置添加上注解即可:

@restsupport("/book/*/chapter/*") 即可。当然这部分可以在xml文件中完成配置,下一篇文章会讲到。

这里有一个示范：

@restsupport("/book/*/chapter/*")
public class chapterservlet extends httpservlet {
        private static final long serialversionuid = -1534235656l;
        protected void doget(httpservletrequest request,
                        httpservletresponse response) throws servletexception, ioexception {
                // code here ...
        }
        protected void dopost(httpservletrequest request,
                        httpservletresponse response) throws servletexception, ioexception {
                // code here ...
        }
        protected void doput(httpservletrequest request,
                        httpservletresponse response) throws servletexception, ioexception {
                // code here ...
        }
        protected void dodelete(httpservletrequest request,
                        httpservletresponse response) throws servletexception, ioexception {
                // code here ...
        }
}

那么怎么在项目中使用呢 ？

在web.xml 中配置filter：

  restfilter 
  class>com.servlet.rest.restfilterclass> 
  
    scanpackage 
    com.yong.test.servlet 
  


  restfilter 
  /* 

scanpackage需要接收一个需要扫描的包的参数，若有多个包，可以包路径之间有一个分隔符逗号“,”,eg:

com.yong.test.servlet,com.xiaomin.bookstore

servletrest 注解需要jdk 1.5支持，servlet 2.*, 3.* 版本，仅仅把servletrest-0.8.jar （）放到项目classpath中，并且不依赖于第三方jar包，除了servlet.jar之外。

在运行期间可以对servlet的进行动态装载和卸载等操作，servletrest已经封装了相应的接口（必须从全局context中获取，下面代码是从示范jsp代码中摘取）:

		servletfactory servletfactory = (servletfactory)application.getattribute("servletfactory");
		
		// 注册新的servlet
		string mappingurl = "新的servlet映射url";
		class servletclass = class.forname("要映射的servlet class路径");
		
		servletfactory.register(mappingurl, servletclass);
		
		// 注销servlet
		//servletfactory.destory(servletclass);

假如不在jsp中操作，那就需要：

getservletcontext().getattribute("servletfactory");

servletrest遵循的原则和原有的servlet容器处理方式一致，一个url对应一个servlet实例原则。

更多信息请阅读servletrest源代码。

/**
* 这次，我们把模板文件放在jar文件包中
*
* @author xiaomin
*
*/
@webservlet("/some/")
public class viewsomethingaction extends httpservlet {
    private static final long serialversionuid = 65464645l;
    private static final string default_encoding = "utf-8";
    private static final string template_name = "some";
    private string templatestring;
    private configuration configuration;
    public void init() throws servletexception {
        configuration = new configuration();
        configuration.setdefaultencoding(default_encoding);
        configuration.setencoding(locale.china, default_encoding);
        // 初始化模板
        templatestring = gettemplatestring("pages/something.html");
    }
    protected void doget(httpservletrequest request,
            httpservletresponse response) throws servletexception, ioexception {
        // 构造要传递到模板的属性值
        map map = new hashmap();       
        map.put("username", "小敏");
        response.setcontenttype("text/html; charset=" default_encoding);
        printresponsesstring(response, map);
    }
    /**
     * 输出请求内容
     * @param response
     * @param map
     * @throws ioexception
     */
    private void printresponsesstring(httpservletresponse response,
            map map) throws ioexception {
        template template = new template(template_name, new stringreader(
                templatestring), configuration, default_encoding);
        writer out = response.getwriter();
        try {
            template.process(map, out);
        } catch (templateexception e) {
            e.printstacktrace();
        } finally {
            out.flush();
            template = null;
        }
    }

    /**
     * 获取jar包内的html模板文件内容
     * @param jarhtmlpath eg: pages/something.html
     * @return
     */
    private string gettemplatestring(string jarhtmlpath) {
        classloader mycl = this.getclass().getclassloader();
        inputstream is = mycl.getresourceasstream(jarhtmlpath);
        if (is == null) {
            return null;
        } else {
            try {
                return templatestring = ioutils.tostring(is, default_encoding);
            } catch (ioexception e) {
                e.printstacktrace();
                return null;
            }
        }
    }
}

这个没得说，tomcat 7 运行要求，最简单安装jre 1.6即可。
下载地址：

嗯，支持servlet 3.0 注解的ide，目前是最受欢迎开发工具。
凯发k8网页登录官网地址：

记得要选择
 
32位下载地址：

tomcat 7 下载地址：

若电脑不是64位，则推荐下载
32-bit windows zip

servlet的轻巧高效，freemarker的强大简便，两者结合将是超轻的组合，即可避免丑陋的java代码和html代码杂揉，又可高效基于模板的站点开发。

闲话少说，项目需要：

freemarker-2.3.13.jar

servlet.jar

定义两个servlet：

helloaction.java 对应 /hello,借助freemarker硬编码输出

public class helloaction extends httpservlet {
    private static final long serialversionuid = -6082007726831320176l;

    private configuration configuration;
    public void init() throws servletexception {
        configuration = new configuration();
        configuration.setservletcontextfortemplateloading(getservletcontext(), "web-inf/pages");
        configuration.setencoding(locale.china, "utf-8");
    }

    @suppresswarnings("unchecked")
    public void doget(httpservletrequest request, httpservletresponse response) throws servletexception, ioexception {
        // 填充数据类型
        map map = new hashmap();
        map.put("username", "小敏");   
        template template = configuration.gettemplate("hello.html");
        response.setcontenttype("text/html; charset=" template.getencoding());
        writer out = response.getwriter();
        try{
            template.process(map, out);
        }catch (templateexception e) {
            e.printstacktrace();
        }
    }

    public void destroy() {
        super.destroy();
        if(configuration != null){
            configuration = null;
        }
    }
}

对应模板：

你好， ${username!} ！

hiaction.java 对应 /hi ，借助freemrker servlet的拦截功能，如以往写代码方式，感觉不到freemarker的存在。

public class hiaction extends httpservlet {
    private static final long serialversionuid = 518767483952153077l;

    public void doget(httpservletrequest request, httpservletresponse response)
            throws servletexception, ioexception {

        request.setattribute("thename", "小敏");
        request.getrequestdispatcher("/web-inf/pages/hi.html").forward(request, response);
    }
}

对应的模板：

hi ${thename!}~

但需要在web.xml 配置文件中定义如下：

    freemarker
   
        freemarker.ext.servlet.freemarkerservlet
   

   
   
        templatepath
        /
   
   
        nocache
        true
   
   
        contenttype
        text/html; charset=utf-8
       
   

   
   
        template_update_delay
        0
   
   
        default_encoding
        utf-8
   
   
        number_format
        0.##########
   

    1

    freemarker
    *.html

使用哪一种组合方式，看您喜好了。

借助于freemarker自身的servlet工具，只是用于拦截servlet中forward转向使用到的html资源文件。

很简陋，但凑合着能看。

项目源代码已经打包如下：