web/neon.git - Ulrich Hilger Code Repository

ulrich

2024-02-23 821908f431da5815b0ca1d0c39f5f30c4c3ce0f3

commit \| author \| age
e58690	1	/*
U	2	neon - Embeddable HTTP Server based on jdk.httpserver
	3	Copyright (C) 2024 Ulrich Hilger
	4
	5	This program is free software: you can redistribute it and/or modify
	6	it under the terms of the GNU Affero General Public License as
	7	published by the Free Software Foundation, either version 3 of the
	8	License, or (at your option) any later version.
	9
	10	This program is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	GNU Affero General Public License for more details.
	14
	15	You should have received a copy of the GNU Affero General Public License
	16	along with this program. If not, see <https://www.gnu.org/licenses/>.
	17	*/
	18	package de.uhilger.neon;
	19
	20	import com.sun.net.httpserver.HttpExchange;
	21	import com.sun.net.httpserver.HttpHandler;
	22	import de.uhilger.neon.Action.Type;
5ebab9	23	import de.uhilger.neon.entity.ActionDescriptor;
e58690	24	import java.io.IOException;
U	25	import java.lang.reflect.InvocationTargetException;
	26	import java.lang.reflect.Method;
	27	import java.lang.reflect.Parameter;
	28	import java.util.EnumMap;
	29	import java.util.HashMap;
	30	import java.util.Iterator;
	31	import java.util.List;
	32	import java.util.Map;
	33
	34	/**
5ebab9	35	* Objekte der Klasse Handler nehmen Objekte entgegen die die Annotationen NeonActor enthalten.
U	36	* Deren mit NeonMethod annotierten Methoden stellt der Handler via HTTP bereit.
e58690	37	*
5ebab9	38	* Wird ein Neon-Server mit der Klasse NeonFactory erzeugt, kann mit der Verwendung dieses Handlers
U	39	* die NeonFactory den Server selbsttaetig erstellen, ohne zusaetzlichen Boilerplate Code, den eine
	40	* eigene Anwendung mitbringen muesste.
e58690	41	*
U	42	* @author Ulrich Hilger
	43	* @version 1, 6.2.2024
	44	*/
	45	public class Handler implements HttpHandler {
	46
	47	private final Map<Type, Map> dispatcher;
	48
	49	/**
	50	* Ein Objekt der Klasse Handler erzeugen
	51	*/
	52	public Handler() {
	53	dispatcher = new EnumMap<>(Type.class);
5ebab9	54	//dispatcher.put(Type.GET, new HashMap<String, String>());
U	55	//dispatcher.put(Type.PUT, new HashMap<String, String>());
	56	//dispatcher.put(Type.POST, new HashMap<String, String>());
	57	//dispatcher.put(Type.DELETE, new HashMap<String, String>());
	58	dispatcher.put(Type.GET, new HashMap<String, ActionDescriptor>());
	59	dispatcher.put(Type.PUT, new HashMap<String, ActionDescriptor>());
	60	dispatcher.put(Type.POST, new HashMap<String, ActionDescriptor>());
	61	dispatcher.put(Type.DELETE, new HashMap<String, ActionDescriptor>());
e58690	62	}
U	63
	64	/**
	65	* Diesem Handler einen Actor hinzufuegen
	66	*
	67	* @param methodType HTTP Methode
	68	* @param route die Route, ueber die der Actor aufgerufen werden soll
	69	* @param className die Klasse, die die Methode enthaelt, die zur Verarbeitung der Route
	70	* ausgefuehrt werden soll
	71	*/
	72	public void setActor(Type methodType, String route, String className) {
5ebab9	73	ActionDescriptor ad = new ActionDescriptor();
U	74	ad.className = className;
	75	ad.routeParams = new HashMap<>();
	76	int pos = route.indexOf("{");
	77	if (pos > -1) {
	78	String paramStr = route.substring(pos);
	79	String[] params = paramStr
	80	.replaceAll("\\{", "")
	81	.replaceAll("\\}", "")
	82	.split("/");
	83	for (int i = 0; i < params.length; i++) {
	84	ad.routeParams.put(params[i], i);
	85	}
	86	ad.route = route.substring(0, pos - 1);
	87	} else {
	88	// Map kann leer bleiben
	89	ad.route = route;
	90	}
	91
e58690	92	//Logger.getLogger(Handler.class.getName())
U	93	// .log(Level.INFO, "{0} {1} {2}", new Object[]{methodType, route, className});
5ebab9	94	dispatcher.get(methodType).put(ad.route, ad);
e58690	95	}
U	96
	97	/**
	98	* Eine Antwort senden
	99	*
	100	* Diese Methode kann ueberschrieben werden, falls die Antwort vor dem Senden noch weiter
	101	* bearbeiten werden soll.
	102	*
	103	* @param exchange das Objekt mit Informationen zu HTTP Anfrage und -Antwort
	104	* @param response das Ergebnisobjekt, das als Antwort gesendet werden soll
	105	* @throws IOException wenn die Antwort nicht gesendet werden kann
	106	*/
	107	public void respond(HttpExchange exchange, Object response) throws IOException {
	108	new HttpResponder().antwortSenden(exchange, HttpResponder.SC_OK, response.toString());
	109	}
	110
	111	/**
	112	* Das Objekt abrufen, das auf die Routen verweist, die von diesem Handler beantwortet werden.
	113	*
	114	* eine Map<Type, Map<String, String>> GET - route1 - Klassenname GET - route2 - Klassenname PUT -
	115	* route1 - Klassenname PUT - route2 - Klassenname usw.
	116	*
	117	* @return das Dispatcher-Objekt dieses Handlers
	118	*/
	119	public Map<Type, Map> getDispatcher() {
	120	return dispatcher;
	121	}
	122
	123	/**
	124	* Eine HTTP-Anfrage ausfuehren
	125	*
	126	* @param exchange das Objekt mit Informationen zu HTTP Anfrage und -Antwort
	127	* @throws IOException
	128	*/
	129	@Override
	130	public void handle(HttpExchange exchange) throws IOException {
880582	131	String route = exchange
U	132	.getRequestURI()
	133	.getPath()
	134	.substring(exchange
	135	.getHttpContext()
	136	.getPath()
	137	.length());
	138
e58690	139	Type requestMethod = Type.valueOf(exchange.getRequestMethod());
U	140	/*
	141	Es wird erst geprueft, ob zu einer bestimmten Route
	142	ein Actor registriert wurde. Wenn kein Actor mit dieser
	143	Route existiert, wird geprueft, ob ein Actor
	144	mit der Route '/' vorhanden ist.
	145	*/
5ebab9	146	boolean found = false;
63bcde	147	Object md = dispatcher.get(requestMethod);
5ebab9	148	if (md instanceof Map) {
U	149	int pos = route.lastIndexOf("/");
	150	Object o = ((Map) md).get(route);
	151	if (!(o instanceof ActionDescriptor)) {
	152	while (!found && (pos > -1)) {
	153	String routeRest = route.substring(0, pos);
	154	o = ((Map) md).get(routeRest);
	155	if (o instanceof ActionDescriptor) {
	156	found = true;
	157	handleRequest(exchange, o, routeRest, route.substring(routeRest.length()));
e58690	158	}
5ebab9	159	pos = routeRest.lastIndexOf("/");
e58690	160	}
5ebab9	161	} else {
U	162	found = true;
	163	handleRequest(exchange, o, route, route);
e58690	164	}
5ebab9	165	if (!found) {
U	166	o = dispatcher.get(requestMethod).get("/");
	167	if (o instanceof ActionDescriptor) {
	168	handleRequest(exchange, o, route, route);
	169	}
	170	}
63bcde	171	}
e58690	172
U	173	}
	174
5ebab9	175	private void handleRequest(HttpExchange exchange, Object o, String route, String subroute) throws IOException {
U	176	ActionDescriptor ad = (ActionDescriptor) o;
	177	String actorClassName = ad.className;
	178	try {
	179	Class actorClass = Class.forName(actorClassName);
	180	Method[] methods = actorClass.getMethods();
	181	for (Method method : methods) {
	182	Action action = method.getAnnotation(Action.class);
	183	if (action != null) {
	184	if (action.route().equals("/") \|\| action.route().startsWith(route)) {
	185	Object[] actionArgs = getActionArgs(exchange, method, ad, subroute);
	186	Object actorObj = actorClass.getDeclaredConstructor().newInstance();
	187	addDataProvider(exchange, actorObj);
	188	Object antwort = method.invoke(actorObj, actionArgs);
	189	if (!action.handlesResponse()) {
	190	respond(exchange, antwort);
	191	}
	192	}
	193	}
	194	}
	195	} catch (ClassNotFoundException \| NoSuchMethodException \| SecurityException \|
	196	InstantiationException \| IllegalAccessException \| IllegalArgumentException \|
	197	InvocationTargetException ex) {
	198	// Klasse nicht gefunden. Muss das geloggt oder sonstwie behandel werden?
	199	}
	200	//}
	201	}
	202
	203	private Object[] getActionArgs(HttpExchange exchange, Method method, ActionDescriptor ad, String subroute) {
63bcde	204	int count = method.getParameterCount();
e58690	205	Parameter[] methodParams = method.getParameters();
63bcde	206	Object[] actionArgs = new Object[count];
5ebab9	207	String[] routeParams = subroute.split("/");
880582	208
U	209
	210	/*
	211	Fall 1: Es sind mehr als ein Parameter zu uebergeben und die Route enthaelt
	212	weniger Parameter als die Methode erfordert.
	213	Fall 2: Die Methode erwartet Parameter und der erste Parameter ist nicht
	214	vom Typ HttpExchange.
	215
	216	Wenn einer dieser beiden Faelle eintritt, wird alles als Parameter an die Methode
	217	uebergeben, was eventuell als Teil einer Query im URL oder im Body enthalten ist.
8bab5f	218	Fuer Mthoden, die nicht vom Typ HTTP GET sind, kann ein Actor kann dann den Body
U	219	nicht mehr lesen, weil das bereits an dieser Stelle gemacht wurde.
880582	220	*/
63bcde	221	Map queryParams = new HashMap();
5ebab9	222	if ((count > 1 && count > routeParams.length)
U	223	\|\| (methodParams.length > 0 && !methodParams[0].getType().equals(HttpExchange.class))) {
63bcde	224	queryParams = new HttpHelper().getQueryMap(exchange);
U	225	}
880582	226
63bcde	227	int k = 0;
e58690	228	for (Parameter methodParam : methodParams) {
U	229	if (methodParam.getType().equals(HttpExchange.class)) {
	230	actionArgs[k] = exchange;
	231	} else {
5ebab9	232	Integer i = ad.routeParams.getOrDefault(methodParam.getName(), -1);
U	233	if (i < 0) {
	234	actionArgs[k] = queryParams.get(methodParam.getName());
	235	} else {
	236	actionArgs[k] = routeParams[i + 1];
	237	}
e58690	238	}
5ebab9	239	++k;
e58690	240	}
U	241	return actionArgs;
	242	}
	243
	244	private void addDataProvider(HttpExchange exchange, Object actorObj) {
	245	if (actorObj instanceof DataConsumer) {
	246	DataConsumer consumer = (DataConsumer) actorObj;
	247	Object sdpListObj = exchange.getHttpContext().getAttributes().get("serverDataProviderList");
	248	if (sdpListObj instanceof List) {
	249	List sdpList = (List) sdpListObj;
	250	Iterator i = sdpList.iterator();
	251	while (i.hasNext()) {
	252	Object value = i.next();
	253	if (value instanceof DataProvider) {
	254	consumer.addDataProvider((DataProvider) value);
	255	}
	256	}
	257	}
	258	}
	259	}
	260	}