I have set my error page like this in web.xml:
<error-page>
<exception-type>java.lang.Exception</exception-type>
<location>/errors/error.jsp</location>
</error-page>
Now I would like to print stack trace of error on JSP (of course in development mode only). How can I print stack trace of error on my JSP page? I don't use any frameworks for this application, so only default servlet APIs are available for my program.
get the parameter from request that is set internally and use it to print and deal with other information like cause, message
<c:set var="exception" value="${requestScope['javax.servlet.error.exception']}"/>
and to print stacktrace
<!-- Stack trace -->
<jsp:scriptlet>
exception.printStackTrace(new java.io.PrintWriter(out));
</jsp:scriptlet>
See Also
The following parameters will be set by the container when request is forwarded to the error page.
In your error JSP do this,
<%request.getAttribute("javax.servlet.error.exception").printStackTrace(new java.io.PrintWriter(out))%>;
Or Else If your error page is defined as Error page with Page Directive like,
<%@ page isErrorPage="true" import="java.io.*"%>
The exception scripting variable will be declared in the JSP. You can printing the scripting variable using a scriptlet using,
exception.printStackTrace(new java.io.PrintWriter(out));
Or,
<jsp:scriptlet>
exception.printStackTrace(response.getWriter())
</jsp:scriptlet>
Using JSP scriptlets is a frowned upon practice since a decade. You'd best avoid it.
If you're already on EL 2.2 or newer (Tomcat 7+, JBoss AS 6+, WildFly, GlassFish 3+, etc), with new support for method expressions of the form ${instance.method()}, then you can just use 100% EL for this.
First you need to explicitly flush the JSP writer via JspWriter#flush(), so that all preceding JSP template output really gets written to the writer of the servlet response:
${pageContext.out.flush()}
Then you can just pass ServletResponse#getWriter() to Throwable#printStackTrace().
${exception.printStackTrace(pageContext.response.writer)}
Complete example:
<%@page pageEncoding="UTF-8" isErrorPage="true" %>
...
<pre>${pageContext.out.flush()}${exception.printStackTrace(pageContext.response.writer)}</pre>
If you're already on EL 3.0 (Tomcat 8+, WildFly, GlassFish 4+, etc), you can even make it a single expression with the new semicolon operator which separates EL statements:
<%@page pageEncoding="UTF-8" isErrorPage="true" %>
...
<pre>${pageContext.out.flush();exception.printStackTrace(pageContext.response.writer)}</pre>
If you can't use isErrorPage="true" for some reason (and thus ${exception} implicit object isn't available), then just substitute with ${requestScope['javax.servlet.error.exception']}:
<%@page pageEncoding="UTF-8" %>
...
<pre>${pageContext.out.flush()}${requestScope['javax.servlet.error.exception'].printStackTrace(pageContext.response.writer)}</pre>
If you're still not on EL 2.2, then your best bet is creating a custom EL function. Detail can be found in What is the good approach to forward the exception from servlets to a jsp page?
Below is a more complete error page example with more detail:
<%@page pageEncoding="UTF-8" isErrorPage="true" %>
<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
...
<ul>
<li>Exception: <c:out value="${requestScope['javax.servlet.error.exception']}" /></li>
<li>Exception type: <c:out value="${requestScope['javax.servlet.error.exception_type']}" /></li>
<li>Exception message: <c:out value="${requestScope['javax.servlet.error.message']}" /></li>
<li>Request URI: <c:out value="${requestScope['javax.servlet.error.request_uri']}" /></li>
<li>Servlet name: <c:out value="${requestScope['javax.servlet.error.servlet_name']}" /></li>
<li>Status code: <c:out value="${requestScope['javax.servlet.error.status_code']}" /></li>
<li>Stack trace: <pre>${pageContext.out.flush()}${exception.printStackTrace(pageContext.response.writer)}</pre></li>
</ul>
Or, to avoid using scriptlets in your jsp, use jstl:
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
...
<c:set var="exception" value="${requestScope['javax.servlet.error.exception']}"/>
<c:if test="${exception != null}">
<h4>${exception}</h4>
<c:forEach var="stackTraceElem" items="${exception.stackTrace}">
<c:out value="${stackTraceElem}"/><br/>
</c:forEach>
</c:if>
Ideally, scriptlets should be disallowed as a best practice. Explicitly prevent scriplets in you jsp files via the web.xml configuration:
<jsp-config>
<jsp-property-group>
<url-pattern>*.jsp</url-pattern>
<scripting-invalid>true</scripting-invalid>
</jsp-property-group>
</jsp-config>
On the error page, just do:
<jsp:scriptlet>
exception.printStackTrace(response.getWriter())
</jsp:scriptlet>
Although this begs the question: what is a user going to do with an exception. Why not write the exception to the error log so it is persisted and you can go back to it after a user complains?
Thrown Exception object is available as request attribute with name 'javax.servlet.error.exception'. So, in your JSP, you can write:
<% request.getAttribute("javax.servlet.error.exception").printStackTrace(new java.io.PrintWriter(out); %>
You can use jstl core library
1) Import tablib on top of JSP file
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
2) use tag
<c:catch var="myExceptionObject">
Code that might throw Exception
</c:catch>
<c:if test="${myExceptionObject} != null">
There was an exception: ${myExceptionObject.message}
</c:if>
In the error.jsp add the below lines
<%Logger log = Logger.getLogger("error_jsp.class");
Exception e = (Exception)request.getAttribute("javax.servlet.error.exception");
log.debug(request.getAttribute("javax.servlet.error.message"));
e.printStackTrace();
log.debug(e.getStackTrace());%>
