com.dounine.clouddisk360.parser.BaseParser Maven / Gradle / Ivy

Go to download
package com.dounine.clouddisk360.parser;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpRequest;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.config.CookieSpecs;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.HttpClients;

import com.dounine.clouddisk360.exception.CloudDiskException;
import com.dounine.clouddisk360.parser.deserializer.BaseConst;
import com.dounine.clouddisk360.parser.deserializer.BaseDes;
import com.dounine.clouddisk360.parser.deserializer.BaseParameter;
import com.dounine.clouddisk360.parser.deserializer.BaseRequestInterceptor;
import com.dounine.clouddisk360.parser.deserializer.MsgConst;
import com.dounine.clouddisk360.parser.deserializer.login.LoginUserToken;
import com.dounine.clouddisk360.pool.PoolingHttpClientConnection;
import com.dounine.clouddisk360.store.CookieStoreUT;

public abstract class BaseParser, ResponseHandle>
		extends JSONBianary {

	protected CookieStoreUT cookieStoreUT = new CookieStoreUT();
	protected HttpClientContext httpClientContext = new HttpClientContext();
	protected HttpClient httpClient = HttpClients.createDefault();

	public RequestInterceptor requestInterceptor;
	public C CONST;
	public HttpRequest requestMethod;
	public ResponseHandler responseHandler;
	public Parameter parameter;
	protected String uriPath;
	protected LoginUserToken loginUserToken;

	@SuppressWarnings("unchecked")
	private void inits() {
		Type genType = getClass().getGenericSuperclass();
		Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
		Class requestInterceptorClazz = (Class) params[4];
		Class> responseHandlerClazz = (Class>) params[5];
		Class requestMethodClazz = (Class) params[0];
		Class baseconstMethodClazz = (Class) params[2];
		try {
			this.responseHandler = (ResponseHandler) responseHandlerClazz.getConstructors()[0].newInstance(this);
			this.requestInterceptor = (RequestInterceptor) requestInterceptorClazz.getConstructors()[0].newInstance();
			this.requestMethod = (HttpRequest) requestMethodClazz.newInstance();
			CONST = (C) baseconstMethodClazz.newInstance();
		} catch (InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}

	public BaseParser() {
		inits();
	}

	public BaseParser(LoginUserToken loginUser) {
		if (null == loginUserToken) {
			if (StringUtils.isBlank(loginUser.getAccount())) {
				throw new CloudDiskException("loginUserToken不能为空");
			}
		}
		super.setLoginUserToken(loginUser);// jsonbianary
		cookieStoreUT.setLoginUserToken(loginUser);
		httpClientContext.setUserToken(loginUser);
		this.loginUserToken = loginUser;
		inits();
	}

	/**
	 * 把parse数据平滑过来
	 */
	public void dataSmooth(Object parse) {
		if (null != parse) {
			BaseParser bp = ((BaseParser) parse);
			this.httpClientContext = bp.httpClientContext;
			if (null == loginUserToken) {
				if (StringUtils.isBlank(bp.loginUserToken.getAccount())) {
					throw new CloudDiskException("loginUserToken不能为空");
				}
			}
			super.setLoginUserToken(bp.loginUserToken);// jsonbianary
			cookieStoreUT.setLoginUserToken(bp.loginUserToken);
			httpClientContext.setUserToken(bp.loginUserToken);
			this.loginUserToken = bp.loginUserToken;
		} else {
			throw new CloudDiskException("数据平滑失败");
		}
	}

	public M parse() {
		if (null == loginUserToken) {
			throw new CloudDiskException("至少给一个解析器初始化用户信息");
		}
		Method request = initRequest(parameter);
		M m = execute(request);
		cookieStoreUT.setCookieStore(httpClientContext.getCookieStore());
		return m;
	}

	public M parse(Parameter parameter) {
		this.parameter = parameter;
		return parse();
	}

	public String getUriPath() {
		return null;
	}

	@SuppressWarnings("unchecked")
	public Method initRequest(Parameter parameter) {
		uriPath = getUriPath();
		if (StringUtils.isNotBlank(uriPath)) {
			if (requestMethod instanceof HttpGet) {
				return (Method) new HttpGet(getRequestHost() + uriPath);
			}
			return (Method) new HttpPost(getRequestHost() + uriPath);
		}
		throw new CloudDiskException("使用默认initRequest,uriPath不能为空");
	}

	protected RequestConfig cookieRequestConfig() {
		RequestConfig config = RequestConfig.custom().setCookieSpec(CookieSpecs.STANDARD_STRICT).build();
		return config;
	}

	protected RequestConfig cookieRequestConfig(String cookieSpecs) {
		return RequestConfig.custom().setCookieSpec(cookieSpecs).build();
	}

	public M execute(Method request) {
		httpClient = HttpClients.custom().setConnectionManager(PoolingHttpClientConnection.getInstalce())
				.addInterceptorLast(requestInterceptor).setDefaultRequestConfig(cookieRequestConfig()).build();
		try {
			if (request instanceof HttpGet) {
				HttpGet get = (HttpGet) request;
				return httpClient.execute(get, responseHandler, this.httpClientContext);
			}
			HttpPost post = (HttpPost) request;
			return httpClient.execute(post, responseHandler, this.httpClientContext);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	public String readCookieStoreValue(String name) {
		if (StringUtils.isBlank(name)) {
			throw new CloudDiskException("cookie名称不能为空");
		}
		CookieStore cookieStore = httpClientContext.getCookieStore();
		List cookies = cookieStore.getCookies();
		Cookie cookie = null;
		for (Cookie coo : cookies) {
			if (coo.getName().equals(name)) {
				cookie = coo;
				break;
			}
		}
		if (null != cookie) {
			return cookie.getValue();
		}
		return null;
	}

	public CookieStore readCookieStoreDisk() {
		httpClientContext.setCookieStore(cookieStoreUT.readCookieStoreForDisk());
		return httpClientContext.getCookieStore();
	}

	public CookieStore readCookieStoreDisk(String[] filterCookie) {
		httpClientContext.setCookieStore(cookieStoreUT.readCookieStoreForDisk(filterCookie));
		return httpClientContext.getCookieStore();
	}

	public HttpClientContext getHttpClientContext() {
		return httpClientContext;
	}

	public void setHttpClientContext(HttpClientContext httpContext) {
		this.httpClientContext = httpContext;
	}

	public CookieStoreUT getCookieStoreUT() {
		return cookieStoreUT;
	}

	public Parameter getParameter() {
		return parameter;
	}

	public void setParameter(Parameter parameter) {
		this.parameter = parameter;
	}

	public String getRequestHostName() {
		if (null == httpClientContext.getAttribute(BaseConst.REQUEST_HOST_NAME)) {
			throw new CloudDiskException(MsgConst.HOST_VALUE_NOT_NULL);
		} else {
			return String.valueOf(httpClientContext.getAttribute(BaseConst.REQUEST_HOST_NAME));
		}
	}

	public String getRequestHost() {
		if (null == httpClientContext.getAttribute(BaseConst.REQUEST_HOST_NAME)) {
			throw new CloudDiskException(MsgConst.HOST_VALUE_NOT_NULL);
		} else {
			return String.valueOf("http://" + httpClientContext.getAttribute(BaseConst.REQUEST_HOST_NAME));
		}
	}

}