Dolch2 Es ist schwierig. Da die Einführung schwierig war, fasste ich den Einführungsteil vorerst kurz zusammen und verwendete verschiedene Websites als Hinweise. Dieser Blog verwendet @Inject, @Module, @Provide, @Component, Ich möchte so klar wie möglich schreiben, bis ich Abhängigkeiten einspringe und Funktionen umschalte. Aus irgendeinem Grund habe ich mich diesmal für Java entschieden.
"Kompilierungszeit-Framework für Abhängigkeitsinjektion", entwickelt von Google Einfach ausgedrückt, wenn Sie eine Instanz einer anderen Klasse in einer Klasse erstellen, Da es schwierig wird, jede Klasse zu testen, Wechseln Sie zu einer Methode namens Abhängigkeitsinjektion, die zur Kompilierungszeit eine Instanz erstellt und injiziert. Zur einfacheren Wartung und zum Testen.
・ [Offiziell] GitHub https://github.com/google/dagger ・ [Offizielles] Benutzerhandbuch https://google.github.io/dagger/users-guide.html ・ Einführung in Dolch2 (2.11), die sehr einfach zu verstehen ist ――Es ist unglaublich einfach zu verstehen! https://qiita.com/m-dove/items/767c4bfaeee53caefc4d ・ Ich verstehe das (ich glaube ich verstehe)! Dolch 2
[\ 1 ] Beispiel vor Verwendung von Dagger2 [Probenabhängige Injektion mit \ 2 ] @Inject, @Component [Beispiel zum Wechseln des Injektionsinhalts mit \ 3 ] @Module, @Provide
Dies ist ein einfaches Beispiel. Erstellen Sie eine Instanz von Fortune Machine mit MainActivity. Dadurch wird eine Instanz von TwiterClient im FortuneMachine-Konstruktor erstellt. Wenn Sie checkFortune of FortuneMachine aufrufen, ziehen Sie nach dem Zufallsprinzip eine Lotterie. Mit postData von TwitterClient auf Twitter posten. (Der auf Twitter gepostete Teil ist kaputt, spucke einfach das Protokoll aus) Für alle Fälle wird die Zeichenfolge auch an MainActivity zurückgegeben.
MainActivity.java
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
FortuneMachine fortuneMachine = new FortuneMachine();
Log.w( "DEBUG_DATA", "result = " + fortuneMachine.checkFortune());
}
}
FortuneMachine.java
public class FortuneMachine {
TwiterClient twiterClient;
String[] fortunes = {"Daikichi","Nakayoshi","Kokichi","Schlecht","大Schlecht"};
public FortuneMachine(){
//Erstellen Sie eine Instanz von TwiterClient
twiterClient = new TwiterClient();
}
public String checkFortune(){
int no = getRandomNo();
twiterClient.postData(fortunes[no]);
return fortunes[no];
}
public int getRandomNo(){
Random r = new Random();
int n = r.nextInt(fortunes.length);
return n;
}
}
TwitterClient.java
public class TwiterClient {
public TwiterClient(){
}
public boolean postData(String fortune){
//Kommunikationsverarbeitung zu Twitter
Log.w("DEBUG_DATA","postData " + fortune);
return true;
}
}
Mit diesem Programm veröffentlicht der Twitter-Client jedes Mal, wenn Sie Fortune Machine testen, Daten, und Sie müssen beim Erweitern vorsichtig sein. Verwenden wir also Dagger2, um den Twitter-Client in die Fortune Machine zu injizieren.
[app]build.gradle
implementation "com.google.dagger:dagger:2.11"
implementation "com.google.dagger:dagger-android-support:2.11"
annotationProcessor "com.google.dagger:dagger-android-processor:2.11"
annotationProcessor "com.google.dagger:dagger-compiler:2.11"
MainActivity.java
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//FortuneMachine fortuneMachine = new FortuneMachine();
Machine fortuneMachine = DaggerMainActivity_Machine.create();
String result = fortuneMachine.maker().checkFortune();
Log.w( "DEBUG_DATA", "result = " + result);
}
//Beschreiben Sie die abhängigen Objekte in Dagger2
@Component
interface Machine{
FortuneMachine maker();
}
}
FortuneMachine.java
public class FortuneMachine {
//Dies ist die gleiche Behandlung wie Neu
@Inject
TwiterClient twiterClient;
String[] fortunes = {"Daikichi","Nakayoshi","Kokichi","Schlecht","大Schlecht"};
//Auch für Konstrukteure erforderlich
@Inject
public FortuneMachine(){
// twiterClient = new TwiterClient();
}
public String checkFortune(){
int no = getRandomNo();
twiterClient.postData(fortunes[no]);
return fortunes[no];
}
public int getRandomNo(){
Random r = new Random();
int n = r.nextInt(fortunes.length);
return n;
}
}
TwitterClient.java
public class TwitterClient {
//Auch für Konstrukteure erforderlich
@Inject
public TwitterClient(){
}
public boolean postData(String fortune){
//Kommunikationsverarbeitung zu Twitter
Log.w("DEBUG_DATA","postData " + fortune);
return true;
}
}
Build.gradle wurden Einstellungen für die Verwendung von Dagger2 hinzugefügt.
Der Teil, der eine Instanz von TwiterClient in FortuneMachine erstellt, ist ------------------------------- @Inject TwiterClient twitter ------------------------------- Es ist geworden. Die Konstruktoren Fortune Machine und Twitter Client verfügen ebenfalls über @Inject.
Dies ist eine Regel, die an die Variable der Instanz angehängt wird, die Sie durch Abhängigkeitsinjektion erstellen möchten, und an den Konstruktor, der verwaltet wird. (Komplizierte Regeln an dieser Stelle)
In der Hauptaktivität ------------------------------- @Component interface Machine{ FortuneMachine maker(); } ------------------------------- Wurde hinzugefügt Instanzerstellung ------------------------------- Machine fortuneMachine = DaggerMainActivity_Machine.create(); ------------------------------- Es hat sich geändert zu.
In @Component werden die Abhängigkeiten unter der Kontrolle von Dagger2 zusammengestellt. (Umfassendes Management?) Sie können maker () frei ändern, müssen sich aber das Format merken. Sobald Sie dies schreiben und kompilieren, DaggerMainActivity_Machine implements MainActivity.Machine Eine Datei mit der geschriebenen Klasse wird angezeigt. (Details sind in \ [Einführung in Dolch2 (2.11), was sehr einfach zu verstehen ist ] in der Referenz-URL beschrieben.) Sie müssen sich an die Regel Dagger [Klassenname] _ [Schnittstellenname] erinnern, die automatisch generiert wird ...
Fügen Sie .create () hinzu, um diese Instanz abzurufen.
Jetzt ist der Twitter-Client in Fortune Machine nicht neu. Der extern instanziierte soll in die Fortune Machine injiziert werden.
Wie Sie bisher sehen können, gibt es trotz der Schwierigkeiten fast keinen Verdienst! !! Lassen Sie uns jedoch studieren, denn es wird praktisch sein, wenn wir es von nun an entwickeln: Frosch:
Was ich tun möchte, ist, dass Sie steuern können, was Sie injizieren, und festlegen können, ob Sie auf Twitter oder Facebook hochladen möchten, ohne sich mit Fortune Machine herumschlagen zu müssen.
Kurz gesagt, ich habe einige Schnittstellen erstellt und implementiert. Lassen Sie uns den Inhalt in einer Klasse namens FortuneModuel verwalten und @Component beibringen, der sich in der allgemeinen Verwaltung befindet.
[app]build.gradle
Das gleiche wie oben
MainActivity.java
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//FortuneMachine fortuneMachine = new FortuneMachine();
Machine fortuneMachine;
// fortuneMachine = DaggerMainActivity_Machine.create();
fortuneMachine = DaggerMainActivity_Machine.builder()
.fortuneModule(new FortuneModule())
.build();
String result = fortuneMachine.maker().checkFortune();
Log.w( "DEBUG_DATA", "result = " + result);
}
//Beschreiben Sie die abhängigen Objekte in Dagger2
//Beschreiben Sie das zu verwendende Modul
@Component(modules = FortuneModule.class)
interface Machine{
FortuneMachine maker();
}
}
FortuneMachine.java
public class FortuneMachine {
//Dies ist die gleiche Behandlung wie Neu
@Inject
Client clinet;
String[] fortunes = {"Daikichi","Nakayoshi","Kokichi","Schlecht","大Schlecht"};
//Auch für Konstrukteure erforderlich
@Inject
public FortuneMachine(){
}
public String checkFortune(){
int no = getRandomNo();
clinet.postData(fortunes[no]);
return fortunes[no];
}
public int getRandomNo(){
Random r = new Random();
int n = r.nextInt(fortunes.length);
return n;
}
}
Client.java
public interface Client {
boolean postData(String fortune);
}
TwitterClient.java
public class TwitterClient implements Client{
//Auch für Konstrukteure erforderlich
@Inject
public TwitterClient(){
}
public boolean postData(String fortune){
//Kommunikationsverarbeitung zu Twitter
Log.w("DEBUG_DATA","postTwitter " + fortune);
return true;
}
}
FacebookClient.java
public class FacebookClient implements Client {
//Auch für Konstrukteure erforderlich
@Inject
public FacebookClient(){
}
public boolean postData(String fortune){
//Kommunikationsverarbeitung zu Facebook
Log.w("DEBUG_DATA","postFacebook" + fortune);
return true;
}
}
FortuneModule.java
//Klasse, die liefert, was injiziert wird
// ...Nennen Sie es Modul
@Module
public class FortuneModule {
//Geben Sie an, was injiziert wird
// provide...Benennen
@Provides
static Client provideClient(){
return new FacebookClient();
}
}
Erstellen Sie einen Client mit öffentlicher Schnittstelle. TwitterClient und FacebookClient haben dies geerbt, Sie können @Inject of FortuneMachine in Clinet definieren und den Wert erhalten.
Erstellen Sie ein Fortune-Modul der öffentlichen Klasse. @Provides ist an die Funktion angehängt, die verwaltet, was für @Inject bereitgestellt wird. @Module ist an die Klasse angehängt, die @Provides zusammenfügt. In der Referenz-URL \ [Ich verstehe das (ich glaube ich verstehe)! Dolch 2 ] ---------------------------------------- Wenn @Inject eine Tankstelle für Autos ist, ist @Module eine Tankstelle und @Provides eine auf dem Stand installierte Tankmaschine. ---------------------------------------- Die Analogie ist ausgezeichnet.
@Component of MainActivity wurde eine Moduleinstellung hinzugefügt. ---------------------------------------- @Component(modules = FortuneModule.class) ---------------------------------------- Außerdem wurde die Methode zum Erstellen einer Instanz von DaggerMainActivity_Machine in die vom Modul angegebene Version geändert. ---------------------------------------- fortuneMachine = DaggerMainActivity_Machine.builder() .fortuneModule(new FortuneModule()) .build(); ---------------------------------------- Es gibt eine Funktion namens FortuneModule, aber ich frage mich, ob sie automatisch generiert wird.
Ändern Sie jetzt einfach den Wert von FoturneModule Sie können festlegen, welcher Client verwendet werden soll, Moc festlegen und testen.
Um klar zu sein, gibt es zu viele Manieren und Mysterienregeln. Es ist fast kein Vorteil, diese Quellenstufe zu verwenden. Sie sollten mit einer if-Anweisung genauso wechseln wie mit Instanzen! ?? Die Beispielquelle von Google enthält jedoch Dagger, daher kann ich nicht anders, als es zu verstehen ... Es scheint praktisch, es mit ViewModel zu verwenden, also diesmal.