blogjava-凯发k8网页登录

java sax 解析实例

小菜毛毛 — wed, 11 may 2011 14:34:00 gmt

用sax解析xml实例

实例：以下输出中的所有属性和标签值

package com.meixin.xml;

import java.io.file;
import java.util.hashmap;
import java.util.vector;

import org.xml.sax.attributes;
import org.xml.sax.saxexception;
import org.xml.sax.helpers.defaulthandler;

import javax.xml.parsers.saxparser;
import javax.xml.parsers.saxparserfactory;

public class prasexml extends defaulthandler
{

  private vector tagname;

  private vector tagvalue;

  private int step;

  // 开始解析xml文件
  public void startdocument() throws saxexception
  {
    tagname = new vector();
    tagvalue = new vector();
    step = 0;
  }

  // 结束解析xml文件
  public void enddocument() throws saxexception
  {
    for (int i = 0; i < tagname.size(); i )
    {
      if (!tagname.get(i).equals("") || tagname.get(i) != null)
      {
        system.out.println("节点名称：" tagname.get(i));
        system.out.println("节点值：" tagvalue.get(i));
      }
    }
  }

  /**
    * 在解释到一个开始元素时会调用此方法.但是当元素有重复时可以自己写算法来区分
    * 这些重复的元素.qname是什么? 这样写就会抛出saxexception错误
    * 通常情况下qname等于localname
    */
  public void startelement(string uri, string localname, string qname,
      attributes attributes) throws saxexception
  {
    // 节点名称
    tagname.add(qname);
    // 循环输出属性
    for (int i = 0; i < attributes.getlength(); i )
    {
      // 获取属性名称
      system.out.println("属性名称：" attributes.getqname(i));
      // 获取属性值
      system.out.println("属性值："
           attributes.getvalue(attributes.getqname(i)));
    }

  }

  /**
    * 在遇到结束标签时调用此方法
    */
  public void endelement(string uri, string localname, string qname)
      throws saxexception
  {

    step = step 1;
  }

  /**
    * 读取标签里的值,ch用来存放某行的xml的字符数据,包括标签,初始大小是2048,
    * 每解释到新的字符会把它添加到char[]里。    * 注意,这个char字符会自己管理存储的字符,
    * 并不是每一行就会刷新一次char,start,length是由xml的元素数据确定的,
    * 暂时找不到规律,以后看源代码.
    *
    * 这里一个正标签，反标签都会被执行一次characters，所以在反标签时不用获得其中的值
    */
  public void characters(char ch[], int start, int length)
      throws saxexception
  {
    // 只要当前的标签组的长度一至，值就不赋，则反标签不被计划在内
    if (tagname.size() - 1 == tagvalue.size())
    {
      tagvalue.add(new string(ch, start, length));
    }
  }

  public static void main(string[] args)
  {
    string filename = "myxml.xml";
    saxparserfactory spf = saxparserfactory.newinstance();
    try
    {
      saxparser saxparser = spf.newsaxparser();
      saxparser.parse(new file(filename), new prasexml());
    }
    catch (exception e)
    {
      e.printstacktrace();
    }
  }

  public vector gettagname()
  {
    return tagname;
  }

  public void settagname(vector tagname)
  {
    this.tagname = tagname;
  }

  public vector gettagvalue()
  {
    return tagvalue;
  }

  public void settagvalue(vector tagvalue)
  {
    this.tagvalue = tagvalue;
  }

}

输出结果：

属性名称：personid
属性值：e01
属性名称：enable
属性值：true
属性名称：personid
属性值：e02
属性名称：enable
属性值：false
属性名称：personid
属性值：e03
属性名称：enable
属性值：true
节点名称：people
节点值：


节点名称：person
节点值：

节点名称：name
节点值：张三
节点名称：tel
节点值：5128
节点名称：email
节点值：txq512@sina.com
节点名称：person
节点值：

节点名称：name
节点值：meixin
节点名称：tel
节点值：5252525
节点名称：email
节点值：wnight88@sina.com
节点名称：person
节点值：

节点名称：name
节点值：yu
节点名称：tel
节点值：5389654
节点名称：email
节点值：yu@188.net

文件内容

xml version="1.0" encoding="utf-8"?>
<people>

  <person personid="e01" enable="true">
    <name>张三name>
    <tel>5128tel>
    <email>txq512@sina.comemail>
  person>

  <person personid="e02" enable="false">
    <name>meixinname>
    <tel>5252525tel>
    <email>wnight88@sina.comemail>
  person>

  <person personid="e03" enable="true">
    <name>yuname>
    <tel>5389654tel>
    <email>yu@188.netemail>
  person>

people>

http://wnight88.blog.51cto.com/512204/163197/

小菜毛毛 2011-05-11 22:34

]]>

spring 框架的设计理念与设计模式分析

小菜毛毛 — tue, 15 feb 2011 08:13:00 gmt

简介： spring 作为现在最优秀的框架之一，已被广泛的使用，并且有很多对其分析的文章。本文将从另外一个视角试图剖析出 spring 框架的作者设计 spring 框架的骨骼架构的设计理念，有那几个核心组件？为什么需要这些组件？它们又是如何结合在一起构成 spring 的骨骼架构？ spring 的 aop 特性又是如何利用这些基础的骨骼架构来工作的？ spring 中又使用了那些设计模式来完成它的这种设计的？它的这种设计理念对对我们以后的软件设计有何启示？本文将详细解答这些问题。

spring 总共有十几个组件，但是真正核心的组件只有几个，下面是 spring 框架的总体架构图：

从上图中可以看出 spring 框架中的核心组件只有三个：core、context 和 beans。它们构建起了整个 spring 的骨骼架构。没有它们就不可能有 aop、web 等上层的特性功能。下面也将主要从这三个组件入手分析 spring。

前面介绍了 spring 的三个核心组件，如果再在它们三个中选出核心的话，那就非 beans 组件莫属了，为何这样说，其实 spring 就是面向 bean 的编程（bop,bean oriented programming），bean 在 spring 中才是真正的主角。

bean 在 spring 中作用就像 object 对 oop 的意义一样，没有对象的概念就像没有面向对象编程，spring 中没有 bean 也就没有 spring 存在的意义。就像一次演出舞台都准备好了但是却没有演员一样。为什么要 bean 这种角色 bean 或者为何在 spring 如此重要，这由 spring 框架的设计目标决定，spring 为何如此流行，我们用 spring 的原因是什么，想想你会发现原来 spring 解决了一个非常关键的问题他可以让你把对象之间的依赖关系转而用配置文件来管理，也就是他的依赖注入机制。而这个注入关系在一个叫 ioc 容器中管理，那 ioc 容器中有又是什么就是被 bean 包裹的对象。spring 正是通过把对象包装在 bean 中而达到对这些对象管理以及一些列额外操作的目的。

它这种设计策略完全类似于 java 实现 oop 的设计理念，当然了 java 本身的设计要比 spring 复杂太多太多，但是都是构建一个数据结构，然后根据这个数据结构设计他的生存环境，并让它在这个环境中按照一定的规律在不停的运动，在它们的不停运动中设计一系列与环境或者与其他个体完成信息交换。这样想来回过头想想我们用到的其他框架都是大慨类似的设计理念。

前面说 bean 是 spring 中关键因素，那 context 和 core 又有何作用呢？前面吧 bean 比作一场演出中的演员的话，那 context 就是这场演出的舞台背景，而 core 应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是 spring 能提供的特色功能了。

我们知道 bean 包装的是 object，而 object 必然有数据，如何给这些数据提供生存环境就是 context 要解决的问题，对 context 来说他就是要发现每个 bean 之间的关系，为它们建立这种关系并且要维护好这种关系。所以 context 就是一个 bean 关系的集合，这个关系集合又叫 ioc 容器，一旦建立起这个 ioc 容器后 spring 就可以为你工作了。那 core 组件又有什么用武之地呢？其实 core 就是发现、建立和维护每个 bean 之间的关系所需要的一些列的工具，从这个角度看来，core 这个组件叫 util 更能让你理解。

它们之间可以用下图来表示：

这里将详细介绍每个组件内部类的层次关系，以及它们在运行时的时序顺序。我们在使用 spring 是应该注意的地方。

bean 组件

前面已经说明了 bean 组件对 spring 的重要性，下面看看 bean 这个组件式怎么设计的。bean 组件在 spring 的 org.springframework.beans 包下。这个包下的所有类主要解决了三件事：bean 的定义、bean 的创建以及对 bean 的解析。对 spring 的使用者来说唯一需要关心的就是 bean 的创建，其他两个由 spring 在内部帮你完成了，对你来说是透明的。

spring bean 的创建时典型的工厂模式，他的顶级接口是 beanfactory，下图是这个工厂的继承层次关系：

beanfactory 有三个子类：listablebeanfactory、hierarchicalbeanfactory 和 autowirecapablebeanfactory。但是从上图中我们可以发现最终的默认实现类是 defaultlistablebeanfactory，他实现了所有的接口。那为何要定义这么多层次的接口呢？查阅这些接口的源码和说明发现，每个接口都有他使用的场合，它主要是为了区分在 spring 内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。例如 listablebeanfactory 接口表示这些 bean 是可列表的，而 hierarchicalbeanfactory 表示的是这些 bean 是有继承关系的，也就是每个 bean 有可能有父 bean。autowirecapablebeanfactory 接口定义 bean 的自动装配规则。这四个接口共同定义了 bean 的集合、bean 之间的关系、以及 bean 行为。

bean 的定义主要有 beandefinition 描述，如下图说明了这些类的层次关系：

bean 的定义就是完整的描述了在 spring 的配置文件中你定义的节点中所有的信息，包括各种子节点。当 spring 成功解析你定义的一个节点后，在 spring 的内部他就被转化成 beandefinition 对象。以后所有的操作都是对这个对象完成的。

bean 的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，必须保证有足够的灵活性，以应对可能的变化。bean 的解析主要就是对 spring 配置文件的解析。这个解析过程主要通过下图中的类完成：

当然还有具体对 tag 的解析这里并没有列出。

context 组件

context 在 spring 的 org.springframework.context 包下，前面已经讲解了 context 组件在 spring 中的作用，他实际上就是给 spring 提供一个运行时的环境，用以保存各个对象的状态。下面看一下这个环境是如何构建的。

applicationcontext 是 context 的顶级父类，他除了能标识一个应用环境的基本信息外，他还继承了五个接口，这五个接口主要是扩展了 context 的功能。下面是 context 的类结构图：

（查看。）

从上图中可以看出 applicationcontext 继承了 beanfactory，这也说明了 spring 容器中运行的主体对象是 bean，另外 applicationcontext 继承了 resourceloader 接口，使得 applicationcontext 可以访问到任何外部资源，这将在 core 中详细说明。

applicationcontext 的子类主要包含两个方面：

configurableapplicationcontext 表示该 context 是可修改的，也就是在构建 context 中用户可以动态添加或修改已有的配置信息，它下面又有多个子类，其中最经常使用的是可更新的 context，即 abstractrefreshableapplicationcontext 类。
webapplicationcontext 顾名思义，就是为 web 准备的 context 他可以直接访问到 servletcontext，通常情况下，这个接口使用的少。

再往下分就是按照构建 context 的文件类型，接着就是访问 context 的方式。这样一级一级构成了完整的 context 等级层次。

总体来说 applicationcontext 必须要完成以下几件事：

标识一个应用环境
利用 beanfactory 创建 bean 对象
保存对象关系表
能够捕获各种事件

context 作为 spring 的 ioc 容器，基本上整合了 spring 的大部分功能，或者说是大部分功能的基础。

core 组件

core 组件作为 spring 的核心组件，他其中包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。这种把所有资源都抽象成一个接口的方式很值得在以后的设计中拿来学习。下面就重要看一下这个部分在 spring 的作用。

下图是 resource 相关的类结构图：

（查看。）

从上图可以看出 resource 接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。对资源的提供者来说，如何把资源包装起来交给其他人用这也是一个问题，我们看到 resource 接口继承了 inputstreamsource 接口，这个接口中有个 getinputstream 方法，返回的是 inputstream 类。这样所有的资源都被可以通过 inputstream 这个类来获取，所以也屏蔽了资源的提供者。另外还有一个问题就是加载资源的问题，也就是资源的加载者要统一，从上图中可以看出这个任务是由 resourceloader 接口完成，他屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源，他的默认实现是 defaultresourceloader。

下面看一下 context 和 resource 是如何建立关系的？首先看一下他们的类关系图：

从上图可以看出，context 是把资源的加载、解析和描述工作委托给了 resourcepatternresolver 类来完成，他相当于一个接头人，他把资源的加载、解析和资源的定义整合在一起便于其他组件使用。core 组件中还有很多类似的方式。

ioc 容器如何工作

前面介绍了 core 组件、bean 组件和 context 组件的结构与相互关系，下面这里从使用者角度看一下他们是如何运行的，以及我们如何让 spring 完成各种功能，spring 到底能有那些功能，这些功能是如何得来的，下面介绍。

如何创建 beanfactory 工厂

正如图 2 描述的那样，ioc 容器实际上就是 context 组件结合其他两个组件共同构建了一个 bean 关系网，如何构建这个关系网？构建的入口就在 abstractapplicationcontext 类的 refresh 方法中。这个方法的代码如下：

                        public void refresh() throws beansexception, illegalstateexception {
                        synchronized (this.startupshutdownmonitor) {
                        // prepare this context for refreshing.
                        preparerefresh();
                        // tell the subclass to refresh the internal bean factory.
                        configurablelistablebeanfactory beanfactory = obtainfreshbeanfactory();
                        // prepare the bean factory for use in this context.
                        preparebeanfactory(beanfactory);
                        try {
                        // allows post-processing of the bean factory in context subclasses.
                        postprocessbeanfactory(beanfactory);
                        // invoke factory processors registered as beans in the context.
                        invokebeanfactorypostprocessors(beanfactory);
                        // register bean processors that intercept bean creation.
                        registerbeanpostprocessors(beanfactory);
                        // initialize message source for this context.
                        initmessagesource();
                        // initialize event multicaster for this context.
                        initapplicationeventmulticaster();
                        // initialize other special beans in specific context subclasses.
                        onrefresh();
                        // check for listener beans and register them.
                        registerlisteners();
                        // instantiate all remaining (non-lazy-init) singletons.
                        finishbeanfactoryinitialization(beanfactory);
                        // last step: publish corresponding event.
                        finishrefresh();
                        }
                        catch (beansexception ex) {
                        // destroy already created singletons to avoid dangling resources.
                        destroybeans();
                        // reset 'active' flag.
                        cancelrefresh(ex);
                        // propagate exception to caller.
                        throw ex;
                        }
                        }
                        }

这个方法就是构建整个 ioc 容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分 spring 的原理和功能了。

这段代码主要包含这样几个步骤：

构建 beanfactory，以便于产生所需的“演员”
注册可能感兴趣的事件
创建 bean 实例对象
触发被监听的事件

下面就结合代码分析这几个过程。

第二三句就是在创建和配置 beanfactory。这里是 refresh 也就是刷新配置，前面介绍了 context 有可更新的子类，这里正是实现这个功能，当 beanfactory 已存在是就更新，如果没有就新创建。下面是更新 beanfactory 的方法代码：

                        protected final void refreshbeanfactory() throws beansexception {
                        if (hasbeanfactory()) {
                        destroybeans();
                        closebeanfactory();
                        }
                        try {
                        defaultlistablebeanfactory beanfactory = createbeanfactory();
                        beanfactory.setserializationid(getid());
                        customizebeanfactory(beanfactory);
                        loadbeandefinitions(beanfactory);
                        synchronized (this.beanfactorymonitor) {
                        this.beanfactory = beanfactory;
                        }
                        }
                        catch (ioexception ex) {
                        throw new applicationcontextexception(
                        "i/o error parsing bean definition source for "
                          getdisplayname(), ex);
                        }
                        }

这个方法实现了 abstractapplicationcontext 的抽象方法 refreshbeanfactory，这段代码清楚的说明了 beanfactory 的创建过程。注意 beanfactory 对象的类型的变化，前面介绍了他有很多子类，在什么情况下使用不同的子类这非常关键。beanfactory 的原始对象是 defaultlistablebeanfactory，这个非常关键，因为他设计到后面对这个对象的多种操作，下面看一下这个类的继承层次类图：

（查看。）

从这个图中发现除了 beanfactory 相关的类外，还发现了与 bean 的 register 相关。这在 refreshbeanfactory 方法中有一行 loadbeandefinitions(beanfactory) 将找到答案，这个方法将开始加载、解析 bean 的定义，也就是把用户定义的数据结构转化为 ioc 容器中的特定数据结构。

这个过程可以用下面时序图解释：

（查看。）

bean 的解析和登记流程时序图如下：

（查看。）

创建好 beanfactory 后，接下去添加一些 spring 本身需要的一些工具类，这个操作在 abstractapplicationcontext 的 preparebeanfactory 方法完成。

abstractapplicationcontext 中接下来的三行代码对 spring 的功能扩展性起了至关重要的作用。前两行主要是让你现在可以对已经构建的 beanfactory 的配置做修改，后面一行就是让你可以对以后再创建 bean 的实例对象时添加一些自定义的操作。所以他们都是扩展了 spring 的功能，所以我们要学习使用 spring 必须对这一部分搞清楚。

其中在 invokebeanfactorypostprocessors 方法中主要是获取实现 beanfactorypostprocessor 接口的子类。并执行它的 postprocessbeanfactory 方法，这个方法的声明如下：

                        void postprocessbeanfactory(configurablelistablebeanfactory beanfactory)
                        throws beansexception;

它的参数是 beanfactory，说明可以对 beanfactory 做修改，这里注意这个 beanfactory 是 configurablelistablebeanfactory 类型的，这也印证了前面介绍的不同 beanfactory 所使用的场合不同，这里只能是可配置的 beanfactory，防止一些数据被用户随意修改。

registerbeanpostprocessors 方法也是可以获取用户定义的实现了 beanpostprocessor 接口的子类，并执行把它们注册到 beanfactory 对象中的 beanpostprocessors 变量中。beanpostprocessor 中声明了两个方法：postprocessbeforeinitialization、postprocessafterinitialization 分别用于在 bean 对象初始化时执行。可以执行用户自定义的操作。

后面的几行代码是初始化监听事件和对系统的其他监听者的注册，监听者必须是 applicationlistener 的子类。

如何创建 bean 实例并构建 bean 的关系网

下面就是 bean 的实例化代码，是从 finishbeanfactoryinitialization 方法开始的。

                        protected void finishbeanfactoryinitialization(
                        configurablelistablebeanfactory beanfactory) {
                        // stop using the temporary classloader for type matching.
                        beanfactory.settempclassloader(null);
                        // allow for caching all bean definition metadata, not expecting further changes.
                        beanfactory.freezeconfiguration();
                        // instantiate all remaining (non-lazy-init) singletons.
                        beanfactory.preinstantiatesingletons();
                        }

从上面代码中可以发现 bean 的实例化是在 beanfactory 中发生的。preinstantiatesingletons 方法的代码如下：

                        public void preinstantiatesingletons() throws beansexception {
                        if (this.logger.isinfoenabled()) {
                        this.logger.info("pre-instantiating singletons in "   this);
                        }
                        synchronized (this.beandefinitionmap) {
                        for (string beanname : this.beandefinitionnames) {
                        rootbeandefinition bd = getmergedlocalbeandefinition(beanname);
                        if (!bd.isabstract() && bd.issingleton()
                        && !bd.islazyinit()) {
                        if (isfactorybean(beanname)) {
                        final factorybean factory =
                        (factorybean) getbean(factory_bean_prefix  beanname);
                        boolean iseagerinit;
                        if (system.getsecuritymanager() != null
                        && factory instanceof smartfactorybean) {
                        iseagerinit = accesscontroller.doprivileged(
                        new privilegedaction() {
                        public boolean run() {
                        return ((smartfactorybean) factory).iseagerinit();
                        }
                        }, getaccesscontrolcontext());
                        }
                        else {
                        iseagerinit = factory instanceof smartfactorybean
                        && ((smartfactorybean) factory).iseagerinit();
                        }
                        if (iseagerinit) {
                        getbean(beanname);
                        }
                        }
                        else {
                        getbean(beanname);
                        }
                        }
                        }
                        }
                        }

这里出现了一个非常重要的 bean —— factorybean，可以说 spring 一大半的扩展的功能都与这个 bean 有关，这是个特殊的 bean 他是个工厂 bean，可以产生 bean 的 bean，这里的产生 bean 是指 bean 的实例，如果一个类继承 factorybean 用户可以自己定义产生实例对象的方法只要实现他的 getobject 方法。然而在 spring 内部这个 bean 的实例对象是 factorybean，通过调用这个对象的 getobject 方法就能获取用户自定义产生的对象，从而为 spring 提供了很好的扩展性。spring 获取 factorybean 本身的对象是在前面加上 & 来完成的。

如何创建 bean 的实例对象以及如何构建 bean 实例对象之间的关联关系式 spring 中的一个核心关键，下面是这个过程的流程图。

（查看。）

如果是普通的 bean 就直接创建他的实例，是通过调用 getbean 方法。下面是创建 bean 实例的时序图：

（查看。）

还有一个非常重要的部分就是建立 bean 对象实例之间的关系，这也是 spring 框架的核心竞争力，何时、如何建立他们之间的关系请看下面的时序图：

（查看。）

ioc 容器的扩展点

现在还有一个问题就是如何让这些 bean 对象有一定的扩展性，就是可以加入用户的一些操作。那么有哪些扩展点呢？ spring 又是如何调用到这些扩展点的？

对 spring 的 ioc 容器来说，主要有这么几个。beanfactorypostprocessor， beanpostprocessor。他们分别是在构建 beanfactory 和构建 bean 对象时调用。还有就是 initializingbean 和 disposablebean 他们分别是在 bean 实例创建和销毁时被调用。用户可以实现这些接口中定义的方法，spring 就会在适当的时候调用他们。还有一个是 factorybean 他是个特殊的 bean，这个 bean 可以被用户更多的控制。

这些扩展点通常也是我们使用 spring 来完成我们特定任务的地方，如何精通 spring 就看你有没有掌握好 spring 有哪些扩展点，并且如何使用他们，要知道如何使用他们就必须了解他们内在的机理。可以用下面一个比喻来解释。

我们把 ioc 容器比作一个箱子，这个箱子里有若干个球的模子，可以用这些模子来造很多种不同的球，还有一个造这些球模的机器，这个机器可以产生球模。那么他们的对应关系就是 beanfactory 就是那个造球模的机器，球模就是 bean，而球模造出来的球就是 bean 的实例。那前面所说的几个扩展点又在什么地方呢？ beanfactorypostprocessor 对应到当造球模被造出来时，你将有机会可以对其做出设当的修正，也就是他可以帮你修改球模。而 initializingbean 和 disposablebean 是在球模造球的开始和结束阶段，你可以完成一些预备和扫尾工作。beanpostprocessor 就可以让你对球模造出来的球做出适当的修正。最后还有一个 factorybean，它可是一个神奇的球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的球了，这样在这个箱子里尼可以发现所有你想要的球

ioc 容器如何为我所用

前面的介绍了 spring 容器的构建过程，那 spring 能为我们做什么，spring 的 ioc 容器又能做什么呢？我们使用 spring 必须要首先构建 ioc 容器，没有它 spring 无法工作，applicatoncontext.xml 就是 ioc 容器的默认配置文件，spring 的所有特性功能都是基于这个 ioc 容器工作的，比如后面要介绍的 aop。

ioc 它实际上就是为你构建了一个魔方，spring 为你搭好了骨骼架构，这个魔方到底能变出什么好的东西出来，这必须要有你的参与。那我们怎么参与？这就是前面说的要了解 spring 中那有些扩展点，我们通过实现那些扩展点来改变 spring 的通用行为。至于如何实现扩展点来得到我们想要的个性结果，spring 中有很多例子，其中 aop 的实现就是 spring 本身实现了其扩展点来达到了它想要的特性功能，可以拿来参考。

要了解 spring 的 aop 就必须先了解的动态代理的原理，因为 aop 就是基于动态代理实现的。动态代理还要从 jdk 本身说起。

在 jdk 的 java.lang.reflect 包下有个 proxy 类，它正是构造代理类的入口。这个类的结构入下：

从上图发现最后面四个是公有方法。而最后一个方法 newproxyinstance 就是创建代理对象的方法。这个方法的源码如下：

                        public static object newproxyinstance(classloader loader,
                        class[] interfaces,
                        invocationhandler h)
                        throws illegalargumentexception {
                        if (h == null) {
                        throw new nullpointerexception();
                        }
                        class cl = getproxyclass(loader, interfaces);
                        try {
                        constructor cons = cl.getconstructor(constructorparams);
                        return (object) cons.newinstance(new object[] { h });
                        } catch (nosuchmethodexception e) {
                        throw new internalerror(e.tostring());
                        } catch (illegalaccessexception e) {
                        throw new internalerror(e.tostring());
                        } catch (instantiationexception e) {
                        throw new internalerror(e.tostring());
                        } catch (invocationtargetexception e) {
                        throw new internalerror(e.tostring());
                        }
                        }

这个方法需要三个参数：classloader，用于加载代理类的 loader 类，通常这个 loader 和被代理的类是同一个 loader 类。interfaces，是要被代理的那些那些接口。invocationhandler，就是用于执行除了被代理接口中方法之外的用户自定义的操作，他也是用户需要代理的最终目的。用户调用目标方法都被代理到 invocationhandler 类中定义的唯一方法 invoke 中。这在后面再详解。

下面还是看看 proxy 如何产生代理类的过程，他构造出来的代理类到底是什么样子？下面揭晓啦。

其实从上图中可以发现正在构造代理类的是在 proxygenerator 的 generateproxyclass 的方法中。proxygenerator 类在 sun.misc 包下，感兴趣的话可以看看他的源码。

假如有这样一个接口，如下：

                        public interface simpleproxy {
                        public void simplemethod1();
                        public void simplemethod2();
                        }

代理来生成的类结构如下：

                        public class $proxy2 extends java.lang.reflect.proxy implements simpleproxy{
                        java.lang.reflect.method m0;
                        java.lang.reflect.method m1;
                        java.lang.reflect.method m2;
                        java.lang.reflect.method m3;
                        java.lang.reflect.method m4;
                        int hashcode();
                        boolean equals(java.lang.object);
                        java.lang.string tostring();
                        void simplemethod1();
                        void simplemethod2();
                        }

这个类中的方法里面将会是调用 invocationhandler 的 invoke 方法，而每个方法也将对应一个属性变量，这个属性变量 m 也将传给 invoke 方法中的 method 参数。整个代理就是这样实现的。

从前面代理的原理我们知道，代理的目的是调用目标方法时我们可以转而执行 invocationhandler 类的 invoke 方法，所以如何在 invocationhandler 上做文章就是 spring 实现 aop 的关键所在。

spring 的 aop 实现是遵守 aop 联盟的约定。同时 spring 又扩展了它，增加了如 pointcut、advisor 等一些接口使得更加灵活。

下面是 jdk 动态代理的类图：

上图清楚的显示了 spring 引用了 aop alliance 定义的接口。姑且不讨论 spring 如何扩展 aop alliance，先看看 spring 如何实现代理类的，要实现代理类在 spring 的配置文件中通常是这样定一个 bean 的，如下：

                        
                        
                        
                        org.springframework.aop.framework.prototypetargettests$testbean
                        
                        
                         
                        true
                        
                        
                        testinterceptor
                        testinterceptor2

配置上看到要设置被代理的接口，和接口的实现类也就是目标类，以及拦截器也就在执行目标方法之前被调用，这里 spring 中定义的各种各样的拦截器，可以选择使用。

下面看看 spring 如何完成了代理以及是如何调用拦截器的。

前面提到 spring aop 也是实现其自身的扩展点来完成这个特性的，从这个代理类可以看出它正是继承了 factorybean 的 proxyfactorybean，factorybean 之所以特别就在它可以让你自定义对象的创建方法。当然代理对象要通过 proxy 类来动态生成。

下面是 spring 创建的代理对象的时序图：

spring 创建了代理对象后，当你调用目标对象上的方法时，将都会被代理到 invocationhandler 类的 invoke 方法中执行，这在前面已经解释。在这里 jdkdynamicaopproxy 类实现了 invocationhandler 接口。

下面再看看 spring 是如何调用拦截器的，下面是这个过程的时序图：

以上所说的都是 jdk 动态代理，spring 还支持一种 cglib 类代理，感兴趣自己看吧。

spring 中使用的设计模式也很多，比如工厂模式、单例模式、模版模式等，在《 webx 框架的系统架构与设计模式》、《 tomcat 的系统架构与模式设计分析》已经有介绍，这里就不赘述了。这里主要介绍代理模式和策略模式。

代理模式原理

代理模式就是给某一个对象创建一个代理对象，而由这个代理对象控制对原对象的引用，而创建这个代理对象就是可以在调用原对象是可以增加一些额外的操作。下面是代理模式的结构：

subject：抽象主题，它是代理对象的真实对象要实现的接口，当然这可以是多个接口组成。
proxysubject：代理类除了实现抽象主题定义的接口外，还必须持有所代理对象的引用
realsubject：被代理的类，是目标对象。

spring 中如何实现代理模式

spring aop 中 jdk 动态代理就是利用代理模式技术实现的。在 spring 中除了实现被代理对象的接口外，还会有 org.springframework.aop.springproxy 和 org.springframework.aop.framework.advised 两个接口。spring 中使用代理模式的结构图如下：

$proxy 就是创建的代理对象，而 subject 是抽象主题，代理对象是通过 invocationhandler 来持有对目标对象的引用的。

spring 中一个真实的代理对象结构如下：

                        public class $proxy4 extends java.lang.reflect.proxy implements
                        org.springframework.aop.framework.prototypetargettests$testbean
                        org.springframework.aop.springproxy
                        org.springframework.aop.framework.advised
                        {
                        java.lang.reflect.method m16;
                        java.lang.reflect.method m9;
                        java.lang.reflect.method m25;
                        java.lang.reflect.method m5;
                        java.lang.reflect.method m2;
                        java.lang.reflect.method m23;
                        java.lang.reflect.method m18;
                        java.lang.reflect.method m26;
                        java.lang.reflect.method m6;
                        java.lang.reflect.method m28;
                        java.lang.reflect.method m14;
                        java.lang.reflect.method m12;
                        java.lang.reflect.method m27;
                        java.lang.reflect.method m11;
                        java.lang.reflect.method m22;
                        java.lang.reflect.method m3;
                        java.lang.reflect.method m8;
                        java.lang.reflect.method m4;
                        java.lang.reflect.method m19;
                        java.lang.reflect.method m7;
                        java.lang.reflect.method m15;
                        java.lang.reflect.method m20;
                        java.lang.reflect.method m10;
                        java.lang.reflect.method m1;
                        java.lang.reflect.method m17;
                        java.lang.reflect.method m21;
                        java.lang.reflect.method m0;
                        java.lang.reflect.method m13;
                        java.lang.reflect.method m24;
                        int hashcode();
                        int indexof(org.springframework.aop.advisor);
                        int indexof(org.aopalliance.aop.advice);
                        boolean equals(java.lang.object);
                        java.lang.string tostring();
                        void sayhello();
                        void dosomething();
                        void dosomething2();
                        java.lang.class getproxiedinterfaces();
                        java.lang.class gettargetclass();
                        boolean isproxytargetclass();
                        org.springframework.aop.advisor; getadvisors();
                        void addadvisor(int, org.springframework.aop.advisor)
                        throws org.springframework.aop.framework.aopconfigexception;
                        void addadvisor(org.springframework.aop.advisor)
                        throws org.springframework.aop.framework.aopconfigexception;
                        void settargetsource(org.springframework.aop.targetsource);
                        org.springframework.aop.targetsource gettargetsource();
                        void setprefiltered(boolean);
                        boolean isprefiltered();
                        boolean isinterfaceproxied(java.lang.class);
                        boolean removeadvisor(org.springframework.aop.advisor);
                        void removeadvisor(int)throws org.springframework.aop.framework.aopconfigexception;
                        boolean replaceadvisor(org.springframework.aop.advisor,
                        org.springframework.aop.advisor)
                        throws org.springframework.aop.framework.aopconfigexception;
                        void addadvice(org.aopalliance.aop.advice)
                        throws org.springframework.aop.framework.aopconfigexception;
                        void addadvice(int, org.aopalliance.aop.advice)
                        throws org.springframework.aop.framework.aopconfigexception;
                        boolean removeadvice(org.aopalliance.aop.advice);
                        java.lang.string toproxyconfigstring();
                        boolean isfrozen();
                        void setexposeproxy(boolean);
                        boolean isexposeproxy();
                        }

策略模式原理

策略模式顾名思义就是做某事的策略，这在编程上通常是指完成某个操作可能有多种方法，这些方法各有千秋，可能有不同的适应的场合，然而这些操作方法都有可能用到。各一个操作方法都当作一个实现策略，使用者可能根据需要选择合适的策略。

下面是策略模式的结构：

context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要的操作。它持有一个策略实例的引用。创建具体策略对象的方法也可以由他完成。
strategy：抽象策略，定义每个策略都要实现的策略方法
concretestrategy：具体策略实现类，实现抽象策略中定义的策略方法

spring 中策略模式的实现

spring 中策略模式使用有多个地方，如 bean 定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。

前面已经了解 spring 的代理方式有两个 jdk 动态代理和 cglib 代理。这两个代理方式的使用正是使用了策略模式。它的结构图如下所示：

在上面结构图中与标准的策略模式结构稍微有点不同，这里抽象策略是 aopproxy 接口，cglib2aopproxy 和 jdkdynamicaopproxy 分别代表两种策略的实现方式，proxyfactorybean 就是代表 context 角色，它根据条件选择使用 jdk 代理方式还是 cglib 方式，而另外三个类主要是来负责创建具体策略对象，proxyfactorybean 是通过依赖的方法来关联具体策略对象的，它是通过调用策略对象的 getproxy(classloader classloader) 方法来完成操作。

本文通过从 spring 的几个核心组件入手，试图找出构建 spring 框架的骨骼架构，进而分析 spring 在设计的一些设计理念，是否从中找出一些好的设计思想，对我们以后程序设计能提供一些思路。接着再详细分析了 spring 中是如何实现这些理念的，以及在设计模式上是如何使用的。

通过分析 spring 给我一个很大的启示就是其这套设计理念其实对我们有很强的借鉴意义，它通过抽象复杂多变的对象，进一步做规范，然后根据它定义的这套规范设计出一个容器，容器中构建它们的复杂关系，其实现在有很多情况都可以用这种类似的处理方法。

虽然我很想把我对 spring 的想法完全阐述清楚，但是所谓“书不尽言，言不尽意。”，有什么不对或者不清楚的地方大家还是看看其源码吧。

原文地址

小菜毛毛 2011-02-15 16:13

]]>

java反射详解

小菜毛毛 — thu, 13 jan 2011 09:09:00 gmt

阅读全文

小菜毛毛 2011-01-13 17:09

]]>

java对象序列化（整理篇）

小菜毛毛 — thu, 13 jan 2011 05:29:00 gmt

在网上看了很多有关序列化的文章，我自己也写了两篇，现在感觉这些文章都没有很好的把序列化说清楚(包括我自己在内)，所以在此我将总结前人以及自己的经验，用更浅显易懂的语言来描述该机制，当然，仍然会有不好的地方，希望你看后可以指出，作为一名程序员应该具有不断探索的精神和强烈的求知欲望！

序列化概述：

简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说(就是i/o)，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

问题的引出：

如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！举个例子来说：假如我有两个类，分别是a和b，b类中含有一个指向a类对象的引用，现在我们对两个类进行实例化{ a a = new a(); b b = new b(); }，这时在内存中实际上分配了两个空间，一个存储对象a，一个存储对象b，接下来我们想将它们写入到磁盘的一个文件中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a的数据复制一份到b中，这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时，内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！

以下序列化机制的凯发天生赢家一触即发官网的解决方案：

1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等)

2.当要保存一个对象时，先检查该对象是否被保存了。

3.如果以前保存过，只需写入"与已经保存的具有序列号x的对象相同"的标记，否则，保存该对象

通过以上的步骤序列化机制解决了对象引用的问题！

序列化的实现：

将需要被序列化的类实现serializable接口，该接口没有需要实现的方法，implements serializable只是为了标注该对象是可被序列化的，然后使用一个输出流(如：fileoutputstream)来构造一个 objectoutputstream(对象流)对象，接着，使用objectoutputstream对象的writeobject(object obj)方法就可以将参数为obj的对象写出(即保存其状态)，要恢复的话则用输入流。

例子：

import java.io.*;

public class test
{
    public static void main(string[] args)
    {
        employee harry = new employee("harry hacker", 50000);
        manager manager1 = new manager("tony tester", 80000);
        manager1.setsecretary(harry);

        employee[] staff = new employee[2];

        staff[0] = harry;
        staff[1] = manager1;
        try
        {
            objectoutputstream out = new objectoutputstream(
                new fileoutputstream("employee.dat"));
            out.writeobject(staff);
            out.close();

            objectinputstream in = new objectinputstream(
                new fileinputstream("employee.dat"));
            employee[] newstaff = (employee[])in.readobject();
            in.close();

            /**
             *通过harry对象来加薪
             *将在secretary上反映出来
             */
            newstaff[0].raisesalary(10);

            for (int i = 0; i < newstaff.length; i )
                system.out.println(newstaff[i]);
        }
        catch (exception e)
        {
            e.printstacktrace();
        }
    }

}

class employee implements serializable
{
    public employee(string n, double s)
    {
        name = n;
        salary = s;
    }

    /**
     *加薪水
     */
    public void raisesalary(double bypercent)
    {
        double raise = salary * bypercent / 100;
        salary = raise;
    }

    public string tostring()
    {
        return getclass().getname()
            "[name = " name
            ",salary = " salary
            "]";
    }

    private string name;
    private double salary;
}

class manager extends employee
{
    public manager(string n, double s)
    {
        super(n, s);
        secretary = null;
    }

    /**
     *设置秘书
     */
    public void setsecretary(employee s)
    {
        secretary = s;
    }

    public string tostring()
    {
        return super.tostring()
            "[secretary = " secretary
            "]";
    }

    //secretary代表秘书
    private employee secretary;
}

修改默认的序列化机制：

在序列化的过程中，有些数据字段我们不想将其序列化，对于此类字段我们只需要在定义时给它加上transient关键字即可，对于transient字段序列化机制会跳过不会将其写入文件，当然也不可被恢复。但有时我们想将某一字段序列化，但它在sdk中的定义却是不可序列化的类型，这样的话我们也必须把他标注为transient，可是不能写入又怎么恢复呢？好在序列化机制为包含这种特殊问题的类提供了如下的方法定义：

private void readobject(objectinputstream in) throws

ioexception, classnotfoundexception;

private void writeobject(objectoutputstream out) throws

ioexception;

(注：这些方法定义时必须是私有的，因为不需要你显示调用，序列化机制会自动调用的)

使用以上方法我们可以手动对那些你又想序列化又不可以被序列化的数据字段进行写出和读入操作。

下面是一个典型的例子，java.awt.geom包中的point2d.double类就是不可序列化的，因为该类没有实现serializable接口，在我的例子中将把它当作labeledpoint类中的一个数据字段，并演示如何将其序列化！

import java.io.*;
import java.awt.geom.*;

public class transienttest
{
    public static void main(string[] args)
    {
        labeledpoint label = new labeledpoint("book", 5.00, 5.00);
        try
        {
            system.out.println(label);//写入前
            objectoutputstream out = new objectoutputstream(new
                fileoutputstream("label.txt"));
            out.writeobject(label);
            out.close();

            system.out.println(label);//写入后

            objectinputstream in = new objectinputstream(new
                fileinputstream("label.txt"));
            labeledpoint label1 = (labeledpoint)in.readobject();
            in.close();
            system.out.println(label1);//读出并加1.0后
        }
        catch (exception e)
        {
            e.printstacktrace();
        }
    }

}

class labeledpoint implements serializable
{
    public labeledpoint(string str, double x, double y)
    {
        label = str;
        point = new point2d.double(x, y);
    }

    private void writeobject(objectoutputstream out) throws ioexception
    {
        /**
         *必须通过调用defaultwriteobject()方法来写入
         *对象的描述以及那些可以被序列化的字段
         */
        out.defaultwriteobject();
        out.writedouble(point.getx());
        out.writedouble(point.gety());
    }

    private void readobject(objectinputstream in)
        throws ioexception, classnotfoundexception
    {
        /**
         *必须调用defaultreadobject()方法
         */
        in.defaultreadobject();
        double x = in.readdouble() 1.0;
        double y = in.readdouble() 1.0;
        point = new point2d.double(x, y);
    }

    public string tostring()
    {
        return getclass().getname()
            "[label = " label
            ", point.getx() = " point.getx()
            ", point.gety() = " point.gety()
            "]";
    }

    private string label;
    transient private point2d.double point;
}

作者blog：

小菜毛毛 2011-01-13 13:29

]]>

android获取contact number的例子（2.0系统以前的获取方式）

小菜毛毛 — fri, 17 dec 2010 09:45:00 gmt

string[] projection = new string[] {

people._id,

people.name,

people.number,

};

// get the base uri for people table in contacts content provider.

// which is: content://contacts/people/

uri contacturi = people.content_uri;

// best way to retrieve a query; returns a managed query.

cursor peoplecursor = managedquery (contacturi,

projection, //which columns to return.

null, // where clause--we won't specify.

null, // selection args??

people.default_sort_order); // order-by name

// go to the beginning of the list

peoplecursor.movetofirst();

// so, here we have a contact. we need to get the contact id (_id) then

// build the uri to get the phones section of that user's record

// which is a subdirectory of a contact record

long personid = peoplecursor.getlong(peoplecursor.getcolumnindex("_id"));

uri personuri = contenturis.withappendedid(contacturi, personid );

// so now the url looks like: content://contacts/people/_id(where the actual id of the record is here)

uri phoneuri=

uri.withappendedpath(personuri, contacts.people.phones.content_directory);

// now the url looks like: content://contacts/people/_id/phones (where phones is literally "phones")

// now get all the phone numbers for this contact

cursor phonescursor = managedquery(phoneuri,

null,

phones.default_sort_order);

// we now have a cursor for all the phone numbers for that user id

// go to the beginning of the phone list.

phonescursor.movetofirst();

小菜毛毛 2010-12-17 17:45

]]>

android 2.2 获取联系人，电话，并拨号

小菜毛毛 — fri, 17 dec 2010 08:58:00 gmt

android 2.2 获取联系人，电话，并拨号

该demo是第一次基于android开发。

主要功能有：读取联系人姓名、号码，并lisetview 显示，获取listview数据，并发短信、或者拨号

package com.android.hello;

import android.app.activity;
import android.content.intent;
import android.database.cursor;
import android.graphics.color;
import android.net.uri;
import android.os.bundle;
import android.telephony.phonenumberutils;
import android.util.log;
import android.view.view;
import android.widget.adapterview;
import android.widget.linearlayout;
import android.widget.listadapter;
import android.widget.listview;
import android.widget.relativelayout;
import android.widget.textview;
import android.widget.toast;
import android.provider.contactscontract;

import java.util.arraylist;
import java.util.hashmap;
import android.widget.simpleadapter;

@suppresswarnings("deprecation")
public class hello extends activity {
    /** called when the activity is first created. */
   // @suppresswarnings("deprecation")
// @override
//
private static final string tag="app";
    listview listview;
    listadapter adapter;
    /** called when the activity is first created. */
    @override
    public void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
       // setcontentview(r.layout.main);
        linearlayout linearlayout=new linearlayout(this);
        linearlayout.setorientation(linearlayout.vertical);
        linearlayout.setbackgroundcolor(color.black);
        linearlayout.layoutparams param=new linearlayout.layoutparams(linearlayout.layoutparams.fill_parent,linearlayout.layoutparams.wrap_content);

        listview=new listview(this);
        listview.setbackgroundcolor(color.black);

        linearlayout.addview(listview,param);

        this.setcontentview(linearlayout);


      //生成动态数组，加入数据
        arraylist> listitem = new arraylist>();
        arraylist> listitemread = new arraylist>();
        cursor cursor = getcontentresolver().query(contactscontract.contacts.content_uri,null, null, null, null);
        while (cursor.movetonext())
        {
        hashmap map = new hashmap();
        string phonename = cursor.getstring(cursor.getcolumnindex(contactscontract.contacts.display_name));
        map.put("itemtitle", phonename);//电话姓名
        string contactid = cursor.getstring(cursor.getcolumnindex(contactscontract.contacts._id));
            string hasphone = cursor.getstring(cursor.getcolumnindex(contactscontract.contacts.has_phone_number));

            if (hasphone.compareto("1") == 0)
            {
                cursor phones = getcontentresolver().query(contactscontract.commondatakinds.phone.content_uri,null,contactscontract.commondatakinds.phone.contact_id " = " contactid,null, null);
                while (phones.movetonext())
                {
                string phonenumber = phones.getstring(phones.getcolumnindex(contactscontract.commondatakinds.phone.number));
                    string phonetpye = phones.getstring(phones.getcolumnindex(contactscontract.commondatakinds.phone.type));

                    map.put("itemtext", phonenumber); // 多个号码如何处理

                    log.d(tag,"testnum=" phonenumber "type:" phonetpye);
                }
                phones.close();
            }
            cursor emails = getcontentresolver().query(contactscontract.commondatakinds.email.content_uri,null,contactscontract.commondatakinds.email.contact_id " = " contactid,null, null);
            while (emails.movetonext())
            {
                string emailaddress = emails.getstring(emails.getcolumnindex(contactscontract.commondatakinds.email.data));
                string emailtype = emails.getstring(emails.getcolumnindex(contactscontract.commondatakinds.email.type));

                log.d(tag,"testnum=" emailaddress "type:" emailtype);
            }
            emails.close();

            listitem.add(map);
        }

        //生成适配器的item和动态数组对应的元素
        simpleadapter listitemadapter = new simpleadapter(this,listitem,//数据源
            android.r.layout.simple_list_item_2,//listitem的xml实现
            //动态数组与imageitem对应的子项
            new string[] {"itemtitle", "itemtext"},
            //imageitem的xml文件里面的一个imageview,两个textview id
            new int[] {android.r.id.text1,android.r.id.text2}
        );

        listview.setadapter(listitemadapter);
        cursor.close();

        //listview.setemptyview(findviewbyid(r.id.empty));

        listview.setonitemselectedlistener(new adapterview.onitemselectedlistener(){

            public void onitemselected(adapterview arg0, view arg1,
                    int arg2, long arg3) {
                // todo auto-generated method stub
                //opentoast("滚动到：" arg0.getselecteditemid());
                //短信发送
            settitle("选择" arg2 "项目");
            opentoast("选择" arg0.getselecteditemid() "项目");
    relativelayout lr = (relativelayout) arg1;
    textview mtext = (textview) lr.getchildat(1);
    opentoast(mtext.gettext().tostring());

    string number = mtext.gettext().tostring();
    log.d(tag, "number=" number);
    // 判断电话号码的有效性
    if (phonenumberutils.isglobalphonenumber(number)) {
     intent intent = new intent(intent.action_sendto, uri
       .parse("smsto://" number));
     intent.putextra("sms_body", "the sms text");
     startactivity(intent);
    }
            }

            public void onnothingselected(adapterview arg0) {
                // todo auto-generated method stub

            }

        });

        listview.setonitemclicklistener(new adapterview.onitemclicklistener(){

   public void onitemclick(adapterview arg0, view arg1,
     int position, long arg3) {
    // todo auto-generated method stub
    // opentoast("click" integer.tostring(position 1) "项目");
    relativelayout lr = (relativelayout) arg1;
    textview mtext = (textview) lr.getchildat(1);
    opentoast(mtext.gettext().tostring());

    string number = mtext.gettext().tostring();
    log.d(tag, "number=" number);
    // 判断电话号码的有效性
    if (phonenumberutils.isglobalphonenumber(number)) {
     intent intent = new intent(intent.action_dial, uri
       .parse("tel://" number));
     startactivity(intent);
    }
   }
  });
}

    private void opentoast(string str){
        toast.maketext(this,str,toast.length_short).show();
    }
}

小菜毛毛 2010-12-17 16:58

]]>

java中文汉字排序

小菜毛毛 — fri, 17 dec 2010 05:22:00 gmt

// collator 类是用来执行区分语言环境的 string 比较的，这里选择使用china

comparator cmp = collator.getinstance(java.util.locale.china);

treemap tree=new treemap(cmp);

string[] arr = {"张三", "李四", "王五"};

// 使根据指定比较器产生的顺序对指定对象数组进行排序。

arrays.sort(arr, cmp);

for (int i = 0; i < arr.length; i )

system.out.println(arr[i]);

另:

示例文本：

string [] test = new string[] {
                "作业",
                "测试",
                "test",
                "我们",
                "。空",
                "镂空",
                "[",
                "浏",
                "皙"
        };

jdk 版本：

1.5.6

开发平台：

eclipse 3.1

关键字：中文排序

概述

我们在应用程序中可能会经常遇到对中文排序的问题，例如姓名列表，词汇表等等。对中文排序，我们使用比较多的是根据汉语拼音发音来确定顺序。

我们可能会经常使用

java.util.

接口，

java.util. .sort((t[] a, comparator super t> c))

等类或方法对含有中文字符的对象进行排序，但是这些在默认情况下都是调用

.compareto( )

方法，这个方法是比较2个字符的 codepoint value，如果第一个字符的值小于第二个，则在排序结果中第一个会在前面，反之亦然。

java.text.

接口及其实现类

其实 java 中提供了和语言相关的类，即 collator 接口及其实现类。

java.text.

是一个具体类，它实现了 comparator 接口中的 compare(object, object) 方法。 rulebasedcollator 根据根据特定语言的默认规则比较字符，也可以按照指定的规则来比较，请参阅 java api 获取此类的详细信息。
如果我们需要对一个有中文的数组进行排序，则可以使用这个类。请看如下示例代码：

import java.util.*;
import java.text.*;
public class test
{
[] test = new [] {
"作业" ,
"测试" ,
"test" ,
"我们" ,
"。空" ,
"镂空" ,
"[" ,
"浏" ,
"皙"
};
java.util. .sort(test,
( ) .getinstance( .china));
.out.println("============" );
for ( key : test)
.out.println(key);
}

以上代码的输出结果为：

============
[
test
。空
测试
我们
作业
浏
镂空
皙

大家可能会发现只有一部分汉字是按照汉语拼音排序了，还有几个没有。

问题分析：

gb2312:
在简体中文中我们使用比较多的字符集是 gb2312-80，简称为 gb2312，这个字符集包含了目前最常用的汉字共计 6736 个。其中的汉字分为两大类：

常用汉字

次常用汉字

常用汉字按照汉语拼音来排序，而次常用汉字按照笔画部首进行排序。

简体汉字在 unicode 中一般是按照 gb2312 的码点值的顺序来放置的，所以如果是常用汉字 java 就能够很准确的进行排序，但如果是次常用汉字，则就会出现问题。在以上示例中，"镂"，"皙" 属于次常用字。

凯发天生赢家一触即发官网的解决方案：

rulebasedcollator 类 getrules() 方法可以返回对应语言的规则设置。简体中文对应的规则是 gb2312 所对应的字符。

对这些汉字重新排序

利用rulebasedcollator(string rules) 构造器新建一个定制的 rulebasedcollator

参考代码

在以下的代码中，我把排过序的汉字直接作为 string 对象放在类里面了，如果要让代码变得简洁一些，则可以把完整的规则（特殊字符＋排序汉字）存为文件。

package sorting;
import java.util.*;
import java.text.*;
/**
* @author gaojianmin
*
*/
public class chinesegb2312collator
{
/**
* @return a customized rulebasedcollator with chinese characters (gb2312) sorted correctly
*
*/
public static final getfixedgb2312collator()
{
fixedgb2312collator =null ;
try
{
fixedgb2312collator = new java.text. (
chinesegb2312collator.getgb2312specialchars()
gb2312chars
);
}catch ( e)
{
e.printstacktrace();
}
return fixedgb2312collator;
}
/**
* @return the special characters in gb2312 charset.
*
*/
public static final getgb2312specialchars()
{
zh_cncollator = ( ) .getinstance( .china);
//index 2125 is the last symbol "╋"
return zh_cncollator.getrules().substring(0,2125);
}
/**
* 6763 chinese characters in gb2312 charset
*/
public static final gb2312chars =
"<吖<阿<啊< 锕<嗄<哎<哀<唉<埃<挨<锿<捱<皑<癌<嗳<矮<蔼< 霭<艾<爱<砹<隘<嗌<嫒<碍<暧<瑷<安<桉<氨<庵< 谙<鹌<鞍<俺<埯<铵<揞<犴<岸<按<案<胺<暗<黯< 肮<昂<盎<凹<坳<敖<嗷<廒<獒<遨<熬<翱<聱<螯< 鳌<鏖<拗<袄<媪<岙<傲<奥<骜<澳<懊<鏊"
"<八<巴<叭< 扒<吧<岜<芭<疤<捌<笆<粑<拔<茇<菝<跋<魃<把< 钯<靶<坝<爸<罢<鲅<霸<灞<掰<白<百<佰<柏<捭< 摆<呗<败<拜<稗<扳<班<般<颁<斑<搬<瘢<癍<阪< 坂<板<版<钣<舨<办<半<伴<扮<拌<绊<瓣<邦<帮< 梆<浜<绑<榜<膀<蚌<傍<棒<谤<蒡<磅<镑<勹<包< 孢<苞<胞<煲<龅<褒<雹<宝<饱<保<鸨<堡<葆<褓< 报<抱<豹<趵<鲍<暴<爆<陂<卑<杯<悲<碑<鹎<北< 贝<狈<邶<备<背<钡<倍<悖<被<惫<焙<辈<碚<蓓< 褙<鞴<鐾<奔<贲<锛<本<苯<畚<坌<笨<崩<绷<嘣< 甭<泵<迸<甏<蹦<逼<荸<鼻<匕<比<吡<妣<彼<秕< 俾<笔<舭<鄙<币<必<毕<闭<庇<畀<哔<毖<荜<陛< 毙<狴<铋<婢<庳<敝<萆<弼<愎<筚<滗<痹<蓖<裨< 跸<辟<弊<碧<箅<蔽<壁<嬖<篦<薜<避<濞<臂<髀< 璧<襞<边<砭<笾<编<煸<蝙<鳊<鞭<贬<扁<窆<匾< 碥<褊<卞<弁<忭<汴<苄<拚<便<变<缏<遍<辨<辩< 辫<灬<杓<彪<标<飑<髟<骠<膘<瘭<镖<飙<飚<镳< 表<婊<裱<鳔<憋<鳖<别<蹩<瘪<宾<彬<傧<斌<滨< 缤<槟<镔<濒<豳<摈<殡<膑<髌<鬓<冫<冰<兵<丙< 邴<秉<柄<炳<饼<禀<并<病<摒<拨<波<玻<剥<钵< 饽<啵<脖<菠<播<伯<孛<驳<帛<泊<勃<亳<钹<铂< 舶<博<渤<鹁<搏<箔<膊<踣<薄<礴<跛<簸<擘<檗< 逋<钸<晡<醭<卜<卟<补<哺<捕<不<布<步<怖<钚< 部<埠<瓿<簿" ;

}
package sorting;
import java.util.*;
import java.text.*;
/**
* @author gaojianmin
*
*/
public class chinesegb2312comparator implements < >, < > {
private gb2312collator =
chinesegb2312collator.getfixedgb2312collator();
private str1;
/**
* @param str1
*/
public chinesegb2312comparator( str1) {
this .str1 = str1;
}
/**
*
*/
public chinesegb2312comparator() {
this .str1="" ;
}
/**
* @param str1
* @param str2
* @return an integer indicatint the comparison result
* @see java.util.comparator#compare(object, object)
*/
public int compare( str1, str2) {
return gb2312collator.compare(str1, str2);
}
/**
* @param str2
* @return an integer indicatint the comparison result
* @see java.lang.comparable#compareto(object)
*/
public int compareto( str2) {
return gb2312collator.compare(str1, str2);
}
}

测试代码及结果

代码：

import java.util.*;
import java.text.*;
public class test
{
[] test = new [] {
"作业" ,
"测试" ,
"test" ,
"我们" ,
"。空" ,
"镂空" ,
"[" ,
"浏" ,
"皙"
};
java.util. .sort(test, new chinesegb2312comparator());
.out.println("============" );
for ( key : test)
.out.println(key);
}

chinesegb2312comparator 类同时实现了 comparator, comparable 接口，这样以后能够使用 compare, compareto 方法的时候都可以使用这个类。

小菜毛毛 2010-12-17 13:22

]]>

struts1和struts2的区别和对比:

小菜毛毛 — tue, 14 dec 2010 13:55:00 gmt

action 类:
• struts1要求action类继承一个抽象基类。struts1的一个普遍问题是使用抽象类编程而不是接口。
• struts 2 action类可以实现一个action接口，也可实现其他接口，使可选和定制的服务成为可能。struts2提供一个actionsupport基类去实现常用的接口。action接口不是必须的，任何有execute标识的pojo对象都可以用作struts2的action对象。

线程模式:
• struts1 action是单例模式并且必须是线程安全的，因为仅有action的一个实例来处理所有的请求。单例策略限制了struts1 action能作的事，并且要在开发时特别小心。action资源必须是线程安全的或同步的。
• struts2 action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

servlet 依赖:
• struts1 action 依赖于servlet api ,因为当一个action被调用时httpservletrequest 和 httpservletresponse 被传递给execute方法。
• struts 2 action不依赖于容器，允许action脱离容器单独被测试。如果需要，struts2 action仍然可以访问初始的request和response。但是，其他的元素减少或者消除了直接访问httpservetrequest 和 httpservletresponse的必要性。

可测性:
• 测试struts1 action的一个主要问题是execute方法暴露了servlet api（这使得测试要依赖于容器）。一个第三方扩展－－struts testcase－－提供了一套struts1的模拟对象（来进行测试）。
• struts 2 action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
• struts1 使用actionform对象捕获输入。所有的actionform必须继承一个基类。因为其他javabean不能用作actionform，开发者经常创建多余的类捕获输入。动态bean（dynabeans）可以作为创建传统actionform的选择，但是，开发者可能是在重新描述(创建)已经存在的javabean（仍然会导致有冗余的javabean）。
• struts 2直接使用action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的rich对象类型。action属性能够通过 web页面上的taglibs访问。struts2也支持actionform模式。rich对象类型，包括业务对象，能够用作输入/输出对象。这种 modeldriven 特性简化了taglib对pojo输入对象的引用。

表达式语言：
• struts1 整合了jstl，因此使用jstl el。这种el有基本对象图遍历，但是对集合和索引属性的支持很弱。
• struts2可以使用jstl，但是也支持一个更强大和灵活的表达式语言－－"object graph notation language" (ognl).

绑定值到页面（view）:
• struts 1使用标准jsp机制把对象绑定到页面中来访问。
• struts 2 使用 "valuestack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。valuestack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。

类型转换：
• struts 1 actionform 属性通常都是string类型。struts1使用commons-beanutils进行类型转换。每个类一个转换器，对每一个实例来说是不可配置的。
• struts2 使用ognl进行类型转换。提供基本和常用对象的转换器。

校验：
• struts 1支持在actionform的validate方法中手动校验，或者通过commons validator的扩展来校验。同一个类可以有不同的校验内容，但不能校验子对象。
• struts2支持通过validate方法和xwork校验框架来进行校验。xwork校验框架使用为属性类类型定义的校验和内容校验，来支持chain校验子属性

action执行的控制：
• struts1支持每一个模块有单独的request processors（生命周期），但是模块中的所有action必须共享相同的生命周期。
• struts2支持通过拦截器堆栈（interceptor stacks）为每一个action创建不同的生命周期。堆栈能够根据需要和不同的action一起使用。

小菜毛毛 2010-12-14 21:55

]]>

android中添加admob广告（转

小菜毛毛 — fri, 10 dec 2010 09:42:00 gmt

花了整整一天时间，研究怎么通过在android应用程序中添加admob广告来赚钱。网上也有些教程，不过说得不够详细，自己还得花时间摸索。为了让后来者能更快开始admob广告赚钱，所以写个详细一点的教程，供大家参考。

例子工程源码下载地址：(建议使用浏览器自带的下载工具下载)
当然，我也参考了一些网上的资料，主要有：

admob：在android应用中嵌入广告的方案
如何在android market赚钱 part 2 - 免费app附带广告
publisher starter kit
面向开发者 wiki 的 admob

好了，现在让我从头开始说起……在这之前，你不需要有任何的帐号，唯一需要的就是有一个有效的email邮箱。只要按照下面的步骤一步步来，你就能通过将admob的广告插到自己的程序中赚钱啦！

首先，当然是需要注册一个admob的帐号。admob的凯发k8网页登录主页是：。当然，如果你对于浏览英文网页还有些障碍的话，可以登录中文网站：。如果网站的文字还是英文，你可以在网站凯发k8网页登录主页的右下角的“language”处，选择“中文（简体）”。点击进入注册页面后，有一些栏目需要填写，不要太过疑虑，就像你注册一个论坛一样，随便填下就好了。最关键的是保证填写的email地址有效，另外就是填上姓名，选择语言。帐户类型我选择的“不确定”，语言“中文（简体）”～提交注册申请之后，不久你就会收到用于确认并激活帐号的电子邮件，点击激活链接，就可以了激活你的admob帐号了～

第二步就是设置你的android应用程序信息，并获得admob的插入代码。登录你的admob帐号后，在凯发k8网页登录主页的左上方（logo上面）点击“marketplace（手机广告市场）”，进入页面后，在“sites&apps（站点和应用程序）”标签下，点击“add site/app”。选择我们熟悉的图标——" android app ” 。这时会出现需要你填写一个“详细信息”，随便填上一些信息。（不要太过在意现在填写的东西，因为这些以后都是可以修改的）。比如“android package url” 我到现在都还没有填写，描述之类的，想写就写点吧。填好详细信息后，点击“继续”，就可以到admob android sdk 的下载页面了。下载这个sdk（当然，这个很重要）。

the admob android sdk includes:

readme: get started with admob android ads!
admob jar file: required for publishing ads. follow the documentation in javadoc/index.html and drop the admob jar file into your project.
sample projects: examples of admob android ads shown in the lunarlander application.

第三步获取你的应用程序对应的publisher id。在下载页面点击"go to sites/apps"就可以到你应用程序的管理界面了。这时你会发现在这个页面醒目的位置会有一个叫你填写详细信息的提示：

在我们发送任何有待收入之前，您需要填写技术联系详细信息和付款首选项。

我们暂时可以不用管它，因为钱是会存在我们的admob的账户上的，等我们需要提现的时候，或者你想填的时候再填就可以了。在下面的列表中，选择你的应用程序并进入。这个界面就是你的应用程序广告的管理界面了，里面有比较多的功能，以后可以慢慢了解，现在我们只需要知道两个东西，一个是发布者 id（publisher id），一个是你程序的状态。publisher id是一个15个字符的字符串，而你程序的状态现在应该还是不活动（inactive）。我们下面要做的就是怎么让它变为active。

第四步代码编写——在你的应用程序中插入admob广告。经过上面的步骤，我们在网站上的设置就告一个段落了，现在我们终于要进入主题了，如何在自己的android应用程序中插入admob广告。如果你不健忘的话，一定还记得我们之前下载的那个admob android sdk 。解压它，看看里面有些什么东西。这里面最重要的就是那个名为“admob-sdk-android.jar”的包啦，admob将如何把广告加载到android应用程序中的代码集成在这个包里，我们编写程序的时候就需要将这个包导入到我们的工程里面去。另外，解压出来的文件夹中还有一个名为“javadoc”的文件夹，打开它里面的index.html。它是关于admob android sdk的帮助文档，在package 下的setup下，有详细完整的在自己的应用程序中插入广告的方法介绍，在这里我就偷懒，引用一下～

including the jar
add the jar file included with the sdk to your android project as an external library. in your project's root directory create a subdirectory libs (this will already be done for you if you used android's activitycreator). copy the admob jar file into that directory. for eclipse projects:

go to the properties of your project (right-click on your project from the package explorer tab and select properties)
select "java build path" from left panel
select "libraries" tab from the main window
click on "add jars..."
select the jar copied to the libs directory
click "ok" to add the sdk to your android project

注意：需要首先在你工程的根目录下新建一个叫做“libs”的文件夹，并把之前所说的最重要的东西“admob-sdk-android.jar”复制到里面。

androidmanifest.xml

your admob publisher id was given to you when creating your publisher account on before downloading this code. it is a 15-character code like a1496ced2842262. just before the closing tag add a line to set your publisher id:

区分activity的四种加载模式

小菜毛毛 — fri, 10 dec 2010 02:38:00 gmt

在多activity开发中，有可能是自己应用之间的activity跳转，或者夹带其他应用的可复用activity。可能会希望跳转到原来某个activity实例，而不是产生大量重复的activity。

这需要为activity配置特定的加载模式，而不是使用默认的加载模式。

加载模式分类及在哪里配置

activity有四种加载模式：

standard
singletop
singletask
singleinstance

设置的位置在androidmanifest.xml文件中activity元素的android:launchmode属性：

android:launchmode="singletask">

也可以在eclipse adt中图形界面中编辑：

区分activity的加载模式，通过示例一目了然。这里编写了一个activity a（acta）和activity b（actb）循环跳转的例子。对加载模式修改和代码做稍微改动，就可以说明四种模式的区别。

standard

首先说standard模式，也就是默认模式，不需要配置launchmode。先只写一个名为acta的activity：

package com.easymorse.activities;

import android.app.activity;
import android.content.intent;
import android.os.bundle;
import android.view.view;
import android.view.view.onclicklistener;
import android.widget.button;
import android.widget.linearlayout;
import android.widget.textview;

public class acta extends activity {
    /** called when the activity is first created. */
    @override
    public void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        textview textview = new textview(this);
        textview.settext(this "");
        button button = new button(this);
        button.settext("go acta");
        button.setonclicklistener(new onclicklistener() {
            @override
            public void onclick(view v) {
                intent intent = new intent();
                intent.setclass(acta.this, acta.class);
                startactivity(intent);
            }
        });
        linearlayout layout = new linearlayout(this);
        layout.setorientation(linearlayout.vertical);
        layout.addview(textview);
        layout.addview(button);
        this.setcontentview(layout);
    }
}

例子中都没有用layout，免得看着罗嗦。可见是acta –> acta的例子。在界面中打印出对象的tostring值可以根据hash code识别是否创建新acta实例。

第一个界面：

点击按钮后：

可以多点几次。发现每次都创建了该activity的新实例。standard的加载模式就是这样的，intent将发送给新的实例。

现在点android设备的回退键，可以看到是按照刚才创建activity实例的倒序依次出现，类似退栈的操作，而刚才操作跳转按钮的过程是压栈的操作。如下图：

singletop

singletop和standard模式，都会将intent发送新的实例（后两种模式不发送到新的实例，如果已经有了的话）。不过，singletop要求如果创建intent的时候栈顶已经有要创建的activity的实例，则将intent发送给该实例，而不发送给新的实例。

还是用刚才的示例，只需将launchmode改为singletop，就能看到区别。

运行的时候会发现，按多少遍按钮，都是相同的actia实例，因为该实例在栈顶，因此不会创建新的实例。如果回退，将退出应用。

singletop模式，可用来解决栈顶多个重复相同的activity的问题。

如果是a activity跳转到b activity，再跳转到a activity，行为就和standard一样了，会在b activity跳转到a activity的时候创建a activity的新实例，因为当时的栈顶不是a activity实例。

acta类稍作改动：

package com.easymorse.activities;

import android.app.activity;
import android.content.intent;
import android.os.bundle;
import android.view.view;
import android.view.view.onclicklistener;
import android.widget.button;
import android.widget.linearlayout;
import android.widget.textview;

public class acta extends activity {
    /** called when the activity is first created. */
    @override
    public void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        textview textview = new textview(this);
        textview.settext(this "");
        button button = new button(this);
        button.settext("go actb");
        button.setonclicklistener(new onclicklistener() {
            @override
            public void onclick(view v) {
                intent intent = new intent();
                intent.setclass(acta.this, actb.class);
                startactivity(intent);
            }
        });
        linearlayout layout = new linearlayout(this);
        layout.setorientation(linearlayout.vertical);
        layout.addview(textview);
        layout.addview(button);
        this.setcontentview(layout);
    }
}

actb类：

package com.easymorse.activities;

import android.app.activity;
import android.content.intent;
import android.os.bundle;
import android.view.view;
import android.view.view.onclicklistener;
import android.widget.button;
import android.widget.linearlayout;

public class actb extends activity {
    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
         button button=new button(this);
            button.settext("go acta");
            button.setonclicklistener(new onclicklistener() {
                @override
                public void onclick(view v) {
                    intent intent=new intent();
                    intent.setclass(actb.this, acta.class);
                    startactivity(intent);
                }
            });
            linearlayout layout=new linearlayout(this);
            layout.addview(button);
            this.setcontentview(layout);
    }
}

actb类使用默认（standard）加载，acta使用singletop加载。结果类似下图：

如果把acta的加载模式改为standard，情况一样。

singletask

singletask模式和后面的singleinstance模式都是只创建一个实例的。

当intent到来，需要创建singletask模式activity的时候，系统会检查栈里面是否已经有该activity的实例。如果有直接将intent发送给它。

把上面singletop的实例中的acta的launchmode改为singletask，actb的改为standard。那么会发现在acta界面中按一次按钮：

然后在actb1界面中按按钮，因为acta是singletask，会使用原来的acta1实例。这时候栈内的情况:

如果多次按按钮跳转，会发现始终只有acta1这一个acta类的实例。

singleinstance

解释singleinstance模式比较麻烦。

首先要说一下task（任务）的概念。

如果是swing或者windows程序，可能有多个窗口可以切换，但是你无法在自己程序中复用人家的窗口。注意是直接复用人家的二进制代码，不是你拿到人家api后的源代码级调用。

android可以做到，让别人的程序直接复用你的activity（类似桌面程序的窗口）。

android为提供这种机制，就引入了task的概念。task可以认为是一个栈，可放入多个activity。比如启动一个应用，那么 android就创建了一个task，然后启动这个应用的入口activity，就是intent-filter中配置为main和launch的那个（见）。这个activity是根（root）activity，可能会在它的界面调用其他activity，这些activity如果按照上面那三个模式，也会在这个栈（task）中，只是实例化的策略不同而已。

验证的办法是调用和打印activity的taskid：

textview textview2 = new textview(this);
textview2.settext("task id: " this.gettaskid());

会发现，无论切换activity，taskid是相同的。

当然也可以在这个单一的task栈中，放入别人的activity，比如google地图，这样用户看过地图按回退键的时候，会退栈回到调用地图的activity。对用户来说，并不觉得在操作多个应用。这就是task的作用。

但是，有这样的需求，多个task共享一个activity（singletask是在一个task中共享一个activity）。

现成的例子是google地图。比如我有一个应用是导游方面的，其中调用的google地图activity。那么现在我比如按home键，然后到应用列表中打开google地图，你会发现显示的就是刚才的地图，实际上是同一个activity。

如果使用上面三种模式，是无法实现这个需求的。google地图应用中有多个上下文activity，比如路线查询等的，导游应用也有一些上下文activity。在各自应用中回退要回退到各自的上下文activity中。

singleinstance模式解决了这个问题（绕了这么半天才说到正题）。让这个模式下的activity单独在一个task栈中。这个栈只有一个activity。导游应用和google地图应用发送的intent都由这个activity接收和展示。

这里又有两个问题：

如果是这种情况，多个task栈也可以看作一个应用。比如导游应用启动地图activity，实际上是在导游应用task栈之上 singleinstance模式创建的（如果还没有的话，如果有就是直接显示它）一个新栈，当这个栈里面的唯一activity，地图activity 回退的时候，只是把这个栈移开了，这样就看到导游应用刚才的activity了；
多个应用（task）共享一个activity要求这些应用都没有退出，比如刚才强调要用home键从导游应用切换到地图应用。因为，如果退出导游应用，而这时也地图应用并未运行的话，那个单独的地图activity（task）也会退出了。

如果还是拿刚才的acta和actb的示例，可以把actb的模式改为singleinstance，acta为standard，如果按一次按钮切换到actb，看到现象用示意图类似这样：

如果是第一次按钮切换到actb，在actb在按按钮切换到acta，然后再回退，示意图是：

另外，可以看到两个activity的taskid是不同的。

小菜毛毛 2010-12-10 10:38

]]>

blogjava-凯发k8网页登录

java sax 解析 实例

spring 框架的设计理念与设计模式分析

java反射详解

java对象序列化（整理篇）

android获取contact number的例子（2.0系统以前的获取方式）

android 2.2 获取联系人，电话，并拨号

java中文汉字排序

示例文本：

jdk 版本：

开发平台：

关键字： 中文排序

概述

java.text. 接口及其实现类

问题分析：

凯发天生赢家一触即发官网的解决方案：

参考代码

测试代码及结果

struts1和struts2的区别和对比:

android中添加admob广告（转

区分activity的四种加载模式

加载模式分类及在哪里配置

standard

singletop

singletask

singleinstance

java sax 解析实例

关键字：中文排序

java.text.

接口及其实现类