精华内容
下载资源
问答
  • VS加载外部资源

    2019-10-17 15:46:56
    VS加载外部资源添加.h所在文件夹添加.lib所在文件夹添加.dll所在文件夹联系链接.dll思考 添加.h所在文件夹 项目右键->属性->配置属性->VC++目录->包含目录 加上相应的文件夹之后,项目会自动去这个...

    环境

    分类 版本
    IDE VS2019(其它版本雷同,原理一样)
    语言 C++
    系统 Win10

    添加.h所在文件夹

    1. 项目右键->属性->配置属性->VC++目录->包含目录
      加上相应的文件夹之后,项目会自动去这个文件夹寻找头文件

    添加.lib所在文件夹

    1. 项目右键->属性->配置属性->VC++目录->库目录
      加上相应的文件夹之后,项目会自动去这个文件夹寻找库文件
    2. 添加代码
      #pragma comment(lib, “静态库文件名”)
      例:#pragma comment(lib, “log4cplusD.lib”)

    添加.dll所在文件夹

    1. 项目右键->属性->配置属性->调试->环境
      格式:path=%path%;.\dll所在文件夹
      解释:.\代表当前项目的路径
      注意:千万不要用绝对路径

    三者的联系

    1. 头文件.h
    编译时寻找声明,检查格式
    2. 静态库文件.lib
    编译时检查是否有相应的定义

    可分为两类 如何使用 怎么得到的
    包含了完整定义 和.h一起使用 直接生成的静态库
    仅包含定义的入口 定义的实体在.dll中,所以需要和.h和.dll一起使用 生成.dll时同时获得

    3. 动态库文件.dll

    使用分类 如何使用 备注
    隐式链接 头文件+静态库联合使用 原理参考静态库说明
    显示链接 单独使用,无需头文件和静态库 代码直接调用,需要函数指针和WIN32 API函数LoadLibrary、GetProcAddress装载

    链接.dll

    #include <windows.h>   //使用函数和某些特殊变量
    typedef void (*DLLFunc)(int);  //即将使用的dll中的函数格式
    int main()
    {
            DLLFunc dllFunc;
            HINSTANCE hInstLibrary = LoadLibrary("DLLSample.dll"); //加载动态库
            
            if (hInstLibrary == NULL)
            {
              FreeLibrary(hInstLibrary);
            }
            dllFunc = (DLLFunc)GetProcAddress(hInstLibrary, "TestDLL"); //加载函数
            if (dllFunc == NULL)
            {
              FreeLibrary(hInstLibrary);
            }
            dllFunc(123); 
            std::cin.get();
            FreeLibrary(hInstLibrary);
            return(1);
    }
    

    思考

    包含文件夹为什么dll在调式里,其它两个在VC++目录
    个人猜测:头文件和静态库在编译时便需要,动态库只有在运行时才需要。编译时寻找的目录在VC++里设置,运行时的目录在调试里设置

    展开全文
  • JAVA加载外部资源

    2015-12-30 09:23:19
    JAVA加载外部资源

    在java代码中加载动态资源库时,JNI需要使用System.load/System.loadLibrary其中的一个方法来加载库文件
    。JNA使用Native.loadLibrary

    System.load:可以指定任意路径,但是必须是文件绝对路径
    System.load("C:\\Documents and Settings\\TestJNI.dll"); 
    //Windows
    System.load("/usr/lib/TestJNI.so");

    //Linux
    要载入的库文件静态链接到其它动态链接库,如TestJNI.dll 静态链接到dependency.dll,必须注意:如果你选择System.load(“D:\lib\TestJNI.dll”);那么即使你把dependency.dll同样放在D:\lib下,load还是会因为找不到依赖的dll而失败。
    因为jvm在载入TestJNI.dll会先去载入TestJNI.dll所依赖的库文件dependency.dll,而dependency.dll并不位于java.library.path所指定的目录下,所以jvm找不到dependency.dll。
    你有两个方法解决这个问题:

    一是把D:\\lib加入到java.library.path的路径中。
    二是先调用System.load("D:\\lib\\dependency.dll"); 让jvm先载入dependency.dll,
    然后再调用System.load("D:\\lib\\TestJNI.dll");
    System.loadLibrary: 参数为库文件名,不包含库文件的扩展名。
    那么你只要把dependency.dll放在任何java.library.path包含的路径中即可。
    展开全文
  • Resources 资源加载及引入外部资源

    千次阅读 2019-04-07 22:13:15
    加载res中的资源,都是通过getResources()获取的,但是Resources是在什么时候被创建的呢,如何通过Resources获取到对应的资源的呢? XmlResourceParser layout = getResources().getLayout(R.layout.activity_change...

    Resources 资源加载

    加载res中的资源,都是通过getResources()获取的,但是Resources是在什么时候被创建的呢,如何通过Resources获取到对应的资源的呢?

    XmlResourceParser layout = getResources().getLayout(R.layout.activity_change_skin);
    int color = getResources().getColor(R.color.color_e83b36);
    Drawable drawable = getResources().getDrawable(R.drawable.image_liu);
    

    ContextThemeWrapper的getResources()

    @Override
    public Resources getResources() {
        return getResourcesInternal();
    }
    

    ContextThemeWrapper的getResourcesInternal():

    1. mResources为null,根据mOverrideConfiguration来判断是从ContextImpl类中获取还是创建之后再获取;
    2. mResources不为null,则直接返回;
    private Resources getResourcesInternal() {
        
        if (mResources == null) {
            //为null,则直接从ContextImpl类中获取;
            if (mOverrideConfiguration == null) {
                mResources = super.getResources();
            } else {
                //不为null,则通过ContextImpl类的createConfigurationContext()方法创建;
                final Context resContext = createConfigurationContext(mOverrideConfiguration);
                mResources = resContext.getResources();
            }
        }
        return mResources;
    }
    

    跳过中间的跳转,直接定位到ContextImpl的createConfigurationContext()方法

    @Override
    public Context createConfigurationContext(Configuration overrideConfiguration) {
    	//创建ContextImpl对象;
        ContextImpl context = new ContextImpl(this, mMainThread, mPackageInfo, mSplitName,
                mActivityToken, mUser, mFlags, mClassLoader);
    
        final int displayId = mDisplay != null ? mDisplay.getDisplayId() : Display.DEFAULT_DISPLAY;
        //通过createResources()方法创建Resources对象;并赋值给mResources;
        context.setResources(createResources(mActivityToken, mPackageInfo, mSplitName, displayId,
                overrideConfiguration, getDisplayAdjustments(displayId).getCompatibilityInfo()));
        return context;
    }
    

    ContextImpl的createResources()

    private static Resources createResources(IBinder activityToken, LoadedApk pi, String splitName,
            int displayId, Configuration overrideConfig, CompatibilityInfo compatInfo) {
        final String[] splitResDirs;
        final ClassLoader classLoader;
        try {
            splitResDirs = pi.getSplitPaths(splitName);
            classLoader = pi.getSplitClassLoader(splitName);
        } catch (NameNotFoundException e) {
            throw new RuntimeException(e);
        }
        //调用ResourcesManager的getResources();
        return ResourcesManager.getInstance().getResources(activityToken,
                pi.getResDir(),
                splitResDirs,
                pi.getOverlayDirs(),
                pi.getApplicationInfo().sharedLibraryFiles,
                displayId,
                overrideConfig,
                compatInfo,
                classLoader);
    }
    

    ResourcesManager的getResources();获取或者创建Resources对象;

    public @Nullable Resources getResources(@Nullable IBinder activityToken,
            @Nullable String resDir,
            @Nullable String[] splitResDirs,
            @Nullable String[] overlayDirs,
            @Nullable String[] libDirs,
            int displayId,
            @Nullable Configuration overrideConfig,
            @NonNull CompatibilityInfo compatInfo,
            @Nullable ClassLoader classLoader) {
        try {
            Trace.traceBegin(Trace.TRACE_TAG_RESOURCES, "ResourcesManager#getResources");
            final ResourcesKey key = new ResourcesKey(
                    resDir,
                    splitResDirs,
                    overlayDirs,
                    libDirs,
                    displayId,
                    overrideConfig != null ? new Configuration(overrideConfig) : null, // Copy
                    compatInfo);
            classLoader = classLoader != null ? classLoader : ClassLoader.getSystemClassLoader();
            return getOrCreateResources(activityToken, key, classLoader);
        } finally {
            Trace.traceEnd(Trace.TRACE_TAG_RESOURCES);
        }
    }
    

    getOrCreateResources():是最终获取或则创建Resources的方法,来详细看下系统 是如何创建的;我们主要看第三种情况

    1. activityToken不为空,则通过key获取ResourcesImpl对象,然后通过getOrCreateResourcesForActivityLocked()方法获取或者创建一个Resources对象;
    2. activityToken为空,则通过key获取ResourcesImpl对象,然后getOrCreateResourcesLocked()获取或者创建一个Resources对象
    3. 如果不存在key对应的ResourcesImpl对象,则通过createResourcesImpl()创建ResourcesImpl对象,再根据activityToken是否为null,调用对应的方法,创建Resources对象;
    private @Nullable Resources getOrCreateResources(@Nullable IBinder activityToken,
            @NonNull ResourcesKey key, @NonNull ClassLoader classLoader) {
        synchronized (this) {
            //1:activityToken不为null;
            if (activityToken != null) {
                final ActivityResources activityResources =
                        getOrCreateActivityResourcesStructLocked(activityToken);
    
                // Clean up any dead references so they don't pile up.
                ArrayUtils.unstableRemoveIf(activityResources.activityResources,
                        sEmptyReferencePredicate);
    
                // Rebase the key's override config on top of the Activity's base override.
                if (key.hasOverrideConfiguration()
                        && !activityResources.overrideConfig.equals(Configuration.EMPTY)) {
                    final Configuration temp = new Configuration(activityResources.overrideConfig);
                    temp.updateFrom(key.mOverrideConfiguration);
                    key.mOverrideConfiguration.setTo(temp);
                }
    			//通过Key获取对应的ResourcesImpl对象;
                ResourcesImpl resourcesImpl = findResourcesImplForKeyLocked(key);
                if (resourcesImpl != null) {
                    return getOrCreateResourcesForActivityLocked(activityToken, classLoader,
                            resourcesImpl, key.mCompatInfo);
                }
    
                // We will create the ResourcesImpl object outside of holding this lock.
    
            } else {
                //2:activityToken为null;
                // Clean up any dead references so they don't pile up.
                ArrayUtils.unstableRemoveIf(mResourceReferences, sEmptyReferencePredicate);
    
                // Not tied to an Activity, find a shared Resources that has the right ResourcesImpl
                ResourcesImpl resourcesImpl = findResourcesImplForKeyLocked(key);
                if (resourcesImpl != null) {
                    return getOrCreateResourcesLocked(classLoader, resourcesImpl, key.mCompatInfo);
                }
    
                // We will create the ResourcesImpl object outside of holding this lock.
            }
        }
    
        //3:创建一个ResourcesImpl对象;
        ResourcesImpl resourcesImpl = createResourcesImpl(key);
        if (resourcesImpl == null) {
            return null;
        }
    	//再次通过key获取对应的ResourcesImpl对象,判断是否存在,不存在加入ArrayMap中;
        synchronized (this) {
            ResourcesImpl existingResourcesImpl = findResourcesImplForKeyLocked(key);
            if (existingResourcesImpl != null) {
                resourcesImpl.getAssets().close();
                resourcesImpl = existingResourcesImpl;
            } else {
                // Add this ResourcesImpl to the cache.
                mResourceImpls.put(key, new WeakReference<>(resourcesImpl));
            }
    		
            //根据activityToken是否为null,判断如何创建Resources对象;
            final Resources resources;
            if (activityToken != null) {
                resources = getOrCreateResourcesForActivityLocked(activityToken, classLoader,
                        resourcesImpl, key.mCompatInfo);
            } else {
                resources = getOrCreateResourcesLocked(classLoader, resourcesImpl, key.mCompatInfo);
            }
            return resources;
        }
    }
    

    createResourcesImpl():系统是如何创建ResourcesImpl对象的,主要参数:AssetManager对象;

    AssetManager类;通过createAssetManager()方法,创建AssetManager对象;可以通过addXXX()方法根据path加载资源;

    ResourcesImpl是资源访问的实现,包含AssetManager和与之关联的所有缓存;ResourcesResources的包装类,Resources中的方法都是通过ResourcesImpl对象来实现的;

    private @Nullable ResourcesImpl createResourcesImpl(@NonNull ResourcesKey key) {
        final DisplayAdjustments daj = new DisplayAdjustments(key.mOverrideConfiguration);
        daj.setCompatibilityInfo(key.mCompatInfo);
    	//根据路径创建AssetManager对象;并且根据path获取资源;
        final AssetManager assets = createAssetManager(key);
        if (assets == null) {
            return null;
        }
    
        final DisplayMetrics dm = getDisplayMetrics(key.mDisplayId, daj);
        final Configuration config = generateConfig(key, dm);
        //创建ResourcesImpl对象;
        final ResourcesImpl impl = new ResourcesImpl(assets, dm, config, daj);
    
        if (DEBUG) {
            Slog.d(TAG, "- creating impl=" + impl + " with key: " + key);
        }
        return impl;
    }
    

    AssetManager类中主要的方法

    //通过路径添加额外的资源,可以是目录或者zip;失败则返回0;
    public final int addAssetPath(String path) {
        return  addAssetPathInternal(path, false);
    }
    
    private final int addAssetPathInternal(String path, boolean appAsLib) {
        synchronized (this) {
            int res = addAssetPathNative(path, appAsLib);
            makeStringBlocks(mStringBlocks);
            return res;
        }
    }
    //native方法;
    private native final int addAssetPathNative(String path, boolean appAsLib);
    

    不管activityToken是否为null,调用getOrCreateResourcesForActivityLocked()还是getOrCreateResourcesLocked()都是类似的,都是遍历集合判断classLoader和impl是否相等,满足条件直接返回;否则创建对象

    if (resources != null
            && Objects.equals(resources.getClassLoader(), classLoader)
            && resources.getImpl() == impl) {
        return resources;
    }
    

    不满足上述条件,直接创建对象;

    //创建Resources对象;
    Resources resources = compatInfo.needsCompatResources() ? new CompatResources(classLoader)
            : new Resources(classLoader);
    //调用setImpl()将ResourcesImpl对象传给Resources对象;
    resources.setImpl(impl);
    mResourceReferences.add(new WeakReference<>(resources));
    

    系统是如何加载资源的Res资源的呢?

    • 创建AssetManager对象,调用addXXXPath()方法,读取对应路径下的资源文件;并添加到ArrayMap对象mResourceImpls中;然后创建ResourcesImpl对象;
    • ClassLoader对象作为参数创建Resources对象,并setImpl()设置ResourcesImpl对象;

    上述是如何获取或者创建Resources对象;有了Resources对象之后,如何获取对应的资源呢?

    Resources中的资源文件,如何生成对应的ID的?

    具体详见Android应用程序资源的编译和打包过程分析

    Resources的getText()方法为例,会调用AssetManager的getResourceText()方法;

    @NonNull public CharSequence getText(@StringRes int id) throws NotFoundException {
        CharSequence res = mResourcesImpl.getAssets().getResourceText(id);
        if (res != null) {
            return res;
        }
        throw new NotFoundException("String resource ID #0x"
                + Integer.toHexString(id));
    }
    

    AssetManager的getResourceText()

    @Nullable
    final CharSequence getResourceText(@StringRes int resId) {
        synchronized (this) {
            final TypedValue outValue = mValue;
            if (getResourceValue(resId, 0, outValue, true)) {
                return outValue.coerceToString();
            }
            return null;
        }
    }
    

    getResourceValue()方法

    final boolean getResourceValue(@AnyRes int resId, int densityDpi, @NonNull TypedValue outValue,
            boolean resolveRefs) {
        synchronized (this) {
            //native方法
            final int block = loadResourceValue(resId, (short) densityDpi, outValue, resolveRefs);
            if (block < 0) {
                return false;
            }
    
            // Convert the changing configurations flags populated by native code.
            outValue.changingConfigurations = ActivityInfo.activityInfoConfigNativeToJava(
                    outValue.changingConfigurations);
    
            if (outValue.type == TypedValue.TYPE_STRING) {
                outValue.string = mStringBlocks[block].get(outValue.data);
            }
            return true;
        }
    }
    

    引入外部资源

    我们平时都是使用APP内部的资源文件,除了一键换肤,插件化开发,很少有引入外部资源文件的情况;我们如何如何APP之外的资源文件呢?

    通过反射的方式创建AssetmanagerResourcesImplResources对象;

    public class OutResources {
    
        private String TAG = OutResources.class.getSimpleName();
        private Resources resources;
        private static OutResources outResources;
        private String mOutPkgName;
        private String mFilePath;
    
        private OutResources() {
        }
    
        public static OutResources getInstance() {
            if (outResources == null) {
                synchronized (OutResources.class) {
                    if (outResources == null) {
                        outResources = new OutResources();
                    }
                }
            }
            return outResources;
        }
    
        /**
         * 创建Resources对象;
         * <p>
         * Resources对外公开的构造方法
         */
        void initResources(String filePath) {
            this.mFilePath = filePath;
            try {
                if (resources == null) {
                    //通过反射的方式获取
                    AssetManager assetManager = createAssetManager();
                    if (assetManager == null) {
                        return;
                    }
    
                    Resources superRes = MyApplication.getContext().getResources();
                    resources = new Resources(assetManager, superRes.getDisplayMetrics(), superRes.getConfiguration());
                }
                Log.e(TAG, "加载外部资源文件");
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        //第二种,按照系统的方式创建Resources对象
        void initRes(String filePath) {
            this.mFilePath = filePath;
            if (resources == null) {
                //创建Resources对象;
                resources = (Resources) RefInvoke.createObject(Resources.class);
    
                AssetManager assetManager = createAssetManager();
                if (assetManager == null) {
                    return;
                }
                Resources superRes = MyApplication.getContext().getResources();
                DisplayMetrics displayMetrics = superRes.getDisplayMetrics();
                Configuration configuration = superRes.getConfiguration();
    
                //获取DisplayAdjustments的class对象和实例;
                Class disCls = null;
                try {
                    disCls = Class.forName("android.view.DisplayAdjustments");
                } catch (Exception e) {
                    e.printStackTrace();
                }
                Object dis = RefInvoke.createObject(disCls);
    
                String className = "android.content.res.ResourcesImpl";
                Class[] pareTyples = {AssetManager.class, DisplayMetrics.class, Configuration.class, disCls};
                Object[] values = {assetManager, displayMetrics, configuration, dis};
                //创建ResourcesImpl实例;
                Object resourcesImpl = RefInvoke.createObject(className, pareTyples, values);
    
                Class resourcesImplClass = null;
                try {
                    resourcesImplClass = Class.forName(className);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                //调用Resources的setImpl()方法;
                RefInvoke.invokeInstanceMethod(resources, "setImpl", resourcesImplClass, resourcesImpl);
            }
            Log.e(TAG, "加载外部资源文件");
        }
    
        /**
         * 1)相同的资源名称,在不同的APK中,编译后对应的ID会不同;
         *
         * @param resId
         * @return
         */
        public Drawable getDrawable(Context context, int resId) {//获取图片
            //Application mContext = context.getApplication();
    
            if (resources == null) {
                return ContextCompat.getDrawable(context, resId);
            }
            //包名+资源名
            String resName = context.getResources().getResourceName(resId);
            //资源名
            String name = context.getResources().getResourceEntryName(resId);
            //包名
            String packageName = context.getResources().getResourcePackageName(resId);
            //对应资源的类型;
            String typeName = context.getResources().getResourceTypeName(resId);
    
            Log.e(TAG, "resName::" + resName);
    
            //需要获取的资源的包名;如果不存在对应的ID,获取不到包名;
            //String mOutPkgName = resources.getResourcePackageName(resId);
    
            //通过资源名称,类型获取对应的资源ID;
            int outResId = resources.getIdentifier(name, typeName, mOutPkgName);
            //outResId 没有这样的资源被发现;
            if (outResId == 0) {
                return ContextCompat.getDrawable(context, resId);
            }
            Log.e(TAG, "resId;;" + R.drawable.image_liu + ",,,outResId::" + outResId);
            return resources.getDrawable(outResId);
        }
    
        public int getColor(Context context, @ColorRes int id) {
            if (resources == null) {
                return ContextCompat.getColor(context, id);
            }
    
            Resources superRes = context.getResources();
            String packageName = superRes.getResourcePackageName(id);
            String name = superRes.getResourceEntryName(id);
            String typeName = superRes.getResourceTypeName(id);
    
            int outResId = resources.getIdentifier(name, typeName, mOutPkgName);
            if (outResId == 0) {
                return ContextCompat.getColor(context, id);
            }
            return resources.getColor(outResId);
        }
    
        private AssetManager createAssetManager() {
            try {
                Class<AssetManager> assetManagerClass = AssetManager.class;
                //AssetManager assetManager = (AssetManager) RefInvoke.createObject(clazz);
                //调用AssetManager的getSystem()方法;
                AssetManager assetManager = (AssetManager) RefInvoke.invokeStaticMethod(assetManagerClass, "getSystem");
    
                Log.e(TAG, "filePath::" + mFilePath);
                getPackageName(mFilePath);
    
                //调用addAssetPath()加载第三方资源;
                int addAssetPath = (int) RefInvoke.invokeInstanceMethod(assetManager, "addAssetPath", String.class, mFilePath);
                Log.e(TAG, "addAssetPath::" + addAssetPath);
    
                if (addAssetPath == 0) {
                    Log.e(TAG, "加载资源失败");
                }
                return assetManager;
            } catch (Exception e) {
                e.printStackTrace();
            }
            return null;
        }
    
        private void getPackageName(String filePath) {
            //取得PackageManager引用
            PackageManager mPm = MyApplication.getContext().getPackageManager();
            //“检索在包归档文件中定义的应用程序包的总体信息”,说人话,外界传入了一个apk的文件路径,这个方法,
            //拿到这个apk的包信息,这个包信息包含什么?
            PackageInfo mInfo = mPm.getPackageArchiveInfo(filePath, PackageManager.GET_ACTIVITIES);
            //先把包名存起来
            mOutPkgName = mInfo.packageName;
        }
    

    然后在点击事件中调用下面两个方法,即可加载app.zip的image_liu资源(app.zip中必须有和相同名称的资源,由apk包改为zip类型文件);

    //可以放在Application中或者MainActivity;
    private void initRes() {
        String filePath = Environment.getExternalStorageDirectory() + File.separator + "a_test_change/app.zip";
        OutResources.getInstance().initRes(filePath);
    }
    
    private void loadImage() {
        imageView.setImageDrawable(OutResources.getInstance().getDrawable(act, R.drawable.image_liu));
    }
    

    以上就是Recouces的主要内容了,如有问题,请多指教,谢谢!

    展开全文
  • 外部依赖项:程序中包含的头文件中所用到的头文件 资源文件:除了代码之外所需的其他如图片,菜单,工具栏等

    外部依赖项:程序中包含的头文件中所用到的头文件

    资源文件:除了代码之外所需的其他如图片,菜单,工具栏等

    展开全文
  • VS资源文件和外部依赖项

    千次阅读 2015-03-26 14:44:27
    比如,你的main函数里面包含了windows.h头文件,而windows.h头文件又包含其他头文件,而这些头文件又可能还包含另外的头文件,所有这些都显示在外部依赖项里面。资源文件主要是你用到的一些程序代码以外的东西
  • Unity3D加载外部资源

    千次阅读 2015-06-26 10:41:31
    Resources.Load就是从一个缺省打进程序包里的AssetBundle里加载资源,而一般AssetBundle文件需要你自己创建,运行时动态加载,可以指定路径和来源的。其实场景里所有静态的对象也有这么一个加载过程,只是
  • springboot对外部静态资源文件的处理

    千次阅读 2019-05-22 17:53:07
    springboot对外部资源文件的处理主要分为2部分,存和取,通过查看官方文件和看博客踩了坑之后终于搞定了,特此记录。 存方面倒还简单,这里贴上一个获取微信临时素材并保存的方法 /** * @功能 下载临时素材接口 ...
  • 很多的项目都要上传图片那些,然后通过打包jar包或者war包发布到服务器上,我们可能把上传图片的文件夹放在jar包或者war包里面,那样会越来越大。所以有了下面的配置,其他框架都好说可以把文件放在tomact下,但是...
  • 如下图: 当把外部资源文件的属性设置为: 复制到输出目录:始终复制 生成操作:无 这样在每次右击项目生成操作时,自动复制到Debug输出目录。就不用每次拷贝过去了。
  • http://blog.csdn.net/luochuanad/article/details/53410537
  • 1.1 外部资源 不论你是什么开发环境,对于开发来说最好的做法就是不要将资源(例如图片等)路径这些整合到代码中。Android支持将这些资源外部化,范围包括一些简单的值,如字符串、颜色和更加复杂的图片资源、主题...
  • 在asp.net中开发自定义控件时,如果我们要用到图片,外部css,js等文件,那么最好的方式就是将这些文件作为自定义控件嵌入的资源,随着控件一起打包成dll文件发布。那么我们要如何将这些文件设置为嵌入的资源,又如何...
  • Tomcat中使用JNDI引用外部资源

    千次阅读 2016-01-15 16:44:27
    JNDIJNDI(Java Naming and Directory Interface )是Java EE中容器服务的重要组成部分. 主要作用是给多种命名...其中的命名和目录服务指定范围比较广泛, 包括LDAP(The Lightweight Directory Access Protocol), DNS和NI
  • 外部依赖项:头文件依赖的头文件(非自己定义),主要包含一些外部库。 头文件:.h文件,内含函数声明、宏定义、结构体定义等内容。 源文件:.c或.cpp文件,函数实现,变量定义等内容。 资源文件:图片等程序...
  • 头文件: 里面是.h文件,包含有函数声明、... 外部依赖项: 不是自己定义,主要包括的是一些外部库 源文件: 主要是.c或.cpp文件,里面包含的是函数实现,变量定义等内容。 资源文件: 图片等程序需要用到的资源 ...
  • 步骤1:创建WinForm工程 ...步骤3:将外部的图片或资源包含到WinForm的工程中 步骤4:设置图片或资源的属性为内容、复制 步骤5:使用相对路径测试程序 public Form1() { InitializeComponent
  • Unity 3D--外部加载资源AssetBundles

    千次阅读 2013-04-15 22:01:22
    Resources.Load就是从一个缺省打进程序包里的AssetBundle里加载资源,而一般AssetBundle文件需要你自己创建,运行时动态加载,可以指定路径和来源的。其实场景里所有静态的对象也有这么一个加载过程,只是
  • MFC工程中调用外部EXE资源...

    千次阅读 2010-11-03 15:05:00
    最近在做网银检测工具,在其中需要检测USBKey管理工具是否安装,如果没有安装的话,需要修复安装,废话多说,基本的操作流程是:(1)、把外部EXE程序加入到VC工程资源Resource中,即Resource ->import —>自定义...
  • 最近想自己写一个cms系统,在前台View层展示上,初始版本用jsp,以后用Freemarker优化,包括生成静态页面等。在设计JSP页面时,遇到了最头疼的问题。路径问题。  J2EE学习道路上有两个最为恼火的问题,一是编码...
  • 1.发现项目中存在的问题 为了直观地发现项目中存在的问题,我们可以在打包时生成...它的作用是什么? 原来,其实默认情况下,项目中我们通过 import 语法导入的第三方依赖包,最终会被打包合并到同一个文件中,而这...
  • 1.发现项目中存在的问题 为了直观地发现项目中存在的问题,我们可以在打包时生成报告。...它的作用是什么? 原来,其实默认情况下,项目中我们通过 import 语法导入的第三方依赖包,最终会被打包合并到同一个文...
  • ssl 此页中包含其他安全资源

    千次阅读 2018-07-18 21:08:06
    本页不但包含安全的内容,也包含不安全的内容     为什么会出现这种安全提示呢?因为SSL证书对网站代码的安全性要求很高,但许多用户网站中却使用了大量的外链,而这些外部资源(图片或js)正是不安全的因素...
  • 码字容易,转载请注明出处! ​ 在实际工程开发中,画面丰富的ui,通常一个界面就需要用到很多图片,刚...首先从图片资源说起,现在用手机拍一张图片,大小就有好几M,如果这张图片分辨率适合自己的屏幕的话,当然...
  • 中url-pattern使用/ ,表示DispatcherServlet处理所有请求,也包括静态资源,这不是我们所希望的。 怎么让DispatcherServlet去处理静态资源的请求? 方式一:使用web.xml <servlet-name>default *.css ...
  • 如果在命令提示符窗口,正常输入有效命令,会弹出提示:该命令不是内部或外部命令,也能运行可执行文件或批处理文件。可能是系统环境出错了。解决步骤:1。可以尝试先输入 cd C:\Windows\System32 (按回车),...
  • 外部依赖项总结

    2019-08-01 17:23:26
    一、什么外部依赖项? 所谓外部依赖项就是工程中显式包含的那些头文件本身所包含的头文件(非自己定义),主要包含一些外部库。例如虽然在main里包含了一个windows.h,但是windows.h本身就包含相当多的头文件。而...
  • 今天有碰到个问题,困扰很久,就是css外部加载background图片能加载问题,网上大都是关于图片的相对/绝对路径的资料,但我的路径是没有问题的。查了很久资料才发现在的被Filter给拦截了,所以要碰到此问题也要检查...
  • 1. 将项目打包成JAR包,但是读取资源的时候出错的解决方法:获取class类的根目录的路径:String path =Thread.currentThread().getContextClassLoader().getResource("").getPath();这种情况仅仅适合于资源文件夹...
  • Maven引入外部依赖

    千次阅读 2018-01-03 15:54:25
      pom.xml的dependencies列表列出了我们的项目需要构建的所有外部依赖项(它是否需要在编译时、测试时、运行时,或者其他什么)。现在,我们的项目只依赖于JUnit(为了清楚起见,我把所有的资源过滤都去掉了):...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 445,661
精华内容 178,264
关键字:

外部资源不包括什么