Question

这是我的代码行：

  new (getDefinitionByName(String( "mypackage.MyDynamicClass"  )) as Class) ;

这会产生错误：mypackage.MyDynamicClass未定义。

我用Google搜索并找到了解决方案：在import语句中使用该类的名称。

所以，

  import mypackage.MyDynamicClass 
  new (getDefinitionByName(String( "mypackage.MyDynamicClass"  )) as Class) ;

它奏效了!!!

但是，我对这个解决方案并不满意，因为它确实违反了动态类的好处。如果我知道类的名称（导入），那么为什么我会将它用作字符串？

使动态加载类的任何替代方法都有效吗？

Vishwas

Answer 1

看一下这篇文章：http://blogs.adobe.com/cantrell/archives/2010/09/loading-classes-dynamically-in-actionscript-3.html 您无法避免在运行时包含所需的类。您可以随时使用：

import mypackage.*

请注意，包括包中的所有类可能会增加代码大小。

Answer 2

它肯定没有违反Class的动态加载，因为我们的编译器在我们的项目中检测未使用的类/ import语句然后去掉那些打包为swc或swf的类文件，因此我们的最终输出文件大小的优势可以减少。 / p>

除非几次无法减小文件大小。

在确保IncludeClass.as

中可用的类之前，您可能知道通过getDefinitionByName（）尝试加载的类是什么

为了更好的方法，您可以为项目导入语句

package
{
    public class IncludeClasses
    {
        import com.abc.db.Database; Database;
        import com.abc.RemoteLogTarget; RemoteLogTarget;
        import com.abc.LocalLogTarget; LocalLogTarget;
        import com.abc.exception.GlobalExceptionHandler; GlobalExceptionHandler;
        import com.abc.utils.NetConnectionMonitor; NetConnectionMonitor;
    }
}

您希望更好地使用您的方式，您可以尝试使用编译器选项。

Answer 3

我建议您使用抽象工厂 http://en.wikipedia.org/wiki/Abstract_factory_pattern 它是一种非常灵活的方式来创建对象，而不需要知道要实例化的类。

在这个抽象的工厂类中你将需要导入你可能创建对象的所有clases，这不需要你导入主类中的所有clases但是你仍然需要导入抽象工厂和用于与新对象通信的界面。

这是一个简单的例子：

/*
The interface you will use to communicate with your objects
*/
InterfaceForAllMyClasses.as
public interface InterfaceForAllMyClasses
{
    public function callMe();
    public function callMe2();
}

/*
Your Classes wich implement the interface
*/
Class1.as
import mypackage.InterfaceForAllMyClasses;
public class Class1 implements InterfaceForAllMyClasses
{
    public function callMe() { trace("called Class1"); }
    public function callMe2() { trace("called Class1 too"); }
}

Class2.as
import mypackage.InterfaceForAllMyClasses;
public class Class1 implements InterfaceForAllMyClasses
{
    public function callMe() { trace("called Class2"); }
    public function callMe2() { trace("called Class2 too"); }
}

/*
The Abstract Factory
*/
AbstractFactory.as
import mypackage.InterfaceForAllMyClasses;
public class AbstractFactory
{
    public function giveMeObject(classNumber:Number):InterfaceForAllMyClasses
    {
        switch(classNumber)
        {
            case 0: return(new Class1()); break;
            case 1: return(new Class2()); break;
            // for any new class that you add you must add a case entry here
        }
    }
}

/*
Your Program
*/
import mypackage.InterfaceForAllMyClasses;
import mypackage.AbstractFactory;
MyProgram.as
public class MyProgram
{
    var abstractFactory:AbstractFactory = new AbstractFactory();

    public function main()
    {
        var x:InterfaceForAllMyClasses=AbstractFactory.giveMeObject(0);
        var y:InterfaceForAllMyClasses=AbstractFactory.giveMeObject(1);

        x.callMe();
        x.callMe2();
        y.callMe();
        y.callMe2();        
    }
}

如果您无法从主应用程序导入类，因为它们是在外部模块（swfs）中声明的，那么您可以将每个模块设置为抽象工厂，这是一个示例：

Interfaces/IModuleInterface.as

package Interfaces
    {
        public interface IModuleInterface
        {
            function giveMeObject(classNumber:Number):IObjectInterface;
        }
    }

Interfaces/IObjectInterface.as

package Interfaces
    {
        public interface IObjectInterface
        {
            function callMe():void;
            function callMeToo():void;
        }
    }

Modules/ModuleOne.mxml

    <?xml version="1.0" encoding="utf-8"?>
    <s:Module xmlns:fx="http://ns.adobe.com/mxml/2009" 
      xmlns:s="library://ns.adobe.com/flex/spark" 
      xmlns:mx="library://ns.adobe.com/flex/mx" width="400" height="300"         implements="Interfaces.IModuleInterface">
        <fx:Script>
            <![CDATA[
                import Interfaces.IObjectInterface;
                public function giveMeObject(classNumber:Number):IObjectInterface
                {
                    switch(classNumber)
                    {
                        case 1:
                            trace("ModuleOne: Instantiating 1");
                            return(new ModuleOneClassOne()); 
                            break;
                        case 2:
                            trace("ModuleOne: Instantiating 2");
                            return(new ModuleOneClassTwo()); 
                            break;
                    }
                    return(null);
                }
            ]]>
        </fx:Script>
        <fx:Declarations>
            <!-- Place non-visual elements (e.g., services, value objects) here -->
        </fx:Declarations>
        <s:Label x="10" y="10" text="Module One Loaded"/>
    </s:Module>

Modules/ModuleOneClassOne.as

    package Modules
    {
        import Interfaces.IObjectInterface;

        public class ModuleOneClassOne implements IObjectInterface
        {
            public function ModuleOneClassOne()
            {
                trace("ModuleOneClassOne: Instantiated");
            }

            public function callMe():void
            {
                trace("ModuleOneClassOne: called callMe()");
            }

            public function callMeToo():void
            {
                trace("ModuleOneClassOne: called callMeToo()");
            }
        }
    }

Modules/ModuleOneClassTwo.as

    package Modules
    {
        import Interfaces.IObjectInterface;

        public class ModuleOneClassTwo implements IObjectInterface
        {
            public function ModuleOneClassTwo()
            {
                trace("ModuleOneClassTwo: Instantiated");
            }

            public function callMe():void
            {
                trace("ModuleOneClassTwo: called callMe()");
            }

            public function callMeToo():void
            {
                trace("ModuleOneClassTwo: called callMeToo()");
            }
        }
    }

AbstractFactoryInModules.mxml

    <?xml version="1.0" encoding="utf-8"?>
    <s:WindowedApplication xmlns:fx="http://ns.adobe.com/mxml/2009"
                   xmlns:s="library://ns.adobe.com/flex/spark"
                   xmlns:mx="library://ns.adobe.com/flex/mx"
                   width="345" height="200">

        <fx:Script>
            <![CDATA[
                import Interfaces.IModuleInterface;
                import Interfaces.IObjectInterface;

                import mx.events.ModuleEvent;
                protected var module:IModuleInterface;
                protected var object:IObjectInterface;

                protected function ButtonLoadSwf_clickHandler(event:MouseEvent):void
                {
                    loader.unloadModule();
                    loader.url=moduleUrl.text;
                }

                protected function loader_readyHandler(event:ModuleEvent):void
                {
                    this.module = (loader.child) as IModuleInterface;
                }

                protected function ButtonCreateObject_clickHandler(event:MouseEvent):void
                {
                    this.object = this.module.giveMeObject(Number(TClassNumber.text));
                }

                protected function BCallMe_clickHandler(event:MouseEvent):void
                {
                    this.object.callMe();
                }

                protected function BCallMeToo_clickHandler(event:MouseEvent):void
                {
                    this.object.callMeToo();
                }
            ]]>
        </fx:Script>

        <fx:Declarations>
            <!-- Place non-visual elements (e.g., services, value objects) here -->
        </fx:Declarations>
        <s:Button id="ButtonLoadSwf" x="236" y="10" width="99" label="Load SWF"
                  click="ButtonLoadSwf_clickHandler(event)"/>
        <s:Button id="ButtonCreateObject" x="150" y="108" label="Create Object"
                  click="ButtonCreateObject_clickHandler(event)"/>
        <s:TextInput id="TClassNumber" x="96" y="107" width="46" text="1"/>
        <s:ModuleLoader x="10" y="39" width="325" height="60" id="loader" ready="loader_readyHandler(event)">
        </s:ModuleLoader>
        <s:TextInput id="moduleUrl" x="10" y="10" width="218" text="Modules/ModuleOne.swf"/>
        <s:Button id="BCallMe" x="96" y="137" width="150" label="callMe"
                  click="BCallMe_clickHandler(event)"/>
        <s:Button id="BCallMeToo" x="96" y="166" width="150" label="callMeToo"
                  click="BCallMeToo_clickHandler(event)"/>
    </s:WindowedApplication>

正确使用getDefinitionByName

3 个答案: