@Module
public class MyModule{
@Provides
String provideHelloWorld(){
return "Hello World";
}
}
dagger๋ ์ปดํ์ผ ํ์
์ ์์กด์ฑ ์ฃผ์
์ ํ์ํ ์ ๋
ธํ
์ด์
์ ์ฝ๊ณ ์์กด์ฑ ์ฃผ์
์ ํ์ํ ํด๋์ค ํ์ผ๋ค์ ์์ฑํ๋ค
Dagger๋ @Module๊ณผ @Provides ์ ๋
ธํ
์ด์
์ ์ฝ๊ณ ์์กด์ฑ ์ฃผ์
์ ํ์ํ ํ์ผ๋ค์ ์์ฑํ๋ค.
@Module : ์์กด์ฑ์ ์ ๊ณตํ๋ ํด๋์ค์ ๋ถ์ธ๋ค.
@Provides : ์์กด์ฑ์ ์ ๊ณตํ๋ ๋ฉ์๋์ ๋ถ์ธ๋ค.
MyModule ํด๋์ค ํ๋๋ง์ผ๋ก ๋ณ๋์ ํด๋์ค ํ์ผ์ด ์์ฑ๋์ง ์๋๋ค. ๋ชจ๋์ ์ฐธ์กฐํ๋ ์ปดํฌ๋ํธ๊ฐ ์๊ธฐ๋๋ฌธ์ด๋ค.
@Component(modules = MyModule.class)
public interface MyComponent{
String getString();
// ํ๋ก๋น์ ๋ฉ์๋, ๋ฐ์ธ๋๋ ๋ชจ๋๋ก๋ถํฐ ์์กด์ฑ์ ์ ๊ณต
}
@Component๊ฐ ๋ถ์ MyComponent์ธํฐํ์ด์ค ๋ด์์๋ Component๊ฐ ์ฐธ์กฐ๋ ๋ชจ๋ ํด๋์ค๋ก๋ถํฐ ์์กด์ฑ์ ์ ๊ณต๋ฐ๋๋ค.
๋ฐ์ธ๋๋ ๋ชจ๋๋ก๋ถํฐ ํด๋น ๋ฐํํ์ ๊ฐ๋ ๋ฉ์๋๋ฅผ ์ฐพ์ง ๋ชปํ๋ค๋ฉด ์ปดํ์ผ ํ์์ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
Dagger๋ ์ปดํ์ผ ํ์์ @Component๋ฅผ ๊ตฌํํ ํด๋์ค๋ฅผ ์์ฑํ๋๋ฐ ์ด๋ ํด๋์ค์ ์ด๋ฆ์ 'Dagger'๋ผ๋ ์ ๋์ด๊ฐ ๋ถ๋๋ค.
ex) MyComponent > DaggerMyComponent
public class ExampleUnitTest{
@Test
public void testHelloWorld(){
MyComponent myComponent = DaggerMyComponent.create();
System.out.println("result="+myComponent.getString());
}
}
๋ชจ๋์ ์ปดํฌ๋ํธ์ ์์กด์ฑ์ ์ ๊ณตํ๋ ์ญํ ์ ํ๋ค. @Module์ ํด๋์ค์ ๋ถ์ด๋ ๊ฒ์ผ๋ก ๊ฐ๋จํ ๋ชจ๋ ํด๋์ค๋ฅผ ๋ง๋ค์ ์๋ค.
๋ชจ๋ ํด๋์ค ๋ด์ ์ ์ธ๋๋ ๋ฉ์๋์๋ @Provides ์ ๋ ธํ ์ด์ ์ ๋ถ์ด๋๊ฒ์ผ๋ก ์ปดํ์ผ ํ์์ ์์กด์ฑ์ ์ ๊ณตํ๋ ๋ฐ์ธ๋๋ ํ๋ก๋ฐ์ด๋๋ฅผ ์์ฑํ๋ค
๋ฉ์๋์ ๋ฐํํ์ ๋ณด๊ณ ์ปดํฌ๋ํธ ๋ด์์ ์์กด์ฑ์ด ๊ด๋ฆฌ๋์ด ์ค๋ณต๋๋ ํ์ ์ด ํ๋์ ์ปดํฌ๋ํธ ๋ด์ ์กด์ฌํ๋ฉด ์๋๋ค.
ex) ์ปดํฌ๋ํธ ๋ด์ ๋์ผํ String ๋ฐํํ์ ๊ฐ๋ ๋ฉ์๋๊ฐ 2๊ฐ ์ด์ ์์ผ๋ฉด ์ปดํ์ผ ํ์์ ์๋ฌ ๋ฐ์ํ๋ค.
@Module
class DuplicationModule{
@Provides
String provideHelloWorld(){
return "hello World";
}
@Provides
String provideCharles(){
return "Charles"; // ๋์ผํ ํ์
์ด 2๊ฐ ์กด์ฌ ํ๋ฏ๋ก ์๋ฌ
}
}
์ปดํฌ๋ํธ ๋ด ๋ฐ์ธ๋๋ ๋ฉ์๋์ ๋ฐํํ์ @Provides ๋ฉ์๋์ ๋งค๊ฐ ๋ณ์๋ก ์ฌ์ฉํ ์ ์๋ค. ๋ค์ ์์ ๋ฅผ ๋ณด์
@Module
public class MyModule{
@Provides
String provideName(){// ์ด๋ฆ ์ ๊ณต
return "Charles";
}
@Provides
int provideAge(){ // ๋์ด ์ ๊ณต
return 100;
}
@Provides
Person providePerson(String name,int age){//์ด๋ฆ ,๋์ด ์ ๊ณต๋ฐ์
return new Person(name,age);// name=Charles, age = 100
}
}
๋งค๊ฐ๋ณ์ ํ์ ์ ๋ง๋ ์์กด์ฑ์ด ์ปดํฌ๋ํธ ๋๋ ์ปดํฌ๋ํธ์ ๋ฐ์ธ๋๋ ๋ชจ๋์ ์๋ค๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
๋ชจ๋ ํด๋์ค๊ฐ ์ถ์ํด๋์ค์ธ ๊ฒฝ์ฐ @Provices ๋ฉ์๋๋ static ๋ฉ์๋์ฌ์ผ ํ๋ค
@Module
public abstract class MyModule{
@Provides
static String provideName(){
return "Charles";
}
}
@Provides ๋ฉ์๋๋ Null์ ๋ฐํํ๋ ๊ฒ์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ํํ๋ค. @provides ๋ฉ์๋์ ๋ฐํ ๊ฐ์ null ์ธ๊ฒ์ ๋ช ์์ ์ผ๋ก ํ์ฉํ๋ ค๋ฉด @Nullable์ ์ถ๊ฐํด์ผ ํ๋ค.
@Provides ๋ฉ์๋์ @Nullable์ด ๋ถ์๋ค๋ฉด ์์กด์ฑ์ ์ฃผ์ ๋ฐ๋ ๋ถ๋ถ์๋ ๋ง์ฐฌ๊ฐ์ง๋ก @Nullable์ ๋ถ์ฌ์ผ ํ๋ค.
@Module
public class MyModule{
...
@Provides
@Nullable// Null ์ ๋ฐํํ ๊ฐ๋ฅ์ฑ์ด ์๋๊ฒฝ์ฐ
Integer provideInteger(){
return null;
}
}
@Component(modules = MyModule.class)
public class MyComponent{
@Nullable// ์ด ์ ๋
ธํ
์ด์
์ด ์์ผ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ๋ค.
Integer provideInteger();
}
@Module ์ ๋ ธํ ์ด์ ์ด ๊ฐ์ง ์ ์๋ ์์ฑ์ค includes ๋ผ๋ ๊ฒ์ด ์๋ค. includes์ ๋ค๋ฅธ ๋ชจ๋ ํด๋์ค๋ค์ ๋ฐฐ์ด์ ์ ์ํ๋ ๊ฒ๋ง์ผ๋ก @Provides ๋ฉ์๋์ ์์์ด ๊ฐ๋ฅํ๋ค
Ex)Module A ์ Module B๊ฐ ์กด์ฌํ๊ณ Module B ๊ฐ Module A ๋ฅผ ์์ํ๋ ์ฝ๋๋ ์๋์ ๊ฐ๋ค
@Module
public class ModuleA{
@Provides
A ProvieA(){
return new A();
}
}
@Module(includes = ModuleA.class)
public class ModuleB{
@Provides
B ProvideB(){
return new B();
}
}
์ปดํฌ๋ํธ๋ฅผ ์ ์ธํ ๋ ModuleB๋ฅผ ์ฐธ์กฐํ๋ ๊ฒฝ์ฐ ModuleA๋ฅผ ์์ํด A ํ์ ์ ๊ฐ์ฒด๋ ๋ฐ์ธ๋ฉ ๋๋ค.
์ฃผ์ํด์ผ ํ ์ ์ ์ค๋ณต๋๋ ํ์ ์ด ์กด์ฌํ๋ค๋ฉด ์๋๋ค.