Inversion of Control

IoC is also known as dependency injection (DI). It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injects those dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control.

Container overview

The interface org.springframework.context.ApplicationContext represents the Spring IoC container and is responsible for instantiating, configuring, and assembling the aforementioned beans. Several implementations of the ApplicationContext interface are supplied out-of-the-box with Spring. In standalone applications it is common to create an instance of ClassPathXmlApplicationContext or FileSystemXmlApplicationContext.

The following diagram is a high-level view of how Spring works. Your application classes are combined with configuration metadata so that after the ApplicationContext is created and initialized, you have a fully configured and executable system or application.

The Spring IoC container

Configuration metadata:
As the preceding diagram shows, the Spring IoC container consumes a form of configuration metadata; this configuration metadata represents how you as an application developer tell the Spring container to instantiate, configure, and assemble the objects in your application.Configuration metadata is traditionally supplied in a simple and intuitive XML format, which is what most of this chapter uses to convey key concepts and features of the Spring IoC container.

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="..." class="..  </bean> <bean id="..." class="...">  </bean> </beans>
Program Sim Interface class
public interface Sim {   void calling(); void data(); }

Class Jio
public class Jio implements Sim {
@Override
public void calling() {
System.out.println(" calling using Jio sim");
}
   @Override
public void data() {
System.out.println(" browsing usin Jio sim");}
}
}
Class Airtel
public class Airtel implements Sim{
@Override
public void calling() {
System.out.println(" calling using Airtel sim");
}
@Override
public void data() {
System.out.println("browsing using Airtel sim"); }
}
}

class Mobile

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Mobile {

public static void main(String[] args){

ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");

System.out.println("Configure loaded");

Sim sim=(Sim) context.getBean("Sim", Sim.class);

sim.calling();

sim.data(); }

}

OUTPT//

Configure loaded

Calling using Airtel sim

Browsing using Airtel sim}

XML file

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</bean>

</beans>