下面列出了javax.servlet.ServletContext#getResourceAsStream ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Override
public Reader locate(String templatePath) {
ServletContext ctx = getServletContext();
if (ctx == null) {
throw new MustacheException(MustacheProblem.TEMPLATE_LOADING_ERROR,
"Servlet context not available");
}
String path = getRootPath() + addSuffix(toRealPath(templatePath));
InputStream in = ctx.getResourceAsStream(path);
if (in == null) {
LOGGER.debug("Template not found: {}", path);
return null;
}
LOGGER.debug("Template located: {}", templatePath);
try {
return new InputStreamReader(in, getDefaultFileEncoding());
} catch (UnsupportedEncodingException e) {
throw new MustacheException(MustacheProblem.TEMPLATE_LOADING_ERROR,
e);
}
}
/**
* Load the resource for the given resourcePath from the servlet context.
*
* @param servletContext the application servlet context
* @param resourcePath the path of the resource to load
* @return the byte array for the given resource path
* @throws IOException if the resource could not be loaded
*/
private byte[] getServletResourceData(ServletContext servletContext,
String resourcePath) throws IOException {
InputStream inputStream = null;
try {
inputStream = servletContext.getResourceAsStream(resourcePath);
if (inputStream != null) {
return IOUtils.toByteArray(inputStream);
} else {
return null;
}
} finally {
if (null != inputStream) {
inputStream.close();
}
// ClickUtils.close(inputStream);
}
}
private InputStream getResourceAsStream(ServletContext servletContext, String host, String contextPath,
String fileName) {
String paths[] = { String.format("/WEB-INF/config/%s/%s", host, fileName),
String.format("/WEB-INF/config/%s%s/%s", host, contextPath, fileName),
String.format("/WEB-INF/config/default/%s", fileName) };
InputStream is = null;
int idx = 0;
do {
is = servletContext.getResourceAsStream(paths[idx]);
idx++;
} while (is == null && idx < paths.length);
if (is != null) {
logger.info("Loading {} file from path {}", fileName, paths[--idx]);
}
return is;
}
private Model loadMetadataTemplate(D2RServer server,
ServletContext context, Property configurationFlag,
String defaultTemplateName) {
Model metadataTemplate;
File userTemplateFile = MetadataCreator.findTemplateFile(server,
configurationFlag);
Model userResourceTemplate = MetadataCreator
.loadTemplateFile(userTemplateFile);
if (userResourceTemplate != null && userResourceTemplate.size() > 0) {
metadataTemplate = userResourceTemplate;
log.info("Using user-specified metadata template at '"
+ userTemplateFile + "'");
} else {
// load default template
InputStream drtStream = context.getResourceAsStream("/WEB-INF/"
+ defaultTemplateName);
log.info("Using default metadata template.");
metadataTemplate = MetadataCreator.loadMetadataTemplate(drtStream);
}
return metadataTemplate;
}
private Properties loadHibernateProperties(ServletContext context) {
try {
// for enterprise builds, hibernate.properties is in the 'classes' dir
InputStream is = context.getResourceAsStream("/WEB-INF/classes/hibernate.properties");
// for installer builds, its in the 'yawllib' dir
if (is == null) {
File f = new File(System.getenv("CATALINA_HOME") + "/yawllib/hibernate.properties");
if (f != null && f.exists()) {
is = new FileInputStream(f);
}
}
if (is != null) {
Properties p = new Properties();
p.load(is);
return p;
}
}
catch (Exception fallthough) { }
return null;
}
private String getVersion(ServletContext context) {
InputStream in = context.getResourceAsStream(MANIFEST);
if (in != null) {
Properties p = new Properties();
try {
p.load(new ByteArrayInputStream(Utility.getInstance().stream2bytes(in)));
return p.getProperty(IMPL_VERSION);
} catch (IOException e) {
// nothing we can do
}
}
return null;
}
private static void init(ServletContext servletContext)
{
try
{
InputStream in = servletContext.getResourceAsStream(ResourceConfigReader.CONFIG_FILE);
resourceConfig = ResourceConfigReader.getFactory().parse(in);
resourceConfig.initialized(); // Lets the resource config set defaults
}
catch (Exception e)
{
throw new DriverConfigurationException(e);
}
}
/**
* Find by pk with a default value
*/
public static ConfigStoredFile getFile(String key, String path, ServletContext sc) throws DatabaseException,
IOException {
InputStream is = null;
try {
if (sc == null) {
is = Thread.currentThread().getContextClassLoader().getResourceAsStream(path);
} else {
is = sc.getResourceAsStream(path);
}
ConfigStoredFile stFile = new ConfigStoredFile();
if (is == null) {
stFile.setContent("");
} else {
stFile.setContent(SecureStore.b64Encode(IOUtils.toByteArray(is)));
}
stFile.setName(PathUtils.getName(path));
stFile.setMime(MimeTypeConfig.mimeTypes.getContentType(stFile.getName()));
// MIME still are not initialized from database
if (MimeTypeConfig.MIME_UNDEFINED.equals(stFile.getMime())) {
if (stFile.getName().toLowerCase().endsWith(".ico")) {
stFile.setMime(MimeTypeConfig.MIME_ICO);
}
}
String value = getProperty(key, new Gson().toJson(stFile), Config.FILE);
return new Gson().fromJson(value, ConfigStoredFile.class);
} finally {
IOUtils.closeQuietly(is);
}
}
@DesireNoWarning("NP_LOAD_OF_KNOWN_NULL_VALUE")
public String falsePositive (ServletContext servletContext) throws IOException {
try (InputStream inputStream = servletContext.getResourceAsStream("/META-INF/MANIFEST.MF")) {
if (inputStream == null) {
return "#InDevelopment#";
}
return new Manifest(inputStream).getMainAttributes().getValue("Implementation-Version");
}
}
/**
* Endpoint to verify scm and version details
*
* @return {@link Attributes}
* @statuscode 200 Successful response for your request with manifest's attributes
* @statuscode 404 Not found version information
*/
@GET
@Path("/version")
@Produces(MediaType.APPLICATION_JSON)
public Response manifestDetails(@Context HttpServletRequest request) {
final ServletContext context = request.getSession().getServletContext();
try (final InputStream manifestStream = context.getResourceAsStream("/META-INF/MANIFEST.MF")) {
return Response.ok(new Manifest(manifestStream).getMainAttributes()).build();
} catch (Exception e) {
return Response.status(Response.Status.NOT_FOUND).entity("Could not find version information").build();
}
}
static protected String getText(String path, ServletContext servletContext) throws Throwable {
String text = null;
InputStream is = null;
try {
is = servletContext.getResourceAsStream(path);
text = FileTextReader.getText(is);
} catch (Throwable t) {
throw new ApsSystemException("Error readind text", t);
} finally {
if (null != is) {
is.close();
}
}
return text;
}
@Override
public void doTag() throws JspException, IOException {
final JspWriter writer = this.getJspContext().getOut();
final PageContext pageContext = (PageContext) this.getJspContext();
final ServletContext sc = pageContext.getServletContext();
InputStream in = sc.getResourceAsStream(this.path);
InputStreamReader reader = new InputStreamReader(in);
this.write(reader, writer);
}
public static InputStream getInputStream(final String path, final ServletContext application)
{
InputStream inputStream = null;
if (!isWebappResource(path))
{
// search classpath except for WEB-INF/*
inputStream = ClassUtils.getResourceAsStream(path, ServletUtils.class);
}
else
{
// then webapp only for WEB-INF/*
if (System.getSecurityManager() != null)
{
inputStream = AccessController.doPrivileged(
new PrivilegedAction<InputStream>()
{
@Override
public InputStream run()
{
return application.getResourceAsStream(path);
}
});
}
else
{
inputStream = application.getResourceAsStream(path);
}
}
return inputStream;
}
@Override
public void handleDeployment(DeploymentInfo deploymentInfo, ServletContext servletContext) {
String componentName = "";
String resourceName = "";
Pattern insecureEndpointPattern = null;
Pattern postQueryPattern = null;
// file to contain configurations options for this Servlet Extension
InputStream is = servletContext.getResourceAsStream(PROPERTY_FILE);
if (is != null) {
try {
Properties props = new Properties();
props.load(is);
componentName = props.getProperty("component");
resourceName = props.getProperty("resource-name");
String insecurePatternString = props.getProperty("unsecure-endpoints");
String postQueryPatternString = props.getProperty("post-query");
if (insecurePatternString != null) {
insecureEndpointPattern = Pattern.compile(insecurePatternString);
}
if (postQueryPatternString != null) {
postQueryPattern = Pattern.compile(postQueryPatternString);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if (componentName == null || componentName.isEmpty()) {
throw new RuntimeException("Missing or empty 'component' key from the " + PROPERTY_FILE + " configuration file.");
}
if (resourceName == null || resourceName.isEmpty()) {
throw new RuntimeException("Missing or empty 'resource-name' key from the " + PROPERTY_FILE + " configuratin file.");
}
final String cName = componentName;
final String rName = resourceName;
final Pattern insecurePattern = insecureEndpointPattern;
final Pattern postQuery = postQueryPattern;
if (DISABLE_NAMESPACE_FILTER.equalsIgnoreCase("true")) {
log.info("The OpenShift Namespace Filter has been disabled via the 'DISABLE_NAMESPACE_FILTER' system property.");
}
else {
log.info("Enabling the OpenShift Namespace Filter.");
deploymentInfo.addInitialHandlerChainWrapper(containerHandler -> {
namespaceHandler = new NamespaceHandler(containerHandler);
return namespaceHandler;
});
}
ImmediateInstanceFactory<EventListener> instanceFactory = new ImmediateInstanceFactory<>(new SCListener());
deploymentInfo.addListener(new ListenerInfo(SCListener.class, instanceFactory));
deploymentInfo.addInitialHandlerChainWrapper(containerHandler -> {
openshiftAuthHandler = new OpenshiftAuthHandler(containerHandler, cName, rName, insecurePattern, postQuery);
return openshiftAuthHandler;
});
}
@Override
protected InputStream getApplicationResourceAsStream(Class<?> contextClass, String fileName) {
ServletContext servletContext = VaadinServlet.getCurrent().getServletContext();
return servletContext.getResourceAsStream("/VAADIN/" + fileName);
}
protected void loadPropertiesFromConfig(ServletContext sc, Properties properties, String propsConfigName) {
SpringProfileSpecificNameResolver nameResolver = new SpringProfileSpecificNameResolver(sc);
DefaultResourceLoader resourceLoader = new DefaultResourceLoader();
StringTokenizer tokenizer = new StringTokenizer(propsConfigName);
tokenizer.setQuoteChar('"');
for (String str : tokenizer.getTokenArray()) {
log.trace("Processing properties location: {}", str);
String baseName = StringSubstitutor.replaceSystemProperties(str);
for (String name : nameResolver.getDerivedNames(baseName)) {
InputStream stream = null;
try {
if (ResourceUtils.isUrl(name) || name.startsWith(ResourceLoader.CLASSPATH_URL_PREFIX)) {
Resource resource = resourceLoader.getResource(name);
if (resource.exists())
stream = resource.getInputStream();
} else {
stream = sc.getResourceAsStream(name);
}
if (stream != null) {
log.info("Loading app properties from {}", name);
BOMInputStream bomInputStream = new BOMInputStream(stream);
try (Reader reader = new InputStreamReader(bomInputStream, StandardCharsets.UTF_8)) {
properties.load(reader);
}
} else {
log.trace("Resource {} not found, ignore it", name);
}
} catch (IOException e) {
throw new RuntimeException("Unable to read properties from stream", e);
} finally {
try {
if (stream != null) {
stream.close();
}
} catch (final IOException ioe) {
// ignore
}
}
}
}
}
public String get(String resourceName,ServletContext servletContext) {
String json=null;
if(!cache.containsKey(resourceName)){
InputStream is = servletContext.getResourceAsStream(
"/META-INF" +resourceName+ ".properties");
Properties properties = new Properties();
try {
properties.load(is);
json=util.getJson(properties);
} catch (IOException e) {
e.printStackTrace();
}
}
return json;
}
/**
* Initialisation.
* @throws IOException e
* @throws ServletException e
*/
@Before
public void setUp() throws IOException, ServletException {
tearDown();
Utils.initialize();
Utils.setProperty(Parameters.PARAMETER_SYSTEM_PREFIX + "mockLabradorRetriever", TRUE);
Utils.setProperty(Parameter.SYSTEM_ACTIONS_ENABLED, TRUE);
final ServletConfig config = createNiceMock(ServletConfig.class);
final ServletContext context = createNiceMock(ServletContext.class);
expect(config.getServletContext()).andReturn(context).anyTimes();
collectorServlet = new CollectorServlet();
InputStream webXmlStream = null;
try {
webXmlStream = getClass().getResourceAsStream("/WEB-INF/web.xml");
InputStream webXmlStream2 = null;
try {
webXmlStream2 = context.getResourceAsStream("/WEB-INF/web.xml");
expect(webXmlStream2).andReturn(webXmlStream).anyTimes();
final String javamelodyDir = "/META-INF/maven/net.bull.javamelody/";
final String webapp = javamelodyDir + "javamelody-test-webapp/";
expect(context.getResourcePaths("/META-INF/maven/"))
.andReturn(Collections.singleton(javamelodyDir)).anyTimes();
expect(context.getResourcePaths(javamelodyDir))
.andReturn(Collections.singleton(webapp)).anyTimes();
expect(context.getResourceAsStream(webapp + "pom.xml"))
.andReturn(getClass().getResourceAsStream("/pom.xml")).anyTimes();
replay(config);
replay(context);
collectorServlet.init(config);
verify(config);
verify(context);
} finally {
if (webXmlStream2 != null) {
webXmlStream2.close();
}
}
} finally {
if (webXmlStream != null) {
webXmlStream.close();
}
}
}
@Override
public void contextInitialized(ServletContextEvent sce) {
ServletContext servletContext = sce.getServletContext();
String configResolverClass = servletContext.getInitParameter("keycloak.config.resolver");
SamlDeploymentContext deploymentContext = (SamlDeploymentContext) servletContext.getAttribute(SamlDeployment.class.getName());
if (deploymentContext == null) {
if (configResolverClass != null) {
try {
SamlConfigResolver configResolver = (SamlConfigResolver) servletContext.getClassLoader().loadClass(configResolverClass).newInstance();
deploymentContext = new SamlDeploymentContext(configResolver);
log.infov("Using {0} to resolve Keycloak configuration on a per-request basis.", configResolverClass);
} catch (Exception ex) {
log.errorv("The specified resolver {0} could NOT be loaded. Keycloak is unconfigured and will deny all requests. Reason: {1}", new Object[] { configResolverClass, ex.getMessage() });
deploymentContext = new SamlDeploymentContext(new DefaultSamlDeployment());
}
} else {
InputStream is = getConfigInputStream(servletContext);
final SamlDeployment deployment;
if (is == null) {
log.warn("No adapter configuration. Keycloak is unconfigured and will deny all requests.");
deployment = new DefaultSamlDeployment();
} else {
try {
ResourceLoader loader = new ResourceLoader() {
@Override
public InputStream getResourceAsStream(String resource) {
return servletContext.getResourceAsStream(resource);
}
};
deployment = new DeploymentBuilder().build(is, loader);
} catch (ParsingException e) {
throw new RuntimeException(e);
}
}
deploymentContext = new SamlDeploymentContext(deployment);
log.debug("Keycloak is using a per-deployment configuration.");
}
}
addTokenStoreUpdaters(servletContext);
servletContext.setAttribute(ADAPTER_DEPLOYMENT_CONTEXT_ATTRIBUTE, deploymentContext);
servletContext.setAttribute(ADAPTER_DEPLOYMENT_CONTEXT_ATTRIBUTE_ELYTRON, deploymentContext);
servletContext.setAttribute(ADAPTER_SESSION_ID_MAPPER_ATTRIBUTE_ELYTRON, idMapper);
servletContext.setAttribute(ADAPTER_SESSION_ID_MAPPER_UPDATER_ATTRIBUTE_ELYTRON, idMapperUpdater);
}
/**
* Increases the maximum column length for stored documents in H2 databases from 255
* to 5Mb.
* <p/>
* H2 defaults to 255 chars for binary types, and this default went out
* with the 2.3 release. This method (1) checks if we are using a H2 database, then
* if so (2) checks the relevant column length, then if it is 255 (3) increases it
* to 5Mb maximum and (4) writes a flag file so that the method short-circuits on
* future executions (i.e. it only runs once).
*
* @param context the current servlet context
*/
private void fixH2BinarySize(ServletContext context) {
// if the flag files already exists, go no further
if (context.getResourceAsStream("/WEB-INF/classes/dbfixed.bin") != null) {
return;
}
// get the db properties from hibernate.properties
Properties p = loadHibernateProperties(context);
if (p == null) return; // couldn't find hibernate.properties
Connection connection = null;
try {
String dialect = p.getProperty("hibernate.dialect");
// proceed only if this is a H2 database
if (dialect != null && dialect.equals("org.hibernate.dialect.H2Dialect")) {
Class.forName(p.getProperty("hibernate.connection.driver_class"));
String url = p.getProperty("hibernate.connection.url");
if (url == null) return; // nothing to connect to
url = url.replace("${catalina.base}", System.getenv("CATALINA_HOME"));
connection = DriverManager.getConnection(url);
if (connection != null) {
// get the YDOC column size, and increase if required
DatabaseMetaData dbmd = connection.getMetaData();
ResultSet rs = dbmd.getColumns(null, null, "YDOCUMENT", "YDOC");
rs.next();
if (rs.getInt("COLUMN_SIZE") <= 255) {
connection.createStatement().executeUpdate(
"ALTER TABLE ydocument ALTER COLUMN ydoc varbinary(5242880)");
// write flag file for next time
new File(context.getRealPath("WEB-INF/classes/dbfixed.bin")).createNewFile();
}
connection.close();
}
}
} catch (Exception e) {
// can't update
}
if (connection != null) {
try {
connection.close();
} catch (SQLException sqle) {
//
}
}
}