Ieri sono passato a IntelliJ IDEA da Eclipse.

Sto usando JRebel anche con WebSphere Server 7.

Ora tutto sembra funzionare piuttosto bene, tranne che quando modifico un file Java e premo save , IntelliJ non ricompila il file, in modo che JRebel lo raccolga.

La funzione " Crea automaticamente " di Eclipse ha risolto questo problema.

In IntelliJ IDEA, devo premere CTRL+ SHIFT+ 9per ricompilare la classe pertinente affinché JRebel la raccolga. Se le modifiche vengono eseguite su due file , l'ho fatto farlo su ognuno di essi e poiché IntelliJ utilizza il meccanismo di salvataggio di tutti, è abbastanza difficile sapere cosa ricompilare manualmente, cosa che non mi interessa davvero fare.

Non c'è un modo per fare in modo che IntelliJ lo faccia da solo ?

AGGIORNATO

Per le versioni IntelliJ IDEA 12+ possiamo creare automaticamente le fonti modificate se utilizziamo l'opzione del compilatore esterno. L'unica cosa necessaria è controllare l'opzione " Crea progetto automaticamente ", che si trova nelle impostazioni " Compilatore ":

Inoltre, se si desidera eseguire la distribuzione a caldo, mentre l'applicazione è in esecuzione o se si utilizzano devtools di avvio a molla, è necessario abilitare anche il compiler.automake.allow.when.app.runningregistro di sistema. Questo compilerà automaticamente le tue modifiche.

Utilizzando Ctrl+ Shift+ A(o ⌘+ Shift+ Asu Mac) digitare Registryuna volta aperte le finestre del registro, individuare e abilitarecompiler.automake.allow.when.app.running , vedere qui:

Per ulteriori suggerimenti, consultare la guida "Migrazione da Eclipse a IntelliJ IDEA" .

Seguire entrambi i passaggi:

1 - Abilita Automake dal compilatore

• Stampa: ctrl + shift+ A(per Mac ⌘+ shift+ A)
• Genere: make project automatically
• Colpire: Enter
• Abilita Make Project automaticallyfunzionalità

2 - Abilita Automake quando l'applicazione è in esecuzione

• Premere: ctrl+ shift+ A(per Mac⌘+ shift+ A)
• Genere: Registry
• Trova la chiave compiler.automake.allow.when.app.runninge abilitala o fai clic sulla casella di controllo accanto ad essa

Nota: riavvia subito l'applicazione :)

Nota: ciò dovrebbe consentire anche il ricaricamento live con gli devtool di avvio a molla.

AVVERTIMENTO

Il plug-in Modalità Eclipse è obsoleto e non è compatibile con le build IDEA 12+ recenti. Se lo installi, IDE si bloccherà ad ogni cambio di file e risponderà in modo estremamente lento.

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

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

C'è anche una voce FAQ che può aiutare.

Aggiornamento sulla funzione di creazione automatica : quando la configurazione di esecuzione / debug è in esecuzione, Make project automaticallynon ha alcun effetto. Le classi sul disco cambieranno solo su Build| Make. È la decisione di progettazione principale poiché, secondo la nostra opinione, le modifiche alla classe su disco dovrebbero essere sempre sotto il controllo dell'utente. La creazione automatica non è il copione della funzione Eclipse, funziona in modo diverso e il suo 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 è ancora necessario attivare 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.

È possibile mappare i tasti ctrl+sper salvare E compilare in un solo passaggio. Vai alle impostazioni della mappa dei tasti e cerca Compile.

In realtà non c'è differenza poiché entrambi richiedono 1 clic:

• Eclipse : salvataggio manuale, compilazione automatica.
• IntelliJ : salvataggio automatico, compilazione manuale.

La soluzione più semplice è solo abituarsi. Perché quando trascorri la maggior parte del tuo giorno nell'IDE, allora è meglio avere abitudini veloci in una che abitudini lente in molte di esse.

Ho finito per registrare una macro per salvarla e compilarla in un solo passaggio, e la mappa dei tasti Ctrl+sad essa.

Sono riuscito a risolverlo usando le macro.

Ho iniziato a registrare una macro:

• Fai clic su Modifica - Macro - Avvia registrazione macro
• Fai clic su File - Salva tutto
• Fai clic su Crea - Crea progetto
• Fai clic su Modifica - Macro - Ferma la registrazione macro

Assegnalo a qualcosa di utile come "SaveAndMake".

Ora basta rimuovere il tasto Salva tutto e aggiungere lo stesso tasto alla tua macro!

Quindi ora, ogni volta che salvo, salva e compila una compilazione sporca e jRebel ora rileva correttamente tutte le modifiche.

Seguire attentamente questi passaggi per abilitarlo.

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

2) invocare Aiuto-> Trova azione ... e digitare "Registro", nella finestra di dialogo cercare "automake" e abilitare la voce " compiler.automake.allow.when.app.running ", chiudere la finestra di dialogo

3) abilita la compilazione in background in Impostazioni-> Build, Execution, Deployment-> Compiler "Crea progetto automaticamente"

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

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

Segnala le tue esperienze e i tuoi problemi come commenti a questo problema.

Clicca qui per maggiori informazioni

L'unica cosa che ha funzionato per me nel mio progetto maven che è stato interessato da questo è aggiungere un obiettivo di "test-compilazione" alla configurazione di esecuzione dei test delle mie unità. Soluzione incredibilmente goffa, ma funziona.

Intellij ha esito negativo quando si verifica un problema di compilazione in un altro modulo e quindi la generazione automatica non viene eseguita. Quindi controlla la tua Problemsfinestra

Ho avuto lo stesso problema. Stavo usando la "Modalità risparmio energia", che impedisce di compilare in modo incrementale e mostrare errori di compilazione.

Utilizza il plug-in Reformat and Compile (ispirato al plug-in Save Actions di Alexandre DuBreuil):

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

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

private final static Set<Document> documentsToProcess = new HashSet<Document>();
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());
}

Modifica la configurazione di esecuzione / debug in modo che l'opzione Crea sia selezionata prima del lancio

Dopo aver selezionato l'opzione è selezionata

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

Non funzionava per me a causa della presenza di un modulo non necessario nella struttura del mio progetto. I test sono stati eseguiti utilizzando l'altro modulo, suppongo.

Non so come sia finito così, ma rimuoverlo ha risolto il problema.

Assicurarsi che le impostazioni di esecuzione / debug utilizzino il modulo che si sta creando con il salvataggio automatico.

Ad esempio: vedere il modulo in

È possibile modificare i moduli in Struttura del progetto - Moduli

Ho avuto lo stesso problema. Penso che sarebbe opportuno verificare se la tua classe può essere compilata o meno. Fai clic su Ricompila (Ctrl + Maiusc + F9 per impostazione predefinita). Se non funziona, devi investigare sul perché non si sta compilando.

Nel mio caso il codice non si compilava automaticamente perché c'erano errori nascosti durante la compilazione (non venivano mostrati nei registri da nessuna parte e anche se clean-install funzionava). La rootcause era una struttura del progetto errata -> Configurazione dei moduli, quindi Intellij Idea non è stata in grado di costruirla secondo questa configurazione.

ho avuto lo stesso problema e anche un'icona del file problema in intellij, quindi ho rimosso la .ideacartella e reimportato il progetto ho risolto il mio problema.

Stavo ottenendo un errore: alcuni vasetti non si trovano nel percorso di classe, quindi elimino solo il vaso danneggiato e eseguo i passaggi seguenti

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
         <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
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

Non abbastanza punti per commentare una risposta esistente, ma simile ad alcune persone sopra, ho semplicemente aggiunto una macro e una mappa di tasti per Organizza importazioni / Formato / Salva tutto / FastReload (F9) / Sincronizza .

La sincronizzazione viene aggiunta in quanto sembra essere l'unico modo in cui posso anche vedere gli aggiornamenti delle risorse modificate da strumenti di build / watcher 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.