web-dev-qa-db-fra.com

Comment configurer IntelliJ/gradle pour utiliser dagger 2.0

J'ai un projet sur les diplômes et je souhaite y utiliser le poignard 2.0. Je ne sais pas comment configurer IntelliJ et gradle pour générer des fichiers et laisser IntelliJ les trouver?

Mon fichier build.gradle ressemble à:

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

Dans le répertoire de construction de mon application, le fichier DaggerXmlConfigurationComponent existe, composant créé par Dagger. Mais je ne peux pas l'utiliser dans IntelliJ car il ne peut pas trouver la classe.

Ce n'est pas une application Android, mais une application pour le Raspberry Pi.

javagradledagger-2
26
Martijn de Munnik

Vous devez activer manuellement le traitement des annotations pour IntelliJ: dans Paramètres… → Construire, Exécution, Déploiement → Compilateur → Processeurs d'annotation, cochez la case Activer le traitement des annotations et Obtenir les processeurs du chemin de classe du projet.

14
robert_difalco

J'ai trouvé une solution.

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

De plus, si vous utilisez Intellij, une configuration suivante est recommandée:

Lorsque vous utilisez l'intégration Gradle dans IntelliJ IDEA, vous devez activer manuellement le traitement des annotations plutôt que pour la tâche d'idée: dans Paramètres… → Construire, Exécution, Déploiement → Compilateur → Processeurs d'annotation, cochez Activer les annotations. traiter et obtenir des processeurs à partir du classpath du projet. Pour imiter le comportement de Gradle et celui des fichiers générés, vous pouvez configurer les répertoires de sources de production et de test de manière à générer/généré/généré/source/apt/main et à construire/généré/source/apt/test et choisir de stocker les sources générées relatives à: Module content root. J'ai également dû supprimer Exclude du répertoire de construction complet et marquer le répertoire/source/apt/main généré comme source.

8
Abdel

Le moyen le plus simple, à ma connaissance, consiste à utiliser le plugin apt-idea

Activez simplement le plugin dans le fichier build.gradle:

plugins {
    id 'Java'
    id 'net.ltgt.apt-idea' version "0.15"
}

puis ajoutez les processeurs d'annotation à la configuration annotationProcessor:

final DAGGER_VER = '2.16'
dependencies {
    implementation "com.google.dagger:dagger:${DAGGER_VER}"
    annotationProcessor"com.google.dagger:dagger-compiler:${DAGGER_VER}"
}

J'ai créé un projet de test très simple sur GitHub: ex.dagger
(utilisant IntelliJ 2018.1.4, Gradle 4.7)

3
TmTron

Moi aussi, je ne pouvais obtenir aucun des plugins, donc, sur la base de la réponse de Stefan, j'ai fait ce qui suit, mais IntelliJ semble créer des modules de groupe, ce qui n'était pas le cas auparavant. Soyez formidable si quelqu'un a la moindre idée de ce qui le cause, j'aimerais vraiment que cela soit réparé.

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}"
}
2
John Howard

J'ai fini avec la solution suivante (et il semble que ce soit la plus simple parmi toutes les réponses envoyées):

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'
}
2
Tomasz Gawel

Dans mon cas, le problème était IDEA de créer un module distinct pour les fichiers générés par le poignard. Je devais aller à File -> Project Structure -> Modules et supprimer le module projectname_dagger (en cliquant sur le moins rouge), puis ajouter le dossier source généré à mon module projectname_main en cliquant sur Add Content Root et en le sélectionnant.

Pour une raison quelconque, je devais supprimer les fichiers de Dagger et laisser IDEA les régénérer, car je rencontrais des erreurs concernant les fichiers en double dans le projet.

Maintenant, cela fonctionne, les événements avec les processeurs d'annotation étant désactivés (je suppose qu'ils doivent être principalement importants pour les projets Android).

1
Gregor Petrin

J'ai eu des problèmes avec les plugins existings, alors j'ai ajouté ceci à mon 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 <<
1
Stefan K.

Depuis la version 0.11 de net.ltgt.apt (février 2018), vous pouvez simplement appliquer le plugin net.ltgt.apt-idea à 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"
}
0
Malt