java - जेएसपी फाइलों में जावा कोड से कैसे बचें?




jsp scriptlet (24)

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

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

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


Answers

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>

निम्नलिखित कोड को वेब-आईएनएफ \ कक्षा \ 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>


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

विकेट देखो।


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

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

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


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


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


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

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


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


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


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


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

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

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

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

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


जेएसपी 2.0 में "टैग फाइल्स" नामक एक सुविधा है, आप बाहरी java कोड और tld बिना टैग लिख सकते हैं। आपको एक .tag फ़ाइल बनाने और इसे WEB-INF\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>

इसे प्रयोग करें

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

इसके अलावा आप टैग बॉडी को आसानी से पढ़ सकते हैं

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

इसका इस्तेमाल करें

<%@ 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)


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

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

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

कृपया देखें:

  1. http://docs.oracle.com/javaee/1.4/tutorial/doc/JSTL3.html
  2. EL

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

<%@ 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>

पायथन दुनिया से एक साफ विचार टेम्पलेट विशेषता भाषाओं हैं ; टीएएल को ज़ोप (इसलिए उर्फ ​​"ज़ोप पेज टेम्पलेट्स", जेडपीटी) द्वारा पेश किया गया था और PHP, एक्सएसएलटी और जावा में कार्यान्वयन के साथ एक मानक है (मैंने पायथन / ज़ोप और 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 (या XHTML) और एक्सएमएल नेमस्पेस में कुछ विशेष विशेषताओं की तरह दिखता है; इसे ब्राउज़र के साथ देखा जा सकता है और एक डिजाइनर द्वारा सुरक्षित रूप से tweaked किया जा सकता है। मैक्रोज़ और 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>

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

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


जेएसपी फाइलों में जावा कोड से कैसे बचें?

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

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


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

<%@ 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>

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

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


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

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

<%@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/> को प्रतिस्थापित कर <jsp:doBody/> । आपके बच्चे के पृष्ठ में कोई टैग lib भी शामिल हो सकता है और आप इसे सामान्य रूप से अन्य उल्लिखित रूप में उपयोग कर सकते हैं। हालांकि, अगर आप यहां किसी भी स्क्रिप्टलेट कोड का उपयोग करते हैं ( <%= 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 फ़ाइल को अपने नियंत्रक से कॉल कर सकते हैं। यह स्ट्रैट्स फ्रेमवर्क के साथ भी अच्छा काम करता है


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

  1. वेब अनुप्रयोग के लिए एमवीसी आर्किटेक्चर का प्रयोग करें

  2. जेएसपी टैग का प्रयोग करें

    ए। मानक टैग

    ख। कस्टम टैग

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


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


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.


यह पृष्ठ संरक्षित और डिफ़ॉल्ट पहुंच संशोधक के बारे में अच्छी तरह से लिखता है

.... संरक्षित: संरक्षित एक्सेस संशोधक थोड़ा मुश्किल है और आप डिफ़ॉल्ट पहुंच संशोधक का सुपरसैट कह सकते हैं। संरक्षित सदस्य डिफ़ॉल्ट सदस्यों के समान हैं जहां तक ​​एक ही पैकेज में पहुंच का संबंध है। अंतर यह है कि, संरक्षित सदस्य कक्षा के उप-वर्गों के लिए भी पहुंच योग्य होते हैं जिसमें सदस्य घोषित किया जाता है जो कि पैकेज के बाहर होते हैं जिसमें मूल वर्ग मौजूद होता है।

लेकिन ये संरक्षित सदस्य "केवल विरासत के माध्यम से पैकेज के बाहर सुलभ" हैं। यानी आप अपने उप-वर्ग में किसी वर्ग के संरक्षित सदस्य को किसी अन्य पैकेज में सीधे एक्सेस कर सकते हैं जैसे कि सदस्य उप-वर्ग में मौजूद है। लेकिन वह संरक्षित सदस्य मूल वर्ग के संदर्भ का उपयोग करके पैकेज के बाहर उप-वर्ग में पहुंच योग्य नहीं होगा। ....







java jsp scriptlet