Quellcode der Klasse
package systems.sdw.statt.util;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Properties;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
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.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.json.JSONException;
import org.json.JSONObject;
import systems.sdw.generic.Exceptions;
public class Client {
//
CloseableHttpClient httpclient=null;
// default encoding
public static String encodingUTF8="UTF-8";
// properties map
public static final String propServer="server";
public static final String propPort="port";
public static final String propScheme="scheme";
public static final String propLogin="login";
public static final String propPassword="password";
//
private String scheme="https";
private String server="stattbuchung.de";
private String port="443";
private String path="/SDW/statt";
private String login="?";
private String password="?";
// opcodes
private static final String opcLogon="1003"; // connect and start session
private static final String opcLogoff="1002"; // close session properly and disconnect
// challange url is prohibited so server starts authentification process when calling this (1. step)
private String getLoginURL() {
return scheme+"://"+server+":"+port+path+"?opc="+opcLogon;
}
// login form url. call this as 2. step
private String getFormURL() {
return scheme+"://"+server+":"+port+path+"/j_security_check";
}
// use this url for all communication after login in succeeded
private String getFcURL(String opc) {
return scheme+"://"+server+":"+port+path+"?opc="+opc;
}
private String getFcURL(String opc, List <NameValuePair> nvps) {
StringBuffer buf=new StringBuffer(getFcURL(opc));
ListIterator<NameValuePair> it=nvps.listIterator();
while (it.hasNext()) {
try {
NameValuePair nvp=it.next();
buf.append("&"+nvp.getName()+"="+URLEncoder.encode(nvp.getValue(), encodingUTF8));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
return buf.toString();
}
// quit session by calling this url
private String getLogoutURL() {
return scheme+"://"+server+":"+port+path+"?opc="+opcLogoff;
}
// default constructor with properties map
public Client(Properties props) {
// provide at least login and password
if (props.getProperty(propServer)!=null) this.setServer((String) props.getProperty(propServer));
if (props.getProperty(propScheme)!=null) this.setScheme((String) props.getProperty(propScheme));
if (props.getProperty(propPort)!=null) this.setPort((String) props.getProperty(propPort));
if (props.getProperty(propLogin)!=null) this.setKennung((String) props.getProperty(propLogin));
if (props.getProperty(propPassword)!=null) this.setKennwort((String) props.getProperty(propPassword));
//
try {
this.httpclient=HttpClients.createDefault();
} catch (Exception e) {
e.printStackTrace();
}
}
public boolean connect() throws Exception {
System.out.println("Client trying to connect with given params:");
System.out.println(server);
System.out.println(port);
System.out.println(scheme);
System.out.println(login);
System.out.println(password);
try {
// call prohibited url to log in
HttpGet httpGet=new HttpGet(getLoginURL());
HttpResponse response=httpclient.execute(httpGet);
System.out.println("HTTPClient connect 1/3 "+getLoginURL()+" "+response.getStatusLine());
if (response.getStatusLine().getStatusCode()!=200) {
System.out.println("Server-Fehler beim Zugriff auf die URL "+getLoginURL());
return false;
}
HttpEntity entity=response.getEntity();
EntityUtils.consume(entity);
// call login form url and prived credentials
HttpPost httpPost=new HttpPost(getFormURL());
List <NameValuePair> nvps=new ArrayList <NameValuePair>();
nvps.add(new BasicNameValuePair("j_username", this.login));
nvps.add(new BasicNameValuePair("j_password", this.password));
httpPost.setEntity(new UrlEncodedFormEntity(nvps, encodingUTF8));
response=httpclient.execute(httpPost);
System.out.println("HTTPClient connect 2/3 "+getFormURL()+" "+nvps.toString()+ " " + response.getStatusLine());
entity=response.getEntity();
EntityUtils.consume(entity);
// if credentials are ok server maps desired url so we can access it: check also for status 302=moved temporarily
if (response.getStatusLine().getStatusCode()==302) {
// no we can call login url again to establish session
httpGet=new HttpGet(getLoginURL());
response=httpclient.execute(httpGet);
System.out.println("HTTPClient connect 3/3 "+getLoginURL()+" "+response.getStatusLine());
// it's always a good idea to check for successfull login on transport layer
if (response.getStatusLine().getStatusCode()!=200) {
System.out.println("Server-Fehler beim Zugriff auf die URL "+getLoginURL());
return false;
}
// check for any exception reported from server on logical layer after successfull login
// dont use a connection when any exception is reported because there is no valid session
checkExceptions(response.getEntity());
// ok, login successfull and session established
EntityUtils.consume(entity);
return true;
}
else {
// otherwise: credentials not ok!
System.out.println("Die Kennung/Kennwort-Kombination "+login+"/"+password+" ist vom Server nicht akzeptiert worden.");
return false;
}
} catch (ClientProtocolException e) {
e.printStackTrace();
return false;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
public static void checkExceptions(HttpEntity responseEntity) throws Exception {
checkExceptions(getResponseAsJSON(responseEntity));
}
public static void checkExceptions(JSONObject response) throws Exception {
try {
JSONObject exception=response.getJSONObject("exception");
if (exception!=null) {
if (exception.getString("exception").equalsIgnoreCase("NoSessionAvailableException")) {
throw new Exceptions.NoSessionAvailableException(exception);
}
else if (exception.getString("exception").equalsIgnoreCase("WrongParamException")) {
throw new Exceptions.WrongParamException(exception);
}
else throw new Exception(exception.getString("exception"));
}
} catch (JSONException e) {;}
}
public static JSONObject getResponseAsJSON(HttpEntity responseEntity) {
if (responseEntity != null){
try {
BufferedReader streamReader = new BufferedReader(new InputStreamReader(responseEntity.getContent(), "UTF-8"));
StringBuilder responseStrBuilder = new StringBuilder();
String inputStr=null;
while ((inputStr = streamReader.readLine()) != null) responseStrBuilder.append(inputStr);
JSONObject json=new JSONObject(responseStrBuilder.toString());
//System.out.println(json.toString(4));
return json;
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
// use this to dump response to stdout for debugging purposes
@SuppressWarnings("unused")
private static void dump(HttpEntity entity) throws IllegalStateException, IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(entity.getContent()));
String readLine;
while(((readLine = br.readLine()) != null)) {
System.err.println(readLine);
}
}
private static boolean checkStatus(HttpResponse response) {
switch (response.getStatusLine().getStatusCode()) {
case 200:
case 302:
return true;
default:
return false;
}
}
public boolean disconnect() {
try {
HttpGet httpGet=new HttpGet(getLogoutURL());
HttpResponse response=httpclient.execute(httpGet);
System.out.println("HTTPClient disconnect 1/1 "+getLogoutURL()+" "+response.getStatusLine());
if (response.getStatusLine().getStatusCode()!=200) return false;
HttpEntity entity=response.getEntity();
EntityUtils.consume(entity);
httpclient=null;
return true;
} catch (ClientProtocolException e) {
e.printStackTrace();
return false;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
public JSONObject get(String opc) throws Exception {
return get(opc, new ArrayList <NameValuePair>());
}
public JSONObject get(String opc, List <NameValuePair> nvps) throws Exception {
JSONObject result=null;
HttpGet httpGet= new HttpGet(this.getFcURL(opc, nvps));
try {
HttpResponse response=httpclient.execute(httpGet);
System.out.println("HTTPClient get 1/1 "+getFcURL(opc, nvps)+" "+response.getStatusLine());
if (checkStatus(response)) {
HttpEntity entity=response.getEntity();
result=getResponseAsJSON(entity);
EntityUtils.consume(entity);
checkExceptions(result);
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
public JSONObject post(String opc, JSONObject json) throws Exception {
JSONObject result=null;
HttpPost httpPost=new HttpPost(this.getFcURL(opc));
try {
List <NameValuePair> nvps=new ArrayList <NameValuePair>();
nvps.add(new BasicNameValuePair("data", json.toString()));
httpPost.setEntity(new UrlEncodedFormEntity(nvps, encodingUTF8));
UrlEncodedFormEntity x=new UrlEncodedFormEntity(nvps, encodingUTF8);
x.writeTo(System.out);
HttpResponse response=httpclient.execute(httpPost);
System.out.println("HTTPClient post 1/1 "+response.getStatusLine());
if (checkStatus(response)) {
HttpEntity entity=response.getEntity();
result=getResponseAsJSON(entity);
EntityUtils.consume(entity);
checkExceptions(result);
}
} catch (ClientProtocolException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return result;
}
public String getScheme() {return scheme;}
public void setScheme(String scheme) {this.scheme=scheme;}
public void setKennung(String login) {this.login= login;}
public void setKennwort(String password) {this.password= password;}
public String getServer() {return server;}
public void setServer(String server) {this.server=server;}
public String getPort() {return port;}
public void setPort(String port) {this.port=port;}
public String getPath() {return path;}
public void setPath(String path) {this.path=path;}
}