दिलचस्प पोस्ट
एल्गोरिथ्म यह निर्धारित करने के लिए कि क्या सरणी में एन … एन + मी? एक Django forms.ChoiceField पर चयनित मान सेट करना WPF सीमा रहित विंडो के लिए DropShadow आदेश दिया गया कुंजियों के साथ एनएसडिएशन रनटाइम पर इकाई फ्रेमवर्क परिवर्तन कनेक्शन MySQL को संग्रहीत दिनचर्या को पास करें एफएफपीपीई जानकारी को मित्रवत तरीके से प्राप्त करें REGISTER_GLOBALS बहुत बुरा क्यों है? मैं अपने सी # WinForm एप्लिकेशन को कैसे पुनरारंभ करूं? सीएसएस सामग्री की संपत्ति: क्या टेक्स्ट के बजाय एचटीएमएल सम्मिलित करना संभव है? Android में एक आशय क्या है? कैसे नए को हटाने के साथ जोड़ना संभवतः स्मृति रिसाव के लिए नेतृत्व कर सकते हैं केवल? एमएस एक्सेल के लिए JSON प्रारूप को सीएसवी प्रारूप में कनवर्ट करें जब आप git विलय के बजाय git रिज का उपयोग करते हैं? मैं वादा करने के लिए मौजूदा कॉलबैक एपीआई कैसे बदलूं?

JSP फ़ाइलों में जावा कोड से बचने के लिए कैसे?

मैं जावा ईई के लिए नया हूँ और मुझे पता है कि निम्न तीन लाइनों की तरह कुछ

<%= x+1 %> <%= request.getParameter("name") %> <%! counter++; %> 

कोडिंग का एक पुराना स्कूल तरीका है और जेएसपी संस्करण 2 में जेएसपी फाइलों में जावा कोड से बचने का एक तरीका मौजूद है। क्या कोई मुझे वैकल्पिक जेएसपी 2 लाइनें बता सकता है, और क्या इस तकनीक को कहा जाता है?

वेब के समाधान से एकत्रित समाधान "JSP फ़ाइलों में जावा कोड से बचने के लिए कैसे?"

जेएसपी में स्क्रीप्लेट्स (उन <% %> चीजों का उपयोग) वास्तव में एक दशक पहले टैगलिब्स (जैसे जेएसटीएल ) और ईएल ( अभिव्यक्ति भाषा , उन ${} चीजें ${} ) के जन्म के बाद बहुत हतोत्साहित हैं

पटकथाओं का प्रमुख नुकसान इस प्रकार हैं:

  1. Reusability: आप scriptlets पुन: उपयोग नहीं कर सकते
  2. प्रतिस्थापन: आप पटकथाओं को सार नहीं बना सकते हैं
  3. ऊ-क्षमता: आप विरासत / संरचना का उपयोग नहीं कर सकते
  4. डिबग्यूबिलिटी: यदि स्क्रिप्टलेट अपवाद आधे रास्ते को फेंकती है, तो आपको एक रिक्त पृष्ठ मिलता है।
  5. परीक्षण योग्यता : स्क्रीप्लेट यूनिट-परीक्षण योग्य नहीं हैं I
  6. रखरखाव योग्यता : प्रति सदाबहार / क्लेटेड / डुप्लिकेट कोड लॉजिक बनाए रखने के लिए अधिक समय की आवश्यकता होती है।

सूर्य ओरेकल खुद जेएसपी कोडिंग सम्मेलनों में भी अनुशंसा करता है ताकि जब भी एक ही कार्यक्षमता (टैग) कक्षाओं द्वारा संभव हो, तो स्क्रिप्टलेट्स का उपयोग करने से बचने के लिए। प्रासंगिकता के कई संकेत दिए गए हैं:

जेएसपी 1.2 विशिष्टता से, यह अत्यधिक अनुशंसित है कि जेएसपी मानक टैग लाइब्रेरी (जेएसटीएल) का उपयोग आपके वेब अनुप्रयोग में किया जाये ताकि आप अपने पृष्ठों में जेएसपी स्क्रिप्टलेट की आवश्यकता को कम कर सकें । जेएसटीएल का उपयोग करने वाले पृष्ठ सामान्य रूप से, पढ़ने और बनाए रखने में आसान हैं।

जहां संभव हो, जेएसपी स्क्रिप्टलेट से बचें जब भी टैग लाइब्रेरी समतुल्य कार्यक्षमता प्रदान करते हैं यह पेज को पढ़ने और बनाए रखने में आसान बनाता है, प्रस्तुति तर्क से व्यावसायिक तर्क को अलग करने में मदद करता है, और जेपीपी 2.0-शैली वाले पृष्ठों (जेएसपी 2.0 विनिर्देश का समर्थन करता है, लेकिन स्क्रिप्टलेट्स का उपयोग करने पर जोर देता है) में अपने पृष्ठों को विकसित करने में आसान बना देगा।

बिजनेस लॉजिक से प्रस्तुति स्तर के बीच युग्मन को कम करने के लिए मॉडल-व्यू-नियंत्रक (एमवीसी) डिजाइन पैटर्न को अपनाने की भावना में, बिजनेस लॉजिक लिखने के लिए जेएसपी स्किपलेट का उपयोग नहीं किया जाना चाहिए । इसके बजाय, जेएसपी स्क्रिप्टलेट का उपयोग किया जाता है यदि आवश्यक डाटा को बदलने के लिए ("मूल्य ऑब्जेक्ट" भी कहा जाता है) क्लाइंट के अनुरोधों को उचित क्लाइंट-तैयार प्रारूप में प्रोसेस करने से वापस आ जाता है। फिर भी, यह एक फ्रंट नियंत्रक सर्वलेट या एक कस्टम टैग के साथ बेहतर होगा


पटकथाओं को कैसे प्रतिस्थापित करना पूरी तरह से कोड / तर्क के एकमात्र उद्देश्य पर निर्भर करती है। अक्सर यह कोड पूर्णवर्थ जावा क्लास में रखा जाना है:

  • अगर आप अनुरोध किए गए पृष्ठ की परवाह किए बिना हर अनुरोध, कम या अधिक पर एक ही जावा कोड लागू करना चाहते हैं, जैसे किसी उपयोगकर्ता द्वारा लॉग इन किए जाने की जांच करना, फिर एक फिल्टर को लागू करें और इसके अनुसार doFilter() विधि में कोड लिखें। उदाहरण के लिए:

     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException { if (((HttpServletRequest) request).getSession().getAttribute("user") == null) { ((HttpServletResponse) response).sendRedirect("login"); // Not logged in, redirect to login page. } else { chain.doFilter(request, response); // Logged in, just continue request. } } 

    जब किसी उपयुक्त <url-pattern> पर मैप की गई, तो जेएसपी पेजों को कवर करने के लिए, फिर आपको सभी जेएसपी पेजों पर कोड का एक ही टुकड़ा कॉपी करने की आवश्यकता नहीं है।


  • यदि आप कुछ जावा कोड को एक अनुरोध को प्रीप्रोस करने के लिए आमंत्रित करना चाहते हैं, उदाहरण के लिए कुछ तालिका में प्रदर्शित करने के लिए डेटाबेस से कुछ सूची लोड करना, यदि आवश्यक हो तो कुछ क्वेरी मापदंडों पर आधारित, फिर एक सर्विसलेट को लागू करें और कोड के अनुसार doGet() विधि लिखें। उदाहरण के लिए:

     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { List<Product> products = productService.list(); // Obtain all products. request.setAttribute("products", products); // Store products in request scope. request.getRequestDispatcher("/WEB-INF/products.jsp").forward(request, response); // Forward to JSP page to display them in a HTML table. } catch (SQLException e) { throw new ServletException("Retrieving products failed!", e); } } 

    इस तरह के अपवादों से निपटना आसान है। जेएसपी रेंडरिंग के बीच डीबी का उपयोग नहीं किया गया है, लेकिन जेएसपी प्रदर्शित होने से पहले। जब भी डीबी एक्सेस एक अपवाद फेंकता है तब भी आपको प्रतिक्रिया बदलने की संभावना है उपर्युक्त उदाहरण में, डिफ़ॉल्ट त्रुटि 500 ​​पृष्ठ प्रदर्शित किया जाएगा जो आप किसी भी तरह से <error-page> web.xml में अनुकूलित कर सकते हैं।


  • यदि आप कुछ जावा कोड को अनुरोध पोस्ट प्रोसेस करने के लिए आमंत्रित करना चाहते हैं, उदाहरण के लिए एक फार्म सबमिट करना प्रसंस्करण करें, फिर सर्वोलेट को लागू करें और कोड के अनुसार doPost() विधि लिखिए। उदाहरण के लिए:

     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { String username = request.getParameter("username"); String password = request.getParameter("password"); User user = userService.find(username, password); if (user != null) { request.getSession().setAttribute("user", user); // Login user. response.sendRedirect("home"); // Redirect to home page. } else { request.setAttribute("message", "Unknown username/password. Please retry."); // Store error message in request scope. request.getRequestDispatcher("/WEB-INF/login.jsp").forward(request, response); // Forward to JSP page to redisplay login form with error. } } 

    अलग-अलग परिणाम पृष्ठ स्थलों से निपटने में यह तरीका आसान है: त्रुटि के मामले में सत्यापन त्रुटियों के साथ फ़ॉर्म को फिर से प्रदर्शित करना (इस विशेष उदाहरण में आप इसे EL में ${message} का उपयोग करके फिर से फिर से दिखा सकते हैं, या बस वांछित लक्ष्य पृष्ठ पर ले जा सकते हैं। सफलता की।


  • अगर आप निष्पादन योजना और / या अनुरोध के गंतव्य और प्रतिक्रिया को नियंत्रित करने के लिए कुछ जावा कोड लागू करना चाहते हैं, तो एमवीसी के फ्रंट नियंत्रक पैटर्न के अनुसार सर्वलेट को लागू करें। उदाहरण के लिए:

     protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { Action action = ActionFactory.getAction(request); String view = action.execute(request, response); if (view.equals(request.getPathInfo().substring(1)) { request.getRequestDispatcher("/WEB-INF/" + view + ".jsp").forward(request, response); } else { response.sendRedirect(view); } } catch (Exception e) { throw new ServletException("Executing action failed.", e); } } 

    या सिर्फ जेएसएफ , स्प्रिंग एमवीसी , विकेट इत्यादि जैसे एमवीसी फ्रेमवर्क अपनाने के लिए, ताकि आप केवल एक जेएसपी / फेसलेट पृष्ठ और एक जावाबायन क्लास के साथ एक कस्टम सर्विसलेट की आवश्यकता के बिना समाप्त हो जाएं।


  • यदि आप जेएसपी पेज के अंदर प्रवाह को नियंत्रित करने के लिए कुछ जावा कोड को खोलना चाहते हैं, तो आपको जेएसटीएल कोर की तरह एक (मौजूदा) प्रवाह नियंत्रण टैगलिब को पकड़ना होगा । उदाहरण एक List<Product> प्रदर्शित करें:

     <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> ... <table> <c:forEach items="${products}" var="product"> <tr> <td>${product.name}</td> <td>${product.description}</td> <td>${product.price}</td> </tr> </c:forEach> </table> 

    एक्सएमएल-स्टाइल टैग्स के साथ जो कि सभी HTML के बीच अच्छी तरह से फिट बैठता है, कोड को विभिन्न खुले और समापन ब्रेसिज़ ( "जहां यह बंद समापन ब्रेस करता है?" ) के साथ स्क्रीप्लेट की एक गुच्छा की तुलना में बेहतर पठनीय (और इस प्रकार बेहतर रख-रखाव) है। एक आसान सहायता वेब अप्लीकेशन को कॉन्फ़िगर करने के लिए एक अपवाद फेंकना है, जब भी स्क्रीप्लेट का उपयोग वेब.एक्सएमएल को निम्नलिखित टुकड़ा जोड़कर किया जाता है:

     <jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <scripting-invalid>true</scripting-invalid> </jsp-property-group> </jsp-config> 

    फेसलेट्स में , जेएसपी के उत्तराधिकारी, जो जावा ईई का हिस्सा है, एमवीसी फ्रेमवर्क जेएसएफ प्रदान करता है, पहले से ही स्क्रीप्लेट का उपयोग करना संभव नहीं है। इस तरह आप चीजों को "सही तरीके से" करने के लिए स्वचालित रूप से मजबूर हो जाते हैं


  • यदि आप कुछ जावा कोड को जेएसपी पेज के अंदर "बैकएंड" डेटा तक पहुंचाने और प्रदर्शित करने के लिए आमंत्रित करना चाहते हैं, तो आपको ईएल (अभिव्यक्ति भाषा), उन ${} चीजों का उपयोग करना होगा। उदाहरण के लिए सबमिट किए गए इनपुट मूल्यों को पुन: प्रदर्शित करना:

     <input type="text" name="foo" value="${param.foo}" /> 

    ${param.foo} request.getParameter("foo") के परिणाम प्रदर्शित करता है।


  • यदि आप कुछ उपयोगिता जावा कोड को सीधे जेएसपी पेज (आम तौर पर public static तरीकों) में जोड़ना चाहते हैं, तो आपको उन्हें ईएल फ़ंक्शन के रूप में परिभाषित करना होगा। जेएसटीएल में एक मानक फ़ंक्शन टैगब्लब है, लेकिन आप आसानी से अपने कार्यों को भी बना सकते हैं । यहां एक उदाहरण है कि एक्सएसएच हमलों को रोकने के लिए जेएसटीएल fn:escapeXml उपयोगी है।

     <%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %> ... <input type="text" name="foo" value="${fn:escapeXml(param.foo)}" /> 

    ध्यान दें कि एक्सएसएस संवेदनशीलता विशेष रूप से जावा / जेएसपी / जेएसटीएल / ईएल / जोशीब से संबंधित नहीं है, इस समस्या को हर वेबपैकेज में विकसित करने की आवश्यकता है जिसे आप विकसित करते हैं। स्क्रीप्लेट की समस्या यह है कि यह मानक जावा एपीआई का उपयोग नहीं करने के साथ-साथ बिल्टिन रोकथाम का कोई रास्ता नहीं प्रदान करता है। जेएसपी के उत्तराधिकारी फेसलेट पहले से ही एचटीएमएल से बाहर निकल रहा है, इसलिए आपको फेसलेट्स में एक्सएसएस छेदों के बारे में चिंता करने की ज़रूरत नहीं है।

यह भी देखें:

  • जेएसपी, सर्लेट और जेएसएफ के बीच अंतर क्या है?
  • सर्विसलेट, सर्विसलेटटॉन्टेक्स, एचटीटीपीएशन और एचटीटीपीएसर्वेटरेंट / रिस्पांस कैसे काम करता है?
  • जेएसपी, सर्लेट और जेडीबीसी के साथ मूल एमवीसी उदाहरण
  • जावा वेब अनुप्रयोगों में डिजाइन पैटर्न
  • JSP / Servlet की छिपी हुई विशेषताओं

सुरक्षा के रूप में: अच्छे के लिए पटकथाएं अक्षम करें

जैसा कि एक अन्य प्रश्न चर्चा कर रहा है, आप अपने web.xml वेब अनुप्रयोग डिस्क्रिप्टर में स्क्रीप्लेट को हमेशा और अक्षम कर सकते हैं।

मैं हमेशा ऐसा करता हूं कि किसी भी डेवलपर को स्क्रिप्टलेट्स को जोड़ने से रोकने के लिए, विशेष रूप से बड़ी कंपनियों में जहां आप जल्दी या बाद में ओवरव्यू खो देंगे वेब। web.xml सेटिंग्स इस तरह दिखती हैं:

 <jsp-config> <jsp-property-group> <url-pattern>*.jsp</url-pattern> <scripting-invalid>true</scripting-invalid> </jsp-property-group> </jsp-config> 

जेएसटीएल सशर्त, लूप, सेट, हो जाता है, आदि के लिए टैग प्रदान करता है उदाहरण के लिए:

 <c:if test="${someAttribute == 'something'}"> ... </c:if> 

जेएसटीएल अनुरोध विशेषताओं के साथ कार्य करता है – वे सबसे अधिक बार सरले द्वारा अनुरोध में सेट करते हैं, जो आगे जेएसपी के लिए।

मुझे यकीन नहीं है कि मुझे ये सही मिलेगा।

आपको एमवीसी के बारे में कुछ पढ़ना चाहिए। स्प्रिंग एमवीसी और स्ट्रट्स 2 दो सबसे आम समाधान हैं

जावा और एचटीएमएल कोड इंटरमीक्सिंग से बचने के लिए आप ईएल एक्सप्रेशंस के साथ जेएसटीएल टैग का उपयोग कर सकते हैं:

 <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %> <html> <head> </head> <body> <c:out value="${x + 1}" /> <c:out value="${param.name}" /> // and so on </body> </html> 

ऐसे घटक-आधारित ढांचा भी होते हैं जैसे कि विकेट जो आपके लिए बहुत सारे HTML उत्पन्न करता है एचटीएमएल में समाप्त होने वाले टैग बेहद मूल होते हैं और वास्तव में कोई तर्क नहीं है जो अंदर मिश्रित हो जाता है। इसका परिणाम लगभग खाली HTML पृष्ठों वाले सामान्य HTML तत्वों के साथ होता है। नकारात्मक पक्ष यह है कि सीखने के लिए विकेट एपीआई में बहुत सारे घटक हैं और कुछ बाधाओं के तहत कुछ चीजें हासिल करना मुश्किल हो सकता है

एमवीसी वास्तुकला पैटर्न में, जेएसपी दृश्य परत का प्रतिनिधित्व करते हैं। JSPs में जावा कोड को एम्बेड करना एक बुरा अभ्यास माना जाता है। आप "टेम्पलेट इंजन" के रूप में जेएसटीएल , फ्री मार्कर , जेएसपी के साथ वेग का उपयोग कर सकते हैं। उन टैगों के डेटा प्रदाता उस चौखटे पर निर्भर करता है जो आप से निपटते हैं। webwork Struts 2 और webwork , एमवीसी पैटर्न के लिए एक कार्यान्वयन के रूप में webwork "बीन्स प्रॉपर्टीज को जेएसपी को बेनकाब करने के लिए बहुत ही दिलचस्प तकनीक" का उपयोग करता है

अनुभव से पता चला है कि जेएसपी के पास कुछ कमियां हैं, उनमें से एक को वास्तविक कोड के साथ मार्कअप मिश्रण से बचने के लिए मुश्किल है।

यदि आप कर सकते हैं, तो आपको एक विशेष तकनीक का उपयोग करने पर विचार करें ताकि आपको क्या करना चाहिए। जावा ईई 6 में जेएसएफ 2.0 है, जो कि #{bean.method(argument)} दृष्टिकोण के माध्यम से जेएसएफ पृष्ठों के साथ मिलकर जावा बीन्स सहित बहुत अच्छी सुविधाएं प्रदान करता है।

विकेट भी एक विकल्प है जो जावा से एचटीएमएल को पूरी तरह से अलग करता है, इसलिए एक डिज़ाइनर और प्रोग्रामर एक-दूसरे के बारे में थोड़ा समझने के साथ मिलकर काम कर सकते हैं।

विकेट को देखो

अगर आप बस जेएसपी में जावा कोडिंग की खामियों से बचने के लिए चाहते हैं तो आप भी स्पीलेट्स के साथ ऐसा कर सकते हैं। बस जेएसपी में न्यूनतम जावा के लिए कुछ अनुशासन का पालन करें और जेएसपी पृष्ठ में लगभग कोई गणना और तर्क नहीं है।

 <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%//instantiate a JSP controller MyController clr = new MyController(request, response); //process action if any clr.process(request); //process page forwaring if necessary //do all variable assignment here String showMe = clr.getShowMe();%> <html> <head> </head> <body> <form name="frm1"> <p><%= showMe %> <p><% for(String str : clr.listOfStrings()) { %> <p><%= str %><% } %> // and so on </form> </body> </html> 

JSTL का उपयोग करके अपना खुद का टैग अनुकूलित और लिखना सीखें

ध्यान दें कि ईएलआईएल (रनटाइम अपवाद, रिफैक्टरिंग) है
विकेट भी बुरा हो सकता है (प्रदर्शन, छोटे एप्लिकेशन या सामान्य दृश्य स्तरीय के लिए परेशान)

जावा 2 से उदाहरण,

यह वेब अनुप्रयोग के web.xml में जोड़ा जाना चाहिए

 <taglib> <taglib-uri>/java2s</taglib-uri> <taglib-location>/WEB-INF/java2s.tld</taglib-location> </taglib> 

फ़ाइल बनाएँ: java2s.tld / web-INF /

 <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd"> <!-- a tab library descriptor --> <taglib xmlns="http://java.sun.com/JSP/TagLibraryDescriptor"> <tlib-version>1.0</tlib-version> <jsp-version>1.2</jsp-version> <short-name>Java2s Simple Tags</short-name> <!-- this tag manipulates its body content by converting it to upper case --> <tag> <name>bodyContentTag</name> <tag-class>com.java2s.BodyContentTag</tag-class> <body-content>JSP</body-content> <attribute> <name>howMany</name> </attribute> </tag> </taglib> 

निम्न कोड को वेब-आईएनएफ \ classes \ com \ java2s में संकलित करें

 package com.java2s; import java.io.IOException; import javax.servlet.jsp.JspWriter; import javax.servlet.jsp.tagext.BodyContent; import javax.servlet.jsp.tagext.BodyTagSupport; public class BodyContentTag extends BodyTagSupport{ private int iterations, howMany; public void setHowMany(int i){ this.howMany = i; } public void setBodyContent(BodyContent bc){ super.setBodyContent(bc); System.out.println("BodyContent = '" + bc.getString() + "'"); } public int doAfterBody(){ try{ BodyContent bodyContent = super.getBodyContent(); String bodyString = bodyContent.getString(); JspWriter out = bodyContent.getEnclosingWriter(); if ( iterations % 2 == 0 ) out.print(bodyString.toLowerCase()); else out.print(bodyString.toUpperCase()); iterations++; bodyContent.clear(); // empty buffer for next evaluation } catch (IOException e) { System.out.println("Error in BodyContentTag.doAfterBody()" + e.getMessage()); e.printStackTrace(); } // end of catch int retValue = SKIP_BODY; if ( iterations < howMany ) retValue = EVAL_BODY_AGAIN; return retValue; } } 

सर्वर प्रारंभ करें और ब्राउज़र में bodyContent.jsp को लोड करें

 <%@ taglib uri="/java2s" prefix="java2s" %> <html> <head> <title>A custom tag: body content</title> </head> <body> This page uses a custom tag manipulates its body content.Here is its output: <ol> <java2s:bodyContentTag howMany="3"> <li>java2s.com</li> </java2s:bodyContentTag> </ol> </body> </html> 

आपने एक अच्छा सवाल उठाया है और अगर आपको अच्छे उत्तर मिलते हैं, तो मैं कहूंगा कि आप जेएसपी से छुटकारा पायेंगे। यह पुरानी तकनीक है जो आखिरकार मर जाएगी टेम्पलेट इंजन जैसे आधुनिक दृष्टिकोण का उपयोग करें आप व्यापार और प्रस्तुति परतों के बहुत स्पष्ट विभाजन और टेम्पलेट्स में निश्चित रूप से कोई जावा कोड नहीं होगा, ताकि आप वेब प्रस्तुति संपादन सॉफ़्टवेयर से सीधे टेम्प्लेट जेनरेट कर सकें, जो ज्यादातर मामलों में WYSIWYG का लाभ उठाते हैं।

और निश्चित रूप से फिल्टर और प्री और पोस्ट प्रोसेसिंग से दूर रहें, अन्यथा आप समर्थन / डिबगिंग कठिनाइयों से निपट सकते हैं, क्योंकि आप हमेशा यह नहीं जानते हैं कि वेरिएबल मूल्य कहां मिल जाता है।

जेएसपी फ़ाइलों में जावा कोड से बचने के लिए जावा अब जेएसटीएल जैसी टैग लाइब्रेरी प्रदान करती है, जावा भी जेएसएफ के साथ आते हैं, जिसमें आप टैग के रूप में सभी प्रोग्रामिंग स्ट्रक्चर लिख सकते हैं।

जब आप अन्य डेवलपर्स के साथ काम करते हैं तो आप कितने भी बचने का प्रयास करते हैं, उनमें से कुछ अभी भी scriptlet पसंद करते हैं और फिर प्रोजेक्ट में बुराई कोड डालें। इसलिए, पहले संकेत पर प्रोजेक्ट सेट करना बहुत ज़रूरी है यदि आप वास्तव में स्क्रिप्टलेट कोड को कम करना चाहते हैं इस पर कई तकनीकें हैं (कई रूपरेखा जिसमें अन्य उल्लेख किया गया है)। हालांकि, यदि आप शुद्ध जेएसपी को पसंद करते हैं, तो जेएसटीएल टैग फ़ाइल का उपयोग करें। इस बारे में अच्छी बात यह है कि आप अपने प्रोजेक्ट के लिए मास्टर पेज भी सेट कर सकते हैं, इसलिए अन्य पृष्ठ मास्टर पेजों के वारिस कर सकते हैं

अपने वेब-आईएनएफ / टैग के तहत बेसटैग नामक एक मास्टर पेज को निम्न सामग्री के साथ बनाएं

 <%@tag description="Overall Page template" pageEncoding="UTF-8"%> <%@attribute name="title" fragment="true" %> <html> <head> <title> <jsp:invoke fragment="title"></jsp:invoke> </title> </head> <body> <div id="page-header"> .... </div> <div id="page-body"> <jsp:doBody/> </div> <div id="page-footer"> ..... </div> </body> </html> 

इस मेटर पेज पर, मैंने "शीर्षक" नामक एक टुकड़ा बनाया है, ताकि बच्चे पृष्ठ में, मैं मास्टर पेज के इस स्थान पर अधिक कोड सम्मिलित कर सकता हूं। इसके अलावा, टैग <jsp:doBody/> को बच्चे पृष्ठ की सामग्री द्वारा प्रतिस्थापित किया जाएगा

अपने वेबकॉटेंट फ़ोल्डर में बाल पृष्ठ (child.jsp) बनाएं:

 <%@ taglib prefix="t" tagdir="/WEB-INF/tags" %> <t:base> <jsp:attribute name="title"> <bean:message key="hello.world" /> </jsp:attribute> <jsp:body> [Put your content of the child here] </jsp:body> </t:base> 

<t:base> का उपयोग उस मास्टर पेज को निर्दिष्ट करने के लिए किया जाता है जिसे आप उपयोग करना चाहते हैं (जो इस समय base.tag है)। टैग <jsp:body> अंदर की सभी सामग्री आपके मास्टर पेज पर <jsp:doBody/> को प्रतिस्थापित करेगी आपका बच्चा पृष्ठ किसी भी टैग को भी शामिल कर सकता है और आप इसका उल्लिखित अन्य रूपों की तरह सामान्य रूप से उपयोग कर सकते हैं। हालांकि, यदि आप यहां किसी भी स्किपलेट कोड का उपयोग करते हैं ( <%= request.getParameter("name") %> …) और इस पृष्ठ को चलाने का प्रयास करें, तो आपको एक JasperException because Scripting elements ( &lt;%!, &lt;jsp:declaration, &lt;%=, &lt;jsp:expression, &lt;%, &lt;jsp:scriptlet ) are disallowed here । इसलिए, जिस तरह से अन्य लोगों में jsp फ़ाइल में बुराई कोड शामिल नहीं हो सकता है

अपने नियंत्रक से इस पृष्ठ को कॉल करना:

आप अपने नियंत्रक से आसानी से child.jsp फाइल को कॉल कर सकते हैं। यह स्ट्रट फ्रेमवर्क के साथ अच्छा काम करता है

JSP में JSTL Tag libraries उपयोग करें, जो सही काम करेगा।

बस जेएसटीएल टैग और ईएल अभिव्यक्ति का उपयोग करें

यदि कोई वास्तव में एक से अधिक भाषाओं में प्रोग्रामिंग के खिलाफ है , तो मैं GWT का सुझाव देता हूं, सैद्धांतिक रूप से आप सभी जेएस और HTML तत्वों से बच सकते हैं, क्योंकि Google Toolkit सभी ग्राहक और साझा कोड को जेएस में बदल देती है, इसलिए आपको उनके साथ समस्या नहीं होगी, इसलिए आपके पास किसी अन्य भाषा में कोडिंग के बिना एक webservice है यहां तक ​​कि आप कहीं भी कुछ डिफ़ॉल्ट सीएसएस का प्रयोग कर सकते हैं क्योंकि यह एक्सटेंशन (स्मार्टजीडब्ल्यूटी या वाडाइन) द्वारा दिया गया है। आपको दर्जनों एनोटेशन सीखने की ज़रूरत नहीं है।

बेशक, यदि आप चाहते हैं, तो आप अपने कोड की गहराई में हैक कर सकते हैं और जेएस को इंजेक्ट कर अपने एचटीएमएल पेज को समृद्ध कर सकते हैं, लेकिन वास्तव में आप इसे से बच सकते हैं यदि आप चाहते हैं, और इसका परिणाम अच्छा होगा क्योंकि यह किसी भी अन्य चौखटे में लिखा गया था। मैं कहता हूं कि एक कोशिश के लायक है, और मूल जीडब्ल्यूटी अच्छी तरह से प्रलेखित है।

और निश्चित रूप से कई साथी प्रोग्रामर द्वारा इसके द्वारा कई अन्य समाधानों का वर्णन या अनुशंसित किया गया है। जीडब्ल्यूटी उन लोगों के लिए है जो वास्तव में वेब पार्ट से निपटने या इसे कम करने के लिए नहीं चाहते हैं

अजगर दुनिया से एक साफ विचार खाका विशेषता भाषा हैं ; टीएएल को Zope (इसलिए उर्फ ​​"ज़ोपे पेज टेम्पलेट्स", जेडपीटी) द्वारा पेश किया गया था और यह PHP, XSLT और जावा में कार्यान्वयन के साथ एक मानक भी है (मैंने पायथन / ज़ोपे और PHP अवतारों का इस्तेमाल किया है)। टेम्पलटिंग भाषाओं के इस वर्ग में, एक उपरोक्त उदाहरण इस तरह दिख सकता है:

 <table> <tr tal:repeat="product products"> <td tal:content="product/name">Example product</td> <td tal:content="product/description">A nice description</td> <td tal:content="product/price">1.23</td> </tr> </table> 

यह कोड सामान्य HTML (या एक्सएचटीएमएल) प्लस एक्सएमएल नेमस्पेस में कुछ विशेष विशेषताओं की तरह दिखता है; यह एक ब्राउज़र के साथ देखा जा सकता है और एक डिज़ाइनर द्वारा सुरक्षित रूप से छेड़ा जा सकता है। मैक्रोज़ के लिए और i18n के लिए भी समर्थन है:

 <h1 i18n:translate="">Our special offers</h1> <table> <tr tal:repeat="product products"> <td tal:content="product/name" i18n:translate="">Example product</td> <td tal:content="product/description" i18n:translate="">A nice description</td> <td tal:content="product/price">1.23</td> </tr> </table> 

यदि सामग्री के अनुवाद उपलब्ध हैं, तो इसका उपयोग किया जाता है।

मैं जावा कार्यान्वयन के बारे में बहुत कुछ नहीं जानता, हालांकि।

जेएसपी में स्क्रीप्लेट का उपयोग करना एक अच्छा अभ्यास नहीं है

इसके बजाय, आप इसका उपयोग कर सकते हैं:

  1. जेएसटीएल टैग
  2. ईएल अभिव्यक्तियाँ
  3. कस्टम टैग- आप उपयोग करने के लिए अपने स्वयं के टैग को परिभाषित कर सकते हैं।

कृपया देखें:

  1. http://docs.oracle.com/javaee/1.4/tutorial/doc/JSTL3.html
  2. ईएल

तकनीकी रूप से, जेएसपी सभी रनटाइम के दौरान सर्विसलेट में परिवर्तित हो जाते हैं । जेएसपी शुरू में एमवीसी पैटर्न के बाद व्यापार तर्क और डिजाइन तर्क के decoupling के उद्देश्य के लिए बनाया गया था इसलिए जेएसपी तकनीकी रूप से क्रम के दौरान सभी जावा कोड हैं। लेकिन प्रश्न का उत्तर देने के लिए, टैग लाइब्रेरीज़ आमतौर पर जेपीपी पृष्ठों पर तर्क (जावा कोड को हटाने) लगाने के लिए उपयोग किया जाता है

निश्चित, <%! counter++; %> जगह <%! counter++; %> <%! counter++; %> <%! counter++; %> एक घटना निर्माता-उपभोक्ता वास्तुकला द्वारा, जहां व्यापार परत को काउंटर बढ़ाने की आवश्यकता के बारे में सूचित किया जाता है, यह तदनुसार प्रतिक्रिया करता है, और प्रस्तुतकर्ताओं को सूचित करता है ताकि वे विचारों को अपडेट कर सकें। कई डेटाबेस लेनदेन शामिल हैं, क्योंकि भविष्य में हमें काउंटर के नए और पुराने मूल्य को जानने की जरूरत होगी, जिन्होंने इसे बढ़ा दिया है और किस उद्देश्य से मन में है स्पष्ट रूप से क्रमबद्धता शामिल है, क्योंकि परतें पूरी तरह से डिकॉप्ल्ड हैं आप अपने काउंटर को आरएमआई, आईआईओपी, सोप पर बढ़ाना सकेंगे। लेकिन केवल HTML आवश्यक है, जिसे आप लागू नहीं करते हैं, क्योंकि यह एक ऐसी मामला मामला है आपका नया लक्ष्य आपके नए चमकदार E7, 64GB रैम सर्वर पर 250 की वृद्धि दर तक पहुंचने के लिए है।

मेरे पास प्रोग्रामिंग में 20 से अधिक वर्षों हैं, अधिकांश परियोजनाएं सीक्सेट से पहले विफल हो जाती हैं: पुन: प्रयोज्यता प्रतिस्थापन ओ ओ-क्षमता, डिबग्यूबिलिटी परीक्षणयोग्यता बरकरारता भी जरूरी है अन्य परियोजनाएं जो लोग केवल कार्यक्षमता के बारे में परवाह करते थे, वे बहुत सफल थे। इसके अलावा, कड़ी ऑब्जेक्ट संरचना, प्रोजेक्ट में बहुत जल्दी लागू की जाती है, कोड को विनिर्देशों (उर्फ एक्सील) में भारी परिवर्तनों के लिए अनुकूलित करने में असमर्थ बनाता है।

इसलिए मैं "परतों" या अनावश्यक डेटा संरचनाओं को परिभाषित करने की प्रक्रिया को जल्दी या प्रोजेक्ट में या विशेष रूप से आवश्यक नहीं होने के कारण विलंब के रूप में मानता हूं।

अगर हम जावा वेब अनुप्रयोग में निम्नलिखित चीजों का इस्तेमाल करते हैं, तो जावा कोड को जेएसपी के अग्रभूमि से हटा दिया जा सकता है।

  1. वेब अनुप्रयोग के लिए MVC वास्तुकला का उपयोग करें

  2. JSP टैग का उपयोग करें

    ए। मानक टैग

    ख। कस्टम टैग

  3. अभिव्यक्ति भाषा

JSP फ़ाइलों में जावा कोड से बचने के लिए कैसे?

आप एक्सपीरियन भाषा ( ईएल ) के अतिरिक्त टैब लाइब्रेरी टैग्स जैसे जेएसटीएल का उपयोग कर सकते हैं। लेकिन ईएल JSP के साथ अच्छी तरह से काम नहीं करता है। इसलिए जेएसपी को पूरी तरह से ड्रॉप करना और फेसलेट का इस्तेमाल करना बेहतर है

फेसलेट जेएसएफ (जावा सर्वर फेस) के लिए डिज़ाइन किया गया पहला गैर जेएसपी पृष्ठ घोषणा भाषा है जो जेएसपी के मुकाबले JSF डेवलपर्स के लिए एक सरल और अधिक शक्तिशाली प्रोग्रामिंग मॉडल प्रदान करता है। यह वेब अनुप्रयोग विकास के लिए जेएसपी में विभिन्न मुद्दों को हल करता है।

यहां छवि विवरण दर्ज करें

जेएसपी 2.0 में "टैग फाइल्स" नामक एक सुविधा है, आप बाहरी java कोड और tld बिना टैग लिख सकते हैं। You need to create a .tag file and put it in WEB-INF\tags you can even create directory structure to package your tags.

उदाहरण के लिए:

 /WEB-INF/tags/html/label.tag <%@tag description="Rensders a label with required css class" pageEncoding="UTF-8"%> <%@attribute name="name" required="true" description="The label"%> <label class="control-label control-default" id="${name}Label">${name}</label> 

Use it like

 <%@ taglib prefix="h" tagdir="/WEB-INF/tags/html"%> <h:label name="customer name" /> 

Also you can read the tag body easly

 /WEB-INF/tags/html/bold.tag <%@tag description="Bold tag" pageEncoding="UTF-8"%> <b> <jsp:doBody/> </b> 

Use it

 <%@ taglib prefix="h" tagdir="/WEB-INF/tags/bold"%> <h:bold>Make me bold</h:bold> 

The samples are very simple but you can do lots of complicated tasks here. Please consider you can use other tags (eg: JSTL which has controlling tags like if/forEcah/chosen text manipulation like format/contains/uppercase or even SQL tags select/update ), pass all kind parameters, for example Hashmap , access session , request , … in your tag file too.

Tag File are so easy developed as you did not need to restart the server when changing them, like jsp files. This make them easy for development.

Even if you use a framework like struts 2, which have lots of good tags, you may find that having your own tags can reduce your code a lot. You can pass your tag parameters to struts and this way customize your framework tag.

You can use tag not only to avoid java but also minimize your HTML codes. I myself try to review HTML codes and build tags a lot as soon as see code duplicates start in my pages.

(Even if you end up using the java in you jsp code, which I hope not, you can encapsulate that code in a tag)

As many answers says, use JSTL or create your own custom tags. Here is good explanation about creating custom tags

Using Scriptlets is a very old way and Not recommended. If you want directly output something in your JSP pages just use Expression Language(EL) along with JSTL .

There are also other options such as using a templating engine such as Velocity, Freemarker, Thymeleaf etc. But using plain JSP with EL and JSTL serves my purpose most of the time and it also seems the simplest for a beginner.

Also, take note that it is not a best practice to do business logic in the view layer, you should perform your business logics in the Service layer, and pass the output result to your views through a Controller.

By using JSTL tags together with EL expression you can avoid this. Put the following things in your jsp page:

 <%@ page contentType="text/html;charset=UTF-8" language="java" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>