FilesExpand file tree

master

/

ResponseHandler.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

124 lines (111 loc) · 3.53 KB

master

/

ResponseHandler.java

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

124 lines (111 loc) · 3.53 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

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

/*

* 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;

import static feign.FeignException.errorReading;

import static feign.Util.ensureClosed;

import feign.Logger.Level;

import feign.codec.Decoder;

import feign.codec.ErrorDecoder;

import java.io.IOException;

import java.lang.reflect.Type;

/**

* The response handler that is used to provide synchronous support on top of standard response

* handling

*/

public class ResponseHandler {

private final Level logLevel;

private final Logger logger;

private final Decoder decoder;

private final ErrorDecoder errorDecoder;

private final boolean dismiss404;

private final boolean closeAfterDecode;

private final boolean decodeVoid;

private final boolean decodeErrorResponses;

private final ResponseInterceptor.Chain executionChain;

public ResponseHandler(

Level logLevel,

Logger logger,

Decoder decoder,

ErrorDecoder errorDecoder,

boolean dismiss404,

boolean closeAfterDecode,

boolean decodeVoid,

ResponseInterceptor.Chain executionChain) {

this(

logLevel,

logger,

decoder,

errorDecoder,

dismiss404,

closeAfterDecode,

decodeVoid,

false,

executionChain);

}

public ResponseHandler(

Level logLevel,

Logger logger,

Decoder decoder,

ErrorDecoder errorDecoder,

boolean dismiss404,

boolean closeAfterDecode,

boolean decodeVoid,

boolean decodeErrorResponses,

ResponseInterceptor.Chain executionChain) {

super();

this.logLevel = logLevel;

this.logger = logger;

this.decoder = decoder;

this.errorDecoder = errorDecoder;

this.dismiss404 = dismiss404;

this.closeAfterDecode = closeAfterDecode;

this.decodeVoid = decodeVoid;

this.decodeErrorResponses = decodeErrorResponses;

this.executionChain = executionChain;

}

public Object handleResponse(

String configKey, Response response, Type returnType, long elapsedTime) throws Exception {

try {

response = logAndRebufferResponseIfNeeded(configKey, response, elapsedTime);

return executionChain.next(

new InvocationContext(

configKey,

decoder,

errorDecoder,

dismiss404,

closeAfterDecode,

decodeVoid,

decodeErrorResponses,

response,

returnType));

} catch (final IOException e) {

if (logLevel != Level.NONE) {

logger.logIOException(configKey, logLevel, e, elapsedTime);

}

throw errorReading(response.request(), response, e);

} catch (Exception e) {

ensureClosed(response.body());

throw e;

}

}

private Response logAndRebufferResponseIfNeeded(

String configKey, Response response, long elapsedTime) throws IOException {

if (logLevel == Level.NONE) {

return response;

}

return logger.logAndRebufferResponse(configKey, logLevel, response, elapsedTime);

}

}