मैं डैगर 2.0

Question

का उपयोग करने के लिए इंटेलिजे/ग्रेडल को कैसे कॉन्फ़िगर कर सकता हूं मेरे पास एक ग्रेडल प्रोजेक्ट है और मैं इसमें डैगर 2.0 का उपयोग करना चाहता हूं। मुझे नहीं पता कि IntelliJ को कॉन्फ़िगर कैसे करें और फ़ाइलों को उत्पन्न करने के लिए धीरे-धीरे कैसे करें और IntelliJ उन्हें ढूंढने दें?

मेरे build.gradle फ़ाइल लगता है:

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

अपने आवेदन फ़ाइल DaggerXmlConfigurationComponent मौजूद है, जो एक घटक डैगर बनाता है के निर्माण निर्देशिका में। लेकिन मैं इंटेलिजे में इसका उपयोग नहीं कर सकता क्योंकि यह कक्षा नहीं ढूंढ सकता है।

यह एंड्रॉइड एप्लिकेशन नहीं है लेकिन रास्पबेरी पीआई के लिए एक आवेदन है।

Answer 1

आपको इंटेलिजे के लिए एनोटेशन प्रोसेसिंग मैन्युअल रूप से सक्षम करना होगा: सेटिंग्स में ... → बिल्ड, निष्पादन, परिनियोजन → कंपाइलर → एनोटेशन प्रोसेसर, एनोटेशन प्रोसेसिंग सक्षम करें और प्रोजेक्ट क्लासपाथ से प्रोसेसर प्राप्त करें।

Answer 2

मुझे एक समाधान मिला है।

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

इसके अतिरिक्त

अगर आप Intellij उपयोग कर रहे हैं एक निम्नलिखित विन्यास की सिफारिश की है: मैन्युअल रूप से करने के लिए

जब तथापि IntelliJ विचार में Gradle एकीकरण का उपयोग कर, बल्कि विचार काम की तुलना में, आप होगा एनोटेशन प्रोसेसिंग सक्षम करें: सेटिंग्स में ... → बिल्ड, निष्पादन, परिनियोजन → कंपाइलर → एनोटेशन प्रोसेसर, एनोटेशन प्रोसेसिंग सक्षम करें और प्रोजेक्ट क्लासपाथ से प्रोसेसर प्राप्त करें। ग्रैडल व्यवहार और जेनरेट की गई फाइल व्यवहार की नकल करने के लिए, आप उत्पादन और परीक्षण स्रोत निर्देशिका को क्रमशः बनाने/जेनरेट/स्रोत/एपीटी/मुख्य और निर्माण/जेनरेट/स्रोत/एपीटी/परीक्षण के लिए कॉन्फ़िगर कर सकते हैं और इसके अनुरूप जेनरेट किए गए स्रोतों को स्टोर करना चुन सकते हैं: मॉड्यूल सामग्री जड़ मुझे पूरी बिल्ड निर्देशिका से बाहर निकालना और स्रोत के रूप में जेनरेट/स्रोत/एपीटी/मुख्य निर्देशिका को चिह्नित करना पड़ा है।

Answer 3

मैं existings प्लग इन के साथ समस्या नहीं थी, इसलिए मैं अपने 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

मैं भी काम करने के लिए है, तो स्टीफन की प्रतिक्रिया के आधार पर मैंने किया निम्न प्लग-इन में से किसी प्राप्त नहीं कर सका जो काम करता है, लेकिन कष्टप्रद IntelliJ समूह मॉड्यूल बनाने लगता है, जो पहले नहीं थे। बढ़िया हो अगर किसी को पता है कि इसका कारण क्या है, तो मैं वास्तव में यह तय करना चाहता हूं।

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

मेरे मामले समस्या में चाकू के लिए एक अलग मॉड्यूल बनाने विचार उत्पन्न फ़ाइलों था। मुझे File -> Project Structure -> Modules पर जाना था और projectname_dagger मॉड्यूल (लाल ऋण पर क्लिक करके) को हटा देना था, फिर मॉड्यूल पर Add Content Root पर क्लिक करके जेनरेट किया गया स्रोत फ़ोल्डर जोड़ें और इसे चुनकर।

किसी कारण से मुझे डैगर की फाइलों को हटाना पड़ा और आईडीईए को पुन: उत्पन्न करना पड़ा क्योंकि मुझे परियोजना में डुप्लिकेट फाइलों के बारे में त्रुटियां मिल रही थीं।

अब यह काम करता है, एनोटेशन प्रोसेसर बंद होने के साथ घटना (मुझे संदेह है कि उन्हें मुख्य रूप से एंड्रॉइड प्रोजेक्ट्स के लिए महत्वपूर्ण होना चाहिए)।

Answer 6

मैं निम्नलिखित समाधान के साथ समाप्त (और यह पूरी तरह से भेजे जवाब से सरल एक लगता है):

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