FeignClient的配置对象、RestTemplate连接池配置对象、获取JDK动态代理/CGLIB代理对象代理的目标对象的工具类、Controller的环绕拦截类、Set拷贝、List拷贝

小灰灰 2023-01-02 11:22 128阅读 0赞

## 一、RestTemplate连接池配置对象。 ##

import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter;
    import org.apache.http.client.HttpClient;
    import org.apache.http.impl.client.HttpClientBuilder;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.http.client.ClientHttpRequestFactory;
    import org.springframework.http.client.ClientHttpResponse;
    import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.converter.StringHttpMessageConverter;
    import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
    import org.springframework.web.client.DefaultResponseErrorHandler;
    import org.springframework.web.client.RestOperations;
    import org.springframework.web.client.RestTemplate;
    
    import java.nio.charset.StandardCharsets;
    import java.util.List;
    
    /** * RestTemplate连接池配置对象。 */
    @Configuration
    public class RestTemplateConfig { 
        private static final int MAX_TOTAL_CONNECTION = 50;
        private static final int MAX_CONNECTION_PER_ROUTE = 20;
        private static final int CONNECTION_TIMEOUT = 20000;
        private static final int READ_TIMEOUT = 30000;
    
        @Bean
        @ConditionalOnMissingBean({ RestOperations.class, RestTemplate.class})
        public RestTemplate restTemplate() { 
            RestTemplate restTemplate = new RestTemplate(createFactory());
            List<HttpMessageConverter<?>> messageConverters = restTemplate.getMessageConverters();
            messageConverters.removeIf(
                    c -> c instanceof StringHttpMessageConverter || c instanceof MappingJackson2HttpMessageConverter);
            messageConverters.add(1, new StringHttpMessageConverter(StandardCharsets.UTF_8));
            messageConverters.add(new FastJsonHttpMessageConverter());
            restTemplate.setErrorHandler(new DefaultResponseErrorHandler() { 
                @Override
                public void handleError(ClientHttpResponse response) { 
                    // 防止400+和500等错误被直接抛出异常，这里避开了缺省处理方式，所有的错误均交给业务代码处理。
                }
            });
            return restTemplate;
        }
    
        private ClientHttpRequestFactory createFactory() { 
            HttpClient httpClient = HttpClientBuilder.create()
                    .setMaxConnTotal(MAX_TOTAL_CONNECTION)
                    .setMaxConnPerRoute(MAX_CONNECTION_PER_ROUTE)
                    .build();
            HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);
            factory.setReadTimeout(READ_TIMEOUT);
            factory.setConnectTimeout(CONNECTION_TIMEOUT);
            return factory;
        }
    }

## 二、FeignClient的配置对象。 ##

import com.imooc.stream.tool.ContextUtil;
    import feign.RequestInterceptor;
    import feign.RequestTemplate;
    import org.springframework.context.annotation.Configuration;
    
    /** * FeignClient的配置对象。 */
    @Configuration
    public class FeignConfig implements RequestInterceptor { 
    
        /** * 请求头跟踪id名。 */
        public static final String HTTP_HEADER_TRACE_ID = "traceId";
    
        /** * 在HTTP Request对象中的属性键。 */
        public static final String REQUEST_ATTRIBUTE_NAME = "tokenData";
    
        @Override
        public void apply(RequestTemplate requestTemplate) { 
            requestTemplate.header(REQUEST_ATTRIBUTE_NAME,
                    ContextUtil.getHttpRequest().getHeader(REQUEST_ATTRIBUTE_NAME));
            requestTemplate.header(HTTP_HEADER_TRACE_ID,
                    ContextUtil.getHttpRequest().getHeader(HTTP_HEADER_TRACE_ID));
        }
    }

## 三、Set拷贝、List拷贝 ##

import java.util.Arrays;
    import java.util.HashSet;
    import java.util.Set;
    
    public class SetUtils { 
    
        public static <T> Set<T> copy(Set<T> set) { 
            Set<T> newSet = new HashSet<>();
            set.forEach(ele -> newSet.add(ele));
            return newSet;
        }
    
        public static <T> Set<T> intersect(Set<T> set1, Set<T> set2) { 
            Set<T> jjSet = new HashSet<>();
            set1.forEach(ele -> { 
                if (set2.contains(ele)) { 
                    jjSet.add(ele);
                }
            });
            return jjSet;
        }
    
        public static <T> Set<T> toSet(T[] t) { 
            Set<T> newSet = new HashSet<>();
            if (t == null || t.length == 0) { 
                return newSet;
            }
            newSet.addAll(Arrays.asList(t));
            return newSet;
        }
    }

import org.apache.commons.beanutils.BeanUtilsBean;
    import org.springframework.beans.BeanUtils;
    
    import java.io.*;
    import java.lang.reflect.InvocationTargetException;
    import java.util.ArrayList;
    import java.util.List;
    
    
    public class MbeanUtils extends BeanUtils { 
    
    
        public Object cloneBean(Object bean)
            throws IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchMethodException { 
            return BeanUtilsBean.getInstance().cloneBean(bean);
        }
    
        public static void copyPropertiesList(List sourceList, List<Object> targetList, Class clazz) { 
            if (sourceList == null || sourceList.isEmpty()) { 
                return;
            }
            for (Object items : sourceList) { 
                Object target;
                try { 
                    target = clazz.newInstance();
                } catch (InstantiationException | IllegalAccessException e) { 
                    throw new RuntimeException(e);
                }
                copyProperties(items, target);
                targetList.add(target);
            }
        }
    
        /** * Arrays 类的 copyOf() 方法 * Arrays 类的 copyOfRange() 方法 * System 类的 arraycopy() 方法 * Object 类的 clone() 方法 */
        public static <T> List<T> deepCopy(List<T> src) throws IOException, ClassNotFoundException { 
            ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(byteOut);
            out.writeObject(src);
            ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
            ObjectInputStream in = new ObjectInputStream(byteIn);
            List<T> copyList = (List<T>) in.readObject();
            return copyList;
        }
    
        /** * 优化并行处理 */
        public static void main(String[] args) { 
            List<String> fileList = new ArrayList<>();
            System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "100");
            long startTime = System.currentTimeMillis();
            fileList.parallelStream().forEach(e -> System.out.println("e"+e));
            long endTime = System.currentTimeMillis();
            System.out.println("jdk8并行流耗时：" + (endTime - startTime) + "ms");
        }
    }

## 四、Controller的环绕拦截类。 ##

import org.springframework.beans.propertyeditors.CustomDateEditor;
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.InitBinder;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    /** * Controller的环绕拦截类。 */
    @ControllerAdvice
    public class MyControllerAdvice { 
    
        /** * 转换前端传入的日期变量参数为指定格式。 * * @param binder 数据绑定参数。 */
        @InitBinder
        public void initBinder(WebDataBinder binder) { 
            binder.registerCustomEditor(Date.class,
                    new CustomDateEditor(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"), false));
        }
    }

## 五、获取JDK动态代理/CGLIB代理对象代理的目标对象的工具类。 ##

import lombok.extern.slf4j.Slf4j;
    import org.springframework.aop.framework.AdvisedSupport;
    import org.springframework.aop.framework.AopProxy;
    import org.springframework.aop.support.AopUtils;
    
    import java.lang.reflect.Field;
    
    /** * 获取JDK动态代理/CGLIB代理对象代理的目标对象的工具类。 */
    @Slf4j
    public class AopTargetUtil { 
    
        /** * 获取参数对象代理的目标对象。 * * @param proxy 代理对象 * @return 代理的目标对象。 */
        public static Object getTarget(Object proxy) { 
            if (!AopUtils.isAopProxy(proxy)) { 
                return proxy;
            }
            try { 
                if (AopUtils.isJdkDynamicProxy(proxy)) { 
                    return getJdkDynamicProxyTargetObject(proxy);
                } else { 
                    return getCglibProxyTargetObject(proxy);
                }
            } catch (Exception e) { 
                log.error("Failed to call getJdkDynamicProxyTargetObject or getCglibProxyTargetObject", e);
                return null;
            }
        }
    
        /** * 私有构造函数，明确标识该常量类的作用。 */
        private AopTargetUtil() { 
        }
    
        private static Object getCglibProxyTargetObject(Object proxy) throws Exception { 
            Field h = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");
            h.setAccessible(true);
            Object dynamicAdvisedInterceptor = h.get(proxy);
            Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");
            advised.setAccessible(true);
            return ((AdvisedSupport) advised.get(dynamicAdvisedInterceptor)).getTargetSource().getTarget();
        }
    
        private static Object getJdkDynamicProxyTargetObject(Object proxy) throws Exception { 
            Field h = proxy.getClass().getSuperclass().getDeclaredField("h");
            h.setAccessible(true);
            AopProxy aopProxy = (AopProxy) h.get(proxy);
            Field advised = aopProxy.getClass().getDeclaredField("advised");
            advised.setAccessible(true);
            return ((AdvisedSupport) advised.get(aopProxy)).getTargetSource().getTarget();
        }
    }

import org.springframework.web.context.request.RequestContextHolder;
    import org.springframework.web.context.request.ServletRequestAttributes;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.util.Objects;
    
    /** * 获取Servlet HttpRequest和HttpResponse的工具类。 */
    public class ContextUtil { 
    
        /** * 判断当前是否处于HttpServletRequest上下文环境。 * * @return 是返回true，否则false。 */
        public static boolean hasRequestContext() { 
            return RequestContextHolder.getRequestAttributes() != null;
        }
    
        /** * 获取Servlet请求上下文的HttpRequest对象。 * * @return 请求上下文中的HttpRequest对象。 */
        public static HttpServletRequest getHttpRequest() { 
            return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getRequest();
        }
    
        /** * 获取Servlet请求上下文的HttpResponse对象。 * * @return 请求上下文中的HttpResponse对象。 */
        public static HttpServletResponse getHttpResponse() { 
            return ((ServletRequestAttributes) Objects.requireNonNull(RequestContextHolder.getRequestAttributes())).getResponse();
        }
    
        /** * 私有构造函数，明确标识该常量类的作用。 */
        private ContextUtil() { 
        }
    }