| Methods Summary |
|---|
| private java.lang.Object | doPrivileged(ApplicationContext appContext, java.lang.String methodName, java.lang.Object[] params)Use reflection to invoke the requested method. Cache the method object
to speed up the process
try{
return invokeMethod(appContext, methodName, params );
} catch (Throwable t){
throw new RuntimeException(t.getMessage());
}
|
| private java.lang.Object | doPrivileged(java.lang.String methodName, java.lang.Object[] params)Use reflection to invoke the requested method. Cache the method object
to speed up the process
will be invoked
try{
return invokeMethod(context, methodName, params);
}catch(Throwable t){
throw new RuntimeException(t.getMessage());
}
|
| private java.lang.Object | doPrivileged(java.lang.String methodName, java.lang.Class[] clazz, java.lang.Object[] params)Use reflection to invoke the requested method. Cache the method object
to speed up the process
try{
Method method = context.getClass()
.getMethod(methodName, (Class[])clazz);
return executeMethod(method,context,params);
} catch (Exception ex){
try{
handleException(ex, methodName);
}catch (Throwable t){
throw new RuntimeException(t.getMessage());
}
return null;
} finally {
params = null;
}
|
| private java.lang.Object | executeMethod(java.lang.reflect.Method method, ApplicationContext context, java.lang.Object[] params)Executes the method of the specified ApplicationContext
if (SecurityUtil.isPackageProtectionEnabled()){
return AccessController.doPrivileged(new PrivilegedExceptionAction(){
public Object run() throws IllegalAccessException, InvocationTargetException{
return method.invoke(context, params);
}
});
} else {
return method.invoke(context, params);
}
|
| public java.lang.Object | getAttribute(java.lang.String name)
if (SecurityUtil.isPackageProtectionEnabled()) {
return doPrivileged("getAttribute", new Object[]{name});
} else {
return context.getAttribute(name);
}
|
| public java.util.Enumeration | getAttributeNames()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (Enumeration) doPrivileged("getAttributeNames", null);
} else {
return context.getAttributeNames();
}
|
| public javax.servlet.ServletContext | getContext(java.lang.String uripath)
// ------------------------------------------------- ServletContext Methods
ServletContext theContext = null;
if (SecurityUtil.isPackageProtectionEnabled()) {
theContext = (ServletContext)
doPrivileged("getContext", new Object[]{uripath});
} else {
theContext = context.getContext(uripath);
}
if ((theContext != null) &&
(theContext instanceof ApplicationContext)){
theContext = ((ApplicationContext)theContext).getFacade();
}
return (theContext);
|
| public java.lang.String | getContextPath()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String) doPrivileged("getContextPath", null);
} else {
return context.getContextPath();
}
|
| public java.lang.String | getInitParameter(java.lang.String name)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String) doPrivileged("getInitParameter",
new Object[]{name});
} else {
return context.getInitParameter(name);
}
|
| public java.util.Enumeration | getInitParameterNames()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (Enumeration) doPrivileged("getInitParameterNames", null);
} else {
return context.getInitParameterNames();
}
|
| public int | getMajorVersion()
return context.getMajorVersion();
|
| public java.lang.String | getMimeType(java.lang.String file)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String)doPrivileged("getMimeType", new Object[]{file});
} else {
return context.getMimeType(file);
}
|
| public int | getMinorVersion()
return context.getMinorVersion();
|
| public javax.servlet.RequestDispatcher | getNamedDispatcher(java.lang.String name)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (RequestDispatcher) doPrivileged("getNamedDispatcher",
new Object[]{name});
} else {
return context.getNamedDispatcher(name);
}
|
| public java.lang.String | getRealPath(java.lang.String path)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String) doPrivileged("getRealPath", new Object[]{path});
} else {
return context.getRealPath(path);
}
|
| public javax.servlet.RequestDispatcher | getRequestDispatcher(java.lang.String path)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (RequestDispatcher) doPrivileged("getRequestDispatcher",
new Object[]{path});
} else {
return context.getRequestDispatcher(path);
}
|
| public java.net.URL | getResource(java.lang.String path)
if (Globals.IS_SECURITY_ENABLED) {
try {
return (URL) invokeMethod(context, "getResource",
new Object[]{path});
} catch(Throwable t) {
if (t instanceof MalformedURLException){
throw (MalformedURLException)t;
}
return null;
}
} else {
return context.getResource(path);
}
|
| public java.io.InputStream | getResourceAsStream(java.lang.String path)
if (SecurityUtil.isPackageProtectionEnabled()) {
return (InputStream) doPrivileged("getResourceAsStream",
new Object[]{path});
} else {
return context.getResourceAsStream(path);
}
|
| public java.util.Set | getResourcePaths(java.lang.String path)
if (SecurityUtil.isPackageProtectionEnabled()){
return (Set)doPrivileged("getResourcePaths", new Object[]{path});
} else {
return context.getResourcePaths(path);
}
|
| public java.lang.String | getServerInfo()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String) doPrivileged("getServerInfo", null);
} else {
return context.getServerInfo();
}
|
| public javax.servlet.Servlet | getServlet(java.lang.String name)
if (SecurityUtil.isPackageProtectionEnabled()) {
try {
return (Servlet) invokeMethod(context, "getServlet",
new Object[]{name});
} catch (Throwable t) {
if (t instanceof ServletException) {
throw (ServletException) t;
}
return null;
}
} else {
return context.getServlet(name);
}
|
| public java.lang.String | getServletContextName()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (String) doPrivileged("getServletContextName", null);
} else {
return context.getServletContextName();
}
|
| public java.util.Enumeration | getServletNames()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (Enumeration) doPrivileged("getServletNames", null);
} else {
return context.getServletNames();
}
|
| public java.util.Enumeration | getServlets()
if (SecurityUtil.isPackageProtectionEnabled()) {
return (Enumeration) doPrivileged("getServlets", null);
} else {
return context.getServlets();
}
|
| private void | handleException(java.lang.Exception ex, java.lang.String methodName)Throw the real exception.
Throwable realException;
if (ex instanceof PrivilegedActionException) {
ex = ((PrivilegedActionException) ex).getException();
}
if (ex instanceof InvocationTargetException) {
realException =
((InvocationTargetException) ex).getTargetException();
} else {
realException = ex;
}
throw realException;
|
| private void | initClassCache()
Class[] clazz = new Class[]{String.class};
classCache.put("getContext", clazz);
classCache.put("getMimeType", clazz);
classCache.put("getResourcePaths", clazz);
classCache.put("getResource", clazz);
classCache.put("getResourceAsStream", clazz);
classCache.put("getRequestDispatcher", clazz);
classCache.put("getNamedDispatcher", clazz);
classCache.put("getServlet", clazz);
classCache.put("getInitParameter", clazz);
classCache.put("setAttribute", new Class[]{String.class, Object.class});
classCache.put("removeAttribute", clazz);
classCache.put("getRealPath", clazz);
classCache.put("getAttribute", clazz);
classCache.put("log", clazz);
|
| private java.lang.Object | invokeMethod(ApplicationContext appContext, java.lang.String methodName, java.lang.Object[] params)Use reflection to invoke the requested method. Cache the method object
to speed up the process
try{
Method method = (Method)objectCache.get(methodName);
if (method == null){
method = appContext.getClass()
.getMethod(methodName, (Class[])classCache.get(methodName));
objectCache.put(methodName, method);
}
return executeMethod(method,appContext,params);
} catch (Exception ex){
handleException(ex, methodName);
return null;
} finally {
params = null;
}
|
| public void | log(java.lang.String msg)
if (SecurityUtil.isPackageProtectionEnabled()) {
doPrivileged("log", new Object[]{msg} );
} else {
context.log(msg);
}
|
| public void | log(java.lang.Exception exception, java.lang.String msg)
if (SecurityUtil.isPackageProtectionEnabled()) {
doPrivileged("log", new Class[]{Exception.class, String.class},
new Object[]{exception,msg});
} else {
context.log(exception, msg);
}
|
| public void | log(java.lang.String message, java.lang.Throwable throwable)
if (SecurityUtil.isPackageProtectionEnabled()) {
doPrivileged("log", new Class[]{String.class, Throwable.class},
new Object[]{message, throwable});
} else {
context.log(message, throwable);
}
|
| public void | removeAttribute(java.lang.String name)
if (SecurityUtil.isPackageProtectionEnabled()) {
doPrivileged("removeAttribute", new Object[]{name});
} else {
context.removeAttribute(name);
}
|
| public void | setAttribute(java.lang.String name, java.lang.Object object)
if (SecurityUtil.isPackageProtectionEnabled()) {
doPrivileged("setAttribute", new Object[]{name,object});
} else {
context.setAttribute(name, object);
}
|
