Spring Core

Injecting Inner Beans in Spring with Example

Injecting Inner Beans in the Spring means beans that are defined within the scope of another bean whenever a bean is used for only one particular property. It’s advise to declare it as an inner bean.It supported in setter injection and constructor injection.

@ImageSource-SlideShare.net

In the previous chapter you have seen that how to inject on object been(point) to another bean(triangle) with using setter-injection methodology. Here we discuss same example with the concept of the injecting inner bean. Inner Bean means bean with in the bean i.e one bean(point) defined inside the another bean(triangle).

In the bean configuration file(spring.xml) there are four beans(ids are triangle, pointA, pointB and pointC) defined in the previous chapter suppose that beans (pointB and pointC) of the Point class are using only for triangle bean definition then there no need to defined the Point been in separately in the  bean configuration file(spring.xml) and pointA is the common point using by different shape as Circle, Rectangle etc si its defined separately in the  bean configuration file(spring.xml). The best idea at this situation we have to defined Point bean ‘s definition as inner bean definition with in the Triangle bean.

<bean class="com.dineshonjava.sdnext.innerBean.tutorial.Triangle" id="triangle">
   <property name="pointA" ref="pointA"></property>
   <property name="pointB">
      <bean class="com.dineshonjava.sdnext.innerBean.tutorial.Point">
  <property name="x" value="-20"></property>
  <property name="y" value="0"></property>
      </bean>
   </property>
   <property name="pointC">
      <bean class="com.dineshonjava.sdnext.innerBean.tutorial.Point">
 <property name="x" value="20"></property>
 <property name="y" value="0"></property>
      </bean>
   </property>
</bean>
<bean class="com.dineshonjava.sdnext.innerBean.tutorial.Point" id="pointA">
   <property name="x" value="0"></property>
   <property name="y" value="0"></property>
</bean>

 

Lets see with example..

Triangle.java

package com.dineshonjava.sdnext.innerBean.tutorial;

public class Triangle 
{
 private Point pointA;
 private Point pointB;
 private Point pointC;
 
 /**
  * @param pointA the pointA to set
  */
 public void setPointA(Point pointA) {
  this.pointA = pointA;
 }

 /**
  * @param pointB the pointB to set
  */
 public void setPointB(Point pointB) {
  this.pointB = pointB;
 }

 /**
  * @param pointC the pointC to set
  */
 public void setPointC(Point pointC) {
  this.pointC = pointC;
 }

 public void draw()
 {
  System.out.println("PointA is ("+pointA.getX()+", "+pointA.getY()+")");
  System.out.println("PointB is ("+pointB.getX()+", "+pointB.getY()+")");
  System.out.println("PointC is ("+pointC.getX()+", "+pointC.getY()+")");
 }
}

Point.java

package com.dineshonjava.sdnext.innerBean.tutorial;

public class Point
{
 private int x;
 private int y;
 /**
  * @return the x
  */
 public int getX() {
  return x;
 }
 /**
  * @param x the x to set
  */
 public void setX(int x) {
  this.x = x;
 }
 /**
  * @return the y
  */
 public int getY() {
  return y;
 }
 /**
  * @param y the y to set
  */
 public void setY(int y) {
  this.y = y;
 }
}
Now see how to define beans as inner beans in the following files.

Spring.xml

<beans class="com.sdnext.innerBean.tutorial.Triangle" triangle="triangle" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:p="http://www.springframework.org/schema/p" xmlns:>
DrawingApp.java
package com.dineshonjava.sdnext.innerBean.tutorial;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author Dinesh Rajput
 *
 */
public class DrawingApp 
{
 /**
  * @param args
  */
 public static void main(String[] args) 
 {
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
  Triangle triangle = (Triangle) context.getBean("triangle");
  triangle.draw();
 }

}

 

Run the application and we get same output as previous

output:
Jun 23, 2012 12:30:25 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@ab50cd: startup date [Sat Jun 23 12:30:25 IST 2012]; root of context hierarchy
Jun 23, 2012 12:30:26 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [spring.xml]
Jun 23, 2012 12:30:26 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@14c1103: defining beans [triangle,zeroPoint,Point2,Point3]; root of factory hierarchy

PointA is (0, 0)
PointB is (-20, 0)
PointC is (20, 0)

 

Aliases of Bean:

Aliase is way in which to give different name to the same bean. The reason for that naming of same bean used as different as per as our naming convention in our application requirement. In the Bean Configuration file(spring.xml) we have defined as the following.

<beans>
   ----
   <bean class="com.dineshonjava.sdnext.innerBean.tutorial.Triangle" id="triangle"> 
   -----
   -----
   </bean>
   <bean ---="">
      ----
   </bean>

    <alias alias="triangleAlias" name="triangle">
</alias></beans>
Here alias element has two attribute one is name and another is alias. name attribute has the value of id of which bean required to alias. alias attribute has the value what ever you want call as alias.
Here attribute name has the value "triangle"(id of triangle bean) and alias attribute has the value "triangleAlias" and get this bean in our application as following way.
ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
Triangle triangle = (Triangle) context.getBean("triangleAlias");
triangle.draw();
Difference between ref and idref: In ref can have the value of id of bean as well as name of the bean.
But the idref can have only and only id of the bean.
Using ref:
<bean class="com.sdnext.innerBean.tutorial.Triangle" id="triangle">
<property name="pointA" ref="zeroPoint"></property>
</bean>
<bean class="com.dineshonjava.sdnext.innerBean.tutorial.Point" name="zeroPoint">
</bean>
Using idref:
<bean class="com.sdnext.innerBean.tutorial.Triangle" id="triangle">
<property name="pointA">
<idref bean="zeropoint">  
</idref>
</property>
</bean>
<bean class="com.dineshonjava.sdnext.innerBean.tutorial.Point" id="zeroPoint">
</bean>

In Next Chapter we will discuss about Injecting Collection to Beans in Spring with Example in Application.

Spring Related Topics you may like

 

Previous
Next
Dinesh Rajput

Dinesh Rajput is the chief editor of a website Dineshonjava, a technical blog dedicated to the Spring and Java technologies. It has a series of articles related to Java technologies. Dinesh has been a Spring enthusiast since 2008 and is a Pivotal Certified Spring Professional, an author of a book Spring 5 Design Pattern, and a blogger. He has more than 10 years of experience with different aspects of Spring and Java design and development. His core expertise lies in the latest version of Spring Framework, Spring Boot, Spring Security, creating REST APIs, Microservice Architecture, Reactive Pattern, Spring AOP, Design Patterns, Struts, Hibernate, Web Services, Spring Batch, Cassandra, MongoDB, and Web Application Design and Architecture. He is currently working as a technology manager at a leading product and web development company. He worked as a developer and tech lead at the Bennett, Coleman & Co. Ltd and was the first developer in his previous company, Paytm. Dinesh is passionate about the latest Java technologies and loves to write technical blogs related to it. He is a very active member of the Java and Spring community on different forums. When it comes to the Spring Framework and Java, Dinesh tops the list!

Share
Published by
Dinesh Rajput

Recent Posts

Strategy Design Patterns using Lambda

Strategy Design Patterns We can easily create a strategy design pattern using lambda. To implement…

2 years ago

Decorator Pattern using Lambda

Decorator Pattern A decorator pattern allows a user to add new functionality to an existing…

2 years ago

Delegating pattern using lambda

Delegating pattern In software engineering, the delegation pattern is an object-oriented design pattern that allows…

2 years ago

Spring Vs Django- Know The Difference Between The Two

Technology has emerged a lot in the last decade, and now we have artificial intelligence;…

2 years ago

TOP 20 MongoDB INTERVIEW QUESTIONS 2022

Managing a database is becoming increasingly complex now due to the vast amount of data…

2 years ago

Scheduler @Scheduled Annotation Spring Boot

Overview In this article, we will explore Spring Scheduler how we could use it by…

3 years ago