利用DefaultHttpClient实现代理访问，和登录CAS并且写cookie

package com.geoglobeportal.shareservice.service;
/*
*
*/
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.cookie.Cookie;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.cookie.BasicClientCookie;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.springframework.security.context.SecurityContextHolder;
import org.springframework.web.context.WebApplicationContext;

import com.geoglobeportal.admin.log4j.service.ILog4jExecute;
import com.geoglobeportal.regcenter.myservice.pojo.TileServiceInfoModel;
import com.geoglobeportal.system.service.ISysArgumentsManager;
import com.geostar.geoglobe.security.context.SecurityUserHolder;
import com.geostar.geoglobe.security.domain.User;

public class ProxyHandler extends HttpServlet {

private static final long serialVersionUID = 1L;

private String casUrl = null;
private String casLoginUrl = null;
private String localUrl = null;
private static Logger logger = Logger.getLogger(ProxyHandler.class);
private WebApplicationContext wac;

@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("-----*****----------------------ProxyHandler init start----------------------------");
wac = (WebApplicationContext) config.getServletContext()
.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
ISysArgumentsManager sysArgumentsManager = (ISysArgumentsManager)wac.getBean("sysArgumentsManager");
casUrl = sysArgumentsManager.getValueByKey("CAS_URL");
casLoginUrl = casUrl+"/login";
String portalUrl = sysArgumentsManager.getValueByKey("PORTAL_URL");
localUrl = portalUrl.replace("/GeoGlobePortal", "");
System.out.println("---------------------------casUrl:"+casUrl+" ----------------------------");
System.out.println("---------------------------casLoginUrl:"+casLoginUrl+" ----------------------------");
System.out.println("---------------------------localUrl:"+localUrl+" ----------------------------");
//casUrl = config.getInitParameter("CAS_URL");
//casLoginUrl = config.getInitParameter("CAS_LOGIN_URL");
if(casUrl == null) {
logger.error("不能初始化身份认证系统，请检查Servlet参数！");
throw new ServletException("不能初始化身份认证系统，请检查Servlet参数！");
}
System.out.println("-----*****----------------------ProxyHandler init end----------------------------");

}

@SuppressWarnings({ "unchecked", "deprecation" })
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException {
//String param = req.getParameter("auth");
System.out.println("------*****---------------------doGet start----------------------------------");
Object obj = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
logger.info("obj : " + obj);
System.out.println("------doGet-----------obj:"+obj+"------------------------------");
String flagUrl = req.getQueryString();
if(obj != null && obj instanceof User){
//（解决登录不显示问题）
if(flagUrl.indexOf(localUrl)>-1){
System.out.println("------////---------------------our service----------------------------------");
securityRequest(req,resp);
}else{
System.out.println("------////---------------------not our service----------------------------------");
noSecurityRequest(req,resp);
}
//securityRequest(req,resp);
} else{
noSecurityRequest(req,resp);
}
System.out.println("------*****---------------------doGet end----------------------------------");
/*
if(param==null || param.length()==0) {

} else {

}
*/
}

private void noSecurityRequest(HttpServletRequest req, HttpServletResponse resp) {
logger.info("ProxyHandler noSecurityRequest 请求类型: GET");
String url0 = "";
OutputStream out = null;
HttpURLConnection conn = null;
boolean sceProFlag = false;
try {
url0 = req.getQueryString();
if (url0.startsWith("url=")) {
url0 = url0.substring(4);
}
if(url0.indexOf("requestTime")!=-1) {
url0 = url0.split("requestTime")[0];
url0 = url0.substring(0, url0.length()-1);
}

//可以去掉
//url0 = new String(url0.getBytes("ISO-8859-1"),"UTF-8");
URL url = new URL(url0);
conn = (HttpURLConnection)url.openConnection();

conn.setRequestMethod("GET");
//urlConnection.setRequestMethod("POST");

conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
//conn.setConnectTimeout(3000);

//InputStream in = conn.getInputStream();
out = resp.getOutputStream();
resp.setContentType("text/xml; charset=UTF-8");

BufferedReader rd = new BufferedReader(new InputStreamReader(conn.getInputStream(), HTTP.UTF_8));
BufferedWriter wd = new BufferedWriter(new OutputStreamWriter(resp.getOutputStream(), HTTP.UTF_8));

String tempLine = rd.readLine();

StringBuffer scenarioSb = new StringBuffer();

while (tempLine != null){
wd.write(tempLine);
logger.info(tempLine);
scenarioSb.append(tempLine);
tempLine = rd.readLine();
}

wd.flush();

if (url0.indexOf("/ScenarioProxy/ScenarioProxy?tag=") != -1) {
if(url0.indexOf("三维") == -1){
insertServicesLog(req, scenarioSb);
}
}

logger.info("/n请求地址: "+url0+"/n请求成功!");
} catch (Exception e) {
logger.error("请求地址: "+url0+"/n请求失败: "+e);
} finally {
try {
if(out!=null) {
out.close();
}
if(conn!=null) {
conn.disconnect();
}
} catch (Exception e) {
logger.error(e);
}
}
}

private void insertServicesLog(HttpServletRequest request, StringBuffer scenarioStringBuffer) {
SAXReader read = new SAXReader();
try {
Document doc = read.read(new ByteArrayInputStream(scenarioStringBuffer.toString().getBytes("UTF-8")));

String xpath = "/QueryScenariosResponse/ListScenariosResult/Registerscenario";

Element queryScenariosResponse = (Element) doc.selectSingleNode("QueryScenariosResponse");

Element listScenariosResult = (Element) queryScenariosResponse.element("ListScenariosResult");

Element registerscenario = (Element) listScenariosResult.element("Registerscenario");

Element serviceList = (Element) registerscenario.element("ServiceList");

List <Element> serviceCapabilities = serviceList.elements("ServiceCapabilities");

if (serviceCapabilities.size() > 0) {
ILog4jExecute log4jExecuteService = (ILog4jExecute)wac.getBean("log4jExecuteService");
String userName = "匿名用户";
Object obj = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
logger.info("obj : " + obj);
if(obj != null && obj instanceof User){
User user = (User) obj;
userName = user.getLoginame();
}

List <TileServiceInfoModel> tsims = new ArrayList <TileServiceInfoModel> ();

for (Element service : serviceCapabilities) {

String name = ((Element) service.element("Name")).getTextTrim();

String serverAddress = ((Element) service.element("ServerAddress")).getTextTrim();

Element data = (Element) service.element("Data");

Element tileData = (Element) data.element("TileData");

String serviceType = ((Element) tileData.element("Tile")).getTextTrim();

TileServiceInfoModel tsim = new TileServiceInfoModel();

tsim.setServiceNodeName(name);

tsim.setServiceUrl(serverAddress);

tsim.setServiceType(serviceType);

tsims.add(tsim);
}

log4jExecuteService.executeLogServer(request, userName, tsims);
}
} catch (Exception e) {
logger.error(e);
}

}

@SuppressWarnings("unchecked")
private void securityRequest(HttpServletRequest req, HttpServletResponse resp)
throws ServletException{
logger.info("ProxyHandler securityRequest 请求类型: GET");
System.out.println("-----*****------------securityRequest start------------------------------");
User user = SecurityUserHolder.getCurrentUser();
System.out.println("-----------------user:"+user+"------------------------------");
if(user == null) throw new ServletException("不能获取身份信息，请检查系统配置！");
try {
String url = req.getQueryString();
if (url.startsWith("url=")) {
url = url.substring(4);
}
if(url.indexOf("requestTime")!=-1) {
url = url.split("requestTime")[0];
url = url.substring(0, url.length()-1);
}
System.out.println("-----------------url:"+url+"------------------------------");
DefaultHttpClient httpclient = new DefaultHttpClient();
System.out.println("-----------------httpclient connection------------------------------");
String loginIt = doCasLoginRequest(httpclient, casUrl);

//登录 CAS 身份认证系统
HttpPost httpost = new HttpPost(casLoginUrl);
List <NameValuePair> nvps = new ArrayList <NameValuePair>();
System.out.println("-----------------username:"+user.getUsername()+"------------------------------");
System.out.println("-----------------password:"+user.getPassword()+"------------------------------");
nvps.add(new BasicNameValuePair("username", user.getUsername()));
nvps.add(new BasicNameValuePair("password", user.getUsername()));
nvps.add(new BasicNameValuePair("lt", loginIt));
nvps.add(new BasicNameValuePair("_eventId", "submit"));
nvps.add(new BasicNameValuePair("submit", "登录"));
httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));

HttpResponse response = httpclient.execute(httpost);
HttpEntity entity = response.getEntity();
if(entity != null) {
System.out.println("-----------------cas login------------------------------");
Cookie cookie = getCookieValue(httpclient, "CASTGC");
System.out.println("-----------------cas cookie:"+cookie+"------------------------------");
entity.consumeContent();
//if(cookie != null) {
System.out.println("-----------------cas login success------------------------------");
System.out.println("-----------------username:"+user.getUsername()+"------------------------------");
writeCookie(httpclient,user.getUsername());
String result = doGetRequest(httpclient, url);
Document doc = DocumentHelper.parseText(result);
resp.setContentType("text/xml; charset=UTF-8");
OutputFormat format = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter writer = new XMLWriter(resp.getOutputStream(), format);
writer.write(doc);
writer.flush();
writer.close();
//}
}
httpclient.getConnectionManager().shutdown();
System.out.println("-----------------httpclient closed------------------------------");
} catch (IOException e) {
logger.error(e);
} catch (NullPointerException e) {
logger.error(e);
} catch (Exception e) {
logger.error(e);
}
System.out.println("-----*****------------securityRequest end------------------------------");
}

private static String doCasLoginRequest(HttpClient httpclient, String url) throws IOException {
System.out.println("-----*****------------doCasLoginRequest start------------------------------");
System.out.println("-----------------casUrl:"+url+"------------------------------");
String result = "";
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
BufferedReader rd = new BufferedReader(new InputStreamReader(entity.getContent(), "UTF-8"));
String tempLine = rd.readLine();
String s = "<input type=/"hidden/" name=/"lt/" value=/"";
while (tempLine != null){
int index = tempLine.indexOf(s);
if(index != -1) {
String s1 = tempLine.substring(index + s.length());
int index1 = s1.indexOf("/"");
if(index1 != -1)
result = s1.substring(0, index1);
}
tempLine = rd.readLine();
}

if (entity != null) {
entity.consumeContent();
}
System.out.println("-----------------result:"+result+"------------------------------");
System.out.println("-----*****------------doCasLoginRequest end------------------------------");
return result;
}

private String doGetRequest(HttpClient httpclient, String url) throws IOException {
System.out.println("-----*****------------doGetRequest start------------------------------");
StringBuffer result = new StringBuffer();
HttpGet httpget = new HttpGet(url);
HttpResponse response = httpclient.execute(httpget);
HttpEntity entity = response.getEntity();
BufferedReader rd = new BufferedReader(new InputStreamReader(entity.getContent(), HTTP.UTF_8));
String tempLine = rd.readLine();
while (tempLine != null){
result.append(tempLine);
tempLine = rd.readLine();
}

if (entity != null) {
entity.consumeContent();
}
System.out.println("-----------------result:"+result.toString()+"------------------------------");
System.out.println("-----*****------------doGetRequest end------------------------------");
return result.toString();
}

private Cookie getCookieValue(DefaultHttpClient httpclient, String name) {
System.out.println("-----*****------------getCookieValue start------------------------------");
List<Cookie> cookies = httpclient.getCookieStore().getCookies();
System.out.println("-----------------cookies:"+cookies.size()+"------------------------------");
if (cookies.isEmpty()) {
return null;
} else {
for (int i = 0; i < cookies.size(); i++) {
Cookie cookie = cookies.get(i);
System.out.println("-----------------cookie["+i+"]:"+cookie.getName()+"------------------------------");
if(cookie.getName().equalsIgnoreCase(name)) {
return cookie;
}
}
}
System.out.println("-----*****------------getCookieValue end------------------------------");
return null;
}

private static void writeCookie(DefaultHttpClient httpclient, String username) throws Exception{
System.out.println("-----*****-------------------writeCookie start-----------------------");
List<Cookie> myCookie = httpclient.getCookieStore().getCookies();
System.out.println("------------------------myCookie:"+myCookie+"-----------------------");
if (myCookie == null || myCookie.size() == 0) {
System.out.println("------------------------myCookie is null-----------------------");
BasicClientCookie cookie = new BasicClientCookie("ssusername", username);
// 设置当前容器中的所有页面都可以访问到该Cookie
cookie.setPath("/");
// 设置cookie的有效时间为2小时
CookieStore cookies = httpclient.getCookieStore();
cookies.addCookie(cookie);
httpclient.setCookieStore(cookies);
System.out.println("------------------------add cookie success-----------------------");
} else {
System.out.println("------------------------myCookie is not null-----------------------");
boolean flag = false;
for(int i=0;i<myCookie.size();i++){
BasicClientCookie cookie = (BasicClientCookie) myCookie.get(i);
String cookiename = cookie.getName();
System.out.println("------------------------cookie["+i+"].name:"+cookiename+"-----------------------");
if("ssusername".equals(cookiename)){
cookie.setValue(username);
flag = true;
System.out.println("------------------------edit cookie success-----------------------");
break;
}
}
System.out.println("------------------------flag:"+flag+"-----------------------");
if (!flag) {
BasicClientCookie cookie = new BasicClientCookie("ssusername", username);
CookieStore cookies = httpclient.getCookieStore();
cookies.addCookie(cookie);
httpclient.setCookieStore(cookies);
System.out.println("------------------------add cookie success-----------------------");
}
}
System.out.println("-----*****-------------------writeCookie end-----------------------");
}

public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
logger.info("请求类型: POST");
Document indoc = null;
try {
//解析客户端发送的请求
SAXReader builder = new SAXReader();
indoc = builder.read(new InputStreamReader(request.getInputStream(),"UTF-8"));
logger.info("请求信息：/n"+indoc.asXML());
} catch (Exception ex) {
logger.error("解析客户端发送的请求错误!/n"+ex);
}

String url0 = request.getQueryString();
//StringBuffer xml = new StringBuffer();
//Document doc = null;
OutputStream out = response.getOutputStream();
try {
if (url0.startsWith("url=")) {
url0 = url0.substring(4);
String urlString = new String(url0.getBytes("ISO-8859-1"),"GBK");
//StringBuffer html = new StringBuffer();
response.setContentType("text/xml");
response.setCharacterEncoding("UTF-8");
java.net.URL url = new java.net.URL(urlString);

BufferedInputStream in = null;
HttpURLConnection connection = null;
byte[] bs = null;
//int count = 0;
if (url != null) {
try {
connection = (HttpURLConnection) url.openConnection();
connection.setRequestMethod("POST");
connection.setRequestProperty("Content-Type", "application/xml");
connection.setDoInput(true);
connection.setDoOutput(true);
OutputStream toserver = connection.getOutputStream();
OutputFormat format = OutputFormat.createCompactFormat();
format.setEncoding("UTF-8");
XMLWriter writer = new XMLWriter(toserver, format);

writer.write(indoc);
toserver.flush();
toserver.close();
// 读取响应信息，并将响应发送到客户端

in = new BufferedInputStream(connection.getInputStream());
bs = new byte[1024];
int startpos = 0;
int num = 0;
num = in.read(bs, startpos, 1024);
logger.info("返回信息:");
while (num != -1) {
out.write(bs, 0, num);
logger.info(new String(bs));
num = in.read(bs, 0, 1024);
}
logger.info("/n请求地址: "+url0+"/n请求成功!");
} catch (IOException e) {
logger.error("请求地址: "+url0+"/n请求失败!"+e);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception ex) {
}
}
if (connection != null) {
try {
connection.disconnect();
} catch (Exception ex) {
}
}
}
}
}
} catch (Exception e) {
logger.error(e);
} finally {
if (out != null) {
out.flush();
out.close();
}
}
}
}