Intellij IDEA Le classi Java non compilano automaticamente al salvataggio

Ieri sono passato a Intellij da Eclipse.

Sto usando jRebel anche con Websphere Server 7.

Tutto ora sembra funzionare abbastanza bene, tranne che quando modifico un file Java e premo Salva , Intellij non ricompila il file, in modo che jRebel lo raccolga.

La funzione ” Costruisci automaticamente ” dell’eclipse ha risolto questo problema.

In Intellij, devo premere CTRL + MAIUSC + 9 per ricompilare la class pertinente per jRebel per raccoglierla. Se le modifiche vengono eseguite su due file , devo eseguire questa operazione su ciascuno di essi e uno di essi e poiché Intellij utilizza il meccanismo di salvataggio tutto, è piuttosto difficile sapere cosa ricompilare manualmente a cui non sono realmente interessato.

    Non c’è un modo per fare in modo che Intellij lo faccia da solo ?

    AGGIORNATO
    Per le versioni di IDEA 12+ possiamo build automaticamente le fonti modificate se stiamo usando l’opzione del compilatore esterno. L’unica cosa necessaria è verificare l’opzione “Crea progetto automaticamente”, che si trova sotto Impostazioni del compilatore. Impostazioni del compilatore Inoltre, se si desidera implementare a caldo, mentre l’applicazione è in esecuzione o se si stanno utilizzando gli sviluppatori di avvio di spring, è necessario abilitare anche il compiler.automake.allow.when.app.running dal registro. Questo compilerà automaticamente le tue modifiche.

    Usando ctrl + shift + A (o + shift + A su mac) digita Registry una volta aperte le windows di registro, individua e abilita compiler.automake.allow.when.app.running , vedi qui: inserisci la descrizione dell'immagine qui


    Per versioni precedenti a 12, è ansible utilizzare il plug-in EclipseMode per fare in modo che IDEA compili automaticamente i file salvati. Vedere: https://www.jetbrains.com/help/idea/2016.3/eclipse.html per ulteriori suggerimenti durante la migrazione da Eclipse.

    Si prega di seguire entrambi i passaggi:

    1 – Abilita Automake dal compilatore

    • Premere: ctrl + MAIUSC + A (per Mac + MAIUSC + A )
    • Tipo: make project automatically
    • Hit: Invio
    • Abilita funzione Make Project automatically

    2 – Abilita Automake quando l’applicazione è in esecuzione

    • Premere: ctrl + MAIUSC + A (per Mac + MAIUSC + A )
    • Tipo: Registry
    • Trova la chiave compiler.automake.allow.when.app.running e abilitala o fai clic sulla casella accanto ad essa

    Nota: riavvia la tua applicazione ora 🙂

    Nota: questo dovrebbe consentire anche la ricarica live con gli strumenti di avvio primaverile.

    AVVERTIMENTO

    Il plug-in Eclipse Mode è obsoleto e non è compatibile con i recenti build IDEA 12+. Se lo installi, IDE si bloccherà a ogni cambio di file e risponderà molto lentamente.


    IntelliJ IDEA non utilizza la build automatica, rileva gli errori al volo, non tramite il compilatore. Simile alla modalità Eclipse sarà disponibile in IDEA 12 :

    Fai il progetto automaticamente

    Usa Build | Make , invoca il processo di creazione incrementale che compilerà solo i file modificati e dipendenti (è molto veloce).

    C’è anche una voce di domande frequenti che può aiutare.

    Aggiornamento sulla funzione di creazione automatica : quando viene eseguita la configurazione di esecuzione / debug, il Make project automatically non ha alcun effetto. Le classi su disco cambieranno solo su Build | Make . È la decisione di base del design, dal momento che, a nostro parere, le modifiche di class sul disco dovrebbero essere sempre sotto il controllo dell’utente. Il make automatico non è il copione della funzione Eclipse, funziona in modo diverso e lo scopo principale è quello di risparmiare tempo in attesa che le classi siano pronte quando sono realmente necessarie (prima di eseguire l’app o i test). La creazione automatica non sostituisce la compilazione esplicita che deve ancora essere triggersta come nel caso descritto in questa domanda. Se stai cercando un comportamento diverso, il plug-in EclipseMode collegato nelle FAQ sopra sarebbe una scelta migliore.

    Puoi keymap ctrl+s per salvare E compilare in un unico passaggio. Vai alle impostazioni della tastiera e cerca Compile .

    Ho finito per registrare una Macro da salvare e compilare in un solo passaggio, e la tastiera di Ctrl+s ad esso.

    In realtà non vi è alcuna differenza in quanto entrambi richiedono 1 clic:

    • Eclipse : salvataggio manuale, auto-compilazione.
    • IntelliJ : salvataggio automatico, compilazione manuale.

    La soluzione più semplice è solo per abituarsi. Perché quando trascorri la maggior parte del tuo giorno nel tuo IDE, allora meglio avere abitudini veloci in uno di abitudini lente in molti di essi.

    Sono riuscito a risolvere questo utilizzando i macro.

    Ho iniziato a registrare una macro:

    • Fare clic su Modifica – Macro – Avvia registrazione macro
    • Fare clic su File – Salva tutto
    • Fai clic su Crea – Crea progetto
    • Fare clic su Modifica – Macro – Interrompi registrazione macro

    Chiamalo come qualcosa di utile come “SaveAndMake”.

    Ora basta rimuovere la combinazione di tasti Salva tutto e aggiungere la stessa combinazione di tasti alla tua macro!

    Così ora, ogni volta che salvo, salva e fa una compilazione sporca, e jebebel ora rileva tutte le modifiche correttamente.

    Si prega di seguire attentamente questi passaggi per abilitarlo.

    1) creare il progetto Spring Boot con SB V1.3 e aggiungere “Devtools” (1 *) alle dipendenze

    2) richiama Aiuto-> Cerca azione … e digita “Registro”, nella finestra di dialogo cerca “automake” e abilita la voce ” compiler.automake.allow.when.app.running “, close dialog

    3) abilitare la compilazione in background in Impostazioni-> Build, Execution, Deployment-> Compiler “Crea progetto automaticamente”

    4) Apri Spring Boot run config, dovresti ricevere un messaggio di avvertimento se tutto è configurato correttamente

    5) Esegui la tua app, cambia le tue classi al volo

    Si prega di segnalare le vostre esperienze e problemi come commenti a questo problema.

    Clicca qui per maggiori informazioni

    L’unica cosa che ha funzionato per me nel mio progetto di maven che è stato influenzato da questo è di aggiungere un objective “test-compile” alla configurazione di esecuzione dei miei test di unità. Soluzione incredibilmente maldestra, ma funziona.

    inserisci la descrizione dell'immagine qui

    Usa il plugin Reformat e Compile (ispirato al plug-in Save Actions di Alexandre DuBreuil):

    https://plugins.jetbrains.com/plugin/8231?pr=idea_ce

    Al momento sto offrendo solo un file jar, ma questa è la parte più importante del codice:

     private final static Set documentsToProcess = new HashSet(); private static VirtualFile[] fileToCompile = VirtualFile.EMPTY_ARRAY; // The plugin extends FileDocumentManagerAdapter. // beforeDocumentSaving calls reformatAndCompile private static void reformatAndCompile( @NotNull final Project project, @NotNull final Document document, @NotNull final PsiFile psiFile) { documentsToProcess.add(document); if (storage.isEnabled(Action.compileFile) && isDocumentActive(project, document)) { fileToCompile = isFileCompilable(project, psiFile.getVirtualFile()); } ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { if (documentsToProcess.contains(document)) { documentsToProcess.remove(document); if (storage.isEnabled(Action.optimizeImports) || storage.isEnabled(Action.reformatCode)) { CommandProcessor.getInstance().runUndoTransparentAction(new Runnable() { @Override public void run() { if (storage.isEnabled(Action.optimizeImports)) { new OptimizeImportsProcessor(project, psiFile) .run(); } if (storage.isEnabled(Action.reformatCode)) { new ReformatCodeProcessor( project, psiFile, null, ChangeListManager .getInstance(project) .getChange(psiFile.getVirtualFile()) != null) .run(); } ApplicationManager.getApplication().runWriteAction(new Runnable() { @Override public void run() { CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(psiFile); } }); } }); } } if (fileToCompile.length > 0) { if (documentsToProcess.isEmpty()) { compileFile(project, fileToCompile); fileToCompile = VirtualFile.EMPTY_ARRAY; } } else if (storage.isEnabled(Action.makeProject)) { if (documentsToProcess.isEmpty()) { makeProject(project); } } else { saveFile(project, document, psiFile.getVirtualFile()); } } }, project.getDisposed()); } private static void makeProject(@NotNull final Project project) { ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { CompilerManager.getInstance(project).make(null); } }, project.getDisposed()); } private static void compileFile( @NotNull final Project project, @NotNull final VirtualFile[] files) { ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { CompilerManager.getInstance(project).compile(files, null); } }, project.getDisposed()); } private static void saveFile( @NotNull final Project project, @NotNull final Document document, @NotNull final VirtualFile file) { ApplicationManager.getApplication().invokeLater(new Runnable() { @Override public void run() { final FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance(); if (fileDocumentManager.isFileModified(file)) { fileDocumentManager.saveDocument(document); } } }, project.getDisposed()); } 

    Intellij fallisce tranquillamente quando incontra un problema di compilazione in un altro modulo e quindi la compilazione automatica non viene eseguita. Quindi controlla la finestra dei tuoi Problems

    Stavo ricevendo un errore: alcuni vasi non sono in classpath. Quindi ho solo cancellato il barattolo corrotto e performato sotto i passaggi

     1.Project > Setting>Build,Execution,Deployment>Compiler>check build project automatically 2.CTRL+SHIFT+A find/search **registry** --Check for below param compiler.automake.allow.when.app.running compiler.automake.trigger.delay=500---According to ur requirement 3.Add devtool in pom.xml  org.springframework.boot spring-boot-devtools true  4.Build ,If found any probelm while building ,saying some jar in not in class path.Just delete the corrupted jar and re-build the project angain after sync with maven lib 

    Modifica la configurazione Esegui / Debug in modo che l’opzione Costruisci sia selezionata prima dell’avvio

    inserisci la descrizione dell'immagine qui

    Dopo l’opzione Costruisci è selezionata

    inserisci la descrizione dell'immagine qui

    La soluzione di cui sopra ha funzionato per me mentre lavoravo alla mia suite di test JBehave

    Ho avuto lo stesso problema. Stavo usando la “Modalità di risparmio energetico”, che impedisce la compilazione in modo incrementale e mostra errori di compilazione.

    Non abbastanza punti per commentare una risposta esistente, ma simile ad alcune persone sopra, mi sono limitato ad aggiungere una macro e una mappa di tasti per Organizzare le importazioni / Formato / Salva tutto / FastReload (F9) / Sincronizzare .

    La sincronizzazione viene aggiunta in quanto sembra essere l’unico modo in cui posso anche vedere gli aggiornamenti nelle risorse modificate da strumenti di creazione / osservatori esterni (ad es., Webpack).

    Il processo è più lento di eclipse e per l’aggiornamento del file esterno spesso è necessario eseguire il comando più volte, ma supponiamo che io possa conviverci.