Ok, DI, mi is az? Eloszor is egy wiki link:

https://en.wikipedia.org/wiki/Dependency_injection

Mi is ez?

A DI egy koncept, ami sok nyelvben megtalalhato, a DI egy olyan koncept, ami mogott az IOC all, Inversion Of Control. Gyakorlatilag egy osztalynak nem kellene statikusan konfiguralnia a fuggosegeit, hanem kivulrol letrehozni azokat.

Ha pl van egy java classunk, amiben van egy masik fuggoseg, mondjuk egy masik osztaly, azt class dependency-nek hivjuk. Idealisan az lenne a jo, ha az osztalyaink fuggetlenek lennenek egymastol, igy tesztelhetoek is. Alant van par pelda is errol.

Androidban vannak DI kontenerek/framework, amiket alkalmaznunk kellene. Errol egy masik postban lesz szo.

Fontosabb dolgok:

Without dependency injection

// An example without dependency injection
public class Client {
    // Internal reference to the service used by this client
    private Service service;

    // Constructor
    Client() {
        // Specify a specific implementation in the constructor instead of using dependency injection
        service = new ServiceExample();
    }

    // Method within this client that uses the services
    public String greet() {
        return "Hello " + service.getName();
    }
}


Ezzel ugye az a baj, hogy a fuggoseg, a Client-en belul letrejon, a new

ServiceExample()-n keresztul. 


Tobb fajta dependency injection van, a lenyege, hogy a fuggo object-et ne 
peldanyositsuk itt, hanem ez kivulrol tortenhet meg.

Milyen modjai vannak? pl egy setter, ilyenkor viszont ha van egy masik metodusunk, ami hasznalja a peldanyositott cuccot konnyen elofordulhat, hogy ugye null-al ter vissza, ha nem a megfelelo sorrendben hivjuk meg a metodusait.

Ezt ki tudjuk vedeni a konstruktorban torteno inicializalassal. Illetve van interface-en keresztuli DI is.

Constructor injection

// Constructor
Client(Service service) {
    // Save the reference to the passed-in service inside this client
    this.service = service;
}

Setter injection

// Setter method
public void setService(Service service) {
    // Save the reference to the passed-in service inside this client
    this.service = service;
}

Interface injection

// Service setter interface.

public interface ServiceSetter {
    public void setService(Service service);
}

// Client class
public class Client implements ServiceSetter {
    // Internal reference to the service used by this client.
    private Service service;

    // Set the service that this client is to use.
    @Override
    public void setService(Service service) {
        this.service = service;
    }
}

Tehat valoszinuleg mindenki hasznalt mar ilyet, maximum nem tudta, 
hogy hogyan hivjak.:)

Bovebben meg lehet rola olvasni, de en most android kozelebol fogom megmutatni (a kovetkezo postban), eloszor egy videoval, ami a DI-t magyarazza el siman: