pricing - Intellij IDEA clases de Java no compilación automática al guardar
uninstall jrebel (14)
Ayer cambié a Intellij de Eclipse.
También estoy usando jRebel con Websphere Server 7.
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 función eclipse " Crear automáticamente " resolvió este problema.
En Intellij, tengo que presionar CTRL + MAYÚS + 9 para 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 utiliza el mecanismo de guardar todo, es bastante difícil saber qué recompilar manualmente, lo que tampoco me interesa.
¿No hay una manera de hacer que Intellij haga esto por sí mismo ?
ADVERTENCIA
El complemento Eclipse Mode es obsoleto y no es compatible con las compilaciones recientes de IDEA 12+. Si lo instala, IDE dependerá de cada cambio de archivo y responderá extremadamente lento.
IntelliJ IDEA no utiliza compilación automática, detecta errores sobre la marcha, no a través del compilador. Similar al modo Eclipse estará disponible en IDEA 12 :
Use Build | Make , invoca el proceso de creación incremental que compilará solo los archivos modificados y dependientes (es muy rápido).
También hay una entrada de preguntas frecuentes que pueden ayudar.
Actualización sobre la función de marca automática : cuando se ejecuta la configuración de ejecución / depuración, Make project automatically no tiene ningún efecto. Las clases en el disco cambiarán solo en Build | Make Es la decisión de diseño central 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 el imitador de la función Eclipse, funciona de manera diferente y su objetivo principal es ahorrar tiempo a la espera de que las clases estén listas cuando realmente las necesite (antes de ejecutar la aplicación o las pruebas). La creación automática no reemplaza la compilación explícita que todavía 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.
En realidad, no hay diferencia ya que ambos requieren 1 clic:
- Eclipse : manual Guardar, autocompilación.
- IntelliJ : autoguardado, compilación manual.
La solución más simple es acostumbrarse. Porque cuando pasas la mayor parte del día en tu IDE, entonces es mejor tener hábitos rápidos en uno que hábitos lentos en varios de ellos.
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 ventana de Problems
Logré resolver esto usando macros.
Empecé a grabar una macro:
- Haga clic en Editar - Macros - Inicie la grabación de macros
- Haga clic en Archivo - Guardar todo
- Haga clic en Build - Make Project
- Haga clic en Editar - Macros - Detener la grabación de macro
Nómbrelo algo útil como, "SaveAndMake".
Ahora solo elimine Save all keybinding, y agregue el mismo keybinding a su macro!
Así que ahora, cada vez que guardo, guarda y hace una compilación sucia, y jRebel ahora detecta todos los cambios correctamente.
No hay suficientes puntos para comentar sobre una respuesta existente, pero, al igual que algunas personas anteriores, terminé simplemente agregando una macro y un mapa de teclas para organizar Imports / Format / SaveAll / FastReload (F9) / Synchronize .
La sincronización se agrega ya que parece ser la única forma en que también puedo ver actualizaciones en recursos modificados por herramientas / observadores de compilación externos (es decir, paquete web).
El proceso es más lento que el eclipse, y para la actualización del archivo externo a menudo hay que ejecutar el comando varias veces, pero supongamos que puedo vivir con él.
Por favor, siga ambos pasos:
1 - Habilitar Automake desde el compilador
- Presione: ctrl + shift + A (para Mac ⌘ + shift + A )
- Tipo:
make project automatically - Hit: Enter
- Habilitar la función
Make Project automatically
2 - Habilite Automake cuando la aplicación se está ejecutando
- Presione: ctrl + shift + A (para Mac ⌘ + shift + A )
- Tipo:
Registry - Busque 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 devtools de arranque de primavera.
Puede presionar el ctrl+s para guardar Y compilar en un solo paso. Ve a la configuración del mapa de teclas y busca Compile .
Recibí un error: algunos archivos jar no están en classpath. Por lo tanto, elimino el archivo jar dañado y realizo los siguientes pasos
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
Terminé grabando una Macro para guardar y compilar en un solo paso, y un mapa de Ctrl+s para ello.
Tuve el mismo problema. Estaba usando el "modo de ahorro de energía", que impide la compilación de forma incremental y muestra errores de compilación.
Utilice el plugin Reformat and Compile (inspirado en el plugin Save Actions 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());
}
ACTUALIZADO
Para las versiones IDEA 12+ podemos construir automáticamente las fuentes editadas si estamos usando la opción del compilador externo. Lo único que se necesita es marcar la opción "Generar proyecto automáticamente", ubicada en Configuración del compilador. Además, si desea implementarlo en caliente, mientras la aplicación se está ejecutando o si está utilizando las herramientas de inicio de primavera, debe habilitar también la compiler.automake.allow.when.app.running del registro. Esto compilará automáticamente sus cambios.
Usando ctrl + shift + A (o ⌘ + shift + A en mac) escriba Registry una vez que las ventanas de registro estén abiertas, ubique y habilite compiler.automake.allow.when.app.running , consulte aquí:
Por favor, siga estos pasos cuidadosamente para habilitarlo.
1) crear el proyecto Spring Boot con SB V1.3 y agregar "Devtools" (1 *) a dependencias
2) invoque Ayuda-> Buscar acción ... y escriba "Registro", en la búsqueda de diálogo para "automake" y habilite la entrada " compiler.automake.allow.when.app.running ", cierre el diálogo
3) habilitar la compilación de fondo en Configuración-> Compilación, Ejecución, Despliegue-> Compilador "Hacer proyecto automáticamente"
4) abra la configuración de ejecución Spring Boot, debería recibir un mensaje de advertencia si todo está configurado correctamente
5) Ejecute su aplicación, cambie sus clases sobre la marcha
Por favor, informe sus experiencias y problemas como comentarios sobre este tema.