streamalism.org

1. הקדמה

מאמר זה יספק סקירה כללית של אופן רישום סרוולט בג'קרטה EE וב Spring Boot. באופן ספציפי, נבחן שתי דרכים לרישום Java Servlet בג'קרטה EE - אחת באמצעות a web.xml הקובץ, והשני באמצעות הערות. לאחר מכן נרשום servlets ב- Spring Boot באמצעות תצורת XML, תצורת Java ובאמצעות מאפיינים הניתנים להגדרה.

מאמר היכרות נהדר על סרוולטים ניתן למצוא כאן.

2. רישום Servlets בג'קרטה EE

בוא נעבור על שתי דרכים לרישום סרוולט בג'קרטה EE. ראשית, אנו יכולים לרשום סרוולט באמצעות web.xml. לחלופין, אנו יכולים להשתמש ב- EE של ג'קרטה @WebServlet ביאור.

2.1. באמצעות web.xml

הדרך הנפוצה ביותר לרשום servlet ביישום EE שלך בג'קרטה היא להוסיף אותו ל- web.xml קוֹבֶץ:

 index.html index.htm index.jsp דוגמה com.baeldung. דוגמה לדוגמא / דוגמה 

כפי שאתה יכול לראות, זה כולל שני שלבים: (1) הוספת servlet שלנו ל- סרוולט תג, וודא שאתה מציין גם את נתיב המקור למחלקה בה שוכן ה- servlet, ו- (2) המציין את נתיב ה- URL אליו ייחשף ה- servlet ב- דפוס url תָג.

ה- EE בג'קרטה web.xml קובץ נמצא בדרך כלל ב WebContent / WEB-INF.

2.2. באמצעות ביאורים

עכשיו בואו נרשום את ה- servlet שלנו באמצעות ה- @WebServlet ביאור על כיתת servlet המותאמת אישית שלנו. זה מבטל את הצורך במיפוי סרוולט ב server.xml ורישום ה- servlet ב- web.xml:

@WebServlet (name = "AnnotationExample", תיאור = "דוגמא Servlet באמצעות הערות", urlPatterns = {"/ AnnotationExample"}) מחלקה ציבורית דוגמה מרחיבה HttpServlet {@Override ruid voGet doGet (HttpServletRequest בקשה, HttpServletResponse תגובה) זורק ServletExc response.setContentType ("טקסט / html"); PrintWriter out = response.getWriter (); out.println ("
שלום עולם!
"); } }

הקוד שלמעלה מדגים כיצד להוסיף את ההערה ישירות ל- servlet. ה- servlet עדיין יהיה זמין באותו נתיב של כתובות אתרים כמו בעבר.

3. רישום סרוולים במגף האביב

כעת, לאחר שהראינו כיצד לרשום Servlets ב- Jakarta EE, בואו נסתכל על מספר דרכים לרישום Servlets ביישום Spring Boot.

3.1. רישום פרוגרמטי

Spring Boot תומך בתצורה פרוגרמטית של 100% של יישום אינטרנט.

ראשית, ניישם את WebApplicationInitializer ממשק ואז ליישם את WebMvcConfigurer ממשק, המאפשר לך לעקוף את ברירות המחדל המוגדרות מראש במקום שיהיה עליך לציין כל הגדרת תצורה מסוימת, לחסוך לך זמן ולאפשר לך לעבוד עם מספר הגדרות ניסו ונכונות מחוץ לקופסה.

בואו נסתכל על דוגמא WebApplicationInitializer יישום:

מחלקה ציבורית WebAppInitializer מיישמת WebApplicationInitializer {public void onStartup (מיכל ServletContext) זורק ServletException {AnnotationConfigWebApplicationContext ctx = AnnotationConfigWebApplicationContext חדש); ctx.register (WebMvcConfigure.class); ctx.setServletContext (מיכל); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcherExample", DispatcherServlet חדש (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }}

לאחר מכן, בואו ליישם את WebMvcConfigurer מִמְשָׁק:

@Configuration מחלקה ציבורית WebMvcConfigure מיישם את WebMvcConfigurer {@Bean public ViewResolver getViewResolver () {InternalResourceViewResolver resolver = new InternalResourceViewResolver (); resolver.setPrefix ("/ WEB-INF /"); resolver.setSuffix (". jsp"); פותר להחזיר; } @Override public void configureDefaultServletHandling (תצורת תצורת DefaultServletHandlerConfigurer) {configurer.enable (); } @Override public void addResourceHandlers (Registry ResourceHandlerRegistry) {registry.addResourceHandler ("/ resources / **") .addResourceLocations ("/ resources /"). SetCachePeriod (3600) .resourceChain (true) .addResolver (PathResourceResolver חדש () ; }}

למעלה אנו מציינים חלק מהגדרות ברירת המחדל עבור JSP servlets במפורש על מנת לתמוך .jsp תצוגות והצגת משאבים סטטית.

3.2. תצורת XML

דרך נוספת להגדיר ולרשום סרוולטים בתוך Spring Boot היא דרך web.xml:

 dispatcher org.springframework.web.servlet.DispatcherServlet contextConfigLocation /WEB-INF/spring/dispatcher.xml משגר 1 / 

ה web.xml המשמש לציון תצורה באביב דומה לזה שנמצא בג'קרטה EE. למעלה, תוכל לראות כיצד אנו מציינים כמה פרמטרים נוספים באמצעות תכונות תחת ה- סרוולט תָג.

כאן אנו משתמשים ב- XML ​​נוסף להשלמת התצורה:

זכור כי האביב שלך web.xml בדרך כלל יחיה ב src / main / webapp / WEB-INF.

3.3. שילוב של XML ורישום תכנותי

בואו נערבב גישה לתצורת XML עם התצורה הפרוגרמטית של Spring:

חלל ציבורי onStartup (מיכל ServletContext) זורק ServletException {XmlWebApplicationContext xctx = XmlWebApplicationContext חדש (); xctx.setConfigLocation ('classpath: /context.xml'); xctx.setServletContext (מיכל); ServletRegistration.Dynamic servlet = container.addServlet ("dispatcher", DispatcherServlet חדש (ctx)); servlet.setLoadOnStartup (1); servlet.addMapping ("/"); }

בואו להגדיר גם את סרוולט השולח:

3.4. רישום על ידי שעועית

אנו יכולים גם להגדיר ולרשום את תוכנת השרת שלנו באמצעות תוכנה ServletRegistrationBean. להלן נעשה זאת על מנת לרשום HttpServlet (שמיישם את javax.servlet.Servlet מִמְשָׁק):

@Bean ServletRegistrationBean publicServletBean () {ServletRegistrationBean שעועית = ServletRegistrationBean חדש (CustomServlet חדש (), "/ exampleServlet / *"); bean.setLoadOnStartup (1); שעועית להחזיר; }

היתרון העיקרי בגישה זו הוא בכך שהיא מאפשרת להוסיף ליישומי האביב שלך גם מספר סרוולטים וגם סוגים שונים של סרוולטים.

במקום להשתמש רק ב- DispatcherServlet, שהוא סוג ספציפי יותר של HttpServlet והסוג הנפוץ ביותר המשמש ב WebApplicationInitializer בגישה פרוגרמטית לתצורה שחקרנו בסעיף 3.1, נשתמש בפשטות יותר HttpServlet מופע תת-מחלקה החושף את ארבעת היסודות HttpRequest פעולות באמצעות ארבע פונקציות: doGet (), doPost (), doPut (), ו doDelete () בדיוק כמו בג'קרטה EE.

זכור כי HttpServlet הוא מחלקה מופשטת (כך שאי אפשר לייצר אותה מיידית). אנו יכולים להמציא סיומת מותאמת אישית בקלות, אם כי:

מחלקה ציבורית CustomServlet מרחיבה את HttpServlet {...}

4. רישום Servlets עם נכסים

דרך אחרת, אם כי לא נדירה, להגדיר ולרשום את ה- servlets שלך היא להשתמש בקובץ מאפיינים מותאם אישית שטוען באפליקציה באמצעות PropertyLoader, PropertySource, אוֹ מקורות נכסים אובייקט מופע.

זה מספק סוג ביניים של תצורה ויכולת התאמה אישית אחרת application.properties המספקים תצורה ישירה מועטה עבור סרטי רשת שאינם מוטבעים.

4.1. גישה למאפייני מערכת

אנחנו יכולים להוסיף כמה הגדרות מותאמות אישית application.properties קובץ או קובץ מאפיינים אחר. בואו נוסיף כמה הגדרות להגדרת התצורה שלנו DispatcherServlet:

servlet.name = dispatcher דוגמה servlet.mapping = / dispatcherExampleURL

בואו נטען את המאפיינים המותאמים אישית שלנו ליישום שלנו:

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

ועכשיו אנו יכולים לגשת למאפיינים אלה באמצעות:

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

4.2. גישת מאפיינים מותאמים אישית

נתחיל עם custom.properties קוֹבֶץ:

servlet.name = dispatcher דוגמה servlet.mapping = / dispatcherExampleURL

לאחר מכן נוכל להשתמש במעמיס נכסים משוכלל:

נכסים ציבוריים getProperties (קובץ מחרוזת) זורק IOException {מאפיינים prop = מאפיינים חדשים (); קלט InputStream = null; קלט = getClass (). getResourceAsStream (קובץ); prop.load (קלט); אם (קלט! = null) {input.close (); } להחזיר אביזר; }

ועכשיו נוכל להוסיף את המאפיינים המותאמים אישית הללו כקבועים ל WebApplicationInitializer יישום:

סופי סטטי פרטי PropertyLoader pl = PropertyLoader חדש (); מאפיינים סופיים סטטיים פרטיים springProps = pl.getProperties ("custom_spring.properties"); סופי סטטי ציבורי מחרוזת SERVLET_NAME = springProps.getProperty ("servlet.name"); סופי סטטי ציבורי מחרוזת SERVLET_MAPPING = springProps.getProperty ("servlet.mapping");

לאחר מכן נוכל להשתמש בהם כדי, למשל, להגדיר את תצורת סרוולט השולח שלנו:

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

היתרון בגישה זו הוא היעדר .xml תחזוקה אך עם הגדרות תצורה קלות לשינוי שאינן דורשות פריסה מחדש של בסיס הקוד.

4.3. ה PropertySource גִישָׁה

דרך מהירה יותר להשיג את האמור לעיל היא לעשות שימוש באביב PropertySource המאפשרת גישה לקובץ תצורה וטעינה.

PropertyResolver הוא ממשק המיושם על ידי להגדרה הסביבה, מה שמאפיין את מאפייני היישומים בהפעלה ובאתחול של סרוולט:

@Configuration @PropertySource ("classpath: /com/yourapp/custom.properties") מחלקה ציבורית ExampleCustomConfig {@Autowired ConfigurableEnvironment env; מחרוזת ציבורית getProperty (מפתח מחרוזת) {return env.getProperty (key); }}

למעלה, אנו חוטים אוטומטית תלות בכיתה ומציינים את המיקום של קובץ המאפיינים המותאמים אישית שלנו. לאחר מכן נוכל להביא את המאפיין הבולט שלנו על ידי קריאה לפונקציה getProperty () העברת ערך המחרוזת.

4.4. הגישה הפרוגרמטית של PropertySource

אנו יכולים לשלב את הגישה הנ"ל (הכוללת אחזור ערכי מאפיינים) לבין הגישה למטה (המאפשרת לנו לציין באופן פרוגרמטי את הערכים הללו):

ConfigurableEnvironment env = StandardEnvironment חדש (); אביזרי MutablePropertySources = env.getPropertySources (); מפת מפה = HashMap חדש (); map.put ("מפתח", "ערך"); props.addFirst (MapPropertySource חדש ("מפה", מפה));

יצרנו מפה המקשרת מפתח לערך ואז הוסף את המפה הזו מקורות נכסים המאפשר קריאה לפי הצורך.

5. רישום סרוולטים משובצים

לבסוף, נסתכל גם על תצורה בסיסית ורישום של סרוולטים משובצים בתוך Spring Boot.

סרוולט משובץ מספק פונקציונליות של מיכל אינטרנט מלא (Tomcat, Jetty וכו ') מבלי להתקין או לתחזק את מיכל האינטרנט בנפרד.

תוכל להוסיף את התלות והתצורה הנדרשים לפריסת שרתים חיים פשוטים בכל מקום שתומכת בפונקציונליות כזו ללא כאב, קומפקטי ומהיר.

נבדוק רק כיצד לעשות את טומקט זה, אך ניתן לנקוט באותה גישה גם למזח ולחלופות.

בואו נציין את התלות של מיכל אינטרנט מוטבע ב- Tomcat 8 pom.xml:

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

עכשיו בואו נוסיף את התגים הנדרשים כדי להוסיף בהצלחה את Tomcat ל- .מִלחָמָה הופק על ידי מייבן בזמן הבנייה:

 embeddedTomcatExample org.codehaus.mojo appassembler-maven-plugin 2.0.0 השקת יעד. חבילת webapp ראשית להרכיב 

אם אתה משתמש באביב אתחול, באפשרותך להוסיף זאת של אביב אביב-מגף-סטרטר-טומט תלות שלך pom.xml:

 org.springframework.boot spring-boot-starter-tomcat מסופק 

5.1. רישום דרך נכסים

Spring Boot תומך בתצורה של הגדרות האביב האפשריות ביותר דרך application.properties. לאחר הוספת התלות הכרוכה ב- servlet המוטמעת pom.xml, אתה יכול להתאים אישית ולהגדיר את סרוולט המשובץ שלך באמצעות מספר אפשרויות תצורה כאלה:

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

להלן כמה מהגדרות היישום שניתן להשתמש בהן כדי להגדיר את DispatcherServlet ושיתוף משאבים סטטי. ניתן להשיג גם הגדרות עבור סרוולטים משובצים, תמיכה ב- SSL והפעלות.

באמת יש יותר מדי פרמטרים של תצורה לרשימה כאן, אך תוכל לראות את הרשימה המלאה בתיעוד האביב של Boot.

5.2. תצורה דרך YAML

באופן דומה, אנו יכולים להגדיר את מיכל השרת המשובץ שלנו באמצעות YAML. לשם כך נדרש שימוש במטעין נכסים ייעודי של YAML - YamlPropertySourceLoader - שחושף את ה- YAML שלנו והופך את המפתחות והערכים בו לזמינים לשימוש באפליקציה שלנו.

YamlPropertySourceLoader sourceLoader = YamlPropertySourceLoader חדש (); PropertySource yamlProps = sourceLoader.load ("yamlProps", משאב, null);

5.3. תצורה תכנותית באמצעות TomcatEmbeddedServletContainerFactory

תצורה תכנותית של מיכל סרוולט מוטבע אפשרית באמצעות מופע מסווג משנה של EmbeddedServletContainerFactory. לדוגמה, אתה יכול להשתמש ב- TomcatEmbeddedServletContainerFactory כדי להגדיר את סרוולט Tomcat המשובץ שלך.

ה TomcatEmbeddedServletContainerFactory עוטף את org.apache.catalina.startup.Tomcat אובייקט המספק אפשרויות תצורה נוספות:

@Bean Public ConfigurableServletWebServerFactory servletContainer () {TomcatServletWebServerFactory tomcatContainerFactory = חדש TomcatServletWebServerFactory (); החזר tomcatContainerFactory; }

אז נוכל להגדיר את המופע שהוחזר:

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

ניתן להגדיר את כל אחת מאותן הגדרות מסוימות באמצעות כל אחת מהשיטות שתוארו לעיל.

אנו יכולים גם לגשת ישירות לתפעל את ה- org.apache.catalina.startup.Tomcat לְהִתְנַגֵד:

Tomcat tomcat = Tomcat חדש (); tomcat.setPort (יציאה); tomcat.setContextPath ("/ springboottomcatexample"); tomcat.start ();

6. מסקנה

במאמר זה סקרנו כמה דרכים לרשום Servlet ביישום ג'קרטה EE ו- Spring Boot.

קוד המקור המשמש במדריך זה זמין בפרויקט Github.