【设计模式】工厂方法模式——工厂方法模式在Android SDK源码中的应用

工厂方法模式在Android SDK源码中有广泛的应用，无论app层还是framework层，无论是Java实现的还是Kotlin实现的。

BitmapFactory

Bitmap的构造方法都没有被public修饰，开发者必须用BitmapFactory来生成Bitmap对象，BitmapFactory中用于生产Bitmap实例的工厂方法如下：

public class BitmapFactory {
    
    // ……代码省略……
    
    /**
     * Decode a file path into a bitmap. If the specified file name is null,
     * or cannot be decoded into a bitmap, the function returns null.
     */
    public static Bitmap decodeFile(String pathName, Options opts) {
        // ……代码省略……       
        return bm;
    }

    /**
     * Synonym for opening the given resource and calling
     */
    public static Bitmap decodeResource(Resources res, int id, Options opts) {
        // ……代码省略……
        return bm;
    }

    /**
     * Decode an immutable bitmap from the specified byte array.
     */
    public static Bitmap decodeByteArray(byte[] data, int offset, int length, Options opts) {
        // ……代码省略……
        return bm;
    }

    /**
     * Decode an input stream into a bitmap. If the input stream is null, or
     * cannot be used to decode a bitmap, the function returns null.
     * The stream's position will be where ever it was after the encoded data
     * was read.
     */
    @Nullable
    public static Bitmap decodeStream(@Nullable InputStream is, @Nullable Rect outPadding,
            @Nullable Options opts) {
        // ……代码省略……
        return bm;
    }

    /**
     * Decode a bitmap from the file descriptor. If the bitmap cannot be decoded
     * return null. The position within the descriptor will not be changed when
     * this returns, so the descriptor can be used again as-is.
     */
    public static Bitmap decodeFileDescriptor(FileDescriptor fd, Rect outPadding, Options opts) {
        // ……代码省略……
        return bm;
    }

    // ……代码省略……
    
}

可见BitmapFactory生产Bitmap对象的方法都是用static修饰的静态方法，是典型的简单工厂。

AppComponentFactory

众所周知Application和四大组件都是不能直接new出来的，需要通知system-server之后才能在当前进程生成实例。AppComponentFactory用来生产Applicaiton和四大组件的工厂方法代码如下：

public class AppComponentFactory {

    public @NonNull ClassLoader instantiateClassLoader(@NonNull ClassLoader cl,
            @NonNull ApplicationInfo aInfo) {
        return cl;
    }

    public @NonNull Application instantiateApplication(@NonNull ClassLoader cl,
            @NonNull String className)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Application) cl.loadClass(className).newInstance();
    }

    public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
            @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Activity) cl.loadClass(className).newInstance();
    }

    public @NonNull BroadcastReceiver instantiateReceiver(@NonNull ClassLoader cl,
            @NonNull String className, @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (BroadcastReceiver) cl.loadClass(className).newInstance();
    }

    public @NonNull Service instantiateService(@NonNull ClassLoader cl,
            @NonNull String className, @Nullable Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (Service) cl.loadClass(className).newInstance();
    }

    public @NonNull ContentProvider instantiateProvider(@NonNull ClassLoader cl,
            @NonNull String className)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        return (ContentProvider) cl.loadClass(className).newInstance();
    }

    /**
     * @hide
     */
    public static final AppComponentFactory DEFAULT = new AppComponentFactory();
}

生成Application和四大组件实例都是靠工厂方法生成，注意最后一行的单例模式的懒汉式实现，AppComponentFactory同时利用了工厂方法模式和单例模式。

在Android源码中简单工厂的应用非常广泛，是否有多工厂的应用呢？答案是有的，就是Jetpack组件里的ViewModelProvider.Factory。

ViewModelProvider.Factory

众所周知ViewModel作为MVVM架构中的VM，是不能直接new出来的，必须是用ViewModelProvider生成，我们来看源码：

@MainThread
public open operator fun <T : ViewModel> get(modelClass: Class<T>): T {
    val canonicalName = modelClass.canonicalName
        ?: throw IllegalArgumentException("Local and anonymous classes can not be ViewModels")
    return get("$DEFAULT_KEY:$canonicalName", modelClass)
}

@MainThread
public open operator fun <T : ViewModel> get(key: String, modelClass: Class<T>): T {
	val viewModel = store[key]
    if (modelClass.isInstance(viewModel)) {
        (factory as? OnRequeryFactory)?.onRequery(viewModel!!)
        return viewModel as T
    } else {
        @Suppress("ControlFlowWithEmptyBody")
        if (viewModel != null) {
            // TODO: log a warning.
        }
    }
    val extras = MutableCreationExtras(defaultCreationExtras)
    extras[VIEW_MODEL_KEY] = key
    // AGP has some desugaring issues associated with compileOnly dependencies so we need to
    // fall back to the other create method to keep from crashing.
    return try {
        factory.create(modelClass, extras)
    } catch (e: AbstractMethodError) {
        factory.create(modelClass)
    }.also { store.put(key, it) }
}

// 用接口实现的抽象工厂
public interface Factory {
	public fun <T : ViewModel> create(modelClass: Class<T>): T {
    	throw UnsupportedOperationException(
            "Factory.create(String) is unsupported.  This Factory requires " +
                    "`CreationExtras` to be passed into `create` method."
        )
    }
    
    // ……代码省略……
}

// 具体工厂之一
@Suppress("SingletonConstructor")
public open class NewInstanceFactory : Factory {
	@Suppress("DocumentExceptions")
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return try {
            modelClass.getDeclaredConstructor().newInstance()
        } catch (e: NoSuchMethodException) {
            throw RuntimeException("Cannot create an instance of $modelClass", e)
        } catch (e: InstantiationException) {
            throw RuntimeException("Cannot create an instance of $modelClass", e)
        } catch (e: IllegalAccessException) {
            throw RuntimeException("Cannot create an instance of $modelClass", e)
        }
    }
    // ……代码省略……
}

// 具体工厂之二
public open class AndroidViewModelFactory
    private constructor(
        private val application: Application?,
        // parameter to avoid clash between constructors with nullable and non-nullable
        // Application
        @Suppress("UNUSED_PARAMETER") unused: Int,
    ) : NewInstanceFactory() {

	/**
	 * Constructs this factory.
     */
    @Suppress("SingletonConstructor")
    public constructor() : this(null, 0)

	@Suppress("SingletonConstructor")
    public constructor(application: Application) : this(application, 0)

    @Suppress("DocumentExceptions")
    override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
		return if (application != null) {
            create(modelClass)
        } else {
            val application = extras[APPLICATION_KEY]
            if (application != null) {
                create(modelClass, application)
            } else {
                // For AndroidViewModels, CreationExtras must have an application set
            if (AndroidViewModel::class.java.isAssignableFrom(modelClass)) {
                throw IllegalArgumentException(
                    "CreationExtras must have an application by `APPLICATION_KEY`"
                )
            }
            super.create(modelClass)
            }
        }
    }

    @Suppress("DocumentExceptions")
   	override fun <T : ViewModel> create(modelClass: Class<T>): T {
		return if (application == null) {
			throw UnsupportedOperationException(
            	"AndroidViewModelFactory constructed " +
					"with empty constructor works only with " +
                    "create(modelClass: Class<T>, extras: CreationExtras)."
            )
        } else {
            create(modelClass, application)
        }
    }
    
    // ……代码省略……
}

不直接new出ViewModel对象而用工厂方法生成的原因是如果ViewModelStore中存在对象，则返回该对象，不存在才new出新对象。除了ViewModelProvider.AndroidViewModelFactory之外，接口ViewModelProvider.Factory还有许多实现的子类，而且AndroidViewModelFactory也是用open修饰的，也是为了让其他类继承的，这是典型的工厂模式的多工厂。