精华内容
下载资源
问答
  • spring.jar是包含有完整发布单个jar,spring.jar中包含除了 spring-mock.jar里所包含内容... 除了spring.jar文件,Spring还包括有其它13个独立jar,各自包含着对应Spring组件,用户可以根据自己需要...
    spring.jar是包含有完整发布的单个jar包,spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容,因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试,正式应用系统中是用不得这些类的。
      除了spring.jar文件,Spring还包括有其它13个独立的jar包,各自包含着对应的Spring组件,用户可以根据自己的需要来选择组合自己的jar包,而不必引入整个spring.jar的所有类文件。

    注:spring3开始jar包不再包含全能的spring.jar了,而是分成20多个jar包了,配置可以按需引入了

    (1) spring-core.jar

    这个jar文件包含Spring框架基本的核心工具类,Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心,当然你也可以在自己的应用系统中使用这些工具类。

    (2) spring-beans.jar

    这个jar文件是所有应用都要用到的,它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection(IoC/DI)操作相关的所有类。如果应用只需基本的IoC/DI支持,引入spring-core.jar及spring- beans.jar文件就可以了。

    (3) spring-aop.jar

    这个jar文件包含在应用中使用Spring的 AOP特性时所需的类。使用基于AOP的Spring特性,如声明型事务管理(Declarative Transaction Management),也要在应用里包含这个jar包。

    (4) spring-context.jar

      这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类,JDNI所需的全部类,UI方面的用来与模板(Templating)引擎如 Velocity、FreeMarker、JasperReports集成的类,以及校验Validation方面的相关类。

    (5) spring-dao.jar

      这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持,还需在自己的应用里包含spring-aop.jar。

    (6) spring-hibernate.jar

      这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。

    (7) spring-jdbc.jar

      这个jar文件包含对Spring对 JDBC数据访问进行封装的所有类。

    (8) spring-orm.jar

      这个jar文件包含Spring对 DAO特性集进行了扩展,使其支持 iBATIS、JDO、OJB、TopLink,因为Hibernate已经独立成包了,现在不包含在这个包里了。这个jar文件里大部分的类都要依赖 spring-dao.jar里的类,用这个包时你需要同时包含spring-dao.jar包。

    (9) spring-remoting.jar

      这个jar文件包含支持EJB、JMS、远程调用Remoting(RMI、 Hessian、Burlap、Http Invoker、JAX-RPC)方面的类。

    (10) spring-support.jar

      这个jar文件包含支持缓存Cache(ehcache)、JCA、JMX、邮件服务(Java Mail、COS Mail)、任务计划Scheduling(Timer、Quartz)方面的类。

    (11) spring-web.jar

      这个jar文件包含Web应用开发时,用到Spring框架时所需的核心类,包括自动载入WebApplicationContext特性的类、 Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。

    (12) spring-webmvc.jar

    这个jar文件包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、Tiles、Velocity、 XSLT相关类。当然,如果你的应用使用了独立的MVC框架,则无需这个JAR文件里的任何类。

    (13) spring-mock.jar

      这个jar文件包含Spring一整套mock类来辅助应用的测试。Spring测试套件使用了其中大量mock类,这样测试就更加简单。模拟HttpServletRequest和HttpServletResponse类在Web应用单元测试是很方便的。

      如何选择这些发布包,决定选用哪些发布包其实相当简单。如果你正在构建Web应用并将全程使用Spring,那么最好就使用单个全部的 spring.jar文件;如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection(IoC/DI)容器,那么只需spring-core.jar与spring-beans.jar即可;如果你对发布的大小要求很高,那么就得精挑细选了,只取包含自己所需特性的jar文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小,节省空间的重点在于准确地找出自己所需的Spring依赖类,然后合并所需的类与包就可以了。Eclispe有个插件叫 ClassPath Helper可以帮你找找所依赖的类。

    Spring包依赖说明:

    1) spring-core.jar需commons-collections.jar,spring-core.jar是以下其它各个的基本。

    2) spring-beans.jar需spring-core.jar,cglib-nodep-2.1_3.jar

    3) spring-aop.jar需spring-core.jar,spring-beans.jar,cglib-nodep-2.1_3.jar,aopalliance.jar

    4) spring-context.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,commons-collections.jar,aopalliance.jar

    5) spring-dao.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,spring-context.jar

    6) spring-jdbc.jar需spring-core.jar,spring-beans.jar,spring-dao.jar

    7) spring-web.jar需spring-core.jar,spring-beans.jar,spring-context.jar

    8) spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar

    9) spring -hibernate.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,spring- dao.jar,spring-jdbc.jar,spring-orm.jar,spring-web.jar,spring-webmvc.jar

    10) spring-orm.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,spring- dao.jar,spring-jdbc.jar,spring-web.jar,spring-webmvc.jar

    11) spring -remoting.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,spring- dao.jar,spring-context.jar,spring-web.jar,spring-webmvc.jar

    12) spring-support.jar需spring-core.jar,spring-beans.jar,spring-aop.jar,spring-dao.jar,spring-context.jar,spring-jdbc.jar

    13) spring-mock.jar需spring-core.jar,spring-beans.jar,spring-dao.jar,spring-context.jar,spring-jdbc.jar
    展开全文
  • spring.jar是包含有完整发布单个jar,spring.jar中包含除了 spring-mock.jar里所包含... 除了spring.jar文件,Spring还包括有其它13个独立jar,各自包含着对应Spring组件,用户可以根据自己需要...

    spring.jar是包含有完整发布的单个jar包,spring.jar中包含除了 spring-mock.jar里所包含的内容外其它所有jar包的内容,因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试,正式应用系统中是用不得这些类的。
      除了spring.jar文件,Spring还包括有其它13个独立的jar包,各自包含着对应的Spring组件,用户可以根据自己的需要来选择组合自己的jar包,而不必引入整个spring.jar的所有类文件。

    注:spring3开始jar包不再包含全能的spring.jar了,而是分成20多个jar包了,配置可以按需引入了

    (1) spring-core.jar

    这个jar文件包含Spring框架基本的核心工具类,Spring其它组件要都要使用到这个包里的类,是其它组件的基本核心,当然你也可以在自己的应用系统中使用这些工具类。

    (2) spring-beans.jar

    这个jar文件是所有应用都要用到的,它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency InjectionIoC/DI)操作相关的所有类。如果应用只需基本的IoC/DI支持,引入spring-core.jarspring- beans.jar文件就可以了。

    (3) spring-aop.jar

    这个jar文件包含在应用中使用Spring AOP特性时所需的类。使用基于AOPSpring特性,如声明型事务管理(Declarative Transaction Management),也要在应用里包含这个jar包。

    (4) spring-context.jar

      这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类,JDNI所需的全部类,UI方面的用来与模板(Templating)引擎如 VelocityFreeMarkerJasperReports集成的类,以及校验Validation方面的相关类。

    (5) spring-dao.jar

      这个jar文件包含Spring DAOSpring Transaction进行数据访问的所有类。为了使用声明型事务支持,还需在自己的应用里包含spring-aop.jar

    (6) spring-hibernate.jar

      这个jar文件包含SpringHibernate 2Hibernate 3进行封装的所有类。

    (7) spring-jdbc.jar

      这个jar文件包含对Spring JDBC数据访问进行封装的所有类。

    (8) spring-orm.jar

      这个jar文件包含Spring DAO特性集进行了扩展,使其支持 iBATISJDOOJBTopLink,因为Hibernate已经独立成包了,现在不包含在这个包里了。这个jar文件里大部分的类都要依赖 spring-dao.jar里的类,用这个包时你需要同时包含spring-dao.jar包。

    (9) spring-remoting.jar

      这个jar文件包含支持EJBJMS、远程调用RemotingRMI HessianBurlapHttp InvokerJAX-RPC)方面的类。

    (10) spring-support.jar

      这个jar文件包含支持缓存Cacheehcache)、JCAJMX、邮件服务(Java MailCOS Mail)、任务计划SchedulingTimerQuartz)方面的类。

    (11) spring-web.jar

      这个jar文件包含Web应用开发时,用到Spring框架时所需的核心类,包括自动载入WebApplicationContext特性的类、 StrutsJSF集成类、文件上传的支持类、Filter类和大量工具辅助类。

    (12) spring-webmvc.jar

    这个jar文件包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarkerJasperReportsTilesVelocity XSLT相关类。当然,如果你的应用使用了独立的MVC框架,则无需这个JAR文件里的任何类。

    (13) spring-mock.jar

      这个jar文件包含Spring一整套mock类来辅助应用的测试。Spring测试套件使用了其中大量mock类,这样测试就更加简单。模拟HttpServletRequestHttpServletResponse类在Web应用单元测试是很方便的。

      如何选择这些发布包,决定选用哪些发布包其实相当简单。如果你正在构建Web应用并将全程使用Spring,那么最好就使用单个全部的 spring.jar文件;如果你的应用仅仅用到简单的Inversion of Control / Dependency InjectionIoC/DI)容器,那么只需spring-core.jarspring-beans.jar即可;如果你对发布的大小要求很高,那么就得精挑细选了,只取包含自己所需特性的jar文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小,节省空间的重点在于准确地找出自己所需的Spring依赖类,然后合并所需的类与包就可以了。Eclispe有个插件叫 ClassPath Helper可以帮你找找所依赖的类。

    Spring包依赖说明:

    1) spring-core.jarcommons-collections.jarspring-core.jar是以下其它各个的基本。

    2) spring-beans.jarspring-core.jarcglib-nodep-2.1_3.jar

    3) spring-aop.jarspring-core.jarspring-beans.jarcglib-nodep-2.1_3.jaraopalliance.jar

    4) spring-context.jarspring-core.jarspring-beans.jarspring-aop.jarcommons-collections.jaraopalliance.jar

    5) spring-dao.jarspring-core.jarspring-beans.jarspring-aop.jarspring-context.jar

    6) spring-jdbc.jarspring-core.jarspring-beans.jarspring-dao.jar

    7) spring-web.jarspring-core.jarspring-beans.jarspring-context.jar

    8) spring-webmvc.jarspring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar

    9) spring -hibernate.jarspring-core.jarspring-beans.jarspring-aop.jarspring- dao.jarspring-jdbc.jarspring-orm.jarspring-web.jarspring-webmvc.jar

    10) spring-orm.jarspring-core.jarspring-beans.jarspring-aop.jarspring- dao.jarspring-jdbc.jarspring-web.jarspring-webmvc.jar

    11) spring -remoting.jarspring-core.jarspring-beans.jarspring-aop.jarspring- dao.jarspring-context.jarspring-web.jarspring-webmvc.jar

    12) spring-support.jarspring-core.jarspring-beans.jarspring-aop.jarspring-dao.jarspring-context.jarspring-jdbc.jar

    13) spring-mock.jarspring-core.jarspring-beans.jarspring-dao.jarspring-context.jarspring-jdbc.jar

     

     

    原文出处:http://blog.csdn.net/huiwenjie168/article/details/8477837

    展开全文
  • Unity5.x虽然说打包时会处理好资源的依赖关系,但前提依然要我们设置好目标资源的AssetBundleName,如果设置资源AssetBundleName时忽略了资源之间的依赖关系,那么打包AssetBundle时,依然会产生重复打包的资源,...

    前提说明:

    • 本文只是针对Unity5.x及以上版本打包AssetBundle。Unity5.x虽然说打包时会处理好资源的依赖关系,但前提依然要我们设置好目标资源的AssetBundleName,如果设置资源AssetBundleName时忽略了资源之间的依赖关系,那么打包AssetBundle时,依然会产生重复打包的资源,所以我写了一套脚本来自动分析资源的依赖关系,并根据资源的依赖关系来设置AssetBundleName,从而避免不必要的资源重复打包。
      我也了解过,
      Unity的AssetStore也有对应的图形界面工具,查看和处理打包AssetBundle时遇到的资源重复打包问题,但觉得图形化界面工具还得人工查看和修改,如果项目大了,一千多个ab甚至几千个ab,那么每次更新资源时去查看哪里存在依赖那也挺累得,效率不高,并且手动修正难说说没有看漏改漏。所以,不如来套脚本搞它一把,提高工作效率和质量。

    我用的是Unity5.3.6。

    前提有点特殊的是Unity的UGUI图集打包,Unity的官网有介绍如何将UGUI图集正确打成AssetBundle(但我现在翻回去找不到链接了= =。),简单说下:
    首先,UGUI是有图集的。
    我的UGUI图集打包AssetBundle方式是,每张图集打成一个AssetBundle,所以我这里保证了每张UI图片的PackingTag和自己的AssetBundleName一样。原因,如果AssetBundleName不一样,那么这张UI图片后面所打成的AssetBundle包将会扯带了整张图集的内容,这张图集别的UI图片也在用啊,却被无辜包含进了这个ab包。所以通过保证UI图片的PackingTag==AssetBundleName来保证每张图集只存在一个AssetBundle,保证图集不被重复打包。

    怎么分析资源的依赖关系呢,并设置AssetBundleName呢?
    我们检测资源之间的依赖关系,遍历每一个有引用的资源进行分析,对于非UGUI的图集资源(UGUI图集上面说了),如果此资源A被其他地方资源B引用仅仅1次,那么就将此资源A的AssetBundleName置空不设置,这样打包时,此资源就会自动被和资源B打到一起合成一个AssetBundle包,如此减少打包的碎片。如果资源A被引用超过2次及以上,那么就为资源独立设置AssetBundleName,从而避免被重复打包到几个依赖它的资源包。
    这里所说的资源被依赖超过2次就独立打包,如果觉得碎片化太严重,产生太多AssetBundle文件,也可以设置成n(n>=1)次才独立打包,开心就好。

    资源依赖处理的代码构建思路:
    这里写图片描述
    其实资源之间的依赖关系,就是一个树形依赖关系,只要能构建出资源之间的依赖树,那么就能了解到某个资源被多少颗树引用,也就是被多少个资源引用,从而对症下药,自然能合理设置AssetBundleName。

    然后有代码LoaderManager.cs和ABInfo.cs。
    注意:一定要放在Editor文件夹下!!

    LoaderManager.cs

    using UnityEngine;
    using System.Collections;
    using System.IO;
    using UnityEditor;
    using System.Collections.Generic;
    
    public class LoaderManager {
    
        static Dictionary<string, AssetInfo> assetInfoDict = new Dictionary<string, AssetInfo>();
    
        private static string curRootAsset = string.Empty;
        private static float curProgress = 0f;
    
    
        [MenuItem("AssetBundleMgr / SetAssetbundleName")]
        static void SetABNames()
        {
            string path = GetSelectedAssetPath();
            if (path == null)
            {
                Debug.LogWarning("请先选择目标文件夹");
                return;
            }
            LoaderManager.GetAllAssets(path);
    
        }
        [MenuItem("AssetBundleMgr / ClearAllAssetbundelname")]
        static void CleaarAllABNames()
        {
            string[] abnames = AssetDatabase.GetAllAssetBundleNames();
            foreach (var n in abnames)
            {
                AssetDatabase.RemoveAssetBundleName(n, true);
            }
        }
    
        public static void GetAllAssets(string rootDir) {
            assetInfoDict.Clear();
    
            DirectoryInfo dirinfo = new DirectoryInfo(rootDir);
            FileInfo[] fs = dirinfo.GetFiles("*.*", SearchOption.AllDirectories);
            int ind = 0;
            foreach (var f in fs)
            {
                curProgress = (float)ind / (float)fs.Length;
                curRootAsset = "正在分析依赖:"+f.Name;
                EditorUtility.DisplayProgressBar(curRootAsset, curRootAsset, curProgress);
                ind++;
                int index = f.FullName.IndexOf("Assets");
                if (index != -1)
                {
                    string assetPath = f.FullName.Substring(index);
                    Object asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
                    string upath = AssetDatabase.GetAssetPath(asset);
                    if (assetInfoDict.ContainsKey(assetPath) == false
                        && assetPath.StartsWith("Assets")
                        && !(asset is MonoScript)
                        && !(asset is LightingDataAsset)
                        && asset != null
                        ) {
                        AssetInfo info = new AssetInfo(upath, true);
                        //标记一下是文件夹下根资源
                        CreateDeps(info);
                    }
                    EditorUtility.UnloadUnusedAssetsImmediate();
                }
                EditorUtility.UnloadUnusedAssetsImmediate();
            }
            EditorUtility.ClearProgressBar();
    
            int setIndex = 0;
            foreach (KeyValuePair<string, AssetInfo> kv in assetInfoDict) {
                EditorUtility.DisplayProgressBar("正在设置ABName", kv.Key, (float)setIndex/(float)assetInfoDict.Count);
                setIndex++;
                AssetInfo a = kv.Value;
                a.SetAssetBundleName(2);
            }
            EditorUtility.ClearProgressBar();
            EditorUtility.UnloadUnusedAssetsImmediate();
            AssetDatabase.SaveAssets();
        }
        /// <summary>
        /// 递归分析每个所被依赖到的资源
        /// </summary>
        /// <param name="self"></param>
        /// <param name="parent"></param>
        static void CreateDeps(AssetInfo self, AssetInfo parent = null) {
            if (self.HasParent(parent))
                return;
            if (assetInfoDict.ContainsKey(self.assetPath) == false) {
                assetInfoDict.Add(self.assetPath, self);
            }
            self.AddParent(parent);
    
            Object[] deps = EditorUtility.CollectDependencies(new Object[] { self.GetAsset() });
            for (int i = 0; i < deps.Length; i++) {
                Object o = deps[i];
                if (o is MonoScript || o is LightingDataAsset)
                    continue;
                string path = AssetDatabase.GetAssetPath(o);
                if (path == self.assetPath)
                    continue;
                if (path.StartsWith("Assets") == false)
                    continue;
                AssetInfo info = null;
                if (assetInfoDict.ContainsKey(path))
                {
                    info = assetInfoDict[path];
                }
                else {
                    info = new AssetInfo(path);
                    assetInfoDict.Add(path, info);
                }
                EditorUtility.DisplayProgressBar(curRootAsset, path, curProgress);
                CreateDeps(info, self);
            }
            EditorUtility.UnloadUnusedAssetsImmediate();
        }
    
        static string GetSelectedAssetPath()
        {
            var selected = Selection.activeObject;
            if (selected == null)
            {
                return null;
            }
            Debug.Log(selected.GetType());
            if (selected is DefaultAsset)
            {
                string path = AssetDatabase.GetAssetPath(selected);
                Debug.Log("选中路径: " + path);
                return path;
            }
            else
            {
                return null;
            }
        }
    }
    
    

    ABInfo.cs

    using UnityEngine;
    using System.Collections;
    using UnityEditor;
    using System.Collections.Generic;
    
    public class AssetInfo
    {
    
        //是不是被打包文件夹下的直接资源
        private bool isRootAsset = false;
    
        public string assetPath { get; private set; }
    
        private HashSet<AssetInfo> childSet = new HashSet<AssetInfo>();
        private HashSet<AssetInfo> parentSet = new HashSet<AssetInfo>();
    
        public AssetInfo(string assetPath, bool isRootAsset = false)
        {
            this.assetPath = assetPath;
        }
        public Object GetAsset()
        {
            Object asset = AssetDatabase.LoadMainAssetAtPath(assetPath);
            return asset;
        }
        /// <summary>
        /// 从这里开始分析构建资源依赖树
        /// </summary>
        /// <param name="parent"></param>
        public void AddParent(AssetInfo parent)
        {
            if (parent == this || IsParentEarlyDep(parent) || parent == null)
                return;
    
            parentSet.Add(parent);
            parent.AddChild(this);
    
            parent.RemoveRepeatChildDep(this);
            RemoveRepeatParentDep(parent);
        }
        /// <summary>
        /// 清除我父节点对我子节点的重复引用,保证树形结构
        /// </summary>
        /// <param name="targetParent"></param>
        private void RemoveRepeatChildDep(AssetInfo targetChild)
        {
    
            List<AssetInfo> infolist = new List<AssetInfo>(parentSet);
            for (int i = 0; i < infolist.Count; i++)
            {
                AssetInfo pinfo = infolist[i];
                pinfo.RemoveChild(targetChild);
                pinfo.RemoveRepeatChildDep(targetChild);
            }
        }
        /// <summary>
        /// 清除我子节点被我父节点的重复引用,保证树形结构
        /// </summary>
        /// <param name="targetChild"></param>
        private void RemoveRepeatParentDep(AssetInfo targetParent)
        {
    
            List<AssetInfo> infolist = new List<AssetInfo>(childSet);
            for (int i = 0; i < infolist.Count; i++)
            {
                AssetInfo cinfo = infolist[i];
                cinfo.RemoveParent(targetParent);
                cinfo.RemoveRepeatParentDep(targetParent);
            }
        }
    
        private void RemoveChild(AssetInfo targetChild)
        {
            childSet.Remove(targetChild);
            targetChild.parentSet.Remove(this);
        }
        private void RemoveParent(AssetInfo parent)
        {
            parent.childSet.Remove(this);
            parentSet.Remove(parent);
        }
    
    
        private void AddChild(AssetInfo child)
        {
            childSet.Add(child);
        }
    
        /// <summary>
        /// 如果父节点早已当此父节点为父节点
        /// </summary>
        /// <param name="targetParent"></param>
        /// <returns></returns>
        private bool IsParentEarlyDep(AssetInfo targetParent)
        {
            if (parentSet.Contains(targetParent))
            {
                return true;
            }
            var e = parentSet.GetEnumerator();
            while (e.MoveNext())
            {
                if (e.Current.IsParentEarlyDep(targetParent))
                {
                    return true;
                }
            }
            return false;
        }
        public bool HasParent(AssetInfo p)
        {
            if (parentSet.Contains(p))
                return true;
            return false;
        }
        /// <summary>
        /// 打包碎片粒度
        /// </summary>
        /// <param name="pieceThreshold"></param>
        public void SetAssetBundleName(int pieceThreshold)
        {
            AssetImporter ai = AssetImporter.GetAtPath(this.assetPath);
            //针对UGUI图集的处理,图集以文件夹为单位打包ab
            if (ai is TextureImporter)
            {
                TextureImporter tai = ai as TextureImporter;
    
                string filePath = System.IO.Path.GetDirectoryName(this.assetPath);
                tai.spritePackingTag = filePath.ToLower().Replace("\\", "_").Replace(".png",string.Empty).Replace(".jpg", string.Empty).Replace(" ", string.Empty);
                
                //AssetBundleName和spritePackingTag保持一致
                tai.SetAssetBundleNameAndVariant(tai.spritePackingTag + ".ab", null);
                Debug.Log("<color=#2E8A00>" + "设置ab,Image资源: " + this.assetPath + "</color>");
            }
            else
            {
                string abname = this.assetPath.Replace("/", "_") + ".ab";
                //不是图集,而且大于阀值
                if (this.parentSet.Count >= pieceThreshold)
                {
                    ai.SetAssetBundleNameAndVariant(abname, string.Empty);
                    Debug.Log("<color=#6501AB>" + "设置ab,有多个引用: " + this.assetPath+"</color>");
                }
                //根节点
                else if (this.parentSet.Count == 0 || this.isRootAsset)
                {
                    ai.SetAssetBundleNameAndVariant(abname, string.Empty);
                    Debug.Log("<color=#025082>" + "设置ab,根资源ab: " + this.assetPath + "</color>");
                }
                else
                {
                    //其余的子资源
                    ai.SetAssetBundleNameAndVariant(string.Empty, string.Empty);
                    Debug.Log("<color=#DBAF00>" + "清除ab, 仅有1个引用: " + this.assetPath + "</color>");
                }
            }
        }
    }
    
    
    

    用法:
    1,选择Unity内我们所要打包的资源所在的文件夹;
    2,菜单栏“AssetBundleMgr->SetAssetbundleName”,完成!看一下资源的AssetBundleName。

    如:我选择了Prefabs文件夹,然后菜单栏“AssetBundleMgr->SetAssetbundleName”,资源都被正确设置了AssetBundleName。

    这里写图片描述

    展开全文
  • 类间的关系包括关联、继承、聚合、组合、依赖和实现。这里没有去深究泛化和继承细微区别哈哈,此处默认泛化就是继承。 继承 一个类(子类、子接口)继承另外一个类(父类、父接口)功能,并可以增加它自己新...

    前言

    类图是使用频率最高的UML图之一,主要用于描述系统中所包含的类以及它们之间的相互关系,帮助开发人员理解系统,它是系统分析和设计阶段的重要产物,也是系统编码和测试的重要模型依据。
    类间的关系包括关联、继承、聚合、组合、依赖和实现。这里没有去深究泛化和继承的细微区别哈哈,此处默认泛化就是继承。

    继承(Generalization)

    一个类(子类、子接口)继承另外的一个类(父类、父接口)的功能,并可以增加它自己的新功能的能力,如果几个类存在部分相同功能,此时就可以抽象出一个父类来,将相同的部分由父类实现,让他们都继承这个类。继承是通过部分相同的功能,实现不同的结果
    表现形式:实线加空心箭头
    在这里插入图片描述

    实现(Realization)

    实现关系用于定义接口和实现接口的类间关系,为什么要有接口?如果几个类对外处理的结果是一致的,但得到这种结果的方式不一样,此时就可以定义一个统一的接口,让这几个类都以自己的方式来实现,我们称这种方式为接口处理。所以,接口由子类自定义实现的过程就体现了一种“实现”关系。
    表现形式:虚线加空心箭头
    在这里插入图片描述

    组合(Composition)

    组合和聚合都是讨论一个类由其他类构成的情况,是一种整体和部分的关系。组合是一种很强的关系,部分对象的创建、存在、和消亡都是和整体一起的,所谓同生共死的关系,比如ATM机由读卡器、吐钞器、凭条打印等组成,他们就构成一个组合关系,创建一个ATM机类对象,就必须构造读卡器对象。
    表现形式:实线加实心棱形
    在这里插入图片描述

    聚合(Aggregation)

    组合和聚合都是讨论一个类由其他类构成的情况,是一种整体和部分的关系。聚合相较于组合,关系要弱一些,但也是整体和部分的关系,并非同生共死,部分实例可以添加到聚合整体,也可以从聚合整体中移出。比如大学里的学院,其部分包括:管理办公室、系和研究中心,系可以创建和撤销,研究中心也可以独立于学院而存在。
    表现形式:实线加空心棱形
    在这里插入图片描述

    关联(Association)

    关联关系是一种在语义级别的强依赖关系,相较与依赖的偶然性、临时性,关联是长期的、平等的。关联可以是单向,也可以是双向的。
    表现形式:无箭头线段 在这里插入图片描述

    依赖(Dependency)

    一个类A使用到了另一个类B,但是这种使用关系是具有偶然性的、临时性的、非常弱的,但是类B的变化会影响到类A,通常,类B作为类A的方法的参数(或者局部变量)存在。
    表现形式:虚线加箭头
    在这里插入图片描述

    总结

    类之间的关系强弱表现为:继承 > 实现 > 组合 > 聚合 > 关联 > 依赖。各种关系之间并不是有非常明确的界限,要根据实际场景去确定类之间的关系。
    关联和依赖的区别:关联关系主要通过属性来实现,依赖则通过函数参数或局部变量来实现。关联是更强,长期的关系。
    聚合和组合的异同:都是整体和部分的关系,但组合更强,组合部分的生命周期同整体。

    展开全文
  • 两个类之间的关系一般包括关联、聚合、泛化和依赖,还有实现关系。   1.关联  当两个类之间在概念上有连接关系时,类之间的连接成为关联。关联关系描述给定类的对象之间语义上的连接,它提供了不同类的对象可以...
  • Spring整体架构和jar包依赖关系详解

    千次阅读 2017-04-09 18:42:07
    想对spring框架进行深入的学习一下,看看源代码,先了解下Spring的整体架构以及各模块之间的关系。 在介绍整体架构之前,我们先来聊聊大家关于Spring,熟悉的模块有哪些,还有哪些不熟悉的模块。 作为优秀的开源...
  • 函数依赖关系学习

    2017-05-16 11:29:00
    函数依赖只分析关系中的非主属性对主属性之间的依赖关系,并不分析主属性对主键(码)的依赖关系。 假设存在关系:R(学号,姓名,性别,班级,班主任,课程号,课程名,学时数,成绩)  主键是:学号+课程号  ...
  • Spark_5 RDD依赖关系

    2019-07-12 20:36:12
    RDD依赖关系Lineage窄依赖与宽依赖窄依赖宽依赖宽依赖与窄依赖在应用上区别DAG任务划分 RDDs 通过操作算子进行转换,转换得到新 RDD 包含了从其他 RDDs 衍生所必需信息,RDDs 之间维护着这种血缘关系,也称之...
  • 题目描述 ...但是现在有个问题:软件之间存在依赖关系,即软件i只有在安装了软件j(包括软件j直接或间接依赖)情况下才能正确工作(软件i依赖软件j)。幸运 是,一个软件最多依赖另外一个...
  • 浅谈UML类图中类之间的5种关系

    千次阅读 2018-05-15 09:38:40
    类加上他们之间的关系就构成了类图,类图中还可以包含接口、等元素,也可以包括对象、链等实例。 类与类之间的关系 类与类之间的关系可以根据关系的强度依次分为以下五种: 依赖关系(Dependency)—关联...
  • 继承关系继承关系包括子类和父类、子接口和父接口之间两种继承关系。用空心三角形和实线表示这种继承关系。 实现关系类和接口之间的关系,用空心三角形和虚线表示。依赖关系依赖关系:A类会用到B类,这种关系具有...
  • 常见的类与类之间的关系包括:关联关系、依赖关系、泛化关系(即继承关系)、接口与实现关系。1.关联关系关联关系通常用来表示一种包含(contains)或者有(has)的关系。contains与has的区别,我的理解是一种表达...
  • 依赖(Dependency) 实体之间一个“使用”关系暗示一个实体的规范发生变化后,可能影响依赖于它的其他实例(图D)。 更具体地说,它可转换为对...也可利用“依赖”来表示和包之间的关系。由于包中含有类,所以你可
  • 一、Conda简介(简介部分翻译自官方文档)Conda是一个开源管理系统和环境管理系统,用于安装多个版本软件包及其依赖关系,并在它们之间切换。Conda发行版包括Anaconda和Miniconda。Conda在pypi中也是可用,...
  • 2427: [HAOI2010]软件安装Time Limit: 10 Sec Memory Limit: 128 MB Description现在我们手头有N个软件,对于一个软件i,它要占用Wi...但是现在有个问题:软件之间存在依赖关系,即软件i只有在安装了软件j(包括
  • (上不了p站我要死了,侵权度娘背锅) Description ... 但是现在有个问题:软件之间存在依赖关系,即软件i只有在安装了软件j(包括软件j直接或间接依赖)情况下才能正确工作(软件i依赖软件j)。
  • 但是现在有个问题:软件之间存在依赖关系,即软件i只有在安装了软件j(包括软件j直接或间接依赖)情况下才能正确工作(软件i依赖软件j)。幸运是,一个软件最多依赖另外一个软件。如果一个...
  • 前言 在上一篇博客中,主要是写的关于如何通过坐标的方式,在互联网中精准定位...因此,对于依赖这个标签而言,仅包括 GAV 这3部分是不够的,还包括其他的部分来应对不同模块之间的依赖调用的关系 引入 提到依赖...
  • 程序包的yum安装

    2015-04-15 19:40:32
    yum是基于C/S架构,需要一个服务器端给我们提供各个程序以及他们之间的依赖关系,当客户端从服务器端下载安装程序时,服务器端会查找元数据信息,包括包的依赖关系,会把依赖的一起下载到客户端安装。...
  • UML中类的关系

    千次阅读 2015-10-09 16:44:27
    UML中类关系  UML中类主要包含了四种关系,包括关联,依赖,泛化,实现,其中... 关联体现是两个类之间语义级别一种强依赖关系,比如我和我朋友,这种关系比依赖更强、不存在 依赖关系的偶然性、关系也不是
  • 类图想必大家都知道了,这里不多解释,但是对于类图间的关系总是弄的模棱俩可,在此做以总结!...也可利用“依赖”来表示和包之间的关系。由于包中含有类,所以你可根据那些包中的各个类之间的关系...
  • 最近已经认识到差异语义(例如,“相似”或“不相似”)的重要性,用于声明各种类型的数据(例如,数值或文本值)之间的依赖性。 我们提出了一种新型的差分依赖关系(dds),它指定了对差异的约束,称为差分函数,而...
  • 越来越碎片化的代码以及代码之间复杂的依赖关系带来诸多维护性问题,较为突出的问题包括:不敢轻易修改或下线对外暴露的接口或组件,因为不知道有什么地方对自己有依赖、会受到影响,于是代码变得臃肿,大小也变得...
  • 更好的可审核性– Libauth的方法不仅没有依赖关系,还使审核关键代码更加容易:更小的捆绑,更小的功能以及版本之间的搅动更少(对面向对象的接口进行级联更改的次数更少)。 完全可移植–从未使用过特定于平台...
  • 而Conda是一个开源软件包管理系统和环境管理系统,用于安装多个版本软件包及其依赖关系,并在它们之间轻松切换。 直接进入正题,本文通过几个最基本命令,来介绍conda如何使用。 创建一个python环境 首...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 509
精华内容 203
关键字:

包之间的依赖关系包括