Java ResourceManager类代码示例

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
public static String loadTemplate(String template, ResourceManager resourceManager) throws Exception {
    byte[] buf = new byte[1024];
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    Resource resource = resourceManager.getResource(template);
    if(resource == null) {
        throw UndertowScriptLogger.ROOT_LOGGER.templateNotFound(template);
    }
    try (InputStream stream = resource.getUrl().openStream()) {
        if(stream == null) {
            throw UndertowScriptLogger.ROOT_LOGGER.templateNotFound(template);
        }
        int res;
        while ((res = stream.read(buf)) > 0) {
            out.write(buf, 0, res);
        }
        return out.toString("UTF-8");
    }
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
@Override
public void start(StartContext context) throws StartException {
    ExtensibleHttpManagement httpManagement = httpManagementInjector.getValue();

    ResourceManager rm = new ClassPathResourceManager(getClass().getClassLoader(), getClass().getPackage());
    httpManagement.addStaticContext("static", rm);
    log.info("Added context 'static'");

    ExtensibleHttpManagement.PathRemapper remapper = new ExtensibleHttpManagement.PathRemapper() {
        @Override
        public String remapPath(String originalPath) {
            if ("/foo".equals(originalPath)) {
                String prefix = forServer ? "" : "/host/master";
                return prefix + "/extension/" + EXTENSION_NAME;
            }
            return null;
        }
    };
    httpManagement.addManagementGetRemapContext("remap", remapper);
    log.info("Added context 'remap'");
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
public synchronized void start() throws ServletException {
    try {
        handle = factory.createInstance();
    } catch (Exception e) {
        throw UndertowServletMessages.MESSAGES.couldNotInstantiateComponent(servletInfo.getName(), e);
    }
    instance = handle.getInstance();
    new LifecyleInterceptorInvocation(servletContext.getDeployment().getDeploymentInfo().getLifecycleInterceptors(), servletInfo, instance, new ServletConfigImpl(servletInfo, servletContext)).proceed();

    //if a servlet implements FileChangeCallback it will be notified of file change events
    final ResourceManager resourceManager = servletContext.getDeployment().getDeploymentInfo().getResourceManager();
    if(instance instanceof ResourceChangeListener && resourceManager.isResourceChangeListenerSupported()) {
        resourceManager.registerResourceChangeListener(changeListener = (ResourceChangeListener) instance);
    }
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
public synchronized void stop() {
    if (handle != null) {
        final ResourceManager resourceManager = servletContext.getDeployment().getDeploymentInfo().getResourceManager();
        if(changeListener != null) {
            resourceManager.removeResourceChangeListener(changeListener);
        }
        invokeDestroy();
        handle.release();
    }
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
private ResourceManager getDocumentRootResourceManager() {
	File root = getCanonicalDocumentRoot();
	if (root.isDirectory()) {
		return new FileResourceManager(root, 0);
	}
	if (root.isFile()) {
		return new JarResourceManager(root);
	}
	return ResourceManager.EMPTY_RESOURCE_MANAGER;
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
private ResourceManager getDocumentRootResourceManager() {
	File root = getValidDocumentRoot();
	if (root != null && root.isDirectory()) {
		return new FileResourceManager(root, 0);
	}
	if (root != null && root.isFile()) {
		return new JarResourcemanager(root);
	}
	return ResourceManager.EMPTY_RESOURCE_MANAGER;
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
@Override
public Resource getResource(String p) {
    for (int i = 0, managersSize = size(); i < managersSize; i++) {
        ResourceManager x = get(i);
        try {
            Resource y = x.getResource(p);
            if (y != null)
                return y;
        } catch (Throwable ignored) {
            //ignore
        }
    }
    return null;
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
@Override
public void init(Map<String, String> properties, ResourceManager resourceManager) {
    this.resourceManager = resourceManager;
    engine = MustacheEngineBuilder
            .newBuilder()
            .registerHelpers(HelpersBuilder.extra().build())
            .addTemplateLocator(new ResourceManagerTemplateLocator())
            .setProperty(EngineConfigurationKey.DEBUG_MODE, Boolean.parseBoolean(properties.get("debug")))
            .setProperty(EngineConfigurationKey.DEFAULT_FILE_ENCODING, properties.containsKey("charset") ? properties.get("charset") : "UTF-8")
            .build();
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
public UndertowSupport(RoutingHandler routingHandler, ClassLoader classLoader, Map<String, InjectionProvider> injectionProviders, JavabeanIntrospector javabeanIntrospector, List<HandlerWrapper> handlerWrappers, ResourceManager resourceManager, RoutingHandler wsRoutingHandler, Map<String, TemplateProvider> templateProviders) {
    this.routingHandler = routingHandler;
    this.classLoader = classLoader;
    this.injectionProviders = injectionProviders;
    this.javabeanIntrospector = javabeanIntrospector;
    this.handlerWrappers = handlerWrappers;
    this.resourceManager = resourceManager;
    this.wsRoutingHandler = wsRoutingHandler;
    this.templateProviders = templateProviders;
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
private ResourceManager getResourceManager(File warFile, Long transferMinSize, String cfmlDirs, File internalCFMLServerRoot) {
    MappedResourceManager mappedResourceManager = new MappedResourceManager(warFile, transferMinSize, cfmlDirs, internalCFMLServerRoot);
    if(serverOptions.isDirectoryListingRefreshEnabled()) return mappedResourceManager;
    final DirectBufferCache dataCache = new DirectBufferCache(1000, 10, 1000 * 10 * 1000, BufferAllocator.DIRECT_BYTE_BUFFER_ALLOCATOR, METADATA_MAX_AGE);
    final int metadataCacheSize = 100;
    final long maxFileSize = 10000;
    return new CachingResourceManager(metadataCacheSize,maxFileSize, dataCache, mappedResourceManager, METADATA_MAX_AGE);
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
static ResourceHandlerDefinition createStaticContentHandler(ResourceManager resource, String context) {
    final io.undertow.server.handlers.resource.ResourceHandler handler = new io.undertow.server.handlers.resource.ResourceHandler(resource)
            .setCacheTime(60 * 60 * 24 * 31)
            .setAllowed(not(path("META-INF")))
            .setResourceManager(resource)
            .setDirectoryListingEnabled(false)
            .setCachable(not(suffixes(NOCACHE_JS, APP_HTML, INDEX_HTML)));

    // avoid clickjacking attacks: console must not be included in (i)frames
    SetHeaderHandler frameHandler = new SetHeaderHandler(handler, "X-Frame-Options", "SAMEORIGIN");
    // we also need to setup the default resource redirect
    PredicateHandler predicateHandler = new PredicateHandler(path("/"), new RedirectHandler(ExchangeAttributes.constant(context + DEFAULT_RESOURCE)), frameHandler);
    return new ResourceHandlerDefinition(context, DEFAULT_RESOURCE, predicateHandler);
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
public void addStaticContext(String contextName, ResourceManager resourceManager) {
    Assert.checkNotNullParam("contextName", contextName);
    Assert.checkNotNullParam("resourceManager", resourceManager);
    String context = fixPath(contextName);
    // Reject reserved contexts or duplicate extensions
    if (extensionHandlers.reservedContexts.contains(context) || !extensionHandlers.extensionContexts.add(context)) {
        throw new IllegalStateException();
    }
    ResourceHandlerDefinition def = DomainUtil.createStaticContentHandler(resourceManager, context);
    HttpHandler readinessHandler = new RedirectReadinessHandler(extensionHandlers.readyFunction, def.getHandler(),
            ErrorContextHandler.ERROR_CONTEXT);
    extensionHandlers.extensionPathHandler.addPrefixPath(context, readinessHandler);
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
protected ResourceManager newResourceManager(OptionMap config) {
	if (this.loadFrom == null) {
		return new FileResourceManager(new File(this.root),
				config.get(Config.TRANSFER_MIN_SIZE));
	}
	return new ClassPathResourceManager(this.loadFrom, this.root);
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
protected HttpHandler wrapWithStaticHandler(HttpHandler baseHandler, String path) {
    // static path is given relative to application root
    if (!new File(path).isAbsolute()) {
        path = WunderBoss.options().get("root", "").toString() + File.separator + path;
    }
    if (!new File(path).exists()) {
        log.debug("Not adding static handler for nonexistent directory {}", path);
        return baseHandler;
    }
    log.debug("Adding static handler for {}", path);
    final ResourceManager resourceManager =
            new CachingResourceManager(1000, 1L, null,
                                       new FileResourceManager(new File(path), 1 * 1024 * 1024), 250);
    String[] welcomeFiles = new String[] { "index.html", "index.html", "default.html", "default.htm" };
    final List<String> welcomeFileList = new CopyOnWriteArrayList<>(welcomeFiles);
    final ResourceHandler resourceHandler = new ResourceHandler()
            .setResourceManager(resourceManager)
            .setWelcomeFiles(welcomeFiles)
            .setDirectoryListingEnabled(false);

    return new PredicateHandler(new Predicate() {
            @Override
            public boolean resolve(HttpServerExchange value) {
                try {
                    Resource resource = resourceManager.getResource(value.getRelativePath());
                    if (resource == null) {
                        return false;
                    }
                    if (resource.isDirectory()) {
                        Resource indexResource = getIndexFiles(resourceManager, resource.getPath(), welcomeFileList);
                        return indexResource != null;
                    }
                    return true;
                } catch (IOException ex) {
                    return false;
                }
            }
    }, resourceHandler, baseHandler);
}
 

import io.undertow.server.handlers.resource.ResourceManager; //导入依赖的package包/类
protected Resource getIndexFiles(ResourceManager resourceManager, final String base, List<String> possible) throws IOException {
    String realBase;
    if (base.endsWith("/")) {
        realBase = base;
    } else {
        realBase = base + "/";
    }
    for (String possibility : possible) {
        Resource index = resourceManager.getResource(realBase + possibility);
        if (index != null) {
            return index;
        }
    }
    return null;
}