Custom-Autowire-candidate Bohnen im Frühjahr 3

Sagen, ich habe die folgende Struktur mit einem service-Schnittstelle ServiceInterface und ein paar Komponenten zur Umsetzung: ProductAService und ProductBService ich habe auch ein RequestContext bean, hat eine qualifizierende Eigenschaft, die sagt, dass wir sagen, dass derzeit die Bearbeitung von ProductA oder ProductB. Wie kann dann automatisch Spritzen mit autowiring oder andere annotation der korrekten Umsetzung (ProductAService oder ProductBService) in einigen service, der es benötigt (ServiceThatNeedsServiceInterface unten).

public interface ServiceInterface {
  void someMethod();
}

@Component(name="ProductAService")
public class ProductAService implements ServiceInterface {
  @Override public void someMethod() { 
    System.out.println("Hello, A Service"); 
  }
}

@Component(name="ProductBService")
public class ProductBService implements ServiceInterface {
  @Override public void someMethod() { 
    System.out.println("Hello, B Service"); 
  }
}

@Component
public class ServiceThatNeedsServiceInterface {

  //What to do here???
  @Autowired
  ServiceInterface service;

  public void useService() {
    service.someMethod();
  }
}

@Component
@Scope( value = WebApplicationContext.SCOPE_REQUEST )
public class RequestContext {
  String getSomeQualifierProperty();
}
InformationsquelleAutor Strelok | 2013-02-21
  1. 11

    Quelle beziehen Ihr Problem, wenn Sie erstellt die ServiceLocatorFactoryBean zurück in der version 1.1.4. Um es zu verwenden benötigen Sie eine Schnittstelle, die ähnlich wie die folgenden:

    public interface ServiceLocator {
    //ServiceInterface service name is the one 
      //set by @Component
    public ServiceInterface lookup(String serviceName);
}

    Müssen Sie den folgenden Abschnitt in Ihre applicationContext.xml

    <bean id="serviceLocatorFactoryBean"
    class="org.springframework.beans.factory.config.ServiceLocatorFactoryBean">
    <property name="serviceLocatorInterface"
              value="org.haim.springframwork.stackoverflow.ServiceLocator" />
</bean>

    Nun Ihre ServiceThatNeedsServiceInterface sieht ähnlich dem folgenden:

    @Component
public class ServiceThatNeedsServiceInterface {
    //What to do here???
    // @Autowired
    // ServiceInterface service;

    /*
     * ServiceLocator lookup returns the desired implementation
     * (ProductAService or ProductBService) 
     */ 
 @Autowired
     private ServiceLocator serviceLocatorFactoryBean;

     //Let’s assume we got this from the web request 
     public RequestContext context;

     public void useService() {
        ServiceInterface service =  
        serviceLocatorFactoryBean.lookup(context.getQualifier());
        service.someMethod();         
      }
}

    ServiceLocatorFactoryBean zurückkehren wird der gewünschte Dienst auf der Grundlage der RequestContext qualifier.
    Neben spring-Annotationen Ihr code ist nicht angewiesen auf den Frühling.
    Ich ausgeführt die folgenden unit-test für die oben genannten

    @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:META-INF/spring/applicationContext.xml" })
public class ServiceThatNeedsServiceInterfaceTest {

    @Autowired
    ServiceThatNeedsServiceInterface serviceThatNeedsServiceInterface;

    @Test
    public void testUseService() {
    //As we are not running from a web container
    //so we set the context directly to the service 
        RequestContext context = new RequestContext();
        context.setQualifier("ProductAService");
        serviceThatNeedsServiceInterface.context = context;
        serviceThatNeedsServiceInterface.useService();

        context.setQualifier("ProductBService");
        serviceThatNeedsServiceInterface.context = context;
        serviceThatNeedsServiceInterface.useService();
    }

}

    In der Konsole-Anzeige

    Hallo, Ein Service

    Hallo, B-Dienst

    Ein Wort der Warnung. In der API-Dokumentation besagt, dass

    "Solche service-Locator-Punkte ... wird in der Regel verwendet werden, für die Prototyp-Bohnen, d.h. für die Fabrik-Methoden zurückgeben sollte, eine neue Instanz für jeden Aufruf... Für singleton-beans, direkte setter-oder constructor-injection der Ziel-bean vorzuziehen ist."

    Kann ich nicht verstehen, warum dies ein Problem verursachen können. In meinem code gibt es den gleichen service auf zwei Sequenz-Aufrufe serviceThatNeedsServiceInterface.useService();

    Finden Sie die Quelle code für mein Beispiel in GitHub

    • Bingo! Dies ist die richtige Antwort. Ich glaube nicht daran, dass das winzige bit der XML-config.
    InformationsquelleAutor Haim Raman
  2. 3

    Der einzige Weg, ich kann denken, etwas zu tun, wie das, was Sie suchen, um etwas zu schaffen wie eine FactoryBean dass die Rendite der entsprechenden Umsetzung auf der Grundlage der RequestContext Eigenschaft. Hier ist etwas, ich schlug zusammen, dass das Verhalten, das Sie wollen:

    import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.context.WebApplicationContext;

import javax.servlet.http.HttpServletRequest;

public class InjectionQualifiedByProperty {

    @Controller
    @Scope(WebApplicationContext.SCOPE_REQUEST)
    public static class DynamicallyInjectedController {
        @Autowired
        @Qualifier("picker")
        Dependency dependency;

        @RequestMapping(value = "/sayHi", method = RequestMethod.GET)
        @ResponseBody
        public String sayHi() {
            return dependency.sayHi();
        }
    }

    public interface Dependency {
        String sayHi();
    }

    @Configuration
    public static class Beans {
        @Bean
        @Scope(WebApplicationContext.SCOPE_REQUEST)
        @Qualifier("picker")
        FactoryBean<Dependency> dependencyPicker(final RequestContext requestContext,
                                                 final BobDependency bob, final FredDependency fred) {
            return new FactoryBean<Dependency>() {
                @Override
                public Dependency getObject() throws Exception {
                    if ("bob".equals(requestContext.getQualifierProperty())) {
                        return bob;
                    } else {
                        return fred;
                    }
                }

                @Override
                public Class<?> getObjectType() {
                    return Dependency.class;
                }

                @Override
                public boolean isSingleton() {
                    return false;
                }
            };
        }
    }

    @Component
    public static class BobDependency implements Dependency {
        @Override
        public String sayHi() {
            return "Hi, I'm Bob";
        }
    }

    @Component
    public static class FredDependency implements Dependency {
        @Override
        public String sayHi() {
            return "I'm not Bob";
        }
    }

    @Component
    @Scope(WebApplicationContext.SCOPE_REQUEST)
    public static class RequestContext {
        @Autowired HttpServletRequest request;

        String getQualifierProperty() {
            return request.getParameter("which");
        }
    }
}

    Habe ich ein funktionierendes Beispiel für die Verwendung dieser code auf Github. Sie können Klonen und starten Sie es mit:

    git clone git://github.com/zzantozz/testbed tmp
cd tmp/spring-mvc
mvn jetty:run

    Dann besuchen Sie http://localhost:8080/dynamicallyInjected zu sehen, die Ergebnis einer Abhängigkeit, und http://localhost:8080/dynamicallyInjected?which=bob andere zu sehen.

    InformationsquelleAutor Ryan Stewart
  3. 1

    Ich denke mal, dass Sie es vermisst habe, die Anmerkung, die sagt spring, dass Sie einen benutzerdefinierten Dienst.
    Also deine Lösung ist, fügen Sie diese Anmerkungen, bevor Sie die Klasse name:

    @Service("ProductAService")
public class ProductAService implements ServiceInterface {
  @Override public void someMethod() { 
    System.out.println("Hello, A Service"); 
  }
}

@Service("ProductBService")
public class ProductBService implements ServiceInterface {
  @Override public void someMethod() { 
    System.out.println("Hello, B Service"); 
  }
}

    Und dann kann man auto-Draht, aber um den spezifischen service, den Sie hinzufügen müssen, um die annotation Qualifier() wie folgt: 

      @Autowired
  @Qualifier("ProductBService") //or ProductAService
  ServiceInterface service;

    Oder haben Sie vielleicht hinzufügen, nur eine Anmerkung-Qualifizierer("name eures bean") 🙂

    • Ich weiß, ich kann dies tun, aber ich würde zu haben, um all die verschiedenen Dienstleistungen, die als separate Felder in der Klasse, der es verwendet. Ich möchte die Immobilie im RequestContext die Entscheidung Faktor, der das "Produkt" Umsetzung zu injizieren, wenn autowiring.
    InformationsquelleAutor PAcan
  4. 1

    Diese kann Ihnen helfen:

    Verwenden 

    AutowireCapeableBeanFactory.autowireBean(Object existingBean)

    ODER 

    AutowireCapeableBeanFactory.autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)

    AutowireCapeableBeanFactory.autowireBean(Objekt existingBean)
    AutowireCapeableBeanFactory.autowireBeanProperties(Objekt existingBean, int autowireMode, boolean dependencyCheck)

    InformationsquelleAutor mukund
  5. 0

    Ich glaube nicht, können Sie dies mit der Anmerkung, der Grund ist, müssen Sie eine Bohne, die dynamisch zur Laufzeit(vielleicht Ein Dienst oder B service), also @Autowire wird verkabelt sein, bevor die bean in jedem Ort. Eine Lösung ist, kommen Bohnen aus dem Kontext, wenn Sie Sie brauchen. 

        @Component
public class ServiceThatNeedsServiceInterface {


  ServiceInterface service;

  public void useService() {
     if(something is something){
        service = applicationContext.getBean("Abean", ServiceInterface.class);
     }else{
        service = applicationContext.getBean("Bbean", ServiceInterface.class);
     }
    service.someMethod();
  }
}

    Sie können setzen else Logik irgendwo in der Klasse als seperate Funktion:

    public void useService() {
        service = findService();
        service.someMethod();
      }

public ServiceInterface findService() {
         if(something is something){
            return applicationContext.getBean("Abean", ServiceInterface.class);
         }else{
            return applicationContext.getBean("Bbean", ServiceInterface.class);
         }

      }

    Dies ist die Dynamik und das könnte das sein, was Sie wollen.

    InformationsquelleAutor Elbek
  6. 0

    Könnten Sie die @Qualifier annotation in Kombination mit Aliase. Sehen Sie ein Beispiel, wie es verwendet wird, laden Sie eine bean-basierend auf einer Eigenschaft hier. Sie ändern könnte, dieser Ansatz und ändern Sie die Eigenschaft/alias in der requestcontext...

    InformationsquelleAutor wrm
Schreibe einen Kommentar