`

cxf和spring集成的一些事

 
阅读更多
问题：
环境：
cxf-2.1.3，jdk6，jboss7.0.2，spring3.0.6

用cxf+spring开发web service程序很简单，不过有一些集成问题要注意。在此把这几天发现的一些总结一下，最后有一个遗留的问题

1、关于bean的声明

要发布或者要调用的web service接口，需要用@WebService注解声明。不过要注意的是，@WebService注解不会把类声明为spring的bean

可以声明为bean的方式有以下4个：

<jaxws:endpoint>
<jaxws:client>
<bean id="" class="">
@Component

写了一个类来证明这一点： 

<?xml version="1.0" encoding="UTF-8"?>  
  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
                            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
                            http://www.springframework.org/schema/context   
                            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
                            http://cxf.apache.org/jaxws   
                            http://cxf.apache.org/schemas/jaxws.xsd">  
  
    <import resource="classpath:META-INF/cxf/cxf.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  
      
    <context:component-scan base-package="com.huawei.framework" />  
      
    <bean id="helloWorldImpl" class="com.huawei.framework.webservice.HelloWorldImpl">  
        <property name="remedy" ref="remedy" />  
    </bean>  
  
    <jaxws:endpoint id="helloWorld" address="/HelloWorld"  
        implementor="#helloWorldImpl" />  
  
    <jaxws:client id="remedy"  
        serviceClass="com.huawei.remedy.webservice.RemedyWebServiceCM"  
        address="http://10.78.229.199:8080/remedy/webservice/RemedyWebService" />  
  
</beans>  



protected void doGet(HttpServletRequest request,  
            HttpServletResponse response) throws ServletException, IOException {  
  
        ServletContext context = request.getServletContext();  
  
        WebApplicationContext wc = WebApplicationContextUtils  
                .getWebApplicationContext(context);  
  
        String[] beans = wc.getBeanDefinitionNames();  
  
        for (String beanName : beans) {  
            System.out.println(beanName);  
        }  
          
        RemedyWebServiceCM remedy = (RemedyWebServiceCM) wc.getBean("remedy");  
          
        AcknowledgeRequest message = new AcknowledgeRequest();  
        remedy.acknowledge(message);  
  
    }


在控制台可以看到以下几个bean：
20:02:24,120 INFO  [stdout] (http--0.0.0.0-8888-2) helloWorldImpl
20:02:24,120 INFO  [stdout] (http--0.0.0.0-8888-2) helloWorld
20:02:24,120 INFO  [stdout] (http--0.0.0.0-8888-2) remedy

以上3个bean，就分别是由<bean>、<jaxws:endpoint>、<jaxws:client>生成的

2、如果要在<jaxws:endpoint>的实现类中注入bean的话，要注意：

错误的写法： 

<jaxws:endpoint id="helloWorld" address="/HelloWorld"  
        implementor="com.huawei.framework.webservice.HelloWorldImpl" />

用这种写法，虽然HelloWorldImpl类已经被声明成bean了，但是注入是失败的

准确来说，在spring容器中存在有HelloWorldImpl对应的bean，并且相关的依赖也已经注入了。但是cxf框架得到的HelloWorldImpl，与上述的bean不是同一个对象，这个HelloWorldImpl对象可能是用反射或者其他机制创建出来的，没有任何组件被注入

正确的写法： 

<jaxws:endpoint id="helloWorld" address="/HelloWorld"  
        implementor="#helloWorldImpl" />

在implementor属性中，用#beanName，这样的话，cxf框架得到的HelloWorldImpl，就是spring容器持有的那个bean。当然这有个前提，就是系统中已经存在这个bean。用<bean id="">或者@Component都是OK的，这里支持注解

3、上面说的是<jaxws:endpoint>，比较简单。但是<jaxws:client>就比较麻烦

我目前感觉，<jaxws:client>声明的bean，没办法在别的bean里用@Autowired注入，只能用<bean id="">的方式来注入 

@WebService  
public interface RemedyWebServiceCM {  
  
    RemedyResponse acknowledge(AcknowledgeRequest arg0);  
  
    RemedyResponse close(CloseRequest arg0);  
  
    RemedyResponse notify(NotifyRequest arg0);  
  
}  



public class HelloWorldImpl implements HelloWorld {  
  
    private RemedyWebServiceCM remedy;  
  
    public String sayHi(User theUser) {  
          
        AcknowledgeRequest message = new AcknowledgeRequest();  
        remedy.acknowledge(message);  
          
        return "Hello " + theUser.getName() + " ,your age is "  
                + theUser.getAge();  
    }  
  
    public void setRemedy(RemedyWebServiceCM remedy) {  
        this.remedy = remedy;  
    }  
      
}  



<?xml version="1.0" encoding="UTF-8"?>  
  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
                            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
                            http://www.springframework.org/schema/context   
                            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
                            http://cxf.apache.org/jaxws   
                            http://cxf.apache.org/schemas/jaxws.xsd">  
  
    <import resource="classpath:META-INF/cxf/cxf.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  
      
    <context:component-scan base-package="com.huawei.framework" />  
      
    <bean id="helloWorldImpl" class="com.huawei.framework.webservice.HelloWorldImpl">  
        <property name="remedy" ref="remedy" />  
    </bean>  
  
    <jaxws:endpoint id="helloWorld" address="/HelloWorld"  
        implementor="#helloWorldImpl" />  
  
    <jaxws:client id="remedy"  
        serviceClass="com.huawei.remedy.webservice.RemedyWebServiceCM"  
        address="http://10.78.229.199:8080/remedy/webservice/RemedyWebService" />  
  
</beans>


用这种<bean id="">的方式就可以 

@Controller  
public class HelloWorldImpl implements HelloWorld {  
  
    @Autowired  
    private RemedyWebServiceCM remedy;  
  
    public String sayHi(User theUser) {  
          
        AcknowledgeRequest message = new AcknowledgeRequest();  
        remedy.acknowledge(message);  
          
        return "Hello " + theUser.getName() + " ,your age is "  
                + theUser.getAge();  
    }  
      
}  



<?xml version="1.0" encoding="UTF-8"?>  
  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"  
    xmlns:context="http://www.springframework.org/schema/context"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
                            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
                            http://www.springframework.org/schema/context   
                            http://www.springframework.org/schema/context/spring-context-3.0.xsd  
                            http://cxf.apache.org/jaxws   
                            http://cxf.apache.org/schemas/jaxws.xsd">  
  
    <import resource="classpath:META-INF/cxf/cxf.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-extension-soap.xml" />  
    <import resource="classpath:META-INF/cxf/cxf-servlet.xml" />  
      
    <context:component-scan base-package="com.huawei.framework" />  
      
    <jaxws:endpoint id="helloWorld" address="/HelloWorld"  
        implementor="#helloWorldImpl" />  
  
    <jaxws:client id="remedy"  
        serviceClass="com.huawei.remedy.webservice.RemedyWebServiceCM"  
        address="http://10.78.229.199:8080/remedy/webservice/RemedyWebService" />  
  
</beans>


用@Autowired加@Component的方式来做，就不行，报以下异常： 

Caused by: org.springframework.beans.factory.BeanCreationException: Could not autowire field: private com.huawei.remedy.webservice.RemedyWebServiceCM com.huawei.framework.webservice.HelloWorldImpl.remedy; nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.huawei.remedy.webservice.RemedyWebServiceCM] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)} 
at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:508) [org.springframework.beans-3.0.6.RELEASE.jar:] 
at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:84) [org.springframework.beans-3.0.6.RELEASE.jar:] 
at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessPropertyValues(AutowiredAnnotationBeanPostProcessor.java:285) [org.springframework.beans-3.0.6.RELEASE.jar:] 
... 21 more 
Caused by: org.springframework.beans.factory.NoSuchBeanDefinitionException: No matching bean of type [com.huawei.remedy.webservice.RemedyWebServiceCM] found for dependency: expected at least 1 bean which qualifies as autowire candidate for this dependency. Dependency annotations: {@org.springframework.beans.factory.annotation.Autowired(required=true)} 
at org.springframework.beans.factory.support.DefaultListableBeanFactory.raiseNoSuchBeanDefinitionException(DefaultListableBeanFactory.java:924) [org.springframework.beans-3.0.6.RELEASE.jar:] 
at org.springframework.beans.factory.support.DefaultListableBeanFactory.doResolveDependency(DefaultListableBeanFactory.java:793) [org.springframework.beans-3.0.6.RELEASE.jar:] 
at org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency(DefaultListableBeanFactory.java:707) [org.springframework.beans-3.0.6.RELEASE.jar:] 
at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:480) [org.springframework.beans-3.0.6.RELEASE.jar:] 
... 23 more

说自动注入失败，因为找不到RemedyWebServiceCM类型的bean

试了很久，完全搞不定。也想不通是为啥，因为RemedyWebServiceCM这个类型的bean，明明已经用<jaxws:client>声明了，而且用配置文件的方式也是能搞定的

解决：
1、如下代码是由org.apache.cxf.frontend.spring.ClientProxyFactoryBeanDefinitionParser进行解析。

写道 
<jaxws:client id="remedy" 
serviceClass="com.huawei.remedy.webservice.RemedyWebServiceCM" 
address="http://10.78.229.199:8080/remedy/webservice/RemedyWebService" />



2、它在解析时使用的是“实例工厂方式”完成创建：http://jinnianshilongnian.iteye.com/blog/1415277
写道 
protected Class getFactoryClass()
{
return SpringClientProxyFactoryBean.class;
}

写道 
bean.setFactoryBean(factoryId, "create");

 
3、而Bean类型默认指定为
写道 
public ClientProxyFactoryBeanDefinitionParser()
{
setBeanClass(Object.class);
}



4、
此处注意： 
<context:component-scan base-package="com.huawei.framework" />
  加载的Bean定义可能早于 
<jaxws:client id="remedy"  ……>


5、问题所在：
当spring实例化HelloWorldImpl完毕时会使用AutowiredAnnotationBeanPostProcessor完成@Autowired的注入，详见http://jinnianshilongnian.iteye.com/blog/1492424

校验类型是否匹配的代码如下： 
public boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException {
		String beanName = transformedBeanName(name);
		Class typeToMatch = (targetType != null ? targetType : Object.class);
 
		// Check manually registered singletons.
		Object beanInstance = getSingleton(beanName, false);  //1、此处获取remeby的单例（但remeby此时还没有创建 所以为null）
		if (beanInstance != null) {
			if (beanInstance instanceof FactoryBean) {
				if (!BeanFactoryUtils.isFactoryDereference(name)) {
					Class type = getTypeForFactoryBean((FactoryBean) beanInstance);
					return (type != null && typeToMatch.isAssignableFrom(type));
				}
				else {
					return typeToMatch.isAssignableFrom(beanInstance.getClass())					;
				}
			}
			else {
				return !BeanFactoryUtils.isFactoryDereference(name) &&
						typeToMatch.isAssignableFrom(beanInstance.getClass());
			}
		}
 
		else {//2、因此执行此段代码
			// No singleton instance found -> check bean definition.
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// No bean definition found in this factory -> delegate to parent.
				return parentBeanFactory.isTypeMatch(originalBeanName(name), targetType);
			}
 
			RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); //2.1、获取Bean定义
			Class beanClass = predictBeanType(beanName, mbd, new Class[] {FactoryBean.class, typeToMatch}); //2.2、获取bean类型
			if (beanClass == null) {
				return false;
			}
 
			// Check bean class whether we're dealing with a FactoryBean.
			if (FactoryBean.class.isAssignableFrom(beanClass)) {
				if (!BeanFactoryUtils.isFactoryDereference(name)) {
					// If it's a FactoryBean, we want to look at what it creates, not the factory class.
					Class type = getTypeForFactoryBean(beanName, mbd);
					return (type != null && typeToMatch.isAssignableFrom(type));
				}
				else {
					return typeToMatch.isAssignableFrom(beanClass);
				}
			}
			else {
				return !BeanFactoryUtils.isFactoryDereference(name) &&
						typeToMatch.isAssignableFrom(beanClass);
			}
		}
	}





protected Class predictBeanType(String beanName, RootBeanDefinition mbd, Class[] typesToMatch) {//2.2、获取bean类型
		Class beanClass = null;
		if (mbd.getFactoryMethodName() != null) {
			beanClass = getTypeForFactoryMethod(beanName, mbd, typesToMatch); //2.2.1、因为我们的remeby是通过实例工厂创建，因此调用此段带啊
		}
		else {
			beanClass = resolveBeanClass(mbd, beanName, typesToMatch);
		}
		// Apply SmartInstantiationAwareBeanPostProcessors to predict the
		// eventual type after a before-instantiation shortcut.
		if (beanClass != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (Iterator it = getBeanPostProcessors().iterator(); it.hasNext(); ) {
				BeanPostProcessor bp = (BeanPostProcessor) it.next();
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					Class processedType = ibp.predictBeanType(beanClass, beanName);
					if (processedType != null) {
						return processedType;
					}
				}
			}
		}
		return beanClass;
	}
 
 
//此方法会遍历所有的工厂方法 查找返回值类型，并且返回该类型  不细说了 （而且我们之前提到的工厂方法create返回值是Object  明显和我们需要的类型不兼容  因此会抛出找不到Bean异常）
protected Class getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class[] typesToMatch) {
		Class factoryClass = null;
		boolean isStatic = true;
 
		String factoryBeanName = mbd.getFactoryBeanName();
		if (factoryBeanName != null) {
			if (factoryBeanName.equals(beanName)) {
				throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
						"factory-bean reference points back to the same bean definition");
			}
			// Check declared factory method return type on factory class.
			factoryClass = getType(factoryBeanName); 
			isStatic = false;
		}
		else {
			// Check declared factory method return type on bean class.
			factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
		}
 
		if (factoryClass == null) {
			return null;
		}
 
		// If all factory methods have the same return type, return that type.
		// Can't clearly figure out exact method due to type converting / autowiring!
		int minNrOfArgs = mbd.getConstructorArgumentValues().getArgumentCount();
		Method[] candidates = ReflectionUtils.getAllDeclaredMethods(factoryClass);
		Set returnTypes = new HashSet(1);
		for (int i = 0; i < candidates.length; i++) {
			Method factoryMethod = candidates[i];
			if (Modifier.isStatic(factoryMethod.getModifiers()) == isStatic &&
					factoryMethod.getName().equals(mbd.getFactoryMethodName()) &&
					factoryMethod.getParameterTypes().length >= minNrOfArgs) {
				returnTypes.add(factoryMethod.getReturnType());
			}
		}
 
		if (returnTypes.size() == 1) {
			// Clear return type found: all factory methods return same type.
			return (Class) returnTypes.iterator().next();
		}
		else {
			// Ambiguous return types found: return null to indicate "not determinable".
			return null;
		}
	}







解决方法：
1、
@DependsOn("remedy") //保证remedy先被加载并初始化
@Component

2、<context:component-scan base-package="com.huawei.framework" /> 放在remedy之后

3、工厂方法返回我们需要的类型RemedyWebServiceCM，而不是Object（这个无法做到 除非我们定义的工厂）
分享到：
| BigDecimal
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    CXF集成Spring

    在上述描述的基础上，如果文件`cxfserver`包含了一个完整的CXF与Spring集成的示例项目，那么这个项目可能包含了Spring配置文件、服务接口和实现类的源代码，以及相关的Maven配置。通过分析这些文件，我们可以学习到...

    cxf与spring集成

    现在，我们将深入探讨如何将CXF与Spring集成，以构建高效、灵活的Web服务。 首先，让我们理解CXF的核心特性。CXF支持多种Web服务规范，如SOAP、RESTful以及WS-*家族，如WS-Security、WS-ReliableMessaging等。它还...

    cxf整合spring

    在IT行业中，Web服务是应用程序之间进行通信的一种标准方法，而CXF和Spring都是Java生态系统中的关键组件。本文将深入探讨如何将CXF与Spring框架整合，以构建高效且灵活的Web服务解决方案。 首先，让我们了解CXF。...

    Apache cxf 与spring集成

    在与Spring框架集成时，Apache CXF能够利用Spring的强大功能来管理服务的生命周期和依赖注入，使得Web服务的开发更加便捷和灵活。集成过程涉及以下几个关键步骤： 1. **环境准备**：确保使用合适的开发环境，例如...

    CXF整合spring的客户端和服务端

    - **cxfConnection**：这个名字暗示这可能是一个关于CXF连接配置的文件，可能包含了CXF与Spring集成的具体配置，例如服务的URL、认证信息、传输协议等。 - **cxfConsumer**：此文件名可能指的是CXF消费者，即...

    CXF-Spring相关jar包

    在【压缩包子文件的文件名称列表】中，"cxf-spring"可能包含的是用于集成CXF与Spring的必要jar包，如cxf-spring-integration.jar，这个文件通常包含了CXF与Spring集成所需的类和资源，使得开发者能够在Spring环境下...

    CXF和Spring搭建webservice代码

    在Spring框架中集成CXF，我们可以利用Spring的依赖注入和配置管理优势，使得Web服务的开发和维护变得更加简洁。以下是一个基本的步骤概述： 1. **创建Spring配置文件**： 首先，我们需要在Spring的配置文件（如`...

    WebService的CXF整合Spring

    通过以上步骤，我们可以构建出一个高效且易于维护的CXF-Spring集成Web服务系统。这种整合不仅使开发工作变得更加简洁，还充分利用了Spring的强大功能，提高了系统的可扩展性和灵活性。在实际项目中，开发者可以根据...

    CXF Mybatis Spring 集成配置

    本篇文章将详细介绍如何在 Spring 环境下集成 CXF 和 MyBatis，以及在集成过程中所需关注的关键点。 首先，我们需要了解 CXF 的作用。CXF 是一款用于构建和服务消费的开源框架，它支持 SOAP 和 RESTful 两种类型的 ...

    cxf+spring实现webservice

    8. **集成测试**：利用Spring Test和CXF的模拟测试工具，可以方便地进行Web服务的单元测试和集成测试。 9. **性能优化**：可以通过调整CXF的配置，例如缓存策略、线程池大小等，优化Web服务的性能。 10. **监控与...

    cxf spring maven 实例

    CXF是一个开源框架，主要用于构建和部署SOAP和RESTful Web服务，Spring则是一个广泛应用的Java企业级开发框架，而Maven是项目管理和集成工具，负责构建、依赖管理和项目信息管理。本实例将展示如何利用这三者来搭建...

    web service cxf 2.7.5 与spring 3.0 集成

    在本篇中，我们将深入探讨如何将Apache CXF 2.7.5版本与Spring 3.0框架集成，以便在Java应用程序中创建和消费Web服务。 **一、CXF简介** Apache CXF是一个全面的Web服务框架，它支持多种协议，如SOAP、RESTful HTTP...

    CXF与Spring 2.5整合

    2. **CXF的Spring支持**：CXF提供了对Spring的深度集成，可以通过Spring的XML配置或注解来定义和管理Web服务。例如，使用`&lt;jaxws:endpoint&gt;`标签创建一个基于JAX-WS的服务端点，或者使用`&lt;jaxrs:server&gt;`创建基于JAX...

    cxf+spring所需的jar包

    在Java企业级应用开发中，CXF和Spring框架的整合是常见的实践，它们共同构建了高效、灵活的服务层。CXF是一个开源的Web服务框架，它支持SOAP、RESTful等多种Web服务标准，而Spring框架则提供了强大的依赖注入、事务...

    CXF与Spring的集成

    **标题：“CXF与Spring的集成”** ...以上就是CXF与Spring集成的基本知识和步骤。通过这样的集成，开发者可以在保持代码简洁的同时，利用Spring的强大功能来管理和监控CXF服务，提升项目的可维护性和扩展性。

    cxf集成Spring的restful WebService接口

    总之，通过将CXF与Spring框架集成，我们可以利用Spring的强大功能来管理和配置服务，同时利用CXF的灵活性来快速开发RESTful接口。这种组合为Java开发者提供了一个高效且可扩展的解决方案，用于构建现代化的、基于...

    cxf_spring 相关 jar

    在IT行业中，CXF和Spring框架的整合是创建高效、灵活的Web服务的重要途径。...这种集成方式也允许你在同一项目中使用Spring的其他功能，如数据库连接池、事务管理和安全控制，从而构建完整的分布式系统。

    cxf+spring整合

    "CXF+Spring整合"是企业级Java应用程序中常用的一种技术组合，它结合了Apache CXF（一个用于构建和服务导向架构的开源框架）和Spring框架的优势，以实现高效、灵活的服务开发和管理。在Java世界里，CXF常用于创建Web...

    CXF跟Spring集成的 WebServer实例

    以上就是CXF与Spring集成的WebServer实例的基础步骤。在实际项目中，你可能需要处理更复杂的配置，如安全性、数据绑定、异常处理等。对于CXF 2.3.0版本，虽然已经有些陈旧，但是理解其工作原理对理解现代版本的CXF...

    cxf+spring+client

    它提供了SOAP和RESTful服务的实现，并且与Spring框架无缝集成，使得配置和服务管理变得更加简单。在这个"**cxf+spring+client**"的主题中，我们将深入探讨CXF与Spring框架结合创建客户端服务的细节，以及如何利用...

Magicbox
Global site tag (gtag.js) - Google Analytics