Wie Konfiguriere ich IntelliJ/gradle verwenden Dolch 2.0

Habe ich ein gradle-Projekt und ich will den Dolch 2.0 in der it. Ich weiß nicht, wie zu konfigurieren, IntelliJ und gradle zu generieren, Dateien und lassen IntelliJ finden Sie Sie?

Meine bauen.gradle-Datei sieht wie folgt aus:

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

In das build-Verzeichnis meiner Anwendung die Datei DaggerXmlConfigurationComponent vorhanden ist, die eine Komponente Dolch erstellt. Aber ich kann es nicht verwenden in IntelliJ, da es nicht die Klasse zu finden.

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

Hast du dies: stackoverflow.com/questions/20107182/... ? Vielleicht kann es helfen.
Hast du eine Lösung finden? Ich habe das gleiche Problem, die Dateien werden erzeugt und wenn ich meinen build von der cmd-Zeile, es ist in Ordnung, aber intellij denkt, es fehlt die generierten Dateien noch.

InformationsquelleAutor Martijn de Munnik | 2015-04-10

16

Müssen Sie manuell aktivieren annotation processing für IntelliJ: in den Einstellungen... → Bauen, Ausführung, Bereitstellung → Compiler → Annotation-Prozessoren, Aktivieren Sie die Option annotation processing und Erhalten-Prozessoren aus der Projekt-classpath.

InformationsquelleAutor robert_difalco
8

Ich eine Lösung gefunden habe.

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 mit Intellij die folgende Konfiguration empfohlen:

Bei Verwendung des Gradle-integration in IntelliJ IDEA aber eher als die Vorstellung, Aufgabe, müssen Sie manuell aktivieren annotation processing: in den Einstellungen... → Bauen, Ausführung, Bereitstellung → Compiler → Annotation-Prozessoren, Aktivieren Sie die Option annotation processing und Erhalten-Prozessoren aus der Projekt-classpath. Zu imitieren, die Gradle Verhalten und die generierten Dateien Verhalten, können Sie den Produktions-und test-Quellen, Verzeichnisse zu erstellen/generated/source/apt/main und bauen/generated/source/apt/test beziehungsweise, und wählen Sie zum Speichern von generierten Quellen relativ zu: Modul Inhalt root.
Ich habe auch zu entfernen, Ausschließen von ganzen build-Verzeichnis und markieren Sie generiert/source/apt/main-Verzeichnis als Quelle.
- Es hat nicht funktioniert für mich, bis ich fügte hinzu, 'Idee' - plugin. Es funktioniert auch ohne die Aktivierung Annotation-Prozessoren. apply plugin:'idea'
- +1 für den letzten Satz, beginnend mit "ich habe auch zu entfernen "habe ich auch schon entfernen, Ausschließen von ganzen build-Verzeichnis und markieren Sie generiert/source/apt/main-Verzeichnis als Quelle"
InformationsquelleAutor Abdel

Auch ich konnte nicht mit den plugins zu arbeiten, so dass basierend auf Stefan ' s Antwort habe ich die folgende, die funktioniert, aber dummerweise IntelliJ scheint die Gruppe zu schaffen-Module, die waren vorher nicht da. Groß sein, wenn wer hat eine Idee, was die Ursache für diese ich würde wirklich gerne, um dieses Problem.

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

InformationsquelleAutor John Howard

3

Der einfachste Weg, den ich kenne, ist die Verwendung der apt-Idee-plugin

Aktivieren Sie einfach das plugin in der build.gradle Datei:
```
plugins {
    id 'java'
    id 'net.ltgt.apt-idea' version "0.15"
}
```
und fügen Sie den annotation-Prozessoren der annotationProcessor Konfiguration:
```
final DAGGER_VER = '2.16'
dependencies {
    implementation "com.google.dagger:dagger:${DAGGER_VER}"
    annotationProcessor"com.google.dagger:dagger-compiler:${DAGGER_VER}"
}
```
Habe ich einen sehr einfachen test-Projekt auf GitHub: ex.Dolch

(mit IntelliJ 2018.1.4, Gradle 4.7)

InformationsquelleAutor TmTron

Beendete ich mit der folgenden Lösung (und es scheint das einfachste von alle von Ihnen gesendeten Antworten):

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

InformationsquelleAutor Tomasz Gawel

Hatte ich Probleme mit den bestehenden plugins, also ich habe Folgendes in 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 <<

InformationsquelleAutor Stefan K.

1

In meinem Fall war das problem der IDEE ist das erstellen eines separaten Modul für die Dolch-Dateien erzeugt. Ich hatte zu gehen, um File -> Project Structure -> Modules und entfernen Sie die projectname_dagger Modul (durch Klick auf das rote minus), dann fügen Sie den generierten source-Ordner auf meine projectname_main Modul, indem Sie Add Content Root und ihn auswählen.

Die aus irgendeinem Grund musste ich löschen Dolch die Dateien und lassen Sie IDEE, regenerieren Sie, weil ich immer Fehler über doppelte Dateien in das Projekt.

Jetzt funktioniert es, Ereignis mit Annotation-Prozessoren ausgeschaltet wird (ich vermute, Sie müssen vor allem wichtig sein, für Android-Projekte).

InformationsquelleAutor Gregor Petrin

Da net.ltgt.apt-version 0.11 (Februar 2018) können Sie einfach anwenden, das plugin net.ltgt.apt-idea zu build.gradle:

plugins {
    id "net.ltgt.apt-idea" version "0.18"
}

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

dependencies {
    compile             "com.google.dagger:dagger:2.17"
    annotationProcessor "com.google.dagger:dagger-compiler:2.17"
}

InformationsquelleAutor Malt

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.