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 package org.apache.hc.core5.http.nio;
29
30 import java.util.concurrent.Future;
31
32 import org.apache.hc.core5.annotation.Contract;
33 import org.apache.hc.core5.annotation.ThreadingBehavior;
34 import org.apache.hc.core5.concurrent.BasicFuture;
35 import org.apache.hc.core5.concurrent.FutureCallback;
36 import org.apache.hc.core5.http.nio.support.BasicClientExchangeHandler;
37 import org.apache.hc.core5.http.protocol.HttpContext;
38 import org.apache.hc.core5.http.protocol.HttpCoreContext;
39
40
41
42
43
44
45
46
47
48 @Contract(threading = ThreadingBehavior.SAFE)
49 public abstract class AsyncClientEndpoint {
50
51
52
53
54
55
56
57 public abstract void execute(
58 AsyncClientExchangeHandler exchangeHandler,
59 HandlerFactory<AsyncPushConsumer> pushHandlerFactory,
60 HttpContext context);
61
62
63
64
65
66
67
68 public void execute(
69 final AsyncClientExchangeHandler exchangeHandler,
70 final HttpContext context) {
71 execute(exchangeHandler, null, context);
72 }
73
74
75
76
77 public abstract void releaseAndReuse();
78
79
80
81
82 public abstract void releaseAndDiscard();
83
84
85
86
87 public abstract boolean isConnected();
88
89
90
91
92
93
94
95 public final <T> Future<T> execute(
96 final AsyncRequestProducer requestProducer,
97 final AsyncResponseConsumer<T> responseConsumer,
98 final HandlerFactory<AsyncPushConsumer> pushHandlerFactory,
99 final HttpContext context,
100 final FutureCallback<T> callback) {
101 final BasicFuture<T> future = new BasicFuture<>(callback);
102 execute(new BasicClientExchangeHandler<>(requestProducer, responseConsumer,
103 new FutureCallback<T>() {
104
105 @Override
106 public void completed(final T result) {
107 future.completed(result);
108 }
109
110 @Override
111 public void failed(final Exception ex) {
112 future.failed(ex);
113 }
114
115 @Override
116 public void cancelled() {
117 future.cancel();
118 }
119
120 }),
121 pushHandlerFactory, context != null ? context : HttpCoreContext.create());
122 return future;
123 }
124
125
126
127
128
129
130
131 public final <T> Future<T> execute(
132 final AsyncRequestProducer requestProducer,
133 final AsyncResponseConsumer<T> responseConsumer,
134 final HttpContext context,
135 final FutureCallback<T> callback) {
136 return execute(requestProducer, responseConsumer, null, context, callback);
137 }
138
139
140
141
142
143
144
145 public final <T> Future<T> execute(
146 final AsyncRequestProducer requestProducer,
147 final AsyncResponseConsumer<T> responseConsumer,
148 final FutureCallback<T> callback) {
149 return execute(requestProducer, responseConsumer, null, null, callback);
150 }
151
152 }