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
|
---
title: Integrating the Two Sides with a Connector
order: 4
layout: page
---
[[gwt.connector]]
= Integrating the Two Sides with a Connector
A client-side widget is integrated with a server-side component with a
__connector__. A connector is a client-side class that communicates changes to
the widget state and events to the server-side.
A connector normally gets the state of the server-side component by the __shared
state__, described later in
<<gwt-shared-state#gwt.shared-state,"Shared
State">>.
[[gwt.connector.basic]]
== A Basic Connector
The basic tasks of a connector is to hook up to the widget and handle events
from user interaction and changes received from the server. A connector also has
a number of routine infrastructure methods which need to be implemented.
[source,java]
----
@Connect(MyComponent.class)
public class MyComponentConnector
extends AbstractComponentConnector {
@Override
public MyComponentWidget getWidget() {
return (MyComponentWidget) super.getWidget();
}
@Override
public MyComponentState getState() {
return (MyComponentState) super.getState();
}
@Override
public void onStateChanged(StateChangeEvent stateChangeEvent)
{
super.onStateChanged(stateChangeEvent);
// Do something useful
final String text = getState().text;
getWidget().setText(text);
}
}
----
Here, we handled state change with the crude [methodname]#onStateChanged()#
method that is called when any of the state properties is changed. A finer and
simpler handling is achieved by using the [classname]#@OnStateChange# annotation
on a handler method for each property, or by [classname]#@DelegateToWidget# on a
shared state property, as described later in
<<../gwt/gwt-shared-state#gwt.shared-state,"Shared
State">>.
[[gwt.connector.communication]]
== Communication with the Server-Side
The main task of a connector is to communicate user interaction with the widget
to the server-side and receive state changes from the server-side and relay them
to the widget.
Server-to-client communication is normally done using a __shared state__, as
described in
<<gwt-shared-state#gwt.shared-state,"Shared
State">>, as well as RPC calls. The serialization of the state data is handled
completely transparently.
ifdef::web[]
Once the client-side engine receives the changes from the server, it reacts to
them by creating and notifying connectors that in turn manage widgets. This is
described in
<<gwt-advanced#gwt.advanced.phases,"Client-Side
Processing Phases">> in more
detail.
endif::web[]
For client-to-server communication, a connector can make remote procedure calls
(RPC) to the server-side. Also, the server-side component can make RPC calls to
the connector. For a thorough description of the RPC mechanism, refer to
<<gwt-rpc#gwt.rpc,"RPC Calls Between Client- and
Server-Side">>.
|
