Ontem mudei para o IntelliJ IDEA do Eclipse.

Também estou usando o JRebel com o WebSphere Server 7.

Agora tudo parece estar funcionando bem, exceto que quando modifico um arquivo Java e clico em Salvar , o IntelliJ não recompila o arquivo, para que o JRebel o recolha.

O recurso " Construir automaticamente " do Eclipse resolveu esse problema.

No IntelliJ IDEA, tenho que pressionar CTRL+ SHIFT+ 9para recompilar a classe relevante para o JRebel buscá-la. Se forem feitas alterações em dois arquivos , eu tenho que fazer isso em cada um deles e, como o IntelliJ usa o mecanismo salvar tudo, é muito difícil saber o que recompilar manualmente, o que também não estou interessado em fazer.

Não existe uma maneira de fazer o IntelliJ fazer isso sozinho ?

ATUALIZADA

Para versões do IntelliJ IDEA 12+, podemos criar automaticamente as fontes editadas se estivermos usando a opção de compilador externo. A única coisa necessária é verificar a opção " Compilar projeto automaticamente ", localizada nas configurações de " Compilador ":

Além disso, se você deseja implantar a quente, enquanto o aplicativo estiver em execução ou se estiver usando o Spring Boot Devtools, também deverá ativar o compiler.automake.allow.when.app.runningregistro from. Isso irá compilar automaticamente suas alterações.

Usando o tipo Ctrl+ Shift+ A(ou ⌘+ Shift+ Ano Mac) Registryquando a janela do registro estiver aberta, localize e ative compiler.automake.allow.when.app.running, veja aqui:

Para obter mais dicas, consulte o guia "Migrando do Eclipse para o IntelliJ IDEA" .

Por favor, siga os dois passos:

1 - Habilite o Automake a partir do compilador

• Pressione: ctrl+ shift+ A(Para Mac ⌘+ shift+ A)
• Tipo: make project automatically
• Acertar: Enter
• Ativar Make Project automaticallyrecurso

2 - Ativar Automake quando o aplicativo estiver sendo executado

• Pressione: ctrl+ shift+ A(Para Mac ⌘+ shift+ A)
• Tipo: Registry
• Encontre a chave compiler.automake.allow.when.app.runninge ative-a ou clique na caixa de seleção ao lado dela

Nota: Reinicie seu aplicativo agora :)

Nota: Isso também deve permitir recarga ao vivo com os devtools de inicialização por mola.

AVISO

O plug-in do Modo Eclipse é obsoleto e não é compatível com as recentes compilações do IDEA 12+. Se você instalá-lo, o IDE travará em todas as alterações de arquivo e responderá extremamente lento.

O IntelliJ IDEA não usa compilação automática, ele detecta erros em tempo real, não via compilador. Semelhante ao modo Eclipse estará disponível no IDEA 12 :

Use Build|Make, ele invoca o processo de criação incremental que compila apenas arquivos alterados e dependentes (é muito rápido).

Há também uma entrada de perguntas frequentes que pode ajudar.

Atualização no recurso de criação automática : Quando a configuração de execução / depuração está em execução, Make project automaticallynão tem efeito. Classes no disco serão alteradas apenas em Build| Make. É a decisão principal do projeto, pois, em nossa opinião, as alterações de classe no disco devem estar sempre sob o controle do usuário. O make automático não é o imitador do recurso Eclipse, funciona de maneira diferente e seu principal objetivo é economizar tempo aguardando que as classes estejam prontas quando realmente são necessárias (antes de executar o aplicativo ou os testes). A criação automática não substitui a compilação explícita que você ainda precisa acionar, como no caso descrito nesta pergunta. Se você estiver procurando um comportamento diferente, o plug-in EclipseMode vinculado na FAQ acima seria uma escolha melhor.

Você pode mapear as teclas ctrl+spara salvar E compilar em uma etapa. Vá para as configurações do mapa de teclas e procure Compile.

Na verdade, não há diferença, pois ambos exigem 1 clique:

• Eclipse : salvamento manual, compilação automática.
• IntelliJ : salvamento automático, compilação manual.

A solução mais simples é apenas para se acostumar. Porque quando você passa a maior parte do dia no IDE, é melhor ter hábitos rápidos em um do que hábitos lentos em vários deles.

Acabei gravando uma macro para salvar e compilar em uma etapa e o mapa Ctrl+sde teclas para ela.

Eu consegui resolver isso usando macros.

Comecei a gravar uma macro:

• Clique em Editar - Macros - Iniciar gravação de macro
• Clique em Arquivo - Salvar tudo
• Clique em Build - Make Project
• Clique em Editar - Macros - Parar gravação de macro

Nomeie algo útil como "SaveAndMake".

Agora basta remover a opção Salvar todas as combinações de teclas e adicionar a mesma combinação de teclas à sua macro!

Então agora, toda vez que eu salvo, ele salva e faz uma compilação suja, e o jRebel agora detecta todas as alterações corretamente.

Por favor, siga estas etapas cuidadosamente para habilitá-lo.

1) crie o projeto Spring Boot com o SB V1.3 e adicione "Devtools" (1 *) às dependências

2) chame Ajuda-> Localizar Ação ... e digite "Registro", na caixa de diálogo, procure por "automake" e ative a entrada " compiler.automake.allow.when.app.running ", feche a caixa de diálogo

3) habilite a compilação em segundo plano em Configurações-> Compilar, Execução, Implantação-> Compilador "Criar projeto automaticamente"

4) abra a configuração de execução do Spring Boot, você receberá uma mensagem de aviso se tudo estiver configurado corretamente

5) Execute seu aplicativo, mude suas aulas on-the-fly

Por favor, relate suas experiências e problemas como comentários para esse problema.

Clique aqui para mais informações

A única coisa que funcionou para mim no meu projeto maven que foi afetado por isso é adicionar uma meta de "compilação de teste" à configuração de execução dos meus testes de unidade. Solução incrivelmente desajeitada, mas funciona.

O Intellij falha silenciosamente quando encontra um problema de compilação em outro módulo e a compilação automática não é executada. Então verifique sua Problemsjanela

Eu tive o mesmo problema. Eu estava usando o "Modo de economia de energia", que impede a compilação incremental e mostra erros de compilação.

Use o plug-in Reformatar e Compilar (inspirado no plug-in Salvar Ações de Alexandre DuBreuil):

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

No momento, estou oferecendo apenas um arquivo jar, mas esta é a parte mais importante do 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 sua Configuração de Execução / Depuração para que a opção Compilar esteja selecionada antes de iniciar

Depois que a opção Compilar estiver selecionada

A solução acima funcionou para mim enquanto trabalhava no meu conjunto de testes JBehave

Não estava funcionando para mim devido a um módulo desnecessário na estrutura do meu projeto. Os testes foram executados usando o outro módulo, suponho.

Não sei como acabou assim, mas removê-lo resolveu o problema.

Verifique se as configurações de Executar / Depurar estão usando o módulo que você está construindo com o salvamento automático.

Por exemplo: veja o módulo em

Você pode alterar os módulos em Estrutura do projeto - Módulos

Eu tive o mesmo problema. Eu acho que seria apropriado verificar se sua classe pode ser compilada ou não. Clique em recompilar (Ctrl + Shift + F9 por padrão). Se não está funcionando, você deve investigar por que não está compilando.

No meu caso, o código não era de compilação automática porque havia erros ocultos na compilação (eles não eram mostrados nos logs em nenhum lugar e a instalação limpa do maven estava funcionando). A causa raiz estava incorreta na Estrutura do Projeto -> Configuração dos módulos, portanto, o Intellij Idea não conseguiu construí-lo de acordo com esta configuração.

Eu tive o mesmo problema e também um ícone de arquivo de problema no intellij, então removi a .ideapasta e reimporte o projeto resolvi o meu problema.

Eu estava recebendo erro: alguns jars não estão no caminho de classe. Então, apenas apague o jar corrompido e execute-o abaixo das etapas

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

Não há pontos suficientes para comentar uma resposta existente, mas semelhante a algumas pessoas acima, acabei adicionando uma macro e um mapa de teclas para Organizar importações / Formato / Salvar / FastReload (F9) / Sincronizar .

A sincronização é adicionada, pois parece ser a única maneira de também ver atualizações nos recursos modificados por ferramentas / observadores de construção externos (por exemplo, webpack).

O processo é mais lento que o eclipse - e para a atualização de arquivos externos, muitas vezes é necessário executar o comando várias vezes - mas suponha que eu possa conviver com ele.