Hier, je suis passé à IntelliJ IDEA d'Eclipse.

J'utilise également JRebel avec WebSphere Server 7.

Tout semble maintenant fonctionner assez bien, sauf que lorsque je modifie un fichier Java et que je clique sur Enregistrer , IntelliJ ne recompile pas le fichier, afin que JRebel le récupère.

La fonctionnalité Eclipse " Build Automatically " a résolu ce problème.

Dans IntelliJ IDEA, je dois appuyer sur CTRL+ SHIFT+ 9pour recompiler la classe appropriée pour que JRebel la récupère. Si des modifications sont apportées à deux fichiers , je dois le faire sur chacun d' entre eux et comme IntelliJ utilise le mécanisme de sauvegarde de tout, il est assez difficile de savoir quoi recompiler manuellement, ce qui ne m'intéresse pas vraiment non plus.

N'y a-t-il pas un moyen de faire en sorte qu'IntelliJ le fasse seul ?

ACTUALISÉ

Pour les versions d'IntelliJ IDEA 12+, nous pouvons créer automatiquement les sources modifiées si nous utilisons l'option du compilateur externe. La seule chose à faire est de cocher l'option " Construire le projet automatiquement ", située dans les paramètres " Compilateur ":

De plus, si vous souhaitez effectuer un déploiement à chaud, pendant que l'application est en cours d'exécution ou si vous utilisez les outils de développement Spring Boot, vous devez également activer le compiler.automake.allow.when.app.runningregistre. Cela compilera automatiquement vos modifications.

En utilisant Ctrl+ Shift+ A(ou ⌘+ Shift+ Asur Mac) tapez Registryune fois que la fenêtre de registre est ouverte, recherchez et activez compiler.automake.allow.when.app.running, voir ici:

Pour plus de conseils, consultez le guide «Migration d'Eclipse vers IntelliJ IDEA» .

Veuillez suivre les deux étapes:

1 - Activez Automake depuis le compilateur

• Appuyez sur: ctrl+ shift+ A(pour Mac ⌘+ shift+ A)
• Type: make project automatically
• Frappé: Enter
• Activer la Make Project automaticallyfonctionnalité

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

• Appuyez sur: ctrl+ shift+ A(pour Mac ⌘+ shift+ A)
• Type: Registry
• Recherchez la clé compiler.automake.allow.when.app.runninget activez-la ou cochez la case à côté

Remarque: redémarrez votre application maintenant :)

Remarque: Cela devrait également permettre le rechargement en direct avec les outils de développement Spring Boot.

AVERTISSEMENT

Le plug-in du mode Eclipse est obsolète et n'est pas compatible avec les versions récentes d'IDEA 12+. Si vous l'installez, l'EDI se bloquera à chaque changement de fichier et répondra extrêmement lentement.

IntelliJ IDEA n'utilise pas de compilation automatique, il détecte les erreurs à la volée, pas via le compilateur. Similaire au mode Eclipse sera disponible dans IDEA 12 :

Utiliser Build| Make, il invoque le processus de création incrémentiel qui ne compilera que les fichiers modifiés et dépendants (c'est très rapide).

Il existe également une entrée de FAQ qui peut vous aider.

Mise à jour sur la fonction de création automatique : lorsque la configuration d'exécution / débogage est en cours d'exécution, Make project automaticallyn'a aucun effet. Les classes sur le disque ne changeront que le Build| Make. C'est la décision de conception fondamentale car, à notre avis, les changements de classe sur le disque devraient toujours être sous le contrôle de l'utilisateur. La création automatique n'est pas le copieur de la fonction Eclipse, elle fonctionne différemment et son objectif principal est de gagner du temps en attendant que les classes soient prêtes quand elles sont vraiment nécessaires (avant d'exécuter l'application ou les tests). La création 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 créer un keymap ctrl+spour enregistrer ET compiler en une seule étape. Accédez aux paramètres du clavier et recherchez Compile.

Il n'y a en fait aucune différence car les deux nécessitent 1 clic:

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

La solution la plus simple consiste simplement à s'y habituer. Parce que lorsque vous passez la majeure partie de votre journée dans votre IDE, il vaut mieux avoir des habitudes rapides dans l'une que des habitudes lentes dans plusieurs d'entre elles.

J'ai fini par enregistrer une macro pour la sauvegarder et la compiler en une seule étape, et y ajouter un keymap Ctrl+s.

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 - Tout enregistrer
• Cliquez sur Construire - Créer un projet
• Cliquez sur Modifier - Macros - Arrêter l'enregistrement des macros

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

Maintenant, supprimez simplement la combinaison de touches Enregistrer toutes et ajoutez la même combinaison de touches à votre macro!

Alors maintenant, chaque fois que j'enregistre, il enregistre 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 Spring Boot avec SB V1.3 et ajouter "Devtools" (1 *) aux dépendances

2) invoquez Help-> Find Action ... et tapez "Registry", dans la boîte de dialogue recherchez "automake" et activez l'entrée " compiler.automake.allow.when.app.running ", fermez le dialogue

3) activer la compilation en arrière-plan dans Paramètres-> Construire, Exécution, Déploiement-> Compilateur "Créer un projet automatiquement"

4) ouvrez la configuration d'exécution de Spring Boot, vous devriez recevoir un message d'avertissement si tout est configuré correctement

5) Exécutez votre application, changez vos cours à la volée

Veuillez signaler vos expériences et problèmes en tant que commentaires sur ce problème.

cliquez ici pour plus d'informations

La seule chose qui a fonctionné pour moi dans mon projet maven qui a été affecté par cela est d'ajouter un objectif "test-compilation" à la configuration d'exécution de mes tests unitaires. Solution incroyablement maladroite, mais cela fonctionne.

Intellij échoue silencieusement lorsqu'il rencontre un problème de compilation dans un autre module, puis la construction automatique n'est pas effectuée. Alors vérifiez votre Problemsfenêtre

J'ai eu le même problème. J'utilisais le "mode d'économie d'énergie", qui empêche de compiler de manière incrémentielle et d'afficher des erreurs de compilation.

Utilisez le plugin Reformat and Compile (inspiré du plugin Save Actions d'Alexandre DuBreuil):

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

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

Modifiez votre configuration d'exécution / débogage afin que l'option Build soit sélectionnée avant le lancement

Une fois l'option de construction sélectionnée

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

Cela ne fonctionnait pas pour moi en raison d'un module inutile dans la structure de mon projet. Les tests ont été exécutés en utilisant l'autre module, je suppose.

Je ne sais pas comment ça s'est passé comme ça, mais le supprimer a résolu le problème.

Assurez-vous que vos paramètres d'exécution / débogage utilisent le module que vous créez avec l'enregistrement automatique.

Ex: voir le module dans

Vous pouvez modifier les modules dans Structure du projet - Modules

J'ai eu le même problème. Je pense qu'il serait approprié de vérifier si votre classe peut être compilée ou non. Cliquez sur recompiler (Ctrl + Maj + F9 par défaut). Si cela ne fonctionne pas, vous devez rechercher pourquoi il ne compile pas.

Dans mon cas, le code ne s'autocompilait pas car il y avait des erreurs cachées lors de la compilation (elles n'étaient pas affichées dans les journaux et maven clean-install fonctionnait). La cause principale était une structure de projet incorrecte -> Configuration des modules, donc Intellij Idea n'a pas pu le construire selon cette configuration.

J'ai eu le même problème et aussi une icône de fichier de problème dans intellij, donc j'ai supprimé le .ideadossier et réimporter le projet a résolu mon problème.

J'obtenais une erreur: certains jars ne sont pas dans classpath.Je supprime donc simplement le jar corrompu et perrform ci-dessous

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

Pas assez de points pour commenter une réponse existante, mais comme certaines personnes ci-dessus, j'ai fini par ajouter une macro et un keymap pour Organiser les importations / Format / SaveAll / FastReload (F9) / Synchronize .

La synchronisation est ajoutée car elle semble être la seule façon de voir les mises à jour des ressources modifiées par des outils / observateurs de construction externes (c'est-à-dire, Webpack).

Le processus est plus lent qu'éclipse - et pour l'actualisation du fichier externe, il faut souvent exécuter la commande plusieurs fois - mais supposons que je puisse vivre avec.