Java Resource类代码示例

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
@Override
public URL getResource(final String path) throws MalformedURLException {
    if (!path.startsWith("/")) {
        throw UndertowServletMessages.MESSAGES.pathMustStartWithSlash(path);
    }
    Resource resource = null;
    try {
        resource = deploymentInfo.getResourceManager().getResource(path);
    } catch (IOException e) {
        return null;
    }
    if (resource == null) {
        return null;
    }
    return resource.getUrl();
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
@Override
public String getRealPath(final String path) {
    if (path == null) {
        return null;
    }
    String canonicalPath = CanonicalPathUtils.canonicalize(path);
    Resource resource = null;
    try {
        resource = deploymentInfo.getResourceManager().getResource(canonicalPath);
    } catch (IOException e) {
        return null;
    }
    if (resource == null) {
        return null;
    }
    File file = resource.getFile();
    if (file == null) {
        return null;
    }
    return file.getAbsolutePath();
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
private ServletPathMatch findWelcomeFile(final String path, boolean requiresRedirect) {
    if(File.separatorChar != '/' && path.contains(File.separator)) {
        return null;
    }
    for (String i : welcomePages) {
        try {
            final String mergedPath = path + i;
            Resource resource = resourceManager.getResource(mergedPath);
            if (resource != null) {
                final ServletPathMatch handler = data.getServletHandlerByPath(mergedPath);
                return new ServletPathMatch(handler.getServletChain(), mergedPath, null, requiresRedirect ? REDIRECT : REWRITE, i);
            }
        } catch (IOException e) {
        }
    }
    return null;
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的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.Resource; //导入依赖的package包/类
@Override
public Set<String> getResourcePaths(final String path) {
    final Resource resource;
    try {
        resource = deploymentInfo.getResourceManager().getResource(path);
    } catch (IOException e) {
        return null;
    }
    if (resource == null || !resource.isDirectory()) {
        return null;
    }
    final Set<String> resources = new HashSet<>();
    for (Resource res : resource.list()) {
        File file = res.getFile();
        if (file != null) {
            File base = res.getResourceManagerRoot();
            if (base == null) {
                resources.add(file.getPath()); //not much else we can do here
            } else {
                String filePath = file.getAbsolutePath().substring(base.getAbsolutePath().length());
                filePath = filePath.replace('\\', '/'); //for windows systems
                if (file.isDirectory()) {
                    filePath = filePath + "/";
                }
                resources.add(filePath);
            }
        }
    }
    return resources;
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
public ServletPathMatch getServletHandlerByPath(final String path) {
    ServletPathMatch match = getData().getServletHandlerByPath(path);
    if (!match.isRequiredWelcomeFileMatch()) {
        return match;
    }
    try {

        String remaining = match.getRemaining() == null ? match.getMatched() : match.getRemaining();
        Resource resource = resourceManager.getResource(remaining);
        if (resource == null || !resource.isDirectory()) {
            return match;
        }

        boolean pathEndsWithSlash = remaining.endsWith("/");
        final String pathWithTrailingSlash = pathEndsWithSlash ? remaining : remaining + "/";

        ServletPathMatch welcomePage = findWelcomeFile(pathWithTrailingSlash, !pathEndsWithSlash);

        if (welcomePage != null) {
            return welcomePage;
        } else {
            welcomePage = findWelcomeServlet(pathWithTrailingSlash, !pathEndsWithSlash);
            if (welcomePage != null) {
                return welcomePage;
            } else if(pathEndsWithSlash) {
                return match;
            } else {
                return new ServletPathMatch(match.getServletChain(), match.getMatched(), match.getRemaining(), REDIRECT, "/");
            }
        }

    } catch (IOException e) {
        throw new RuntimeException(e);
    }

}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
@Override
public Resource getResource(String path) throws IOException {
	URL url = new URL("jar:file:" + this.jarPath + "!" + path);
	URLResource resource = new URLResource(url, url.openConnection(), path);
	if (resource.getContentLength() < 0) {
		return null;
	}
	return resource;
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的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.Resource; //导入依赖的package包/类
public Resource getResource(String path) {
	if ( path.startsWith( "/WEB-INF" ) ) {
		File reqFile = new File( WEBINF, path.replace( "/WEB-INF", "" ) );
		return new FileResource( reqFile, this, path );
	}
	return super.getResource(path);
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
public HttpHandler getHandler(final HttpHandler next) {
    return new HttpHandler() {
        @Override
        public void handleRequest(HttpServerExchange exchange) throws Exception {
            if (hotDeployment) {
                long lastHotDeploymentCheck = UndertowJS.this.lastHotDeploymentCheck;
                if (System.currentTimeMillis() > lastHotDeploymentCheck + HOT_DEPLOYMENT_INTERVAL) {
                    synchronized (UndertowJS.this) {
                        if (UndertowJS.this.lastHotDeploymentCheck == lastHotDeploymentCheck) {
                            for (Map.Entry<Resource, Date> entry : lastModified.entrySet()) {
                                if (!entry.getValue().equals(entry.getKey().getLastModified())) {
                                    UndertowScriptLogger.ROOT_LOGGER.rebuildingDueToFileChange(entry.getKey().getPath());
                                    buildEngine();
                                    break;
                                }
                            }
                            UndertowJS.this.lastHotDeploymentCheck = System.currentTimeMillis();
                        }
                    }
                }
            }
            if(rejectPaths.contains(exchange.getRelativePath())) {
                exchange.setResponseCode(StatusCodes.NOT_FOUND);
                exchange.endExchange();
                return;
            }
            exchange.putAttachment(NEXT, next);
            routingHandler.handleRequest(exchange);
        }
    };
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的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.Resource; //导入依赖的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;
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
public UndertowServer() {
    host = config.getString("server.host");
    port = config.getInt("server.port");
    staticDir = config.getString("dirs.static");

    List<String> staticFileSuffixes = config.getStrings("app.static.suffixes");

    ResourceManager resourceManager = new FileResourceManager(new File(staticDir), 10) {
        ClassPathResourceManager cprm = new ClassPathResourceManager(this.getClass().getClassLoader(), "");

        @Override
        public Resource getResource(String path) {
            Resource resource = super.getResource(path);
            if (isNull(resource)) {
                try {
                    resource = cprm.getResource(path);
                } catch (IOException e) {
                    resource = null;
                }
            }
            return resource;
        }
    };

    RoutesManager routesManager = ApplicationContext.instance().getRoutesManager();

    HttpHandler dynamicHandlers =
            monitor(errors(session(security(forms(route(routesManager, invocation(redirect(respond()))))))));

    server = Undertow.builder()
            .addListener(port, host)
            .setHandler(
                predicate(
                    suffixs(staticFileSuffixes.toArray(new String[0])), resource(resourceManager),
                    dynamicHandlers
                )
            )
            .build();

}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
@Override
protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    String path = getPath(req);
    if (!isAllowed(path, req.getDispatcherType())) {
        resp.sendError(StatusCodes.NOT_FOUND);
        return;
    }
    if (File.separatorChar != '/') {
        //if the separator char is not / we want to replace it with a / and canonicalise
        path = CanonicalPathUtils.canonicalize(path.replace(File.separatorChar, '/'));
    }
    final Resource resource;
    //we want to disallow windows characters in the path
    if (File.separatorChar == '/' || !path.contains(File.separator)) {
        resource = resourceManager.getResource(path);
    } else {
        resource = null;
    }

    if (resource == null) {
        if (req.getDispatcherType() == DispatcherType.INCLUDE) {
            //servlet 9.3
            throw new FileNotFoundException(path);
        } else {
            resp.sendError(StatusCodes.NOT_FOUND);
        }
        return;
    } else if (resource.isDirectory()) {
        if ("css".equals(req.getQueryString())) {
            resp.setContentType("text/css");
            resp.getWriter().write(DirectoryUtils.Blobs.FILE_CSS);
            return;
        } else if ("js".equals(req.getQueryString())) {
            resp.setContentType("application/javascript");
            resp.getWriter().write(DirectoryUtils.Blobs.FILE_JS);
            return;
        }
        if (directoryListingEnabled) {
            StringBuilder output = DirectoryUtils.renderDirectoryListing(req.getRequestURI(), resource);
            resp.getWriter().write(output.toString());
        } else {
            resp.sendError(StatusCodes.FORBIDDEN);
        }
    } else {
        if (path.endsWith("/")) {
            //UNDERTOW-432
            resp.sendError(StatusCodes.NOT_FOUND);
            return;
        }
        serveFileBlocking(req, resp, resource);
    }
}
 

import io.undertow.server.handlers.resource.Resource; //导入依赖的package包/类
@Override
protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) throws ServletException, IOException {
    String path = getPath(req);
    if (!isAllowed(path, req.getDispatcherType())) {
        resp.sendError(StatusCodes.NOT_FOUND);
        return;
    }
    if(File.separatorChar != '/') {
        //if the separator char is not / we want to replace it with a / and canonicalise
        path = CanonicalPathUtils.canonicalize(path.replace(File.separatorChar, '/'));
    }
    final Resource resource;
    //we want to disallow windows characters in the path
    if(File.separatorChar == '/' || !path.contains(File.separator)) {
        resource = resourceManager.getResource(path);
    } else {
        resource = null;
    }

    if (resource == null) {
        if (req.getDispatcherType() == DispatcherType.INCLUDE) {
            //servlet 9.3
            throw new FileNotFoundException(path);
        } else {
            resp.sendError(StatusCodes.NOT_FOUND);
        }
        return;
    } else if (resource.isDirectory()) {
        if ("css".equals(req.getQueryString())) {
            resp.setContentType("text/css");
            resp.getWriter().write(DirectoryUtils.Blobs.FILE_CSS);
            return;
        } else if ("js".equals(req.getQueryString())) {
            resp.setContentType("application/javascript");
            resp.getWriter().write(DirectoryUtils.Blobs.FILE_JS);
            return;
        }
        if (directoryListingEnabled) {
            StringBuilder output = DirectoryUtils.renderDirectoryListing(req.getRequestURI(), resource);
            resp.getWriter().write(output.toString());
        } else {
            resp.sendError(StatusCodes.FORBIDDEN);
        }
    } else {
        if(path.endsWith("/")) {
            //UNDERTOW-432
            resp.sendError(StatusCodes.NOT_FOUND);
            return;
        }
        serveFileBlocking(req, resp, resource);
    }
}