The first and foremost thing when we talk about spring is dependency injection which is possible because spring is actually a container and behaves as a factory of Beans. Just like the BeanFactory interface is the simplest container providing an advanced configuration mechanism to instantiate, configure, and manage the life cycle of beans. Beans are Java objects that are configured at run-time by Spring IoC Container. BeanFactory represents a basic IoC container which is a parent interface of ApplicationContext. BeanFactory uses Beans and their dependencies metadata to create and configure them at run-time. BeanFactory loads the bean definitions and dependency amongst the beans based on a configuration file(XML) or the beans can be directly returned when required using Java Configuration. There are other types of configuration files like LDAP, RDMS, properties files, etc. BeanFactory does not support Annotation-based configuration whereas ApplicationContext does.
Let us do first go through some of the methods of Bean factory before landing up on implementation which are shown below in tabular format below as follows:
|
Method |
Description |
|---|---|
| containsBean(String name) | Does this bean factory contain a bean definition or externally registered singleton instance with the given name? |
| getAliases(String name) | Return the aliases for the given bean name, if any. |
| getBean(Class<T> requiredType) | Return the bean instance that uniquely matches the given object type, if any. |
| getBean(Class<T> requiredType, Object… args) | Return an instance, which may be shared or independent, of the specified bean. |
| getBean(String name) | Return an instance, which may be shared or independent, of the specified bean. |
| getBean(String name, Class<T> requiredType) | Return an instance, which may be shared or independent, of the specified bean. |
| getBean(String name, Object… args) | Return an instance, which may be shared or independent, of the specified bean. |
| getBeanProvider(Class<T> requiredType) | Return a provider for the specified bean, allowing for lazy on-demand retrieval of instances, including availability and uniqueness options. |
| getBeanProvider(ResolvableType requiredType) | Return a provider for the specified bean, allowing for lazy on-demand retrieval of instances, including availability and uniqueness options. |
| getType(String name) | Determine the type of the bean with the given name. |
| getType(String name, boolean allowFactoryBeanInit) | Determine the type of the bean with the given name. |
| isPrototype(String name) | Is this bean a prototype? That is, will getBean(java.lang.String) always return independent instances? |
| isSingleton(String name) | Is this bean a shared singleton? That is, will getBean(java.lang.String) always return the same instance? |
| isTypeMatch(String name, Class<?> typeToMatch) | Check whether the bean with the given name matches the specified type. |
| isTypeMatch(String name, ResolvableType typeToMatch) | Check whether the bean with the given name matches the specified type. |
Procedure:
- Creating a Spring project using start.spring.io.
- Creating a POJO class.
- Configure the Student bean in the bean-factory-demo.xml file.
- Writing it to application class.
Implementation:
Step 1: Bean Definition: Create a Student POJO class.
// Java Program where we are
// creating a POJO class
// POJO class
public class Student {
// Member variables
private String name;
private String age;
// Constructor 1
public Student() {
}
// Constructor 2
public Student(String name, String age) {
this.name = name;
this.age = age;
}
// Method inside POJO class
@Override
public String toString() {
// Print student class attributes
return "Student{" + "name='" + name + '\'' + ", age='" + age + '\'' + '}';
}
}