हमने डिपेंडेंसी इंजेक्शन के लिए गूगल गुइस फ्रेमवर्क का इस्तेमाल किया है। मुझे जावा में एक इंटरफ़ेस के एकाधिक insatnce बनाने की जरूरत है।

निष्पादन यहां से शुरू होता है: नीचे दिए गए कोड में KfhRecordValidator.java वर्ग:

public class KfhRecordValidator implements RequestHandler<Request, Response> {
       public Response handleRequest(Request request, Context context) 
        {
     // Resolve the necessary dependencies, and process the request.
       Injector injector = Guice.createInjector(new 
                      DependencyModule());
            Processor processor = 
                 injector.getInstance(Processor.class);
              return processor.process(request, context);
}}

प्रक्रिया वर्ग में RecordValidationHelper वर्ग का संदर्भ है और इंजेक्शन कंस्ट्रक्टर के माध्यम से है। IRecordValidationService.java एक इंटरफ़ेस है जिसमें मान्य विधि है।

public interface IRecordValidationService {
              void validate(Record record) throws ValidationException;}

क्लास प्रोसेसर में एक विधि है जिसे प्रोसेस कहा जाता है जिसे RecordValidationHelper क्लास में बुलाया जा रहा है।

class Processor {
   private final RecordValidationHelper recordValidationHelper;
@Inject
@SuppressWarnings({"WeakerAccess"})
public Processor(IRecordValidationService recordValidationService, 
IRecordService<ErrorRecord> recordService,
                 S3UtilsInterface s3Utils, IEnvironmentVariableReader 
                 environmentVariableReader) {
                 this.recordValidationHelper = new 
                 RecordValidationHelper(recordValidationService);
                 this.errorRecordHelper = new 
                 ErrorRecordHelper(recordService, environmentVariableReader);
}

public Response process(Request request, @SuppressWarnings("unused") Context context) {

    // Validate records
    List<LambdaRecord> records = recordValidationHelper.processRecords(request.getRecords());}

क्लास डिपेंडेंसीमॉड्यूल.जावा ने गुइस इंजेक्शन के एब्सट्रैक्ट मॉड्यूल क्लास का विस्तार किया है जिसमें कॉन्फ़िगर विधि है।

class DependencyModule extends AbstractModule {
@Override
protected void configure() {
    String validationType = System.getenv("ValidationType");

    validationType= validationType.toLowerCase(Locale.ENGLISH);

    String valType[]= validationType.split(",");
    int length= valType.length;

    for(int i=0;i<length;i++){

        switch(valType[i]){
         case "json":
             bind(IRecordValidationService.class).to(JsonValidationService.class);
             break;
         case "avro":
             bind(IRecordValidationService.class).to(AvroSchemaValidationService.class);
             break;
         case "clientlogging":
             bind(IRecordValidationService.class).to(ClientLoggingValidationService.class);
             break;
         case "servicelogs":
             bind(IRecordValidationService.class).to(ServiceLoggingValidationService.class);
             break;
         default:
             throw new UnsupportedOperationException(String.format("Encountered an unsupported ValidationType of '%s'.", valType[i]));
        }

    } } }

तो मुद्दा यह है कि अगर मुझे AVRO, JSON के रूप में सत्यापन प्रकार मिल रहा है तो यह IRecordValidationService को संबंधित JsonValidationService/AvroSchemaValidationService क्लास से जोड़ देगा। मुझे इसके लिए एकाधिक उदाहरण बनाने की आवश्यकता है लेकिन यह एक समय में केवल एक बार उदाहरण का समर्थन करता है। नीचे RecordValidationHelper.java क्लास है

पब्लिक क्लास RecordValidationHelper AbstractModule को बढ़ाता है {निजी अंतिम IRecordValidationService RecordValidationService;

@Inject
public RecordValidationHelper(IRecordValidationService recordValidationService) {
    this.recordValidationService = recordValidationService;
}

सार्वजनिक सूची प्रक्रिया रिकॉर्ड्स (सूची अनुरोध रिकॉर्ड्स) {सूची रिकॉर्ड = नई ऐरेलिस्ट <> ();

    for (RequestRecord record : requestRecords) {
        try {

            Record domainRecord = new Record();
            domainRecord.setKey(record.getRecordId());
            domainRecord.setValue(new String(Base64.getDecoder().decode(record.getData())));

            // Use the injected logic to validate the record.
            ((IRecordValidationService) 
           recordValidationService).validate(domainRecord);}
           catch (ValidationException ex) {}}}
           return records;}

किसी को भी इस बारे में कोई विचार है कि इसके लिए उपयुक्त एकाधिक उदाहरण प्राप्त करने के लिए इसे कैसे कार्यान्वित किया जाना चाहिए।

2
Mohit Mathuriya 29 अक्टूबर 2018, 11:48

1 उत्तर

सबसे बढ़िया उत्तर

@Named बाइंडिंग का प्रयोग करें

अपने DependencyModule में, नामों का उपयोग करके आबद्ध करें:

bind(IRecordValidationService.class)
  .annotatedWith(Names.named("json"))
  .to(JsonValidationService.class);
bind(IRecordValidationService.class)
  .annotatedWith(Names.named("avro"))
  .to(AvroSchemaValidationService.class);
bind(IRecordValidationService.class)
  .annotatedWith(Names.named("clientlogging"))
  .to(ClientLoggingValidationService.class);
bind(IRecordValidationService.class)
  .annotatedWith(Names.named("servicelogs"))
  .to(ServiceLoggingValidationService.class);

फिर अपने इंजेक्शन में:

@Inject
public RecordValidationHelper(
    @Named("json") IRecordValidationService jsonValidation,
    @Named("avro") IRecordValidationService avroValidation,
    @Named("clientlogging") IRecordValidationService clientLoggingValidation,
    @Named("servicelogs") IRecordValidationService serviceLogsValidation,
  ) {
    this.jsonValidation = jsonValidation;
    this.avroValidation = avroValidation;
    this.clientLoggingValidation = clientLoggingValidation;
    this.serviceLogsValidation = serviceLogsValidation;
}

अधिक जानकारी के लिए Guice's BindingAnnotation wiki पेज देखें।

2
Olivier Grégoire 29 अक्टूबर 2018, 11:12