में मल्टी-मॉड्यूल एनोटेशन प्रोसेसिंग मेरे पास एंड्रॉइड स्टूडियो में एकाधिक मॉड्यूल के साथ एक प्रोजेक्ट है। > मॉड्यूल FeatureOne - -> मॉड्यूल सेवाएंएंड्रॉइड स्टूडियो
मैं जड़ मॉड्यूल में मेरी टिप्पणी के प्रसंस्करण को शामिल किया है लेकिन एंड्रॉयड-उपयुक्त एनोटेशन प्रसंस्करण होता है
मॉड्यूल PhoneApp: एक मॉड्यूल उदाहरण के लिए, एक और मॉड्यूल पर निर्भरता हो सकता है केवल शीर्षतम स्तर (फोन ऐप) पर, ताकि सैद्धांतिक रूप से संकलन समय पर सभी मॉड्यूल तक पहुंच हो। हालांकि, जेनरेट की गई जावा फाइल में जो कुछ मैं देख रहा हूं वह केवल फोन ऐप में एनोटेटेड कक्षाओं और अन्य मॉड्यूल से कोई नहीं है।
PhoneApp/build/generated/source/apt/debug/.../GeneratedClass.java
अन्य मॉड्यूल में, मैं मध्यवर्ती निर्देशिका कि कि मॉड्यूल से केवल टिप्पणी सहित फ़ाइलें हैं में एक उत्पन्न फ़ाइल लग रहा है।
FeatureOne/build/intermediates/classes/debug/.../GeneratedClass.class
FeatureOne/build/intermediates/classes/debug/.../GeneratedClass.java
मेरा लक्ष्य है कि मुझे सभी मॉड्यूल से एनोटेट फ़ाइलों तक पहुँचने के लिए अनुमति देता PhoneApp में एक भी उत्पन्न फ़ाइल है। पूरी तरह से सुनिश्चित नहीं है कि प्रत्येक के लिए कोड जनरेशन प्रक्रिया क्यों चल रही है और फ़ोन ऐप पर सभी एनोटेशन को एकत्र करने में विफल रही है। किसी भी मदद की सराहना की।
कोड काफी सरल है और सीधे आगे अब तक, checkIsValid() लोप इसे सही ढंग से काम करता है के रूप में:
एनोटेशन प्रोसेसर:
@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
try {
for (Element annotatedElement : roundEnv.getElementsAnnotatedWith(GuiceModule.class)) {
if (checkIsValid(annotatedElement)) {
AnnotatedClass annotatedClass = new AnnotatedClass((TypeElement) annotatedElement);
if (!annotatedClasses.containsKey(annotatedClass.getSimpleTypeName())) {
annotatedClasses.put(annotatedClass.getSimpleTypeName(), annotatedClass);
}
}
}
if (roundEnv.processingOver()) {
generateCode();
}
} catch (ProcessingException e) {
error(e.getElement(), e.getMessage());
} catch (IOException e) {
error(null, e.getMessage());
}
return true;
}
private void generateCode() throws IOException {
PackageElement packageElement = elementUtils.getPackageElement(getClass().getPackage().getName());
String packageName = packageElement.isUnnamed() ? null : packageElement.getQualifiedName().toString();
ClassName moduleClass = ClassName.get("com.google.inject", "Module");
ClassName contextClass = ClassName.get("android.content", "Context");
TypeName arrayOfModules = ArrayTypeName.of(moduleClass);
MethodSpec.Builder methodBuilder = MethodSpec.methodBuilder("juice")
.addParameter(contextClass, "context")
.addModifiers(Modifier.PUBLIC, Modifier.STATIC)
.returns(arrayOfModules);
methodBuilder.addStatement("$T<$T> collection = new $T<>()", List.class, moduleClass, ArrayList.class);
for (String key : annotatedClasses.keySet()) {
AnnotatedClass annotatedClass = annotatedClasses.get(key);
ClassName className = ClassName.get(annotatedClass.getElement().getEnclosingElement().toString(),
annotatedClass.getElement().getSimpleName().toString());
if (annotatedClass.isContextRequired()) {
methodBuilder.addStatement("collection.add(new $T(context))", className);
} else {
methodBuilder.addStatement("collection.add(new $T())", className);
}
}
methodBuilder.addStatement("return collection.toArray(new $T[collection.size()])", moduleClass);
TypeSpec classTypeSpec = TypeSpec.classBuilder("FreshlySqueezed")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(methodBuilder.build())
.build();
JavaFile.builder(packageName, classTypeSpec)
.build()
.writeTo(filer);
}
यह सिर्फ एनोटेशन प्रसंस्करण का एक डेमो है कि Guice के साथ काम करता के लिए है , अगर कोई उत्सुक है।
तो मैं सभी एनोटेटेड कक्षाओं को सभी मॉड्यूल से उत्पन्न फ़ोन ऐप .java फ़ाइल में शामिल करने के लिए कैसे प्राप्त कर सकता हूं?
यह एक अच्छा सवाल है।मुझे लगता है कि जब भी आप इसे पाते हैं तो अपना समाधान साझा करते हैं तो बहुत से लोग सराहना करेंगे, मैंने अभी तक नहीं किया है। [डीबीएफएलओ परियोजना मुद्दों अनुभाग] (https://github.com/Raizlabs/DBFlow/issues/266) में प्रोसेसर प्रतिबंधों के बारे में एक चर्चा है, जिसे एक प्रमाण के रूप में माना जा सकता है कि वांछित क्रॉस- मॉड्यूल एनोटेशन प्रोसेसर। – konata
चूंकि एनोटेशन प्रोसेसर अलग-अलग मॉड्यूल के लिए अलग-अलग चलता है, इसलिए आप वृद्धिशील दृष्टिकोण को आजमा सकते हैं, लेकिन यह आपके मामले पर थोड़ा निर्भर करता है। यदि आप अगले मॉड्यूल को संसाधित करने के बाद पूरी कक्षा को बदलने की जरूरत नहीं है, तो यह काम कर सकता है, लेकिन मौजूदा वर्ग में केवल नई लाइनें जोड़ें: 1. पहली मॉड्यूल को प्रोसेस करते समय, निर्दिष्ट स्थान पर अपनी कक्षा उत्पन्न करें (कहीं PhonApp मॉड्यूल के ** उत्पन्न ** पेड़); 2. अगले मॉड्यूल को संसाधित करते समय, जांचें कि जेनरेट क्लास मौजूद है या नहीं और इसमें नया कोड जोड़ें। – konata
चूंकि यह एक प्रेजेंटेशन में सिर्फ एक डेमो था, इसलिए मैंने समाधान की तलाश जारी नहीं रखी। (विचार किया गया कि सवाल उठता है कि जेनरेट की गई फाइल में सभी मॉड्यूल डेटा क्यों शामिल नहीं किए गए थे) मैंने प्रत्येक मॉड्यूल से जेनरेट की गई फ़ाइलों की प्रतिलिपि बनाने के लिए ग्रैडल कार्यों का उपयोग करने पर विचार किया था, लेकिन ऐसे समाधान को पसंद करेंगे जिन्हें बिल्ड टूल्स पर भरोसा करने की आवश्यकता नहीं होगी । – fakataha