Come rendere veloce Tomcat nel caricamento delle modifiche per velocizzare lo sviluppo web Java

Question

La mia app utilizza Struts2 MVC, Spring JDBC Template con Eclipse IDE e Tomcat. Ogni volta che cambio un codice di classe, devo riavviare Tomcat, che spreca circa 15-20 secondi ogni volta.

Ho configurato hot deployment, ad esempio, on-java-class-change, il contesto viene ricaricato automaticamente, ma spesso fallisce e devo riavviare Tomcat.

Quello che desidero è:

1. Quando faccio una modifica a JSP, dovrebbe essere automaticamente caricato, invece di on-primo-richiesta.

2. Quando una classe java viene modificata e generata, solo quella classe deve essere caricata, senza riavviare Tomcat, anche l'intero contesto non deve essere riavviato o ricaricato.

Se qualcuno ha usato Jetty, si prega di condividere - non Jetty fornire una migliore soluzione a questi problemi.

In PHP, si modifica lo script e si accede a tale pagina. Lo auguro solo in Java.

Answer 1

Usiamo Jetty incorporato al lavoro ed è un vero spasso. Vedi http://wiki.eclipse.org/Jetty/Tutorial/Embedding_Jetty per una guida sull'integrazione di Jetty.

Il tempo di avvio sul lato Jetty è estremamente veloce (1-2 secondi). Nel nostro caso, però, la primavera richiede molto tempo per inizializzarsi.

E 'facile da configurare Jetty per ricaricare automaticamente JSP solo punto in una directory e non file WAR e JSP sarà ricaricata automaticamente, qualcosa di simile:

public class OneWebAppUnassembled 
{ 
    public static void main(String[] args) throws Exception 
    { 
     Server server = new Server(8080); 

     WebAppContext context = new WebAppContext(); 
     context.setDescriptor(webapp+"/WEB-INF/web.xml"); 
     context.setResourceBase("../test-jetty-webapp/src/main/webapp"); 
     context.setContextPath("/"); 
     context.setParentLoaderPriority(true); 

     server.setHandler(context); 

     server.start(); 
     server.join(); 
    } 
} 

Classe ricarico è possibile tramite hot swap, I non so se ci sono soluzioni pronte per quando hot swap non funziona.

Answer 2

Dai un'occhiata allo JRebel. Devi pagare per questo, ma potrebbe valerne la pena a lungo termine per il tempo risparmiato! :)

Answer 3

Scopri SpringSource Tool Suite. Ho iniziato a usarlo un paio di mesi fa.

Viene fornito con un server SpringSource tc preconfigurato (versione di sviluppo). Fondamentalmente, quando lavoro su un'applicazione web, semplicemente lo trascino da Project Explorer sul server SpringSource tc e continuo a svilupparlo. Il codice include le modifiche alle classi Java e le modifiche JSP vengono ricaricate al volo. Quindi qualsiasi modifica apportata può essere visualizzata praticamente istantaneamente.

L'altra cosa che faccio è con Jetty, simile a quello che Yuval menzionato comunque la mia configurazione è in pom.xml di Maven 2 e appare come

<plugin> 
    <groupId>org.mortbay.jetty</groupId> 
    <artifactId>maven-jetty-plugin</artifactId> 
    <configuration> 
     <contextPath>/tas</contextPath> 
     <tmpDir>/tmp</tmpDir> 
     <jettyEnvXml>${basedir}/jetty-env.xml</jettyEnvXml> 
     <systemProperties> 
      <systemProperty> 
       <key> org.mortbay.jetty.webapp.parentLoaderPriority </key> 
       <value>true</value> 
      </systemProperty> 
     </systemProperties> 
    </configuration> 
</plugin> 

Io però preferisco fare ricaricamento manuale con pontile così Di solito aggiungo

<reload>manual</reload> 

nell'elemento <configuration>. Il ricaricamento manuale si applica solo alle modifiche apportate ai file Java.Quindi, dopo un certo numero di modifiche sostanziali e il passaggio positivo dei casi di test, premo Invio nella console Jetty e il tutto viene ricaricato. (Mi piace troppo la scorciatoia Ctrl-S e quindi la colpisco dopo ogni seconda riga, ma non voglio che Jetty si ricarichi dopo ogni seconda riga di codice che scrivo).

Inoltre, tenere presente che il caricamento manuale si applica solo alle modifiche di classe Java ed è richiesto solo quando si modifica la classe Java o una configurazione XML. Se tutto ciò che hai modificato è il JSP, non dovresti aver bisogno di ricaricare la modifica che viene prelevata automaticamente e puoi premere Aggiorna nel browser per vedere il cambio JSP senza il ricaricamento manuale.

Spero che questo aiuti!

Answer 4

Tapestry5 ha live class and template reloading, funziona in Tomcat e Jetty. Questo rende lo sviluppo molto più veloce.

Per quanto riguarda Jetty su Tomcat, in genere utilizzo Jetty per lo sviluppo in questi giorni. È molto veloce da avviare e molto configurabile. È possibile scrivere il proprio server semplice, ed eseguirlo in Eclipse, in questo modo:

import org.eclipse.jetty.server.Server; 
import org.eclipse.jetty.webapp.WebAppContext; 

public class JettyServer { 
    public static void main(String[] args) throws Exception { 
     run(8080, "/path/to/eclipse/project/WebContent", "/WEB-INF/web.xml"); 
    } 
    private static void run(int port, String resourceBase, String descriptor) throws Exception { 
     Server server = new Server(port); 

     WebAppContext context = new WebAppContext(); 
     context.setResourceBase(resourceBase); 
     context.setDescriptor(resourceBase+descriptor); 
     context.setContextPath("/"); 
     context.setParentLoaderPriority(true); 
     server.setHandler(context); 
     server.start(); 
     server.join(); 
    } 
} 

Answer 5

ho usato Sysdeo Tomcat Laucher plug-in di Eclipse con grande successo http://www.eclipsetotale.com/tomcatPlugin.html. La cosa DevLoader è incredibile. L'unico problema che ho con esso è che non può ricaricare una classe che introduce nuove proprietà o metodi. Anche l'autore del plugin è molto reattivo.