JNDI (Java Naming and Directory Interface) bietet einen Namens- und Verzeichnisdienst, über den Objekte und Dienste gefunden und verfügbar gemacht werden.
Besonders zu Beginn kann es sehr hilfreich sein, die genauen Namen aller JNDI-Einträge anzeigen zu lassen.
Zum Beispiel der Name für das 'UserTransaction'-Objekt heißt bei den verschiedenen Java EE Application Servern unterschiedlich.
-
Installieren Sie sowohl ein aktuelles
Java SE JDK als auch
Ant,
zum Beispiel wie beschrieben unter
java-install.htm.
Legen Sie für eine Projektverzeichnisstruktur folgende in eckigen Klammern dargestellten Verzeichnisse an:
[\MeinWorkspace]
`- [MeineWebApp]
|- [lib]
| `- *servlet*.jar
|- [src]
| |- [meinjavabeanpkg]
| |- [meinservletpkg]
| `- [meinsessionbeanpkg]
`- [webapp]
`- [WEB-INF]
`- [lib]
Sie können diese Verzeichnisstruktur und die meisten der im Folgenden vorgestellten Dateien auch
downloaden (außer den Libs).
-
Kopieren Sie die '*servlet*.jar'-Lib (z.B. servlet.jar, servlet-api.jar oder javax.servlet_1.0.0.0_2-5.jar)
in das '<Projektverzeichnis>\lib'-Verzeichnis.
Je nach Java EE Application Server finden Sie diese Lib in Verzeichnissen ähnlich zu:
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\src\meinservletpkg'
die folgende Servlet-Datei 'MeinServlet.java':
package meinservletpkg;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class MeinServlet extends HttpServlet
{
public void doGet( HttpServletRequest requ, HttpServletResponse resp )
throws ServletException, IOException
{
resp.setContentType( "text/html" );
PrintWriter out = resp.getWriter();
out.println( "<html>" );
out.println( "Hallo, mein erstes Servlet meldet sich." );
out.println( "</html>" );
out.close();
}
}
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\src\meinjavabeanpkg'
die folgende JavaBean-Datei 'MeineJavaBean.java':
package meinjavabeanpkg;
import java.text.SimpleDateFormat;
import java.util.Date;
public class MeineJavaBean
{
public String getDateString()
{
return (new SimpleDateFormat("yyyy-MM-dd, HH:mm:ss")).format(new Date()) + " h";
}
}
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\src\meinsessionbeanpkg'
das folgende EJB-Remote-Interface 'IHelloWorld.java':
package meinsessionbeanpkg;
public interface IHelloWorld
{
String sayHello();
Integer getCount();
}
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\src\meinsessionbeanpkg'
das folgende EJB-Home-Interface 'IHelloWorldHome.java':
package meinsessionbeanpkg;
public interface IHelloWorldHome
{
public IHelloWorld create();
public IHelloWorld create( String myname );
}
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp'
die folgende Start-Index-Datei 'index.jsp':
<html>
<head><title>Meine Start-Seite</title></head>
<body>
<h1>Meine Start-Seite (index.jsp)</h1>
<p><a href="helloservlet">helloservlet</a></p>
<p><a href="HelloJSP.jsp">HelloJSP.jsp</a></p>
<p><a href="HelloJavaBean.jsp">HelloJavaBean.jsp</a></p>
<p><a href="HelloEJB.jsp">HelloEJB.jsp</a></p>
<p><a href="HelloDB.jsp">HelloDB.jsp</a></p>
</body>
</html>
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp'
die folgende JSP-Datei 'HelloJSP.jsp':
<%@ page import="java.text.SimpleDateFormat" %>
<%@ page import="java.util.Date" %>
<html>
<head><title>Hello JSP</title></head>
<body>
<h2>Hallo, meine erste JSP-Seite meldet sich.</h2>
<%= request.getRemoteHost() %>,
<%= (new SimpleDateFormat("yyyy-MM-dd, HH:mm:ss")).format(new Date()) + " h" %>
</body>
</html>
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp'
die folgende JSP-Datei 'HelloJavaBean.jsp':
<%@ page import="meinjavabeanpkg.MeineJavaBean" %>
<html>
<head><title>Hello JavaBean</title></head>
<body>
<h2>Hallo, meine JSP-Seite mit JavaBean meldet sich.</h2>
<%= request.getRemoteHost() %><br>
<%
MeineJavaBean jb = new MeineJavaBean();
out.println( jb.getDateString() );
%>
</body>
</html>
-
Voraussetzung für die folgende JSP-Seite ist eine korrekt im Java EE Application Server deployte 'HelloWorld'-EJB,
wie oben unter EJB erstellen und deployen beschrieben ist.
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp'
die folgende JSP-Datei 'HelloEJB.jsp':
<%@ page import="javax.naming.*" %>
<%@ page import="javax.rmi.PortableRemoteObject" %>
<%@ page import="meinsessionbeanpkg.*" %>
<html>
<head><title>Hello EJB</title></head>
<body>
<h2>Hallo, meine JSP-Seite mit EJB-Zugriff meldet sich.</h2>
<%
Context ctx = new InitialContext();
// Je nach Java EE Application Server bzw. Deployment-Descriptor:
// "HelloWorld" oder
// "meinsessionbeanpkg.IHelloWorldHome"
Object ref = ctx.lookup( "HelloWorld" );
IHelloWorldHome home = (IHelloWorldHome) PortableRemoteObject.narrow(
ref, IHelloWorldHome.class );
IHelloWorld helloWorld = home.create();
out.println( helloWorld.sayHello() + "<br>" );
out.println( helloWorld.sayHello() + "<br>" );
out.println( helloWorld.getCount() + "<br>" );
%>
</body>
</html>
(Bezüglich EJB und 'ctx.lookup()' siehe:
jee-ejb2.htm und
jee-jndi.htm.)
-
Voraussetzung für die folgende JSP-Seite ist die Einrichtung einer DataSource im Java EE Application Server,
zum Beispiel so wie beschrieben für
Oracle WebLogic und
GlassFish
(ansonsten können Sie auf diese JSP-Seite auch verzichten).
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp'
die folgende JSP-Datei 'HelloDB.jsp':
<%@ page import="java.sql.*" %>
<%@ page import="java.util.*" %>
<%@ page import="javax.naming.*" %>
<%@ page import="javax.sql.DataSource" %>
<%@ page import="javax.transaction.*" %>
<html>
<head><title>Hello DB</title></head>
<body>
<h2>Hallo, meine JSP-Seite mit Datenbank-Zugriff meldet sich.</h2>
<%
Context ctx = new InitialContext();
DataSource ds = (DataSource) ctx.lookup( "jdbc/MeinDatasourceJndiName" );
Connection cn = null;
Statement st = null;
ResultSet rs = null;
try {
cn = ds.getConnection();
st = cn.createStatement();
rs = st.executeQuery( "Select * from MeineTestTabelle" );
if( rs.next() ) out.println( "Ergebnis: " + rs.getString( 1 ) + "<br>" );
out.println( cn.getMetaData().getDatabaseProductName() + ", " );
out.println( cn.getMetaData().getDatabaseProductVersion() + "<br>" );
} finally {
try { if( null != rs ) rs.close(); } catch( Exception ex ) {/*ok*/}
try { if( null != st ) st.close(); } catch( Exception ex ) {/*ok*/}
try { if( null != cn ) cn.close(); } catch( Exception ex ) {/*ok*/}
}
%>
</body>
</html>
Passen Sie 'MeinDatasourceJndiName' und 'MeineTestTabelle' an Ihre DataSource an.
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>\webapp\WEB-INF'
die folgende Webanwendungs-Konfigurations-Datei 'web.xml':
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC
'-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN'
'http://java.sun.com/dtd/web-app_2_3.dtd'>
<web-app>
<display-name>Meine WebApp</display-name>
<servlet>
<servlet-name>MeinServletName</servlet-name>
<servlet-class>meinservletpkg.MeinServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MeinServletName</servlet-name>
<url-pattern>/helloservlet</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
-
Speichern Sie im Verzeichnis
'<Projektverzeichnis>'
die folgende Ant-Datei 'build.xml':
<project name="MeinWebAppProjekt" default="usage">
<!-- Overwrite the following props in a 'build.properties' file:
<property name="deploy.dir" value="..." />
-->
<property file="build.properties" />
<property name="app.name" value="MeineWebApp" />
<property name="deploy.dir" value="dist" />
<property name="dist.dir" value="dist" />
<property name="lib.dir" value="lib" />
<property name="src.dir" value="src" />
<property name="webapp.dir" value="webapp" />
<property name="WEBINF.dir" value="${webapp.dir}/WEB-INF" />
<path id="compile.classpath">
<fileset dir="${lib.dir}" includes="*.jar" />
<fileset dir="${WEBINF.dir}/lib" />
<pathelement path="${WEBINF.dir}/classes" />
</path>
<target name="usage">
<echo message="Availiable Targets" />
<echo message=" clean : Delete ${WEBINF.dir}/classes, ${dist.dir}" />
<echo message=" compile : Compile from ${src.dir} to ${WEBINF.dir}/classes" />
<echo message=" create-war: Create ${dist.dir}/${app.name}.war" />
<echo message=" deploy-war: Copy ${dist.dir}/${app.name}.war to ${deploy.dir}" />
</target>
<target name="clean"
description="Delete ${WEBINF.dir}/classes, ${dist.dir}">
<delete dir="${WEBINF.dir}/classes" />
<delete dir="${dist.dir}" />
</target>
<target name="compile"
description="Compile from ${src.dir} to ${WEBINF.dir}/classes">
<mkdir dir="${WEBINF.dir}/lib" />
<mkdir dir="${WEBINF.dir}/classes" />
<javac srcdir="${src.dir}" destdir="${WEBINF.dir}/classes">
<classpath refid="compile.classpath" />
</javac>
<copy todir="${WEBINF.dir}/classes">
<fileset dir="${src.dir}" excludes="**/*.java" />
</copy>
</target>
<target name="create-war" depends="compile"
description="Create ${dist.dir}/${app.name}.war">
<mkdir dir="${dist.dir}" />
<war destfile="${dist.dir}/${app.name}.war" webxml="${WEBINF.dir}/web.xml">
<fileset dir="${webapp.dir}" includes="**/*.*"
excludes="**/web.xml, **/servlet*.jar, **/junit*.jar" />
</war>
</target>
<target name="deploy-war" depends="create-war"
description="Copy ${dist.dir}/${app.name}.war to ${deploy.dir}">
<copy todir="${deploy.dir}" preservelastmodified="true">
<fileset dir="${dist.dir}" includes="${app.name}.war" />
</copy>
</target>
</project>
-
Falls Ihr Java EE Application Server für Auto-Deployment konfiguriert ist:
Speichern Sie im Verzeichnis
'<Projektverzeichnis>'
eine Properties-Datei 'build.properties' mit der Angabe des Auto-Deployment-Verzeichnisses.
Für Oracle WebLogic zum Beispiel so:
deploy.dir=C:/WebLogic/user_projects/domains/MeineDomain/autodeploy
Für GlassFish V2 zum Beispiel so:
deploy.dir=C:/GlassFish/glassfish/domains/domain1/autodeploy
Für JBoss zum Beispiel so:
deploy.dir=/JBoss/server/default/deploy
Ihr Projektverzeichnis muss jetzt so aussehen
(überprüfen Sie es mit "tree /F", dist und classes erscheinen erst nach dem 'Ant'-Lauf):
[\MeinWorkspace]
`- [MeineWebApp]
|- [dist]
| `- ...
|- [lib]
| `- *servlet*.jar
|- [src]
| |- [meinjavabeanpkg]
| | `- MeineJavaBean.java
| |- [meinservletpkg]
| | `- MeinServlet.java
| `- [meinsessionbeanpkg]
| |- IHelloWorld.java
| `- IHelloWorldHome.java
|- [webapp]
| |- [WEB-INF]
| | |- [classes]
| | | `- ...
| | |- [lib]
| | `- web.xml
| |- HelloDB.jsp
| |- HelloEJB.jsp
| |- HelloJavaBean.jsp
| |- HelloJSP.jsp
| `- index.jsp
|- build.properties
`- build.xml
-
Falls Ihr Java EE Application Server für Auto-Deployment konfiguriert ist:
Öffnen Sie ein Kommandozeilenfenster und geben Sie die folgenden Kommandos ein:
cd \MeinWorkspace\MeineWebApp
ant deploy-war
Im Auto-Deployment-Verzeichnis
(z.B. 'WebLogic\user_projects\domains\MeineDomain\autodeploy')
wird das Webarchiv 'MeineWebApp.war' generiert und vom Java EE Application Server automatisch deployt.
-
Falls Ihr Java EE Application Server nicht für Auto-Deployment konfiguriert ist:
Öffnen Sie ein Kommandozeilenfenster und geben Sie die folgenden Kommandos ein:
cd \MeinWorkspace\MeineWebApp
ant create-war
Im '<Projektverzeichnis>\dist'-Verzeichnis
wird das Webarchiv 'MeineWebApp.war' generiert.
Deployen Sie diese .war-Datei über die Administrationskonsole des Java EE Application Servers,
zum Beispiel für Oracle WebLogic über
'http://localhost:7001/console'.
-
Testen Sie Ihre Webanwendung:
Klicken Sie für die einzelnen Tests nacheinander auf die Links der Startseite:
-
Falls Sie beim Compilieren eine Fehlermeldung ähnlich zu
'...\MeineWebApp\src\meinservletpkg\MeinServlet.java: package javax.servlet does not exist'
erhalten, fehlt die '*servlet*.jar'-Library.
Falls Sie eine Fehlermeldung ähnlich zu
'javax.servlet.ServletException: javax.naming.NameNotFoundException: HelloWorld not found'
erhalten, erwartet Ihr Java EE Application Server einen anderen JNDI-Namen.
Probieren Sie in 'webapp/HelloEJB.jsp' beim 'ctx.lookup()'-Aufruf zum Beispiel
'meinsessionbeanpkg.IHelloWorldHome' statt 'HelloWorld' und führen Sie obiges 'ant'-Kommando erneut aus.
Oder: Sehen Sie mit dem
JNDI-Auslese-Programm
nach, welchen JNDI-Namen Ihr Java EE Application Server vergeben hat.
Falls Sie beim Application-Server-Deployment auf der Serverkonsole eine Fehlermeldung ähnlich zu
'java.lang.UnsupportedClassVersionError: Bad version number in .class file'
erhalten, müssen Sie die Webanwendung mit derselben Java-Version kompilieren, die Ihr Java EE Application Server verwendet.
Das kann für Oracle WebLogic (mit Sun-JDK) zum Beispiel folgendermaßen erfolgen (bitte Pfade anpassen):
cd \MeinWorkspace\MeineWebApp
set JAVA_HOME=C:\WebLogic\jdk160_05
set PATH=%JAVA_HOME%\bin;%PATH%
ant clean deploy-war
Falls Sie im Server-Logfile eine Fehlermeldung ähnlich zu
'java.lang.IllegalStateException: Class interface meinsessionbeanpkg.IHelloWorldHome must extend java.rmi.Remote'
erhalten, müssen Sie 'IHelloWorldHome.java' erweitern wie in
jee-ejb2.htm#StatefulSessionBean-HomeInterface.
Allerdings benötigen Sie dann auch zusätzlich eine entsprechende .jar-lib.
Falls Sie im Server-Logfile eine Fehlermeldung ähnlich zu
'java.rmi.MarshalException: org.omg.CORBA.MARSHAL: vmcid: Maybe'
erhalten, können Sie versuchen, die 'MeineWebApp.war' und 'HelloWorldBean.jar' nicht getrennt,
sondern gemeinsam in einer '.ear'-Datei zu deployen.
Ab WebLogic 9.2 ist die Classloader-Reihenfolge geändert worden.
Falls Sie auf Probleme mit unterschiedlichen Versionen eigener und bereits im 'weblogic.jar' vorhandenen Bibliotheken stoßen
(z.B. mit "org.apache.*" oder "javax.jws.*"),
dann versuchen Sie je nach Anwendung einen der beiden oder beide folgenden Vorschläge:
Falls Sie Probleme beim Zugriff auf einen WebLogic-Server von einem externen Client aus haben (z.B. mit unterschiedlichen Java-Versionen),
sehen Sie sich folgende auf Clientseite anwendbaren Kommandozeilenparameter an:
Mit den Monitoring-Tools für WebLogic können der Speicherverbrauch, GC-Aktivitäten, Threads, MBeans, die VM u.a. des WebLogic beobachtet werden.
Hilfreich kann sein, dass im laufenden Betrieb Snapshots von Thread-Stacktraces einzelner Threads erstellt werden können.
Wenn man dies vielleicht zehnmal macht, ist die Wahrscheinlichkeit groß, auf Methoden mit großem Zeitverbrauch zu stoßen.
YourKit muss installiert sein.
Um eine lokale Java-SE-Anwendung profilen zu können, muss der Pfad zur yjpagent.dll-Library zur PATH-Environmentvariable hinzugefügt werden
und muss dem Java-Aufruf ein Kommandozeilenparameter hinzugefügt werden, zum Beispiel so:
set PATH_OLD=%PATH%
set PATH=C:\Programme\YourKit Java Profiler 7.5.6\bin\win32;%PATH%
set JAVA_OPTIONS=-agentlib:yjpagent=sessionname=MeineJavaAnwendung,port=11042
java %JAVA_OPTIONS% MeineJavaAnwendung
set PATH=%PATH_OLD%
Um im Java EE Application Server (z.B. WebLogic) profilen zu können, muss er mit speziellen Optionen gestartet werden.
Eine entsprechende Batchdatei kann von YourKit automatisch erzeugt werden, für WebLogic zum Beispiel über
'Tools' | 'Integrate with J2EE Server...' | 'WebLogic 9.x/10' und Angabe der bisherigen startWebLogic.cmd-Datei.
Alternativ kann auch selbst eine entsprechende Batchdatei erstellt werden:
set PATH=C:\Programme\YourKit Java Profiler 7.5.6\bin\win32;%PATH%
set JAVA_OPTIONS=-agentlib:yjpagent=sessionname=WebLogic %JAVA_OPTIONS%
set JAVA_VENDOR=Bea
set DOMAIN_HOME=C:\WebLogic\user_projects\domains\MeineDomain
call "%DOMAIN_HOME%\bin\startWebLogic.cmd" %*
Die Verbindung von YourKit zur lokalen Anwendung oder zum lokalen Java EE Application Server (z.B. WebLogic) wird hergestellt über:
'File' | 'Open Profiling Session...' | 'Connect to locally running profiled application...'.
Die Verbindung von YourKit zu einem entfernten Java EE Application Server wird hergestellt über:
'File' | 'Open Profiling Session...' | 'Connect to remote application...'.
Unter http://www.yourkit.com/docs
gibt es Hilfe und einführende Demos.
In Produktionsumgebungen sollten einige Optionen eher nicht verwendet werden, da sie zu Timeouts bis hin zum mehrere Minuten langen Stillstand
und zu "stuck Threads" führen (z.B. "CPU Profiling" mit "Tracing" und "Capture Memory Snapshot").
Siehe hierzu: Profiling overhead
(selbst nur das Aktivieren des serverseitigen YourKit-Agenten kann die Performance um durchaus deutlich mehr als die auf der Webseite genannten 5 % beeinträchtigen, auch wenn kein Client aktiv ist).
"CPU Profiling"
(Laufzeiten von Methoden und SQL-Kommandos):
- Oben in der Toolbar den Mauszeiger auf das "Start CPU Profiling"-Icon mit der Uhr und dem grünen Pfeil positionieren, aber noch nicht klicken.
- Entweder "Sampling" für einfache Messungen oder "Tracing" für zeitaufwändige vollständige Messungen wählen.
(Falls "Tracing" gewählt wird: Eventuell muss der JTA-Timeout erhöht werden.)
- "Profile J2EE" aktivieren.
- Zum Starten der Messung auf das Icon mit der Uhr und dem grünen Pfeil klicken ("Start CPU Profiling").
- Zum Beenden der Messung (z.B. nach 5 Minuten) auf das Icon mit der Diskette klicken ("Capture Performance Snapshot").
In der sich öffnenden Snapshot-Ansicht:
Oben links unter "CPU statistics" die "Call tree"-, "Hot spot"- und "Method list"-Optionen anklicken, um die gewünschten Methoden zu finden.
- Im rechten oberen Fenster gewünschte Methode markieren.
- Im rechten unteren Fenster per "Back Traces"- und "Merged Callees"-Tabulatorreiter umschalten zwischen Aufrufern und aufgerufenen Methoden.
- Mit 'Strg + S' oder der rechten Maustaste kann in eine .csv-Datei exportiert werden.
Wenn in jeder Zeile nach der schließenden ')'-Klammer die Kommata durch Semikolons ersetzt werden,
kann die .csv-Datei in Excel bearbeitet werden.
Es ist wichtig, den Unterschied zwischen
"CPU Time" und "Wall Time"
zu verstehen:
CPU Time ist die in der Methode selbst verbrauchte Zeit (z.B. ohne Wartezeit für andere Threads) und Wall Time ist die absolute Zeit von Methodenaufruf bis -ende.
Am besten führen Sie zwei Messungen durch und vergleichen die Ergebnisse:
Die eine Messung in Default-Einstellung und für die andere Messung fügen Sie unter "Settings" | "Wall Time Methods..." die Zeile "* * *" zu unterst hinzu (ohne Anführungszeichen).
Oben links unter "J2EE statistics" auf "SQL" klicken, um SQL-Laufzeiten zu sehen.
- Wenn im rechten oberen Fenster ein SQL-Kommando markiert wird, erscheinen im rechten unteren Fenster die aufrufenden Methoden.
"Memory Snapshot"
(Speicherverbrauch und Memory Leaks):
- Für vergleichbare Ausgangsbedingungen sollte oben in der Toolbar über das Mülleimer-Icon eine explizite "Force Garbage Collection" ausgelöst werden.
- Auf das Toolbar-Icon "Capture Memory Snapshot" klicken und warten, bis die Snapshot-Erstellung fertig ist.
(Eventuell muss der JTA-Timeout erhöht werden.)
- In dem geöffneten Snapshot oben links auf den Tabulatorreiter "Memory", oben links unter "Statistics" auf "Class list" und dann oben rechts auf "Calculate" klicken und warten, bis die Berechnung fertig ist (kann lange dauern).
- "Shallow Size" gibt nur die Größe des Objekts selbst an. "Retained Size" schließt dagegen alle referenzierten Objekte mit ein.
- In der Eingabezeile oberhalb des rechten oberen Fensters kann ein Klassenfilter gesetzt werden (z.B. "de.meinefirma.meinpackage").
- Im rechten oberen Fenster eine Klasse markieren, im rechten unteren Fenster ein Objekt markieren und die Optionen unter der rechten Maustaste ansehen
(z.B. "Paths from GC Roots" und "Selected Objects").
- Oben links unter "Statistics" auf "Biggest objects (dominators)" klicken und Ergebnis ansehen.
- Oben links unter "Statistics" auf "Inspections" klicken, "Run All Inspections" wählen und Ergebnisse ansehen
(z.B. "Duplicate Strings", "Null Fields", "Sparse Arrays", "Zero Length Arrays", "Possible leaks").
- Insbesondere für Vergleiche sollte vor jedem einzelnen "Memory Snapshot" eine explizite "Force Garbage Collection" ausgelöst werden
(über das Toolbar-Mülleimer-Icon).
- Wenn vor dem Start und nach Beendigung einer Anwendung jeweils ein "Memory Snapshot" erstellt wird,
können diese verglichen und so eventuell Memory Leaks gefunden werden (über 'File' | 'Compare Snapshot with...').
- Alternativ kann oben in der Toolbar über das Icon "Advance Object Generation Number" die Snapshot-Generierungsnummerierung um eins erhöht werden.
Der folgende Snapshot wird dann unter "Generation #2" usw. aufgeführt und die verschiedenen Snapshots können verglichen werden.
"Object Allocation Recording"
(Garbage Collection vieler oder großer temporärer Objekte):
- Für vergleichbare Ausgangsbedingungen sollte oben in der Toolbar über das Mülleimer-Icon eine explizite "Force Garbage Collection" ausgelöst werden.
- Oben in der Toolbar den Mauszeiger auf das "Start Object Allocation Recording"-Icon (mit dem Speichersymbol und dem grünen Pfeil) positionieren,
aber noch nicht klicken.
- Normalerweise die beiden Einstellungen ("10" und "1048576") so lassen.
- Auf das "Start Object Allocation Recording"-Icon klicken.
- Nach einigen Minuten auf das Toolbar-Icon "Capture Memory Snapshot" klicken und warten, bis die Snapshot-Erstellung fertig ist.
- In dem geöffneten Snapshot auf den Tabulatorreiter "Garbage Collection" und dann wahlweise auf
"Call tree ...", "Hot spots ..." oder "Method list" klicken und verdächtige Methoden oder Objekte suchen.