75 Fragen zu Boss

Ja, es ist grundsätzlich möglich, dass Capcom in einem offiziellen Videospiel Mega Man als einen der Level-Bosse auftreten lässt. Capcom besitzt die Rechte an der Mega Man-Marke und hat in der Vergangenheit bereits Charaktere aus eigenen Reihen in anderen Spielen als Bosse, Gegner oder Gastcharaktere verwendet. Beispiele dafür sind die "Mega Man Battle Network"-Reihe, in der verschiedene Versionen von Mega Man als Gegner auftreten, oder Crossover-Spiele wie "Marvel vs. Capcom", in denen Capcom-Charaktere gegeneinander kämpfen. Ob Mega Man tatsächlich als Boss in einem zukünftigen offiziellen Capcom-Spiel auftaucht, hängt von der kreativen Ausrichtung des jeweiligen Spiels ab. Es wäre also durchaus denkbar, etwa in einem Crossover- oder Spin-off-Titel. Bislang ist Mega Man jedoch in den Hauptspielen seiner eigenen Reihe meist der spielbare Held und nicht als Boss eines Levels zu besiegen. Weitere Informationen zu Capcom findest du auf der offiziellen Website: https://www.capcom.com/

Mega Man selbst taucht offiziell nicht als Level-Boss in anderen Videospielen auf, die nicht Teil der Mega-Man-Reihe sind. In den offiziellen Mega-Man-Spielen ist er immer der Protagonist und nicht der Bossgegner. Es gibt jedoch einige Ausnahmen und Anspielungen: 1. **Cameos und Gastauftritte:** Mega Man hatte Gastauftritte in anderen Spielen, zum Beispiel als spielbarer Charakter in „Super Smash Bros.“ ([Nintendo](https://www.nintendo.de/Spiele/Nintendo-Switch/Super-Smash-Bros-Ultimate-1395713.html)), aber nicht als Boss. 2. **Fan-Games und Mods:** In inoffiziellen Fan-Spielen oder Mods kann es vorkommen, dass Mega Man als Bossgegner eingebaut wird. Diese sind aber nicht offiziell von Capcom lizenziert. 3. **Crossovers:** In einigen Crossover-Spielen wie „Street Fighter X Mega Man“ ([Capcom Unity](https://www.capcom-unity.com/mega_man)), einem Fan-Spiel, das von Capcom unterstützt wurde, treten Street-Fighter-Charaktere als Bosse in einem Mega-Man-Spiel auf, aber nicht umgekehrt. Fazit: In offiziellen, von Capcom veröffentlichten Spielen gibt es keine Level, in denen Mega Man selbst als Boss bekämpft wird. In Fan-Projekten oder Mods kann das jedoch durchaus vorkommen.

Um die `ViewExpiredException` im JBoss-Server (WildFly oder JBoss EAP) gezielt vom Logging auszuschließen oder deren Log-Level zu reduzieren, kannst du die Logging-Konfigurationpassen. Das Ziel ist, dass Exception nicht mehr als ERROR oder WARN im Log, sondern z.B. nur noch als DEBUG oder gar nicht mehr geloggt wird**Vorgehen:** 1. **Finde den Logger-Namen:** Die `ViewExpiredException` wird in JSF-Anwendungen meist von der Klasse `javax.faces.application.ViewExpiredException` geworfen. Die Log-Ausgabe erfolgt häufig über den Logger `javax.enterprise.resource.webcontainer.jsf.lifecycle` oder ähnliche. 2. **Logging-Konfiguration anpassen:** In JBoss/WildFly wird das Logging über die Datei `standalone.xml` (oder `domain.xml`) im Abschnitt `<subsystem xmlns="urn:jboss:domain:logging:...">` konfiguriert. Beispiel für das Setzen des Log-Levels auf `ERROR` (oder `FATAL`, um weniger zu loggen): ```xml <logger category="javax.enterprise.resource.webcontainer.jsf.lifecycle"> <level name="ERROR"/> </logger> ``` Oder, um die Exception komplett zu unterdrücken, kannst du den Level auf `OFF` setzen: ```xml <logger category="javax.enterprise.resource.webcontainer.jsf.lifecycle"> <level name="OFF"/> </logger> ``` **Hinweis:** Der genaue Logger-Name kann je nach JSF-Implementierung (z.B. Mojarra, MyFaces) variieren. Prüfe im Logfile, welcher Logger die `ViewExpiredException` ausgibt, und passe ggf. den `category`-Wert an. 3. **Server neu starten:** Nach der Änderung der Konfiguration muss der Server neu gestartet werden, damit die Änderungen wirksam werden. **Weitere Hinweise:** - Alternativ kannst du auch in der `logging.properties` (bei älteren JBoss-Versionen) den Log-Level anpassen. - Wenn du gezielt nur die `ViewExpiredException` filtern willst, ohne andere Fehler zu unterdrücken, ist das mit Standardmitteln schwierig. In diesem Fall wäre ein [Custom Log Filter](https://docs.wildfly.org/26/Admin_Guide.html#Log_Filters) notwendig, der Einträge mit dieser Exception ignoriert. **Links:** - [WildFly Logging Guide](https://docs.wildfly.org/26/Admin_Guide.html#Logging) - [JSF ViewExpiredException Handling](https://stackoverflow.com/questions/10534764/how-to-handle-viewexpiredexception-in-jsf) **Zusammenfassung:** Passe den Logger für JSF-Lifecycle in der JBoss-Logging-Konfiguration an und setze den Level auf `ERROR`, `FATAL` oder `OFF`, um die `ViewExpiredException` aus dem Log auszuschließen.

Die **ViewExpiredException** in JavaServer Faces (JSF) tritt auf, wenn eine Benutzer-Session abgelaufen ist und die zugehörige View nicht mehr im Speicher vorhanden ist Standardmäßig wird diese Exception oft alsSEVERE** oder **ERROR** im JBoss/WildFly-Log protokolliert, was zu unnötigen Alarmen führen kann, da es sich meist um ein erwartbares Verhalten handelt (z.B. bei Inaktivität). **Ob die ViewExpiredException als Warning kategorisiert werden sollte, hängt vom Anwendungskontext ab:** - **Pro Warning:** In vielen produktiven JSF-Anwendungen ist eine ViewExpiredException ein normaler Vorgang, der keine unmittelbare Aktion erfordert. In solchen Fällen ist es sinnvoll, die Exception als **WARNING** zu loggen, um das Log sauberer zu halten und echte Fehler besser zu erkennen. - **Contra Warning:** Wenn die ViewExpiredException auf ein echtes Problem (z.B. zu kurze Session-Timeouts oder fehlerhafte Navigation) hindeutet, sollte sie weiterhin als **ERROR** behandelt werden. **Wie kann man das Logging-Level anpassen?** 1. **Logging-Konfiguration anpassen:** In der Regel wird das Logging über die `logging.properties` oder die JBoss/WildFly-Logging-Subsystem-Konfiguration gesteuert. Du kannst gezielt das Logging-Level für die Klasse `javax.faces.application.ViewExpiredException` oder den entsprechenden Logger auf **WARNING** setzen. Beispiel für `standalone.xml` (WildFly/JBoss): ```xml <logger category="javax.faces.application.ViewExpiredException"> <level name="WARN"/> </logger> ``` 2. **Eigene Exception-Handler verwenden:** Du kannst einen eigenen `ExceptionHandler` in JSF implementieren, der die ViewExpiredException abfängt und das Logging-Level selbst bestimmt. Beispiel: ```java public class CustomExceptionHandler extends ExceptionHandlerWrapper { // ... Konstruktor und Methoden @Override public void handle() throws FacesException { for (Iterator<ExceptionQueuedEvent> i = getUnhandledExceptionQueuedEvents().iterator(); i.hasNext();) { Throwable t = i.next().getContext().getException(); if (t instanceof ViewExpiredException) { Logger.getLogger(getClass().getName()).log(Level.WARNING, "ViewExpiredException aufgetreten", t); // Weiterleitung oder eigene Behandlung i.remove(); } } getWrapped().handle(); } } ``` **Fazit:** Es ist in vielen Fällen sinnvoll, die ViewExpiredException als **Warning** zu kategorisieren, um die Logfiles übersichtlicher zu halten. Die Anpassung erfolgt entweder über die Logging-Konfiguration des Servers oder durch einen eigenen Exception-Handler. Weitere Infos: - [WildFly Logging Documentation](https://docs.wildfly.org/26/Admin_Guide.html#Logging) - [JSF Exception Handling](https://www.baeldung.com/jsf-exception-handling)

Eine `ViewExpiredException` im JBoss EAP (Enterprise Application Platform) tritt typischerweise in JavaServer Faces (JSF)-Anwendungen auf. Sie bedeutet, dass der Server die JSF-View (also den Zustand der Benutzeroberfläche) nicht mehr im Speicher oder im Persistent Store finden kann, wenn eine Anfrage eintrifft, die sich auf eine bestimmte View bezieht. Hauptursachen für eine `ViewExpiredException` sind: 1. **Session Timeout**: Die HTTP-Session ist abgelaufen, bevor der Benutzer eine Aktion ausgeführt hat. Die View, die im Session-Scope gespeichert war, ist nicht mehr verfügbar. 2. **View State Timeout**: JSF speichert den View-State (Zustand der Seite) entweder im Server-Speicher (serverseitig) oder im Client (z. B. als verstecktes Feld im HTML). Wenn der View-State auf dem Server gespeichert wird und dieser Speicher (z. B. durch Zeitablauf oder Speicherbereinigung) verloren geht, tritt die Exception auf. 3. **Zu viele gleichzeitige Views**: JSF begrenzt die Anzahl der gespeicherten Views pro Session (Standard: 15). Wird diese Anzahl überschritten, werden ältere Views entfernt. Greift der Benutzer auf eine entfernte View zu, kommt es zur Exception. 4. **Cluster- oder Deployment-Probleme**: In einem Cluster kann es passieren, dass die View auf einem anderen Knoten gespeichert ist oder nach einem Redeploy nicht mehr verfügbar ist. 5. **Browser-Back-Button oder Lesezeichen**: Wenn ein Benutzer mit dem Zurück-Button oder einem alten Lesezeichen eine abgelaufene View aufruft, ist diese nicht mehr vorhanden. **Weitere Informationen:** - [JBoss EAP](https://www.redhat.com/de/technologies/jboss-middleware/application-platform) - [JSF ViewExpiredException – Ursachen und Lösungen (externer Blog)](https://www.thoughts-on-java.org/jsf-viewexpiredexception/) **Zusammengefasst:** Eine `ViewExpiredException` entsteht, wenn JSF den Zustand einer View nicht mehr wiederherstellen kann, meist durch Session-Timeout, Speicherbereinigung, zu viele Views oder inkonsistente Zustände im Cluster.

**Hugo Boss The Scent Deodorant** ist ein beliebtes Produkt aus der „The Scent“-Duftlinie von Hugo Boss. Hier findest du eine Übersicht mit den wichtigsten Daten und typischen Meinungen: ### Produktdaten - **Name:** Hugo Boss The Scent Deodorant Spray - **Hersteller:** Hugo Boss ([Website](https://www.hugoboss.com)) - **Duftfamilie:** Aromatisch, würzig - **Duftnoten:** - **Kopfnote:** Ingwer - **Herznote:** Maninka-Frucht, Lavendel - **Basisnote:** Leder - **Inhalt:** Meist 150 ml (Spray), auch als Stick erhältlich - **Anwendung:** Für die tägliche Körperpflege, auf die Achseln aufsprühen - **Preis:** Ca. 15–25 € (je nach Händler und Größe) - **Verfügbarkeit:** Parfümerien, Drogerien, Online-Shops ### Typische Meinungen (aus Bewertungen und Foren) - **Duft:** Wird als elegant, maskulin und verführerisch beschrieben. Viele Nutzer loben die besondere, nicht aufdringliche Duftkomposition. - **Haltbarkeit:** Die Wirkung als Deo wird meist als gut bewertet, der Duft hält jedoch nicht so lange wie das Eau de Toilette. - **Hautverträglichkeit:** In der Regel gut verträglich, selten berichten Nutzer von Hautreizungen. - **Design:** Das Flakondesign wird als hochwertig und ansprechend empfunden. - **Preis-Leistung:** Wird als angemessen bewertet, da es sich um ein Markenprodukt handelt. ### Fazit Hugo Boss The Scent Deodorant ist besonders für Fans des gleichnamigen Parfums geeignet, die Wert auf einen dezenten, aber eleganten Duft im Alltag legen. Die meisten Nutzer sind mit Duft und Wirkung zufrieden, auch wenn die Haltbarkeit des Dufts als Deo naturgemäß kürzer ist als beim Parfum. Weitere Informationen findest du z.B. auf [Douglas](https://www.douglas.de/de/p/3001040732) oder [Flaconi](https://www.flaconi.de/deo/hugo-boss/the-scent/hugo-boss-the-scent-deodorant-spray.html).

Probleme mit JavaScript-Operatoren in einer JSF-Anwendung auf JBoss 8 können verschiedene Ursachen haben. Hier sind einige typische Fehlerquellen und Lösungsansätze: 1. **JSF und JavaScript Verwechslung** JSF verwendet oft eigene Ausdrücke mit `#` oder `${}` (Expression Language, EL). Diese können mit JavaScript-Operatoren wie `==`, `===`, `+`, `-` verwechselt werden, besonders wenn JavaScript-Code direkt in JSF-Seiten (z.B. in `<h:outputScript>`) eingebettet wird. **Lösung:** Stelle sicher, dass JavaScript-Code korrekt in `<script>`-Tags oder `<h:outputScript>` ausgelagert ist und nicht von JSF/EL interpretiert wird. Verwende z.B. `<![CDATA[ ... ]]>` innerhalb von `<script>`-Tags, um EL-Ausdrücke zu schützen. 2. **Escape-Probleme** JSF kann bestimmte Zeichen (wie `<`, `>`, `&`) escapen, was zu Syntaxfehlern im JavaScript führt. **Lösung:** Nutze das Attribut `escape="false"` bei `<h:outputText>` oder `<h:outputScript>`, wenn du JavaScript-Code einfügst. 3. **Ressourcen-Ladereihenfolge** Manchmal werden JavaScript-Dateien nicht korrekt geladen oder überschrieben, z.B. durch PrimeFaces oder andere JSF-Bibliotheken. **Lösung:** Überprüfe die Reihenfolge der Ressourcen mit `<h:outputScript>` und `<h:outputStylesheet>`. Stelle sicher, dass eigene Skripte nach den Framework-Skripten geladen werden. 4. **Kompatibilität mit JBoss 8 (WildFly 8)** JBoss 8 (WildFly 8) ist relativ alt und verwendet ältere JSF-Versionen. Manche modernen JavaScript-Features oder Operatoren (wie `let`, `const`, Arrow Functions) werden von älteren Browsern nicht unterstützt, die in Unternehmensumgebungen noch im Einsatz sein könnten. **Lösung:** Verwende möglichst kompatiblen JavaScript-Code oder prüfe die Browser-Kompatibilität. 5. **Fehlermeldungen analysieren** Öffne die Browser-Konsole (F12) und prüfe die genaue Fehlermeldung. Oft gibt sie Hinweise, ob es sich um einen Syntaxfehler, einen nicht erkannten Operator oder ein Problem mit der JSF-Ausgabe handelt. **Weiterführende Links:** - [WildFly (JBoss) 8 Dokumentation](https://docs.wildfly.org/8/) - [JSF 2.2 Dokumentation](https://javaee.github.io/javaee-spec/javadocs/javax/faces/package-summary.html) Wenn du eine konkrete Fehlermeldung oder einen Codeausschnitt hast, kann gezielter geholfen werden.

Um in JBoss (WildFly) im Standalone-Modus das Limit für die maximale Request-Größe (z. B. bei Datei-Uploads) anzupassen, gibt es je nach eingesetztem Subsystem verschiedene Möglichkeiten. Die häufigsten Fälle betreffen das HTTP-Subsystem (undertow) oder das Servlet-Subsystem. **Für Undertow (Standard ab WildFly 8/JBoss EAP 7):** 1. **Standalone-Konfiguration öffnen:** Die Datei `standalone.xml` (oder das jeweilige Profil, z. B. `standalone-full.xml`) im Verzeichnis `standalone/configuration` bearbeiten. 2. **Den passenden Listener finden:** Suche nach dem Abschnitt `<server name="default-server">` und darin nach `<http-listener ...>` oder `<https-listener ...>`. 3. **max-post-size setzen:** Füge das Attribut `max-post-size` hinzu oder passe es an, z. B.: ```xml <http-listener name="default" socket-binding="http" max-post-size="104857600"/> ``` (Das Beispiel setzt das Limit auf 100 MB.) 4. **Server neu starten:** Änderungen werden erst nach einem Neustart von JBoss/WildFly wirksam. **Für ältere JBoss-Versionen (z. B. JBoss 6/7 mit Tomcat):** Hier wird das Limit meist in der Datei `server.xml` im Tomcat-Connector gesetzt: ```xml <Connector port="8080" ... maxPostSize="104857600" /> ``` **Weitere Hinweise:** - Auch in der Anwendung selbst (z. B. in `web.xml`) kann ein Limit gesetzt sein: ```xml <multipart-config> <max-file-size>104857600</max-file-size> <max-request-size>104857600</max-request-size> </multipart-config> ``` - Die Werte sind in Bytes anzugeben. - Nach jeder Änderung ist ein Neustart des Servers erforderlich. **Offizielle Dokumentation:** - [WildFly Undertow Subsystem](https://docs.wildfly.org/30/Admin_Guide.html#Undertow_subsystem) - [JBoss EAP HTTP Connector](https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/7.4/html/configuration_guide/configuring_connectors#http_connector) Damit kannst du das Request-Limit in JBoss/WildFly Standalone anpassen.

Das Boss Netzteil PSA-230S2 liefert eine Ausgangsspannung von 9 Volt DC (Gleichstrom) bei einer maximalen Stromstärke von 500 mA (Milliampere). Weitere Informationen findest du direkt beim Hersteller: https://www.boss.info/de/products/psa-series/

Für JBoss EAP 7 (die Version 8 gibt es nicht, vermutlich ist WildFly 8 oder JBoss EAP 7.x gemeint) empfiehlt Red Hat als Mindestanforderung für den Heap-Speicher in der Regel **512 MB**. Für produktive Umgebungen und größere Anwendungen werden jedoch **2 GB oder mehr** empfohlen, abhängig von der Anwendung und der Anzahl der Deployments. Typische Startparameter für die JVM lauten zum Beispiel: ``` -Xms512m -Xmx2048m ``` - **-Xms**: Initialer Heap-Speicher (z.B. 512 MB) - **-Xmx**: Maximaler Heap-Speicher (z.B. 2 GB) Die tatsächlichen Anforderungen hängen stark von der Anwendung, der Anzahl der Benutzer und den eingesetzten Modulen ab. Für Entwicklungs- und Testumgebungen reichen oft 1–2 GB, für produktive Systeme sollte der Speicherbedarf anhand von Lasttests und Monitoring ermittelt werden. Weitere Informationen findest du in der offiziellen [Red Hat Dokumentation](https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/7.4/html/installation_guide/assembly_planning-the-installation#ref_hardware-requirements_installing-eap).

Um in einer Java-17-Anwendung, die auf JBoss EAP 8 läuft, die HTTP-Version für einen Apache CXF `httpConduit` explizit auf HTTP/1.1 zu setzen, gehst du wie folgt vor: 1. **Bearbeite die CXF-Konfiguration** In der Regel geschieht das in der Datei `cxf.xml` oder direkt im Spring-Context, falls du Spring nutzt. Beispiel für eine `cxf.xml`-Konfiguration: ```xml <cxf:bus> <cxf:properties> <entry key="org.apache.cxf.transport.http.HTTPConduitFactory" value="org.apache.cxf.transport.http.HTTPConduitFactory"/> </cxf:properties> </cxf:bus> <http:conduit name="{ServiceNamespace}PortName.http-conduit"> <http:client Connection="Keep-Alive" /> <http:tlsClientParameters disableCNCheck="true" /> <http:protocols> <http:protocol>HTTP/1.1</http:protocol> </http:protocols> </http:conduit> ``` Wichtig ist der Block: ```xml <http:protocols> <http:protocol>HTTP/1.1</http:protocol> </http:protocols> ``` 2. **Alternativ: Programmgesteuert setzen** Falls du die Konfiguration im Code vornehmen möchtest: ```java import org.apache.cxf.endpoint.Client; import org.apache.cxf.frontend.ClientProxy; import org.apache.cxf.transport.http.HTTPConduit; import org.apache.cxf.transports.http.configuration.HTTPClientPolicy; Object service = ...; // Dein Service-Proxy Client client = ClientProxy.getClient(service); HTTPConduit conduit = (HTTPConduit) client.getConduit(); HTTPClientPolicy policy = new HTTPClientPolicy(); policy.setVersion(org.apache.cxf.transports.http.configuration.HTTPClientPolicy.Version.HTTP_1_1); conduit.setClient(policy); ``` 3. **JBoss-spezifische Hinweise** JBoss EAP 8 nutzt standardmäßig Undertow als Webserver. Die HTTP-Version für eingehende Verbindungen wird serverseitig über die Undertow-Konfiguration gesteuert, für ausgehende Verbindungen (CXF-Clients) ist aber die CXF-Konfiguration maßgeblich. **Weitere Informationen:** - [Apache CXF Dokumentation](https://cxf.apache.org/docs/client-http-transport-including-ssl-support.html) - [JBoss EAP 8 Dokumentation](https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/8.0/) Falls du eine bestimmte Service- oder Port-Konfiguration hast, muss der Name im `<http:conduit name="...">`-Attribut entsprechend angepasst werden.

Um Java 17 mit JBoss EAP 8 (bzw. WildFly 28, auf dem JBoss EAP 8 basiert) und der HTTP-Version im Zusammenhang mit `HttpConduit` zu verwenden, sind einige technische Details zu beachten: **1. Java 17 und JBoss 8 Kompatibilität:** JBoss EAP 8 unterstützt offiziell Java 17. Das bedeutet, du kannst Anwendungen mit Java 17 auf diesem Application Server betreiben. **2. HttpConduit:** `HttpConduit` ist eine Komponente aus Apache CXF, einem Framework für Webservices. Sie steuert, wie HTTP-Verbindungen für Webservice-Clients hergestellt werden. **3. HTTP-Version konfigurieren:** Mit Apache CXF und `HttpConduit` kannst du die HTTP-Version (z.B. HTTP/1.1 oder HTTP/2) konfigurieren. Standardmäßig wird HTTP/1.1 verwendet. Für HTTP/2 ist zusätzliche Konfiguration und ggf. ein passender Transport notwendig. **Beispiel für die Konfiguration der HTTP-Version in CXF:** ```xml <http:conduit name="{ServiceNamespace}Port.http-conduit"> <http:client Connection="Keep-Alive" /> <http:tlsClientParameters disableCNCheck="true" /> <http:protocols> <http:protocol>HTTP/1.1</http:protocol> </http:protocols> </http:conduit> ``` **4. HTTP/2 Unterstützung:** Ab Java 11 unterstützt die Java-HTTP-Client-API HTTP/2. Apache CXF unterstützt HTTP/2 ab Version 3.4.x, aber nicht immer automatisch über `HttpConduit`. Für HTTP/2 kann es notwendig sein, Jetty als Transport zu verwenden oder explizit den Java-HTTP-Client zu konfigurieren. **5. JBoss/WildFly HTTP/2 Support:** WildFly 10+ (und damit auch JBoss EAP 8) unterstützt HTTP/2 für eingehende Verbindungen über Undertow. Für ausgehende Verbindungen (z.B. Webservice-Clients) ist die Unterstützung abhängig von der verwendeten Client-Bibliothek (CXF, RESTEasy, etc.). **Fazit:** - Java 17 und JBoss 8 sind kompatibel. - Die HTTP-Version für `HttpConduit` wird in der CXF-Konfiguration festgelegt. - HTTP/2 für ausgehende Verbindungen benötigt ggf. zusätzliche Konfiguration und aktuelle Bibliotheken. **Links:** - [JBoss EAP 8](https://www.redhat.com/en/technologies/jboss-middleware/application-platform) - [Apache CXF HttpConduit Doku](https://cxf.apache.org/docs/client-http-transport-including-ssl-support.html) - [WildFly HTTP/2 Support](https://docs.wildfly.org/28/Admin_Guide.html#HTTP2) Falls du eine konkrete Konfiguration oder ein Beispiel benötigst, bitte die genaue Anforderung (z.B. HTTP/2 für CXF-Client) angeben.

JBoss EAP 8 (Enterprise Application Platform) basiert auf WildFly 26. WildFly 26 und damit auch JBoss EAP 8 unterstützen HTTP/1.1 und HTTP/2. **Java 17** wird von JBoss EAP 8 offiziell unterstützt. **HTTP-Versionen:** - **HTTP/1.1**: Standardmäßig unterstützt - **HTTP/2**: Unterstützt, kann aber zusätzliche Konfiguration erfordern **Weitere Informationen:** - [JBoss EAP 8 Dokumentation](https://access.redhat.com/documentation/en-us/red_hat_jboss_enterprise_application_platform/8.0/) - [WildFly HTTP/2 Support](https://docs.wildfly.org/26/Admin_Guide.html#HTTP2) **Fazit:** Mit Java 17 und JBoss EAP 8 kannst du sowohl HTTP/1.1 als auch HTTP/2 nutzen.

JBoss-Anwendungen (heute meist als WildFly bezeichnet) laufen im Debug-Mode standardmäßig auf dem Port **8787**. Das bedeutet, wenn du den Server mit Debug-Optionen startest (z. B. mit `-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8787`), lauscht der Debugger auf diesem Port. Du kannst den Port aber in der Startkonfiguration anpassen. Standardmäßig ist jedoch **8787** üblich. Weitere Informationen findest du in der offiziellen Dokumentation: https://docs.wildfly.org/26/Admin_Guide.html#debugging-the-server

Wenn du deine Java-Anwendung in IntelliJ IDEA im JBoss-Server nur im Debug-Modus, aber nicht im normalen Modus starten kannst, gibt es dafür mehrere mögliche Ursachen: 1. **Run/Debug-Konfigurationen** Prüfe, ob du für den normalen Start eine passende Run-Konfiguration eingerichtet hast. Manchmal ist nur eine Debug-Konfiguration vorhanden oder die Run-Konfiguration ist fehlerhaft. 2. **Port-Konflikte** Wenn der JBoss-Server bereits läuft (z.B. im Debug-Modus), kann ein erneuter Start im normalen Modus fehlschlagen, weil die Ports (z.B. 8080, 9990) schon belegt sind. 3. **Fehlende oder falsche Einstellungen** In den Einstellungen der Run-Konfiguration kann z.B. das JDK falsch gewählt sein oder Umgebungsvariablen fehlen, die im Debug-Modus gesetzt werden. 4. **Fehlermeldungen und Logs** Starte den Server im normalen Modus und prüfe die Ausgaben in der Konsole von IntelliJ. Oft gibt es dort Hinweise auf die Ursache (z.B. fehlende Rechte, falscher Pfad, fehlende Abhängigkeiten). 5. **Unterschiedliches Verhalten durch Plugins** Manche Plugins oder Tools (z.B. JRebel) können das Startverhalten beeinflussen und dazu führen, dass der Server nur im Debug-Modus korrekt startet. 6. **Unterschiedliche JVM-Optionen** Im Debug-Modus werden oft andere JVM-Optionen gesetzt (z.B. für das Remote Debugging). Wenn im normalen Modus wichtige Optionen fehlen, kann der Start fehlschlagen. **Empfohlene Schritte zur Fehlersuche:** - Vergleiche die Einstellungen der Run- und Debug-Konfiguration. - Prüfe die Server-Logs auf Fehlermeldungen. - Stelle sicher, dass der Server nicht bereits läuft. - Teste den Start außerhalb von IntelliJ (z.B. über die Kommandozeile). Weitere Informationen zu JBoss findest du auf der offiziellen Seite: [https://www.jboss.org/](https://www.jboss.org/) Und zu IntelliJ IDEA: [https://www.jetbrains.com/idea/](https://www.jetbrains.com/idea/) Falls du eine konkrete Fehlermeldung erhältst, kann diese bei der weiteren Eingrenzung helfen.