Hoe een servlet in Java te registreren

1. Inleiding

Dit artikel biedt een overzicht van hoe je een servlet registreert binnen Jakarta EE en Spring Boot. We zullen specifiek kijken naar twee manieren om een ​​Java-servlet in Jakarta EE te registreren - een met een web.xml bestand, en de andere met behulp van annotaties. Vervolgens registreren we servlets in Spring Boot met behulp van XML-configuratie, Java-configuratie en via configureerbare eigenschappen.

Een geweldig inleidend artikel over servlets is hier te vinden.

2. Servlets registreren in Jakarta EE

Laten we twee manieren bekijken om een ​​servlet in Jakarta EE te registreren. Ten eerste kunnen we een servlet registreren via web.xml. Als alternatief kunnen we de Jakarta EE gebruiken @WebServlet annotatie.

2.1. Via web.xml

De meest gebruikelijke manier om een ​​servlet in uw Jakarta EE-toepassing te registreren, is door deze toe te voegen aan uw web.xml het dossier:

 index.html index.htm index.jsp Voorbeeld com.baeldung.Voorbeeld Voorbeeld / Voorbeeld 

Zoals u kunt zien, omvat dit twee stappen: (1) het toevoegen van onze servlet aan het servlet tag, zorg ervoor dat u ook het bronpad specificeert naar de klasse waarin de servlet zich bevindt, en (2) specificeer het URL-pad waarop de servlet wordt weergegeven in de url-patroon label.

De Jakarta EE web.xml bestand is meestal te vinden in WebContent / WEB-INF.

2.2. Via annotaties

Laten we nu onze servlet registreren met de @WebServlet annotatie op onze aangepaste servletklasse. Dit elimineert de noodzaak voor servlet-toewijzingen in het server.xml en registratie van de servlet in web.xml:

@WebServlet (name = "AnnotationExample", description = "Voorbeeldservlet die annotaties gebruikt", urlPatterns = {"/ AnnotationExample"}) openbare klasse Voorbeeld breidt HttpServlet uit {@Override protected void doGet (HttpServletRequest-verzoek, HttpServletResponse-antwoord {) genereert Is ServOException-antwoord {) response.setContentType ("text / html"); PrintWriter uit = response.getWriter (); out.println ("

Hallo Wereld!

"); } }

De bovenstaande code laat zien hoe u die annotatie rechtstreeks aan een servlet kunt toevoegen. De servlet is nog steeds beschikbaar op hetzelfde URL-pad als voorheen.

3. Servlets registreren in Spring Boot

Nu we hebben laten zien hoe servlets in Jakarta EE kunnen worden geregistreerd, gaan we eens kijken naar verschillende manieren om servlets in een Spring Boot-toepassing te registreren.

3.1. Programmatische registratie

Spring Boot ondersteunt 100% programmatische configuratie van een webapplicatie.

Eerst implementeren we het WebApplicationInitializer interface en implementeer vervolgens het WebMvcConfigurer interface, waarmee u vooraf ingestelde standaardinstellingen kunt overschrijven in plaats van dat u elke specifieke configuratie-instelling hoeft op te geven, waardoor u tijd bespaart en u direct met verschillende beproefde instellingen kunt werken.

Laten we naar een voorbeeld kijken WebApplicationInitializer implementatie:

openbare klasse WebAppInitializer implementeert WebApplicationInitializer {public void onStartup (ServletContext-container) gooit ServletException {AnnotationConfigWebApplicationContext ctx = nieuwe AnnotationConfigWebApplicationContext (); ctx.register (WebMvcConfigure.class); ctx.setServletContext (container); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcherExample", nieuwe DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }}

Laten we vervolgens het WebMvcConfigurer koppel:

@Configuration openbare klasse WebMvcConfigure implementeert WebMvcConfigurer {@Bean openbare ViewResolver getViewResolver () {InternalResourceViewResolver resolver = nieuwe InternalResourceViewResolver (); resolver.setPrefix ("/ WEB-INF /"); resolver.setSuffix (". jsp"); return resolver; } @Override public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {configurer.enable (); } @Override public void addResourceHandlers (register ResourceHandlerRegistry) {registry.addResourceHandler ("/ resources / **") .addResourceLocations ("/ resources /"). SetCachePeriod (3600) .resourceChain (true) .addResolver (nieuwe PathRes) ; }}

Hierboven specificeren we expliciet enkele van de standaardinstellingen voor JSP-servlets om .jsp weergaven en statische bronweergave.

3.2. XML-configuratie

Een andere manier om servlets in Spring Boot te configureren en te registreren is via web.xml:

 dispatcher org.springframework.web.servlet.DispatcherServlet contextConfigLocation /WEB-INF/spring/dispatcher.xml 1 dispatcher / 

De web.xml die wordt gebruikt om de configuratie in Spring op te geven, is vergelijkbaar met die in Jakarta EE. Hierboven kunt u zien hoe we nog enkele parameters specificeren via attributen onder de servlet label.

Hier gebruiken we een andere XML om de configuratie te voltooien:

Onthoud dat uw lente web.xml zal gewoonlijk in leven src / main / webapp / WEB-INF.

3.3. XML en programmatische registratie combineren

Laten we een XML-configuratiebenadering combineren met de programmatische configuratie van Spring:

public void onStartup (ServletContext-container) gooit ServletException {XmlWebApplicationContext xctx = nieuwe XmlWebApplicationContext (); xctx.setConfigLocation ('classpath: /context.xml'); xctx.setServletContext (container); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcher", nieuwe DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }

Laten we ook de dispatcher-servlet configureren:

3.4. Registratie door Bean

We kunnen onze servlets ook programmatisch configureren en registreren met behulp van een ServletRegistrationBean. Hieronder doen we dit om een HttpServlet (die het javax.servlet.Servlet koppel):

@Bean openbare ServletRegistrationBean exampleServletBean () {ServletRegistrationBean bean = nieuwe ServletRegistrationBean (nieuwe CustomServlet (), "/ exampleServlet / *"); bean.setLoadOnStartup (1); terugkeer boon; }

Het belangrijkste voordeel van deze aanpak is dat u zowel meerdere servlets als verschillende soorten servlets aan uw Spring-applicatie kunt toevoegen.

In plaats van alleen een VerzenderServlet, dat is een meer specifiek soort HttpServlet en de meest voorkomende soort die wordt gebruikt in de WebApplicationInitializer programmatische benadering van configuratie die we hebben onderzocht in sectie 3.1, we zullen een eenvoudiger HttpServlet subklasse-instantie die de vier basis HttpRequest bewerkingen via vier functies: doGet (), doPost (), doPut (), en doDelete () net als in Jakarta EE.

Onthoud dat HttpServlet een abstracte klasse is (dus het kan niet worden geïnstantieerd). We kunnen echter gemakkelijk een aangepaste extensie maken:

openbare klasse CustomServlet breidt HttpServlet {...} uit

4. Servlets registreren met eigenschappen

Een andere, hoewel ongebruikelijke, manier om uw servlets te configureren en te registreren, is door een aangepast eigenschappenbestand te gebruiken dat in de app is geladen via een PropertyLoader, PropertySource, of PropertySources instantie-object.

Dit biedt een tussenliggende configuratie en de mogelijkheid om anderszins aan te passen application.properties die weinig directe configuratie bieden voor niet-ingebedde servlets.

4.1. Systeemeigenschappen aanpak

We kunnen enkele aangepaste instellingen toevoegen aan onze application.properties bestand of een ander eigenschappenbestand. Laten we een paar instellingen toevoegen om onze DispatcherServlet:

servlet.name = dispatcherExample servlet.mapping = / dispatcherExampleURL

Laten we onze aangepaste eigenschappen in onze applicatie laden:

System.setProperty ("custom.config.location", "classpath: custom.properties");

En nu hebben we toegang tot die eigenschappen via:

System.getProperty ("custom.config.location");

4.2. Aangepaste eigenschappenbenadering

Laten we beginnen met een custom.properties het dossier:

servlet.name = dispatcherExample servlet.mapping = / dispatcherExampleURL

We kunnen dan een doorsnee Property Loader gebruiken:

openbare Eigenschappen getProperties (String-bestand) gooit IOException {Eigenschappen prop = nieuwe Eigenschappen (); InputStream input = null; input = getClass (). getResourceAsStream (bestand); prop.load (invoer); if (input! = null) {input.close (); } terugkeer prop; }

En nu kunnen we deze aangepaste eigenschappen als constanten toevoegen aan onze WebApplicationInitializer implementatie:

private statische laatste PropertyLoader pl = nieuwe PropertyLoader (); private statische definitieve Eigenschappen springProps = pl.getProperties ("custom_spring.properties"); openbare statische laatste String SERVLET_NAME = springProps.getProperty ("servlet.name"); openbare statische laatste String SERVLET_MAPPING = springProps.getProperty ("servlet.mapping");

We kunnen ze vervolgens gebruiken om bijvoorbeeld onze dispatcher-servlet te configureren:

ServletRegistration.Dynamic servlet = container.addServlet (SERVLET_NAME, nieuwe DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping (SERVLET_MAPPING);

Het voordeel van deze aanpak is de afwezigheid van .xml onderhoud, maar met eenvoudig aan te passen configuratie-instellingen waarvoor de codebase niet opnieuw hoeft te worden geïmplementeerd.

4.3. De PropertySource Nadering

Een snellere manier om het bovenstaande te bereiken, is door gebruik te maken van Spring's PropertySource waarmee een configuratiebestand kan worden geopend en geladen.

PropertyResolver is een interface geïmplementeerd door Configureerbare omgeving, die applicatie-eigenschappen beschikbaar maakt bij het opstarten en initialiseren van de servlet:

@Configuration @PropertySource ("classpath: /com/yourapp/custom.properties") openbare klasse ExampleCustomConfig {@Autowired ConfigurableEnvironment env; public String getProperty (String key) {return env.getProperty (key); }}

Hierboven zetten we automatisch een afhankelijkheid in de klasse en specificeren we de locatie van ons aangepaste eigenschappenbestand. We kunnen dan onze meest opvallende eigenschap ophalen door de functie aan te roepen getProperty () doorgeven van de String-waarde.

4.4. De programmatische aanpak van PropertySource

We kunnen de bovenstaande benadering (waarbij eigenschapswaarden worden opgehaald) combineren met de onderstaande benadering (waarmee we die waarden programmatisch kunnen specificeren):

ConfigurableEnvironment env = nieuwe StandardEnvironment (); MutablePropertySources rekwisieten = env.getPropertySources (); Map map = nieuwe HashMap (); map.put ("sleutel", "waarde"); props.addFirst (nieuwe MapPropertySource ("Kaart", kaart));

We hebben een kaart gemaakt die een sleutel aan een waarde koppelt en vervolgens die kaart toevoegen aan PropertySources inschakelen van aanroep als dat nodig is.

5. Ingesloten servlets registreren

Ten slotte kijken we ook naar de basisconfiguratie en registratie van embedded servlets in Spring Boot.

Een embedded servlet biedt volledige webcontainerfunctionaliteit (Tomcat, Jetty, etc.) zonder dat de webcontainer apart hoeft te worden geïnstalleerd of onderhouden.

U kunt de vereiste afhankelijkheden en configuratie toevoegen voor eenvoudige live serverimplementatie overal waar dergelijke functionaliteit pijnloos, compact en snel wordt ondersteund.

We zullen alleen kijken hoe we deze Tomcat moeten doen, maar dezelfde aanpak kan worden gevolgd voor Jetty en alternatieven.

Laten we de afhankelijkheid voor een ingesloten Tomcat 8-webcontainer specificeren in pom.xml:

 org.apache.tomcat.embed tomcat-embed-core 8.5.11 

Laten we nu de tags toevoegen die nodig zijn om Tomcat met succes toe te voegen aan het .oorlog geproduceerd door Maven tijdens build-tijd:

 embeddedTomcatExample org.codehaus.mojo appassembler-maven-plugin 2.0.0 target launch.Main webapp-pakket assembleren 

Als u Spring Boot gebruikt, kunt u in plaats daarvan Spring's spring-boot-starter-tomcat afhankelijkheid van uw pom.xml:

 org.springframework.boot spring-boot-starter-tomcat voorzien 

5.1. Registratie via eigendommen

Spring Boot ondersteunt het configureren van de meeste mogelijke Spring-instellingen via application.properties. Na het toevoegen van de nodige embedded servlet-afhankelijkheden aan uw pom.xml, kunt u uw ingebedde servlet aanpassen en configureren met behulp van verschillende van dergelijke configuratie-opties:

server.jsp-servlet.class-name = org.apache.jasper.servlet.JspServlet server.jsp-servlet.registered = true server.port = 8080 server.servlet-path = /

Hierboven vindt u enkele van de applicatie-instellingen die kunnen worden gebruikt om het DispatcherServlet en het delen van statische bronnen. Instellingen voor embedded servlets, SSL-ondersteuning en sessies zijn ook beschikbaar.

Er zijn echt te veel configuratieparameters om hier op te noemen, maar je kunt de volledige lijst zien in de Spring Boot-documentatie.

5.2. Configuratie via YAML

Evenzo kunnen we onze embedded servlet-container configureren met YAML. Dit vereist het gebruik van een gespecialiseerde YAML-property loader - de YamlPropertySourceLoader - die onze YAML blootlegt en de sleutels en waarden daarin beschikbaar maakt voor gebruik in onze app.

YamlPropertySourceLoader sourceLoader = nieuwe YamlPropertySourceLoader (); PropertySource yamlProps = sourceLoader.load ("yamlProps", resource, null);

5.3. Programmatische configuratie via TomcatEmbeddedServletContainerFactory

Programmatische configuratie van een embedded servlet-container is mogelijk via een subklasse van EmbeddedServletContainerFactory. U kunt bijvoorbeeld de TomcatEmbeddedServletContainerFactory om uw ingesloten Tomcat-servlet te configureren.

De TomcatEmbeddedServletContainerFactory wikkelt de org.apache.catalina.startup.Tomcat object dat aanvullende configuratie-opties biedt:

@Bean openbaar ConfigurableServletWebServerFactory servletContainer () {TomcatServletWebServerFactory tomcatContainerFactory = nieuwe TomcatServletWebServerFactory (); retourneer tomcatContainerFactory; }

Vervolgens kunnen we de geretourneerde instantie configureren:

tomcatContainerFactory.setPort (9000); tomcatContainerFactory.setContextPath ("/ springboottomcatexample");

Elk van deze specifieke instellingen kan configureerbaar worden gemaakt met behulp van een van de eerder beschreven methoden.

We kunnen ook rechtstreeks toegang krijgen tot het org.apache.catalina.startup.Tomcat voorwerp:

Tomcat tomcat = nieuwe Tomcat (); tomcat.setPort (poort); tomcat.setContextPath ("/ springboottomcatexample"); tomcat.start ();

6. Conclusie

In dit artikel hebben we verschillende manieren besproken om registreer een Servlet in een Jakarta EE en Spring Boot-applicatie.

De broncode die in deze tutorial wordt gebruikt, is beschikbaar in het Github-project.