[Java] Object toevoegen aan servletcontext van buitenaf

[B-Man]

Ik ben bezig met het programmeren van een systeem dat web-plugins gebruikt voor configuratie. Deze plugins kan ik op dit moment al dynamisch laden (eigen classloader), starten, stoppen, enz.

Ik gebruik Jetty (jetty.mortbay.org) als embedded web/app server, wat zeer prettig werkt. Een module creeert zodra hij gestart wordt automatisch een nieuwe HttpContext in jetty, en is daarna direct toegangkelijk.

Alle functionaliteit wil ik in de module stoppen (niet in de JSPs); Deze regelt database toegang, enz. Ik wil vervolgens vanuit mijn JSPs functies aanroepen op mijn modules.

Ik wil binnen iedere HttpContext de bijbehorende module beschikbaar maken, zodat ik de functionaliteit die erin zit kan aanspreken. Mijn vraag is dus: hoe voeg ik in Jetty een geinstantieerd object toe aan de HttpContext van de JSPs die bij de module horen?

Ik heb reeds het volgende geprobeerd:
Embedded Jetty:

Java:

public void addModuleToContext(String context, IModule module) throws Exception{
        
    HttpHandler []handlers = server.getContext(context).getHandlers();
    for(int i=0; i< handlers.length; i++) {
        if(handlers[i] instanceof ServletHandler) {
            // We have a JSP context, add the module to it
            ServletHandler handler = (ServletHandler) handlers[i];
            handler.getServletContext().setAttribute("Module", module);
        }
    }
}

In mijn JSP:

Java:

IModule module = (IModule) application.getAttribute("Module");
Usermgt mgt = (Usermgt) module;

Waarbij IModule mijn generieke module interface is, en Usermgt een specifieke implementatie ervan (module voor gebruikersbeheer).
Ik wil de module generiek beschikbaar stellen, omdat de appserver de exacte implementatie dan niet nodig heeft, en pas hoeft te laden zodra ik in mijn JSP de module cast naar de benodigde implementatie.

Ik krijg echter alleen null door, en niet mijn IModule... Vermoedelijk zit ik in de verkeerde context, maar ik kan er weinig over vinden met google, dus tast in het duister.

[B-Man]

My Bad, ben er al achter waarom het niet werkte...
Ik had een type in mijn aanroep van addModuleToContext zitten, met als input een foutieve context.

Werkt dan toch handiger dan ik verwacht had...

Al zit ik nu met een volgend probleem: ClassCastException vanwege het feit dat de ene Usermgt niet de andere is: Ik laad de modules met een eigen ClassLoader, en Jetty laad ze met een andere engine... Eens kijken of ik de classloader van jasper (JSP engine achter Jetty) kan redirecten naar mijn eigen ClassLoader als er een module geladen moet worden.

[B-Man]

Jasper zit nu precies geintegreerd zoals ik wil: Ik heb een specifieke ClassLoader voor mijn modulen, en alle Modules worden nu, ook vanuit JSPs, netjes doorgespeeld aan mijn eigen ClassLoader.

Mooie is dat ik hiervoor slechts een wijziging van een drietal regels heb hoeven doorvoeren in JasperLoader (de CL van Jasper): namelijk de aanroep van een singleton class met static methoden die ik instantieer zodra ik mijn eigen classloader creeer. Op deze manier controleert JasperLoader of mijn eigen ModuleLoader actief is, en zo ja, speelt hij alle requests door.

Erg handig!

[Tuinhark]

Misschien is het handiger om met de HttpServletRequest te werken? Daar kun je ook attributen in hangen, maar werkt inderdaad per servlet request. Ik geef toe dat het me nog niet helemaal duidelijk is hoe de opzet van je appie is, maar zo is hoe ik het al eens heb gedaan:

Een servlet die alle HTTP requests 'onderschept' en vervolgens op basis van URL + params 'de request doorstuurt' naar een JSP. Daarvoor had ik dan binnen de servlet een object 'in de request gehangen' en die kon ik dan in de JSP er weer uit halen.

Verder had ik het zo dat de servlet al het werk deed (connecties naar DB, sessies, etc, etc) en het resultaat 'klaar zette' (in de request hing). Vervolgens hoefde de JSP dat resultaat alleen maar te tonen. Hap klare brokken enzo. Ik vermoed dat jij ook een beetje die kant op wilt.

Misschien dat die aanpak voor je werkt?

[B-Man]

Tuinhark: de focus ligt voor mij voornamelijk op functionaliteit, daarom stel ik alle modules ook direct beschikbaar in mijn programma. De modulefunctionaliteit is dus niet alleen via JSP aan te roepen. Vandaar dat ik JSP <--> functionaliteit gescheiden heb, en niet in de vorm van servlets <--> JSP; Het systeem zal in de toekomst namelijk ook remote beheer gaan ondersteunen... Een remote (RMI waarschijnlijk) connection kan vervolgens erg gemakkelijk wat zaken aanpassen, bijvoorbeeld een nieuwe module laden en activeren.

[bodiam]

Tuinhark:
Ik heb momenteel precies het probleem dat jij hier opschrijft, oftwel: het onderscheppen van alle HTTP requests door een servlet. zou je je daar misschien wat meer over kunnen uitwijden? Ik naam aan dat je het gedaan hebt door een url mapping? Ik namelijk wel, maar mijn programma komt in een loopje: /admin roept een servlet aan, die forward de request naar een jsp in /admin, bijvoorbeeld /admin/index.jsp, maar daardoor wordt de forwardende servlet weer aanroepen, etc...

Hoop dat je me kunt helpen.

Erik