Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.wicket.settings; import org.apache.wicket.util.lang.Args; import org.apache.wicket.util.lang.EnumeratedType; /** * * Settings class for configuring exception handling related settings. * <p> * <i>unexpectedExceptionDisplay </i> (defaults to SHOW_EXCEPTION_PAGE) - Determines how exceptions * are displayed to the developer or user * <p> * <i>throwExceptionOnMissingResource </i> (defaults to true) - Set to true to throw a runtime * exception if a required string resource is not found. Set to false to return the requested * resource key surrounded by pairs of question mark characters (e.g. "??missingKey??") * * @author Jonathan Locke * @author Chris Turner * @author Eelco Hillenius * @author Juergen Donnerstag * @author Johan Compagner * @author Igor Vaynberg (ivaynberg) * @author Martijn Dashorst * @author James Carman */ public class ExceptionSettings { /** * Enumerated type for different ways of displaying unexpected exceptions. */ public static final class UnexpectedExceptionDisplay extends EnumeratedType { private static final long serialVersionUID = 1L; UnexpectedExceptionDisplay(final String name) { super(name); } } /** * Indicates that an exception page appropriate to development should be shown when an * unexpected exception is thrown. */ public static final UnexpectedExceptionDisplay SHOW_EXCEPTION_PAGE = new UnexpectedExceptionDisplay( "SHOW_EXCEPTION_PAGE"); /** * Indicates a generic internal error page should be shown when an unexpected exception is * thrown. */ public static final UnexpectedExceptionDisplay SHOW_INTERNAL_ERROR_PAGE = new UnexpectedExceptionDisplay( "SHOW_INTERNAL_ERROR_PAGE"); /** * Indicates that no exception page should be shown when an unexpected exception is thrown. */ public static final UnexpectedExceptionDisplay SHOW_NO_EXCEPTION_PAGE = new UnexpectedExceptionDisplay( "SHOW_NO_EXCEPTION_PAGE"); /** * How to handle errors while processing an Ajax request * * @author igor */ public enum AjaxErrorStrategy { /** redirect to error page, just like a normal requset */ REDIRECT_TO_ERROR_PAGE, /** invoke client side failure handler */ INVOKE_FAILURE_HANDLER } /** * Which threads' stacktrace to dump when a page lock timeout occurs * * @author papegaaij */ public enum ThreadDumpStrategy { /** Do not dump any stacktraces */ NO_THREADS, /** Dump the stacktrace of the thread holding the lock */ THREAD_HOLDING_LOCK, /** Dump stacktraces of all threads of the application */ ALL_THREADS } /** * A strategy defining what to do when a component that will not render its * markup tag (because of {@link org.apache.wicket.Component#setRenderBodyOnly(boolean) setRenderBodyOnly(true)} * or used with <wicket:xyz>) is also asked to output a * markup {@link org.apache.wicket.Component#setOutputMarkupId(boolean) id} or * {@link org.apache.wicket.Component#setOutputMarkupPlaceholderTag(boolean) placeholder tag} */ public enum NotRenderableErrorStrategy { /** * Log a message with level {@link org.slf4j.Logger#warn(String) WARNING} */ LOG_WARNING, /** * Throw a runtime exception */ THROW_EXCEPTION } /** Type of handling for unexpected exceptions */ private UnexpectedExceptionDisplay unexpectedExceptionDisplay = SHOW_EXCEPTION_PAGE; private AjaxErrorStrategy errorHandlingStrategyDuringAjaxRequests = AjaxErrorStrategy.REDIRECT_TO_ERROR_PAGE; /** * Strategy to use for dumping stack traces of live threads in the JVM. * <p> * By default will dump the stacktrace of the thread that holds the lock on the page. * </p> */ private ThreadDumpStrategy threadDumpStrategy = ThreadDumpStrategy.THREAD_HOLDING_LOCK; private NotRenderableErrorStrategy notRenderableErrorStrategy = NotRenderableErrorStrategy.LOG_WARNING; /** * @return Returns the unexpectedExceptionDisplay. */ public UnexpectedExceptionDisplay getUnexpectedExceptionDisplay() { return unexpectedExceptionDisplay; } /** * The exception display type determines how the framework displays exceptions to you as a * developer or user. * <p> * The default value for exception display type is SHOW_EXCEPTION_PAGE. When this value is set * and an unhandled runtime exception is thrown by a page, a redirect to a helpful exception * display page will occur. * <p> * This is a developer feature, however, and you may want to instead show an internal error page * without developer details that allows a user to start over at the application's home page. * This can be accomplished by setting the exception display type to SHOW_INTERNAL_ERROR_PAGE. * <p> * Finally, if you are having trouble with the exception display pages themselves, you can * disable exception displaying entirely with the value SHOW_NO_EXCEPTION_PAGE. This will cause * the framework to re-throw any unhandled runtime exceptions after wrapping them in a * ServletException wrapper. * * @param unexpectedExceptionDisplay * The unexpectedExceptionDisplay to set. * @return {@code this} object for chaining */ public ExceptionSettings setUnexpectedExceptionDisplay(UnexpectedExceptionDisplay unexpectedExceptionDisplay) { this.unexpectedExceptionDisplay = unexpectedExceptionDisplay; return this; } /** * @return strategy used to handle errors during Ajax request processing */ public AjaxErrorStrategy getAjaxErrorHandlingStrategy() { return errorHandlingStrategyDuringAjaxRequests; } /** * Sets strategy used to handle errors during Ajax request processing * * @param errorHandlingStrategyDuringAjaxRequests * @return {@code this} object for chaining */ public ExceptionSettings setAjaxErrorHandlingStrategy( AjaxErrorStrategy errorHandlingStrategyDuringAjaxRequests) { this.errorHandlingStrategyDuringAjaxRequests = errorHandlingStrategyDuringAjaxRequests; return this; } /** * Sets the strategy to use for dumping stack traces of live threads in the JVM. * * @param strategy * @return {@code this} object for chaining */ public ExceptionSettings setThreadDumpStrategy(ThreadDumpStrategy strategy) { threadDumpStrategy = Args.notNull(strategy, "strategy"); return this; } /** * @return strategy to use for dumping stack traces of live threads in the JVM. */ public ThreadDumpStrategy getThreadDumpStrategy() { return threadDumpStrategy; } public NotRenderableErrorStrategy getNotRenderableErrorStrategy() { return notRenderableErrorStrategy; } public void setNotRenderableErrorStrategy(final NotRenderableErrorStrategy notRenderableErrorStrategy) { this.notRenderableErrorStrategy = notRenderableErrorStrategy; } }