设计模式-工厂模式

1.工厂模式的定义及使用场景

工厂模式是创建型设计模式之一。定义一个用户创建对象的接口，让子类决定实例化那个类。工厂模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用

2.工厂模式的优缺点

2.1优点

1）良好的封装性，代码结构清晰

2）具有良好的扩展性，在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成需求变化

3）典型解耦框架，遵循迪米特法则、里氏替换原则、依赖倒置原则

2.2缺点

1）需要谨慎考虑是否要增加一个工厂类进行管理，会增加代码的复杂度

3.工厂模式的实现方式

Product:抽象产品类

public abstract class Product {
  public abstract void excute();
}

Facory：抽象工厂类

public abstract class Factory {
  public abstract <T extends Product> T excute(Class<T> tClass);
}

ConcreteFactory：工厂实现类

public class ConcreteFactory extends Factory {
    @Override
  public  <T extends Product> T excute(Class<T> tClass) {
        Product product = null;
        try {
            product = (Product) Class.forName(tClass.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T)product;
    }
}

ProductOne：产品实现One

public class ProductOne extends Product {
    @Override
  public void excute() {
        System.out.println("ProductOne excute!");
    }
}

ProductTwo：产品实现Two

public class ProductTwo extends Product {
    @Override
    public  void excute() {
        System.out.println("ProductTwo excute!");
    }
}

Test：客户端使用类

public class Test {

    public static void main(String args[]) {
        Factory factory = new ConcreteFactory();
        Product r1 = factory.excute(ProductOne.class);
        r1.excute();
        Product r2 = factory.excute(ProductTwo.class);
        r2.excute();
    }
}

4.工厂模式在Android中的实际应用

关于Activity的创建工程，是一个复杂的调度过程。这里我们主要研究Activity的创建是如何采用实现。Activity的创建最终由ActivityThread的performLaunchActivity中实现。

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
  // System.out.println("##### [" + System.currentTimeMillis() + "] ActivityThread.performLaunchActivity(" + r + ")");

  ActivityInfo aInfo = r.activityInfo;
  if (r.packageInfo == null) {
  r.packageInfo = getPackageInfo(aInfo.applicationInfo, r.compatInfo,
  Context.CONTEXT_INCLUDE_CODE);
  }

  ComponentName component = r.intent.getComponent();
  if (component == null) {
  component = r.intent.resolveActivity(
  mInitialApplication.getPackageManager());
  r.intent.setComponent(component);
  }

  if (r.activityInfo.targetActivity != null) {
  component = new ComponentName(r.activityInfo.packageName,
  r.activityInfo.targetActivity);
  }

  Activity activity = null;
  try {
  java.lang.ClassLoader cl = r.packageInfo.getClassLoader();
  activity = mInstrumentation.newActivity(
  cl, component.getClassName(), r.intent);
  StrictMode.incrementExpectedActivityCount(activity.getClass());
  r.intent.setExtrasClassLoader(cl);
  r.intent.prepareToEnterProcess();
  if (r.state != null) {
  r.state.setClassLoader(cl);
  }
  } catch (Exception e) {
  if (!mInstrumentation.onException(activity, e)) {
  throw new RuntimeException(
  "Unable to instantiate activity " + component
  + ": " + e.toString(), e);
  }
  }

  try {
  Application app = r.packageInfo.makeApplication(false, mInstrumentation);

  if (localLOGV) Slog.v(TAG, "Performing launch of " + r);
  if (localLOGV) Slog.v(
  TAG, r + ": app=" + app
  + ", appName=" + app.getPackageName()
  + ", pkg=" + r.packageInfo.getPackageName()
  + ", comp=" + r.intent.getComponent().toShortString()
  + ", dir=" + r.packageInfo.getAppDir());

  if (activity != null) {
  Context appContext = createBaseContextForActivity(r, activity);
  CharSequence title = r.activityInfo.loadLabel(appContext.getPackageManager());
  Configuration config = new Configuration(mCompatConfiguration);
  if (DEBUG_CONFIGURATION) Slog.v(TAG, "Launching activity "
  + r.activityInfo.name + " with config " + config);
  activity.attach(appContext, this, getInstrumentation(), r.token,
  r.ident, app, r.intent, r.activityInfo, title, r.parent,
  r.embeddedID, r.lastNonConfigurationInstances, config,
  r.referrer, r.voiceInteractor);

  if (customIntent != null) {
  activity.mIntent = customIntent;
  }
  r.lastNonConfigurationInstances = null;
  activity.mStartedActivity = false;
  int theme = r.activityInfo.getThemeResource();
  if (theme != 0) {
  activity.setTheme(theme);
  }

  activity.mCalled = false;
  if (r.isPersistable()) {
  mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
  } else {
  mInstrumentation.callActivityOnCreate(activity, r.state);
  }
  if (!activity.mCalled) {
  throw new SuperNotCalledException(
  "Activity " + r.intent.getComponent().toShortString() +
  " did not call through to super.onCreate()");
  }
  r.activity = activity;
  r.stopped = true;
  if (!r.activity.mFinished) {
  activity.performStart();
  r.stopped = false;
  }
  if (!r.activity.mFinished) {
  if (r.isPersistable()) {
  if (r.state != null || r.persistentState != null) {
  mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,
  r.persistentState);
  }
  } else if (r.state != null) {
  mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);
  }
  }
  if (!r.activity.mFinished) {
  activity.mCalled = false;
  if (r.isPersistable()) {
  mInstrumentation.callActivityOnPostCreate(activity, r.state,
  r.persistentState);
  } else {
  mInstrumentation.callActivityOnPostCreate(activity, r.state);
  }
  if (!activity.mCalled) {
  throw new SuperNotCalledException(
  "Activity " + r.intent.getComponent().toShortString() +
  " did not call through to super.onPostCreate()");
  }
  }
  }
  r.paused = true;

  mActivities.put(r.token, r);

  } catch (SuperNotCalledException e) {
  throw e;

  } catch (Exception e) {
  if (!mInstrumentation.onException(activity, e)) {
  throw new RuntimeException(
  "Unable to start activity " + component
  + ": " + e.toString(), e);
  }
  }

  return activity;
  }

其中  activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); 

 public Activity newActivity(Class<?> clazz, Context context,

  IBinder token, Application application, Intent intent, ActivityInfo info,

  CharSequence title, Activity parent, String id,
  Object lastNonConfigurationInstance) throws InstantiationException,

  IllegalAccessException {
  Activity activity = (Activity)clazz.newInstance();
  ActivityThread aThread = null;
  activity.attach(context, aThread, this, token, 0, application, intent,
  info, title, parent, id,
  (Activity.NonConfigurationInstances)lastNonConfigurationInstance,
  new Configuration(), null, null);
  return activity;
  }

在 Instrumentation中的newActivity最终执行了Activity的实例化创建。