Bonjour,

J'ai un petit problème dont je ne trouve pas la solution, J'ai crée une classe générique pour faire des appels REST en GWT. Elle prend 2 paramètres un POJO (qui servira a déclencher des événements sur le bus correspondant au nom du POJO) et l'interface de ce POJO qui étend JsonEncoderDecoder<POJO> (L'interface sert à sérialiser/deserializer en JSON).

Environnement de développement: Eclipse
Version de GWT: 2.6
Libraries additionnelles: RestyGWT, MVP4G

Avec le plugin de google: Tout fonctionne correctement, l'application se lance et les appels REST fonctionnent
Par contre des que je lance un build via Maven (avec le plugin gwt-maven-plugin) la compilation tombe en erreur avec le message suivant:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
[INFO]    [ERROR] Errors in 'com/stef/gwt/template/client/services/common/CommonAsyncRestService.java'
[INFO]       [ERROR] Line 64: Only class literals may be used as arguments to GWT.create()
L'erreur vient du faite que j'utilise un type générique pour passer l'interface en paramètre du GWT.create(). La compilation avec le plugin Maven ne semble pas apprécier cela, bien qu'en pratique tous fonctionne comme souhaité.

Voici la classe effectuant les appels REST elle n'est pas sensée être utilisée en direct elle doit être étendue.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
package com.stef.gwt.template.client.services.common;
 
import org.fusesource.restygwt.client.JsonCallback;
import org.fusesource.restygwt.client.JsonEncoderDecoder;
import org.fusesource.restygwt.client.Method;
import org.fusesource.restygwt.client.Resource;
 
import com.google.gwt.core.client.GWT;
import com.google.gwt.json.client.JSONValue;
import com.google.gwt.user.client.Window;
import com.mvp4g.client.Mvp4gException;
import com.stef.gwt.template.client.StefEventBus;
 
public abstract class CommonAsyncRestService<T, I extends JsonEncoderDecoder<T>> {
 
	private static final String BEFORE_REST_SEARCH = "beforeRestSearch";
	private static final String AFTER_REST_SEARCH = "afterRestSearch";
	private static final String BEFORE_REST_CREATE = "beforeRestCreate";
	private static final String AFTER_REST_CREATE = "afterRestCreate";
	private static final String BEFORE_REST_READ = "beforeRestRead";
	private static final String AFTER_REST_READ = "afterRestRead";
	private static final String BEFORE_REST_UPDATE = "beforeRestUpdate";
	private static final String AFTER_REST_UPDATE = "afterRestUpdate";
	private static final String BEFORE_REST_DELETE = "beforeRestDelete";
	private static final String AFTER_REST_DELETE = "afterRestDelete";
 
	private static final String SUCCESS = "Success";
	private static final String FAILED = "Failed";
 
	private Class<T> typeParameterClass;
	private Class<I> typeParameterInterface;
	private String endpoint;
 
	public CommonAsyncRestService(Class<T> typeParameterClass, Class<I> typeParameterInterface, String endpoint){
		this.endpoint = endpoint;
        this.typeParameterClass = typeParameterClass;
        this.typeParameterInterface = typeParameterInterface;
	};
 
	public void search(final StefEventBus eventBus) {
		fireEvent(eventBus, BEFORE_REST_SEARCH);
		fireEvent(eventBus, BEFORE_REST_SEARCH + typeParameterClass.getSimpleName());
		final I codec = GWT.create(typeParameterInterface);
		Resource resource = new Resource(endpoint);
		resource.get().send(new JsonCallback() {
			@Override
			public void onSuccess(Method method, JSONValue response) {
				T responseObject = codec.decode(response);
				fireEvent(eventBus, AFTER_REST_SEARCH + SUCCESS);
				fireEvent(eventBus, AFTER_REST_SEARCH + typeParameterClass.getSimpleName() + SUCCESS, responseObject);
			}
			@Override
			public void onFailure(Method method, Throwable exception) {
				fireEvent(eventBus, AFTER_REST_SEARCH + FAILED);
				fireEvent(eventBus, AFTER_REST_SEARCH + typeParameterClass.getSimpleName() + FAILED, exception);
				Window.alert("Failed " + exception);
			}
		});
	};
 
	public void create(final StefEventBus eventBus, T object) {
		fireEvent(eventBus, BEFORE_REST_CREATE);
		fireEvent(eventBus, BEFORE_REST_CREATE + typeParameterClass.getSimpleName());
		final I codec = GWT.create(typeParameterInterface);
		JSONValue jsonData = codec.encode((T)object);
		Resource resource = new Resource(endpoint);
		resource.post().json(jsonData).send(new JsonCallback() {
			@Override
			public void onSuccess(Method method, JSONValue response) {
				T responseObject = codec.decode(response);
				fireEvent(eventBus, AFTER_REST_CREATE + SUCCESS);
				fireEvent(eventBus, AFTER_REST_CREATE + typeParameterClass.getSimpleName() + SUCCESS, responseObject);
			}
			@Override
			public void onFailure(Method method, Throwable exception) {
				fireEvent(eventBus, AFTER_REST_CREATE + FAILED);
				fireEvent(eventBus, AFTER_REST_CREATE + typeParameterClass.getSimpleName() + FAILED, exception);
				Window.alert("Failed " + exception);
			}
		});
	};
 
	public void read(final StefEventBus eventBus, Integer id) {
		fireEvent(eventBus, BEFORE_REST_READ);
		fireEvent(eventBus, BEFORE_REST_READ + typeParameterClass.getSimpleName());
		final I codec = GWT.create(typeParameterInterface);
		Resource resource = new Resource(endpoint + "/" + id);
		resource.get().send(new JsonCallback() {
			@Override
			public void onSuccess(Method method, JSONValue response) {
				T responseObject = codec.decode(response);
				fireEvent(eventBus, AFTER_REST_READ + SUCCESS);
				fireEvent(eventBus, AFTER_REST_READ + typeParameterClass.getSimpleName() + SUCCESS, responseObject);
			}
			@Override
			public void onFailure(Method method, Throwable exception) {
				fireEvent(eventBus, AFTER_REST_READ + FAILED);
				fireEvent(eventBus, AFTER_REST_READ + typeParameterClass.getSimpleName() + FAILED, exception);
				Window.alert("Failed " + exception);
			}
		});
	};
 
	public void update(final StefEventBus eventBus, Integer id, T object) {
		fireEvent(eventBus, BEFORE_REST_UPDATE);
		fireEvent(eventBus, BEFORE_REST_UPDATE + typeParameterClass.getSimpleName());
		final I codec = GWT.create(typeParameterInterface);
		JSONValue jsonData = codec.encode((T)object);
		Resource resource = new Resource(endpoint + "/" + id);
		resource.put().json(jsonData).send(new JsonCallback() {
			@Override
			public void onSuccess(Method method, JSONValue response) {
				T responseObject = codec.decode(response);
				fireEvent(eventBus, AFTER_REST_UPDATE + SUCCESS);
				fireEvent(eventBus, AFTER_REST_UPDATE + typeParameterClass.getSimpleName() + SUCCESS, responseObject);
			}
			@Override
			public void onFailure(Method method, Throwable exception) {
				fireEvent(eventBus, AFTER_REST_UPDATE + FAILED);
				fireEvent(eventBus, AFTER_REST_UPDATE + typeParameterClass.getSimpleName() + FAILED, exception);
				Window.alert("Failed " + exception);
			}
		});
	};
 
	public void delete(final StefEventBus eventBus, Integer id) {
		fireEvent(eventBus, BEFORE_REST_DELETE);
		fireEvent(eventBus, BEFORE_REST_DELETE + typeParameterClass.getSimpleName());
		Resource resource = new Resource(endpoint + "/" + id);
		resource.delete().send(new JsonCallback() {
			@Override
			public void onSuccess(Method method, JSONValue response) {
				fireEvent(eventBus, AFTER_REST_DELETE + SUCCESS);
				fireEvent(eventBus, AFTER_REST_DELETE + typeParameterClass.getSimpleName() + SUCCESS);
			}
			@Override
			public void onFailure(Method method, Throwable exception) {
				fireEvent(eventBus, AFTER_REST_DELETE + FAILED);
				fireEvent(eventBus, AFTER_REST_DELETE + typeParameterClass.getSimpleName() + FAILED, exception);
				Window.alert("Failed " + exception);
			}
		});
	};
 
	protected void fireEvent(StefEventBus eventBus, String eventName, Object... args) {
		GWT.log("Event Fire: " + eventName);
		try {
			eventBus.dispatch(eventName, args);
		} catch(Mvp4gException e) {
			//event is not catched by any handler
		}
	}
 
}
Voici la classe utilisée par le presenter, elle sert a effectuer des calls REST sur un objet User
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package com.stef.gwt.template.client.services.common;
 
import com.stef.gwt.template.shared.bean.user.User;
 
public class UserAsyncRestService extends CommonAsyncRestService<User, UserCodec> {
 
	private static final String RESSOURCE_ENDPOINT = "services/login";
 
	public UserAsyncRestService() {
		super(User.class, UserCodec.class, RESSOURCE_ENDPOINT);
	}
 
}
Voici comment cette dernière est utilisée dans un presenter
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
 
 
...
	private UserAsyncRestService userAsyncRestService = GWT.create(UserAsyncRestService.class);
...
	public void createUser(String user, String password) {
	    userAsyncRestService.create(eventBus, new User(user, password));
	}
...
Je dois absolument pouvoir utiliser le plugin gwt maven pour faire cette compilation, si l'un de vous voit un moyen de contourner ce problème que ce soit via un paramètrage du plugin Maven ou bien une modification de code.

Je vous remercie pour votre attention,