what is the difference between using or not Spring Beans?

Question

Probably i'll get a lot of downvotes, but it's so confusing for me all this fact of whether use beans or not. Lets suppose this example

interface ICurrency {
       String getSymbol();
}


public class CurrencyProcessor {

    private ICurrency currency ;

    public CurrencyProcessor(ICurrency currency) {
        this.currency = currency;
    }

    public void doOperation(){
        String symbol = currency.getSymbol();
        System.out.println("Doing process with " + symbol + " currency");
        // Some process...
    }

}

So, to inject the ICurrency impl injection i think that i can do it by two ways:

---

Way 1: Without Spring beans

public class CurrencyOperator {

    private ICurrency currency ;
    private CurrencyProcessor processor;

    public void operateDefault(){
        currency = new USDollarCurrency();
        processor = new CurrencyProcessor(currency)
        this.processor.doOperation();
    }

}

Where USDollarCurrency is an ICurrency interface implementation

---

Way 2: Using Spring beans

@ContextConfiguration(classes = CurrencyConfig.class)
public class CurrencyOperator {

    @Autowired private ICurrency currency ;
    @Autowired private CurrencyProcessor processor;

    public void operateDefault(){
        this.processor.doOperation();
    }

}

@Configuration
public class CurrencyConfig {

    @Bean
    public CurrencyProcessor currencyProcessor() {
        return new CurrencyProcessor(currency());
    }

    @Bean
    public ICurrency currency() {
        return new USDollarCurrency();
}

---

I really don't understand what would be the benefits of using Spring's beans. I read some things but what i most found was about the benefits of using DI, and as i understand, both ways are injecting the dependency that CurrencyProcessor require, what is changing is the way that i am creating and using objets, am i wrong? So in concrete, my questions are: 1. What are the benefits of using Beans at this case? 2. Why should i use Spring instead of doing it manually like first way? 3. Talking about performance, which of this cases is better?

Answer 1

Suppose you have 2 DAO classes one for Oracle, the seconde for MySQL, and both classes are implementing a DAO interface. You define an implementation as a bean in Spring configuration file. In the business class you have an attribut of type DAO, while in the spring configuration file you choose the real type wheather Oracle or MySQL to inject or using spring annotation @Autowired

This reduce coupling and it will be easy to move from Oracle to MySQL.

@Service
public class Business {
    @Autowired
    private Dao daoImpl;

    //Business methods that invoks Dao methods 
}

In the Spring configuration file (XML file) you use the following:

<bean id="daoImpl" class="app.com.MySQLDaoImpl OR app.com.OracleDaoImpl"/>

By just changing the class attribut of your bean you change the whole implementation, without any change in your business class !
Good luck.

Answer 2

Your example without Spring doesn't dependency injection! With dependency injection, the actual implementation of the interface is determined outside the code itself in order to reduce the coupling!

You should be able to need another implementation (you could for example switch from one JMS client to another...).

To answer to your last question, using Spring is (a very little bit) less performant but much more flexible.

EDIT : Spring is not the only tool that can be used for DI but it is the most popular and it contains a lot of features. Note that many Java standards also (such as JPA) use DI.