Spring: Delega a un wrapper proxy personalizzato per l'iniezione dell'interfaccia

Question

In un'applicazione legacy molto grande, ho interfacce e classi che fanno non implementare tali interfacce.

Le interfacce vengono generate in base alla classe in modo che le firme siano uguali (tranne che l'interfaccia aggiunge un'altra eccezione in alto) ei nomi sono simili (quindi è facile trovare il nome della classe dal nome dell'interfaccia).

Per ottenere un'implementazione dell'interfaccia, eseguiamo una serie di chiamate di elaborazione e registrazione, ma fondamentalmente utilizziamo java.lang.reflect.Proxy per delegare alla classe. Semplificata sembra che questo:

// This will create a proxy and invoke handler that calls HelloWorld.doSomething 
HelloWorldInterface i = MyProxyUtil.getInstance(HelloWorldInterface.class); 
i.doSomething(); 

public interface HelloWorldInterface { 
    public void doSomething() throws Exception; 
} 

public class HelloWorld { 
    public void doSomething() { 
    //something 
    } 
} 

E 'possibile con l'elaborazione di primavera annotazione, genericamente @Autowire tutti i campi di tipo *Interface e usufruire primavera MyProxyUtil.getInstance(*Interface.class) per iniettare l'attuazione?

Tale che

@Autowire HelloWorldInterface a; 

HelloWorldInterface b = MyProxyUtil.getInstance(HelloWorldInterface.class); 

@Autowire AnotherInterface c; 

AnotherInterface d = MyProxyUtil.getInstance(AnotherInterface.class); 


a == b 
c == d 

Answer 1

Sì, è necessario implementare un AutowireCandidateResolver.

Ad esempio:

public class ProxyAutowiredCandidateResolver extends SimpleAutowireCandidateResolver { 

    @Override 
    public Object getSuggestedValue(DependencyDescriptor descriptor) { 
     String dependencyClassName = descriptor.getDependencyType().getSimpleName(); 
     if (dependencyClassName.endsWith("Interface")) { 
      return MyProxyUtil.getInstance(descriptor.getDependencyType()); 
     } 

     return super.getSuggestedValue(descriptor); 
    } 

} 

si potrebbe usare un BeanFactoryPostProcessor per configurarlo nel contesto dell'applicazione:

public class AutowireCandidateResolverConfigurer implements BeanFactoryPostProcessor { 

    private AutowireCandidateResolver autowireCandidateResolver; 

    public void postProcessBeanFactory(
      ConfigurableListableBeanFactory beanFactory) throws BeansException { 
     DefaultListableBeanFactory bf = (DefaultListableBeanFactory) beanFactory; 
     bf.setAutowireCandidateResolver(autowireCandidateResolver); 


    } 

    public AutowireCandidateResolver getAutowireCandidateResolver() { 
     return autowireCandidateResolver; 
    } 

    public void setAutowireCandidateResolver(

      AutowireCandidateResolver autowireCandidateResolver) { 
     this.autowireCandidateResolver = autowireCandidateResolver; 
    } 

} 

<bean id="autowireCandidateResolverConfigurer" class="AutowireCandidateResolverConfigurer"> 
     <property name="autowireCandidateResolver"> 
      <bean class="ProxyAutowiredCandidateResolver" /> 
     </property> 
</bean> 

Answer 2

Se sto leggendo correttamente, si dovrebbe essere in grado di definirli in una classe JavaConfig @Configuration annotata e poi usarli altrove.

Dalla documentazione (Spring):

@Configuration 
public class AppConfig { 
    @Bean 
    public MyService myService() { 
     return new MyServiceImpl(); 
    } 
} 

Si potrebbe fare qualcosa di simile:

@Configuration 
public class InterfaceConfig { 
    @Bean 
    public HelloWorldInterface helloWorldInterface() { 
     return MyProxyUtil.getInstance(HelloWorldInterface.class); 
    } 
} 

A quel punto, Primavera avrebbe utilizzato tale definizione ogni volta che era necessario che Bean.

Dovresti collegare in qualche modo la classe @Configuration (scansione del percorso di classe, a livello di programmazione, ecc.), Ma dipende da come stai configurando il contesto dell'applicazione.

Penso che questo dovrebbe funzionare. Ho usato JavaConfig un bel po ', ma mai del tutto simile a questo. Ma sembra ragionevole.