/*
|
Transit - Remote procedure calls made simple
|
Copyright (c) 2012 Ulrich Hilger
|
|
This program is free software: you can redistribute it and/or modify
|
it under the terms of the GNU Affero General Public License as published by
|
the Free Software Foundation, either version 3 of the License, or
|
(at your option) any later version.
|
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU Affero General Public License for more details.
|
|
You should have received a copy of the GNU Affero General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
*/
|
|
package de.uhilger.transit;
|
|
import java.lang.reflect.Method;
|
import java.util.HashMap;
|
import java.util.Set;
|
import java.util.Iterator;
|
|
/**
|
* Methoden beliebiger Java-Klassen zur Ausfuehrung bringen und
|
* dabei Methodenaufrufe, Parameter und Rueckgabewerte als
|
* Zeichenketten (Strings) verarbeiten.
|
*
|
* @author Copyright (c) Ulrich Hilger, http://uhilger.de
|
* @author Published under the terms and conditions of
|
* the <a href="http://www.gnu.org/licenses/agpl-3.0" target="_blank">GNU Affero General Public License</a>
|
*
|
* @version 1, September 16, 2012
|
*/
|
public class JavaServer implements JavaDienst {
|
|
/**
|
* Die Sammlung von Wandlern, die dieser Server
|
* verwenden soll um Objekte in Java und zuruck
|
* zu verwandeln
|
*/
|
private HashMap<String, Wandler> wandler;
|
|
/**
|
* Ein Objekt der Klasse <code>JavaServer</code> erzeugen
|
*/
|
public JavaServer() {
|
super();
|
wandler = new HashMap<String, Wandler>();
|
}
|
|
/**
|
* Eine Klasse heraussuchen
|
*
|
* @param klassenName voller Name der gesuchten Klasse, z.B. java.lang.String
|
* @return die Klasse oder null, wenn keine Klasse mit diesem Namen gefunden wurde
|
*/
|
@SuppressWarnings("rawtypes")
|
public Class klasseFinden(String klassenName) throws Exception {
|
Class c = null;
|
c = Class.forName(klassenName);
|
return c;
|
}
|
|
/**
|
* Eine Methode ausfuehren
|
*
|
* Diese Methode sieht vor, dass ein Methodenname nur einmal in einer
|
* Klasse vorkommt. In Faellen, wo mehrere Methoden einer Klasse den
|
* selben Namen haben, wird die erste Methode dieses Namens verwendet.
|
*
|
* @param klassenName Name der Klasse
|
* @param methodenName Name der Methode
|
* @param format das Format, das Parameter und Rueckgabewert haben
|
* @param parameter die Parameter der Methode
|
* @return der Rueckgabewert der Methode nach der Ausfuehrung
|
*/
|
@SuppressWarnings("rawtypes")
|
public Object methodeAusfuehren(String klassenName, String methodenName, String format, Object... parameter) throws Exception {
|
Object resultat = null;
|
Class c = klasseFinden(klassenName);
|
if(c != null) {
|
resultat = methodeAusfuehren(c.newInstance(), methodenName, format, parameter);
|
}
|
return resultat;
|
}
|
|
/**
|
* Eine Methode ausfuehren
|
*
|
* Diese Methode sieht vor, dass ein Methodenname nur einmal in einer
|
* Klasse vorkommt. In Faellen, wo mehrere Methoden einer Klasse den
|
* selben Namen haben, wird die erste Methode dieses Namens verwendet.
|
*
|
* @param o ein Objekt der Klasse, die die auszufuehrende Methode enthaelt
|
* @param methodenName Name der Methode
|
* @param format das Format, das Parameter und Rueckgabewert haben
|
* @param parameter die Parameter der Methode
|
* @return der Rueckgabewert der Methode nach der Ausfuehrung
|
*/
|
@SuppressWarnings("rawtypes")
|
public Object methodeAusfuehren(Object o, String methodenName, String format, Object... parameter) throws Exception {
|
Object resultat = null;
|
if(o != null) {
|
Class c = o.getClass();
|
Method m = findeMethode(c.getDeclaredMethods(), methodenName);
|
resultat = methodeAusfuehren(o, m, format, parameter);
|
}
|
return resultat;
|
}
|
|
/**
|
* Eine Methode ausfuehren
|
*
|
* @param o ein Objekt der Klasse, die die auszufuehrende Methode enthaelt
|
* @param methode das Methodenobjekt, das ausgefuehrt werden soll
|
* @param format das Format, das Parameter und Rueckgabewert haben
|
* @param parameter die Parameter der Methode
|
* @return der Rueckgabewert der Methode nach der Ausfuehrung
|
*/
|
@SuppressWarnings("rawtypes")
|
public Object methodeAusfuehren(Object o, Method methode, String format, Object... parameter) throws Exception {
|
Object resultat = null;
|
if(methode != null) {
|
Access access = methode.getAnnotation(Access.class);
|
if(access != null && access.type().equals(Access.Type.ALLOW)) {
|
resultat = methode.invoke(o, parameterKonvertieren(methode, parameter, format));
|
Class returnType = methode.getReturnType();
|
/*
|
* Wenn der Rueckgabewert der Methode nicht vom Typ String ist,
|
* wird das Objekt in das Format verwandelt, das der Standardwandler
|
* liefert, z.B. JSON
|
*/
|
if(!returnType.getName().equals("java.lang.String")) {
|
//resultat = new JsonWandler().vonJava(resultat, returnType);
|
Wandler w = wandler.get(format);
|
if(w != null) {
|
resultat = w.vonJava(resultat, returnType);
|
}
|
/*if(format == Wandler.JSON) {
|
resultat = new JsonWandler().vonJava(resultat, returnType);
|
}*/
|
}
|
} else {
|
// nicht zum Zugriff vorgesehen
|
}
|
}
|
return resultat;
|
}
|
|
/**
|
* Zur Vereinfachung wird hier angenommen, dass es nur Eingangsparamter vom Typ String gibt
|
*
|
* @param m
|
* @param parameter
|
* @return
|
*/
|
@SuppressWarnings("rawtypes")
|
protected Object[] parameterKonvertieren(Method m, Object[] parameter, String format) throws Exception {
|
Object[] resultat = null;
|
if(parameter != null && parameter.length > 0) {
|
resultat = new Object[parameter.length];
|
Class[] types = m.getParameterTypes();
|
for(int i = 0; i < types.length; i++) {
|
resultat[i] = toType(types[i], parameter[i].toString(), format);
|
}
|
}
|
return resultat;
|
}
|
|
/**
|
* Umwandlung von String zu einem anderen Typ
|
*
|
* @param c die Klasse, in deren Typ umgewandelt werden soll
|
* @param parameter der Wert, der umgewandelt werden soll
|
* @return der Parameter umgewandelt in den gewuenschten Typ oder null, falls
|
* die Umwandlung nicht gelang
|
*/
|
@SuppressWarnings("rawtypes")
|
protected Object toType(Class c, String parameter, String format) throws Exception {
|
Object o = null;
|
String className = c.getName();
|
if(className.equals("java.lang.Integer") || className.equals("int")) {
|
o = Integer.parseInt(parameter);
|
} else if(className.equals("java.lang.Short") || className.equals("short")) {
|
o = Short.parseShort(parameter);
|
} else if(className.equals("java.lang.Boolean") || className.equals("boolean")) {
|
o = Boolean.parseBoolean(parameter);
|
} else if(className.equals("java.lang.Character") || className.equals("char")) {
|
o = Character.valueOf(parameter.charAt(0));
|
} else if(className.equals("java.lang.Byte") || className.equals("byte")) {
|
o = Byte.parseByte(parameter);
|
} else if(className.equals("java.lang.Long") || className.equals("long")) {
|
o = Long.parseLong(parameter);
|
} else if(className.equals("java.lang.Double") || className.equals("double")) {
|
o = Double.parseDouble(parameter);
|
} else if(className.equals("java.lang.String")) {
|
o = parameter;
|
} else {
|
/*
|
* wenn die Ziel-Klasse keine der vorigen Klasse ist wird angenommen, dass
|
* der Standardwandler das Format erzeugen kann, z.B. aus einem JSON-String
|
*/
|
//o = wandler.get(format).zuJava(parameter, c);
|
//o = new JsonWandler().zuJava(parameter, c);
|
Wandler w = wandler.get(format);
|
if(w != null) {
|
o = w.zuJava(parameter, c);
|
}
|
/*if(format == Wandler.JSON) {
|
o = new JsonWandler().zuJava(parameter, c);
|
}*/
|
}
|
return o;
|
}
|
|
/**
|
* Eine Methode aus einer Liste von Methoden heraussuchen
|
* @param methoden die Liste der Methoden
|
* @param methodenName der Name der gesuchten Methode
|
* @return die Methode oder null, wenn die gesuchte Methode nicht gefunden wurde
|
*/
|
protected Method findeMethode(Method[] methoden, String methodenName) {
|
Method methode = null;
|
for(int i = 0; methode == null && i < methoden.length; i++) {
|
Method m = methoden[i];
|
if(m.getName().equals(methodenName)) {
|
methode = m;
|
}
|
}
|
return methode;
|
}
|
|
/**
|
* Eine Methode heraussuchen
|
*
|
* Diese Methode sieht vor, dass ein Methodenname nur einmal in einer
|
* Klasse vorkommt. In Faellen, wo mehrere Methoden einer Klasse den
|
* selben Namen haben, wird die erste Methode dieses Namens geliefert.
|
*
|
* @param klassenName Name der Klasse
|
* @param methodenName Name der gesuchten Mthode
|
* @return die Methode oder null, wenn keine Methode mit diesem Namen
|
* in der angegebenen Klasse gefunden wurde
|
*/
|
@SuppressWarnings("rawtypes")
|
public Method methodeFinden(String klassenName, String methodenName) throws Exception {
|
Method m = null;
|
Class klasse = Class.forName(klassenName);
|
if(klasse != null) {
|
m = findeMethode(klasse.getDeclaredMethods(), methodenName);
|
}
|
return m;
|
}
|
|
/**
|
* Einen Wandler entfernen
|
*
|
* @param wandler der Wandler, der entfernt werden soll
|
*/
|
public void wandlerEntfernen(Wandler wandler) {
|
this.wandler.remove(wandler.getFormat());
|
}
|
|
/**
|
* Einen Wandler hinzufuegen
|
*
|
* @param wandler der Wandler, der hinzugefuegt werden soll
|
*/
|
public void wandlerHinzufuegen(Wandler wandler) {
|
this.wandler.put(wandler.getFormat(), wandler);
|
}
|
|
/**
|
* Diese Instanz aufloesen, also alle Ressourcen frei geben
|
*/
|
public void aufloesen() {
|
Set keySet = wandler.keySet();
|
Iterator i = keySet.iterator();
|
while(i.hasNext()) {
|
String key = i.next().toString();
|
Wandler w = wandler.get(key);
|
w.aufloesen();
|
w = null;
|
}
|
wandler.clear();
|
wandler = null;
|
}
|
|
}
|
