Vor kurzem habe ich einen Artikel zum Ausführen der Web-API (Hatena Bookmark Entry Information Acquisition API) mit Retrofit + Gson erstellt.
Ich habe den Quellcode von Retrofit von github erhalten und die Implementierungsmethode untersucht, die die Verarbeitung des Web-API-Zugriffs durch einfaches Erstellen einer Schnittstelle ermöglicht.
Als Ergebnis stellte ich fest, dass ich die Proxy of Reflection-API verwende.
Es gibt möglicherweise nicht viele Fälle, in denen Proxy bei der Implementierung der Anwendung verwendet wird, da die Verarbeitung redundant ist / die Sichtbarkeit schlecht wird, aber ich dachte, dass dies eine interessante Verwendung war.
Retrofit ist eine Android-App (Java), eine Open-Source-Bibliothek für den einfachen Zugriff auf Web-APIs (JSON-Daten). Verwendung in Kombination mit JSON-Datenkonvertierungsbibliotheken (Gson, Jackson usw.).
Der Web-API-Ausführungsprozess wird durch das folgende Verfahren implementiert.
Implementieren Sie zunächst die Schnittstelle für die API. Die folgende Oberfläche ist ein Beispiel für die Hatena Bookmark Entry Information Acquisition API.
// HatenaApiInterface.java
public interface HatenaApiInterface {
String END_POINT = "http://b.hatena.ne.jp";
String TARGET_URL = "http://b.hatena.ne.jp/ctop/it";
//API zur Erfassung von Hatena-Lesezeicheneintragsinformationen
// http://developer.hatena.ne.jp/ja/documents/bookmark/apis/getinfo
@GET("/entry/jsonlite/")
Call<BookmarkEntry> getBookmarkEntry(@Query("url") String target);
}
Die folgende URL ist die URL der Hatena Bookmark Entry Information Acquisition API (GET) in Bezug auf Technologie. Wobei URL ein Argument ist, das die Kategorie angibt. Die Spezifikationen der API zur Erfassung von Hatena-Lesezeicheneinträgen finden Sie unter hier.
http://b.hatena.ne.jp/entry/jsonlite/?url=http%3A%2F%2Fb.hatena.ne.jp%2Fctop%2Fit
Beschreiben Sie die Informationen, die diese URL in der Benutzeroberfläche generieren können.
Der Endpunkt ist die Stamm-URL der Web-API. Wird beim Erstellen einer Instanz von Retrofit verwendet.
Der Methodenname ist beliebig.
Die Anmerkung (@GET) gibt an, dass Sie die GET-Methode verwenden und dass der relative Pfad der Web-API `/ entry / jsonlite /` lautet. Außerdem wird die Anmerkung (@Query) unten als Abfragezeichenfolge hinzugefügt.
Führen Sie die folgenden Schritte aus, um auf die Web-API zuzugreifen. (Haupt-) Implementierung in Aktivität usw.
//Instanz nachrüsten
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(HatenaApiInterface.END_POINT)
.addConverterFactory(GsonConverterFactory.create())
.build();
//Erstellen einer Schnittstelle für den Web-API-Zugriff
mApiInterface = retrofit.create(HatenaApiInterface.class);
//Web-API-Ausführungsinstanz(Schnittstelle)Bekommen.
Call<BookmarkEntry> call = mApiInterface.getBookmarkEntry(targetUrl);
//Führen Sie die Web-API aus
//Das Verarbeitungsergebnis wird durch den Rückruf benachrichtigt
call.enqueue(new Callback<BookmarkEntry>() {
@Override
public void onResponse(Call<BookmarkEntry> call, Response<BookmarkEntry> response) {
//Beschreibt den Prozess, wenn der Web-API-Zugriff erfolgreich ist
}
@Override
public void onFailure(Call<BookmarkEntry> call, Throwable t) {
//Beschreibt die Verarbeitung, wenn der Web-API-Zugriff fehlschlägt
}
});
Unten finden Sie die Quelle für Retrofit.create.
InvocationHandler wird mithilfe der Proxy of Reflection-API erstellt und zurückgegeben. Wenn Sie getBookmarkEntry der erfassten Schnittstelle (Instanz) ausführen, wird die Aufrufmethode ausgeführt. Der Methodenname getBookmarkEntry wird in der Argumentmethode und der String targetUrl in den Argumentargumenten gespeichert.
Verwenden Sie loadServiceMethod, um die dieser Methode zugeordneten Web-API-Zugriffsinformationen abzurufen. Fügen Sie eine weitere okHttp-Aufrufklasse hinzu und geben Sie die Adapterklasse zurück. Setzen Sie dies auf eine Variable vom Typ `` `Call
Führen Sie dann die Enqueque-Methode aus, um einen Web-API-Aufruf durchzuführen. Das Ergebnis kann durch Zurückrufen des Arguments erhalten werden.
public <T> T create(final Class<T> service) {
Utils.validateServiceInterface(service);
if (validateEagerly) {
eagerlyValidateMethods(service);
}
return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[] { service },
new InvocationHandler() {
private final Platform platform = Platform.get();
@Override public Object invoke(Object proxy, Method method, Object... args)
throws Throwable {
// If the method is a method from Object then defer to normal invocation.
if (method.getDeclaringClass() == Object.class) {
return method.invoke(this, args);
}
if (platform.isDefaultMethod(method)) {
return platform.invokeDefaultMethod(method, service, proxy, args);
}
ServiceMethod<Object, Object> serviceMethod =
(ServiceMethod<Object, Object>) loadServiceMethod(method);
OkHttpCall<Object> okHttpCall = new OkHttpCall<>(serviceMethod, args);
return serviceMethod.callAdapter.adapt(okHttpCall);
}
});
}
Erläutert die Verwendung der Proxy of Reflection-API. Sehen heißt glauben. Erstellen Sie TestInterface und TestProxy und versuchen Sie, TestProxy auszuführen. Sie können die obige Erklärung gut sehen.
Informationen zur Verwendung von Proxy finden Sie unter hier.
$ java TestProxy
$ cat TestInterface.java
public interface TestInterface {
public void doSomething();
}
$ cat TestProxy.java
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class TestProxy {
private Object proxy;
private TestProxy(Class<TestInterface> clazz) {
this.proxy = Proxy.newProxyInstance(clazz.getClassLoader(),
new Class[] { clazz },
new InvocationHandler() {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//Informationen zur Ausgabemethode
System.out.println("method: " + method);
return null;
}
});
}
public static TestInterface createProxy(Class<TestInterface> clazz) {
TestProxy obj = new TestProxy(clazz);
return clazz.cast(obj.proxy);
}
public static void main(String[] args) {
TestInterface someInterface = TestProxy.createProxy(TestInterface.class);
someInterface.doSomething();
}
}
Recommended Posts