Spring Framework

• Core Container: These are core modules that provide key features of the Spring framework.
• Data Access/Integration: These modules support JDBC and ORM data access approaches in Spring applications.
• Web: These modules provide support to implement web applications.
• Others: Spring also provides few other modules such as the Test for testing Spring applications.

Spring Framework - Modules

• Spring Modules - Core Container

• Core: This is the key module of Spring Framework which provides fundamental support on which all other modules of the framework are dependent.
• Bean: This module provides a basic Spring container called BeanFactory. 
• Context: This module provides one more Spring container called ApplicationContext which inherits the basic features of the BeanFactory container and also provides additional features to support enterprise application development. 
• Spring Expression Language (SpEL): This module is used for querying/manipulating object value.
• AOP (Aspect Oriented Programming) and aspects: These modules help in isolating cross-cutting functionality from business logic.

• Spring Modules - Data Access/Integration

• Java Database Connectivity (JDBC): It provides an abstract layer to support JDBC calls to relational databases.
• Object Relational Mapping (ORM): It provides integration support for popular ORM(Object-Relational Mapping) solutions such as Hibernate, JPA, etc.
• Transactions: It provides simple transaction API which abstracts the complexity of underlying repository specific transaction API's from the application.

• Spring Modules - Web

• Web: This module has a container called web application context which inherits basic features from ApplicationContext container and adds features to develop web based applications.
• Webmvc: It provides the implementation of the MVC(model-view-controller) pattern to implement the server side presentation layer and also support features to implement RESTful Web Services.
• WebFlux: Spring 5.0 introduced a reactive stack with a web framework called Spring WebFlux to support Reactive programming in Spring's web layer and runs on containers such as Netty, Undertow, and Servlet 3.1+.
• WebSocket: It is used for 2 way communication between client and server in WebSocket based web applications.

• Test:  This module provides required support to test Spring applications using TestNG or JUnits

• JDK baseline update
• Core framework revision
• Reactive Programming Model: Introduces a new non-blocking web framework called Spring WebFlux
• Functional programming using Kotlin language support
• Testing improvements by supporting integration with JUnit5

JDK baseline update

Core framework revision

*
* The Class Client.
*/
public class Client{
    public static void main(String[] args) {
        //ApplicationContext container is instantiated by loading the configuration from config.xml available in application classpath
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        // Accessing bean with id "reportService" and typecast from Object type to ReportService type
        ReportService reportService = (ReportService) context.getBean("reportService");
         // Invoking display method of ReportService to display greeting on console
       reportService.display();
    }
}

• Right click on Client file(which has main method) -> Run As -> Java Application

Output

• You can observe below response on the console.

public class Client{   
    public static void main(String[] args) {        
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        -------------------
        context.close();      
    }
}

1. In the client code Client.java

• Replace bean access line "ReportService reportService = (ReportService ) context.getBean("reportService");" with this "ReportService reportService = context.getBean(ReportService.class);"
• Run the application and observe the response
• --@ work same as normal

2. Now, in the configuration file config.xml

• Define one more bean of ReportService class with id reportService2
• Run the application and observe the response
• --@Exception in thread "main" org.springframework.beans.factory.NoUniqueBeanDefinitionException: No qualifying bean of type 'com.infosys.service.ReportService' available: expected single matching bean but found 2: reportService,reportService2

3. In the client code

• Now use this line for accessing bean "ReportService reportService = context.getBean("reportService2", ReportService.class);"
• Run the application and observe the response.
• --@code will work as normal

ReportService reportService = (ReportService)context.getBean("reportService");

ReportService reportService =  context.getBean(ReportService.class);

ReportService reportService =  context.getBean("reportService2", ReportService.class);

 bean id = "reportService" class="com.infosys.demo.ReportService" > /bean

ReportService reportService = new ReportService();

How do we initialize bean with some specific values in Spring?

• Constructor Injection: This is achieved when the container invokes parameterized constructor to initialize the properties of a class

• by name = constructor-arg name="totalRecords" value="500" /,
• type = constructor-arg value="200.00" type = "double"/, 
• index= constructor-arg value="500" index="1" /

• Setter Injection: This is achieved when the container invokes setter methods of a class to initialize the properties after invoking a default construct

package com.infosys.service;
public class ReportService {
    private int recordsPerPage;
    public ReportService(int recordsPerPage) {
                this.recordsPerPage = recordsPerPage;
        }
    -------------------- 
}

How do we define bean in the configuration to initialize values?

/ bean id = "reportService" class = "com.infosys.service.ReportService" 
     / constructor-arg value = "150"/ /     
/bean /

What is mandatory for constructor injection?

• Parameterized constructor is required in the ReportService class as we are injecting the values through the constructor argument
• constructor-arg tag in the bean definition

package com.infosys.service;

public class ReportService {   

    /** The properties. */
    private int recordsPerPage ;
    private int totalRecords;
  
   public ReportService(int recordsPerPage,  int totalRecords) {
          this.recordsPerPage = recordsPerPage;
          this.totalRecords = totalRecords;
    }

   -------------------------
}

* <bean id="reportService" class="com.infosys.service.ReportService" >*
     * <constructor-arg value="100" />*
    *  <constructor-arg value="500" />*
*</bean>*

How does Spring resolve ambiguities if any in terms of passing values to parameterized constructor?

From Spring 3.0 onwards, constructor parameter name can be used for providing value as shown below. Here the values are passed to appropriate constructor arguments based on argument name instead of in the order of sequence mentioned in the bean definition.

  public ReportService(int recordsPerPage,  int totalRecords) {
          this.recordsPerPage = recordsPerPage;
          this.totalRecords = totalRecords;
   }

bean id="reportService" class="com.infosys.service.ReportService"
          constructor-arg name="totalRecords" value="500" /
          constructor-arg name="recordsPerPage" value ="100" /
/bean

package com.infosys.service;

public class ReportService {   

    /** The properties. */
    private int recordsPerPage ;
    private int totalRecords; 
    public ReportService(int recordsPerPage,  int totalRecords) {
          this.recordsPerPage = recordsPerPage;
          this.totalRecords = totalRecords;
    }

   --------------------------
}

 id="reportService" class="com.infosys.service.ReportService" >
       value="500" index="1" />
       value="100" index="0" />

package com.infosys.demo;
public class ReportService {
    private ReportGenerator master;
    private int recordsPerPage;
    public ReportService(ReportGenerator master, int recordsPerPage) {
        this.master = master;
        this.recordsPerPage = recordsPerPage;
    }
    public void generateReport() {  
       System.out.println(master.generateReport(recordsPerPage));
     }
}

How do we inject object dependencies through configuration using constructor injection?

bean id="reportService" class="com.infosys.demo.ReportService"
        constructor-arg name="master" ref="pdfReportGenerator" /
        constructor-arg name="recordsPerPage" value="150" /
/bean
!-- Bean of HTMLReportGenerator type --
bean id="htmlReportGenerator" class="com.infosys.demo.HTMLReportGenerator" /   
!-- Bean of PDFReportGenerator type --
bean id="pdfReportGenerator" class="com.infosys.demo.PDFReportGenerator" /

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        ReportService srv = (ReportService)context.getBean("reportService");
        srv.generateReport();
    }
}

Parameterized Constructor
Generated PDF Report with 150 records

Problem Statement

• Add new Employee details
• Get Employee details
• Check Loan Eligibility based on the following criteria
  • "Manager" and "GM" roles are not eligible for applying for a loan
  • If an employee already has taken a loan and it is still not closed also not eligible for the loan

Application Architecture

Class Description

public class Employee {   
        private int empId;
        private String firstName;       
        private String lastName;        
        private String role;    
        private String department;      
        private Address address;  
 }

public class Address {
        private String city;
        private String state;
        private int pincode;
}

public class Loan {       
        private int loanId;     
        private int empId;
        private double amount;
        private double emi;
        private int noOfInsatllment;
        private double balance;
        /** The status. It can be either "open" or "closed" state */
        private String status;
}

• Define required bean definitions by initializing needed dependency using constructor injection in the Spring configuration
• Client code has to access the EmployeeService bean to get the services

• You have learned how to implement construct injection to initialize the dependencies

package com.infosys.demo;
public class ReportService {
   private int recordsPerPage;
    public int getRecordsPerPage() {
        return recordsPerPage;
    }
    public void setRecordsPerPage(int recordsPerPage) {
        this.recordsPerPage = recordsPerPage;
    }
   --------------------------
}

id="reportService" class="com.infosys.demo.ReportService" >
         name="recordsPerPage" value="500" />

package com.infosys.demo;
public class ReportService {
    private ReportGenerator master;
    public void setMaster(ReportGenerator master) {
        this.master = master;
    }
    public ReportGenerator getMaster() {
         return master;
    }
   -----------------------------------
}

bean id="reportService" class="com.infosys.demo.ReportService">
         name="master" ref="htmlReportGenerator" />
/bean
bean id="htmlReportGenerator" class="com.infosys.demo.HTMLReportGenerator" /bean id="pdfReportGenerator" class="com.infosys.demo.PDFReportGenerator" /

public class Client {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        ReportService srv = (ReportService)context.getBean("reportService");
        srv.generateReport();
    }
}

• list helps in injecting a list of values allowing duplicates
• set helps in injecting a set of values without any duplicates
• map helps in injecting a collection of key-value pairs where key and value can be of any type
• props helps in injecting a collection of key-value pairs where key and value are both Strings

package com.infosys.demo;

public class ReportService {

    private List<ReportGenerator> reports;
   
    public void setReports(List<ReportGenerator> reports) {
        this.reports= reports;
    }
    // getter and setters
}

bean id="htmlReportGenerator" class="com.infosys.demo.HTMLReportGenerator" /
bean id="pdfReportGenerator" class="com.infosys.demo.PDFReportGenerator" /
bean id = "reportService" class = "com.infosys.demo.ReportService" 
     property name = "reports"
         list
            ref bean = "PDFReportGenerator /
            ref bean = "HTMLReportGenerator /
         /list
      /property   
/bean

• The dependency of ReportService class on ReportGenerator type of object has been resolved using the new operator in the ReportService class

• The dependency of ReportService class on ReportGenerator type of object has been moved to Spring configuration

Consider the MobileService class given below:

package com.infosys;
public class MobileService{
   private long mobileNumber;
   private String model;   
   public void setMobileNumber(long mobileNumber){
         this.mobileNumber = mobileNumber;
   }

   public void setModel(String model){
         this.model = model;
  } 
}

 A Spring configuration file(config.xml) defines a bean of Mobile class as shown below:

bean id="mobileService" class="com.infosys.MobileService"
    property name="mobileNumber" value="1234567892"/
/bean

The main method of the application is shown below:

ApplicationContext ac=new ClassPathXmlApplicationContext("config.xml");
MobileService m = (MobileService)ac.getBean("mobileService");

Which of the following is TRUE about the above example?

• Error as all the properties of the MobileService class are not provided in the definition of bean
• A bean of MobileService class is created with the value of mobileNumber as 1234567892 and model as null
• Fail to create bean as matching constructor not found
• Fail to create bean as model value is not assigned through bean definition

package com.infosys;
public class MobileService{
   private long mobileNumber;
   private String model;   
   public void setMobileNumber(long mobileNumber){
         this.mobileNumber = mobileNumber;
   }

   public void setModel(String model){
         this.model = model;
  } 
}

 A Spring configuration file(config.xml) defines a bean of Mobile class as shown below:

*bean id="mobileService" class="com.infosys.MobileService"*
    *property  value="1234567892"/">
    *property name="model"  value="Nokia"/*
*/bean*

The main method of the application is shown below:

ApplicationContext ac=new ClassPathXmlApplicationContext("config.xml");
MobileService m = (MobileService)ac.getBean("mobileService");

What is the output of the above code execution?

• A bean of MobileService class is created with the value of mobileNumber as “0” and model as “Nokia”
• Exception: Attribute 'name' must appear on element 'property' in bean definition
• A bean of MobileService class is created with the value of mobileNumber as “1234567892” and model as “Nokia”

Q3 of 4

Consider the class given below:

package com.infosys;
public class MobileService{
   private long mobileNumber;
   private String model;
   //default constructor  
   public void MobileService(){  }
   //parameterized constructor
   public void MobileService(long mobileNumber, String model){
          this.mobileNumber = mobileNumber;
          this.model = model; 
   }
  //setter method
  public void setMobileNumber(long mobileNumber){  
          this.mobileNumber = mobileNumber;   
  }   
  public void setModel(String model){ 
          this.model = model;   
  } 
}

Assume below given Spring configuration:

*!--Bean definitions --*
*bean id="mobileService1" class="com.infosys.MobileService" /*
*bean id="mobileService2" class="com.infosys.MobileService" *
    *constructor-arg value="1234567891" /*
    *constructor-arg value="Nokia" /*
*/bean*
*bean id="mobileService3" class="com.infosys.MobileService" *
        *property name="mobileNumber" value="1234642323" /*
        *property name="model" value="Nokia" /* 
*/bean*

Choose the RIGHT options. Choose two options.

• Spring does not allow both constructor and setter injection together in the configuration
• Code works fine, it is allowed to use constructor and setter injection together based on need.
• It is mandatory to define default constructor explicitly in this code example as there exists a parameterized constructor
• In mobileService3 bean definition, it is optional to specify name attribute in the property tag.

Q4 of 4 Consider the class given below:

package com.infosys.service;
public class BookService { 
       private List bookRepositories;
        //constructors
        //setter and getter methods
 }

Choose the RIGHT approach to define bookService bean from the options given below? Choose 3 options.

a) Assume bookRepository1 and bookRepository2 bean definitions are available

*bean id="bookService" class = "com.infosys.service.BookService"*
 *property name="bookRepositories"*
     *list*
                     */list*
  */property* 
*/bean*

 b)Assume BookRepository is present in com.infosys.repository package

*bean id="bookService" class = "com.infosys.service.BookService"*
 *property name="bookRepositories"*
     *list*
        *bean id ="bookRepository1"  class = "com.infosys.repository.BookRepository/*
        *bean id ="bookRepository2" class = "com.infosys.repository.BookRepository/*
     */list* 
  */property* 
*/bean

c) Spring provides support for all the collection types such as List, Set, Map

d) Spring does not support collection in the bean definition

Exercise : Setter Injection

ProblemStatement 1:

Consider the Constructor Injection Exercise solution implemented for Employee scenario.

Now, as part of this exercise

• Use setter injection for initializing the required bean dependencies in the Spring configuration

Summary: In this exercise,

• You have learned how to implement setter injection to initialize the dependencies

ProblemStatement 2 : 

Consider the previous exercise solution implemented for Employee application.

As part of this exercise, update Spring configuration for the following

• Use setter injection for initializing loanService bean dependency
• Use constructor injection for initializing employeeService bean dependencies

Summary: In this exercise,

• You have learn how to implement both construct injection and setter injection to initialize the dependencies

Exercise : Constructor And Setter Injection

ProblemStatement:

Consider the previous exercise solution implemented for Employee application.

As part of this exercise, update Spring configuration for the following

• Use setter injection for initializing loanService bean dependency
• Use constructor injection for initializing employeeService bean dependencies

Summary: In this exercise,

• You have learned how to implement both construct injection and setter injection to initialize the dependencies

Comparison Constructor Injection and Setter Injection

Constructor Injection	Setter Injection
Dependency Injection is through parameterized constructor	Dependency Injection is through setter methods after invoking the default constructor
Need parameterized constructor in the POJO class	Need default constructor and setter methods in the POJO class
tag is used in configuration file	tag is used in configuration file
tag "ref" attribute is used to provide dependency for Object type	tag "ref" attribute is used to provide dependency for Object type
Preferred for mandatory dependencies Immutable dependencies concise(pass several parameters once)	optional / changeable dependencies circular dependencies

Analyze : Dependency Injection

ProblemStatement:

Consider the below given GreetingService class which is having dependency on GreetingUtil bean. 

package com.infosys.service;
public class GreetingService {
    /** The greetingUtil reference. */
    private GreetingUtil greetingUtil;
    /** Default Constructor */
    public GreetingService() {
        System.out.println("GreetingService: Default constructor");
    }
  /** Parameterized contructor */
    public GreetingService(GreetingUtil greetingUtil) {
        this.greetingUtil = greetingUtil;
        System.out.println("GreetingService: Parameterized constructor");
    }
  public GreetingUtil getGreetingUtil() {
        return greetingUtil;
    }
 /** Setter method */
    public void setGreetingUtil(GreetingUtil greetingUtil) {
        this.greetingUtil = greetingUtil;        
        System.out.println("GreetingService: Setter Method");
    }
}

Following is the GreetingUtil class which provides greeting details.

package com.infosys.util;
public class GreetingUtil{    
    private String greeting = "Hi, Welcome to Spring!!";   
    public GreetingUtil() {
           System.out.println("GreetingUtil: Default Constructor");
    } 
   public String getGreeting(){  
           return greeting;
   }            
}

Following is the configuration:

*!--Bean definitions --*
*bean id="greetingUtil" class="com.infosys.util.GreetingUtil" /*                   // Bean Definition1
*bean id="greetingService1" class="com.infosys.service.GreetingService" /*         // Bean Definition2
*bean id="greetingService2" class="com.infosys.service.GreetingService"*           // Bean Definition3
    *constructor-arg ref="greetingUtil" /*  
*/bean*
*bean id="greetingService3" class="com.infosys.service.GreetingService" *          // Bean Definition4 
        *property name="greetingUtil" ref="greetingUtil" /*      
*/bean*

Analyze the above code to understand why above application execution displays following on the console for the above bean definitions.

Bean Definition1 --> GreetingUtil: Default Constructor

Bean Definition2 --> GreetingService: Default constructor

Bean Definition3 --> GreetingService: Parameterized constructor

Bean Definition4 --> GreetingService: Default constructor

GreetingService: Setter Method

Let us analyze the result of the previous tryout. 

• Bean Definition1 --> GreetingUtil: Default ConstructorGreetingUtil: Default Constructor

For below kind of bean definitions:

id="greetingUtil" class="com.infosys.util.GreetingUtil" />    // Bean Definition1

This bean instantiation internally invokes default constructor of GreetingUtil class for creating and initializing default values.

Below is the equivalent Java code of above-given bean definition.

GreetingUtil greetingUtil = new GreetingUtil();

• Bean Definition2 --> GreetingService: Default constructor

id="greetingService1" class ="com.infosys.service.GreetingService" />   // Bean Definition2

This bean instantiation also uses default constructor and hence default constructor or GreetingService class has been invoked.

Below is the equivalent Java code of above-given bean definition.

GreetingService greetingService1 = new GreetingService();

• Bean Definition3 --> GreetingService: Parameterized constructor

For below kind of bean definitions:

  bean id="greetingService2" class="com.infosys.service.GreetingService">           // Bean Definition3
     ref="greetingUtil" />   bean/

• It is not required to specify all the properties values while defining bean in the configuration. For non-primitive properties we can use the Autowiring feature.
• If Autowiring is enabled, Spring container automatically initializes the dependencies of that bean.
• There is no need to provide explicit property or constructor-arg with ref tags in the bean definition for object dependencies.
• Autowiring cannot be used to inject primitive and string values.

• no (no autowiring)
• byName
• byType
• constructor

package com.infosys.demo;


public class ReportService {


        private ReportGenerator master;


        private int recordsPerPage;


    ---------------------------


}

• Define bean of ReportGenerator with id same as property name (Here it is "master" in the above class)
• Mention an attribute autowire value "byName" in the reportService bean definition as shown below.

*bean id="reportService" class="com.infosys.demo.ReportService"autowire="byName"*
                *property name="recordsPerPage" value="500" /*
*/bean*        
*bean id="master" class="com.infosys.demo.PDFReportGenerator" /*

public class Client {
public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
        ReportService srv = (ReportService)context.getBean("reportService");
        srv.generateReport();
    }
}

Setter Method of RecordsPerPage Property
Setter Method of master Property
Generated PDF Report with 500 records

• You have learn that bean id as to be same as property name for wiring the dependency byName.

Consider the following classes defined in a Spring application:

package com.infosys.service;
public class MobileService {
    private String mobileName;
    public MobileService() {    }
    //getter and setter methods
}

package com.infosys.service;
public class PersonService {
     private MobileService mob;
       //getter and setter methods
}

The Spring configuration file includes the following declarations:

bean id="mobileService" class="com.infosys.service.MobileService"
      property name="mobileName" value="Nokia"/
/bean
bean id="personService" class="com.infosys.service.PersonService" autowire="byName" /

The main method for the application is defined as follows:

ApplicationContext ac= new ClassPathXmlApplicationContext(“config.xml");
PersonService p1= (PersonService) ac.getBean("personService");
System.out.println("I have : "+p1.getMob().getMobileName());

Ans : throws null pointer exception

package com.infosys.demo;
public class ReportService {
        private ReportGenerator master;
        private int recordsPerPage;
        ------------------------------
}

• Define bean of ReportGenerator with any bean id
• Mention an attribute autowire value "byType" in the reportService bean definition as shown below.

*bean id="reportService" class="com.infosys.demo.ReportService" autowire="byType"*
   *property name="recordsPerPage" value= "500"/*
*/bean*

*bean id="htmlReportGenerator" class="com.infosys.demo.HTMLReportGenerator" /*

Consider the following classes defined in a Spring Application:

package com.infosys.service;
public class MobileService {
    private String mobileName;
    public MobileService() {    }
    //getter and setter methods
}

package com.infosys.service;
public class PersonService {
            private MobileService mob;
           //getter and setter methods
}

The Spring configuration file includes the following declarations:

*bean id="mobileService1" class="com.infosys.service.MobileService"*
       *property name="mobileName" value="Nokia"/*
*/bean*
*bean id="mobileService2" class="com.infosys.service.MobileService"*
       *property name="mobileName" value="Samsung"/*
*/bean*
*bean id="personService" class="com.infosys.service.PersonService" autowire="byType" /*

The main method for the application is defined as follows:

ApplicationContext ac= new ClassPathXmlApplicationContext(“config.xml");
PersonService p1= (PersonService) ac.getBean("personService");
System.out.println("I have : "+p1.getMob().getMobileName());

1. Modify the ReportGenerator reference name from "master" to "reportGenerator" in ReportService class.

• You have learned that bean id can be different from property name for wiring dependency using byType
• There has to be single bean of the required type in the container for byType autowiring

package com.infosys.demo;
public class ReportService {
        private ReportGenerator master;
        private int recordsPerPage;

        public ReportService(ReportGenerator master, int recordsPerPage) {
                this.master = master;
                this.recordsPerPage = recordsPerPage;
        }

        public ReportService() {
                
        }
        -------------------------------
        ---------------------------------
}

• Define bean of ReportGenerator with any bean id
• Mention an attribute autowire with value "constructor" in the reportService bean definition as shown below.

*bean id="reportService" class="com.infosys.demo.ReportService" autowire="constructor"*
     *constructor-arg name="recordsPerPage" value= "500"/*
   */bean*
   *bean id="pdfReportGenerator" class="com.infosys.demo.PDFReportGenerator"/*

package com.infosys.service;
public class MobileService {
    private String mobileName;
    public MobileService() {    }
    public String getMobileName() {
         return mobileName;
     }
    public void setMobileName(String mname) {
        this.mobileName = mname;  
     }
}

package com.infosys.service;
public class PersonService {
         private MobileService mob;
         public PersonService() {
                   System.out.println("Person: Default Constructor");
         }
         public PersonService(MobileService mob) {
                   System.out.println("Person: Parameterized Constructor");
                   this.mob = mob;
         }
         public MobileService getMob() {
                    return mob;
         }
         public void setMob(MobileService mob) {
                   this.mob = mob;
         }
}

The Spring configuration file includes the following declarations:      

*bean id="mobileService" class="com.infosys.service.MobileService"*
       *property name="mobileName" value="Nokia"/*
*/bean*
*bean id="personService" class="com.infosys.service.PersonService" autowire="constructor" /*

The main method for the application is defined as follows:

ApplicationContext ac= new ClassPathXmlApplicationContext(“config.xml");
PersonService p1= (PersonService) ac.getBean("personService");
System.out.println("I have : "+p1.getMob().getMobileName());

What is the output of the above code execution?

Person: Parameterized Constructor I have : Nokia

Explanation :

Accessing the mobileName property using PersonService instance is possible. It will return the mobileName value.As the autowiring is done by constructor, the default constructor is not called. The value of mobileName attribute is set to Nokia, and not null

package com.infosys.demo;
public class ReportService {
        private ReportGenerator master;
        private int recordsPerPage;
       ------------------------------------
}

bean id="reportService" class="com.infosys.demo.ReportService"  autowire="no"
                property name="master" ref="htmlGenerator" /
                property name="recordsPerPage" value="500" /
/bean
        
bean id="htmlReportGenerator"class="com.infosys.demo.HTMLReportGenerator" /

bean id="reportService" class="com.infosys.demo.ReportService"
                property name="master" ref="htmlGenerator" /
                property name="recordsPerPage" value="500" /
/bean