国际时区转换 - 404 Not Found

1，概述#

1.1，需求场景#

海外部署服务，用户界面展示当地时间，后端及数据库采用北京时间GMT+8时区，前端采用浏览器定位当地时区，前后端交互时需对时间进行时区转换。

1.2，实现原理#

前端增加请求头 ISrmTimeZone，传入当前浏览器获取时区；后端自定义消息转换器 HttpMessageConverter，修改 Jackson 序列化配置，根据请求头 ISrmTimeZone 设置时区。

2，代码实现#

2.1，自定义 HttpMessageConverter#

继承 MappingJackson2HttpMessageConverter，原逻辑基础上修改 objectMapper 部分，从请求头/响应头上获取 ISrmTimeZone 设置时区。

1
package com.midea.srm.core.timezone;
2

3
import javax.servlet.http.HttpServletResponse;
4
import java.io.IOException;
5
import java.lang.reflect.Type;
6
import java.text.SimpleDateFormat;
7
import java.util.List;
8
import java.util.Objects;
9
import java.util.TimeZone;
10
import com.fasterxml.jackson.core.JsonEncoding;
11
import com.fasterxml.jackson.core.JsonGenerator;
12
import com.fasterxml.jackson.core.JsonProcessingException;
13
import com.fasterxml.jackson.core.util.DefaultIndenter;
14
import com.fasterxml.jackson.core.util.DefaultPrettyPrinter;
15
import com.fasterxml.jackson.databind.JavaType;
16
import com.fasterxml.jackson.databind.ObjectMapper;
17
import com.fasterxml.jackson.databind.ObjectWriter;
18
import com.fasterxml.jackson.databind.SerializationConfig;
19
import com.fasterxml.jackson.databind.SerializationFeature;
20
import com.fasterxml.jackson.databind.exc.InvalidDefinitionException;
21
import com.fasterxml.jackson.databind.ser.FilterProvider;
22
import lombok.extern.slf4j.Slf4j;
23
import org.apache.commons.lang3.StringUtils;
24
import org.springframework.http.HttpInputMessage;
25
import org.springframework.http.HttpOutputMessage;
26
import org.springframework.http.MediaType;
27
import org.springframework.http.converter.HttpMessageConversionException;
28
import org.springframework.http.converter.HttpMessageNotReadableException;
29
import org.springframework.http.converter.HttpMessageNotWritableException;
30
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
31
import org.springframework.http.converter.json.MappingJacksonInputMessage;
32
import org.springframework.http.converter.json.MappingJacksonValue;
33
import org.springframework.lang.NonNull;
34
import org.springframework.lang.Nullable;
35
import org.springframework.util.TypeUtils;
36
import org.springframework.web.context.request.RequestContextHolder;
37
import org.springframework.web.context.request.ServletRequestAttributes;
38

39
/**
40
 * 国际时区消息转换器
41
 * 请求头/响应头包含 ISrmTimeZone 时生效
42
 * 根据 ISrmTimeZone 动态设置 objectMapper 时区
43
 * {@link org.springframework.http.converter.json.AbstractJackson2HttpMessageConverter}
44
 *
45
 * @author liwf106
46
 * @since 2023/12/7
47
 */
48
@Slf4j
49
@SuppressWarnings("all")
50
public class TimeZoneMessageConverter extends MappingJackson2HttpMessageConverter {
51
    public static final String TIME_ZONE_HEADER = "ISrmTimeZone";
52

53
    public TimeZoneMessageConverter() {
54
        super();
55
    }
56

57
    @NonNull
58
    @Override
59
    protected Object readInternal(@NonNull Class<?> clazz, HttpInputMessage inputMessage) throws IOException,
60
        HttpMessageNotReadableException {
61
        List<String> timeZone = inputMessage.getHeaders().get(TIME_ZONE_HEADER);
62
        ObjectMapper objectMapper = getObjectMapper(timeZone);
63
        JavaType javaType = getJavaType(clazz, null);
64
        return readJavaType(objectMapper, javaType, inputMessage);
65
    }
66

67
    @NonNull
68
    @Override
69
    public Object read(@NonNull Type type, Class<?> contextClass, HttpInputMessage inputMessage)
70
        throws IOException, HttpMessageNotReadableException {
71
        List<String> timeZone = inputMessage.getHeaders().get(TIME_ZONE_HEADER);
72
        ObjectMapper objectMapper = getObjectMapper(timeZone);
73
        JavaType javaType = getJavaType(type, contextClass);
74
        return readJavaType(objectMapper, javaType, inputMessage);
75
    }
76

77
    @Override
78
    public boolean canRead(Class<?> clazz, MediaType mediaType) {
79
        HttpServletResponse response =
80
            ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
81
        String timezone = response.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
82
        return super.canRead(clazz, mediaType) && StringUtils.isNotBlank(timezone);
83
    }
84

85
    @Override
86
    public boolean canWrite(Class<?> clazz, MediaType mediaType) {
87
        HttpServletResponse response =
88
            ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
89
        String timezone = response.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
90
        return super.canWrite(clazz, mediaType) && StringUtils.isNotBlank(timezone);
91
    }
92

93
    @Override
94
    protected void writeInternal(@NonNull Object object, @Nullable Type type, @NonNull HttpOutputMessage outputMessage)
95
        throws IOException, HttpMessageNotWritableException {
96
        List<String> timeZone = outputMessage.getHeaders().get(TIME_ZONE_HEADER);
97
        ObjectMapper objectMapper = getObjectMapper(timeZone);
98

99
        MediaType contentType = outputMessage.getHeaders().getContentType();
100
        JsonEncoding encoding = getJsonEncoding(contentType);
101
        JsonGenerator generator = objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
102
        try {
103

104
            Class<?> serializationView = null;
105
            FilterProvider filters = null;
106
            Object value = object;
107
            JavaType javaType = null;
108
            if (object instanceof MappingJacksonValue) {
109
                MappingJacksonValue container = (MappingJacksonValue) object;
110
                value = container.getValue();
111
                serializationView = container.getSerializationView();
112
                filters = container.getFilters();
113
            }
114
            if (type != null && TypeUtils.isAssignable(type, value.getClass())) {
115
                javaType = getJavaType(type, null);
116
            }
117
            ObjectWriter objectWriter;
118
            if (serializationView != null) {
119
                objectWriter = objectMapper.writerWithView(serializationView);
120
            } else if (filters != null) {
121
                objectWriter = objectMapper.writer(filters);
122
            } else {
123
                objectWriter = objectMapper.writer();
124
            }
125
            if (javaType != null && javaType.isContainerType()) {
126
                objectWriter = objectWriter.forType(javaType);
127
            }
128
            SerializationConfig config = objectWriter.getConfig();
129
            if (contentType != null && contentType.isCompatibleWith(MediaType.TEXT_EVENT_STREAM) &&
130
                config.isEnabled(SerializationFeature.INDENT_OUTPUT)) {
131
                DefaultPrettyPrinter prettyPrinter = new DefaultPrettyPrinter();
132
                prettyPrinter.indentObjectsWith(new DefaultIndenter("  ", "\ndata:"));
133
                objectWriter = objectWriter.with(prettyPrinter);
134
            }
135
            objectWriter.writeValue(generator, value);
136

137
            generator.flush();
138

139
        } catch (InvalidDefinitionException ex) {
140
            throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
141
        } catch (JsonProcessingException ex) {
142
            throw new HttpMessageNotWritableException("Could not write JSON: " + ex.getOriginalMessage(), ex);
143
        }
144

145
    }
146

147
    // 修改 objectMapper 时区
148
    private ObjectMapper getObjectMapper(List<String> timeZone) {
149
        ObjectMapper timeZoneObjectMapper = objectMapper.copy();
150
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
151
        timeZoneObjectMapper.setDateFormat(dateFormat);
152

153
        if (Objects.nonNull(timeZone) && !timeZone.isEmpty()) {
154
            timeZoneObjectMapper.setTimeZone(TimeZone.getTimeZone(timeZone.get(0)));
155
            log.info("set srm timezone {}", TimeZone.getTimeZone(timeZone.get(0)));
156
        } else {
157
            timeZoneObjectMapper.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
158
        }
159
        return timeZoneObjectMapper;
160
    }
161

162
    private Object readJavaType(ObjectMapper objectMapper, JavaType javaType, HttpInputMessage inputMessage)
163
        throws IOException {
164
        try {
165
            if (inputMessage instanceof MappingJacksonInputMessage) {
166
                Class<?> deserializationView = ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
167
                if (deserializationView != null) {
168
                    return objectMapper.readerWithView(deserializationView).forType(javaType).
169
                        readValue(inputMessage.getBody());
170
                }
171
            }
172
            return objectMapper.readValue(inputMessage.getBody(), javaType);
173
        } catch (InvalidDefinitionException ex) {
174
            throw new HttpMessageConversionException("Type definition error: " + ex.getType(), ex);
175
        } catch (JsonProcessingException ex) {
176
            throw new HttpMessageNotReadableException("JSON parse error: " + ex.getOriginalMessage(), ex);
177
        }
178
    }
179

180
}

2.2，自定义 ResponseBodyAdvice#

为兼容 mcomponent 的 JsonResponseBodyAdvice，仅修改 supports 方法以适配自定义 MessageConverter。

1
//
2
// Source code recreated from a .class file by IntelliJ IDEA
3
// (powered by FernFlower decompiler)
4
//
5

6
package com.midea.srm.core.timezone;
7

8
import java.util.Arrays;
9
import java.util.Iterator;
10
import java.util.List;
11
import com.midea.mcomponent.core.config.Settings;
12
import com.midea.mcomponent.core.response.Response;
13
import com.midea.mcomponent.core.response.SuccessResponse;
14
import com.midea.mcomponent.core.response.SuccessResponseData;
15
import com.midea.mcomponent.core.util.IPUtils;
16
import com.midea.mcomponent.core.util.TraceContext;
17
import org.apache.tomcat.util.buf.StringUtils;
18
import org.slf4j.Logger;
19
import org.slf4j.LoggerFactory;
20
import org.springframework.beans.factory.annotation.Autowired;
21
import org.springframework.core.MethodParameter;
22
import org.springframework.core.annotation.Order;
23
import org.springframework.http.MediaType;
24
import org.springframework.http.server.ServerHttpRequest;
25
import org.springframework.http.server.ServerHttpResponse;
26
import org.springframework.util.AntPathMatcher;
27
import org.springframework.web.bind.annotation.ControllerAdvice;
28
import org.springframework.web.context.request.RequestContextHolder;
29
import org.springframework.web.context.request.ServletRequestAttributes;
30
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
31

32
/**
33
 * {@link com.midea.mcomponent.web.common.advice.JsonResponseBodyAdvice}
34
 *
35
 * @author liwf106
36
 * @since 2023/12/7
37
 */
38
@Order(-1)
39
@ControllerAdvice
40
@SuppressWarnings("all")
41
public class TJsonResponseBodyAdvice implements ResponseBodyAdvice<Object> {
42
    protected final Logger logger = LoggerFactory.getLogger(TJsonResponseBodyAdvice.class);
43
    private static final List<String> DEFAULT_UN_WARP_PATHS =
44
        Arrays.asList("/**/configuration/ui", "/**/swagger-resources", "/**/v2/api-docs", "/**/configuration/security");
45
    @Autowired
46
    private Settings settings;
47

48
    public TJsonResponseBodyAdvice() {
49
    }
50

51
    public Object beforeBodyWrite(Object object, MethodParameter methodParameter, MediaType mediaType, Class clazz,
52
                                  ServerHttpRequest request, ServerHttpResponse response) {
53
        ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse()
54
            .setHeader("Cache-Control", "no-cache,no-store");
55
        String uri = request.getURI().getPath();
56
        boolean isRecord = new Boolean(TraceContext.getLocaleWeb());
57
        if (this.isUnWarpPath(uri)) {
58
            return object;
59
        } else {
60
            if (object instanceof SuccessResponseData) {
61
                ((SuccessResponseData) object).setProviderSpans(
62
                    isRecord ? StringUtils.join(TraceContext.getSpans()) : null);
63
                ((SuccessResponseData) object).setWebIpAddress(IPUtils.getLocalIpAddress());
64
                ((SuccessResponseData) object).setTraceId(TraceContext.getTraceId());
65
            }
66
            if (object instanceof Response) {
67
                return object;
68
            } else if (object == null) {
69
                return SuccessResponse.newInstance();
70
            } else {
71
                SuccessResponseData data = SuccessResponseData.newInstance(object);
72
                data.setProviderSpans(isRecord ? StringUtils.join(TraceContext.getSpans()) : null);
73
                data.setWebIpAddress(IPUtils.getLocalIpAddress());
74
                data.setTraceId(TraceContext.getTraceId());
75
                return data;
76
            }
77
        }
78
    }
79

80
    private boolean isUnWarpPath(String path) {
81
        AntPathMatcher matcher = new AntPathMatcher();
82
        Iterator var4 = DEFAULT_UN_WARP_PATHS.iterator();
83
        String pattern;
84
        while (var4.hasNext()) {
85
            pattern = (String) var4.next();
86
            if (org.apache.commons.lang.StringUtils.isNotEmpty(pattern) && matcher.match(pattern, path)) {
87
                return true;
88
            }
89
        }
90
        if (this.settings.getUnwarpUrls() != null && this.settings.getUnwarpUrls().size() > 0) {
91
            var4 = this.settings.getUnwarpUrls().iterator();
92
            while (var4.hasNext()) {
93
                pattern = (String) var4.next();
94
                if (org.apache.commons.lang.StringUtils.isNotEmpty(pattern) && matcher.match(pattern, path)) {
95
                    return true;
96
                }
97
            }
98
        }
99
        return false;
100
    }
101

102
    public boolean supports(MethodParameter methodParameter, Class clazz) {
103
        return clazz.equals(TimeZoneMessageConverter.class);
104
    }
105
}

2.3，替换 MappingJackson2HttpMessageConverter#

使用自定义 MessageConverter 替换掉项目原来默认处理 json 类型报文的 MappingJackson2HttpMessageConverter。若不确定项目默认消息转换器可在此方法下断点判断：

1
org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport#addDefaultHttpMessageConverters

1
package com.midea.srm.core.timezone;
2

3
import java.util.List;
4
import org.springframework.context.annotation.Configuration;
5
import org.springframework.http.converter.HttpMessageConverter;
6
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
7
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
8

9
/**
10
 * 配置国际时区转换器
11
 *
12
 * @author liwf106
13
 * @since 2023/12/7
14
 */
15
@Configuration
16
public class WebMvcConfig implements WebMvcConfigurer {
17
    @Override
18
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
19
        int index = converters.size();
20
        for (int i = 0; i < converters.size(); i++) {
21
            if (converters.get(i) instanceof MappingJackson2HttpMessageConverter) {
22
                index = i;
23
                break;
24
            }
25
        }
26
        converters.add(index, new TimeZoneMessageConverter());
27
    }
28
}

2.4，响应头设置 ISrmTimeZone & 特殊传参处理#

使用 AOP 拦截需要进行时区转换的接口，将请求头 ISrmTimeZone 设置到响应头中以供自定义 messageConverter 获取时区。修改 objectMapper 时区仅适用于 Java 对象传参，若使用形如 Map<String, String>的方式传参则无法获取到 Date 类型而无法转换时区，因此可在 AOP 内酌情判断并手动转换时区。

1
package com.midea.srm.core.timezone;
2

3
import javax.servlet.http.HttpServletRequest;
4
import javax.servlet.http.HttpServletResponse;
5
import java.text.ParseException;
6
import java.text.SimpleDateFormat;
7
import java.util.Date;
8
import java.util.Map;
9
import java.util.TimeZone;
10
import cn.hutool.json.JSONUtil;
11
import com.fasterxml.jackson.databind.ObjectMapper;
12
import lombok.extern.slf4j.Slf4j;
13
import org.apache.commons.lang3.StringUtils;
14
import org.aspectj.lang.ProceedingJoinPoint;
15
import org.aspectj.lang.annotation.Around;
16
import org.aspectj.lang.annotation.Aspect;
17
import org.aspectj.lang.annotation.Pointcut;
18
import org.springframework.beans.factory.annotation.Autowired;
19
import org.springframework.stereotype.Component;
20
import org.springframework.web.context.request.RequestContextHolder;
21
import org.springframework.web.context.request.ServletRequestAttributes;
22

23
/**
24
 * 国际时区转换处理
25
 * 处理 Map 等特殊入参形式
26
 *
27
 * @author liwf106
28
 * @since 2023/12/6
29
 */
30
@Slf4j
31
@Aspect
32
@Component
33
@SuppressWarnings("all")
34
public class TimeZoneConvertAspect {
35
    // 国内时区
36
    public static final SimpleDateFormat SH_SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
37
    // 国内时区-日期
38
    public static final SimpleDateFormat SH_SDF_DATE = new SimpleDateFormat("yyyy-MM-dd");
39
    // 国际时区
40
    public static final SimpleDateFormat GLOBAL_SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
41
    // 国际时区-日期
42
    public static final SimpleDateFormat GLOBAL_SDF_DATE = new SimpleDateFormat("yyyy-MM-dd");
43

44
    @Autowired
45
    private ObjectMapper objectMapper;
46

47
    public TimeZoneConvertAspect(ObjectMapper objectMapper) {
48
        SH_SDF.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
49
        SH_SDF_DATE.setTimeZone(TimeZone.getTimeZone("Asia/Shanghai"));
50
        this.objectMapper = objectMapper;
51
    }
52

53
    @Pointcut("@within(org.springframework.web.bind.annotation.RestController) && within(com.midea.srm..*)")
54
    public void point() {
55
    }
56

57
    @Around("point()")
58
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
59
        try {
60
            HttpServletRequest request =
61
                ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
62
            String timeZone = request.getHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER);
63
            if (StringUtils.isNotBlank(timeZone)) {
64
                HttpServletResponse response =
65
                    ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
66
                response.addHeader(TimeZoneMessageConverter.TIME_ZONE_HEADER, timeZone);
67
                // 根据请求头设置国际时区
68
                GLOBAL_SDF.setTimeZone(TimeZone.getTimeZone(timeZone));
69
                GLOBAL_SDF_DATE.setTimeZone(TimeZone.getTimeZone(timeZone));
70
                // 入参
71
                Object[] args = joinPoint.getArgs();
72
                log.info("原始请求参数为{}", args);
73
                for (Object arg : args) {
74
                    log.info("参数:{}", JSONUtil.toJsonStr(arg));
75
                    // 仅处理 Map 形式入参
76
                    if (arg instanceof Map) {
77
                        ((Map) arg).forEach((k, v) -> {
78
                            if (v instanceof String && StringUtils.isNotBlank((String) v) && isDateFieldName((String) k)) {
79
                                try {
80
                                    log.info("传参含date字段:[{}],[{}]", k, v);
81
                                    Date date;
82
                                    String format;
83
                                    // 仅年月日
84
                                    if ((((String) v)).length() == 10) {
85
                                        date = GLOBAL_SDF_DATE.parse((String) v);
86
                                        format = SH_SDF_DATE.format(date);
87
                                    } else {
88
                                        date = GLOBAL_SDF.parse((String) v);
89
                                        format = SH_SDF.format(date);
90
                                    }
91
                                    ((Map) arg).put(k, format);
92
                                    log.info("传参含date字段转换结果:[{}],[{}]", k, format);
93
                                } catch (ParseException e) {
94
                                    log.error("解析失败", e);
95
                                }
96
                            }
97
                        });
98
                    }
99
                }
100
            }
101
        } catch (Exception e) {
102
            log.error("时区转换失败", e);
103
        }
104
        return joinPoint.proceed();
105
    }
106

107
    /**
108
     * 根据字段名猜测是否为日期
109
     *
110
     * @param fieldName 字段名
111
     * @return isDateFieldName
112
     */
113
    private boolean isDateFieldName(String fieldName) {
114
        return fieldName.contains("date") || fieldName.contains("Date");
115
    }
116
}

3，逻辑验证#

前端验证可修改浏览器位置信息模拟海外场景
后端验证手动添加请求头，若不生效可关注所有已注册的 HttpMessageConverter 响应的 contentType 和注册顺序

附：注意事项#

以上方案仅处理前后端交互报文，未处理 excel 导入导出场景
以上方案会替换处理 json 的默认 HttpMessageConverter，建议根据实际情况评估影响范围（例如本例中影响了 com.midea.mcomponent.web.common.advice.JsonResponseBodyAdvice）
2.4 中特殊传参处理仅考虑了传参为 Map 的场景