streamalism.org

1. Bemutatkozás

Ez a cikk biztosítja áttekintés arról, hogyan kell regisztrálni egy szervletet a Jakarta EE és a Spring Boot rendszeren belül. Konkrétan két módot fogunk megvizsgálni a Java szervlet regisztrálásához Jakarta EE-ben - az egyiket az a használatával web.xml fájlt, a másik pedig kommentárokkal. Ezután regisztráljuk a szervleteket a Spring Boot alkalmazásban az XML konfiguráció, a Java konfiguráció és a konfigurálható tulajdonságok segítségével.

A szervletekkel kapcsolatos nagyszerű bevezető cikk itt található.

2. A Servlet regisztrálása Jakarta EE-ben

Nézzünk át két módot a szervlet regisztrálására Jakarta EE-ben. Először is regisztrálhatunk egy szervletet a következőn keresztül: web.xml. Alternatív megoldásként használhatjuk a Jakarta EE-t is @WebServlet annotáció.

2.1. Keresztül web.xml

A szervlet regisztrálásának leggyakoribb módja a Jakarta EE alkalmazáson belül az, hogy hozzáadja azt a web.xml fájl:

 index.html index.htm index.jsp példa com.baeldung.Példa példa / példa 

Mint látható, ez két lépést foglal magában: (1) hozzáadjuk a szervletünket a servlet címkét, ügyelve arra, hogy megadja a kiszolgálóaljzat osztályának forrását is, és (2) megadja az URL elérési utat, amelyen a URL-minta címke.

A Jakarta EE web.xml fájl általában itt található WebContent / WEB-INF.

2.2. Jegyzetek útján

Most regisztráljuk a szervletünket a @WebServlet annotáció az egyedi servlet osztályunkon. Ez kiküszöböli a szervlet leképezések szükségességét a server.xml és a szervlet regisztrációja web.xml:

@WebServlet (név = "AnnotationExample", leírás = "Példa kiszolgálóra, amely kommentárokat használ", urlPatterns = {"/ AnnotationExample"}) nyilvános osztály A példa kiterjeszti a HttpServlet {@Override protected void doGet (HttpServletRequest kérés, HttpServletRepletRespaceResponseResponseTranslet response.setContentType ("text / html"); PrintWriter out = response.getWriter (); out.println ("
Helló Világ!
"); } }

A fenti kód bemutatja, hogyan lehet ezt a jegyzetet közvetlenül hozzáadni egy szervlethez. A szervlet továbbra is elérhető lesz ugyanazon az URL-elérési úton, mint korábban.

3. A Servlet regisztrálása a Spring Boot alkalmazásban

Most, hogy megmutattuk, hogyan kell a szervleteket regisztrálni a Jakarta EE-ben, vessen egy pillantást a szervletek regisztrációjának több módjára egy Spring Boot alkalmazásban.

3.1. Programos regisztráció

A Spring Boot támogatja a webalkalmazások 100% -os programozási konfigurációját.

Először a WebApplicationInitializer interfészt, majd hajtsa végre a WebMvcConfigurer felület, amely lehetővé teszi az előre beállított alapértelmezések felülbírálását ahelyett, hogy meg kellene adnia az egyes konfigurációs beállításokat, időt spórolva és lehetővé téve, hogy több kipróbált és igaz beállítással dolgozzon kívülről.

Nézzünk meg egy mintát WebApplicationInitializer végrehajtás:

public class WebAppInitializer megvalósítja a WebApplicationInitializer {public void onStartup (ServletContext tároló) dobja a ServletException {AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext (); ctx.register (WebMvcConfigure.class); ctx.setServletContext (tároló); ServletRegistration.Dynamic servlet = container.addServlet ("diszpécserExample", új DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }}

Ezután hajtsuk végre a WebMvcConfigurer felület:

@Configuration nyilvános osztály A WebMvcConfigure a WebMvcConfigurer {@Bean public ViewResolver getViewResolver () {InternalResourceViewResolver resolver = new InternalResourceViewResolver (); resolver.setPrefix ("/ WEB-INF /"); resolver.setSuffix (". jsp"); return resolver; } @Orride public void configureDefaultServletHandling (DefaultServletHandlerConfigurer configurer) {configurer.enable (); } @Orride public void addResourceHandlers (ResourceHandlerRegistry registry) {register.addResourceHandler ("/ resources / **") .addResourceLocations ("/ resources /"). SetCachePeriod (3600) .resourceChain (true) .addResolver (new PathResourceResol ; }}

A fentiekben kifejezetten megadunk néhány alapértelmezett beállítást a JSP kiszolgálók számára a támogatás érdekében .jsp nézetek és statikus erőforrások kiszolgálása.

3.2. XML konfiguráció

A szervletek konfigurálásának és regisztrálásának másik módja a Spring Boot-on keresztül van web.xml:

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

A web.xml a konfiguráció megadásához tavasszal hasonló, mint a Jakarta EE-ben. Fent láthatja, hogyan adhatunk meg még néhány paramétert az attribútumokon keresztül a servlet címke.

Itt egy másik XML-t használunk a konfiguráció befejezéséhez:

Ne feledje, hogy a tavasz web.xml általában lakni fog src / main / webapp / WEB-INF.

3.3. XML és programozási regisztráció kombinálása

Keverjük össze az XML konfigurációs megközelítést a Spring programozási konfigurációjával:

public void onStartup (ServletContext tároló) dobja a ServletException {XmlWebApplicationContext xctx = new XmlWebApplicationContext (); xctx.setConfigLocation ('classpath: /context.xml'); xctx.setServletContext (tároló); ServletRegistration.Dynamic servlet = container.addServlet ("diszpécser", új DispatcherServlet (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }

Konfiguráljuk a diszpécser szervletet is:

3.4. Bean által történő regisztráció

Programozottan konfigurálhatjuk és regisztrálhatjuk a szervleteket is az a használatával ServletRegistrationBean. Az alábbiakban megtesszük a HttpServlet (amely végrehajtja a javax.servlet.Servlet felület):

@Bean public ServletRegistrationBean exampleServletBean () {ServletRegistrationBean bean = new ServletRegistrationBean (new CustomServlet (), "/ exampleServlet / *"); bean.setLoadOnStartup (1); visszatérő bab; }

Ennek a megközelítésnek az a fő előnye, hogy lehetővé teszi mind a több, mind a különféle típusú kis kiszolgálók hozzáadását a Spring alkalmazáshoz.

Ahelyett, hogy a DispatcherServlet, amely egy specifikusabb fajta HttpServlet és a leggyakoribb fajta, amelyet a WebApplicationInitializer a konfiguráció programozott megközelítése, amelyet a 3.1 szakaszban vizsgáltunk, egy egyszerűbbet fogunk használni HttpServlet alosztályi példány, amely a négy alapot tárja fel HttpRequest műveletek négy funkcióval: doGet (), doPost (), doPut (), és doDelete () akárcsak Jakarta EE-ben.

Ne feledje, hogy a HttpServlet egy absztrakt osztály (tehát nem lehet példányosítani). Könnyen felkorbácsolhatunk egy egyedi kiterjesztést:

public class CustomServlet kiterjeszti a HttpServlet {...}

4. Szervletek regisztrálása tulajdonságokkal

A szervletek konfigurálásának és regisztrálásának másik, bár nem gyakori módja az, ha az alkalmazásba egy PropertyLoader, PropertySource, vagy PropertySources példány objektum.

Ez egy közbülső típusú konfigurációt és lehetőséget biztosít az egyéb testreszabásra alkalmazás.tulajdonságok amelyek kevés közvetlen konfigurációt biztosítanak a beágyazatlan kiszolgálók számára.

4.1. A rendszer tulajdonságainak megközelítése

Hozzáadhatunk néhány egyéni beállítást a sajátunkhoz alkalmazás.tulajdonságok fájl vagy más tulajdonságfájl. Adjunk hozzá néhány beállítást a konfiguráláshoz DispatcherServlet:

servlet.name = diszpécserPélda servlet.mapping = / diszpécserExampleURL

Töltsük be egyedi tulajdonságainkat az alkalmazásunkba:

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

És most ezeken az ingatlanokon keresztül érhetjük el:

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

4.2. Egyéni tulajdonságok megközelítés

Kezdjük egy szokás.tulajdonságok fájl:

servlet.name = diszpécserPélda servlet.mapping = / diszpécserExampleURL

Ezután használhatunk egy üzemszerű Property Loader-t:

public Properties getProperties (String file) dobja az IOException {Properties prop = new Properties (); InputStream input = null; input = getClass (). getResourceAsStream (fájl); prop.load (input); if (input! = null) {input.close (); } visszatérő támasz; }

És most ezeket az egyedi tulajdonságokat állandóként felvehetjük a sajátunkba WebApplicationInitializer végrehajtás:

privát statikus végleges PropertyLoader pl = új PropertyLoader (); privát statikus végleges Tulajdonságok springProps = pl.getProperties ("custom_spring.properties"); public static final String SERVLET_NAME = springProps.getProperty ("servlet.név"); public static final String SERVLET_MAPPING = springProps.getProperty ("servlet.térkép");

Ezután felhasználhatjuk őket például a diszpécser szervlet konfigurálására:

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

Ennek a megközelítésnek az az előnye, hogy nincs .xml karbantartás, de könnyen módosítható konfigurációs beállításokkal, amelyek nem igénylik a kódbázis újratelepítését.

4.3. A PropertySource Megközelítés

A fentiek megvalósításának gyorsabb módja a Spring használata PropertySource amely lehetővé teszi egy konfigurációs fájl elérését és betöltését.

PropertyResolver egy olyan interfész, amelyet a Konfigurálható környezet, amely elérhetővé teszi az alkalmazás tulajdonságait a szervlet indításakor és inicializálásakor:

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

Fentebb egy függőséget írunk be az osztályba, és megadjuk az egyéni tulajdonságok fájljának helyét. Ezután a függvény meghívásával lekérhetjük kiemelt tulajdonságunkat getProperty () adja át a String értéket.

4.4. A PropertySource programozási megközelítés

Kombinálhatjuk a fenti megközelítést (amely magában foglalja a tulajdonságértékek beolvasását) az alábbi megközelítéssel (amely lehetővé teszi számunkra, hogy programozottan meghatározzuk ezeket az értékeket):

ConfigurableEnvironment env = new StandardEnvironment (); MutablePropertySources props = env.getPropertySources (); Térképtérkép = új HashMap (); map.put ("kulcs", "érték"); props.addFirst (új MapPropertySource ("Térkép", térkép));

Hoztunk létre egy térképet, amely összekapcsolja a kulcsot egy értékkel, majd hozzáadja azt a térképet PropertySources szükség esetén lehetővé teszi a meghívást.

5. Beágyazott szervlet regisztrálása

Végül megvizsgáljuk a beágyazott szervletek alapkonfigurációját és regisztrációját a Spring Boot-on belül.

A beágyazott szervlet teljes webes tároló (Tomcat, Jetty, stb.) Funkciót biztosít, anélkül, hogy külön kellene telepíteni vagy karbantartani a webes tárolót.

Hozzáadhatja a szükséges függőségeket és konfigurációkat az egyszerű élő szerver-telepítéshez, ahol ez a funkció fájdalommentesen, kompaktan és gyorsan támogatott.

Csak megnézzük, hogyan kell ezt a Tomcat-t csinálni, de ugyanez a megközelítés alkalmazható a mólóra és az alternatívákra is.

Adjuk meg a beágyazott Tomcat 8 webtároló függőségét pom.xml:

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

Most adjuk hozzá a Tomcat sikeres hozzáadásához szükséges címkéket a .háború gyártotta Maven építkezéskor:

 embeddedTomcatExample org.codehaus.mojo appassembler-maven-plugin 2.0.0 target launch. A fő webapp csomag összeáll 

Ha a Spring Boot programot használja, akkor hozzáadhatja a Spring's programot tavasz-csizma-indító-bika függőség az ön pom.xml:

 org.springframework.boot spring-boot-starter-tomcat biztosított 

5.1. Regisztráció a Tulajdonságokon keresztül

A Spring Boot támogatja a lehető legtöbb tavaszi beállítás konfigurálását alkalmazás.tulajdonságok. Miután hozzáadta a szükséges beágyazott szervlet-függőségeket a pom.xml, számos ilyen konfigurációs lehetőség segítségével testre szabhatja és konfigurálhatja a beágyazott kiszolgáló kisalkalmazást:

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

A fentiekben bemutatjuk azokat az alkalmazásbeállításokat, amelyek felhasználhatók a DispatcherServlet és a statikus erőforrások megosztása. A beágyazott kiszolgálók, az SSL támogatás és a munkamenetek beállításai is elérhetők.

Tényleg túl sok konfigurációs paraméter van itt felsorolásra, de a teljes listát a Spring Boot dokumentációban láthatja.

5.2. Konfiguráció a YAML-en keresztül

Hasonlóképpen a YAML használatával konfigurálhatjuk a beágyazott servlet-tárolót is. Ehhez speciális YAML tulajdonságbetöltő - a YamlPropertySourceLoader - amely kiteszi a YAML-jünket, és elérhetővé teszi az ott található kulcsokat és értékeket alkalmazásunkon belül.

YamlPropertySourceLoader sourceLoader = új YamlPropertySourceLoader (); PropertySource yamlProps = sourceLoader.load ("yamlProps", erőforrás, null);

5.3. Programos konfiguráció a TomcatEmbeddedServletContainerFactory segítségével

A beágyazott kiszolgáló kisalkalmazás-programozás konfigurálása a (z) alosztályozott példányán keresztül lehetséges EmbeddedServletContainerFactory. Például használhatja a TomcatEmbeddedServletContainerFactory a beágyazott Tomcat szervlet konfigurálásához.

A TomcatEmbeddedServletContainerFactory tekeri a org.apache.catalina.startup.Tomcat objektum, amely további konfigurációs lehetőségeket kínál:

@Bean public ConfigurableServletWebServerFactory servletContainer () {TomcatServletWebServerFactory tomcatContainerFactory = új TomcatServletWebServerFactory (); return tomcatContainerFactory; }

Ezután konfigurálhatjuk a visszaküldött példányt:

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

Az említett beállítások mindegyike konfigurálhatóvá tehető a korábban leírt módszerek bármelyikével.

Közvetlenül hozzáférhetünk és manipulálhatjuk a org.apache.catalina.startup.Tomcat tárgy:

Tomcat tomcat = új Tomcat (); tomcat.setPort (port); tomcat.setContextPath ("/ springboottomcatexample"); macska.indulás ();

6. Következtetés

Ebben a cikkben számos módszert tekintettünk át regisztráljon egy Servletet egy Jakarta EE és Spring Boot alkalmazásban.

Az oktatóanyagban használt forráskód elérhető a Github projektben.