Ayer me cambié a IntelliJ IDEA desde Eclipse.

Estoy usando JRebel con WebSphere Server 7 también.

Ahora todo parece estar funcionando bien, excepto que cuando modifico un archivo Java y presiono guardar , IntelliJ no vuelve a compilar el archivo, para que JRebel lo recoja.

La característica " Compilar automáticamente " de Eclipse resolvió este problema.

En IntelliJ IDEA, tengo que presionar CTRL+ SHIFT+ 9para volver a compilar la clase relevante para que JRebel la recoja. Si se realizan cambios en dos archivos , tengo que hacer esto en cada uno de ellos y dado que IntelliJ usa el mecanismo de guardar todo, es bastante difícil saber qué recompilar manualmente, lo que tampoco me interesa hacer.

¿No hay una manera de hacer que IntelliJ haga esto solo ?

ACTUALIZADO

Para las versiones de IntelliJ IDEA 12+, podemos construir automáticamente las fuentes editadas si estamos utilizando la opción de compilador externo. Lo único que se necesita es marcar la opción " Crear proyecto automáticamente ", ubicada en la configuración de " Compilador ":

Además, si desea realizar una implementación en caliente, mientras la aplicación se está ejecutando o si está utilizando las herramientas de arranque de Spring, también debe habilitar el compiler.automake.allow.when.app.runningregistro from. Esto compilará automáticamente sus cambios.

Usando el tipo Ctrl+ Shift+ A(o ⌘+ Shift+ Aen Mac) Registryuna vez que la ventana de registro esté abierta, ubique y habilite compiler.automake.allow.when.app.running, vea aquí:

Para obtener más consejos, consulte la guía "Migración de Eclipse a IntelliJ IDEA" .

Por favor siga los dos pasos:

1 - Habilitar Automake desde el compilador

• Presione: ctrl+ shift+ A(para Mac ⌘+ shift+ A)
• Tipo: make project automatically
• Golpear: Enter
• Habilitar Make Project automaticallycaracterística

2 - Habilite Automake cuando la aplicación se esté ejecutando

• Presione: ctrl+ shift+ A(para Mac ⌘+ shift+ A)
• Tipo: Registry
• Encuentre la clave compiler.automake.allow.when.app.runningy actívela o haga clic en la casilla de verificación junto a ella

Nota: reinicie su aplicación ahora :)

Nota: Esto también debería permitir la recarga en vivo con las herramientas de arranque de Spring.

ADVERTENCIA

El complemento Eclipse Mode está obsoleto y no es compatible con las versiones recientes de IDEA 12+. Si lo instala, IDE se bloqueará en cada cambio de archivo y responderá extremadamente lento.

IntelliJ IDEA no usa compilación automática, detecta errores sobre la marcha, no a través del compilador. El modo similar a Eclipse estará disponible en IDEA 12 :

Uso Build|Make, invoca el proceso de creación incremental que compilará solo archivos modificados y dependientes (es muy rápido).

También hay una entrada de preguntas frecuentes que puede ayudar.

Actualización de la función de creación automática : cuando se ejecuta la configuración de ejecución / depuración, Make project automaticallyno tiene ningún efecto. Las clases en el disco cambiarán solo en Build| Make. Es la decisión central del diseño, ya que en nuestra opinión, los cambios de clase en el disco siempre deben estar bajo el control del usuario. La creación automática no es la imitación de la función Eclipse, funciona de manera diferente y su objetivo principal es ahorrar tiempo esperando que las clases estén listas cuando realmente se necesitan (antes de ejecutar la aplicación o las pruebas). La creación automática no reemplaza la compilación explícita que aún necesita activar como en el caso descrito en esta pregunta. Si está buscando un comportamiento diferente, el complemento EclipseMode vinculado en las preguntas frecuentes anteriores sería una mejor opción.

Puede hacer un mapa ctrl+sde teclas para guardar Y compilar en un solo paso. Vaya a la configuración del mapa de teclas y busque Compile.

En realidad no hay diferencia ya que ambos requieren 1 clic:

• Eclipse : guardado manual, compilación automática.
• IntelliJ : guardado automático, compilación manual.

La solución más simple es acostumbrarse. Porque cuando pasa la mayor parte del día en su IDE, es mejor tener hábitos rápidos en uno que hábitos lentos en varios de ellos.

Terminé grabando una Macro para guardar y compilar en un solo paso, y asignarle Ctrl+sun mapa .

Logré resolver esto usando macros.

Empecé a grabar una macro:

• Haga clic en Editar - Macros - Iniciar grabación de macro
• Haga clic en Archivo - Guardar todo
• Haga clic en Build - Make Project
• Haga clic en Editar - Macros - Detener la grabación de macros

Nómbrelo algo útil como "SaveAndMake".

¡Ahora simplemente elimine la combinación de teclas Guardar todo y agregue la misma combinación de teclas a su macro!

Entonces, cada vez que guardo, guarda y hace una compilación sucia, y jRebel ahora detecta todos los cambios correctamente.

Siga estos pasos cuidadosamente para habilitarlo.

1) cree el proyecto Spring Boot con SB V1.3 y agregue "Devtools" (1 *) a las dependencias

2) invoque Ayuda-> Buscar acción ... y escriba "Registro", en el cuadro de diálogo busque "automake" y habilite la entrada " compiler.automake.allow.when.app.running ", cierre el cuadro de diálogo

3) habilite la compilación en segundo plano en Configuración-> Compilación, Ejecución, Implementación-> Compilador "Crear proyecto automáticamente"

4) abra Spring Boot run config, debería recibir un mensaje de advertencia si todo está configurado correctamente

5) Ejecute su aplicación, cambie sus clases sobre la marcha

Informe sus experiencias y problemas como comentarios a este problema.

Haga clic aquí para más información

Lo único que funcionó para mí en mi proyecto maven que se vio afectado por esto es agregar un objetivo de "compilación de prueba" a la configuración de ejecución de mis pruebas unitarias. Solución increíblemente torpe, pero funciona.

Intellij falla silenciosamente cuando encuentra un problema de compilación en otro módulo, y luego no se realiza la compilación automática. Así que revisa tu Problemsventana

Tuve el mismo problema. Estaba usando el "Modo de ahorro de energía", que impide la compilación incremental y muestra errores de compilación.

Utilice el complemento Reformatear y compilar (inspirado en el complemento Guardar acciones de Alexandre DuBreuil):

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

Por el momento solo estoy ofreciendo un archivo jar, pero esta es la parte más importante del código:

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

Edite su Configuración de ejecución / depuración para que la opción de compilación esté seleccionada antes de iniciar

Después de seleccionar la opción Construir

La solución anterior funcionó para mí mientras trabajaba en mi conjunto de pruebas JBehave

No funcionaba para mí debido a que tenía un módulo innecesario en la estructura de mi proyecto. Las pruebas se ejecutaron utilizando el otro módulo, supongo.

No sé cómo terminó así, pero eliminarlo resolvió el problema.

Asegúrese de que su configuración de Ejecutar / Depurar esté utilizando el módulo que está creando con el autoguardado.

Por ejemplo: ver el módulo en

Puede cambiar los módulos en Estructura del proyecto - Módulos

Tuve el mismo problema. Creo que sería apropiado verificar si tu clase se puede compilar o no. Haga clic en recompilar (Ctrl + Shift + F9 por defecto). Si no funciona, debe investigar por qué no se está compilando.

En mi caso, el código no se autocompilaba porque había errores ocultos con la compilación (no se mostraban en los registros en ninguna parte y la instalación limpia de Maven funcionaba). La causa raíz era Estructura del proyecto incorrecta -> Configuración de módulos, por lo que Intellij Idea no pudo construirlo de acuerdo con esta configuración.

tuve mismo tema y también un icono de archivo problema en intellij, por lo quité el .ideaproyecto de importación de carpeta y volver resuelto mi problema.

Recibí un error: algunos frascos no están en classpath, así que simplemente elimino el frasco dañado y realizo los pasos a continuación

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

No hay suficientes puntos para comentar sobre una respuesta existente, pero similar a algunas personas anteriores, terminé agregando una macro y un mapa de teclas para Organizar importaciones / Formato / Guardar todo / FastReload (F9) / Sincronizar .

Se agrega la sincronización, ya que parece ser la única forma en que también puedo ver actualizaciones en los recursos modificados por herramientas / observadores de compilación externos (es decir, webpack).

El proceso es más lento que eclipse, y para la actualización del archivo externo a menudo tengo que ejecutar el comando varias veces, pero supongamos que puedo vivir con él.