veuillez suivre les deux étapes:

1-Activer Automake à partir du compilateur

• de la Presse: ctrl + shift + Un (Pour Mac ⌘ + shift + Un )
• Type: make project automatically
• Hit: Entrée
• activer Make Project automatically caractéristique

2 - Activer Automake lorsque l'application est en cours d'exécution

• de la Presse: ctrl + shift + Un (Pour Mac ⌘ + shift + Un )
• Type: Registry
• trouver la clé compiler.automake.allow.when.app.running et activer ou cochez la case à côté de lui

Note: redémarrez votre application maintenant :)

Note: cela devrait également permettre une recharge en direct avec des devtools de botte de printemps.

avertissement

mode Eclipse le plug-in est obsolète et n'est pas compatible avec les constructions IDEA 12+ récentes. Si vous l'installez, IDE s'accrochera à chaque changement de fichier et répondra très lentement.

IntelliJ IDEA n'utilise pas la construction automatique, il détecte les erreurs à la volée, pas via un compilateur. Similaire au mode Eclipse sera disponible en idée 12 :

Use Build / Make , il invoque le processus de make incrémental qui ne compilera que les fichiers modifiés et dépendants (c'est très rapide).

Il ya aussi un FAQ entrée qui peut aider.

mise à Jour automatique faire des : Lorsque la configuration run/debug est en cours d'exécution, Make project automatically n'a aucun effet. Les Classes sur disque dur changer uniquement sur Build / Make . C'est la décision de conception de base car à notre avis les changements de classe sur le disque devraient toujours être sous le contrôle de l'utilisateur. La marque automatique n'est pas l'imitateur de la fonctionnalité Eclipse, elle fonctionne différemment et son but principal est de gagner du temps en attendant que les classes soient prêtes quand elles sont vraiment nécessaires (avant de lancer l'application ou les tests). La marque automatique ne remplace pas la compilation explicite que vous devez encore déclencher comme dans le cas décrit dans cette question. Si vous recherchez un comportement différent, le plug-in EclipseMode lié dans la FAQ ci-dessus serait un meilleur choix.

vous pouvez taper ctrl+s pour sauvegarder et compiler en une seule étape. Allez dans les paramètres keymap et recherchez Compile .

j'ai fini par enregistrer un Macro pour enregistrer et compiler en une seule étape, et keymap Ctrl+s .

il y a effectivement pas de différence car les deux nécessitent un clic:

• Eclipse : sauvegarde manuelle, auto-compilation.
• IntelliJ : sauvegarde automatique, compilation manuelle.

la solution la plus simple est juste pour s'y habituer. Parce que quand vous passez la plupart de votre journée dans votre IDE, alors mieux d'avoir des habitudes rapides dans un que lent habitudes dans plusieurs d'entre eux.

j'ai réussi à résoudre ce problème en utilisant des macros.

j'ai commencé à enregistrer une macro:

• , Cliquez sur Modifier - Macros - Démarrer l'enregistrement de la macro
• Cliquez Sur Fichier-Save All
• Cliquez Sur L'Accumulation De Créer Le Projet
• , Cliquez sur Modifier - Macros - Arrêter l'enregistrement de la macro

appelez - le quelque chose d'utile comme "SaveAndMake".

maintenant, il suffit de supprimer le Sauvegardez toutes les liaisons, et ajoutez la même liaison à votre macro!

donc maintenant, chaque fois que je sauve, Il sauve et fait une compilation sale, et jRebel détecte maintenant toutes les modifications correctement.

veuillez suivre attentivement ces étapes pour l'activer.

1) Créer un projet de Botte de printemps avec SB V1.3 et ajouter "Devtools" (1*) aux dépendances

2) appeler l'Aide->Trouver d'Action... et tapez "Registry", dans la boîte de dialogue recherche de" automake " et activez l'entrée " compilateur.automake.permettre.lorsque.App.lancer ", fermer le dialogue

3) activer la compilation de Paramètres->Construire, l'Exécution, le Déploiement->Compilateur "projet automatiquement"

4) ouvrez le Printemps de Démarrage exécuter config, vous devriez obtenir un message d'avertissement si tout est configuré correctement

5) lancez votre application, changez vos classes à la volée

s'il vous Plaît rapport à vos expériences et des problèmes que les commentaires à cette question.

Cliquez ici pour plus d'informations

la seule chose qui a fonctionné pour moi dans mon projet maven qui a été affectée par ceci est d'ajouter un but" test-Compilation " à la configuration d'exécution de mes tests unitaires. Solution incroyablement maladroite, mais ça marche.

utiliser le plugin Reformat et compiler (inspiré du plugin Save Actions D'Alexandre Dubreuil):

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

en ce moment je ne propose qu'un fichier jar, mais c'est la partie la plus importante du code:

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());
}

Intellij échoue tranquillement quand il rencontre un problème de compilation dans un autre module, et alors la compilation automatique n'est pas effectuée. Donc, vérifiez votre Problems fenêtre

j'ai eu une erreur: certains pots ne sont pas dans classpath.Donc je viens de supprimer le pot corrompu et perrform ci-dessous les étapes

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

modifiez votre Configuration D'exécution / débogage pour que L'option de compilation soit sélectionnée avant de lancer

après L'option de construction est sélectionnée

la solution ci-dessus a fonctionné pour moi tout en travaillant sur ma suite de test JBehave

j'ai eu le même problème. J'utilisais le "mode D'économie D'énergie", qui empêche de compiler de façon incrémentale et de montrer des erreurs de compilation.

pas assez de points pour commenter une réponse existante, mais comme certaines personnes ci-dessus, j'ai fini par ajouter une macro & keymap à organiser les importations / Format / SaveAll / FastReload(F9) / synchroniser .

la synchronize est ajoutée car elle semble être la seule façon que je puisse voir aussi des mises à jour dans les ressources modifiées par des outils de construction externes / watchers (i.e., webpack).

le processus est plus lent que l'éclipse - et pour le rafraîchir le fichier externe doit souvent exécuter la commande plusieurs fois - mais supposons que je puisse vivre avec.