《Android深入透析》之常用设计模式经验谈

前言：

       Android开发的设计模式，基本设计思想源于java的设计模式，java的设计模式有N多种，据不完全统计，迄今为止，网络出现最频繁的大概有23种。Java只是一门开发语言，学会并掌握这门语言进行代码编写，这是每个程序员必修的课程，但如何写出高质量、易维护和复用性强的代码，那就体现出程序员的层次和水平了。设计模式的出现就是为了解决这些问题。

       开始学习设计模式的时候，我们通常都有种将简单问题复杂化的感觉，明明一个类N行代码就能完成的事情，干嘛非要创建几个类？又抽象又难理解的。后来随着开发经验的增长，重复劳动的频繁，终有一天顿悟，体验到设计模式的妙用，方感慨万千。常言，水滴石穿，做任何事都是这样，经验和时间是最好的试金石，B哥老矣，前车之鉴，后车之师。闲言少叙，话转正题，我们介绍一下常用的设计模式。

工厂模式：

       什么是工厂模式？官方有很多解释，我这里把我所理解的结合经验，诠释给大家，我不想绞尽脑汁，抽象总结出类似于古文（JAVA编程思想）那样难于理解的文字，也没那个水平言简意赅的、一针见血的总结出众生都能看懂的解释。只能笨鸟先飞、勤能补拙，从实践出真知的角度出发，抛砖引玉，供大家思考。公司有个这样一个需求，在App中要使用到LBS定位来实现某些功能。产品技术一大堆开始了需求、技术确认会，当大家讨论到定位是用百度API来实现，还是用高德来实现。大家争论不休，有人说百度定位不准，有人说高德定位不准，众说纷纭。咋办？最后，B总拍板，两个一起用，哪个好用哪个，领导拍板了，但说了又等于没说，咋办？工厂模式这时候就呼之欲出了，我两个都给你设计，代码设个开关和参数，你说用高德不爽，我改个参数，就换百度，直到领导高兴为止，于是代码就产生了。     

public class test {
       public static void main(String[] args) {
              Location position= new LocationFactory().getInstance("xiaomi");
              position.getPosition();
              position.getCityName(10, 20);
       }
}
 
class LocationFactory{
       public static Location getInstance(String type){
              if("baidu".equals(type)){
                     return new BaiduLocation();
              }else {
                     return new XiaoMiLocation();
              }
       }
}
class BaiduLocation implements Location{
       @Override
       public void getPosition() {
              // TODO Auto-generated method stub
              System.out.println("通过百度定位获取到当前的经纬度是XXXXX");
       }
       @Override
       public void getCityName(long lat, long lng) {
              // TODO Auto-generated method stub
              System.out.println("通过百度定位获取到当前的城市是XXXXX");
       }
}
class XiaoMiLocation implements Location{
       @Override
       public void getPosition() {
              // TODO Auto-generated method stub
              System.out.println("通过小米定位获取到当前的经纬度是XXXXX");
       }
       @Override
       public void getCityName(long lat, long lng) {
              // TODO Auto-generated method stub
              System.out.println("通过小米定位获取到当前的城市是XXXXX");
       }
}
interface Location{
       public void getPosition();
       public void getCityName(long lat,long lng);
}

上面的例子，较好的阐述了工厂模式的概念。LocationFactory是一个工厂类，静态函数getInstance的参数决定了是选用百度还是高德，这样，对于调用者来说，只需要关心你是用百度还是高德即可。Location是一个接口，它抽象出高德和百度常用的函数调用。拿定位来说，基本上常用的就是根据经纬度查询地址，或者定位当前所在位置获取经纬度。当然可能还有更多有用的函数，我这里就不在列举。有了这样一个共性的接口，XiaoMiLocation和BaiduLocation通过实现它的接口就能分别满足调用者的需求。调用者就能够任意通过改变参数，来实现来自不同定位API的需求。当然，如果百度和高德不爽，你完全可以使用谷歌API，只需要构造一个GoogleLocation类并实现Location接口的方法即可。

       工厂模式的应用非常广泛，比如android的bitmap中常用的BitmapFactory类，创建Bitmap对象，通常使用静态工厂方法。

单例模式：

       什么是单例模式？单例模式的精髓主要在这个“单”字上，“单”就是一个，直接进入主题，我们通常使用“new”关键字创建一个对象，一旦“new”了，它就会开辟内存创建一个对象。假设我们经常反复创建的这个对象对我们来说其实都是一回事，那么我们就没必要浪费资源和时间嘛，好比，你去外地出差在某个地方至少1天，第一次你去服务台，服务台给你开了间房，你高高兴兴的拿着钥匙进房睡觉了。睡醒后出去办事。完事后，你是不是直接拿着这个钥匙直接奔你开好的房间？该不会去服务台再去开一间吧？大道至简，其实，细细想来，生活就是一种模式，只要你善于发现，你就会有意外惊喜，原来都是这样简单。

来个例子吧，枯燥的代码。

public class Room {
       public static Room key;
       public static void main(String[] args) {
              Room room=getKey();
              room.openDoor();
              Room room1=getKey();
              room1.openDoor(); 
       }
       public static Room getKey(){
              if(key==null){
                     key=new Room();
              }
              return key;
       } 
       public void openDoor(){
              System.out.println("我打开了门......");
       }
}

看看上面这个例子，是不是跟我举得宾馆的例子相似？你不管多少次拿钥匙，你都拿的是同一间房的钥匙，不会重新给你发一把，这样做，既节约了宾馆的时间，也节约了你的时间，多好啊。再引申一点说，android开发中也常常使用到单例模式，比如网络的封装，数据库的访问都用到了单利的设计模式。

观察者模式：

       什么是观察者模式？一般提到原告，必然脑子立刻联想到被告，观察者和被观察者就如同原告和被告总是那么成对出现。观察者模式，又被叫做订阅模式，有订阅者和发布者。当下IPHONE6异常火爆，国内粉丝要想购买，那必须得预定，必须到它苹果官方去预定，填一大堆资料，交不交钱我不知道，反正得预定登记。等粉丝等到两眼欲穿、花儿快谢了时候，它粉墨登场了，官方以高姿态从容向预定过的粉丝发售。这苹果就是被观察者，粉丝就是观察者，观察者和被观察者之间需要建立联系，那就是登记。登记过后，被观察者拿捏火候觉得时机成熟的时候，就以权位者姿态向观察者抛出绣球，观察者迫不及待的伸出双手牢牢抓住后，满心欢喜的赞美苹果的伟大和自己的庆幸。睁大眼睛盯着目标看，期待期望结果，这就是观察者模式。

来段代码体验一把

import java.util.ArrayList;
import java.util.List;
 
 
public class MyOberver {
        public static void main(String[] args) {
               American american=new American();
               Chinese chinese=new Chinese();
               Iphone iphone=new Iphone();
               System.out.println("一个美国人登记购买");
               iphone.register(american);
               System.out.println("一个中国人登记购买");
               iphone.register(chinese);
               try {
                      System.out.println("经过6个月的漫长等待...");
                     Thread.sleep(2000);
              } catch (InterruptedException e) {
                     // TODO Auto-generated catch block
                     e.printStackTrace();
              }
               iphone.notifys();
       }
}
/**观察者*/
class Iphone{
       private List<Fensi> list=new ArrayList<Fensi>();
       public void register(Fensi n){
              list.add(n);
              System.out.println("又一个苹果被预订了,现在总共有："+list.size()+"个人预订了...");
       }
       public void notifys(){
              System.out.println("IPHONE 6现在高调发售...");
              for (Fensi n:list) {
                            n.receive();
              }
       }
}
class American implements Fensi{
       @Override
       public void receive() {
              // TODO Auto-generated method stub
              System.out.println("美国人喊叫：嗯哼，有点贵....");
       }
}
class  Chinese implements Fensi{
       @Override
       public void receive() {
              // TODO Auto-generated method stub
              System.out.println("中国人：我终于买到了，高兴死了....");
       }
}
interface Fensi{
              public void receive();
}

运行后输出结果：

一个美国人登记购买

又一个苹果被预订了,现在总共有：1个人预订了...

一个中国人登记购买

又一个苹果被预订了,现在总共有：2个人预订了...

经过6个月的漫长等待...

IPHONE 6现在高调发售...

美国人喊叫：嗯哼，有点贵....

中国人：我终于买到了，高兴死了....

这就是观察者模式，Chinese和American都是观察者，它们继承了Fensi接口，具有了接收消息receive的能力，Iphone是被观察者，是被观察的目标，它的一举一动，都会深深的影响Fensi们的热情，观察者需要在被观察者哪里进行登记购买register，登记过后，等到时机成熟了，被观察者会主动放出信号iphone.notifys();这样，凡是登记过购买苹果6的粉丝们，都会纷纷收到取货的信息了。

代理模式：

什么是代理模式？代理模式在各类开发中运用的相当广泛，不论是j2ee，android还是ios，都能看到它的身影，所以说设计模式无处不在。代理模式，字面理解就是自己不方便做或者不能做的事情，需要第三方代替来做，最终通过第三方来达到自己想要的目的或效果。举例了：员工小李在B总公司打工，B总成天让小李加班不给加班费，小李忍受不住了，就想去法院告B总。虽然法律上允许打官司不请律师，允许自辩。但是小李第一不熟悉法律起诉的具体流程，第二嘴比较笨，人一多腿就抖得厉害。因此，小李决定去找律师帮忙打官司。找律师打官司和自己打官司相比，有相同的地方，也有不同的地方。

相同的地方在于：

1、  都需要提交原告的资料，如姓名、年龄、事情缘由、想达到的目的。

2、  都需要经过法院的取证调查，开庭争辩等过程。

3、  最后拿到审判结果。

不同地方在于：

1、  小李省事了，让专业的人做专业的事，不需要自己再去了解法院那一套繁琐复杂的流程。

2、  把握更大了。

通过上面的例子，我们注意到代理模式有几个重点。

1、  被代理的角色（小李）

2、  代理角色（律师）

3、  协议（不管是代理和被代理谁去做，都需要做的事情，抽象出来就是协议）

下面给个例子：

public class Proxy {
       public static void main(String[] args) {
              Employer employer=new Employer();
              System.out.println("我受不了了，我要打官司告老板");
              System.out.println("找律师解决一下吧......");
              Protocol lawyerProxy=new LawyerProxy(employer);
              lawyerProxy.register("朵朵花开");
              lawyerProxy.dosomething();
              lawyerProxy.notifys();
       }
}
interface Protocol{
       //登记资料
       public void register(String name);
       //调查案情，打官司
       public void dosomething();
       //官司完成，通知雇主
       public void notifys();
}
//律师类
class LawyerProxy  implements Protocol{
       private Employer employer;
       public LawyerProxy(Employer employer){
              this.employer=employer;
       }
       @Override
       public void register(String name) {
              // TODO Auto-generated method stub
              this.employer.register(name);
       }
 
       public void collectInfo(){
              System.out.println("作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。");
       }
       @Override
       public void dosomething() {
              // TODO Auto-generated method stub
              collectInfo();
              this.employer.dosomething();
              finish();
       }
       public void finish(){
              System.out.println("本次官司打完了...............");
 
       }
       @Override
       public void notifys() {
              // TODO Auto-generated method stub
              this.employer.notifys();
       } 
}
//雇主类
class Employer implements Protocol{
       String name=null;
       @Override
       public void register(String name) {
              // TODO Auto-generated method stub
              this.name=name;
       }
 
       @Override
       public void dosomething() {
              // TODO Auto-generated method stub
              System.out.println("我是‘"+this.name+"‘要告B总，他每天让我不停的加班，还没有加班费。");
       }
 
       @Override
       public void notifys() {
              // TODO Auto-generated method stub
              System.out.println("法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。");
       }
       
}

运行后，打印如下：

我受不了了，我要打官司告老板

找律师解决一下吧......

作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。

我是‘朵朵花开‘要告B总，他每天让我不停的加班，还没有加班费。

本次官司打完了...............

法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。

代码说明：

Protocol这个类就是上面所说的协议，是被代理者或者代理者共同遵守的约定。也就是说，无论是原告还是代理律师，到法院走程序，都需要做的事情。我们抽象出来，这个就是协议。

Employer这类是雇主类也称被代理者类，它遵从Protocol协议，并实现了Protocol协议的三个方法，并去分别完成了具体事情。

LawyerProxy这类是代理类，它也遵从Protocol协议，与Employer不同的是，定义了一个Employer对象，通过构造函数初始化。在实现的三个方法里，分别去调用被代理类的相同实现。就好比去模拟一个被告者，站在被告的角度上，去法院告状。也就是说LawyerProxy代理类对所有想打官司的人开放，只要有原告进来，我就帮他打官司。值得注意的是collectInfo和finish这两个函数，请律师打官司和不请律师打官司，其实都要做同样的事情（register、dosomething、notifys），但是至于为什么？刚才不是说了吗，请律师的好处是省心并且专业，他在做同样的事情前提下，还会收集对你有利的证据和资料（collectInfo），以及后续事情的处理（finish）。

上面就是最普通的代理模式，引申一点，我们看到，对于被告来说，必须创建一个Employer类，并实例化后传参给LawyerProxy代理类，这样做，是不是暴漏了Employer？如果隐藏一下，对于被告来说，更智能傻瓜一点，该怎么做呢？

public class Proxy {
       public static void main(String[] args) {
              //Employer employer=new Employer();
              System.out.println("我受不了了，我要打官司告老板");
              System.out.println("找律师解决一下吧......");
              Protocol lawyerProxy=new LawyerProxy("朵朵花开"); 
              lawyerProxy.dosomething();
              lawyerProxy.notifys();
       }
}
interface Protocol{
       //登记资料
       public void register(String name);
       //调查案情，打官司
       public void dosomething();
       //官司完成，通知雇主
       public void notifys();
}
//律师类
class LawyerProxy  implements Protocol{
       private Employer employer;
       public LawyerProxy(String name){
              if(name==null) {
                     System.out.println("谁告状？逗我玩呢吧？");
                     return;
              }
              if(employer==null) employer=new Employer();
              register(name); 
       }
       @Override
       public void register(String name) {
              // TODO Auto-generated method stub
              this.employer.register(name);
       }
 
       public void collectInfo(){
              System.out.println("作为律师，我需要根据雇主提供的资料，整理与调查，给法院写出书面文字，并提供证据。");
       }
       @Override
       public void dosomething() {
              // TODO Auto-generated method stub
              collectInfo();
              this.employer.dosomething();
              finish();
       }
       public void finish(){
              System.out.println("本次官司打完了...............");
 
       }
       @Override
       public void notifys() {
              // TODO Auto-generated method stub
              this.employer.notifys();
       } 
}
//雇主类
class Employer implements Protocol{
       String name=null;
       @Override
       public void register(String name) {
              // TODO Auto-generated method stub
              this.name=name;
       }
 
       @Override
       public void dosomething() {
              // TODO Auto-generated method stub
              System.out.println("我是‘"+this.name+"‘要告B总，他每天让我不停的加班，还没有加班费。");
       }
 
       @Override
       public void notifys() {
              // TODO Auto-generated method stub
              System.out.println("法院裁定，官司赢了，B总需要赔偿10万元精神补偿费。");
       }
       
}

        看到没new LawyerProxy("朵朵花开")，只需要给代理类传入简单的名字，隐含了Employer类，代理类就会自动去创建一个Employer实例，模拟一个用户继续替你完成打官司的事情。

篇幅有限，设计模式有很多种，以上列举了常用的几种，也是最常用最基础的几种，希望大家能够理解并掌握，如有兴趣，请参考《设计模式之禅》这本书，个人觉得不错。