FilesExpand file tree

master

/

ResponseInterceptor.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

70 lines (64 loc) · 2.57 KB

master

/

ResponseInterceptor.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

70 lines (64 loc) · 2.57 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

/*

* Copyright © 2012 The Feign Authors (feign@commonhaus.dev)

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package feign;

/**

* {@code ResponseInterceptor}s may be configured for purposes such as verifying or modifying

* headers of response, verifying the business status of decoded object, or processing responses to

* unsuccessful requests. Once the interceptors are applied, {@link

* ResponseInterceptor#intercept(InvocationContext, Chain)} is called, then the response is decoded.

*/

public interface ResponseInterceptor {

/**

* Called by {@link ResponseHandler} after refreshing the response and wrapped around the whole

* decode process, must either manually invoke {@link Chain#next(InvocationContext)} or manually

* create a new response object

*

* @param invocationContext information surrounding the response being decoded

* @return decoded response

*/

Object intercept(InvocationContext invocationContext, Chain chain) throws Exception;

/**

* Return a new {@link ResponseInterceptor} that invokes the current interceptor first and then

* the one that is passed in.

*

* @param nextInterceptor the interceptor to delegate to after the current

* @return a new interceptor that chains the two

*/

default ResponseInterceptor andThen(ResponseInterceptor nextInterceptor) {

return (ic, chain) ->

intercept(ic, nextContext -> nextInterceptor.intercept(nextContext, chain));

}

/** Contract for delegation to the rest of the chain. */

interface Chain {

Chain DEFAULT = InvocationContext::proceed;

/**

* Delegate to the rest of the chain to execute the request.

*

* @param context the request to execute the {@link Chain} .

* @return the response

*/

Object next(InvocationContext context) throws Exception;

}

/**

* Apply this interceptor to the given {@code Chain} resulting in an intercepted chain.

*

* @param chain the chain to add interception around

* @return a new chain instance

*/

default Chain apply(Chain chain) {

return request -> intercept(request, chain);

}

}