修改${TOMCAT_HOME}/bin/catalina.sh (windows修改catalina.bat) 里加上一句 “CATALINA_OPTS=-Djava.awt.headless=true

修改${TOMCAT_HOME}/bin/catalina.sh (windows修改catalina.bat)  
查到-Djava.io.tmpdir="$CATALINA_TMPDIR"这行，并在这一行下加入:  
-Djava.awt.headless=true /  
共有八处的。 

#!/bin/sh 
# 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. 
# ----------------------------------------------------------------------------- 
# Control Script for the CATALINA Server 
# 
# Environment Variable Prerequisites 
# 
#   Do not set the variables in this script. Instead put them into a script 
#   setenv.sh in CATALINA_BASE/bin to keep your customizations separate. 
# 
#   CATALINA_HOME   May point at your Catalina "build" directory. 
# 
#   CATALINA_BASE   (Optional) Base directory for resolving dynamic portions 
#                   of a Catalina installation.  If not present, resolves to 
#                   the same directory that CATALINA_HOME points to. 
# 
#   CATALINA_OUT    (Optional) Full path to a file where stdout and stderr 
#                   will be redirected. 
#                   Default is $CATALINA_BASE/logs/catalina.out 
# 
#   CATALINA_OPTS   (Optional) Java runtime options used when the "start", 
#                   "run" or "debug" command is executed. 
#                   Include here and not in JAVA_OPTS all options, that should 
#                   only be used by Tomcat itself, not by the stop process, 
#                   the version command etc. 
#                   Examples are heap size, GC logging, JMX ports etc. 
# 
#   CATALINA_TMPDIR (Optional) Directory path location of temporary directory 
#                   the JVM should use (java.io.tmpdir).  Defaults to 
#                   $CATALINA_BASE/temp. 
# 
#   JAVA_HOME       Must point at your Java Development Kit installation. 
#                   Required to run the with the "debug" argument. 
# 
#   JRE_HOME        Must point at your Java Runtime installation. 
#                   Defaults to JAVA_HOME if empty. If JRE_HOME and JAVA_HOME 
#                   are both set, JRE_HOME is used. 
# 
#   JAVA_OPTS       (Optional) Java runtime options used when any command 
#                   is executed. 
#                   Include here and not in CATALINA_OPTS all options, that 
#                   should be used by Tomcat and also by the stop process, 
#                   the version command etc. 
#                   Most options should go into CATALINA_OPTS. 
# 
#   JAVA_ENDORSED_DIRS (Optional) Lists of of colon separated directories 
#                   containing some jars in order to allow replacement of APIs 
#                   created outside of the JCP (i.e. DOM and SAX from W3C). 
#                   It can also be used to update the XML parser implementation. 
#                   Defaults to $CATALINA_HOME/endorsed. 
# 
#   JPDA_TRANSPORT  (Optional) JPDA transport used when the "jpda start" 
#                   command is executed. The default is "dt_socket". 
# 
#   JPDA_ADDRESS    (Optional) Java runtime options used when the "jpda start" 
#                   command is executed. The default is 8000. 
# 
#   JPDA_SUSPEND    (Optional) Java runtime options used when the "jpda start" 
#                   command is executed. Specifies whether JVM should suspend 
#                   execution immediately after startup. Default is "n". 
# 
#   JPDA_OPTS       (Optional) Java runtime options used when the "jpda start" 
#                   command is executed. If used, JPDA_TRANSPORT, JPDA_ADDRESS, 
#                   and JPDA_SUSPEND are ignored. Thus, all required jpda 
#                   options MUST be specified. The default is: 
# 
#                   -agentlib:jdwp=transport=$JPDA_TRANSPORT, 
#                       address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND 
# 
#   CATALINA_PID    (Optional) Path of the file which should contains the pid 
#                   of the catalina startup java process, when start (fork) is 
#                   used 
# 
#   LOGGING_CONFIG  (Optional) Override Tomcat's logging config file 
#                   Example (all one line) 
#                   LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
# 
#   LOGGING_MANAGER (Optional) Override Tomcat's logging manager 
#                   Example (all one line) 
#                   LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
# 
# $Id: catalina.sh 1498485 2013-07-01 14:37:43Z markt $ 
# ----------------------------------------------------------------------------- 
# OS specific support.  $var _must_ be set to either true or false. 
cygwin=false 
darwin=false 
os400=false 
case "`uname`" in 
CYGWIN*) cygwin=true;; 
Darwin*) darwin=true;; 
OS400*) os400=true;; 
esac 
# resolve links - $0 may be a softlink 
PRG="$0" 
while [ -h "$PRG" ]; do 
ls=`ls -ld "$PRG"` 
link=`expr "$ls" : '.*-> /(.*/)$'` 
if expr "$link" : '/.*' > /dev/null; then 
PRG="$link" 
else 
PRG=`dirname "$PRG"`/"$link" 
fi 
done 
# Get standard environment variables 
PRGDIR=`dirname "$PRG"` 
# Only set CATALINA_HOME if not already set 
[ -z "$CATALINA_HOME" ] && CATALINA_HOME=`cd "$PRGDIR/.." >/dev/null; pwd` 
# Copy CATALINA_BASE from CATALINA_HOME if not already set 
[ -z "$CATALINA_BASE" ] && CATALINA_BASE="$CATALINA_HOME" 
# Ensure that any user defined CLASSPATH variables are not used on startup, 
# but allow them to be specified in setenv.sh, in rare case when it is needed. 
CLASSPATH= 
if [ -r "$CATALINA_BASE/bin/setenv.sh" ]; then 
. "$CATALINA_BASE/bin/setenv.sh" 
elif [ -r "$CATALINA_HOME/bin/setenv.sh" ]; then 
. "$CATALINA_HOME/bin/setenv.sh" 
fi 
# For Cygwin, ensure paths are in UNIX format before anything is touched 
if $cygwin; then 
[ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"` 
[ -n "$JRE_HOME" ] && JRE_HOME=`cygpath --unix "$JRE_HOME"` 
[ -n "$CATALINA_HOME" ] && CATALINA_HOME=`cygpath --unix "$CATALINA_HOME"` 
[ -n "$CATALINA_BASE" ] && CATALINA_BASE=`cygpath --unix "$CATALINA_BASE"` 
[ -n "$CLASSPATH" ] && CLASSPATH=`cygpath --path --unix "$CLASSPATH"` 
fi 
# For OS400 
if $os400; then 
# Set job priority to standard for interactive (interactive - 6) by using 
# the interactive priority - 6, the helper threads that respond to requests 
# will be running at the same priority as interactive jobs. 
COMMAND='chgjob job('$JOBNAME') runpty(6)' 
system $COMMAND 
# Enable multi threading 
export QIBM_MULTI_THREADED=Y 
fi 
# Get standard Java environment variables 
if $os400; then 
# -r will Only work on the os400 if the files are: 
# 1. owned by the user 
# 2. owned by the PRIMARY group of the user 
# this will not work if the user belongs in secondary groups 
. "$CATALINA_HOME"/bin/setclasspath.sh 
else 
if [ -r "$CATALINA_HOME"/bin/setclasspath.sh ]; then 
. "$CATALINA_HOME"/bin/setclasspath.sh 
else 
echo "Cannot find $CATALINA_HOME/bin/setclasspath.sh" 
echo "This file is needed to run this program" 
exit 1 
fi 
fi 
# Add on extra jar files to CLASSPATH 
if [ ! -z "$CLASSPATH" ] ; then 
CLASSPATH="$CLASSPATH": 
fi 
CLASSPATH="$CLASSPATH""$CATALINA_HOME"/bin/bootstrap.jar 
if [ -z "$CATALINA_OUT" ] ; then 
CATALINA_OUT="$CATALINA_BASE"/logs/catalina.out 
fi 
if [ -z "$CATALINA_TMPDIR" ] ; then 
# Define the java.io.tmpdir to use for Catalina 
CATALINA_TMPDIR="$CATALINA_BASE"/temp 
fi 
# Add tomcat-juli.jar to classpath 
# tomcat-juli.jar can be over-ridden per instance 
if [ -r "$CATALINA_BASE/bin/tomcat-juli.jar" ] ; then 
CLASSPATH=$CLASSPATH:$CATALINA_BASE/bin/tomcat-juli.jar 
else 
CLASSPATH=$CLASSPATH:$CATALINA_HOME/bin/tomcat-juli.jar 
fi 
# Bugzilla 37848: When no TTY is available, don't output to console 
have_tty=0 
if [ "`tty`" != "not a tty" ]; then 
have_tty=1 
fi 
# For Cygwin, switch paths to Windows format before running java 
if $cygwin; then 
JAVA_HOME=`cygpath --absolute --windows "$JAVA_HOME"` 
JRE_HOME=`cygpath --absolute --windows "$JRE_HOME"` 
CATALINA_HOME=`cygpath --absolute --windows "$CATALINA_HOME"` 
CATALINA_BASE=`cygpath --absolute --windows "$CATALINA_BASE"` 
CATALINA_TMPDIR=`cygpath --absolute --windows "$CATALINA_TMPDIR"` 
CLASSPATH=`cygpath --path --windows "$CLASSPATH"` 
JAVA_ENDORSED_DIRS=`cygpath --path --windows "$JAVA_ENDORSED_DIRS"` 
fi 
# Set juli LogManager config file if it is present and an override has not been issued 
if [ -z "$LOGGING_CONFIG" ]; then 
if [ -r "$CATALINA_BASE"/conf/logging.properties ]; then 
LOGGING_CONFIG="-Djava.util.logging.config.file=$CATALINA_BASE/conf/logging.properties" 
else 
# Bugzilla 45585 
LOGGING_CONFIG="-Dnop" 
fi 
fi 
if [ -z "$LOGGING_MANAGER" ]; then 
LOGGING_MANAGER="-Djava.util.logging.manager=org.apache.juli.ClassLoaderLogManager" 
fi 
# Uncomment the following line to make the umask available when using the 
# org.apache.catalina.security.SecurityListener 
#JAVA_OPTS="$JAVA_OPTS -Dorg.apache.catalina.security.SecurityListener.UMASK=`umask`" 
# ----- Execute The Requested Command ----------------------------------------- 
# Bugzilla 37848: only output this if we have a TTY 
if [ $have_tty -eq 1 ]; then 
echo "Using CATALINA_BASE:   $CATALINA_BASE" 
echo "Using CATALINA_HOME:   $CATALINA_HOME" 
echo "Using CATALINA_TMPDIR: $CATALINA_TMPDIR" 
if [ "$1" = "debug" ] ; then 
echo "Using JAVA_HOME:       $JAVA_HOME" 
else 
echo "Using JRE_HOME:        $JRE_HOME" 
fi 
echo "Using CLASSPATH:       $CLASSPATH" 
if [ ! -z "$CATALINA_PID" ]; then 
echo "Using CATALINA_PID:    $CATALINA_PID" 
fi 
fi 
if [ "$1" = "jpda" ] ; then 
if [ -z "$JPDA_TRANSPORT" ]; then 
JPDA_TRANSPORT="dt_socket" 
fi 
if [ -z "$JPDA_ADDRESS" ]; then 
JPDA_ADDRESS="8000" 
fi 
if [ -z "$JPDA_SUSPEND" ]; then 
JPDA_SUSPEND="n" 
fi 
if [ -z "$JPDA_OPTS" ]; then 
JPDA_OPTS="-agentlib:jdwp=transport=$JPDA_TRANSPORT,address=$JPDA_ADDRESS,server=y,suspend=$JPDA_SUSPEND" 
fi 
CATALINA_OPTS="$CATALINA_OPTS $JPDA_OPTS" 
shift 
fi 
if [ "$1" = "debug" ] ; then 
if $os400; then 
echo "Debug command not available on OS400" 
exit 1 
else 
shift 
if [ "$1" = "-security" ] ; then 
if [ $have_tty -eq 1 ]; then 
echo "Using Security Manager" 
fi 
shift 
exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" / 
-sourcepath "$CATALINA_HOME"/../../java / 
-Djava.security.manager / 
-Djava.security.policy=="$CATALINA_BASE"/conf/catalina.policy / 
-Dcatalina.base="$CATALINA_BASE" / 
-Dcatalina.home="$CATALINA_HOME" / 
-Djava.io.tmpdir="$CATALINA_TMPDIR" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start 
else 
exec "$_RUNJDB" "$LOGGING_CONFIG" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs="$JAVA_ENDORSED_DIRS" -classpath "$CLASSPATH" / 
-sourcepath "$CATALINA_HOME"/../../java / 
-Dcatalina.base="$CATALINA_BASE" / 
-Dcatalina.home="$CATALINA_HOME" / 
-Djava.io.tmpdir="$CATALINA_TMPDIR" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start 
fi 
fi 
elif [ "$1" = "run" ]; then 
shift 
if [ "$1" = "-security" ] ; then 
if [ $have_tty -eq 1 ]; then 
echo "Using Security Manager" 
fi 
shift 
eval exec /"$_RUNJAVA/" /"$LOGGING_CONFIG/" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Djava.security.manager / 
-Djava.security.policy==/"$CATALINA_BASE/conf/catalina.policy/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start 
else 
eval exec /"$_RUNJAVA/" /"$LOGGING_CONFIG/" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start 
  fi 
elif [ "$1" = "start" ] ; then 
if [ ! -z "$CATALINA_PID" ]; then 
if [ -f "$CATALINA_PID" ]; then 
if [ -s "$CATALINA_PID" ]; then 
echo "Existing PID file found during start." 
if [ -r "$CATALINA_PID" ]; then 
PID=`cat "$CATALINA_PID"` 
ps -p $PID >/dev/null 2>&1 
if [ $? -eq 0 ] ; then 
echo "Tomcat appears to still be running with PID $PID. Start aborted." 
exit 1 
else 
echo "Removing/clearing stale PID file." 
rm -f "$CATALINA_PID" >/dev/null 2>&1 
if [ $? != 0 ]; then 
if [ -w "$CATALINA_PID" ]; then 
cat /dev/null > "$CATALINA_PID" 
else 
echo "Unable to remove or clear stale PID file. Start aborted." 
exit 1 
fi 
fi 
fi 
else 
echo "Unable to read PID file. Start aborted." 
exit 1 
fi 
else 
rm -f "$CATALINA_PID" >/dev/null 2>&1 
if [ $? != 0 ]; then 
if [ ! -w "$CATALINA_PID" ]; then 
echo "Unable to remove or write to empty PID file. Start aborted." 
exit 1 
fi 
fi 
fi 
fi 
fi 
shift 
touch "$CATALINA_OUT" 
if [ "$1" = "-security" ] ; then 
if [ $have_tty -eq 1 ]; then 
echo "Using Security Manager" 
fi 
shift 
eval /"$_RUNJAVA/" /"$LOGGING_CONFIG/" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Djava.security.manager / 
-Djava.security.policy==/"$CATALINA_BASE/conf/catalina.policy/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start / 
>> "$CATALINA_OUT" 2>&1 "&" 
 
else 
eval /"$_RUNJAVA/" /"$LOGGING_CONFIG/" $LOGGING_MANAGER $JAVA_OPTS $CATALINA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" start / 
>> "$CATALINA_OUT" 2>&1 "&" 
 
fi 
if [ ! -z "$CATALINA_PID" ]; then 
echo $! > "$CATALINA_PID" 
fi 
elif [ "$1" = "stop" ] ; then 
shift 
SLEEP=5 
if [ ! -z "$1" ]; then 
echo $1 | grep "[^0-9]" >/dev/null 2>&1 
if [ $? -gt 0 ]; then 
SLEEP=$1 
shift 
fi 
fi 
FORCE=0 
if [ "$1" = "-force" ]; then 
shift 
FORCE=1 
fi 
if [ ! -z "$CATALINA_PID" ]; then 
if [ -f "$CATALINA_PID" ]; then 
if [ -s "$CATALINA_PID" ]; then 
kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
if [ $? -gt 0 ]; then 
echo "PID file found but no matching process was found. Stop aborted." 
exit 1 
fi 
else 
echo "PID file is empty and has been ignored." 
fi 
else 
echo "/$CATALINA_PID was set but the specified file does not exist. Is Tomcat running? Stop aborted." 
exit 1 
fi 
fi 
eval /"$_RUNJAVA/" $LOGGING_MANAGER $JAVA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap "$@" stop 
if [ ! -z "$CATALINA_PID" ]; then 
if [ -f "$CATALINA_PID" ]; then 
while [ $SLEEP -ge 0 ]; do 
kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
if [ $? -gt 0 ]; then 
rm -f "$CATALINA_PID" >/dev/null 2>&1 
if [ $? != 0 ]; then 
if [ -w "$CATALINA_PID" ]; then 
cat /dev/null > "$CATALINA_PID" 
else 
echo "Tomcat stopped but the PID file could not be removed or cleared." 
fi 
fi 
break 
fi 
if [ $SLEEP -gt 0 ]; then 
sleep 1 
fi 
if [ $SLEEP -eq 0 ]; then 
if [ $FORCE -eq 0 ]; then 
echo "Tomcat did not stop in time. PID file was not removed." 
fi 
fi 
SLEEP=`expr $SLEEP - 1 ` 
done 
fi 
fi 
KILL_SLEEP_INTERVAL=5 
if [ $FORCE -eq 1 ]; then 
if [ -z "$CATALINA_PID" ]; then 
echo "Kill failed: /$CATALINA_PID not set" 
else 
if [ -f "$CATALINA_PID" ]; then 
PID=`cat "$CATALINA_PID"` 
echo "Killing Tomcat with the PID: $PID" 
kill -9 $PID 
while [ $KILL_SLEEP_INTERVAL -ge 0 ]; do 
kill -0 `cat "$CATALINA_PID"` >/dev/null 2>&1 
if [ $? -gt 0 ]; then 
rm -f "$CATALINA_PID" >/dev/null 2>&1 
if [ $? != 0 ]; then 
echo "Tomcat was killed but the PID file could not be removed." 
fi 
break 
fi 
if [ $KILL_SLEEP_INTERVAL -gt 0 ]; then 
sleep 1 
fi 
KILL_SLEEP_INTERVAL=`expr $KILL_SLEEP_INTERVAL - 1 ` 
done 
if [ $KILL_SLEEP_INTERVAL -gt 0 ]; then 
echo "Tomcat has not been killed completely yet. The process might be waiting on some system call or might be UNINTERRUPTIBLE." 
fi 
fi 
fi 
fi 
elif [ "$1" = "configtest" ] ; then 
eval /"$_RUNJAVA/" $LOGGING_MANAGER $JAVA_OPTS / 
-Djava.endorsed.dirs=/"$JAVA_ENDORSED_DIRS/" -classpath /"$CLASSPATH/" / 
-Dcatalina.base=/"$CATALINA_BASE/" / 
-Dcatalina.home=/"$CATALINA_HOME/" / 
-Djava.io.tmpdir=/"$CATALINA_TMPDIR/" / 
-Djava.awt.headless=true / 
org.apache.catalina.startup.Bootstrap configtest 
result=$? 
if [ $result -ne 0 ]; then 
echo "Configuration error detected!" 
fi 
exit $result 
elif [ "$1" = "version" ] ; then 
"$_RUNJAVA"   / 
-classpath "$CATALINA_HOME/lib/catalina.jar" / 
org.apache.catalina.util.ServerInfo 
else 
echo "Usage: catalina.sh ( commands ... )" 
echo "commands:" 
if $os400; then 
echo "  debug             Start Catalina in a debugger (not available on OS400)" 
echo "  debug -security   Debug Catalina with a security manager (not available on OS400)" 
else 
echo "  debug             Start Catalina in a debugger" 
echo "  debug -security   Debug Catalina with a security manager" 
fi 
echo "  jpda start        Start Catalina under JPDA debugger" 
echo "  run               Start Catalina in the current window" 
echo "  run -security     Start in the current window with security manager" 
echo "  start             Start Catalina in a separate window" 
echo "  start -security   Start in a separate window with security manager" 
echo "  stop              Stop Catalina, waiting up to 5 seconds for the process to end" 
echo "  stop n            Stop Catalina, waiting up to n seconds for the process to end" 
echo "  stop -force       Stop Catalina, wait up to 5 seconds and then use kill -KILL if still running" 
echo "  stop n -force     Stop Catalina, wait up to n seconds and then use kill -KILL if still running" 
echo "  configtest        Run a basic syntax check on server.xml - check exit code for result" 
echo "  version           What version of tomcat are you running?" 
echo "Note: Waiting for the process to end and use of the -force option require that /$CATALINA_PID is defined" 
exit 1 
fi