Hvordan registrere en servlet i Java
1. Introduksjon
Denne artikkelen vil gi en oversikt over hvordan du registrerer en servlet i Jakarta EE og Spring Boot. Spesielt vil vi se på to måter å registrere en Java Servlet i Jakarta EE - en ved hjelp av a web.xml filen, og den andre ved hjelp av merknader. Deretter registrerer vi servlets i Spring Boot ved hjelp av XML-konfigurasjon, Java-konfigurasjon og gjennom konfigurerbare egenskaper.
En flott innledende artikkel om servlets finner du her.
2. Registrering av servlets i Jakarta EE
La oss gå over to måter å registrere en servlet i Jakarta EE. Først kan vi registrere en servlet via web.xml. Alternativt kan vi bruke Jakarta EE @WebServlet kommentar.
2.1. Via web.xml
Den vanligste måten å registrere en servlet i Jakarta EE-applikasjonen er å legge den til din web.xml fil:
index.html index.htm index.jsp Eksempel com.baeldung.Exempeleksempel / eksempel Som du kan se, innebærer dette to trinn: (1) å legge servleten vår til servlet sørg for å også spesifisere kildebanen til klassen servleten ligger i, og (2) spesifisere URL-banen servleten vil bli eksponert for i url-mønster stikkord.
Jakarta EE web.xml filen finnes vanligvis i Webinnhold / WEB-INF.
2.2. Via merknader
La oss nå registrere servletten vår ved hjelp av @WebServlet kommentar på vår tilpassede servletklasse. Dette eliminerer behovet for servletkartlegginger i server.xml og registrering av servlet i web.xml:
@WebServlet (name = "AnnotationExample", description = "Eksempel Servlet ved bruk av annoteringer", urlPatterns = {"/ AnnotationExample"}) offentlig klasse Eksempel utvider HttpServlet {@Override-beskyttet ugyldig doGet (HttpServletRequest-forespørsel, HttpServletResponse-svar) kaster ServletException respons.setContentType ("tekst / html"); PrintWriter out = respons.getWriter (); out.println ("Hei Verden!
"); } }Koden ovenfor viser hvordan du legger til merknaden direkte i en servlet. Servletten vil fortsatt være tilgjengelig på samme URL-bane som før.
3. Registrering av servlets i Spring Boot
Nå som vi har vist hvordan du registrerer servlets i Jakarta EE, la oss se på flere måter å registrere servlets i en Spring Boot-applikasjon.
3.1. Programmatisk registrering
Spring Boot støtter 100% programmatisk konfigurasjon av en webapplikasjon.
Først implementerer vi WebApplicationInitializer grensesnitt, og implementer deretter WebMvcConfigurer grensesnitt, som lar deg overstyre forhåndsinnstilte standarder i stedet for å måtte spesifisere hver spesielle konfigurasjonsinnstilling, noe som sparer tid og lar deg jobbe med flere prøvde og sanne innstillinger utenom boksen.
La oss se på et utvalg WebApplicationInitializer gjennomføring:
offentlig klasse WebAppInitializer implementerer WebApplicationInitializer {public void onStartup (ServletContext container) kaster ServletException {AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext (); ctx.register (WebMvcConfigure.class); ctx.setServletContext (container); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcherExample", ny DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }}La oss deretter implementere WebMvcConfigurer grensesnitt:
@Configuration public class WebMvcConfigure implementerer WebMvcConfigurer {@Bean public ViewResolver getViewResolver () {InternalResourceViewResolver resolver = new InternalResourceViewResolver (); resolver.setPrefix ("/ WEB-INF /"); resolver.setSuffix (". jsp"); retur resolver; } @Override public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {configurer.enable (); } @Override public void addResourceHandlers (ResourceHandlerRegistry registry) {registry.addResourceHandler ("/ resources / **") .addResourceLocations ("/ resources /"). SetCachePeriod (3600) .resourceChain (true) .addResolver (new PathResourceResolver () ; }}Ovenfor spesifiserer vi noen av standardinnstillingene for JSP-servlets eksplisitt for å støtte .jsp visninger og statisk ressursservering.
3.2. XML-konfigurasjon
En annen måte å konfigurere og registrere servlets på Spring Boot er gjennom web.xml:
dispatcher org.springframework.web.servlet.DispatcherServlet contextConfigLocation /WEB-INF/spring/dispatcher.xml 1 dispatcher / De web.xml brukes til å spesifisere konfigurasjon om våren, er lik den som ble funnet i Jakarta EE. Ovenfor kan du se hvordan vi spesifiserer noen flere parametere via attributter under servlet stikkord.
Her bruker vi en annen XML for å fullføre konfigurasjonen:
Husk at våren web.xml vil vanligvis bo i src / main / webapp / WEB-INF.
3.3. Kombinere XML og programmatisk registrering
La oss blande en XML-konfigurasjonstilnærming med Spring's programmatiske konfigurasjon:
public void onStartup (ServletContext container) kaster ServletException {XmlWebApplicationContext xctx = new XmlWebApplicationContext (); xctx.setConfigLocation ('classpath: /context.xml'); xctx.setServletContext (container); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcher", new DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }La oss også konfigurere senderen servlet:
3.4. Registrering av Bean
Vi kan også konfigurere og registrere servlets programmatisk ved hjelp av en ServletRegistrationBean. Nedenfor gjør vi det for å registrere et HttpServlet (som implementerer javax.servlet.Servlet grensesnitt):
@Bean public ServletRegistrationBean exampleServletBean () {ServletRegistrationBean bean = new ServletRegistrationBean (new CustomServlet (), "/ exampleServlet / *"); bean.setLoadOnStartup (1); retur bønne; }Den største fordelen med denne tilnærmingen er at den lar deg legge til både flere servlets og forskjellige typer servlets i vårapplikasjonen.
I stedet for bare å bruke en DispatcherServlet, som er en mer spesifikk type HttpServlet og den vanligste typen brukt i WebApplicationInitializer programmatisk tilnærming til konfigurasjon vi utforsket i avsnitt 3.1, bruker vi en enklere HttpServlet underklasseforekomst som avslører de fire grunnleggende HttpForespørsel operasjoner gjennom fire funksjoner: doGet (), doPost (), doPut (), og slett () akkurat som i Jakarta EE.
Husk at HttpServlet er en abstrakt klasse (så den kan ikke instantieres). Vi kan enkelt piske opp en tilpasset utvidelse, skjønt:
offentlig klasse CustomServlet utvider HttpServlet {...}4. Registrere servlets med egenskaper
En annen, men uvanlig måte å konfigurere og registrere servlets på, er å bruke en egendefinert egenskaperfil lastet inn i appen via en PropertyLoader, PropertySource, eller PropertySources forekomst objekt.
Dette gir en mellomstor konfigurasjon og muligheten til ellers å tilpasse application.properties som gir liten direkte konfigurasjon for ikke-innebygde servlets.
4.1. Systemegenskaper
Vi kan legge til noen tilpassede innstillinger i vår application.properties fil eller en annen eiendomsfil. La oss legge til noen få innstillinger for å konfigurere våre DispatcherServlet:
servlet.name = dispatcherExample servlet.mapping = / dispatcherExampleURLLa oss laste inn våre egendefinerte egenskaper i applikasjonen vår:
System.setProperty ("custom.config.location", "classpath: custom.properties");Og nå kan vi få tilgang til disse egenskapene via:
System.getProperty ("tilpasset.config.location");4.2. Tilpasset egenskaper
La oss starte med en tilpassede.egenskaper fil:
servlet.name = dispatcherExample servlet.mapping = / dispatcherExampleURLVi kan deretter bruke en eiendomsbelaster:
public Properties getProperties (strengfil) kaster IOException {Properties prop = new Properties (); InputStream input = null; input = getClass (). getResourceAsStream (fil); prop.load (input); hvis (input! = null) {input.close (); } returstøtte; }Og nå kan vi legge til disse egendefinerte egenskapene som konstanter i vår WebApplicationInitializer gjennomføring:
privat statisk slutt PropertyLoader pl = ny PropertyLoader (); private static final Egenskaper springProps = pl.getProperties ("custom_spring.properties"); offentlig statisk sluttstreng SERVLET_NAME = springProps.getProperty ("servlet.name"); offentlig statisk sluttstreng SERVLET_MAPPING = springProps.getProperty ("servlet.mapping");Vi kan deretter bruke dem til å for eksempel konfigurere vår senderservlet:
ServletRegistration.Dynamic servlet = container.addServlet (SERVLET_NAME, ny DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping (SERVLET_MAPPING);Fordelen med denne tilnærmingen er fraværet av .xml vedlikehold, men med enkle å endre konfigurasjonsinnstillinger som ikke krever omplassering av kodebasen.
4.3. De PropertySource Nærme seg
En raskere måte å oppnå det ovennevnte på er å bruke Spring's PropertySource som gjør det mulig å få tilgang til og laste inn en konfigurasjonsfil.
PropertyResolver er et grensesnitt implementert av Konfigurerbart miljø, som gjør applikasjonsegenskaper tilgjengelige ved oppstart og initialisering av servlet:
@Configuration @PropertySource ("classpath: /com/yourapp/custom.properties") public class EksempelCustomConfig {@Autowired ConfigurableEnvironment env; public String getProperty (String key) {return env.getProperty (key); }}Ovenfor autoleder vi en avhengighet i klassen og spesifiserer plasseringen til vår tilpassede egenskaperfil. Vi kan da hente vår fremtredende eiendom ved å ringe funksjonen getProperty () passerer inn strengverdien.
4.4. The PropertySource Programmatic Approach
Vi kan kombinere fremgangsmåten ovenfor (som innebærer å hente eiendomsverdier) med tilnærmingen nedenfor (som lar oss programmatisk spesifisere disse verdiene):
ConfigurableEnvironment env = new StandardEnvironment (); MutablePropertySources rekvisitter = env.getPropertySources (); Kartkart = nytt HashMap (); map.put ("nøkkel", "verdi"); props.addFirst (ny MapPropertySource ("Kart", kart));Vi har opprettet et kart som knytter en nøkkel til en verdi, og legg det til i PropertySources muliggjør påkallelse etter behov.
5. Registrering av innebygde servlets
Til slutt vil vi også se på grunnleggende konfigurasjon og registrering av innebygde servlets i Spring Boot.
En innebygd servlet gir full webcontainer (Tomcat, Jetty, etc.) funksjonalitet uten å måtte installere eller vedlikeholde webcontaineren separat.
Du kan legge til de nødvendige avhengighetene og konfigurasjonen for enkel distribusjon av live server uansett hvor en slik funksjonalitet støttes smertefritt, kompakt og raskt.
Vi vil bare se på hvordan du gjør denne Tomcat, men den samme tilnærmingen kan foretas for brygge og alternativer.
La oss spesifisere avhengigheten av en innebygd Tomcat 8-nettbeholder i pom.xml:
org.apache.tomcat.embed tomcat-embed-core 8.5.11 La oss nå legge til kodene som kreves for å kunne legge til Tomcat i .krig produsert av Maven ved byggetid:
embeddedTomcatExample org.codehaus.mojo appassembler-maven-plugin 2.0.0 target launch.Main webapp pakke montere Hvis du bruker Spring Boot, kan du i stedet legge til Spring's spring-boot-starter-tomcat avhengighet til din pom.xml:
org.springframework.boot spring-boot-starter-tomcat levert 5.1. Registrering gjennom eiendommer
Spring Boot støtter konfigurering av mest mulig vårinnstillinger gjennom application.properties. Etter å ha lagt til de nødvendige innebygde servletavhengighetene til pom.xml, kan du tilpasse og konfigurere den innebygde servleten din ved å bruke flere slike konfigurasjonsalternativer:
server.jsp-servlet.class-name = org.apache.jasper.servlet.JspServlet server.jsp-servlet.registered = true server.port = 8080 server.servlet-path = /Ovenfor er noen av programinnstillingene som kan brukes til å konfigurere DispatcherServlet og statisk ressursdeling. Innstillinger for innebygde servlets, SSL-støtte og økter er også tilgjengelige.
Det er virkelig for mange konfigurasjonsparametere å liste opp her, men du kan se hele listen i Spring Boot-dokumentasjonen.
5.2. Konfigurasjon gjennom YAML
På samme måte kan vi konfigurere den innebygde servletbeholderen vår ved hjelp av YAML. Dette krever bruk av en spesialisert YAML eiendomslaster - YamlPropertySourceLoader - som avslører YAML og gjør nøklene og verdiene der tilgjengelig for bruk i appen vår.
YamlPropertySourceLoader sourceLoader = ny YamlPropertySourceLoader (); PropertySource yamlProps = sourceLoader.load ("yamlProps", ressurs, null);5.3. Programmatisk konfigurasjon gjennom TomcatEmbeddedServletContainerFactory
Programmatisk konfigurasjon av en innebygd servletbeholder er mulig gjennom en underklassert forekomst av EmbeddedServletContainerFactory. For eksempel kan du bruke TomcatEmbeddedServletContainerFactory for å konfigurere den innebygde Tomcat-servletten.
De TomcatEmbeddedServletContainerFactory pakker inn org.apache.catalina.startup.Tomcat objekt som gir ekstra konfigurasjonsalternativer:
@Bean public ConfigurableServletWebServerFactory servletContainer () {TomcatServletWebServerFactory tomcatContainerFactory = ny TomcatServletWebServerFactory (); returner tomcatContainerFactory; }Da kan vi konfigurere den returnerte forekomsten:
tomcatContainerFactory.setPort (9000); tomcatContainerFactory.setContextPath ("/ springboottomcatexample");Hver av disse spesielle innstillingene kan gjøres konfigurerbare ved hjelp av hvilken som helst av metodene som er beskrevet tidligere.
Vi kan også få direkte tilgang til og manipulere org.apache.catalina.startup.Tomcat gjenstand:
Tomcat tomcat = ny Tomcat (); tomcat.setPort (port); tomcat.setContextPath ("/ springboottomcatexample"); tomcat.start ();6. Konklusjon
I denne artikkelen har vi gjennomgått flere måter å registrer en Servlet i en Jakarta EE og Spring Boot-applikasjon.
Kildekoden som brukes i denne opplæringen, er tilgjengelig i Github-prosjektet.
