Der Tomcat-Server ist ein kostenloser Open-Source-Webanwendungsserver. Es handelt sich um einen leichten Anwendungsserver. Er wird häufig in kleinen und mittleren Systemen und in Fällen verwendet, in denen es nicht viele Benutzer mit gleichzeitigem Zugriff gibt. Er ist die erste Wahl für die Entwicklung und das Debuggen JSP-Programme.
Im Allgemeinen hat Tomcat zwar die gleiche Funktion wie Webserver wie Apache oder Nginx, hat jedoch die Funktion, HTML-Seiten zu verarbeiten. Da seine Fähigkeit zur Verarbeitung von statischem HTML jedoch weitaus geringer ist als die von Apache oder Nginx, wird normalerweise Tomcat verwendet als Servlet- und JSP-Container. Hinteres Ende.

Zusammenfassung:

1) Kostenloser Open-Source-Webanwendungsserver
2) Ein Kernprojekt des Jakarta-Projekts der Apache Software Foundation (Apache Software Foundation)
3) Gemeinsam entwickelt von Apache, Sun und einigen Unternehmen und Einzelpersonen
4) Sehr beliebt bei Java. Von Enthusiasten geliebt und anerkannt von einigen Softwareentwicklern
5) Derzeit beliebter Webanwendungsserver

2. Drei Kernkomponenten von Tomcat

Tomcat besteht aus einer Reihe von Komponenten, von denen es drei Kernkomponenten gibt

Webcontainer: Vervollständigen Sie die Funktion des Webservers.
Servlet-Container: Der Name ist Catalina und wird zur Verarbeitung des Servlet-Codes verwendet.
JSP-Container: Wird zum Übersetzen dynamischer JSP-Webseiten in Servlet-Codes verwendet.

3. Java-Servlet

Servlet ist die Abkürzung für Java Servlet. Es kann als Service-Connector verstanden werden, ein in Java geschriebenes serverseitiges Programm, das die Eigenschaften aufweist, unabhängig von Plattformen und Protokollen zu sein. Einfaches Verständnis: Servlet ist eine Middleware, einschließlich Schnittstellen und Methoden . Verbinden Sie den Client mit der Datenbank, um die Erstellung dynamischer Webseiten zu realisieren.

Ein Programm, das auf einem Webserver oder Anwendungsserver ausgeführt wird und als Vermittler zwischen einer Anfrage von einem Webbrowser oder einem anderen HTTP-Client und einer Datenbank oder Anwendung auf dem HTTP-Server fungiert. Mithilfe von Servlets können Sie Benutzereingaben aus Webseitenformularen sammeln, Datensätze aus Datenbanken oder anderen Quellen rendern und Webseiten dynamisch erstellen. Ähnlich der CGI-Funktionalität (Common Gateway Interface).

4. Der vollständige Name von JSP lautet Java Server Pages

Der vollständige Name von JSP lautet Java Server Pages, eine dynamische Webseitenentwicklungstechnologie. Es verwendet JSP-Tags, um Java-Code in HTML-Webseiten einzufügen. Tags beginnen normalerweise mit <% und enden mit %>.
JSP ist ein Java-Servlet, das hauptsächlich zur Implementierung des Benutzeroberflächenteils einer Java-Webanwendung verwendet wird.
JSP übernimmt Benutzereingabedaten über Webseitenformulare, greift auf Datenbanken und andere Datenquellen zu und erstellt dann dynamisch Webseiten.

5. Struktur der Tomcat-Funktionskomponenten

Es gibt zwei Kernfunktionen von Tomcat: den Connector, der für den Empfang und die Rückmeldung externer Anfragen verantwortlich ist, und den Container, der für die Verarbeitung von Anfragen zuständig ist. Unter ihnen ergänzen sich der Connector und der Container und bilden zusammen den grundlegenden Webdienst. Jeder Tomcat-Server kann mehrere Dienste verwalten.

● Connector : Verantwortlich für den Empfang und die Beantwortung externer Anfragen. Er stellt den Kommunikationsknotenpunkt zwischen Tomcat und der Außenwelt dar. Der Listening-Port empfängt externe Anfragen, verarbeitet die Anfragen und leitet sie zur Geschäftsverarbeitung an den Container weiter und antwortet schließlich mit den verarbeiteten Ergebnissen des Containers an die Außenwelt.
● Container : Verantwortlich für die interne Verarbeitung der Geschäftslogik. Sein Inneres besteht aus vier Containern: Engine, Host, Context und Wrapper, die zum Verwalten und Aufrufen der Servlet-bezogenen Logik verwendet werden.
● Dienst : Extern bereitgestellter Webdienst. Es umfasst hauptsächlich zwei Kernkomponenten, Connector und Container, sowie andere Funktionskomponenten. Tomcat kann mehrere Dienste verwalten und jeder Dienst ist unabhängig voneinander.

6. Analyse der Containerstruktur

Jeder Dienst enthält einen Container-Container. Es gibt 4 Untercontainer im Container:
Die Funktionen der 4 Untercontainer sind:
(1) Engine : Engine, wird zum Verwalten mehrerer virtueller Hosts verwendet. Ein Dienst kann höchstens eine Engine haben.
(2) Host : Stellt dar ein virtueller Host, kann auch als Site bezeichnet werden, Sie können eine Site hinzufügen, indem Sie den Host konfigurieren;
(3) Kontext : Stellt eine Webanwendung dar, einschließlich mehrerer Servlet-Wrapper;
(4) Wrapper : Wrapper, die unterste Ebene des Containers. Jeder Wrapper kapselt ein Servlet, das für die Erstellung, Ausführung und Zerstörung von Objektinstanzen verantwortlich ist.

Engine, Host, Kontext und Wrapper, diese vier Container gehören zur Eltern-Kind-Beziehung.
Ein Container kann mehrere virtuelle Hosts von einer Engine verwalten. Jeder virtuelle Host kann mehrere Webanwendungen verwalten. Jede Webanwendung verfügt über mehrere Servlet-Wrapper.

7. Tomcat-Anfrageprozess

(1) Der Benutzer gibt die URL in den Browser ein und die Anfrage wird an Port 8080 des lokalen Computers gesendet und vom Connector abgerufen, der dort lauscht. (2) Der Connector übergibt die Anfrage an die Engine (
Container) des Der Dienst, in dem er sich zur Verarbeitung befindet, und wartet auf die Antwort von der Engine.
(3) Die Anforderung wird Schicht für Schicht zwischen den vier Containern Engine, Host, Kontext und Wrapper aufgerufen und führt schließlich die entsprechende Geschäftslogik und Datenspeicherung aus das Servlet.
(4) Nach der Ausführung wird die Anforderungsantwort Schicht für Schicht zwischen den Kontext-, Host- und Engine-Containern zurückgegeben, schließlich an den Connector zurückgegeben und über den Connector an den Client zurückgegeben.

Zweitens: Tomcat-Bereitstellung und -Installation

1) Laden Sie das JDK herunter und installieren Sie es

2) Installieren und starten Sie Tomcat

3) Konfigurieren Sie den virtuellen Host

Hinweis: JDK muss vor der Bereitstellung von Tomcat installiert werden, da JDK eine notwendige Umgebung für die Ausführung von Tomcat ist.

1. Schalten Sie die Firewall aus und laden Sie das erforderliche Softwarepaket hoch

Schalten Sie die Firewall aus und übertragen Sie die zur Installation von Tomcat erforderlichen Softwarepakete in das Verzeichnis /opt

所需安装包为：
apache-tomcat-9.0.16.tar.gz  
jdk-8u201-linux-x64.rpm 

systemctl stop firewalld.service 
systemctl disable firewalld.service 
setenforce 0

2. JDK installieren

rpm -qpl jdk-8u201-linux-x64.rpm
rpm -ivh jdk-8u201-linux-x64.rpm 
java -version

3. Legen Sie JDK-Umgebungsvariablen fest

vim /etc/profile.d/java.sh
export JAVA_HOME=/usr/java/jdk1.8.0_201-amd64
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib:$JRE_HOME/lib
export PATH=$JAVA_HOME/bin:$JRE_HOME/bin:$PATH

source /etc/profile.d/java.sh
java -version

Verwandte Erklärung:

JDK : Java Development Kit (Java-Entwicklungstool)
JRE : Java Runtime Environment (Java Runtime Environment)
JVM : Java Virtuak Machine (Java Virtual Machine), sodass Java-Programme Klassendateien auf mehreren Plattformen ausführen können.
CLASSPATH : Teilen Sie JVM mit, wo die Klasse zur Verwendung oder Ausführung abgelegt werden soll, damit die JVM die Klassendatei laden kann.
tools.jar : Wird verwendet, wenn das System zum Kompilieren einer Klasse verwendet wird, dh wenn Javac ausgeführt wird.
dt.jar : dt.jar ist eine Klassenbibliothek über die Betriebsumgebung, hauptsächlich das Swing-Paket.

4. Schreiben Sie zur Überprüfung ein Java-Skript

cd /opt
vim abc.java
#类名、接口名命令：英文大小写字母、数字字符、$和_，不能使用关键字和数字开头；
一个单词命名时第一个单词的首字母要大写；多单词组成时，所有单词的首字母大写：XxxYyyZzz（大驼峰命名法）
public class abc {
  public static void main(String[] args){
    System.out.println("Hello World!")
  }
}

[root@localhost?opt]#javac abc.java      #用来检测JDK环境是否设置成功
[root@localhost?opt]#java abc
Hello World!

5. Installieren und starten Sie Tomcat

cd /opt
tar zxvf apache-tomcat-9.0.16.tar.gz
mv apache-tomcat-9.0.16 /usr/local/tomcat
##启动tomcat ##
#后台启动
/usr/local/tomcat/bin/startup.sh 
或
/usr/local/tomcat/bin/catalina.sh start	
	
#前台启动
/usr/local/tomcat/bin/catalina.sh run		

netstat -natp | grep 8080

Browserzugriff auf virtuelle Maschinen http://192.168.231.102:8080

6. Treten Sie der Systemumgebung bei

1. #先关闭服务
/usr/local/tomcat/bin/shutdown.sh
 
2. #添加用户设置属主属组
useradd -s /sbin/nologin tomcat
chown tomcat:tomcat /usr/local/tomcat -R

3. #新建服务文件
vim /etc/systemd/system/tomcat.service
[Unit]
Description=Tomcat
#After=syslog.target network.target remote-fs.target nss-lookup.target
After=syslog.target network.target
 
[Service]
Type=forking
ExecStart=/usr/local/tomcat/bin/startup.sh
ExecStop=/usr/local/tomcat/bin/shutdown.sh
RestartSec=3
PrivateTmp=true
User=tomcat
Group=tomcat
 
[Install]
WantedBy=multi-user.target
 
4. #重新加载服务，并开启，查看是否成功启动
systemctl daemon-reload
systemctl start tomcat
ss -ntap |grep 8080

7. Optimieren Sie die Startgeschwindigkeit von Tomcat

Wenn Sie Tomcat zum ersten Mal starten, stellen Sie möglicherweise fest, dass Tomcat sehr langsam startet. Standardmäßig kann es mehrere zehn Sekunden dauern. Sie können die JDK-Parameter ändern, um dies zu ändern.

vim /usr/java/jdk1.8.0_201-amd64/jre/lib/security/java.security
--117行--修改
securerandom.source=file:/dev/urandom

/usr/local/tomcat/bin/shutdown.sh 
/usr/local/tomcat/bin/startup.sh 

ll /usr/local/tomcat/

Beschreibung des Hauptverzeichnisses:

bin : Speichern Sie die Skriptdateien zum Starten und Herunterfahren von Tomcat, z. B. catalina.sh, Startup.sh, Shutdown.sh
conf : Speichert verschiedene Konfigurationsdateien des Tomcat-Servers, z. B. die Hauptkonfigurationsdatei server.xml und die Beschreibungsdatei für die Standardbereitstellung der Anwendung web.xml
lib : Das JAR-Paket, das die für die Ausführung von Tomcat erforderlichen Bibliotheksdateien speichert, im Allgemeinen ohne Änderungen
Protokolle : Speichern Sie die Protokolle, wenn Tomcat ausgeführt wird
temp : speichert die Dateien, die generiert werden, wenn Tomcat ausgeführt wird
webapps : Das Verzeichnis, in dem die Standard-Webanwendungsprojektressourcen von Tomcat gespeichert sind
Arbeit : Das Arbeitsverzeichnis von Tomcat, in dem Dateien zur Generierung und Kompilierung von Webanwendungscode gespeichert werden

Drittens: Konfiguration des virtuellen Tomcat-Hosts

In vielen Fällen muss das Unternehmen mehrere Projekte ausführen. Im Allgemeinen werden nicht mehrere Tomcat-Dienste auf einem Server ausgeführt, was zu viele Systemressourcen verbraucht. Zu diesem Zeitpunkt müssen Sie den virtuellen Tomcat-Host verwenden.
Fügen Sie nun beispielsweise zwei Domänennamen hinzu, www.qhw.com und www.benet.com, in der Hoffnung, über diese beiden Domänennamen auf unterschiedliche Projektinhalte zugreifen zu können.

1. Erstellen Sie qhw- und benet-Projektverzeichnisse und -dateien

mkdir /usr/local/tomcat/webapps/qhw
mkdir /usr/local/tomcat/webapps/benet
echo "This is qhw page\!" > /usr/local/tomcat/webapps/qhw/index.jsp
echo "This is benet page\!" > /usr/local/tomcat/webapps/benet/index.jsp

2. Ändern Sie die Tomcat-Hauptkonfigurationsdatei server.xml

vim /usr/local/tomcat/conf/server.xml
--165行前--插入
<Host name="www.qhw.com" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
	<Context docBase="/usr/local/tomcat/webapps/qhw" path="" reloadable="true" />
</Host>

<Host name="www.benet.com" appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false">
	<Context docBase="/usr/local/tomcat/webapps/benet" path="" reloadable="true" />
</Host>



/usr/local/tomcat/bin/shutdown.sh
/usr/local/tomcat/bin/startup.sh

Verwandte Hinweise:

Hostname : Hostname
appBase : Arbeitsverzeichnis des Tomcat-Programms, relativer Pfad ist webapps, absoluter Pfad ist /usr/local/tomcat/webapps
unpackWARs : ob das
dekomprimiert werdenKriegspaket
xmlValidation : Ob das Flag der Gültigkeitsprüfung der XML überprüft werden soll Datei
xmlNamespaceAware : Gibt an, ob der XML-Namespace aktiviert werden soll. Setzen Sie diesen Wert und xmlValidation auf true, um anzuzeigen, dass die Gültigkeitsprüfung für die Datei web.xml durchgeführt wird

docBase : Der
Verzeichnispfad der WEB-Anwendung: Legen Sie den Zugriffs-URI auf das Stammverzeichnis der WEB-Anwendung fest.
reloadable : Legt fest, ob neu geladen werden soll, wenn das Programm geändert wird

3. Überprüfung des Client-Browserzugriffs

echo "192.168.231.102 www.qhw.com www.benet.com" >> /etc/hosts

Wenn der Browser http://.qhw.com:8080/ aufruft, wird auf der Seite „Dies ist die KGC-Seite“ angezeigt. Wenn
der Browser http://www.benet.com:8080/ aufruft, wird auf der Seite „Dies ist die Seite von benet“ angezeigt. !

HTTP-Anfrageprozess:
(1) Der vom Connector überwachte Port ist 8080. Da der angeforderte Port mit dem Überwachungsport übereinstimmt, akzeptiert der Connector die Anfrage.
(2) Weil der standardmäßige virtuelle Host der Engine www.kgc.com ist und das Verzeichnis des virtuellen Hosts webapps ist. Die Anfrage findet also das Verzeichnis tomcat/webapps.
(3) Der Zugriffspfad ist der Stammpfad, und der URI ist leer, dh der leere ist der Anwendungsname des Webprogramms, dh der Kontext. Zu diesem Zeitpunkt findet die Anforderung das Verzeichnis /usr/local/tomcat/webapps/kgc, analysiert index.jsp und gibt es zurück.

Viertens: Tomcat-Mehrinstanzbereitstellung

1. JDK installieren

2. Installieren Sie Tomcat

cd /opt
tar zxvf apache-tomcat-9.0.16.tar.gz
mkdir /usr/local/tomcat
mv apache-tomcat-9.0.16 /usr/local/tomcat/tomcat1
cp -a /usr/local/tomcat/tomcat1 /usr/local/tomcat/tomcat2

3. Konfigurieren Sie Tomcat-Umgebungsvariablen

vim /etc/profile.d/tomcat.sh
#tomcat1
export CATALINA_HOME1=/usr/local/tomcat/tomcat1
export CATALINA_BASE1=/usr/local/tomcat/tomcat1
export TOMCAT_HOME1=/usr/local/tomcat/tomcat1

#tomcat2
export CATALINA_HOME2=/usr/local/tomcat/tomcat2
export CATALINA_BASE2=/usr/local/tomcat/tomcat2
export TOMCAT_HOME2=/usr/local/tomcat/tomcat2


source /etc/profile.d/tomcat.sh

4. Ändern Sie die Datei server.xml in Tomcat2, sodass jede Tomcat-Instanz ohne doppelte Portnummern konfiguriert werden muss

vim /usr/local/tomcat/tomcat2/conf/server.xml
<Server port="8006" shutdown="SHUTDOWN">		#22行，修改Server prot，默认为8005 -> 修改为8006
<Connector port="8081" protocol="HTTP/1.1"		#69行，修改Connector port，HTTP/1.1  默认为8080 -> 修改为8081
<Connector port="8010" protocol="AJP/1.3" redirectPort="8443" />	#116行，修改Connector port AJP/1.3，默认为8009 -> 修改为8010

Der erste Connector lauscht standardmäßig auf Port 8080 und ist für den Aufbau von HTTP-Verbindungen verantwortlich. Dieser Connector wird verwendet, wenn über einen Browser auf die Webanwendung des Tomcat-Servers zugegriffen wird.
Der zweite Connector lauscht standardmäßig auf Port 8009 und der AJP-Port wird vom Container verwendet. Beispielsweise kann Apache über das AJP-Protokoll auf den Tomcat-Port 8009 zugreifen.

5. Ändern Sie die Dateien „startup.sh“ und „shutdown.sh“ in jeder Tomcat-Instanz und fügen Sie Tomcat-Umgebungsvariablen hinzu

vim /usr/local/tomcat/tomcat1/bin/startup.sh 
# -----------------------------------------------------------------------------
# Start Script for the CATALINA Server
# -----------------------------------------------------------------------------
##添加以下内容
export CATALINA_BASE=$CATALINA_BASE1
export CATALINA_HOME=$CATALINA_HOME1
export TOMCAT_HOME=$TOMCAT_HOME1

vim /usr/local/tomcat/tomcat1/bin/shutdown.sh
# -----------------------------------------------------------------------------
# Stop script for the CATALINA Server
# -----------------------------------------------------------------------------
export CATALINA_BASE=$CATALINA_BASE1
export CATALINA_HOME=$CATALINA_HOME1
export TOMCAT_HOME=$TOMCAT_HOME1


vim /usr/local/tomcat/tomcat2/bin/startup.sh 
# -----------------------------------------------------------------------------
# Start Script for the CATALINA Server
# -----------------------------------------------------------------------------
export CATALINA_BASE=$CATALINA_BASE2
export CATALINA_HOME=$CATALINA_HOME2
export TOMCAT_HOME=$TOMCAT_HOME2

vim /usr/local/tomcat/tomcat2/bin/shutdown.sh
# -----------------------------------------------------------------------------
# Stop script for the CATALINA Server
# -----------------------------------------------------------------------------
export CATALINA_BASE=$CATALINA_BASE2
export CATALINA_HOME=$CATALINA_HOME2
export TOMCAT_HOME=$TOMCAT_HOME2

6. Starten Sie /bin/startup.sh in jedem Tomcat

/usr/local/tomcat/tomcat1/bin/startup.sh 
/usr/local/tomcat/tomcat2/bin/startup.sh 

netstat -natp | grep java

7. Browser-Zugriffstest

http://192.168.231.100:8080

http://192.168.231.100:8081

Fünftens: Tomcat-Optimierung

Die standardmäßig installierte Standardkonfiguration von Tomcat ist nicht für die Produktionsumgebung geeignet. Es kann häufig zu angehaltenen Animationen kommen und ein Neustart erforderlich sein. Nur durch kontinuierliche Stresstests und Optimierung kann es mit höchster Effizienz und Stabilität ausgeführt werden. Die Optimierung umfasst hauptsächlich drei Aspekte:
Betriebssystemoptimierung (Kernel-Parameteroptimierung), Optimierung der Tomcat-Konfigurationsdateiparameter und Optimierung der Java Virtual Machine (JVM).

1. Parameteroptimierung der Tomcat-Konfigurationsdatei

【redirectPort】如果某连接器支持的协议是HTTP，当接收客户端发来的HTTPS请求时，则转发至此属性定义的 8443 端口。

【maxThreads】Tomcat使用线程来处理接收的每个请求，这个值表示Tomcat可创建的最大的线程数，即支持的最大并发连接数，默认值是 200。

【minSpareThreads】最小空闲线程数，Tomcat 启动时的初始化的线程数，表示即使没有人使用也开这么多空线程等待，默认值是 10。

【maxSpareThreads】最大备用线程数，一旦创建的线程超过这个值，Tomcat就会关闭不再需要的socket线程。默认值是-1（无限制）。一般不需要指定。

【processorCache】进程缓冲器，可以提升并发请求。默认值是200，如果不做限制的话可以设置为-1，一般采用maxThreads的值或者-1。

【URIEncoding】指定 Tomcat 容器的 URL 编码格式，网站一般采用UTF-8作为默认编码。

【connnectionTimeout】网络连接超时，单位：毫秒，设置为 0 表示永不超时，这样设置有隐患的。通常默认 20000 毫秒就可以。

【enableLookups】是否反查域名，以返回远程主机的主机名，取值为：true 或 false，如果设置为 false，则直接返回 IP 地址，为了提高处理能力，应设置为 false。

【disableUploadTimeout】上传时是否使用超时机制。应设置为 true。

【connectionUploadTimeout】上传超时时间，毕竟文件上传可能需要消耗更多的时间，这个根据你自己的业务需要自己调，以使Servlet有较长的时间来完成它的执行，
需要与上一个参数一起配合使用才会生效。

【acceptCount】指定当所有可以使用的处理请求的线程数都被使用时，可传入连接请求的最大队列长度，超过这个数的请求将不予处理，默认为 100 个。

【maxKeepAliveRequests】指定一个长连接的最大请求数。默认长连接是打开的，设置为1时，代表关闭长连接；为-1时，代表请求数无限制

【compression】是否对响应的数据进行GZIP压缩，off：表示禁止压缩；on：表示允许压缩（文本将被压缩）、force：表示所有情况下都进行压缩，默认值为 off，
压缩数据后可以有效的减少页面的大小，一般可以减小 1/3 左右，节省带宽。

【compressionMinSize】表示压缩响应的最小值，只有当响应报文大小大于这个值的时候才会对报文进行压缩，如果开启了压缩功能，默认值就是 2048。

【compressableMimeType】压缩类型，指定对哪些类型的文件进行数据压缩。

【noCompressionUserAgents="gozilla, traviata"】对于以下的浏览器，不启用压缩
#如果已经进行了动静分离处理，静态页面和图片等数据就不需做 Tomcat 处理，也就不要在 Tomcat 中配置压缩了。

vim /usr/local/tomcat/conf/server.xml
......
<Connector port="8080" protocol="HTTP/11.1" 
connectionTimeout="20000" 
redirectPort="8443" 
--71行--插入
minSpareThreads="50" 
enableLookups="false" 
disableUploadTimeout="true" 
acceptCount="300" 
maxThreads="500" 
processorCache="500"
URIEncoding="UTF-8" 
maxKeepAliveRequests="100"
compression="on" 
compressionMinSize="2048" 
compressableMimeType="text/html,text/xml,text/javascript,text/css,text/plain,image/gif,image /jpg,image/png"/>

/usr/local/tomcat/bin/shutdown.sh
/usr/local/tomcat/bin/startup.sh #参数修改后重启服务

2. Was ist der Standardport von Tomcat und wie kann er geändert werden?

Suchen Sie den Ordner conf im Tomcat-Verzeichnis
Geben Sie den Ordner conf ein und suchen Sie die Datei server.xml
Öffnen Sie die Datei server.xml
Suchen Sie in der Datei server.xml nach den folgenden Informationen
Ändern Sie den Port 8080 auf der Registerkarte „Connector“ in den gewünschten Port

<Service name="Catalina">
<Connector port="8080" protocol="HTTP/1.1" 
               connectionTimeout="20000" 
               redirectPort="8443" />

3. Speicheroptimierung (JVM-Optimierung)

严重: Exception invoking periodic operation: java.lang.OutOfMemoryError: Java heap space  
严重: Error processing request java.lang.OutOfMemoryError: GC overhead limit exceeded

Umweltspezifikationen nehmen 2C4G als Beispiel

Die Konfiguration wird in catalina.sh im bin-Verzeichnis von Tomcat vor cygwin=false hinzugefügt.

vim /usr/local/tomcat/bin/catalina.sh
......
JAVA_OPTS="$JAVA_OPTS -server -Xms2048m -Xmx2048m -Xmn768m -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/usr/local/tomcat/temp/oom.hprof -XX:ParallelGCThreads=2 -XX:PermSize=1024m -XX:MaxPermSize=1024m -Djava.awt.headless=true -XX:+DisableExplicitGC" 

cygwin=false

参数说明：
-server：一定要作为第一个参数，在多个CPU时性能佳

-Xms：堆内存的初始大小，是分配JVM的初始内存，默认为物理内存的1/64。一般来讲，此值设的大点，程序会启动的快一点。

-Xmx：堆内存的最大大小，是分配JVM的最大内存，默认为物理内存的1/4。如果程序运行需要占用更多的内存，超出了这个设置值，就会抛出OutOfMemory异常。
----------------------------------------------------
默认空余堆内存小于40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到 -Xms的最小限制。
因此建议-Xms与-Xmx设成一样的值，均设为物理内存的一半。其目的是为了避免在java每次GC（垃圾回收机制清理堆区）后需要重新调整堆的大小而浪费资源。
----------------------------------------------------

-Xmn：堆内新生代的大小，通过这个值也可以得到老生代的大小：-Xmx减去-Xmn。官方推荐配置为整个堆的 3/8。
----------------------------------------------------
●堆区进一步细化分为：新生代、中生代、老生代。
●java中每新new一个对象所占用的内存空间就是新生代的空间，当java垃圾回收机制对堆区进行资源回收后，那些新生代中没有被回收的资源将被转移到中生代，中生代的被转移到老生代。
●整个JVM堆大小 = 新生代大小 + 老生代大小 + 永久代大小
----------------------------------------------------

-Xss：设置每个线程可使用的内存大小，即栈的大小。一般情况下，设置256k就足够了，此配置将会影响此进程中并发线程数的大小。

-XX:ParallelGCThreads：配置并行收集器的线程数，即：同时有多少个线程一起进行垃圾回收。当 CPU 数量小于8，此值建议配置等于 CPU 数量。

-XX:PermSize：设置非堆内存初始值，即持久代内存大小，默认是物理内存的1/4

-XX:MaxPermSize：最大非堆内存的大小，即最大持久代内存大小，默认是物理内存的1/4
----------------------------------------------------
●非堆区内存是不会被java垃圾回收机制进行处理的，且最大堆内存与最大非堆内存的和不能超出操作系统的可用内存。
●XMX和XMS设置一样大，MaxPermSize和MinPermSize设置一样大，这样可以减轻伸缩堆大小带来的压力。
----------------------------------------------------

-XX:+HeapDumpOnOutOfMemoryError：表示当JVM发生OOM时，自动生成DUMP文件

-XX:HeapDumpPath：表示生成DUMP文件的路径

-XX:+UseParNewGC：对新生代采用多线程并行回收，缩短垃圾收集的时间

-XX:+UseConcMarkSweepGC：并发标记清除收集器，它是老年代的收集算法，缩短垃圾收集的时间

-XX:+DisableExplicitGC：禁止调用System.gc()，防止误调用gc方法导致系统的 JVM 大起大落而使系统响应时间严重降低。

-Djava.awt.headless=true：免避在 Linux/Unix 环境下 Web 网页不能正常显示图片

-XX:+CMSParallelRemarkEnabled：启用并行标记，降低标记停顿

-XX:+UseCMSCompactAtFullCollection -XX:CMSFullGCsBeforeCompaction=0：这两个参数默认值就是这样的，表示触发FullGC时压缩堆，优化内存碎片

-XX:CMSInitiatingOccupancyFraction=70：在应用程序使用70％完内存后开始CMS垃圾收集

verifizieren:

  设置成功后我们可以利用JDK自带的工具进行验证，这些工具都在JAVA_HOME/bin目录下：

    1）jps：用来显示本地的java进程，以及进程号，进程启动的路径等。

    2）jmap：观察运行中的JVM 物理内存的占用情况，包括Heap size , Perm size [下载地址](http://item.taobao.com/item.htm?id=41222768202) 等。

    进入命令行模式后，进入JAVA_HOME/bin目录下，然后输入jps命令：

jps
#显示以下结果
2340 Bootstrap
6696 Jps

其中 Bootstrap进程就是我们启动了的 Tomcat，其进程号为2340.

然后我们利用 jmap工具查看其内存相关配置：

jmap -heap 2340
#显示以下结果 Attaching to process ID 2340, please wait… Debugger attached successfully. Server compiler detected. JVM version is
24.65-b04 using thread-local object allocation. Parallel GC with 4 thread(s)


若内存不足，显示500错误，一般调整Xms和Xmx，可以将Xms和Xmx设置成一样

使用：set JAVA_OPTS=-Xms512m-Xmx512m

Bereitstellung und Optimierung von Tomcat (Details zum Dieb)

1. Einführung in den Tomcat-Server

1. Tomcat-Server