Unity应用架构设计(7)——IoC工厂理念先行

一谈到 『IoC』,有经验的程序员马上会联想到控制反转,将创建对象的责任反转给工厂。IoC是依赖注入 『DI』 的核心,大名鼎鼎的Spring框架就是一个非常卓越的的控制反转、依赖注入框架。遗憾的是,我们显然不能在Unity 3D中去使用Spring框架,但思想是相通的——IoC也好,控制反转也罢,本质上是一个工厂,或者又被称为容器,我们可以自己维护一个工厂来实现对对象的管理,这也是本文的核心内容。

工厂模式初探

工厂,顾名思义,就是生产对象的地方。如果之前没有接触过设计模式,你可能会疑惑,我直接使用 『new』 关键字难道不能创建对象吗?为什么还要大费周章的让工厂来创建?当然这是没错的,直接使用 『new』 关键字很简洁,也很易懂,但你考虑过对象的释放吗?你可能会说不用考虑啊,GC会帮我们回收啊。

其实问题就出在这里,因为你没有考虑对象管理的动机,所以就不会有工厂这个概念。试想一下,使用ADO.NET或者JDBC去访问数据库,我们是不是要先建立一个Connection,当工作结束后,Close了这个连接。当再一次需要连接数据库时,再建立一次Connection,这背后其实有隐患。因为和数据库建立连接是非常耗时的,只是我们感受不到。我们能不能在关闭连接时,不销毁对象,而是将其放到一个对象池,当下一次请求来时,直接从对象池中获取。这就是工厂的动机,对对象的创建和释放进行管理,这样可以有效的提高效率。

注:释放指的是对象实现了IDisposable接口的非托管资源,在uMVVM框架,工厂维护的都是托管资源,销毁由GC决定

工厂的分类

在uMVVM框架中,我将工厂分为三类:单例(Singleton),临时(Transient),池(Pool)。

  • Singleton :该工厂生产的对象是单例的,即一旦生产出来的对象将处理所有的请求,不会因为不同的请求而产生新的对象,通常需要考虑多线程并发问题
  • Transient :该工厂生产的对象是临时的,转瞬即逝的,即每一次请求产生一个新对象,处理请求完毕后就被销毁
  • Pool:该工厂并不会无限的创建对象,取而代之的是内部维护了一个对象池,当请求来时,从对象池中获取,当请求处理完毕后,对象也不会被销毁,而是再次放回对象池中

我们可以为这三种工厂声明公共的接口:IObjectFactory,这是非常有必要的,方便在运行时根据需求动态的切换不同工厂:

public interface IObjectFactory
{
    object AcquireObject(string className);
    object AcquireObject(Type type);
    object AcquireObject<TInstance>() where TInstance : class, new();
    void ReleaseObject(object obj);
}

这个接口功能很简单,通过统一的入口对对象进行创建与销毁的管理。

Singleton Factory

有了统一的工厂的接口之后,接下来就是去实现对应的工厂了,第一个要实现的就是 Singleton Factory:

public class SingletonObjectFactory:IObjectFactory
{
    /// <summary>
    /// 共享的字典,不会因为不同的SingletonObjectFactory对象返回不唯一的实例对象
    /// </summary>
    private static Dictionary<Type,object> _cachedObjects = null;
    private static readonly object _lock=new object();
    private Dictionary<Type, object> CachedObjects
    {
        get
        {
            lock (_lock)
            {
                if (_cachedObjects==null)
                {
                    _cachedObjects=new Dictionary<Type, object>();
                }
                return _cachedObjects;
            }
        }
    }

    //...省略部分代码...

    public object AcquireObject<TInstance>() where TInstance:class,new()
    {
        var type = typeof(TInstance);
        if (CachedObjects.ContainsKey(type))
        {
            return CachedObjects[type];
        }
        lock (_lock)
        {
            var instance=new TInstance();
            CachedObjects.Add(type, instance);
            return CachedObjects[type];
        }
    }

}

上述代码中,我们需要定义一个全局的字典,用来存储所有的单例,值得注意的是,CachedObjects 字典是一个 static 类型,这表明这是一个共享的字典,不会因为不同的SingletonObjectFactory对象返回不唯一的实例对象。

还有一点,单例模式最好考虑一下多线程并发问题,虽然这是一个 『伪』 需求,毕竟Unity 3D是个单线程应用程序,但 uMVVM 框架还是考虑了多线程并发的问题,使用 lock 关键字,它必须是一个 static 类型,保证 lock 了同一个对象。

Transient Factory

Transient Factory 是最容易实现的工厂,不用考虑多线程并发问题,也不用考虑Pool,对每一次请求返回一个不同的对象:

public class TransientObjectFactory : IObjectFactory
{
    //...省略部分代码...

    public object AcquireObject<TInstance>() where TInstance : class, new()
    {
        var instance = new TInstance();
        return instance;
    }

}

Pool Factory

Pool Factory 相对来说是比较复杂的工厂,它对 Transient Factory 进行了升级——创建实例前先去Pool中看看是否有未被使用的对象,有的话,那么直接取出返回,如果没有则向Pool中添加一个。

Pool的实现有两种形式,一种是内置了诸多对象,还有一种是初始时是一个空的池,然后再往里面添加对象。第一种效率更高,直接从池里面拿,而第二种更省内存空间,类似于懒加载,uMVVM 的对象池技术使用第二种模式。

public class PoolObjectFactory : IObjectFactory
{
    /// <summary>
    /// 封装的PoolData
    /// </summary>
    private class PoolData
    {
        public bool InUse { get; set; }
        public object Obj { get; set; }
    }

    private readonly List<PoolData> _pool;
    private readonly int _max;
    /// <summary>
    /// 如果超过了容器大小,是否限制
    /// </summary>
    private readonly bool _limit;

    public PoolObjectFactory(int max, bool limit)
    {
        _max = max;
        _limit = limit;
        _pool = new List<PoolData>();
    }

    private PoolData GetPoolData(object obj)
    {
        lock (_pool)
        {
            for (var i = 0; i < _pool.Count; i++)
            {
                var p = _pool[i];
                if (p.Obj == obj)
                {
                    return p;
                }
            }
        }
        return null;
    }
    /// <summary>
    /// 获取对象池中的真正对象
    /// </summary>
    /// <param name="type"></param>
    /// <returns></returns>
    private object GetObject(Type type)
    {
        lock (_pool)
        {
            if (_pool.Count > 0)
            {
                if (_pool[0].Obj.GetType() != type)
                {
                    throw new Exception(string.Format("the Pool Factory only for Type :{0}", _pool[0].Obj.GetType().Name));
                }
            }

            for (var i = 0; i < _pool.Count; i++)
            {
                var p = _pool[i];
                if (!p.InUse)
                {
                    p.InUse = true;
                    return p.Obj;
                }
            }


            if (_pool.Count >= _max && _limit)
            {
                throw new Exception("max limit is arrived.");
            }

            object obj = Activator.CreateInstance(type, false);
            var p1 = new PoolData
            {
                InUse = true,
                Obj = obj
            };
            _pool.Add(p1);
            return obj;
        }
     }

    private void PutObject(object obj)
    {
        var p = GetPoolData(obj);
        if (p != null)
        {
            p.InUse = false;
        }
    }

    public object AcquireObject(Type type)
    {
        return GetObject(type);
    }

    public void ReleaseObject(object obj)
    {
        if (_pool.Count > _max)
        {
            if (obj is IDisposable)
            {
                ((IDisposable)obj).Dispose();
            }
            var p = GetPoolData(obj);
            lock (_pool)
            {
                _pool.Remove(p);
            }
            return;
        }
        PutObject(obj);
    }
}

上述的代码通过构造函数的 max 决定Pool的大小,limit 参数表示超过Pool容量时,是否可以再继续往Pool中添加数据。方法 GetObject 是最核心的方法,逻辑非常简单,获取对象之前先判断Pool中是否有未被使用的对象,如果有,则返回,如果没有,则根据 limit 参数再决定是否可以往Pool中添加数据。

小结

工厂模式是最常见的设计模式,根据工厂的类型可以获取不同形式的数据对象,比如单例数据、临时数据、亦或是对象池数据。这一章的工厂模式很重要,也是对下一篇对象的注入『Inject』做准备,故称之为理念先行。 源代码托管在Github上,点击此了解

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏程序员宝库

PHP 中被忽略的性能优化利器:生成器

如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生。但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,...

3126
来自专栏张善友的专栏

通用的序列号生成器库

正如文章《通用的业务编号规则设计实现(附源码)》 文章里需要一个多实例和线程安全的序列化生成器,在SQL Server 2012+ 版本 有一个通过.NET程序...

1905
来自专栏吴伟祥

Jmockdata随机模拟 Java 数据插件

     Jmockdta是一款实现模拟JAVA类型或对象的实例化并随机初始化对象的数据的工具框架。

1022
来自专栏李航的专栏

Shell 主要逻辑源码级分析:SHELL 运行流程 (1)

分享一下在学校的时候分析shell源码的一些收获,帮助大家了解shell的一个工作流程,从软件设计的角度,看看shell这样一个历史悠久的软件的一些设计优点和缺...

2.1K0
来自专栏QQ会员技术团队的专栏

JavaScript引擎分析

JavaScript引擎分析 一. JavaScript简介 JavaScript是一种动态类型的脚本语言;在1995年时,由Netscape公司的Brend...

2445
来自专栏技术博文

PHP编程风格规范

本规范由 EasyChen 借鉴 SINA网络应用开发部《C++开发规范》和互动技术部《PHP4开发规范》,以及phpDocument规范 整理出的开发规范。我...

3667
来自专栏SDNLAB

《P4语言规范》parser详解

前言 为深入研究P4语言相关规范及运行操作使用,本系列文章根据P4.org网站给出的《The P4 Language Specification v1.0.2》...

3979
来自专栏marsggbo

python多线程学习笔记(超详细)

python threading 多线程 一. Threading简介 首先看下面的没有用Threading的程序 import threading,time ...

2188
来自专栏韩伟的专栏

框架设计原则和规范(完)

祝大家圣诞节快乐!有事没事别出门,外面太!挤!了! 此文是《.NET:框架设计原则、规范》的读书笔记,本文内容较多,共分九章,今天推送最后一章。 1. 什么是好...

2874
来自专栏阮一峰的网络日志

JavaScript Source Map 详解

上周,jQuery 1.9发布。 ? 这是2.0版之前的最后一个新版本,有很多新功能,其中一个就是支持Source Map。 访问 http://ajax.go...

3435

扫码关注云+社区

领取腾讯云代金券