创建自定义ErrorReportValveClass Tomcat

大家好，我不希望用户在异常期间看到tomcat生成的错误页面，我尝试通过两种方式实现这一点，
1.扩展

ValveBase

类，并在的帮助下创建自己的

ErrorReportClass

版本。现在根据Tomcat文档 我需要为

server.xml

中的

Host

标记的

errorReportValveClass

属性指定类名，我这样做了，我还将该类转换为

.jar

文件以及其他所需的

jar

，把它放在

Tomcat

的

lib

文件夹中，但当我启动服务器时，它说

ErrorReportClass

找不到，这是我的代码 （请参阅负责打印错误的

report（）

方法）

/*
*要更改此许可证标题，请在“项目属性”中选择“许可证标题”。
*要更改此模板文件，请选择工具|模板
*然后在编辑器中打开模板。
*/
导入java.io.IOException；
导入java.io.Writer；
导入javax.servlet.ServletException；
导入javax.servlet.http.HttpServletResponse；
导入org.apache.catalina.Globals；
导入org.apache.catalina.connector.Constants；
导入org.apache.catalina.connector.Request；
导入org.apache.catalina.connector.Response；
导入org.apache.catalina.util.RequestUtil；
导入org.apache.catalina.util.StringManager；
导入org.apache.catalina.valves.ValveBase；
导入org.apache.tomcat.util.ExceptionUtils；
/**
*
*@作者Kainix
*/
公共类ErrorReportValve扩展ValveBase{
公共错误报告阀（）{
超级（）；
}
/**
*与此实现相关的描述性信息。
*/
私有静态最终字符串信息
=“org.apache.catalina.valves.ErrorReportValve/1.0”；
/**
*此包的StringManager。
*/
受保护的静态最终StringManager sm=StringManager.getManager（Constants.Package）；
//-------------------------------------------------------------属性
/**
*返回有关此阀门实施的描述性信息。
*/
@凌驾
公共字符串getInfo（）{
返回（信息）；
}
/**
*调用序列中的下一个阀门。当调用返回时，检查响应状态，并输出错误报告。
*
*@param request要处理的servlet请求
*@param response要创建的servlet响应
*
*@exception IOException如果发生输入/输出错误
*@exception ServletException如果发生servlet错误
*/
@凌驾
公共void调用（请求、响应）
抛出IOException、ServletException{
//执行请求
getNext（）.invoke（请求、响应）；
if（response.isCommitted（））{
返回；
}
//如果（！request.isAsyncStarted（））{
//}其他{
//返回；
//        }
丢弃的
=（可丢弃）request.getAttribute（Globals.EXCEPTION\u ATTR）；
if（可丢弃！=null）{
//该响应是一个错误
response.setError（）；
//重置响应（如果可能）
试一试{
response.reset（）；
}捕获（非法状态）{
//忽略
}
senderError（HttpServletResponse.SC_内部_服务器_错误）；
}
响应。设置暂停（错误）；
试一试{
报告（请求、响应、可丢弃）；
}捕获（可丢弃tt）{
例外情况。可手动旋转（tt）；
}
}
/**
*打印错误报告。
*
*@param request正在处理的请求
*@param response正在生成的响应
*@param throwable发生的异常（可能包装了根本原因异常）
*/
受保护无效报告（请求、响应、，
可丢弃的（可丢弃的）{
//对非HTTP响应不执行任何操作
int statusCode=response.getStatus（）；
//在1xx、2xx和3xx状态下不执行任何操作
//如果已经写了什么，什么也不要做
if（（状态代码<400）| |（response.getContentCount（）>0））{
返回；
}
String message=RequestUtil.filter（response.getMessage（））；
如果（消息==null）{
message=“”；
}
StringBuilder sb=新的StringBuilder（）；
某人加上（“”）；
某人加上（“”）；
sb.append（“这是自定义错误页..！！”；
某人加上（“”）；
试一试{
试一试{
response.setContentType（“text/html”）；
响应。setCharacterEncoding（“utf-8”）；
}捕获（可丢弃的t）{
if（container.getLogger（）.isDebugEnabled（））{
container.getLogger（）.debug（“status.setContentType”，t）；
}
}
Writer=response.getReporter（）；
if（writer！=null）{
//如果writer为null，则表示响应已被删除
//已经做出了艰难的承诺，这是不应该发生的
写（某人写的东西）；
}
}捕获（IOException |非法状态例外）{
//忽略
}
}
}

它还要求

• tomcat-catalina-7.0.47.jar

• catalina-6.0.29

如果我使用Tomcat提供的

catalina.jar

，它会在

Globals.EXCEPTION\u ATTR

处显示错误，任何人都无法使用这种方法，因为它给我

ClassNotFound

，有时用于我自己的类，有时用于

jar

文件中的类，所以我尝试了另一种方法

我从他们的网站下载了Tomcat的最新源代码；在

ErrorReportValve.java

文件中进行了更改（通过修改

 /*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

import java.io.IOException;
import java.io.Writer;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletResponse;
import org.apache.catalina.Globals;
import org.apache.catalina.connector.Constants;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.util.RequestUtil;
import org.apache.catalina.util.StringManager;
import org.apache.catalina.valves.ValveBase;
import org.apache.tomcat.util.ExceptionUtils;

/**
 *
 * @author Kainix
 */
public class ErrorReportValve extends ValveBase {

    public ErrorReportValve() {
        super();
    }
    /**
     * The descriptive information related to this implementation.
     */
    private static final String info
            = "org.apache.catalina.valves.ErrorReportValve/1.0";

    /**
     * The StringManager for this package.
     */
    protected static final StringManager sm = StringManager.getManager(Constants.Package);

    // ------------------------------------------------------------- Properties
    /**
     * Return descriptive information about this Valve implementation.
     */
    @Override
    public String getInfo() {

        return (info);

    }

    /**
     * Invoke the next Valve in the sequence. When the invoke returns, check the response state, and output an error report is necessary.
     *
     * @param request The servlet request to be processed
     * @param response The servlet response to be created
     *
     * @exception IOException if an input/output error occurs
     * @exception ServletException if a servlet error occurs
     */
    @Override
    public void invoke(Request request, Response response)
            throws IOException, ServletException {

        // Perform the request
        getNext().invoke(request, response);

        if (response.isCommitted()) {
            return;
        }

//        if (!request.isAsyncStarted()) {
//        } else {
//            return;
//        }

        Throwable throwable
                = (Throwable) request.getAttribute(Globals.EXCEPTION_ATTR);

        if (throwable != null) {

            // The response is an error
            response.setError();

            // Reset the response (if possible)
            try {
                response.reset();
            } catch (IllegalStateException e) {
                // Ignore
            }

            response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);

        }

        response.setSuspended(false);

        try {
            report(request, response, throwable);
        } catch (Throwable tt) {
            ExceptionUtils.handleThrowable(tt);
        }

    }

    /**
     * Prints out an error report.
     *
     * @param request The request being processed
     * @param response The response being generated
     * @param throwable The exception that occurred (which possibly wraps a root cause exception
     */
    protected void report(Request request, Response response,
            Throwable throwable) {

        // Do nothing on non-HTTP responses
        int statusCode = response.getStatus();

        // Do nothing on a 1xx, 2xx and 3xx status
        // Do nothing if anything has been written already
        if ((statusCode < 400) || (response.getContentCount() > 0)) {
            return;
        }

        String message = RequestUtil.filter(response.getMessage());
        if (message == null) {
            message = "";
        }

        StringBuilder sb = new StringBuilder();

        sb.append("<html><head><title>");
        sb.append("</head><body>");
        sb.append("This is custom error page..!!");
        sb.append("</body></html>");

        try {
            try {
                response.setContentType("text/html");
                response.setCharacterEncoding("utf-8");
            } catch (Throwable t) {
                if (container.getLogger().isDebugEnabled()) {
                    container.getLogger().debug("status.setContentType", t);
                }
            }
            Writer writer = response.getReporter();
            if (writer != null) {
                // If writer is null, it's an indication that the response has
                // been hard committed already, which should never happen
                writer.write(sb.toString());
            }
        } catch (IOException | IllegalStateException e) {
            // Ignore
        }

    }

}