מזהה אזור
REGION_ID הוא קוד מקוצר ש-Google מקצה על סמך האזור שבוחרים כשיוצרים את האפליקציה. הקוד לא תואם למדינה או למחוז, למרות שחלק ממזהי האזורים עשויים להיראות דומים לקודים נפוצים של מדינות ומחוזות. באפליקציות שנוצרו אחרי פברואר 2020, REGION_ID.r נכלל בכתובות URL של App Engine. באפליקציות קיימות שנוצרו לפני התאריך הזה, מזהה האזור הוא אופציונלי בכתובת ה-URL.
אפליקציות אינטרנט ב-Java משתמשות בקובץ תיאור פריסה כדי לקבוע איך כתובות URL ממופות ל-servlets, אילו כתובות URL דורשות אימות ומידע נוסף. שם הקובץ הוא web.xml, והוא חלק ממפרט ה-servlet לאפליקציות אינטרנט.
מידע נוסף על web.xml קובץ תיאור הפריסה זמין במפרט של servlet.
אם אתם מבצעים העברה מ-Java 8 ואתם צריכים להשתמש בשירותים הישנים שצורפו לגרסה העדכנית הנתמכת של Java, אתם צריכים להוסיף את הרכיב <app-engine-apis> ולהגדיר אותו לערך true בקובץ web.xml:
<app-engine-apis>true</app-engine-apis>
קובצי תיאור פריסה
קובץ תיאור הפריסה של אפליקציית אינטרנט מתאר את המחלקות, המשאבים וההגדרות של האפליקציה, ואיך שרת האינטרנט משתמש בהם כדי לטפל בבקשות אינטרנט. כאשר שרת האינטרנט מקבל בקשה לאפליקציה, הוא משתמש בקובץ תיאור הפריסה כדי למפות את כתובת ה-URL של הבקשה לקוד שאמור לטפל בבקשה.
קובץ תיאור הפריסה הוא קובץ בשם web.xml. הוא נמצא בקובץ ה-WAR של האפליקציה בספרייה WEB-INF/. הקובץ הוא קובץ XML שרכיב הבסיס שלו הוא <web-app>.
בדוגמה הבאה web.xml ממופים כל נתיבי כתובות ה-URL (/*) למחלקה של ה-servlet mysite.server.ComingSoonServlet ב-Jakarta EE 10, EE 11 ב-servlet 6.0 וב-Java EE 8. כדי להשתמש בגרסה העדכנית ביותר שנתמכת בהגדרת ברירת המחדל, צריך לעדכן את רכיבי ה-servlet של האפליקציה ואת התלות שלהם כך שיכללו את מרחב השמות Jakarta. מידע נוסף על אפשרויות ההגדרה זמין במאמר שדרוג של אפליקציה קיימת.
Jakarta EE 11
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_1.xsd"
version="6.1">
<servlet>
<servlet-name>comingsoon</servlet-name>
<servlet-class>mysite.server.ComingSoonServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>comingsoon</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
Jakarta EE 10
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_6_0.xsd"
version="6.0">
<servlet>
<servlet-name>comingsoon</servlet-name>
<servlet-class>mysite.server.ComingSoonServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>comingsoon</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
Java EE 8
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<servlet>
<servlet-name>comingsoon</servlet-name>
<servlet-class>mysite.server.ComingSoonServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>comingsoon</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
אם מחלקים את האפליקציה לשירותים, לכל שירות יש פרמטרים משלו להגדרה.
Servlets ונתיבים של כתובות URL
web.xml מגדיר מיפויים בין נתיבי כתובות URL לבין הסרוולטים שמטפלים בבקשות עם הנתיבים האלה. שרת האינטרנט משתמש בהגדרה הזו כדי לזהות את ה-servlet לטיפול בבקשה נתונה, וקורא לשיטת המחלקה שמתאימה לשיטת הבקשה. לדוגמה: ה-method doGet() לבקשות HTTP GET.
כדי למפות כתובת URL לסרוולט, צריך להצהיר על הסרוולט באמצעות האלמנט <servlet>, ואז להגדיר מיפוי מנתיב כתובת ה-URL להצהרה על סרוולט באמצעות האלמנט <servlet-mapping>.
רכיב <servlet> מכריז על ה-servlet, כולל שם שמשמש להתייחסות ל-servlet על ידי רכיבים אחרים בקובץ, המחלקה שבה יש להשתמש עבור ה-servlet ופרמטרים של אתחול. אפשר להצהיר על כמה סרוולטים באמצעות אותה מחלקה עם פרמטרים שונים של אתחול. השם של כל servlet חייב להיות ייחודי בתוך קובץ תיאור הפריסה.
<servlet> <servlet-name>redteam</servlet-name> <servlet-class>mysite.server.TeamServlet</servlet-class> <init-param> <param-name>teamColor</param-name> <param-value>red</param-value> </init-param> <init-param> <param-name>bgColor</param-name> <param-value>#CC0000</param-value> </init-param> </servlet> <servlet> <servlet-name>blueteam</servlet-name> <servlet-class>mysite.server.TeamServlet</servlet-class> <init-param> <param-name>teamColor</param-name> <param-value>blue</param-value> </init-param> <init-param> <param-name>bgColor</param-name> <param-value>#0000CC</param-value> </init-param> </servlet>
רכיב <servlet-mapping> מציין תבנית URL ואת השם של סרוולט מוצהר שייעשה בו שימוש לבקשות שכתובת ה-URL שלהן תואמת לתבנית. בתבנית של כתובת ה-URL אפשר להשתמש בכוכבית (*) בתחילת התבנית או בסופה כדי לציין אפס תווים או יותר מכל תו. דפוס כתובת ה-URL לא תומך בתווים כלליים באמצע מחרוזת, ולא מאפשר שימוש בכמה תווים כלליים בדפוס אחד. התבנית תואמת לנתיב המלא של כתובת ה-URL, החל מהלוכסן (/) שאחרי שם הדומיין, כולל הלוכסן. נתיב כתובת ה-URL לא יכול להתחיל בנקודה (.).
<servlet-mapping> <servlet-name>redteam</servlet-name> <url-pattern>/red/*</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>blueteam</servlet-name> <url-pattern>/blue/*</url-pattern> </servlet-mapping>
בדוגמה הזו, בקשה לכתובת ה-URL http://www.example.com/blue/teamProfile מטופלת על ידי המחלקה TeamServlet, כאשר הפרמטר teamColor שווה ל-blue והפרמטר bgColor שווה ל-#0000CC. ה-servlet יכול לקבל את החלק של נתיב כתובת ה-URL שתואם לתו כל כללי באמצעות השיטה getPathInfo() של האובייקט ServletRequest.
הסרוולט יכול לגשת לפרמטרים של ההפעלה שלו באמצעות קבלת ההגדרה של הסרוולט באמצעות השיטה getServletConfig() שלו, ואז קריאה לשיטה getInitParameter() באובייקט ההגדרה באמצעות שם הפרמטר כארגומנט.
String teamColor = getServletConfig().getInitParameter("teamColor");
JSPs
אפליקציה יכולה להשתמש ב-JavaServer Pages (JSP) כדי להטמיע דפי אינטרנט. קובצי JSP הם סרוולטים שמוגדרים באמצעות תוכן סטטי, כמו HTML, בשילוב עם קוד Java.
App Engine תומך בהידור אוטומטי ובמיפוי כתובות URL ל-JSP. קובץ JSP ב-WAR של האפליקציה (מחוץ ל-WEB-INF/) ששם הקובץ שלו מסתיים ב-.jsp עובר קומפילציה אוטומטית למחלקת servlet, וממופה לנתיב כתובת ה-URL ששווה לנתיב לקובץ ה-JSP משורש ה-WAR. לדוגמה, אם לאפליקציה יש קובץ JSP בשם start.jsp בספריית משנה בשם register/ בקובץ ה-WAR שלה, App Engine יקמפל אותו וימפה אותו לנתיב כתובת ה-URL /register/start.jsp.
אם רוצים לקבל יותר שליטה על המיפוי של ה-JSP לכתובת URL, אפשר לציין את המיפוי באופן מפורש על ידי הצהרה עליו באמצעות רכיב <servlet> בתיאור הפריסה. במקום אלמנט <servlet-class>, מציינים אלמנט <jsp-file> עם הנתיב לקובץ ה-JSP משורש ה-WAR. האלמנט <servlet> של JSP יכול להכיל פרמטרים של אתחול.
<servlet> <servlet-name>register</servlet-name> <jsp-file>/register/start.jsp</jsp-file> </servlet> <servlet-mapping> <servlet-name>register</servlet-name> <url-pattern>/register/*</url-pattern> </servlet-mapping>
אפשר להתקין ספריות תגים של JSP באמצעות האלמנט <taglib>. לספריית תגים יש נתיב לקובץ JSP Tag Library Descriptor (TLD) (<taglib-location>) ו-URI שדפי JSP משתמשים בו כדי לבחור את הספרייה לטעינה (<taglib-uri>). שימו לב ש-App Engine מספק את JavaServer Pages Standard Tag Library (JSTL), ואין צורך להתקין אותה.
<taglib> <taglib-uri>/escape</taglib-uri> <taglib-location>/WEB-INF/escape-tags.tld</taglib-location> </taglib>
אבטחה ואימות
אפליקציית App Engine יכולה להשתמש בחשבונות Google לאימות משתמשים. האפליקציה יכולה להשתמש ב-Google Accounts API כדי לזהות אם המשתמש מחובר, לקבל את כתובת האימייל של המשתמש שמחובר כרגע וליצור כתובות URL לכניסה ויציאה. אפליקציה יכולה גם לציין הגבלות גישה לנתיבי כתובות URL על סמך חשבונות Google, באמצעות מתאר הפריסה.
רכיב <security-constraint> מגדיר אילוצי אבטחה לכתובות URL שתואמות לתבנית. אם משתמש ניגש לכתובת URL שהנתיב שלה כולל הגבלת אבטחה והמשתמש לא מחובר, App Engine מפנה אותו לדף הכניסה לחשבונות Google. אחרי שהמשתמש נכנס לחשבון Google או נרשם לחשבון חדש, הוא מופנה חזרה לכתובת ה-URL של האפליקציה. האפליקציה לא צריכה לבצע פעולות נוספות כדי להבטיח שרק משתמשים מחוברים יוכלו לגשת לכתובת ה-URL.
אילוצי אבטחה כוללים אילוצי הרשאה שמציינים אילו משתמשים עם חשבונות Google יכולים לגשת לנתיב. אם אילוץ ההרשאה מציין תפקיד משתמש של *, כל משתמש שמחובר לחשבון Google יכול לגשת לכתובת ה-URL. אם ההגבלה מציינת תפקיד משתמש של admin, רק מפתחים רשומים של האפליקציה יכולים לגשת לכתובת ה-URL. adminהתפקיד
מאפשר ליצור בקלות קטעים באתר שרק לאדמינים יש גישה אליהם.
<security-constraint> <web-resource-collection> <web-resource-name>profile</web-resource-name> <url-pattern>/profile/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>*</role-name> </auth-constraint> </security-constraint> <security-constraint> <web-resource-collection> <web-resource-name>admin</web-resource-name> <url-pattern>/admin/*</url-pattern> </web-resource-collection> <auth-constraint> <role-name>admin</role-name> </auth-constraint> </security-constraint>
App Engine לא תומך בתפקידי אבטחה בהתאמה אישית (<security-role>) או במנגנוני אימות חלופיים (<login-config>) בתיאור הפריסה.
מגבלות האבטחה חלות על קבצים סטטיים וגם על servlets.
כתובות URL מאובטחות
App Engine תומך בחיבורים מאובטחים עם HTTPS לכתובות URL באמצעות הדומיין REGION_ID.r.appspot.com. כשבקשה ניגשת לכתובת URL באמצעות HTTPS, וכתובת ה-URL הזו מוגדרת לשימוש ב-HTTPS בקובץ web.xml, גם נתוני הבקשה וגם נתוני התגובה מוצפנים על ידי השולח לפני שהם מועברים, ומפוענחים על ידי הנמען אחרי שהם מתקבלים. חיבורים מאובטחים שימושיים להגנה על נתוני לקוחות, כמו פרטים ליצירת קשר, סיסמאות והודעות פרטיות.
כדי להצהיר שצריך להשתמש ב-HTTPS עבור כתובת URL, מגדירים אילוץ אבטחה בקובץ תיאור הפריסה (כפי שמתואר במאמר אבטחה ואימות) עם תג <user-data-constraint> שהערך של <transport-guarantee> שלו הוא CONFIDENTIAL.
לדוגמה:
<security-constraint> <web-resource-collection> <web-resource-name>profile</web-resource-name> <url-pattern>/profile/*</url-pattern> </web-resource-collection> <user-data-constraint> <transport-guarantee>CONFIDENTIAL</transport-guarantee> </user-data-constraint> </security-constraint>
בקשות שמשתמשות ב-HTTP (לא מאובטח) לכתובות URL שההעברה שלהן מובטחת על ידי CONFIDENTIAL מופנות אוטומטית לאותה כתובת URL באמצעות HTTPS.
כל כתובת URL יכולה להשתמש בהבטחת ההעברה CONFIDENTIAL, כולל קובצי JSP וקובצי סטטיים.
שרת פיתוח להצגה באינטרנט (development web server) לא תומך בחיבורי HTTPS. הוא מתעלם מההבטחה לגבי התעבורה, כך שאפשר לבדוק נתיבים שמיועדים לשימוש עם HTTPS באמצעות חיבורי HTTP רגילים לשרת פיתוח להצגה באינטרנט (development web server).
כשבודקים את אמצעי הטיפול ב-HTTPS של האפליקציה באמצעות כתובת URL עם גרסה ב-appspot.com, כמו https://1.latest.your_app_id.REGION_ID.r.appspot.com/, הדפדפן מציג אזהרה שאישור ה-HTTPS לא נחתם עבור נתיב הדומיין הספציפי הזה. אם מאשרים את האישור לדומיין הזה, הדפים ייטענו בהצלחה. המשתמשים לא יראו את אזהרת האישור כשהם ייגשו אל https://your_app_id.REGION_ID.r.appspot.com/.
אפשר גם להשתמש בפורמט חלופי של כתובת ה-URL עם הגרסה ב-appspot.com, שנועד למנוע את הבעיה הזו. כדי לעשות את זה, צריך להחליף את הנקודות שמפרידות בין רכיבי תת-הדומיין במחרוזת -dot-. לדוגמה, אפשר לגשת לדוגמה הקודמת ללא אזהרה לגבי אישור בכתובת https://VERSION_ID-dot-default-dot-PROJECT_ID.REGION_ID.r.appspot.com.
הכניסה לחשבונות Google והיציאה מהם מתבצעות תמיד באמצעות חיבור מאובטח, ואין קשר בין זה לבין אופן ההגדרה של כתובות ה-URL של האפליקציה.
כפי שצוין למעלה, מגבלות האבטחה חלות על קבצים סטטיים וגם על סרוולטים. האחריות הזו כוללת את האחריות לשינוע.
הערה: Google ממליצה
להשתמש בפרוטוקול HTTPS כדי לשלוח בקשות לאפליקציה. Google לא מנפיקה אישורי SSL לדומיינים עם תו כללי כפול לחיפוש שמארחים ב-appspot.com. לכן, כשמשתמשים ב-HTTPS, צריך להשתמש במחרוזת '-dot-' במקום בנקודה '.' כדי להפריד בין תת-דומיינים, כמו בדוגמאות שלמטה. אפשר להשתמש בנקודה פשוטה '.' עם דומיין מותאם אישית משלכם או עם כתובות HTTP.
רשימת קבצים עם הודעת פתיחה
אם כתובות ה-URL של האתר מייצגות נתיבים לקבצים סטטיים או ל-JSP ב-WAR, כדאי שגם נתיבים לספריות יבצעו פעולה שימושית.
משתמש שנכנס לנתיב כתובת ה-URL /help/accounts/password.jsp כדי לקבל מידע על סיסמאות לחשבון, עשוי לנסות להיכנס לכתובת /help/accounts/ כדי למצוא דף עם מבוא לתיעוד של מערכת החשבונות. קובץ תיאור הפריסה יכול לציין רשימה של שמות קבצים שהשרת צריך לנסות כשהמשתמש ניגש לנתיב שמייצג ספריית משנה של WAR שלא ממופה כבר באופן מפורש ל-servlet. במפרט של ה-servlet, הרכיב הזה נקרא welcome file list.
לדוגמה, אם המשתמש ניגש לנתיב כתובת ה-URL /help/accounts/, הרכיב <welcome-file-list> הבא בקובץ תיאור הפריסה מציין לשרת לבדוק את help/accounts/index.jsp ואת help/accounts/index.html לפני שהוא מדווח שכתובת ה-URL לא קיימת:
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
<welcome-file>index.html</welcome-file>
</welcome-file-list>מסננים
מסנן הוא מחלקה שפועלת על בקשה כמו סרוולט, אבל יכולה לאפשר לטיפול בבקשה להמשיך עם מסננים או סרוולטים אחרים. מסנן יכול לבצע משימה משנית, כמו רישום ביומן, ביצוע בדיקות אימות מיוחדות או הוספת הערות לאובייקטים של הבקשה או התגובה לפני הקריאה ל-servlet. המסננים מאפשרים ליצור משימות לעיבוד בקשות מתוך קובץ תיאור הפריסה.
בדוגמה הבאה להטמעה של מסנן מתבצעת רישום ביומן של הודעה, והשליטה מועברת בהמשך לשרשרת, שעשויה לכלול מסננים אחרים או servlet, כפי שמתואר בקובץ תיאור הפריסה לגרסה 21 ואילך ב-EE10 (ברירת מחדל), לגרסה 21 ב-EE8 ולגרסה 17 ואילך. כדי להשתמש בגרסה העדכנית ביותר שנתמכת בהגדרת ברירת המחדל, צריך לעדכן את רכיבי ה-servlet של האפליקציה ואת התלות שלהם כך שיכללו את מרחב השמות Jakarta. מידע נוסף על אפשרויות ההגדרה זמין במאמר שדרוג של אפליקציה קיימת.
גרסה 21 ואילך (EE10)
מחלקה זו של מסננים מטמיעה את הממשק jakarta.servlet.Filter באמצעות המתודה doFilter().
package mysite.server;
import java.io.IOException;
import java.util.logging.Logger;
import jakarta.servlet.Filter;
import jakarta.servlet.FilterChain;
import jakarta.servlet.FilterConfig;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletRequest;
import jakarta.servlet.ServletResponse;
public class LogFilterImpl implements Filter {
private FilterConfig filterConfig;
private static final Logger log = Logger.getLogger(LogFilterImpl.class.getName());
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws IOException, ServletException {
log.warning("Log filter processed a " + getFilterConfig().getInitParameter("logType")
+ " request");
filterChain.doFilter(request, response);
}
public FilterConfig getFilterConfig() {
return filterConfig;
}
public void init(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
public void destroy() {}
}
v21 (EE8)
במחלקה הזו של המסנן מוטמע הממשק javax.servlet.Filter עם המתודה doFilter().
package mysite.server;
import java.io.IOException;
import java.util.logging.Logger;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class LogFilterImpl implements Filter {
private FilterConfig filterConfig;
private static final Logger log = Logger.getLogger(LogFilterImpl.class.getName());
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws IOException, ServletException {
log.warning("Log filter processed a " + getFilterConfig().getInitParameter("logType")
+ " request");
filterChain.doFilter(request, response);
}
public FilterConfig getFilterConfig() {
return filterConfig;
}
public void init(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
public void destroy() {}
}
גרסה 17 וגרסאות קודמות
מחלקה זו של מסננים מטמיעה את הממשק javax.servlet.Filter באמצעות המתודה doFilter().
package mysite.server;
import java.io.IOException;
import java.util.logging.Logger;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public class LogFilterImpl implements Filter {
private FilterConfig filterConfig;
private static final Logger log = Logger.getLogger(LogFilterImpl.class.getName());
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws IOException, ServletException {
log.warning("Log filter processed a " + getFilterConfig().getInitParameter("logType")
+ " request");
filterChain.doFilter(request, response);
}
public FilterConfig getFilterConfig() {
return filterConfig;
}
public void init(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
public void destroy() {}
}
בדומה ל-servlets, מגדירים מסנן בתיאור הפריסה על ידי הצהרה על המסנן באמצעות רכיב <filter>, ואז מיפוי שלו לתבנית של כתובת URL באמצעות רכיב <filter-mapping>. אפשר גם למפות מסננים ישירות לסרוולטים אחרים.
הרכיב <filter> מכיל רכיבים <filter-name>, <filter-class> ורכיבים אופציונליים <init-param>.
<filter> <filter-name>logSpecial</filter-name> <filter-class>mysite.server.LogFilterImpl</filter-class> <init-param> <param-name>logType</param-name> <param-value>special</param-value> </init-param> </filter>
האלמנט <filter-mapping> מכיל את האלמנט <filter-name> שתואם לשם של מסנן מוצהר, ואת האלמנט <url-pattern> להחלת המסנן על כתובות URL, או את האלמנט <servlet-name> שתואם לשם של servlet מוצהר להחלת המסנן בכל פעם שה-servlet נקרא.
<!-- Log for all URLs ending in ".special" --> <filter-mapping> <filter-name>logSpecial</filter-name> <url-pattern>*.special</url-pattern> </filter-mapping> <!-- Log for all URLs that use the "comingsoon" servlet --> <filter-mapping> <filter-name>logSpecial</filter-name> <servlet-name>comingsoon</servlet-name> </filter-mapping>
טיפול בשגיאות
אפשר להתאים אישית את מה שהשרת שולח למשתמש כשמתרחשת שגיאה, באמצעות קובץ תיאור הפריסה. השרת יכול להציג מיקום חלופי של דף כשהוא עומד לשלוח קוד סטטוס של HTTP מסוים, או כשסרוולט מעלה חריג מסוים של Java.
האלמנט <error-page> מכיל אלמנט <error-code> עם ערך של קוד שגיאת HTTP (למשל 500), או אלמנט <exception-type> עם שם המחלקה של החריגה הצפויה (למשל java.io.IOException). הוא מכיל גם אלמנט <location> עם נתיב כתובת ה-URL של המשאב שיוצג כשהשגיאה מתרחשת.
<error-page> <error-code>500</error-code> <location>/errors/servererror.jsp</location> </error-page>
אי אפשר להגדיר מטפלים מותאמים אישית בשגיאות עבור תנאי השגיאה הבאים:
- תגובת
404כשלא מוגדר מיפוי של servlet לכתובת URL. - דף שגיאת מכסה
403 500דף שגיאת שרת שמופיע אחרי שגיאה פנימית ב-App Engine.
תכונות שלא נתמכות ב-web.xml
התכונות הבאות של web.xml לא נתמכות ב-App Engine:
- App Engine תומך ברכיב
<load-on-startup>להצהרות על סרוולטים. עם זאת, הטעינה מתרחשת בפועל במהלך הבקשה הראשונה שמטופלת על ידי מופע שרת האינטרנט, ולא לפני כן. - חלק מרכיבי קובץ תיאור הפריסה יכולים לקבל שם מוצג קריא, תיאור וסמל לשימוש בסביבות פיתוח משולבות (IDE). App Engine לא משתמש בהן ומתעלם מהן.
- App Engine לא תומך במשתני סביבה של JNDI (
<env-entry>). - App Engine לא תומך במשאבי EJB (
<resource-ref>). - אין תמיכה בהודעה על השמדה של סרוולטים, הקשר של סרוולט או מסננים.
- המערכת מתעלמת מהרכיב
<distributable>. - אין תמיכה בתזמון של Servlet באמצעות
<run-at>.