1一152期六合图库资料

小菜毛毛技術分享

與大家共同成長

  BlogJava :: 首頁 :: 聯系 :: 聚合  :: 管理
  164 Posts :: 141 Stories :: 94 Comments :: 0 Trackbacks

2011年5月11日 #

 
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<String> tagName;

  private Vector<String> tagValue;

  private int step;

  // 開始解析XML文件
  public void startDocument() throws SAXException
  {
    tagName = new Vector<String>();
    tagValue = new Vector<String>();
    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是什么? <name:page ll=""></name:page>這樣寫就會拋出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>5128</tel>
    <email>txq512@sina.com</email>
  </person>
    
  <person personid="e02" enable="false">
    <name>meixin</name>
    <tel>5252525</tel>
    <email>wnight88@sina.com</email>
  </person>
    
  <person personid="e03" enable="true">
    <name>yu</name>
    <tel>5389654</tel>
    <email>yu@188.net</email>
  </person>
    
</people>

http://wnight88.blog.51cto.com/512204/163197/
posted @ 2011-05-11 22:34 小菜毛毛 閱讀(2797) | 評論 (0)編輯 收藏

2011年2月15日 #

簡介: Spring 作為現在最優秀的框架之一,已被廣泛的使用,并且有很多對其分析的文章。本文將從另外一個視角試圖剖析出 Spring 框架的作者設計 Spring 框架的骨骼架構的設計理念,有那幾個核心組件?為什么需要這些組件?它們又是如何結合在一起構成 Spring 的骨骼架構? Spring 的 AOP 特性又是如何利用這些基礎的骨骼架構來工作的? Spring 中又使用了那些設計模式來完成它的這種設計的?它的這種設計理念對對我們以后的軟件設計有何啟示?本文將詳細解答這些問題。

Spring 的骨骼架構

Spring 總共有十幾個組件,但是真正核心的組件只有幾個,下面是 Spring 框架的總體架構圖:


圖 1 .Spring 框架的總體架構圖
圖 1 .Spring 框架的總體架構圖

從上圖中可以看出 Spring 框架中的核心組件只有三個:Core、Context 和 Beans。它們構建起了整個 Spring 的骨骼架構。沒有它們就不可能有 AOP、Web 等上層的特性功能。下面也將主要從這三個組件入手分析 Spring。

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 更能讓你理解。

它們之間可以用下圖來表示:


圖 2. 三個組件關系
圖 2. 三個組件關系

核心組件詳解

這里將詳細介紹每個組件內部類的層次關系,以及它們在運行時的時序順序。我們在使用 Spring 是應該注意的地方。

Bean 組件

前面已經說明了 Bean 組件對 Spring 的重要性,下面看看 Bean 這個組件式怎么設計的。Bean 組件在 Spring 的 org.springframework.beans 包下。這個包下的所有類主要解決了三件事:Bean 的定義、Bean 的創建以及對 Bean 的解析。對 Spring 的使用者來說唯一需要關心的就是 Bean 的創建,其他兩個由 Spring 在內部幫你完成了,對你來說是透明的。

Spring Bean 的創建時典型的工廠模式,他的頂級接口是 BeanFactory,下圖是這個工廠的繼承層次關系:


圖 4. Bean 工廠的繼承關系
圖 4. Bean 工廠的繼承關系

BeanFactory 有三個子類:ListableBeanFactory、HierarchicalBeanFactory 和 AutowireCapableBeanFactory。但是從上圖中我們可以發現最終的默認實現類是 DefaultListableBeanFactory,他實現了所有的接口。那為何要定義這么多層次的接口呢?查閱這些接口的源碼和說明發現,每個接口 都有他使用的場合,它主要是為了區分在 Spring 內部在操作過程中對象的傳遞和轉化過程中,對對象的數據訪問所做的限制。例如 ListableBeanFactory 接口表示這些 Bean 是可列表的,而 HierarchicalBeanFactory 表示的是這些 Bean 是有繼承關系的,也就是每個 Bean 有可能有父 Bean。AutowireCapableBeanFactory 接口定義 Bean 的自動裝配規則。這四個接口共同定義了 Bean 的集合、Bean 之間的關系、以及 Bean 行為。

Bean 的定義主要有 BeanDefinition 描述,如下圖說明了這些類的層次關系:


圖 5. Bean 定義的類層次關系圖
圖 5. Bean 定義的類層次關系圖

Bean 的定義就是完整的描述了在 Spring 的配置文件中你定義的 <bean/> 節點中所有的信息,包括各種子節點。當 Spring 成功解析你定義的一個 <bean/> 節點后,在 Spring 的內部他就被轉化成 BeanDefinition 對象。以后所有的操作都是對這個對象完成的。

Bean 的解析過程非常復雜,功能被分的很細,因為這里需要被擴展的地方很多,必須保證有足夠的靈活性,以應對可能的變化。Bean 的解析主要就是對 Spring 配置文件的解析。這個解析過程主要通過下圖中的類完成:


圖 6. Bean 的解析類
圖 6. Bean 的解析類

當然還有具體對 tag 的解析這里并沒有列出。

Context 組件

Context 在 Spring 的 org.springframework.context 包下,前面已經講解了 Context 組件在 Spring 中的作用,他實際上就是給 Spring 提供一個運行時的環境,用以保存各個對象的狀態。下面看一下這個環境是如何構建的。

ApplicationContext 是 Context 的頂級父類,他除了能標識一個應用環境的基本信息外,他還繼承了五個接口,這五個接口主要是擴展了 Context 的功能。下面是 Context 的類結構圖:


圖 7. Context 相關的類結構圖
圖 7. Context 相關的類結構圖

(查看 圖 7 的清晰版本。)

從上圖中可以看出 ApplicationContext 繼承了 BeanFactory,這也說明了 Spring 容器中運行的主體對象是 Bean,另外 ApplicationContext 繼承了 ResourceLoader 接口,使得 ApplicationContext 可以訪問到任何外部資源,這將在 Core 中詳細說明。

ApplicationContext 的子類主要包含兩個方面:

  1. ConfigurableApplicationContext 表示該 Context 是可修改的,也就是在構建 Context 中用戶可以動態添加或修改已有的配置信息,它下面又有多個子類,其中最經常使用的是可更新的 Context,即 AbstractRefreshableApplicationContext 類。
  2. WebApplicationContext 顧名思義,就是為 web 準備的 Context 他可以直接訪問到 ServletContext,通常情況下,這個接口使用的少。

再往下分就是按照構建 Context 的文件類型,接著就是訪問 Context 的方式。這樣一級一級構成了完整的 Context 等級層次。

總體來說 ApplicationContext 必須要完成以下幾件事:

  • 標識一個應用環境
  • 利用 BeanFactory 創建 Bean 對象
  • 保存對象關系表
  • 能夠捕獲各種事件

Context 作為 Spring 的 Ioc 容器,基本上整合了 Spring 的大部分功能,或者說是大部分功能的基礎。

Core 組件

Core 組件作為 Spring 的核心組件,他其中包含了很多的關鍵類,其中一個重要組成部分就是定義了資源的訪問方式。這種把所有資源都抽象成一個接口的方式很值得在以后的設計中拿來學習。下面就重要看一下這個部分在 Spring 的作用。

下圖是 Resource 相關的類結構圖:


圖 8. Resource 相關的類結構圖
圖 8. Resource 相關的類結構圖

(查看 圖 8 的清晰版本。)

從上圖可以看出 Resource 接口封裝了各種可能的資源類型,也就是對使用者來說屏蔽了文件類型的不同。對資源的提供者來說,如何把資源包裝起來交給其他人用這也是一個問題,我們看到 Resource 接口繼承了 InputStreamSource 接口,這個接口中有個 getInputStream 方法,返回的是 InputStream 類。這樣所有的資源都被可以通過 InputStream 這個類來獲取,所以也屏蔽了資源的提供者。另外還有一個問題就是加載資源的問題,也就是資源的加載者要統一,從上圖中可以看出這個任務是由 ResourceLoader 接口完成,他屏蔽了所有的資源加載者的差異,只需要實現這個接口就可以加載所有的資源,他的默認實現是 DefaultResourceLoader。

下面看一下 Context 和 Resource 是如何建立關系的?首先看一下他們的類關系圖:


圖 9. Context 和 Resource 的類關系圖
圖 9. Context 和 Resource 的類關系圖

從上圖可以看出,Context 是把資源的加載、解析和描述工作委托給了 ResourcePatternResolver 類來完成,他相當于一個接頭人,他把資源的加載、解析和資源的定義整合在一起便于其他組件使用。Core 組件中還有很多類似的方式。

Ioc 容器如何工作

前面介紹了 Core 組件、Bean 組件和 Context 組件的結構與相互關系,下面這里從使用者角度看一下他們是如何運行的,以及我們如何讓 Spring 完成各種功能,Spring 到底能有那些功能,這些功能是如何得來的,下面介紹。

如何創建 BeanFactory 工廠

正如圖 2 描述的那樣,Ioc 容器實際上就是 Context 組件結合其他兩個組件共同構建了一個 Bean 關系網,如何構建這個關系網?構建的入口就在 AbstractApplicationContext 類的 refresh 方法中。這個方法的代碼如下:


清單 1. 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 的方法代碼:


清單 2. AbstractRefreshableApplicationContext. refreshBeanFactory
                        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,這個非常關鍵,因為他設計到后面對這個對象的多種操作,下面看一下這個類的繼承層次類圖:


圖 10. DefaultListableBeanFactory 類繼承關系圖
圖 10. DefaultListableBeanFactory 類繼承關系圖

(查看 圖 10 的清晰版本。)

從這個圖中發現除了 BeanFactory 相關的類外,還發現了與 Bean 的 register 相關。這在 refreshBeanFactory 方法中有一行 loadBeanDefinitions(beanFactory) 將找到答案,這個方法將開始加載、解析 Bean 的定義,也就是把用戶定義的數據結構轉化為 Ioc 容器中的特定數據結構。

這個過程可以用下面時序圖解釋:


圖 11. 創建 BeanFactory 時序圖
圖 11. 創建 BeanFactory 時序圖

(查看 圖 11 的清晰版本。)

Bean 的解析和登記流程時序圖如下:


圖 12. 解析和登記 Bean 對象時序圖
圖 12. 解析和登記 Bean 對象時序圖

(查看 圖 12 的清晰版本。)

創建好 BeanFactory 后,接下去添加一些 Spring 本身需要的一些工具類,這個操作在 AbstractApplicationContext 的 prepareBeanFactory 方法完成。

AbstractApplicationContext 中接下來的三行代碼對 Spring 的功能擴展性起了至關重要的作用。前兩行主要是讓你現在可以對已經構建的 BeanFactory 的配置做修改,后面一行就是讓你可以對以后再創建 Bean 的實例對象時添加一些自定義的操作。所以他們都是擴展了 Spring 的功能,所以我們要學習使用 Spring 必須對這一部分搞清楚。

其中在 invokeBeanFactoryPostProcessors 方法中主要是獲取實現 BeanFactoryPostProcessor 接口的子類。并執行它的 postProcessBeanFactory 方法,這個方法的聲明如下:


清單 3. 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 方法開始的。


清單 4. AbstractApplicationContext.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 方法的代碼如下:


清單 5. DefaultListableBeanFactory.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<Boolean>() {
                        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 中的一個核心關鍵,下面是這個過程的流程圖。


圖 13.Bean 實例創建流程圖
圖 13.Bean 實例創建流程圖

(查看 圖 13 的清晰版本。)

如果是普通的 Bean 就直接創建他的實例,是通過調用 getBean 方法。下面是創建 Bean 實例的時序圖:


圖 14.Bean 實例創建時序圖
圖 14.Bean 實例創建時序圖

(查看 圖 14 的清晰版本。)

還有一個非常重要的部分就是建立 Bean 對象實例之間的關系,這也是 Spring 框架的核心競爭力,何時、如何建立他們之間的關系請看下面的時序圖:


圖 15.Bean 對象關系建立
圖 15.Bean 對象關系建立

(查看 圖 15 的清晰版本。)

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 特性詳解

動態代理的實現原理

要了解 Spring 的 AOP 就必須先了解的動態代理的原理,因為 AOP 就是基于動態代理實現的。動態代理還要從 JDK 本身說起。

在 Jdk 的 java.lang.reflect 包下有個 Proxy 類,它正是構造代理類的入口。這個類的結構入下:


圖 16. Proxy 類結構
圖 16. Proxy 類結構

從上圖發現最后面四個是公有方法。而最后一個方法 newProxyInstance 就是創建代理對象的方法。這個方法的源碼如下:


清單 6. 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 如何產生代理類的過程,他構造出來的代理類到底是什么樣子?下面揭曉啦。


圖 17. 創建代理對象時序圖
圖 17. 創建代理對象時序圖

其實從上圖中可以發現正在構造代理類的是在 ProxyGenerator 的 generateProxyClass 的方法中。ProxyGenerator 類在 sun.misc 包下,感興趣的話可以看看他的源碼。

假如有這樣一個接口,如下:


清單 7. SimpleProxy 類
                        public interface SimpleProxy {
                        public void simpleMethod1();
                        public void simpleMethod2();
                        }
                        

代理來生成的類結構如下:


清單 8. $Proxy2 類
                        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 參數。整個代理就是這樣實現的。

Spring AOP 如何實現

從前面代理的原理我們知道,代理的目的是調用目標方法時我們可以轉而執行 InvocationHandler 類的 invoke 方法,所以如何在 InvocationHandler 上做文章就是 Spring 實現 Aop 的關鍵所在。

Spring 的 Aop 實現是遵守 Aop 聯盟的約定。同時 Spring 又擴展了它,增加了如 Pointcut、Advisor 等一些接口使得更加靈活。

下面是 Jdk 動態代理的類圖:


圖 18. Jdk 動態代理的類圖
圖 18. Jdk 動態代理的類圖

上圖清楚的顯示了 Spring 引用了 Aop Alliance 定義的接口。姑且不討論 Spring 如何擴展 Aop Alliance,先看看 Spring 如何實現代理類的,要實現代理類在 Spring 的配置文件中通常是這樣定一個 Bean 的,如下:


清單 9. 配置代理類 Bean
                        <bean id="testBeanSingleton"
                        class="org.springframework.aop.framework.ProxyFactoryBean">
                        <property name="proxyInterfaces">
                        <value>
                        org.springframework.aop.framework.PrototypeTargetTests$TestBean
                        </value>
                        </property>
                        <property name="target"><ref local="testBeanTarget"></ref> </property>
                        <property name="singleton"><value>true</value></property>
                        <property name="interceptorNames">
                        <list>
                        <value>testInterceptor</value>
                        <value>testInterceptor2</value>
                        </list>
                        </property>
                        </bean>
                        

配置上看到要設置被代理的接口,和接口的實現類也就是目標類,以及攔截器也就在執行目標方法之前被調用,這里 Spring 中定義的各種各樣的攔截器,可以選擇使用。

下面看看 Spring 如何完成了代理以及是如何調用攔截器的。

前面提到 Spring Aop 也是實現其自身的擴展點來完成這個特性的,從這個代理類可以看出它正是繼承了 FactoryBean 的 ProxyFactoryBean,FactoryBean 之所以特別就在它可以讓你自定義對象的創建方法。當然代理對象要通過 Proxy 類來動態生成。

下面是 Spring 創建的代理對象的時序圖:


圖 19.Spring 代理對象的產生
圖 19.Spring 代理對象的產生

Spring 創建了代理對象后,當你調用目標對象上的方法時,將都會被代理到 InvocationHandler 類的 invoke 方法中執行,這在前面已經解釋。在這里 JdkDynamicAopProxy 類實現了 InvocationHandler 接口。

下面再看看 Spring 是如何調用攔截器的,下面是這個過程的時序圖:


圖 20.Spring 調用攔截器
圖 20.Spring 調用攔截器

以上所說的都是 Jdk 動態代理,Spring 還支持一種 CGLIB 類代理,感興趣自己看吧。


Spring 中設計模式分析

Spring 中使用的設計模式也很多,比如工廠模式、單例模式、模版模式等,在《 Webx 框架的系統架構與設計模式》、《 Tomcat 的系統架構與模式設計分析》已經有介紹,這里就不贅述了。這里主要介紹代理模式和策略模式。

代理模式

代理模式原理

代理模式就是給某一個對象創建一個代理對象,而由這個代理對象控制對原對象的引用,而創建這個代理對象就是可以在調用原對象是可以增加一些額外的操作。下面是代理模式的結構:


圖 21. 代理模式的結構
圖 21. 代理模式的結構
  • Subject:抽象主題,它是代理對象的真實對象要實現的接口,當然這可以是多個接口組成。
  • ProxySubject:代理類除了實現抽象主題定義的接口外,還必須持有所代理對象的引用
  • RealSubject:被代理的類,是目標對象。

Spring 中如何實現代理模式

Spring Aop 中 Jdk 動態代理就是利用代理模式技術實現的。在 Spring 中除了實現被代理對象的接口外,還會有 org.springframework.aop.SpringProxy 和 org.springframework.aop.framework.Advised 兩個接口。Spring 中使用代理模式的結構圖如下:


圖 22. Spring 中使用代理模式的結構圖
圖 22. Spring 中使用代理模式的結構圖

$Proxy 就是創建的代理對象,而 Subject 是抽象主題,代理對象是通過 InvocationHandler 來持有對目標對象的引用的。

Spring 中一個真實的代理對象結構如下:


清單 10 代理對象 $Proxy4
                        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();
                        }
                        

策略模式

策略模式原理

策略模式顧名思義就是做某事的策略,這在編程上通常是指完成某個操作可能有多種方法,這些方法各有千秋,可能有不同的適應的場合,然而這些操作方法都有可能用到。各一個操作方法都當作一個實現策略,使用者可能根據需要選擇合適的策略。

下面是策略模式的結構:


圖 23. 策略模式的結構
圖 23. 策略模式的結構
  • Context:使用不同策略的環境,它可以根據自身的條件選擇不同的策略實現類來完成所要的操作。它持有一個策略實例的引用。創建具體策略對象的方法也可以由他完成。
  • Strategy:抽象策略,定義每個策略都要實現的策略方法
  • ConcreteStrategy:具體策略實現類,實現抽象策略中定義的策略方法

Spring 中策略模式的實現

Spring 中策略模式使用有多個地方,如 Bean 定義對象的創建以及代理對象的創建等。這里主要看一下代理對象創建的策略模式的實現。

前面已經了解 Spring 的代理方式有兩個 Jdk 動態代理和 CGLIB 代理。這兩個代理方式的使用正是使用了策略模式。它的結構圖如下所示:


圖 24. Spring 中策略模式結構圖
圖 24. Spring 中策略模式結構圖

在上面結構圖中與標準的策略模式結構稍微有點不同,這里抽象策略是 AopProxy 接口,Cglib2AopProxy 和 JdkDynamicAopProxy 分別代表兩種策略的實現方式,ProxyFactoryBean 就是代表 Context 角色,它根據條件選擇使用 Jdk 代理方式還是 CGLIB 方式,而另外三個類主要是來負責創建具體策略對象,ProxyFactoryBean 是通過依賴的方法來關聯具體策略對象的,它是通過調用策略對象的 getProxy(ClassLoader classLoader) 方法來完成操作。


總結

本文通過從 Spring 的幾個核心組件入手,試圖找出構建 Spring 框架的骨骼架構,進而分析 Spring 在設計的一些設計理念,是否從中找出一些好的設計思想,對我們以后程序設計能提供一些思路。接著再詳細分析了 Spring 中是如何實現這些理念的,以及在設計模式上是如何使用的。

通過分析 Spring 給我一個很大的啟示就是其這套設計理念其實對我們有很強的借鑒意義,它通過抽象復雜多變的對象,進一步做規范,然后根據它定義的這套規范設計出一個容器,容器中構建它們的復雜關系,其實現在有很多情況都可以用這種類似的處理方法。

雖然我很想把我對 Spring 的想法完全闡述清楚,但是所謂“書不盡言,言不盡意。”,有什么不對或者不清楚的地方大家還是看看其源碼吧。

 原文地址 http://www.ibm.com/developerworks/cn/java/j-lo-spring-principle/index.html
posted @ 2011-02-15 16:13 小菜毛毛 閱讀(1288) | 評論 (0)編輯 收藏

2011年1月13日 #

     摘要: Java的反射機制是Java特性之一,反射機制是構建框架技術的基礎所在。靈活掌握Java反射機制,對大家以后學習框架技術有很大的幫助。     那么什么是Java的反射呢?        大家都知道,要讓Java程序能夠運行,那么就得讓Java類要被Java虛擬機加載。Java類如果不被Java虛擬機加載,是不...  閱讀全文
posted @ 2011-01-13 17:09 小菜毛毛 閱讀(2667) | 評論 (0)編輯 收藏

 在網上看了很多有關序列化的文 章,我自己也寫了兩篇,現在感覺這些文章都沒有很好的把序列化說清楚(包括我自己在內),所以在此我將總結前人以及自己的經驗,用更淺顯易懂的語言來描述 該機制,當然,仍然會有不好的地方,希望你看后可以指出,作為一名程序員應該具有不斷探索的精神和強烈的求知欲望!

序列化概述:

      簡單來說序列化就是一種用來處理對象流的機制,所謂對象流也就是將對象的內容進行流化,流的概念這里不用多說(就是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;
}
 

 


posted @ 2011-01-13 13:29 小菜毛毛 閱讀(499) | 評論 (0)編輯 收藏

2010年12月17日 #

  1. String[] projection = new String[] {  
  2. People._ID,  
  3. People.NAME,  
  4. People.NUMBER,  
  5. };  
  6.   
  7. // Get the base URI for People table in Contacts content provider.  
  8. // which is: content://contacts/people/  
  9. Uri contactUri = People.CONTENT_URI;  
  10.   
  11. // Best way to retrieve a query; returns a managed query.  
  12. Cursor peopleCursor = managedQuery (contactUri,  
  13. projection, //Which columns to return.  
  14. null, // WHERE clause--we won't specify.  
  15. null, // Selection Args??  
  16. People.DEFAULT_SORT_ORDER); // Order-by name  
  17.   
  18. // go to the beginning of the list  
  19. peopleCursor.moveToFirst();  
  20.   
  21.   
  22. // So, here we have a contact. We need to get the contact ID (_id) then  
  23. // build the Uri to get the phones section of that user's record  
  24. // which is a subdirectory of a contact record  
  25.   
  26. long personId = peopleCursor.getLong(peopleCursor.getColumnIndex("_id"));  
  27.   
  28. Uri personUri = ContentUris.withAppendedId(contactUri, personId );  
  29.   
  30. // So now the URL looks like: content://contacts/people/_id(where the actual id of the record is here)  
  31. Uri phoneUri=  
  32. Uri.withAppendedPath(personUri, Contacts.People.Phones.CONTENT_DIRECTORY);  
  33.   
  34. // Now the URL looks like: content://contacts/people/_id/phones (where phones is literally "phones")  
  35.   
  36. // Now get all the phone numbers for this contact  
  37. Cursor phonesCursor = managedQuery(phoneUri,  
  38. null,  
  39. null,  
  40. null,  
  41. Phones.DEFAULT_SORT_ORDER);  
  42.   
  43. // We now have a cursor for all the phone numbers for that User ID  
  44. // go to the beginning of the phone list.  
  45. phonesCursor.moveToFirst();   
posted @ 2010-12-17 17:45 小菜毛毛 閱讀(855) | 評論 (0)編輯 收藏

原創  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<HashMap<String, Object>> listItem = new ArrayList<HashMap<String, Object>>();        
        ArrayList<HashMap<String, Object>> listItemRead = new ArrayList<HashMap<String, Object>>();     
        Cursor cursor = getContentResolver().query(ContactsContract.Contacts.CONTENT_URI,null, null, null, null);      
        while (cursor.moveToNext())    
        {     
         HashMap<String, Object> map = new HashMap<String, Object>();
         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();   
    }   

posted @ 2010-12-17 16:58 小菜毛毛 閱讀(1569) | 評論 (0)編輯 收藏

// 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]);

 

 

<script>
 names = ["張三", "李四", "王五", "劉六"];
 names.sort(function(a,b){return a.localeCompare(b)});//a,b 為數組a的某兩個值,自動傳入
 alert(names);
</script>

 

另:

示例文本:



String [] test = new String[] {
                "作業",
                "測試",
                "test",
                "我們",
                "。空",
                "鏤空",
                "[",
                "瀏",
                "皙"
        };

jdk 版本:

 1.5.6

開發平臺:

 Eclipse 3.1

關鍵字: 中文排序

 

概述


我們在應用程序中可能會經常遇到對中文排序的問題,例如姓名列表,詞匯表等等。對中文排序,我們使用比較多的是根據漢語拼音發音來確定順序。

我們可能會經常使用 

  1. java.util.Set

 接口,

  1. java.util.Arrays .sort((T[] a, Comparator <? super  T> c))

 等類或方法對含有中文字符的對象進行排序,但是這些在默認情況下都是調用 

  1. String .CompareTo(String )

方法,這個方法是比較2個字符的 codepoint value,如果第一個字符的值小于第二個,則在排序結果中第一個會在前面,反之亦然。

  1. java.text.Collator
接口及其實現類


其實 java 中提供了和語言相關的類,即 Collator 接口及其實現類。

 是一個具體類,它實現了 Comparator 接口中的 compare(Object, Object) 方法。 RuleBasedCollator 根據根據特定語言的默認規則比較字符,也可以按照指定的規則來比較,請參閱 java API 獲取此類的詳細信 息。
如果我們需要對一個有中文的數組進行排序,則可以使用這個類。請看如下示例代碼:

  1. import  java.util.*;
  2. import  java.text.*;
  3. public  class  Test
  4. {
  5.         String  [] test = new  String [] {
  6.                 "作業" ,
  7.                 "測試" ,
  8.                 "test" ,
  9.                 "我們" ,
  10.                 "。空" ,
  11.                 "鏤空" ,
  12.                 "[" ,
  13.                 "瀏" ,
  14.                 "皙"
  15.         };
  16.       java.util.Arrays .sort(test, 
  17.               (RuleBasedCollator )Collator .getInstance(Locale .CHINA));
  18.       System .out.println("============" );
  19.       for (String  key : test)
  20.           System .out.println(key);
  21. }



以上代碼的輸出結果為:

============
[
test
。空
測試
我們
作業

鏤空



大家可能會發現只有一部分漢字是按照漢語拼音排序了,還有幾個沒有。

問題分析:


GB2312:
在簡體中文中我們使用比較多的字符集是 GB2312-80,簡稱為 GB2312,這個字符集包含了目前最常用的漢字共計 6736 個。其中的漢字分為兩大類:

    常用漢字

 

    次常用漢字



常用漢字按照漢語拼音來排序,而次常用漢字按照筆畫部首進行排序。

簡體漢字在 Unicode 中一般是按照 gb2312 的碼點值的順序來放置的,所以如果是常用漢字 java 就能夠很準確的進行排序,但如果是次常用漢字,則就會出現問題。在以上示例中,"鏤","皙" 屬于次常用字。

解決方案:


RuleBasedCollator 類 getRules() 方法可以返回對應語言的規則設置。簡體中文對應的規則是 gb2312 所對應的字符。


    我們可以把其中的全部漢字提取出來

 

    對這些漢字重新排序

 

    利用RuleBasedCollator(String rules) 構造器新建一個定制的 RuleBasedCollator

 

參考代碼


在以下的代碼中,我把排過序的漢字直接作為 String 對象放在類里面了,如果要讓代碼變得簡潔一些,則可以把完整的規則(特殊字符+排序漢字)存為文件。

  1. package  sorting;
  2. import  java.util.*;
  3. import  java.text.*;
  4. /**
  5.  * @author GaoJianMin
  6.  *
  7.  */
  8. public  class  ChineseGB2312Collator
  9. {
  10.     /**
  11.      * @return a customized RuleBasedCollator with Chinese characters (GB2312) sorted correctly
  12.      * 
  13.      */
  14.     public  static  final  RuleBasedCollator  getFixedGB2312Collator()
  15.     {
  16.         RuleBasedCollator  fixedGB2312Collator =null ;
  17.         try
  18.         {
  19.             fixedGB2312Collator = new  java.text.RuleBasedCollator (
  20.                     ChineseGB2312Collator.getGB2312SpecialChars() +
  21.                     GB2312Chars
  22.                     );
  23.         }catch (ParseException  e)
  24.         {
  25.             e.printStackTrace();
  26.         }
  27.         return  fixedGB2312Collator;
  28.     }
  29.     
  30.     /**
  31.      * @return the special characters in GB2312 charset.
  32.      * 
  33.      */
  34.     public  static  final  String  getGB2312SpecialChars()
  35.     {
  36.         RuleBasedCollator  zh_CNCollator = (RuleBasedCollator )Collator .getInstance(Locale .CHINA);
  37.         //index 2125 is the last symbol "╋"
  38.         return  zh_CNCollator.getRules().substring(0,2125);
  39.     }
  40.     
  41.     /**
  42.      * 6763 Chinese characters in GB2312 charset
  43.      */
  44.     public  static  final  String  GB2312Chars =
  45.         "<吖<阿<啊< 錒<嗄<哎<哀<唉<埃<挨<锿<捱<皚<癌<噯<矮<藹< 靄<艾<愛<砹<隘<嗌<嬡<礙<曖<璦<安<桉<氨<庵< 諳<鵪<鞍<俺<埯<銨<揞<犴<岸<按<案<胺<暗<黯< 骯<昂<盎<凹<坳<敖<嗷<廒<獒<遨<熬<翱<聱<螯< 鰲<鏖<拗<襖<媼<岙<傲<奧<驁<澳<懊<鏊"  +
  46.         "<八<巴<叭< 扒<吧<岜<芭<疤<捌<笆<粑<拔<茇<菝<跋<魃<把< 鈀<靶<壩<爸<罷<鲅<霸<灞<掰<白<百<佰<柏<捭< 擺<唄<敗<拜<稗<扳<班<般<頒<斑<搬<瘢<癍<阪< 坂<板<版<鈑<舨<辦<半<伴<扮<拌<絆<瓣<邦<幫< 梆<浜<綁<榜<膀<蚌<傍<棒<謗<蒡<磅<鎊<勹<包< 孢<苞<胞<煲<齙<褒<雹<寶<飽<保<鴇<堡<葆<褓< 報<抱<豹<趵<鮑<暴<爆<陂<卑<杯<悲<碑<鵯<北< 貝<狽<邶<備<背<鋇<倍<悖<被<憊<焙<輩<碚<蓓< 褙<鞴<鐾<奔<賁<錛<本<苯<畚<坌<笨<崩<繃<嘣< 甭<泵<迸<甏<蹦<逼<荸<鼻<匕<比<吡<妣<彼<秕< 俾<筆<舭<鄙<幣<必<畢<閉<庇<畀<嗶<毖<蓽<陛< 斃<狴<鉍<婢<庳<敝<萆<弼<愎<篳<潷<痹<蓖<裨< 蹕<辟<弊<碧<箅<蔽<壁<嬖<篦<薜<避<濞<臂<髀< 璧<襞<邊<砭<籩<編<煸<蝙<鳊<鞭<貶<扁<窆<匾< 碥<褊<卞<弁<忭<汴<芐<拚<便<變<緶<遍<辨<辯< 辮<灬<杓<彪<標<颮<髟<驃<膘<瘭<鏢<飆<飚<鑣< 表<婊<裱<鰾<憋<鱉<別<蹩<癟<賓<彬<儐<斌<濱< 繽<檳<鑌<瀕<豳<擯<殯<臏<髕<鬢<冫<冰<兵<丙< 邴<秉<柄<炳<餅<稟<并<病<摒<撥<波<玻<剝<缽< 餑<啵<脖<菠<播<伯<孛<駁<帛<泊<勃<亳<鈸<鉑< 舶<博<渤<鵓<搏<箔<膊<踣<薄<礴<跛<簸<擘<檗< 逋<鈽<晡<醭<卜<卟<補<哺<捕<不<布<步<怖<钚< 部<埠<瓿<簿"  ;
  1. }
  2. package  sorting;
  3. import  java.util.*;
  4. import  java.text.*;
  5. /**
  6.  * @author GaoJianMin
  7.  *
  8.  */
  9. public  class  ChineseGB2312Comparator implements  Comparator <String >, Comparable <String > {
  10.     private  RuleBasedCollator  GB2312Collator =
  11.         ChineseGB2312Collator.getFixedGB2312Collator();
  12.     private  String  str1;
  13.     
  14.     /**
  15.      * @param str1
  16.      */
  17.     public  ChineseGB2312Comparator(String  str1) {
  18.         this .str1 = str1;
  19.     }
  20.     /**
  21.      * 
  22.      */
  23.     public  ChineseGB2312Comparator() {
  24.         this .str1="" ;
  25.     }
  26.     /**
  27.      * @param str1
  28.      * @param str2
  29.      * @return an integer indicatint the comparison result
  30.      * @see java.util.Comparator#compare(Object, Object)
  31.      */
  32.     public  int  compare(String  str1, String  str2) {
  33.         return  GB2312Collator.compare(str1, str2);
  34.     }
  35.     /**
  36.      * @param str2
  37.      * @return an integer indicatint the comparison result
  38.      *  @see java.lang.Comparable#compareTo(Object)
  39.      */
  40.     public  int  compareTo(String  str2) {
  41.         return  GB2312Collator.compare(str1, str2);
  42.     }
  43. }


測試代碼及結果


代碼:
  1. import  java.util.*;
  2. import  java.text.*;
  3. public  class  Test
  4. {
  5.         String  [] test = new  String [] {
  6.                 "作業" ,
  7.                 "測試" ,
  8.                 "test" ,
  9.                 "我們" ,
  10.                 "。空" ,
  11.                 "鏤空" ,
  12.                 "[" ,
  13.                 "瀏" ,
  14.                 "皙"
  15.         };
  16.       java.util.Arrays .sort(test, new  ChineseGB2312Comparator());
  17.       System .out.println("============" );
  18.       for (String  key : test)
  19.           System .out.println(key);
  20. }


ChineseGB2312Comparator 類同時實現了 Comparator, Comparable 接口,這樣以后能夠使用 compare, compareTo 方法的時候都可以使用這個類。
posted @ 2010-12-17 13:22 小菜毛毛 閱讀(8617) | 評論 (2)編輯 收藏

2010年12月14日 #

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一起使用。
posted @ 2010-12-14 21:55 小菜毛毛 閱讀(446) | 評論 (0)編輯 收藏

2010年12月10日 #

花了整整一天時間,研究怎么通過在Android應用程序中添加Admob廣告來賺錢。網上也有些教程,不過說得不夠詳細,自己還得花時間摸索。為了讓后來者能更快開始Admob廣告賺錢,所以寫個詳細一點的教程,供大家參考。

例子工程源碼下載地址:(建議使用瀏覽器自帶的下載工具下載)http://cid-cb78b387364ae9a7.skydrive.live.com/browse.aspx/.Public/%e8%bd%af%e4%bb%b6/Andoroid
當然,我也參考了一些網上的資料,主要有:

AdMob:在android應用中嵌入廣告的方案
如何在Android Market賺錢 part 2 - 免費app附帶廣告
Publisher Starter Kit
面向開發者 Wiki 的 AdMob

好了,現在讓我從頭開始說起……在這之前,你不需要有任何的帳號,唯一需要的就是有一個有效的email郵箱。只要按照下面的步驟一步步來,你就能通過將Admob的廣告插到自己的程序中賺錢啦!

首先,當然是需要注冊一個Admob的帳號。Admob的主頁是:http://www.admob.com/ 。 當然,如果你對于瀏覽英文網頁還有些障礙的話,可以登錄中文網站:http://zhcn.admob.com/ 。如果網站的文字還是英文,你可以在網站主頁的右下角的“Language”處,選擇“中文(簡體)”。點擊進入注冊頁面后,有一些欄目需要填寫,不要太 過疑慮,就像你注冊一個論壇一樣,隨便填下就好了。最關鍵的是保證填寫的email地址有效,另外就是填上姓名,選擇語言。帳戶類型我選擇的“不確定”, 語言“中文(簡體)”~ 提交注冊申請之后,不久你就會收到用于確認并激活帳號的電子郵件,點擊激活鏈接,就可以了激活你的Admob帳號了~

第二步就是設置你的Android應 用程序信息,并獲得Admob的插入代碼。登錄你的Admob帳號后,在主頁的左上方(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 www.admob.com before downloading this code. It is a 15-character code like a1496ced2842262. Just before the closing </application> tag add a line to set your publisher ID:


                <!-- The application's publisher ID assigned by AdMob -->
                <meta-data android:value="YOUR_ID_HERE" android:name="ADMOB_PUBLISHER_ID" />
        </application>
Set any permissions not already included just before the closing </manifest> tag:
                <!-- AdMob SDK permissions -->
                <uses-permission android:name="android.permission.INTERNET" />
                <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
        </manifest>

Only the INTERNET permission is required. Setting ACCESS_COARSE_LOCATION (and/or ACCESS_FINE_LOCATION) allows narrowly geo-targeted ads be shown.

這里需要注意的是,<meta-data android:value="YOUR_ID_HERE" android:name="ADMOB_PUBLISHER_ID" />中,我們只需要改的是"YOUR_ID_HERE"。這里需要你填上的ID就是我們之前在Admob網站我們的應用程序管理頁面上看到的 Publisher ID,而name="ADMOB_PUBLISHER_ID"是不應該改的。程序需要這個Key來查找對應的Value。

attrs.xml
The attrs.xml file specifies custom AdView attributes in XML layout files. If your application does not already have an /res/values/attrs.xml file then create one and copy-and-paste the following into it. If you do have that file then just add the declare-styleable element:


        <?xml version="1.0" encoding="utf-8"?>
        <resources>
                <declare-styleable name="com.admob.android.ads.AdView">
                        <attr name="testing" format="boolean" />
                        <attr name="backgroundColor" format="color" />
                        <attr name="textColor" format="color" />
                        <attr name="keywords" format="string" />
                        <attr name="refreshInterval" format="integer" />
                        <attr name="isGoneWithoutAd" format="boolean" />
                </declare-styleable>
        </resources>

這個,沒什么說的。


Placing an AdView in a Layout
AdView widgets can be put into any XML layout now. The first step is to reference attrs.xml in your layout element by adding an xmlns line that includes your package name specified in AndroidManifest.xml:


        xmlns:yourapp=http://schemas.android.com/apk/res/yourpackage

For example a simple screen with only an ad on it would look like:


        <?xml version="1.0" encoding="utf-8"?>
        <LinearLayout
                xmlns:android="http://schemas.android.com/apk/res/android"
                xmlns:admobsdk="http://schemas.android.com/apk/res/com.admob.android.example"
                android:orientation="vertical"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent">
   
                <com.admob.android.ads.AdView
                        android:id="@+id/ad"
                        android:layout_width="fill_parent"
                        android:layout_height="wrap_content"
                        admobsdk:backgroundColor="#000000"
                        admobsdk:textColor="#FFFFFF"
                        admobsdk:keywords="Android application"
                />
                       
        </LinearLayout>

這里好像也沒什么需要特別注意的,注意加上xmlns,另外知道這里可以設置一個keywords

Test Mode
When you start integrating AdMob ads into your application it is recommended to use test mode. This always returns the same ad. Normal ad requests are not deterministic making it harder to be sure the ad view looks like you want (e.g. ad requests can timeout or may not fill).

Once the ad shows up as you expect be sure to turn test mode off to get real ads. Never put your application into the Android Market with test mode enabled.

Test mode can be enabled either by calling AdManager.setInTestMode(true) or by adding a "admobsdk:testing="true"" property to the ad in your XML layout (where "admobsdk" is the XML namespace for your application).


設置Test Mode這個很關鍵,千萬別將處于Test Mode的程序發布出去了,那樣可賺不了錢啊~!如果在AdView的屬性中不加上admobsdk:testing="false",似乎程序也是不處于Test Mode的,不過最好還是加上吧~

第五步編譯運行,并激活程序。編譯運行你的程序,在模擬器上就可以看到效果啦~(當然你的模擬器需要能上網,關于怎么讓模擬器上網呢?用路由的應該 可以直接上,如果不是用路由,那么可能需要設置下,具體方法大家自己網上搜吧,具體忘了)。如果你的應用程序能顯示出廣告,那么恭喜你,你的應用程序很快 就會在Admob上被激活了(需要一定的時間,我的好像花了一個小時不到)!

第六步在Admob網站上查看應用程序賺了多少錢~“手機廣告市場”—>“報告”—>“站點和應用程序報告”。選擇你的應用程序,然后點擊頁面最下面的“創建報告”~ OK,賺錢啦~

最后,我把我自己寫的一個例子工程上傳上來,大家可以下載來參考下。另外,我的工程將廣告作為移動的,并且改變了它默認的寬度和背景,希望對如何在應用程序中擺放廣告,起到一個拋磚引玉的作用。效果圖如下(哈哈,在模擬器跑的~):



1.http://www.admob.com/注冊一個帳號,

添加Add Mobile Site/app,輸入相關信息后,提交完成,

下載Android平臺使用的JAR,查看發布者 ID。

2.然后將JAR添加到你的項目中

Properties->Java Build Path->Libraries->Add JARs…->Select the JAR->OK

3.編輯AndroidManifest.xml

application節點中添加

<!– The application’s publisher ID assigned by AdMob –>

<meta-data android:value=”a14ae1ce0357305″ android:name=”ADMOB_PUBLISHER_ID” />

manifest節點添加權限申請

<!– AdMob SDK permissions –>

<uses-permission android:name=”android.permission.INTERNET” />

4.添加attrs.xml

/res/values/attrs.xml

<?xml version=”1.0″ encoding=”utf-8″?>

<resources>

<declare-styleable name=”com.admob.android.ads.AdView”>

<attr name=”testing” format=”boolean” />

<attr name=”backgroundColor” format=”color” />

<attr name=”textColor” format=”color” />

<attr name=”keywords” format=”string” />

<attr name=”refreshInterval” format=”integer” />

<attr name=”isGoneWithoutAd” format=”boolean” />

</declare-styleable>

</resources>

5.添加廣告組件

<?xml version=”1.0″ encoding=”utf-8″?>

<LinearLayout xmlns:android=”http://schemas.android.com/apk/res/android”

xmlns:admobsdk=”http://schemas.android.com/apk/res/com.moandroid.livesports”

android:orientation=”vertical”

android:layout_width=”fill_parent”

android:layout_height=”fill_parent”

>

<TextView

android:layout_width=”fill_parent”

android:layout_height=”wrap_content”

android:text=”@string/hello”

/>

<com.admob.android.ads.AdView

android:id=”@+id/ad”

android:layout_width=”fill_parent”

android:layout_height=”wrap_content”

admobsdk:backgroundColor=”#000000″

admobsdk:textColor=”#FFFFFF”

admobsdk:keywords=”Android application”

admobsdk:refreshInterval=”60″

/>

</LinearLayout>

6.顯示效果

為免費app嵌入Admob廣告,進而獲得廣告收入。

adm

posted @ 2010-12-10 17:42 小菜毛毛 閱讀(2338) | 評論 (2)編輯 收藏

http://marshal.easymorse.com/archives/2950

在多Activity開發中,有可能是自己應用之間的Activity跳轉,或者夾帶其他應用的可復用Activity。可能會希望跳轉到原來某個Activity實例,而不是產生大量重復的Activity。

這需要為Activity配置特定的加載模式,而不是使用默認的加載模式。

加載模式分類及在哪里配置

Activity有四種加載模式:

  • standard
  • singleTop
  • singleTask
  • singleInstance

設置的位置在AndroidManifest.xml文件中activity元素的android:launchMode屬性:

<activity android:name="ActB" android:launchMode="singleTask"></activity>

也可以在Eclipse ADT中圖形界面中編輯:

image

區分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實例。

第一個界面:

image

點擊按鈕后:

image

可以多點幾次。發現每次都創建了該Activity的新實例。standard的加載模式就是這樣的,intent將發送給新的實例。

現在點Android設備的回退鍵,可以看到是按照剛才創建Activity實例的倒序依次出現,類似退棧的操作,而剛才操作跳轉按鈕的過程是壓棧的操作。如下圖:

image

singleTop

singleTop和standard模式,都會將intent發送新的實例(后兩種模式不發送到新的實例,如果已經有了的話)。不 過,singleTop要求如果創建intent的時候棧頂已經有要創建的Activity的實例,則將intent發送給該實例,而不發送給新的實例。

還是用剛才的示例,只需將launchMode改為singleTop,就能看到區別。

運行的時候會發現,按多少遍按鈕,都是相同的ActiA實例,因為該實例在棧頂,因此不會創建新的實例。如果回退,將退出應用。

image

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加載。結果類似下圖:

image

如果把ActA的加載模式改為standard,情況一樣。

singleTask

singleTask模式和后面的singleInstance模式都是只創建一個實例的。

當intent到來,需要創建singleTask模式Activity的時候,系統會檢查棧里面是否已經有該Activity的實例。如果有直接將intent發送給它。

把上面singleTop的實例中的ActA的launchMode改為singleTask,ActB的改為standard。那么會發現在ActA界面中按一次按鈕:

image

然后在ActB1界面中按按鈕,因為ActA是singleTask,會使用原來的ActA1實例。這時候棧內的情況:

image

如果多次按按鈕跳轉,會發現始終只有ActA1這一個ActA類的實例。

singleInstance

解釋singleInstance模式比較麻煩。

首先要說一下Task(任務)的概念。

如果是Swing或者Windows程序,可能有多個窗口可以切換,但是你無法在自己程序中復用人家的窗口。注意是直接復用人家的二進制代碼,不是你拿到人家api后的源代碼級調用。

Android可以做到,讓別人的程序直接復用你的Activity(類似桌面程序的窗口)。

Android為提供這種機制,就引入了Task的概念。Task可以認為是一個棧,可放入多個Activity。比如啟動一個應用,那么 Android就創建了一個Task,然后啟動這個應用的入口Activity,就是intent-filter中配置為main和launch的那個 (見一個APK文件部署產生多個應用安裝的效果)。這個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,看到現象用示意圖類似這樣:

image

如果是第一次按鈕切換到ActB,在ActB在按按鈕切換到ActA,然后再回退,示意圖是:

image

另外,可以看到兩個Activity的taskId是不同的。

posted @ 2010-12-10 10:38 小菜毛毛 閱讀(830) | 評論 (0)編輯 收藏

1一152期六合图库资料