Question

在我正在开发的基于Spring的项目中，有一层用于调用Web服务的功能。对于每个Web服务操作，创建具有几乎相同代码但具有一些不同的特定于操作的信息（例如，服务名称，操作名称，命名空间等）的方法。

我用接口和带注释的方法替换这个层。例如，下面的代码是为web服务（“foo”）的操作“fetchBar”提供的。

package a.b.c.webservices;

@WebService(service="foo", namespace="...")
public interface FooWebService {

    @WebServiceOperation(operation="fetchBar")
    BarRespons fetchBar(BarRequest request) throws WebServiceException;
}

现在我想，通过一些机制，spring允许我从一些指定的包创建动态代理bean，我可以使用以下代码来调用Web服务。

package a.b.c.business;

import a.b.c.webservices.FooWebService;

public class FooBusiness {

    @Autowired 
    FooWebService fooWebService;


    public Bar getBar() {

        Bar bar = null;            

        BarRequest request; 

        //create request
        BarResponse response = fooWebService.fetchBar(request);
        //extrac bar from response

        return bar;
    }
}

为了实现这一点，我使用java.lang.reflect.Proxy.newProxyInstance创建了动态bean实例，为其提供了InvocationHandler的实现。但是，自动装配在提供的invocationHandler实现及其进一步的依赖性中不起作用。

我尝试了以下方法来实现这一目标。

使用BeanFactoryPostProcessor.postProcessBeanFactory方法实现了ConfigurableListableBeanFactory.registerSingleton和已注册的bean。
已实现ImportBeanDefinitionRegistrar.registerBeanDefinitions并尝试使用BeanDefinitionRegistry.registerBeanDefinition但我很困惑如何提供支持自动装配的正确Bean定义。

任何人都可以告诉我缺少什么吗？如果我没有朝着正确的方向前进，请引导我。

Answer 1

以下是我如何实现创建＆＃39; WebService＆＃39;的bean的所有功能。带注释的接口，还支持代理实现中的自动装配。（以下代码中省略了包声明和import语句）首先，我创建了WebService和WebServiceOperation注释。

WebService注释

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface WebService {
    String service();
    String namespace();
}

WebService操作注释

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface WebServiceOperation {
    String operation();
}

下一步是从指定的包中扫描所有WebService带注释的接口。 Spring为包扫描提供ClassPathScanningCandidateComponentProvider，但它不检测接口。有关详细信息，请参阅this question和it's answer。因此，我延长了ClassPathScanningCandidateComponentProvider并覆盖了isCandidateComponent方法。

<强> ClassPathScanner

public class ClassPathScanner extends ClassPathScanningCandidateComponentProvider {

    public ClassPathScanner(final boolean useDefaultFilters) {
        super(useDefaultFilters);
    }

    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isIndependent();
    }

}

此时我创建了EnableWebServices注释以启用Web服务并提供包含WebService带注释的接口的Web服务包。

启用Web服务注释

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import({
    WebServiceProxyConfig.class, 
    WebServiceProxyBeansRegistrar.class
})

public @interface EnableWebServices {

    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

}

此注释可应用于某些带注释接口的Configuration带注释的类，如下所示。

@EnableWebServices({
    "a.b.c.webservices",
    "x.y.z.webservices"
})

现在是时候考虑动态代理创建，它将根据WebService和WebServiceOperation注释中提供的信息调用实际的Web服务。 Java提供了一种创建动态代理的机制，它需要提供InvocationHandler接口的实现并在其invoke方法中提供逻辑。我将此实现命名为WebServiceProxy

假设一个类型为#WebServiceCaller＆＃39;的bean。包含调用Web服务的所有讨厌逻辑。我只是注入它并使用call（从TheWebServiceInfo和WebService注释中提取）和请求对象调用它的WebServiceOperation方法。

TheWebServiceInfo（假设所有字段都有getter和setter）

public class TheWebServiceInfo {
    private String service;
    private String namespace;
    private String operation;
}

<强> WebServiceProxy

public class WebServiceProxy implements InvocationHandler {

    @Autowired
    private TheWebServiceCaller caller;

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Exception {

        Object request = (null != args && args.length > 0) ? args[0] : null;

        WebService webService = method.getDeclaringClass().getAnnotation(WebService.class);
        WebServiceOperation webServiceOperation = method.getAnnotation(WebServiceOperation.class);

        TheWebServiceInfo theInfo = createTheWebServiceInfo(webService, webServiceOperation);

        return caller.call(theInfo, request);
    }

    private TheWebServiceInfo createTheWebServiceInfo(WebService webService, WebServiceOperation webServiceOperation) {
        TheWebServiceInfo theInfo = new TheWebServiceInfo();
        theInfo.setService(webService.service());
        theInfo.setNamespace(webService.namespace());
        theInfo.setOperation(webServiceOperation.operation());
        return theInfo;
    }
}

将InvocationHandler的实现传递给Proxy.newProxyInstance（以及其他一些信息）以创建代理对象。我需要为每个WebService带注释的接口分离代理对象。我现在将创建一个代理实例创建工厂，名称为＆＃39; WebServiceProxyBeanFactory＆＃39;。此工厂创建的实例将成为相应的WebService带注释的接口的bean。

稍后，我将公开＆＃39; WebServiceProxy＆＃39;和WebServiceProxyBeanFactory作为豆子。在＆＃39; WebServiceProxyBeanFactory＆＃39;中，我将注入WebServiceProxy并使用它。请注意createWebServiceProxyBean使用泛型。这很重要。

<强> WebServiceProxyBeanFactory

public class WebServiceProxyBeanFactory {

    @Autowired 
    WebServiceProxy webServiceProxy;

    @SuppressWarnings("unchecked")
    public <WS> WS createWebServiceProxyBean(ClassLoader classLoader, Class<WS> clazz) {
        return (WS) Proxy.newProxyInstance(classLoader, new Class[] {clazz}, webServiceProxy);
    }

}

如果你还记得，早些时候我在WebServiceProxyConfig注释中导入了EnableWebServices。 WebServiceProxyConfig用于将WebServiceProxy和WebServiceProxyBeanFactory公开为bean。

<强> WebServiceProxyConfig

@Configuration
public class WebServiceProxyConfig {

    @Bean
    public WebServiceProxy webServiceProxy() {
        return new WebServiceProxy();
    }

    @Bean(name = "webServiceProxyBeanFactory")
    public WebServiceProxyBeanFactory webServiceProxyBeanFactory() {
        return new WebServiceProxyBeanFactory();
    }

}

现在一切都已到位。是时候编写一个钩子来开始扫描Web服务包并将动态代理注册为bean。我将提供ImportBeanDefinitionRegistrar。

的实施

<强> WebServiceProxyBeansRegistrar

@Configuration
public class WebServiceProxyBeansRegistrar implements ImportBeanDefinitionRegistrar, BeanClassLoaderAware {

    private ClassPathScanner classpathScanner;
    private ClassLoader classLoader;

    public WebServiceProxyBeansRegistrar() {
        classpathScanner = new ClassPathScanner(false);
        classpathScanner.addIncludeFilter(new AnnotationTypeFilter(WebService.class));
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        this.classLoader = classLoader;
    }

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        String[] basePackages = getBasePackages(importingClassMetadata);
        if (ArrayUtils.isNotEmpty(basePackages)) {
            for (String basePackage : basePackages) {
                createWebServicProxies(basePackage, registry);
            }
        }
    }

    private String[] getBasePackages(AnnotationMetadata importingClassMetadata) {

        String[] basePackages = null;

        MultiValueMap<String, Object> allAnnotationAttributes = 
            importingClassMetadata.getAllAnnotationAttributes(EnableWebServices.class.getName());

        if (MapUtils.isNotEmpty(allAnnotationAttributes)) {
            basePackages = (String[]) allAnnotationAttributes.getFirst("basePackages");
        }

        return basePackages;
    }

    private void createWebServicProxies(String basePackage, BeanDefinitionRegistry registry) {
        try {

            for (BeanDefinition beanDefinition : classpathScanner.findCandidateComponents(basePackage)) {

                Class<?> clazz = Class.forName(beanDefinition.getBeanClassName());

                WebService webService = clazz.getAnnotation(WebService.class);

                String beanName = StringUtils.isNotEmpty(webService.bean())
                    ? webService.bean() : ClassUtils.getShortNameAsProperty(clazz);

                GenericBeanDefinition proxyBeanDefinition = new GenericBeanDefinition();
                proxyBeanDefinition.setBeanClass(clazz);

                ConstructorArgumentValues args = new ConstructorArgumentValues();

                args.addGenericArgumentValue(classLoader);
                args.addGenericArgumentValue(clazz);
                proxyBeanDefinition.setConstructorArgumentValues(args);

                proxyBeanDefinition.setFactoryBeanName("webServiceProxyBeanFactory");
                proxyBeanDefinition.setFactoryMethodName("createWebServiceProxyBean");

                registry.registerBeanDefinition(beanName, proxyBeanDefinition);

            }
        } catch (Exception e) {
            System.out.println("Exception while createing proxy");
            e.printStackTrace();
        }

    }

}

在本课程中，我提取了EnableWebServices注释中提供的所有包。对于每个提取的包，我使用ClassPathScanner进行扫描。（这里可以优化逻辑以仅过滤WebService带注释的接口）。对于每个检测到的接口，我已经注册了bean定义。请注意我使用了webServiceProxyBeanFactory并使用classLoader和接口类型调用了它的createWebServiceProxyBean。这个工厂方法，在春天之后调用时，将返回与接口类型相同的bean，因此注册了具有正确类型的bean。可以使用接口类型将此bean注入任何位置。而且，WebServiceProxy可以注入并使用任何其他bean。因此，自动装配也将按预期工作。

Answer 2

我在考虑同样的问题，但是环境要轻一些。我不需要动态加载所有Web服务客户端。因此，我改为使用FactoryBean，并在该工厂bean中构造了动态代理。这是自动装配服务的一个示例：

public class CurrencyServiceWithDynamicProxy extends AbstractFactoryBean<CurrencyService> {

    ServiceClientConfiguration clientConfiguration;

    Object proxy;

    @Autowired
    public CurrencySyncFactoryDynamicProxy(ServiceClientConfigurationProvider serviceClientConfigurationProvider) {
        this.clientConfiguration = serviceClientConfigurationProvider.createClientConfig("currency");
        proxy = Proxy.newProxyInstance(getClass().getClassLoader(), new Class<?>[] { getObjectType() }, new MyInvocationHandler());
    }

    @Override
    public Class<CurrencySync> getObjectType() {
        // TODO Auto-generated method stub
        return CurrencyService.class;
    }

    @Override
    public CurrencySync createInstance() throws Exception {
          // do some creational logic
         return (CurrencySync)proxy;
    }

    public CurrencySync createService() {
        JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
        factory.setServiceClass(getObjectType());
        factory.getFeatures().add(som features);

        return getObjectType().cast(factory.create());
    }   
}

关于已接受的答案，此工厂示例可以轻松扩展为更具动态性的版本。

Answer 3

你的InvocationHandler是一个bean吗？您应该将其创建为bean，而不仅仅是一个简单的对象来获得自动工作

具有自动装配功能的动态代理Bean

3 个答案: