I'm making my first forays into spring and am getting the following error trying to run on eclipse:
org.springframework.beans.factory.BeanNotOfRequiredTypeException: Bean named 'model' must be of type [com.myCompany.project.Model], but was actually of type [com.myCompany.project.Model]
Code causing the exception:
import com.myCompany.project.Model;
// some code
public Model getModel() {
ClassPathXmlApplicationContext applicationContext =
new ClassPathXmlApplicationContext("client-context.xml");
return applicationContext.getBean("model", Model.class);
}
Spring xml:
<?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:context="http://www.springframework.org/schema/context"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config />
<bean id="model" class="com.myCompany.project.Model" />
</beans>
The client-context.xml is located in project/resources, the code in project/src/main/
I assume this is a classpath issue, but I am at a loss as to what to do to fix it.
Java and Spring are case sensitive. This:
<bean id="model" class="com.myCompany.project.model" />
is not the same as this:
<bean id="model" class="com.myCompany.project.Model" />
I'd think about some better names. Those aren't very insightful.
I don't like the way you're going about this. You shouldn't have a bean that has to access the app context this way. You'll have to post more code to be sure, but you ought to be wiring that model bean into object that wants it, not doing what you're doing.
The only reason for doing what you're proposing is if the bean interacting with the app context is creating using new rather than the Spring bean factory. Since you're just starting with Spring, I would recommend letting Spring handle all dependencies.
Related
We use Spring IoC and Struts as the web app framework. There is a helper class in the presentation layer which reads some stuff from request and populates some data as request attributes for the action and other classes to use. So we need the request object (HttpServletRequest) in this class, and we use ServletActionContext.getRequest() for this.
The helper class is a Spring bean in request scope, and gets invoked for all requests. The data loading happens in a method which is configured as "init-method" in the helper's Spring bean. The actions are also Spring beans.
In struts.xml, we refer to the action beans configured in spring by name. For eg:
<action name="myAction" class="actionBeanNameFromSpring">
<result>myResult.jsp</result>
</action>
In this case, the ServletActionContext.getRequest() method in the helper returns the proper request object. However, we have other actions in the XML where we directly refer to the action class instead of action bean i.e. we bypass Spring. In these cases, the request comes out as null.
Now I know that the solution to this is to change all action entries in XML to refer to Spring beans. But I would like to know why exactly this happens. AFAIK, ServletActionContext is a Struts thing and is handled completely by Struts. How does going through Spring (i.e. using Spring action beans) populate the context, and not going through Spring (i.e. using Action class name) doesn't?
#Roman
I am assuming the entire content is unnecessary. Given below is the relevant part:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd 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://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
....
<!-- the helper which accesses request -->
<bean id="myActionHelper" class="com.company.product.webapp.package.MyActionHelper" init-method="init" scope="request">
<property name="someSvcBean" ref="someSvcBean" />
</bean>
....
<!-- a typical action -->
<bean id="myAction" class="com.company.product.webapp.action.MyAction" scope="request">
</bean>
....
</beans>
I'am trying to configure spring with XML syntax only and come into a problem with native resource exceptions translation to DataAccessException. According to documentation I always need to put #Repository on repository bean and declare PersistenceExceptionTranslationPostProcessor bean. I think that here should be the way to define some sort of filter using AOP which will perform exceptions translation but can't find anything like this in docs. The idea is to introduce convention, for example 'for everything what ends with Dao apply native exceptions translation'. Any ideas?
Similar to #Repository annotaion spring xml config looks like:
<?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:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
...
<bean id="translationInterceptor" class="org.springframework.dao.support.PersistenceExceptionTranslationInterceptor" />
<aop:config>
<aop:advisor advice-ref="translationInterceptor" pointcut="within(org.example.spring.dao..*Dao)" />
</aop:config>
...
</beans>
Pointcut "within(org.example.spring.dao..*Dao)" applies interceptor to methods in classes located in package org.example.spring.dao and its subpackages ends with "Dao" suffix
I want to use spring together with jbossws-cxf. Is this possible?
First I tried using jbossws-cxf.xml with bean definitions of spring. The warning message [DescriptorDeploymentAspect] Spring not available, skipping check for user provided jbossws-cxf.xml / cxf.xml configuration files. states that the file gets ignored and means that you should install spring in order for it to not get ignored :-) . So I installed spring for jboss..
After installation and running of a simple MathWS together with a simple WS example I get a
[org.jboss.wsf.stack.cxf.client.configuration.JBossWSSpringBusFactory] INITIAL_APP_CONTEXT_CREATION_FAILED_MSG: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.apache.cxf.binding.soap.customEditorConfigurer' defined in URL [vfs:/D:/lifeDevSuite/jboss/jboss-6.0.0.FinalSpring/common/lib/cxf-rt-bindings-soap.jar/META-INF/cxf/cxf-extension-soap.fixml]: Initialization of bean failed; nested exception is org.springframework.beans.ConversionNotSupportedException: Failed to convert property value of type 'java.util.ArrayList' to required type 'org.springframework.beans.PropertyEditorRegistrar[]' for property 'propertyEditorRegistrars'; nested exception is java.lang.IllegalStateException: Cannot convert value of type [org.apache.cxf.binding.soap.spring.SoapVersionRegistrar] to required type [org.springframework.beans.PropertyEditorRegistrar] for property 'propertyEditorRegistrars[0]': no matching editors or conversion strategy found
error.
My jbossws-cxf.xml looks like this:
`
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://cxf.apache.org/jaxws
http://cxf.apache.org/schemas/jaxws.xsd">
<bean id="mathBean" class="com.sample.MathWS">
<constructor-arg value="alabama" />
</bean>
<jaxws:endpoint id="MathWSX" implementor="#mathBean" address="http://localhost:8080/HelloCXF" />
`
I solved the problem. Sadly - I cannot recall how. And please forgive me - but I'm not going back to try and reproduce it :-)
Basically the answer is "yes". To that specific problem, it may have been a namespace problem, e.g. correct would be
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:jaxws="http://cxf.apache.org/jaxws"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-2.5.xsd
http://cxf.apache.org/jaxws
http://cxf.apache.org/schemas/jaxws.xsd">
It may have been as well that custom spring libraries were deployed (I think it is recommended using the spring libraries coming with jboss and are deployed dynamically automagically)
It may have been something else alltogether
In my Spring MVC webapplication I want to mix xml based configuration with annotations:
I use annotations like #Controller, #RequestMapping("bla.htm"), #RequestParam etc. to resolve HttpRequests to Controller Methods. Therefore I added
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping"/>
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"/>
<context:component-scan base-package="somePackage.controller"/>
to my dispatcher-servlet.xml.
But my controllers have attributes. Those attributes could be injected via #AutoWired annotation. But I also have do define Scopes. So i would have two annotations per attribute, which makes the code bad readable. So I want to inject dependencies in my applicationContext.xml file.
Is there a way I can keep the annotation-driven request-mapping but use context.xml files for Dependency Injection? Or is it only possible to use EITHER annotations OR xml configuration?
note: my beans for dependency injection are in a different xml file.
PS:
I should have mentioned, I use Spring 2.5 and can't upgrade it.
No, <mvc:annotation-driven> works fine with XML. But you'll need to get rid of the <context:component-scan>.
Update: with Spring 2.5, this should get you started:
<?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:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-2.5.xsd">
<context:annotation-config />
<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />
<bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />
<!-- now add some controllers -->
</beans>
Yes this is certainly possible.
To use the controller annotations such as #Controller and #RequestMapping make sure you put
<mvc:annotation-driven/>
in your <servletname>-servlet.xml
Then simple define your controllers using the normal XML bean notation such as:
<bean class="com.company.controllers.AController">
<property name="propertyName" ref="beanId" />
</bean>
These bean refs can come from any other applicationContext.xml defined in your web.xml too.
I have an aspect working correctly in my unit tests, a log message is printed from the actual method, and afterwards from the aspect applied.
When running my webapp though, I only see the result of the '#afterReturning' advice applied, my method does not execute first.
My config:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
<aop:aspectj-autoproxy proxy-target-class="true" />
<bean id="loggingAspect" class="com.mypackage.MyAspect" />
</beans>
Any ideas ?
Thanks for your help.
Information you provided in not enough to analyze. So check below things in your web app,
1) Verify that the method you are expecting to be intercepted by your advice, belongs to spring bean class & not some other servlet or other class defined outside spring. If any class is not initialized through spring then aop advice can not be applied to that class.
2) Verify that above aop & advice configs are put in proper context xml for spring. Like in case of spring-mvc, you have to explicitely define the name of your application context xml. And in that application context xml only you have to write aop configurations.
3) Verify if your pointcut is appropriate to find exact class & method for advice.
See if these things are in place.