Come configurare IntelliJ/gradle per usare dagger 2.0

Question

Ho un progetto gradle e voglio usare dagger 2.0 al suo interno. Non so come configurare IntelliJ e gradle per generare file e consentire a IntelliJ di trovarli?

Il mio file build.gradle assomiglia:

apply plugin: 'java' 
apply plugin: 'idea' 

version = '1.0' 

repositories { 
    mavenCentral() 
    maven { 
     url "https://oss.sonatype.org/content/repositories/snapshots" 
    } 
} 

dependencies { 
    compile 'org.slf4j:slf4j-api:1.7.12' 
    compile 'org.slf4j:slf4j-simple:1.7.12' 
    compile 'commons-configuration:commons-configuration:1.10' 
    compile 'commons-collections:commons-collections:3.2.1' 
    compile 'com.google.dagger:dagger:2.0' 
    compile 'com.google.dagger:dagger-compiler:2.0:jar-with-dependencies' 
    compile 'com.pi4j:pi4j-distribution:1.1-SNAPSHOT' 
} 

Nella cartella di generazione della mia applicazione del file DaggerXmlConfigurationComponent esiste, che è una componente crea Dagger. Ma non posso usarlo in IntelliJ perché non riesce a trovare la classe.

Questa non è un'applicazione Android ma un'applicazione per Raspberry Pi.

Answer 1

È necessario abilitare manualmente l'elaborazione delle annotazioni per IntelliJ: in Impostazioni ... → Build, Esecuzione, Distribuzione → Compilatore → Processi di annotazione, selezionare Abilita elaborazione annotazione e Ottieni processori dal classpath del progetto.

Answer 2

Ho trovato una soluzione.

https://github.com/tbroyer/gradle-apt-plugin

buildscript { 
    repositories { 
    maven { 
     url "https://plugins.gradle.org/m2/" 
    } 
    } 
    dependencies { 
    classpath "net.ltgt.gradle:gradle-apt-plugin:0.3" 
    } 
} 

apply plugin: "net.ltgt.apt" 

dependecies { 
    apt 'com.google.dagger:dagger-compiler:2.0.1' 
    compile 'com.google.dagger:dagger:2.0.1' 
} 

Inoltre se si utilizza un Intellij seguente configurazione è consigliata:

Quando si utilizza l'integrazione Gradle in IntelliJ IDEA tuttavia, piuttosto che il compito idea, dovrete manualmente abilitare l'elaborazione delle annotazioni: in Impostazioni ... → Build, Execution, Deployment → Compiler → Processori annotazione, selezionare Abilita elaborazione annotazione e Ottieni processori dal classpath del progetto. Per simulare il comportamento di Gradle e il comportamento dei file generati, è possibile configurare le directory di produzione e di verifica delle origini per generare/generate/source/apt/main e build/generate/source/apt/test rispettivamente e scegliere Memorizza origini generate relative a: Modulo radice del contenuto. Ho anche dovuto rimuovere Exclude dall'intera directory di build e contrassegnare la directory/source/apt/main come sorgente.

Answer 3

ho avuto problemi con l'existings plugin, così ho aggiunto il seguente al mio build.gradle:

def daggerVersion = "2.4" 

// APT >> 
def genPath = new File(buildDir,"generated/java/APT") 

task createGenPath << { 
    if(!genPath.exists()){ 
     genPath.mkdirs() 
    } 
} 
compileJava.dependsOn(createGenPath) 

compileJava { 
    options.compilerArgs << '-s' << genPath 
} 
// APT << 


dependencies { 
    compile "com.google.dagger:dagger:$daggerVersion" 
    compile "com.google.dagger:dagger-compiler:$daggerVersion" 
} 

// APT IDEA >> 
idea.module { 
    sourceDirs += genPath 
    // maybe add to generatedSourceDirs 
    iml { 
     withXml { 
      File ideaCompilerXml = project.file('.idea/compiler.xml') 
      if (ideaCompilerXml.isFile()) { 
       Node parsedProjectXml = (new XmlParser()).parse(ideaCompilerXml) 
       updateIdeaCompilerConfiguration(parsedProjectXml) 
       ideaCompilerXml.withWriter { writer -> 
        XmlNodePrinter nodePrinter = new XmlNodePrinter(new PrintWriter(writer)) 
        nodePrinter.setPreserveWhitespace(true) 
        nodePrinter.print(parsedProjectXml) 
       } 
      } 
     } 
    } 
} 

static void updateIdeaCompilerConfiguration(Node projectConfiguration) { //actually resets APT 
    Object compilerConfiguration = projectConfiguration.component.find { it.@name == 'CompilerConfiguration' } 
    compilerConfiguration.annotationProcessing.replaceNode{ 
     annotationProcessing() { 
      profile(default: 'true', name: 'Default', enabled: 'true') { 
       sourceOutputDir(name: '') 
       sourceTestOutputDir(name: '') 
       outputRelativeToContentRoot(value: 'true') 
       processorPath(useClasspath: 'true') 
      } 
     } 
    } 
} 
// APT IDEA << 

Answer 4

anch'io non potevano ottenere qualsiasi dei plugin per lavorare, quindi in base alla risposta di Stefan ho fatto la seguente che funziona, ma IntelliJ sembra fastidioso creare moduli di gruppo, che prima non c'erano. Sii bravo se qualcuno ha idea di cosa stia causando questo mi piacerebbe davvero ottenere questo problema.

apply plugin: 'java' 
apply plugin: 'idea' 

configurations { 
    compileDagger 
} 

def genPath = new File(buildDir,"generated/source/apt/main") 

task createGenPath << { 
    if(!genPath.exists()){ 
     genPath.mkdirs() 
    } 
} 

compileJava.dependsOn(createGenPath) 

compileJava { 
    source += genPath 
    classpath += configurations.compileDagger 
    options.compilerArgs += ['-s', genPath] 
} 

idea.module { 
    sourceDirs += genPath 
} 

dependencies { 
    compileDagger "com.google.dagger:dagger-compiler:${dagger2Version}" 
    compile "com.google.dagger:dagger:${dagger2Version}" 
} 

Answer 5

Nel mio caso il problema era IDEA che creava un modulo separato per i file generati da pugnale. Dovevo andare a File -> Project Structure -> Modules e rimuovere il modulo projectname_dagger (facendo clic sul segno meno rosso), quindi aggiungere la cartella di origine generata al mio modulo projectname_main facendo clic su Add Content Root e selezionandolo.

Per qualche motivo ho dovuto eliminare i file di Dagger e lasciare che IDEA li rigenerava perché stavo ottenendo degli errori sui file duplicati nel progetto.

Ora funziona, l'evento con Annotation Processors viene disattivato (ho il sospetto che debbano essere principalmente importanti per i progetti Android).

Answer 6

ho finito con la seguente soluzione (e sembra essere la più semplice di tutte le risposte inviate):

apply plugin: 'java' 
apply plugin: 'idea' 

def generatedMain = new File(buildDir, "generated/main") 

compileJava { 
    doFirst { 
     generatedMain.mkdirs() 
    } 
    options.compilerArgs += ['-s', generatedMain] 
} 
idea.module.sourceDirs += generatedMain 

dependencies { 
    compileOnly 'com.google.dagger:dagger-compiler:2.8' 
    compile 'com.google.dagger:dagger:2.8' 
}