mkyong

In last tutorial, you are able to get the MessageSource via ApplicationContext. But for a bean to get the MessageSource, you have to implement the MessageSourceAware interface. Example A CustomerService class, implement the MessageSourceAware interface, has a setter method to set the MessageSource property. During Spring container initialization, if any class which implements the MessageSourceAware […]

Problem The ContextLoaderListener is used to integrate Spring with other web application. <!– file : web.xml –> <context-param> <param-name>contextConfigLocation</param-name> <param-value>/WEB-INF/Spring/applicationContext.xml</param-value> </context-param> <listener> <listener-class> org.springframework.web.context.ContextLoaderListener </listener-class> </listener> And the common error message is, your server can not find this Spring ContextLoaderListener class during the server start up. SEVERE: Error configuring application listener of class org.springframework.web.context.ContextLoaderListener java.lang.ClassNotFoundException: […]

The @Required annotation is used to make sure a particular property has been set. If you are migrate your existing project to Spring framework or have your own @Required-style annotation for whatever reasons, Spring is allow you to define your custom @Required-style annotation, which is equivalent to @Required annotation. In this example, you will create […]

The ‘MapFactoryBean‘ class provides developer a way to create a concrete Map collection class (HashMap and TreeMap) in Spring’s bean configuration file. Here’s a MapFactoryBean example, it will instantiate a HashMap at runtime,, and inject it into a bean property. package com.mkyong.common; import java.util.Map; public class Customer { private Map maps; //… } Spring’s bean […]

The ‘SetFactoryBean‘ class provides developer a way to create a concrete Set collection (HashSet and TreeSet) in Spring’s bean configuration file. Here’s a ListFactoryBean example, it will instantiate an HashSet at runtime, and inject it into a bean property package com.mkyong.common; import java.util.Set; public class Customer { private Set sets; //… } Spring’s bean configuration […]

The ‘ListFactoryBean‘ class provides developer a way to create a concrete List collection class (ArrayList and LinkedList) in Spring’s bean configuration file. Here’s a ListFactoryBean example, it will instantiate an ArrayList at runtime, and inject it into a bean property. package com.mkyong.common; import java.util.List; public class Customer { private List lists; //… } Spring’s bean […]

Spring examples to show you how to inject values into collections type (List, Set, Map, and Properties). 4 major collection types are supported : List – <list/> Set – <set/> Map – <map/> Properties – <props/> Spring beans A Customer object, with four collection properties. package com.mkyong.common; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Set; […]

In Spring, the inheritance is supported in bean configuration for a bean to share common values, properties or configurations. A child bean or inherited bean can inherit its parent bean configurations, properties and some attributes. In additional, the child beans are allow to override the inherited value. See following full example to show you how […]

Spring’s dependency checking in bean configuration file is used to make sure all properties of a certain types (primitive, collection or object) have been set. In most scenarios, you just need to make sure a particular property has been set, but not all properties.. For this case, you need @Required annotation, see following example : […]

In Spring,you can use dependency checking feature to make sure the required properties have been set or injected. Dependency checking modes 4 dependency checking modes are supported: none – No dependency checking. simple – If any properties of primitive type (int, long,double…) and collection types (map, list..) have not been set, UnsatisfiedDependencyException will be thrown. […]

In Spring framework, whenever a bean is used for only one particular property, it’s advise to declare it as an inner bean. And the inner bean is supported both in setter injection ‘property‘ and constructor injection ‘constructor-arg‘. See a detail example to demonstrate the use of Spring inner bean. package com.mkyong.common; public class Customer { […]

In Spring framework, when your class contains multiple constructors with same number of arguments, it will always cause the constructor injection argument type ambiguities issue. Problem Let’s see this customer bean example. It contains two constructor methods, both accept 3 arguments with different data type. package com.mkyong.common; public class Customer { private String name; private […]

In Spring frameowork, Dependency Injection (DI) design pattern is used to define the object dependencies between each other. It exits in two major types : Setter Injection Constructor Injection 1. Setter Injection This is the most popular and simple DI method, it will injects the dependency via a setter method. Example A helper class with […]

In Spring, beans can “access” to each other by specify the bean references in the same or different bean configuration file. 1. Bean in different XML files If you are referring to a bean in different XML file, you can reference it with a ‘ref‘ tag, ‘bean‘ attribute. <ref bean="someBean"/> In this example, the bean […]

In Spring, there are three ways to inject value into bean properties. Normal way Shortcut “p” schema See a simple Java class, which contains two properties – name and type. Later you will use Spring to inject value into the bean properties. package com.mkyong.common; public class FileNameGenerator { private String name; private String type; public […]

The concept of object-oriented is a good design to break your system into a group of reusable objects. However, when system grows larger, especially in Java project, the huge object dependencies will always tightly coupled causing objects very hard to manage or modify. In this scenario, you can use Spring framework to act as a […]

Problem In a large project structure, the Spring’s bean configuration files are located in different folders for easy maintainability and modular. For example, Spring-Common.xml in common folder, Spring-Connection.xml in connection folder, Spring-ModuleA.xml in ModuleA folder…and etc. You may load multiple Spring bean configuration files in the code : ApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"Spring-Common.xml", […]