JAVA编程杂记

2019独角兽企业重金招聘Python工程师标准>>>

1、spring切面编程中，如何获取request和response

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();//获取request
HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();//获取response

 

2、httpClient 例子

String url = "http://localhost:8080/nap/api/inquiry/v2";
        String method = "POST";
        String[] datas = new String[10];
        datas[0]="{\"ver\":400,\"sid\":101,\"voyType\":\"ST\",\"passengers\":{\"adtCount\":1,\"chdCount\":0},\"voys\":[{\"orgCity\":\"BJS\",\"dstCity\":\"SHA\",\"deptDate\":\"2017-03-30\"}]}";
        datas[1]="{\"ver\":400,\"sid\":101,\"voyType\":\"ST\",\"passengers\":{\"adtCount\":1,\"chdCount\":0},\"voys\":[{\"orgCity\":\"BJS\",\"dstCity\":\"SHA\",\"deptDate\":\"2017-03-21\"}]}";




        DefaultHttpClient httpClient = new DefaultHttpClient();
        httpClient.getParams().setParameter("http.protocol.content-charset", "utf-8");
        httpClient.getParams().setParameter("http.socket.timeout", 15 * 1000);
        httpClient.getParams().setParameter("http.connection.timeout", 15 * 1000);
        BasicResponseHandler e = new BasicResponseHandler();
        HttpPost req1 = new HttpPost(url);
        req1.setEntity(new StringEntity(datas[index]));
        String ret = httpclient.execute(req1, e);

 

3、http请求中 request的getReader()和getInputStream()只能读取一次，如下为springboot实现方案

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

/**
 * http请求 入参 reader流重复读取实现
 * Created by ysma on 2018/5/22.
 */
@WebFilter(urlPatterns = "/*")
public class HttpParamFilter implements Filter{

    private static final Logger LOGGER = LoggerFactory.getLogger(HttpParamFilter.class);

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        LOGGER.debug("======HttpParamFilter init==========");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain filterChain) throws IOException, ServletException {

        HttpServletRequest req = (HttpServletRequest)request;
        HttpServletResponse resp = (HttpServletResponse)response;
        TnfHttpServletRequestWrapper tnfHttpServletRequestWrapper = new TnfHttpServletRequestWrapper(req);
        filterChain.doFilter(tnfHttpServletRequestWrapper, resp);
    }

    @Override
    public void destroy() {
        LOGGER.debug("======HttpParamFilter destroyed==========");
    }
}


====================分割线=======================

import org.apache.commons.codec.binary.Base64;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

/**
 * tnf 定制httpServletRequest
 * Created by ysma on 2018/5/22.
 */
public class TnfHttpServletRequestWrapper extends HttpServletRequestWrapper{

    private byte[] bytes;

    /**
     * Constructs a request object wrapping the given request.
     *
     * @param request
     * @throws IllegalArgumentException if the request is null
     */
    public TnfHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        StringBuilder buffer = new StringBuilder();
        BufferedReader reader = request.getReader();
        String line;
        while ((line = reader.readLine()) != null) {
            buffer.append(line);
        }
        String paramStr = buffer.toString();
        byte[] originBytes = paramStr.getBytes();
        if (Base64.isBase64(originBytes)) {
            bytes = Base64.decodeBase64(originBytes);
        } else {
            bytes = originBytes;
        }
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        final ByteArrayInputStream baInputStream = new ByteArrayInputStream(bytes);
        return new ServletInputStream()
        {
            @Override
            public boolean isFinished() {
                return false;
            }

            @Override
            public boolean isReady() {
                return false;
            }

            @Override
            public void setReadListener(ReadListener readListener) {

            }

            public int read() throws IOException
            {
                return baInputStream.read();
            }
        };
    }

    /**
     * The default behavior of this method is to return getReader()
     * on the wrapped request object.
     */
    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(this.getInputStream()));
    }
}

4、ajax跨域请求设置，jsonp之外的另一个服务端实现方案

response.setHeader("Access-Control-Allow-Origin", "*");

 

5、自实现配置文件读取

    

Configuration config = new PropertiesConfiguration("yourfile.properties");

如果需要使用自动加载，只需要在年id配置信息里声明一个自动重载策略:

config.setReloadingStrategy(new FileChangedReloadingStrategy());    
 

特殊字符
如果你需要用到一些特殊字符，比如换行符，制表符，或者unicode字符，你需要进行字符转义，字符串分隔符（默认的是逗号“,”）也需要被转义  :

key = This /n string /t contains /, escaped // characters /u0020

colors.pie = #FF0000, #00FF00, #0000FF
你不用手动拆分字符串，可以直接作为数组返回:

String[] colors = config.getStringArray("colors.pie");

getList(key) 等。。。。

 

6、spring扩展代理类

    

public class MyInvocationHandler implements InvocationHandler {

   @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

       MyMethod myMethod = method.getAnnotation(MyMethod.class);

      String serviceName = myMethod.serviceName();

       //TODO serviceName向开源中国say hello

       Object result = callOschina(serviceName);

       return result；

    }

}

代理类是写完了，那么如何注册？

public class MyProxyAutowireCandidateResolver extends QualifierAnnotationAutowireCandidateResolver {

    @Override
    public Object getSuggestedValue(DependencyDescriptor descriptor) {
        Class<?> clazz = descriptor.getDependencyType();
        if (clazz.isInterface() && MyInterface.class.isAssignableFrom(clazz)) {
            return createProxy(clazz);
        }
        return super.getSuggestedValue(descriptor);
    }

    private Object createProxy(Class<?> clazz) {
        return Proxy.newProxyInstance(MyProxyAutowireCandidateResolver.class.getClassLoader(),
                new Class[] { clazz }, new MyInvocationHandler());
    }

}

 

转载于:https://my.oschina.net/ysma1987/blog/3035281