以上这几个东西的目的是设计来解决位于主线程中的某些操作比较耗时（比如httpclient请求），影响界面响应，而导

致主程序无法处理其他监听事件。致使程序卡死的问题。（界面提示，无响应关闭）

1：Handler对象 中有两个属性，一个是来自于当前线程（或者拥有Looper对象的线程）的threadlocal变量中的Looper

对象和该looper对象中的messagequeue属性。
有这两个属性的目的主要是往当前线程的looper对象的messagequeue队列中加入message对象。
2：Message对象，也有两个重要的属性，一个是Hander对象，这个handler对象就是把该message加入队列的那

个handler对象，另一个对象就是bundle对象，这个对象的目的就是用来存储数据，相当于一个hashmap对象。

3：Looper对象，有一个重要的属性就是MessageQueue对象，Looper的loop方法，会不断的从该队列中读取message对

象，并调用messgae对象中的Hander属性对象的dispatherMessage（msg）方法，该方法，就是会调

用handler的handleMessage方法，(也就是我们重写的那个方法)。

4：MessageQueue对象，管理message的队列对象，它有一个属性就是Message对象，MessageQueue中始终只有一

个message对象，因为message对象是一个链式结构的对象，它的prv和next属性记录了他之前和之后的message对象，所

以，我们调用MessageQueue的next方法就能回的需要的message对象。

从hander与Looper以及MessageQueue和Message的关系中我们可以看出来，执行流程如下：
  1：有人创建hander对象，并取得对应的Looper对象赋给该hander，通过Hander的sendmessage或post方法将handler

包装到message对象中， 再将该message对象加入到消息队列中。（消息队列就是Looper对象中消息队列属性）
  2：线程（管理Looper对象的线程）不断的调用Looper对象中的loop方法，loop方法又从messageQueue队列中获

取Message对象，然后调用该对象里的hander属性对象的dispatherMessage（msg）方法，从而，依次执行我们加入

的handler任务。

这就是hander的处理流程。那么HandlerThread是做什么的，他是一个管理Looper对象的线程类。我们的Looper一般来自

于两个地方，一个地方就是主线程的Looper对象，另一个就是我们另外开启一个线程来创建和管理Looper对

象。android提供已经给我们提供了一种这样的一个类，那就是HandlerThread对象。

    this.config.setTemplateExceptionHandler(TemplateExceptionHandler.HTML_DEBUG_HANDLER);
    this.contentType = "text/html";

    this.wrapper = createObjectWrapper(servletContext);
    if (LOG.isDebugEnabled())
      LOG.debug("Using object wrapper of class " + this.wrapper.getClass().getName(), new String[0]);

    this.config.setObjectWrapper(this.wrapper);

    this.templatePath = servletContext.getInitParameter("TemplatePath");
    if (this.templatePath == null)
      this.templatePath = servletContext.getInitParameter("templatePath");

    if (this.templatePath == null)
      this.templatePath = "class://";
    this.config.setTemplateLoader(createTemplateLoader(servletContext, this.templatePath));

    loadSettings(servletContext);
  }
    
protected TemplateLoader createTemplateLoader(ServletContext servletContext, String templatePath)
  {
    TemplateLoader templatePathLoader = null;
    try
    {
      if (templatePath.startsWith("class://"))
      {
        templatePathLoader = new ClassTemplateLoader(super.getClass(), templatePath.substring(7));
      } else if (templatePath.startsWith("file://"))
        templatePathLoader = new FileTemplateLoader(new File(templatePath));
    }
    catch (IOException e) {
      LOG.error("Invalid template path specified: " + e.getMessage(), e, new String[0]);
    }

    if (templatePathLoader != null);
    return new MultiTemplateLoader(new TemplateLoader[] { new WebappTemplateLoader(servletContext), new StrutsClassTemplateLoader() });
  }

不过，这个问题已经在2.3的版本中修复过来了。

方案１：提供两台ｍｅｍｃａｃｈｅｄ服务器（主从关系，保证数据稳定），将访问这两类数据的方法缓存。在数据变更以后更新缓存即可
主要目的是隔离频繁的数据的访问。
方案２：将这两类数据都生成静态ｈｔｍｌ文件，通过ｎｇｉｎｘ指定前台缓存访问。缺点是更新数据后要生成新的文件，担心时间久了
以后有磁盘碎片。另外多次读取文件，可能有磁盘io影响。如果缓存到前台，后台数据变更了，前台可能很难得到新的版本
方案３：将第一类生成静态文件，第二类通过方法缓存起来，看上去好，但是我觉得实现起来比较困难。
实际上方案２，３都有一个实现上比较麻烦的地方，那就是所有的页面头部有一个用户的登录信息。如果缓存成文件这样就我目前所想
头部的数据只能通过ａｊａｘ来得去了，这样不但多了一次网络io，也不允许页面可以后退。

另外，我做这个方案有两个目的，一种就是提高访问速度，另外就是想从缓存的基础上做数据库读写分离，以便某些统计数据可以白天
及时的做

 function reinitIframe(){
  var iframe = document.getElementById("frame_content");
  try{
   var bHeight = iframe.contentWindow.document.body.scrollHeight;
  }catch (ex){
     var bHeight = 0;
  } 
  try{
   var dHeight = iframe.contentWindow.document.documentElement.scrollHeight;
  }catch (ex){
      var dHeight = 0;
  }
  if(dHeight!=0 && bHeight!=0){
   var height = Math.min(bHeight, dHeight);
  }else{
   var height = Math.max(bHeight, dHeight);
  }
  if(Ext.isGecko){
   height = height+30;
  }
  iframe.style.height =  height+"px";
 }
 window.setInterval(function(){
  reinitIframe()
 }, 200);
});

一：Ext下类函数定义
extcore通过：Ext.extend方法来创建类（构造函数），这个类以下用sb代替。
这个类函数默认会有这些属性（类属性）。
superclass：父类，也就是第一个或第二个参数的prototype属性对象。（具体根据传入的参数类型决定）
superclass(): 父类，(sb.propertype下) 这是一个函数，该函数返回父类的propertype对象
supr():同上
constructor()：构造函数，（sb函数的propertype对象下）实际上引用的就是sb函数自己。
override(o)：重写方法，（sb函数下），调用的是 Ext.override(sb, o);也就是将o中的属性复制到sb的propertype下。
override(o)：重写方法，（sb.propertype下）也就是将o的属性复制到sb的propertype下。
extend(o):(sb函数下),该函数调用的是Ext.extend(sb.o);

Ext.extend(sb, sp, overrides)方法有三个参数，这三个参数有一定的类型要求：
sb 一般情况下是一个类函数。
sp：有两种情况：一种是类函数，另一种是：一个Object对象。
overrides：Object对象，通过Ext.override(sb, overrides);方法覆盖类对象的属性。

通过代码分析，可以看出Ext.extend方法有两个应用：
第一：
因为js没有重构语法，所以我们没办法定义js方法的重构，而上边这个extend方法，可以说是一种重构的实现。因为，我们通过代码的分析，我们可以总结出extend方法的参数传

递方式。(用面向对象语言来表示的话，如下结构)
1:extend(Calss sb,Object sp);
2:extend(Calss sb,Class sp);
3:extend(Calss sb,Class sp,Object overrides);
第一种方式目的是定义一个类函数，这个类函数的父类为sb类函数，属性方法的定义在sp对象中完成。
比如： var Student = Ext.extend(Person,{
    constructor:function(old){
  this.age=old;
 },
   name:'sam'}
})
其实通过
  if(Ext.isObject(sp)){
                    overrides = sp;
                    sp = sb;
                    sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
                }

我们可以看出Ext.extend

只有在sp.constructor==Object.prototype.constructor的时候，才创建并返回一个函数，该函数就一句话，

就是调用sb（即父类构造函数）

如果sp.constructor==Object.prototype.constructor

那么sp应该是这样，是一个对象直接量，或者new Object方式创建的对象，且它们都没有显示定义

constructor方法。

以下这几种情况都不会有sp.constructor==Object.prototype.constructor。

1：var obj = new Object(); 

obj.constructor=function(){...};

Ext.extend(sb,obj) //extend 返回的类就是constructor函数

2: var obj = {

constructor:function(){...}

};

Ext.extend(sb,obj) //extend 返回的类就是constructor函数

3: var obj = new function(){...}();  

Ext.extend(sb,obj) //extend返回的类就是这个匿名函数

4: var obj = new function(){

this.constructor=function(){...} 

}();

Ext.extend(sb,obj) //extend 返回的类就是constructor函数。

总结 ：其实很简单,Ext.extend这么做的目的是要说，定义一个类，构造函数就是constructor方法，如果没显示定义这个方法，那么类就使用父类函数作为新类的构造函数。

var A=function(){
   alert("this is a");
}
var B=function(){
   alert("this is b");
}

var SubA = Ext.extend(A,new B());
var subA = new SubA();//这里就会弹出 this is  a 的提示。
第二种方式：修改现有类的类结构
2:extend(Calss sb,Class sp);
这个方法的目的其实之一种包装，是将sb继承于sp下，不管sb是不是ext框架下的类，在这个方法执行后sb就成了ext框架
下的类结构了
3:extend(Calss sb,Class sp,Object overrides);
除了有第二种方法的功能外，还额外的给sb添加或覆盖新的方法或属性
Ext.extend(Person,DongWu);
Ext.extend(Person,DongWu，{sex:'man'});

sam.chuan.yang 2010-06-29 07:07 发表评论

]]>

@Component("/targetAction")
public class TargetAction {

 @Autowired()
 @Qualifier("targetService")
 private ItargetService itargetService;

 @ActionForm(TblBsTargetInfo.class)
 public Object add(Object form, HttpServletRequest request,
   HttpServletResponse response) {
  
      itargetService.saveTarget((TblBsTargetInfo) form）;
     return new JsonResultHandler(“ok”);
 }