This is the first<\/strong> of a series of tutorials about setting up a RESTfull web application using Spring 3.1 with Java based configuration. The article will focus on bootstrapping the web application<\/strong>, discussing how to make the jump from XML to Java without having to completely migrate the entire XML configuration.<\/p>\n You may wonder why cglib<\/em> is a dependency \u2013 it turns out there is a valid reason to include it \u2013 the entire configuration cannot function without it. If removed, Spring will throw:<\/p>\n Caused by: java.lang.IllegalStateException: CGLIB is required to process @Configuration classes. Either add CGLIB to the classpath or remove the following @Configuration bean definitions<\/em><\/p>\n<\/blockquote>\n The reason this happens is explained by the way Spring deals with @Configuration<\/em> classes. These classes are effectively beans, and because of this they need to be aware of the Context, and respect scope and other bean semantics. This is achieved by dynamically creating a cglib proxy with this awareness for each @Configuration<\/em> class, hence the cglib dependency.<\/p>\n Also, because of this, there are a few restrictions for Configuration<\/em> annotated classes:<\/p>\n Starting with Spring 3.2, it is no longer necessary to add cglib<\/em> as an explicit dependency<\/strong>. This is because Spring is in now inlining cglib<\/em> \u2013 which will ensure that all class based proxying functionality will work out of the box with Spring 3.2. The new cglib code is placed under the Spring package: org.springframework.cglib<\/em> (replacing the original net.sf.cglib<\/em>). The reason for the package change is to avoid conflicts with any cglib<\/em> versions already existing on the classpath.<\/p>\n Also, the new cglib 3.0 is now used, upgraded from the older 2.2 dependency (see this JIRA issue<\/a> for more details).<\/p>\n First, the @Configuration<\/em><\/strong> annotation \u2013 this is the main artifact used by the Java based Spring configuration; it is itself meta-annotated with @Component<\/em>, which makes the annotated classes standard beans<\/strong> and as such, also candidates for component scanning. The main purpose of @Configuration<\/em> classes is to be sources of bean definitions for the Spring IoC Container. For a more detailed description, see the official docs<\/a>.<\/p>\n Then, @ImportResource<\/em><\/strong> is used to import the existing XML based Spring configuration. This may be configuration which is still being migrated from XML to Java, or simply legacy configuration that you wish to keep. Either way, importing it into the Container is essential for a successful migration, allowing small steps without to much risk. The equivalent XML annotation that is replaced is:<\/p>\n <import resource=\u201dclasspath*:\/rest_config.xml\u201d \/><\/em><\/p>\n Moving on to @ComponentScan<\/em><\/strong> \u2013 this configures the component scanning directive, effectively replacing the XML:<\/p>\n As of Spring 3.1, the @Configuration<\/em> are excluded from classpath scanning by default \u2013 see this JIRA issue<\/a>. Before Spring 3.1 though, these classes should have been excluded explicitly:<\/p>\n The @Configuration<\/em> classes should not be autodiscovered because they are already specified and used by the Container \u2013 allowing them to be rediscovered and introduced into the Spring context will result in the following error:<\/p>\n Caused by: org.springframework.context.annotation.ConflictingBeanDefinitionException: Annotation-specified bean name \u2018webConfig\u2019 for bean class [org.rest.spring.AppConfig] conflicts with existing, non-compatible bean definition of same name and class [org.rest.spring.AppConfig]<\/em><\/p>\n<\/blockquote>\n And finally, using the @Bean<\/strong> annotation to configure the properties support<\/strong> –\u00a0PropertySourcesPlaceholderConfigurer<\/em> is initialized in a @Bean<\/em> annotated method, indicating it will produce a Spring bean managed by the Container. This new configuration has replaced the following XML:<\/p>\n For a more in detph discussion on why it was necessary to manually register the PropertySourcesPlaceholderConfigurer<\/em> bean, see the Properties with Spring Tutorial<\/a>.<\/p>\n First, the root context is defined and configured to use AnnotationConfigWebApplicationContext<\/em> instead of the default XmlWebApplicationContext<\/em>. The newer AnnotationConfigWebApplicationContext<\/em> accepts @Configuration<\/em> annotated classes as input for the Container configuration and is needed in order to set up the Java based context.<\/p>\n Unlike XmlWebApplicationContext<\/em>, it assumes no default configuration class locations, so the \u201ccontextConfigLocation\u201d<\/em> init-param<\/em> for the Servlet must be set. This will point to the java package where the @Configuration<\/em> classes are located; the fully qualified name(s) of the classes are also supported.<\/p>\n Next, the DispatcherServlet<\/em> is configured to use the same kind of context, with the only difference that it\u2019s loading configuration classes out of a different package.<\/p>\n Other than this, the web.xml<\/em> doesn\u2019t really change from a XML to a Java based configuration.<\/p>\n The presented approach allows for a smooth migration of the Spring configuration<\/strong> from XML to Java, mixing the old and the new. This is important for older projects, which may have a lot of XML based configuration that cannot be migrated all at once. This way, the web.xml<\/em> and bootstrapping of the application is the first step in a migration, after which the remaining XML beans can be ported in small increments.<\/p>\n In the next article on REST with Spring<\/a>, I cover setting up MVC in the project, configuration of the HTTP status codes, payload marshalling and content negotiation. In the meantime, you can check out the github project<\/a>. 1. Overview This is the first of a series of tutorials about setting up a RESTfull web application using Spring 3.1 with Java based configuration. The article will focus on bootstrapping the web application, discussing how to make the jump from XML to Java without having to completely migrate the entire XML configuration. 2. The …<\/p>\n","protected":false},"author":104,"featured_media":240,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[8],"tags":[30],"class_list":["post-16828","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-enterprise-java","tag-spring"],"yoast_head":"\n2. The Maven pom.xml<\/em><\/h2>\n
\n <\/p>\n<project xmlns=\"http:\/\/maven.apache.org\/POM\/4.0.0\" \r\n xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n xsi:schemaLocation=\"\r\n http:\/\/maven.apache.org\/POM\/4.0.0 \r\n http:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\r\n <modelVersion>4.0.0<\/modelVersion>\r\n <groupId>org<\/groupId>\r\n <artifactId>rest<\/artifactId>\r\n <version>0.0.1-SNAPSHOT<\/version>\r\n <packaging>war<\/packaging>\r\n\r\n <dependencies>\r\n\r\n <dependency>\r\n <groupId>org.springframework<\/groupId>\r\n <artifactId>spring-webmvc<\/artifactId>\r\n <version>${spring.version}<\/version>\r\n <exclusions>\r\n <exclusion>\r\n <artifactId>commons-logging<\/artifactId>\r\n <groupId>commons-logging<\/groupId>\r\n <\/exclusion>\r\n <\/exclusions>\r\n <\/dependency>\r\n <dependency>\r\n <groupId>cglib<\/groupId>\r\n <artifactId>cglib-nodep<\/artifactId>\r\n <version>${cglib.version}<\/version>\r\n <scope>runtime<\/scope>\r\n <\/dependency>\r\n\r\n <\/dependencies>\r\n\r\n <build>\r\n <finalName>rest<\/finalName>\r\n\r\n <plugins>\r\n <plugin>\r\n <groupId>org.apache.maven.plugins<\/groupId>\r\n <artifactId>maven-compiler-plugin<\/artifactId>\r\n <version>3.1<\/version>\r\n <configuration>\r\n <source>1.6<\/source>\r\n <target>1.6<\/target>\r\n <encoding>UTF-8<\/encoding>\r\n <\/configuration>\r\n <\/plugin>\r\n <\/plugins>\r\n <\/build>\r\n\r\n <properties>\r\n <spring.version>3.2.2.RELEASE<\/spring.version>\r\n <cglib.version>2.2.2<\/cglib.version>\r\n <\/properties>\r\n\r\n<\/project><\/pre>\n2.1. Justification of the cglib<\/em> dependency<\/h4>\n
\n
\n
2.2. The cglib<\/em> dependency in Spring 3.2
\n<\/h4>\n3. The Java based web configuration<\/h2>\n
@Configuration\r\n@ImportResource( { \"classpath*:\/rest_config.xml\" } )\r\n@ComponentScan( basePackages = \"org.rest\" )\r\n@PropertySource({ \"classpath:rest.properties\", \"classpath:web.properties\" })\r\npublic class AppConfig{\r\n\r\n @Bean\r\n\u00a0\u00a0 public static PropertySourcesPlaceholderConfigurer properties() {\r\n\u00a0\u00a0 return new PropertySourcesPlaceholderConfigurer();\r\n\u00a0\u00a0 }\r\n}<\/pre>\n<context:component-scan base-package=\"org.rest\" \/><\/pre>\n
excludeFilters = { @ComponentScan.Filter( Configuration.class ) }<\/pre>\n\n
<context:property-placeholder\r\nlocation=\"classpath:persistence.properties, classpath:web.properties\"\r\nignore-unresolvable=\"true\"\/><\/pre>\n
3.1. The web.xml<\/em><\/h4>\n
<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<web-app xmlns=\"\r\n http:\/\/java.sun.com\/xml\/ns\/javaee\"\r\n\u00a0\u00a0 \u00a0 xmlns:web=\"http:\/\/java.sun.com\/xml\/ns\/javaee\/web-app_3_0.xsd\"\r\n\u00a0\u00a0 \u00a0 xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n\u00a0\u00a0 \u00a0xsi:schemaLocation=\"\r\n http:\/\/java.sun.com\/xml\/ns\/javaee \r\n http:\/\/java.sun.com\/xml\/ns\/javaee\/web-app_3_0.xsd\"\r\n\u00a0\u00a0 \u00a0id=\"rest\" version=\"3.0\">\r\n\r\n <context-param>\r\n <param-name>contextClass<\/param-name>\r\n <param-value>\r\n org.springframework.web.context.support.AnnotationConfigWebApplicationContext\r\n <\/param-value>\r\n <\/context-param>\r\n <context-param>\r\n <param-name>contextConfigLocation<\/param-name>\r\n <param-value>org.rest.spring.root<\/param-value>\r\n <\/context-param>\r\n <listener>\r\n <listener-class>org.springframework.web.context.ContextLoaderListener<\/listener-class>\r\n <\/listener>\r\n\r\n <servlet>\r\n <servlet-name>rest<\/servlet-name>\r\n <servlet-class>\r\n org.springframework.web.servlet.DispatcherServlet\r\n <\/servlet-class>\r\n <init-param>\r\n <param-name>contextClass<\/param-name>\r\n <param-value>\r\n org.springframework.web.context.support.AnnotationConfigWebApplicationContext\r\n <\/param-value>\r\n <\/init-param>\r\n <init-param>\r\n <param-name>contextConfigLocation<\/param-name>\r\n <param-value>org.rest.spring.rest<\/param-value>\r\n <\/init-param>\r\n <load-on-startup>1<\/load-on-startup>\r\n <\/servlet>\r\n <servlet-mapping>\r\n <servlet-name>rest<\/servlet-name>\r\n <url-pattern>\/api\/*<\/url-pattern>\r\n <\/servlet-mapping>\r\n\r\n <welcome-file-list>\r\n <welcome-file \/>\r\n <\/welcome-file-list>\r\n\r\n<\/web-app><\/pre>\n
4. Conclusion<\/h2>\n
\n <\/p>\n