Il n'y a pas longtemps, j'ai créé un article sur la façon d'exécuter l'API Web (Hatena Bookmark Entry Information Acquisition API) en utilisant Retrofit + Gson.
J'ai obtenu le code source de Retrofit de github et j'ai étudié la méthode d'implémentation qui permet le traitement d'accès à l'API Web simplement en créant une interface.
En conséquence, j'ai constaté que j'utilisais l'API Proxy of Reflect.
Comme le traitement est redondant / la visibilité se détériore, il se peut qu'il n'y ait pas beaucoup de cas où Proxy est utilisé dans la mise en œuvre de l'application, mais j'ai pensé que c'était une utilisation intéressante.
Retrofit est une application Android (Java), une bibliothèque open source pour un accès facile aux API Web (données json). À utiliser en combinaison avec les bibliothèques de conversion de données json (gson, jackson, etc.).
Le processus d'exécution de l'API Web est implémenté par la procédure suivante.
Tout d'abord, implémentez l'interface pour l'API. L'interface suivante est un exemple de l'API d'acquisition d'informations d'entrée de signets Hatena.
// HatenaApiInterface.java
public interface HatenaApiInterface {
String END_POINT = "http://b.hatena.ne.jp";
String TARGET_URL = "http://b.hatena.ne.jp/ctop/it";
//API d'acquisition d'informations d'entrée de signets Hatena
// http://developer.hatena.ne.jp/ja/documents/bookmark/apis/getinfo
@GET("/entry/jsonlite/")
Call<BookmarkEntry> getBookmarkEntry(@Query("url") String target);
}
L'URL suivante est l'URL de l'API d'acquisition d'informations d'entrée de signets Hatena (GET) liée à la technologie. Où url est un argument qui indique la catégorie. Veuillez consulter ici pour les spécifications de l'API d'acquisition d'informations d'entrée de signets Hatena.
http://b.hatena.ne.jp/entry/jsonlite/?url=http%3A%2F%2Fb.hatena.ne.jp%2Fctop%2Fit
Décrivez les informations qui peuvent générer cette URL dans l'interface.
Le point de terminaison est l'URL racine de l'API Web. Utilisé lors de la création d'une instance de Retrofit.
Le nom de la méthode est arbitraire. L'annotation (@GET) indique que vous utilisez la méthode GET et que le chemin relatif de l'API Web est `` / entry / jsonlite / ''. En outre, l'annotation (@Query) est ajoutée en tant que chaîne de requête ci-dessous?
Suivez les étapes ci-dessous pour accéder à l'API Web. (Principal) Mettre en œuvre dans l'activité, etc.
//Création d'instances de modernisation
Retrofit retrofit = new Retrofit.Builder()
.baseUrl(HatenaApiInterface.END_POINT)
.addConverterFactory(GsonConverterFactory.create())
.build();
//Création d'une interface pour l'accès à l'API Web
mApiInterface = retrofit.create(HatenaApiInterface.class);
//Instance d'exécution de l'API Web(interface)Obtenir.
Call<BookmarkEntry> call = mApiInterface.getBookmarkEntry(targetUrl);
//Exécutez l'API Web
//Le résultat du traitement est notifié par l'appel de rappel
call.enqueue(new Callback<BookmarkEntry>() {
@Override
public void onResponse(Call<BookmarkEntry> call, Response<BookmarkEntry> response) {
//Décrit le processus lorsque l'accès à l'API Web réussit
}
@Override
public void onFailure(Call<BookmarkEntry> call, Throwable t) {
//Décrit le traitement en cas d'échec de l'accès à l'API Web
}
});
Vous trouverez ci-dessous la source de Retrofit.create.
InvocationHandler est créé et renvoyé à l'aide de l'API Proxy of Reflect. Lorsque vous exécutez getBookmarkEntry de l'interface (instance) acquise, la méthode invoke est exécutée. Le nom de la méthode getBookmarkEntry est stocké dans l'argument Method et la chaîne targetUrl est stockée dans l'argument args.
Utilisez loadServiceMethod pour obtenir les informations d'accès à l'API Web associées à cette méthode. Ajoutez une autre classe d'appel okHttp et renvoyez la classe Adapter. Définissez ceci sur une variable de type Call
Exécutez ensuite la méthode enqueque pour effectuer un appel d'API Web. Le résultat peut être obtenu en rappelant l'argument.
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);
}
});
}
Explique comment utiliser l'API Proxy of Reflect. Voir c'est croire. Créez TestInterface et TestProxy et essayez d'exécuter TestProxy. Vous pouvez bien voir l'explication ci-dessus.
Pour savoir comment utiliser Proxy, je me suis référé à ici.
$ 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 {
//Informations sur la méthode de sortie
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