那么，我们可不可以通过程序设置一定的时间，当程序运行超过该时长后自行终止或者进行其他操作呢?

　　查了大量资料后发现，Future类就能满足这个需求。

　　Future类中重要方法包括get()和cancel()。

　　get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。

　　另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。

　　通过这些方法即可实现我们要求。

　　Java 代码示例：

　　final ExecutorService exec = Executors.newFixedThreadPool(1);

　　Callable call = new Callable() {

　　public String call() throws Exception {

　　// 放入耗时操作代码块

　　int cash = 300;

　　String name = "张三";

　　System.out.println(name + "现在有" + cash + "元存款");

　　User u = new User(name, cash);

　　String[] arr = { "线程A", "线程B", "线程C", "线程D", "线程E", "线程F",

　　"线程G", "线程H", "线程I", "线程J" };

　　for (int i = 0; i < 10; i++) {

　　MyThread th = new MyThread(arr[i], u,

　　(int) (Math.random() * 1000 - 500));

　　th.start();

　　}

　　//耗时代码块结束

　　Thread.sleep(1000 * 5);

　　return "线程执行完成";

　　}

　　};

　　try {

　　Future future = exec.submit(call);

　　String obj = future.get(1000 * 1, TimeUnit.MILLISECONDS); // 任务处理超时时间设为1 秒

　　System.out.println("任务成功返回:" + obj);

　　} catch (TimeoutException ex) {

　　System.out.println("处理超时啦....");

　　System.exit(0);

　　} catch (Exception e) {

　　System.out.println("处理失败.");

　　e.printStackTrace();

　　}

　　exec.shutdown(); // 关闭线程池

　　将耗时的代码块放入标注的地方后，即可满足要求。

　　System.out.println("处理失败.");

　　e.printStackTrace();

　　System.out.println("处理失败.");

　　e.printStackTrace();

　　在该示例程序中，当运行超时后，执行的是退出程序的操作。

　　也可以根据需要放入其他代码进行相关操作。

　　例如可以设置当处理超时时就忽略 该错误继续向下执行

是在服务器端起作用,当使用forward()时,Servlet engine传递HTTP请求从当前的Servlet or JSP到另外一个Servlet,JSP 或普通HTML文件,也即你的form提交至a.jsp,在a.jsp用到了forward()重定向至b.jsp,此时form提交的所有信息在 b.jsp都可以获得,参数自动传递. 但forward()无法重定向至有frame的jsp文件,可以重定向至有frame的html文件,同时forward()无法在后面带参数传递,比如servlet?name=frank,这样不行,可以程序内通过response.setAttribute("name",name)来传至下一个页面。

重定向后浏览器地址栏URL不变。

例：在servlet中进行重定向

public void doPost(HttpServletRequest request,HttpServletResponse response) 
throws ServletException,IOException{　 response.setContentType("text/html; charset=gb2312");　 ServletContext sc = getServletContext();　 RequestDispatcher rd = null;　 rd = sc.getRequestDispatcher("/index.jsp"); //定向的页面　 rd.forward(request, response);}

通常在servlet中使用，不在jsp中使用。

2. response.sendRedirect()

是在用户的浏览器端工作,sendRedirect()可以带参数传递,比如servlet?name=frank传至下个页面,同时它可以重定向至不同的主机上,sendRedirect()可以重定向有frame.的jsp文件.

重定向后在浏览器地址栏上会出现重定向页面的URL

例：在servlet中重定向

public void doPost(HttpServletRequest request,HttpServletResponse response)

throws ServletException,IOException

{

　 response.setContentType("text/html; charset=gb2312");

　 response.sendRedirect("/index.jsp");

}

由于response是jsp页面中的隐含对象，故在jsp页面中可以用response.sendRedirect()直接实现重定位。

注意：

(1) 使用response.sendRedirect时，前面不能有HTML输出；

这并不是绝对的，不能有HTML输出其实是指不能有HTML被送到了浏览器。事实上现在的server都有cache机制，一般在8K（我是说 JSP　SERVER），这就意味着，除非你关闭了cache，或者你使用了out.flush()强制刷新，那么在使用sendRedirect之前，有少量的HTML输出也是允许的。

(2) response.sendRedirect之后，应该紧跟一句return。

我们已经知道response.sendRedirect是通过浏览器来做转向的，所以只有在页面处理完成后，才会有实际的动作。既然你已经要做转向了，那么后的输出还有什么意义呢？而且有可能会因为后面的输出导致转向失败。

比较：

(1) Dispatcher.forward()是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址；

(2) response.sendRedirect()则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。

前者更加高效，在前者可以满足需要时，尽量使用RequestDispatcher.forward()方法。

注：在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用HttpServletResponse.sendRequest()方法。

构造函数中下面开始在map中初始化自己的events属性:
this.events = new OpenLayers.Events(this,
                                            this.div,
                                            this.EVENT_TYPES,
                                            this.fallThrough,
                                            {includeXY: true});
再往下就注册了:
if(this.eventListeners instanceof Object) {
            this.events.on(this.eventListeners);
        }
通过map自己的Events属性(其实也是个object,就是events类的实例)中的on这个函数注册上，
我们要进入OpenLayers.Events类
---------------------------------------------------------------------------
---------------------------------------------------------------------------
看这个on方法
   /**
     * Method: on
     * Convenience method for registering listeners with a common scope.
     *
     * Example use:
     * (code)
     * events.on({
     *     "loadstart": loadStartListener,
     *     "loadend": loadEndListener,
     *     scope: object
     * });
     * (end)
     */
    on: function(object) {
        for(var type in object) {
            if(type != "scope") {
                this.register(type, object.scope, object[type]);
            }
        }
    },
on这个函数参数还是第一步中我们传入的eventListeners，就是那个哈希表
遍历，这个“scope”键值是事件的“产生源”对象，就是这个键值对应的对象触发我们注册的事件
register(type, object.scope, object[type])
type就是事件名称
object[type]就是处理事件的函数名
可以看一下第一步中传入的参数:
eventListeners: {
                        "moveend": mapEvent,
                        "zoomend": mapEvent,
                        "changelayer": mapLayerChanged,
                        "changebaselayer": mapBaseLayerChanged
                    }
再进入events类的另一个函数:this.register(type, object.scope, object[type])
   /**
     * APIMethod: register
     * Register an event on the events object.
     *
     * When the event is triggered, the 'func' function will be called, in the
     * context of 'obj'. Imagine we were to register an event, specifying an
     * OpenLayers.Bounds Object as 'obj'. When the event is triggered, the
     * context in the callback function will be our Bounds object. This means
     * that within our callback function, we can access the properties and
     * methods of the Bounds object through the "this" variable. So our
     * callback could execute something like:
     * :    leftStr = "Left: " + this.left;
     *  
     *                   or
     * 
     * :    centerStr = "Center: " + this.getCenterLonLat();
     *
     * Parameters:
     * type - {String} Name of the event to register
     * obj - {Object} The object to bind the context to for the callback#.
     *                     If no object is specified, default is the Events's
     *                     'object' property.
     * func - {Function} The callback function. If no callback is
     *                        specified, this function does nothing.
     *
     *
     */
    register: function (type, obj, func) {

        if ( (func != null) &&
             (OpenLayers.Util.indexOf(this.eventTypes, type) != -1) ) {

            if (obj == null)  {
                obj = this.object;
            }
            var listeners = this.listeners[type];
            listeners.push( {obj: obj, func: func} );
        }
    },
到这里，我们能看到我们所说的核心，那个哈希表，把自己的值都赋给了events类的一个属性:listeners
  /**
     * Property: listeners
     * {Object} Hashtable of Array(Function): events listener functions 
     */
    listeners: null,

这个事件机制的核心哈希表，键名就是事件的名称,也就是参数中的type,键值是一个对象{obj: obj, func: func}
当然这个对象中还有对象。。。。

现在事件已经注册上了，还有一个问题，register函数中提到了this.eventTypes，this.object
所以我们再回来看下events类的构造函数。
map类中实例化events属性的情景:
this.events = new OpenLayers.Events(    this, //指的是map
                                            this.div,
                                            this.EVENT_TYPES,
                                            this.fallThrough,
                                            {includeXY: true});
我们可以和events类的构造函数对比一下参数，就会明白了 
   /**
     * Constructor: OpenLayers.Events
     * Construct an OpenLayers.Events object.
     *
     * Parameters:
     * object - {Object} The js object to which this Events object  is being
     * added element - {DOMElement} A dom element to respond to browser events
     * eventTypes - {Array(String)} Array of custom application events
     * fallThrough - {Boolean} Allow events to fall through after these have
     *                         been handled?
     * options - {Object} Options for the events object.
     */
    initialize: function (
                   object,
                   element,
                   eventTypes,
                   fallThrough,
                   options)
      {
        OpenLayers.Util.extend(this, options);
        this.object     = object;
        this.element    = element;
        this.fallThrough = fallThrough;
        this.listeners  = {};

        // keep a bound copy of handleBrowserEvent() so that we can
        // pass the same function to both Event.observe() and .stopObserving()
        this.eventHandler = OpenLayers.Function.bindAsEventListener(
            this.handleBrowserEvent, this
        );

        // if eventTypes is specified, create a listeners list for each
        // custom application event.
        this.eventTypes = [];
        if (eventTypes != null) {
            for (var i=0, len=eventTypes.length; i<len; i++) {
                this.addEventType(eventTypes[i]);
            }
        }
       
        // if a dom element is specified, add a listeners list
        // for browser events on the element and register them
        if (this.element != null) {
            this.attachToElement(element);
        }
    },
 上面events的初始化是发生在map的初始化中，this.events.on(this.eventListeners);之前的，所以上面提到的register函数中的this.eventTypes，this.object 就明确意思了：
 this.object(this是指的events类)就是map,也就是说map是我们第一步传入参数中的注册事件的“发生源”，（比如button是onclik的“发生源”，“发生源”是本人自定义的。。不知道是否有合适的称呼，术语应该就是srcElement）
this.eventTypes(this是指的events类)就是map类中定义的一个常量:this.EVENT_TYPES(this是指的map类)
查到map类中的这个常量 EVENT_TYPES: [
        "preaddlayer", "addlayer", "removelayer", "changelayer", "movestart",
        "move", "moveend", "zoomend", "popupopen", "popupclose",
        "addmarker", "removemarker", "clearmarkers", "mouseover",
        "mouseout", "mousemove", "dragstart", "drag", "dragend",
        "changebaselayer"],
所以我们在初始化map的时候传入的参数中，注册的事件都是来自于这个常量中的

MapGuide 的 Fusion 框架最为核心的地图 Widget ，就是采用了 OpenLayers 框架。 Fusion 框架对 OpenLayers 进行包装，为其添加了更多的功能，从而使之能够更符合 Fusion 框架并与其余 Fusion 组件进行交互。

非常有趣的是，由于 OpenLayers 所采用的术语跟 Fusion 采用的并不是十分一致，甚至 Fusion 不同部分采用的术语也不是十分一致，所以同一个名字在不同地方表达的意思却很可能并不相同。所以，在详细介绍 Fusion 如何对 OpenLayers 进行包装之前，有必要对两者之间的术语进行一下区分，以免当您阅读到相关材料时感到疑惑。

OpenLayers 认为，用户看到的由多个图层 (layer) 组成的一张地图 (map) 。地图本身与加载的数据源格式无关，与数据源格式相关的是图层。因此，地图类只有一个（ OpenLayers.Map ），而图层类却有很多，这些类都以 OpenLayers.Layer 作为命名空间，如 OpenLayers.Layer.Google/Yahoo/MapGuide/WMS/Vector 等等。

这样的结构有一个问题，那就是所有的图层之间是平行的关系，这是很不利于图层管理的。我们假设有这样一张地图：该地图包含有十二个图层，有九个来自于不同数据源的图层和三个位于顶层的 Vector 层。那么，我如果想用代码去处理所有 Vector 的层，就必须遍历所有的层，依次比较是不是 Vector 层，再对 Vector 层进行处理。解决这个问题的方案很简单，那就是引入层级结构，允许用户把图层分组。比如上面的例子中，把三个 Vector 分成一组，比如命名为“标记”组，届时只需要对标记组中的每一个层进行处理即可。

这也正是 Fusion 对于 OpenLayers 众多改进中的一个。而问题也正是这里引入的：地图 Widget 在给这种层级结构命名的时候，出人意料地采用了另外的命名方式：地图 Widget 把图层组命名为“地图组” (map group) ，把组里面的图层命名为 (map) 。下面代码是示例数据中 Library://Samples/Sheboygan/FlexibleLayouts/Slate.ApplicationDefinition 布局文件对于地图定义的那一部分，用户可以在 MapGuide Studio 中通过点击位于 Map 面板上的 “Edit Map Group” 按钮来查看这部分内容。

布局文件中地图定义的部分代码

其实， MapGuide 这样做是有原因的。这个问题源于不同产品之间定位的不同： OpenLayers 框架的目的是在同一张地图上面显示多个数据源。所以在 OpenLayers 看来，一个来自 MapGuide 的地图仅仅是一个层而已。然而，在 MapGuide 内部，一张 MapGuide 地图内是包含多个 Layer ，具体表现就是一个 MapDefinition 里可以包含多个 LayerDefinition 。所以，如果 Fusion 把 MapGuide 叫做一个 Layer 的话，又该如何称呼里面的 Layer 呢？

鉴于这样的考虑， Fusion 才做了这种概念上的映射： Fusion 中的地图 Widget 对应 OpenLayers 里面的地图； Fusion 里面的地图组是一个逻辑概念，从而形成一种逻辑上的层级结构以便管理； Fusion 中的地图实际对应于 OpenLayers 里面的图层。

但事情到这里还没有结束，接下来的事情可能会让您有些意外：在编写地图 Widget 实现代码时，为了能够便于与 OpenLayers 中的类对应起来， Fusion 将地图（也就是 OpenLayers 中的图层）称为 Layers （注意，不是 Layer ），并要求每一个地图的代码都继承自 Fusion.Layers 。比如， MapGuide 的 Layers 的名称就叫做 Fusion.Layers.MapGuide 。

下表总结了 Fusion 与 OpenLayers 之间这种概念映射关系

 Fusion 与 OpenLayers 之间的概念映射关系

在阅读 Fusion 和 OpenLayers 的源代码或学习他们的 API 时，一定要注意两者术语上的区别。

本节中，我们提到了 Fusion 引入了地图组这一个概念。这只是 Fusion 对于 OpenLayers 众多改动中的一个。下面我们来看看到底 Fusion 对 OpenLayers 还做了哪些改动。
Fusion 对于 OpenLayers 的改进
为了便于 Fusion 的其他组件能够与地图进行交互， Fusion 对于 OpenLayers 进行了较为全面的包装。一般来说，如果您不是开发 Fusion.Layers 的开发人员，除了使用一些 OpenLayers 的一些工具性的函数之外，您甚至都不需要知道 OpenLayers 的存在。但是，仅仅进行包装是不够的，由于 OpenLayers 与 Fusion 定位的不同， Fusion 必须对 OpenLayers 进行扩展才能适应更为复杂的模型。

1.       Fusion 中添加了选择集的概念。 OpenLayers 在同一张地图里面显示多种不同数据源的方面确实做的很好，遗憾的是，它缺少选择集这一至关重要的概念。对于 OpenLayers 来说，选择集完全是可有可无的，因为它的目的在于将地图展示出来，而且，很多地图根本就没有选择集这样的 API ，比如 Google 地图等等。但对于 Fusion 则不同，我们很难想象没有选择集，用户该如何利用 MapGuide 进行管理。所以， Fusion 加入了选择集这个概念，并且要求实现 Layers 的地图（比如 MapGuide ）实现选择集功能。我们可以看到， Fusion.Widget.Map 中不但有诸如 get/set/clear/hasSelection 这样控制和读取选择集的函数，而且有 MAP_SELECTION_ON 和 MAP_SELECTION_OFF 这两个事件来通知监听者地图选择集的当前状况。

2.       Fusion 开放了更多的事件。借助于 Fusion 自己独立实现的事件机制， Fusion 允许用户接收到更多种类的事件，比如 Session 是否已创建、地图当前忙碌与否、选择集状态变更、当前图层（这个是 Fusion 中的图层，不是 OpenLayers 的）变化等等。

3.       Fusion 允许地图的实现类返回自身支持哪些比例尺，这就使得用户可以直观的知道自己当前缩放地图到什么程度。

4.       允许用户随时设置当前地图的背景图片和地图上的光标形状。这对于直观地反应地图当前状态是是否有用的。

5.       支持右键菜单。虽然在浏览器上实现右键菜单相对简单一些，但是通过使用地图 Widget 的 setContextMenu ，代码编写者就可以直接把已经准备好的 div 作为右键菜单，再也不需要直接与底层鼠标事件打交道了。

地图的定义
前面在介绍 Fusion 与 OpenLayers 术语不同的时候，摘录了应用程序定义中对于地图部分的定义。通过解析这个定义， Fusion 了解了应该如何加载该地图。下面，我们就来看看这个定义中到底都定义了哪些东西。

在 Fusion 中，一个地图组用一个 MapGroup 进行标签定义， MapGroup 里面的 Map 标签就是对于一个地图的定义了。

1.       Type: 该标签标示了地图的类型。所有 MapGuide 地图该标签的值均为 MapGuide 。当 Fusion 读取到该地图的 Type 时，就会用对应的 “Fusion.Layers. 标签值 ” 来初始化该地图。比如 MapGuide 地图就会用 Fusion.Layer.MapGuide 来初始化。

2.       SingleTile: 如果该项为真，则表示该项不采用分块服务。

3.       Extension: 该于扩展 Map 标签，来为地图初始化提供更多的信息。各个 Fusion.Layers 的实现类可以自行决定其需要的内容，以及如何解释这些内容。对于 MapGuide 而言，有以下常见的扩展：

a)         ResourceId: MapDefinition 的资源 Id ，通过该 Id ， Fusion 可以知道加载哪一个地图定义。

b)        SelectionAsOverLay: 如果该项是 true ，那么将会使用 GETDYNAMICOVERLAY 来获取地图，否则采用 GETMAPIMAGE 来获取地图。前者是新版本才支持的，可以把选择集和地图本身绘制成两张地图。如果您使用的 MapGuide 版本比较旧，您可以把该项设置成为 false

c)         SelectionColor: 该项表示用什么颜色来显示选中的要素。

现在成熟的地图平台均不同程度上支持瓦片生成方式，而且每个WebGIS产品均有各自不同的瓦片(Tile)组织方式。MapGuide OS/E 的和Bing Map、Google Map、TMS的组织方式有很大不同，如果可以知道存储方式就可以自己实现MapGuide Provider，部署地图时则不需要安装MapGuide OS/E。现分析下以供有缘人使用。

       public override Uri GetUri(int x, int y, int zoomLevel)
        {//适用于MS Silverlight mapControl，xy为行列号，zoomLevel为当前地图比例级别
            string tileRowGroup = “”;
            string tileColGroup = “”;
            if (x >= 0 && y >= 0 )
            {
                tileRowGroup += (Math.Floor(x/tileRowsPerFolder) * tileRowsPerFolder).ToString();//tileRowsPerFolder=30
                tileColGroup += (Math.Floor(y / tileColumnsPerFolder) * tileColumnsPerFolder).ToString();
                string tilePath = “/S” + Math.Floor(zoomLevel)
                + “/” + basemaplayergroupname
                + “/R” + tileRowGroup
                + “/C” + tileColGroup
                + “/” + (x % tileRowsPerFolder)
                + “_” + (y % tileColumnsPerFolder)
                +”.” + this.format;//png
                return new Uri(this.url + tilePath);
            }
            return null;
        }