Wie konfiguriere ich IntelliJ/Gradle, um dagger 2.0 zu verwenden

Question

Ich habe ein Großprojekt und ich möchte Dolch 2.0 darin verwenden. Ich kann IntelliJ und Gradle nicht konfigurieren, um Dateien zu generieren und IntelliJ sie finden zu lassen?

Meine build.gradle Datei wie folgt aussieht:

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' 
} 

Im Build-Verzeichnis meiner Anwendung die Datei DaggerXmlConfigurationComponent vorhanden ist, die eine Komponente Dagger ist erstellt. Aber ich kann es nicht in IntelliJ verwenden, weil es die Klasse nicht finden kann.

Dies ist keine Android-Anwendung, sondern eine Anwendung für den Raspberry Pi.

Answer 1

Sie müssen die Annotationsverarbeitung für IntelliJ manuell aktivieren: Aktivieren Sie unter Einstellungen ... → Erstellen, Ausführung, Implementierung → Compiler → Annotationsprozessoren die Option Annotationsverarbeitung aktivieren und Prozessoren aus dem Projektklassenpfad abrufen.

Answer 2

Ich habe eine Lösung gefunden.

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' 
} 

Zusätzlich, wenn Sie Intellij verwenden eine folgende Konfiguration empfohlen:

Wenn die Integration Gradle Verwendung jedoch in IntelliJ IDEA, anstatt die Idee Aufgabe, müssen Sie manuell müssen Annotationsverarbeitung aktivieren: Aktivieren Sie unter Einstellungen ... → Build, Ausführung, Deployment → Compiler → Annotation Processors die Option Annotationsverarbeitung aktivieren und Prozessoren aus dem Projektklassenpfad beziehen. Um das Gradle-Verhalten und das generierte Dateiverhalten nachzuahmen, können Sie die Produktions- und Testquellenverzeichnisse für Build/Generated/Source/Apt/Main bzw. build/generated/source/apt/test konfigurieren und Generierte Quellen relativ zu speichern: Modul Inhaltsstamm Ich musste auch Ausschließen aus dem gesamten Erstellungsverzeichnis entfernen und das generierte/source/apt/main-Verzeichnis als Quelle markieren.

Answer 3

Ich hatte Probleme mit den existings Plugins, so fügte ich folgendes meine 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

Auch ich konnte keine der Plugins zu arbeiten, so basierend auf Stefan Antwort habe ich die folgende Das funktioniert, aber ärgerlich scheint IntelliJ Gruppenmodule zu erstellen, die vorher nicht da waren. Sei toll, wenn jemand eine Idee hat, was das verursacht, würde ich das wirklich gerne reparieren lassen.

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

In meinem Fall war das Problem, dass IDEA ein separates Modul für die daggergenerierten Dateien erstellt. Ich musste File -> Project Structure -> Modules gehen und das Modul projectname_dagger entfernen (indem ich auf das rote Minuszeichen klicke), dann den generierten Quellenordner zu meinem projectname_main Modul hinzufügen, indem ich auf Add Content Root klicke und ihn auswähle.

Aus irgendeinem Grund musste ich die Dateien von Dagger löschen und IDEA neu generieren lassen, weil ich Fehler über doppelte Dateien im Projekt bekam.

Jetzt funktioniert es, Ereignis mit Annotation Processors wird ausgeschaltet (ich vermute, dass sie hauptsächlich wichtig für Android-Projekte sein müssen).

Answer 6

ich mit folgenden Lösung fertig (und es scheint die einfachste von allen gesendeten Antworten zu sein):

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' 
}