వెబ్ సర్వర్ ఫిల్టర్లు

ఫిల్టర్లకు పరిచయం

అయితే అంతే కాదు. సర్వ్లెట్‌లు అంత సులభం అని మీరు నిజంగా అనుకోరు, అవునా?

మేము ఇప్పటికే విశ్లేషించిన సర్వ్‌లెట్‌లతో పాటు, “యుటిలిటీ సర్వ్‌లెట్‌లు” అని పిలవబడేవి కూడా ఉన్నాయి - ఫిల్టర్‌లు . అవి సర్వ్‌లెట్‌ల మాదిరిగానే ఉంటాయి, అయితే అభ్యర్థనలను ప్రాసెస్ చేయడంలో సర్వ్‌లెట్‌లకు సహాయం చేయడం వారి ప్రధాన పని.

ఫిల్టర్ సెక్రటరీ లాంటిది మరియు సర్వ్లెట్ డైరెక్టర్ లాంటిది. పత్రం డైరెక్టర్ డెస్క్‌కు చేరుకునే ముందు, అది కార్యదర్శి చేతుల్లోకి వెళుతుంది. మరియు దర్శకుడు దానిపై సంతకం చేసిన తర్వాత, అది మళ్లీ కార్యదర్శికి వెళుతుంది, ఇప్పటికే అవుట్‌గోయింగ్ కరస్పాండెన్స్‌గా, ఉదాహరణకు.

అలాంటి సెక్రటరీ డైరెక్టర్‌కి కొన్ని అభ్యర్థనలను తిరస్కరించవచ్చు (ఉదాహరణకు, స్పామ్). లేదా అతనికి తెలిసిన ప్రశ్నలకు ప్రామాణిక సమాధానాలు ఇవ్వండి ("దర్శకుడు స్థానంలో లేరు"). మరియు అందువలన న. అంతేకాకుండా, అటువంటి అనేక కార్యదర్శులు ఉండవచ్చు: ఒకరు ఒకేసారి అన్ని డైరెక్టర్‌ల కోసం స్పామ్‌ను ఫిల్టర్ చేయవచ్చు, మరొకరు వేర్వేరు డైరెక్టర్ల మధ్య అభ్యర్థనలను బదిలీ చేయవచ్చు మరియు ఇలాంటివి.

ఫిల్టర్లు అదే విధంగా పని చేస్తాయి.

తరగతులు ఫిల్టర్, ఫిల్టర్‌చైన్, ఫిల్టర్ కాన్ఫిగర్

ఫిల్టర్‌లు సర్వ్‌లెట్‌ల మాదిరిగానే ఉంటాయి, కానీ కొన్ని చిన్న తేడాలతో ఉంటాయి. మీ స్వంత ఫిల్టర్‌ని వ్రాయడానికి, మీరు నుండి వారసత్వంగా పొందాలి javax.servlet.Filter.

ఫిల్టర్‌లో పద్ధతులు కూడా ఉన్నాయి init()మరియు destroy(). పద్ధతికి బదులుగా, service()ఫిల్టర్ ఒక doFilter(). మరియు దాని స్వంత తరగతి FilterConfig కూడా ఉంది. ఫిల్టర్ web.xml ఫైల్‌లోని సర్వ్‌లెట్‌కి లేదా @WebFilter ఉల్లేఖనం ద్వారా కూడా జోడించబడుతుంది.

పద్ధతుల జాబితా:

సర్వ్లెట్ మరియు ఫిల్టర్ మధ్య తేడా ఏమిటి?

అనేక ఫిల్టర్‌లు ఉండవచ్చు మరియు అవి అభ్యర్థనను (మరియు ప్రతిస్పందన) వరుసగా ప్రాసెస్ చేస్తాయి. అవి గొలుసు అని పిలవబడేవిగా మిళితం చేయబడ్డాయి - మరియు వాటి కోసం ఒక ప్రత్యేక తరగతి కూడా ఉంది FilterChain.

పద్ధతిలో అభ్యర్థనను ప్రాసెస్ చేసిన తర్వాత, మీరు గొలుసులోని తదుపరి ఫిల్టర్ యొక్క doFilter()పద్ధతిని కాల్ చేయాలి . doFilter()ఉదాహరణ:

public class MyFilter implements Filter {

  public void init(FilterConfig arg0) throws ServletException {
  }

  public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws Exception {

      PrintWriter out = resp.getWriter();
      out.print("Adding something before the body of the response");

      chain.doFilter(req, resp); // call the next filter in the chain

      out.print("Adding something after the body of the response");
    }

  public void destroy() {
  }
}

వాస్తవానికి, మీరు ప్రతిస్పందన సారాన్ని ఆ విధంగా జోడించలేరు . అధికారికంగా, ఫిల్టర్‌లు మరియు సర్వ్‌లెట్‌లు ఒకదానికొకటి స్వతంత్రంగా ఉంటాయి మరియు వాటిని స్వతంత్రంగా మార్చవచ్చు. వాటిని వేర్వేరు డెవలపర్‌లు వేర్వేరు సమయాల్లో వ్రాయవచ్చు. ఫిల్టర్ ఫంక్షన్ కేవలం సేవా ఫంక్షన్ మాత్రమే, ఉదాహరణకు:

• అన్ని ఇన్‌కమింగ్ అభ్యర్థనలను (మరియు ప్రతిస్పందనలు) లాగ్ చేయడం
• డేటా కంప్రెషన్
• డేటా యొక్క ఎన్క్రిప్షన్ (మరియు డిక్రిప్షన్).
• డేటా ధ్రువీకరణను అభ్యర్థించండి
• కావలసిన శీర్షికలను జోడించండి/తీసివేయండి
• మళ్లింపు అభ్యర్థనలు
• యాక్సెస్ నియంత్రణ (వినియోగదారు లాగిన్ అయ్యారో లేదో తనిఖీ చేయడం)

అభ్యర్థన డిస్పాచర్ తరగతి

ఒక పద్ధతిలో ఫిల్టర్ రన్ అవుతున్నప్పుడు కొన్నిసార్లు doFilter() మరొక సర్వ్‌లెట్‌కి కాల్ చేయడం అవసరం కావచ్చు . ఇది చేయుటకు, కంటైనర్ ప్రత్యేక వస్తువును కలిగి ఉంటుంది RequestDispatcher.

మీరు దానిని రెండు విధాలుగా పొందవచ్చు:

• వస్తువు వద్దHttpServletRequest
• వస్తువు వద్దServletContext

ఇప్పటికే ఉన్న అభ్యర్థనను మరొక సర్వ్‌లెట్‌కి దారి మళ్లించడానికి ఈ వస్తువును ఉపయోగించవచ్చు . ఉదాహరణకు, వినియోగదారుకు అధికారం లేదని తేలింది మరియు మేము అతనికి అధికారం ఉన్న పేజీని చూపించాలనుకుంటున్నాము. సరే, లేదా సర్వర్‌లో లోపం ఉంది మరియు మేము వినియోగదారుకు లోపం పేజీని ప్రదర్శించాలనుకుంటున్నాము :)

public class HelloServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response)  throws Exception {
           String path = "/error.html";
           ServletContext servletContext = this.getServletContext();
           RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher(path);
           requestDispatcher.forward(request, response);
    }
}

RequestDispatcherమీరు ఫిల్టర్ నుండి కూడా కాల్ చేయవచ్చు .

public class MyFilter implements Filter {

  public void init(FilterConfig arg0) throws ServletException {
  }

  public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws Exception {
           String path = "/error.html";
           ServletContext servletContext = req.getServletContext();
           RequestDispatcher requestDispatcher = servletContext.getRequestDispatcher(path);
           requestDispatcher.forward(req, resp);
    }

  public void destroy() {
  }
}

అభ్యర్థన పద్ధతిలో నిర్వహించబడుతుందని మరియు ఉపయోగం తర్వాత forward()కాల్ చేయవలసిన అవసరం లేదని గమనించండి .doFilter()RequestDispatcher

దారిమార్పు మరియు ఫార్వార్డ్ యొక్క పోలిక

మరియు మరొక ముఖ్యమైన అంశం. మీరు మీ సర్వ్‌లెట్‌లోని మరొక URIకి వినియోగదారుని దారి మళ్లించాలనుకుంటే, మీరు దీన్ని రెండు విధాలుగా చేయవచ్చు:

• redirect
• forward

మేము ఇప్పటికే వాటిని విశ్లేషించాము, కానీ సౌలభ్యం కోసం నేను మళ్ళీ చెబుతాను.

మీరు కాల్ ద్వారా దారి మళ్లించినప్పుడుresponse.sendRedirect("link") , సర్వర్ బ్రౌజర్ (క్లయింట్)కి ప్రతిస్పందనను 302మరియు మీరు పేర్కొన్న లింక్‌ను తిరిగి పంపుతుంది. మరియు బ్రౌజర్, సర్వర్ ప్రతిస్పందనను విశ్లేషించిన తర్వాత, మీరు ఆమోదించిన లింక్‌ను డౌన్‌లోడ్ చేస్తుంది. అంటే, బ్రౌజర్‌లోని లింక్ కొత్తదానికి మారుతుంది.

మీరు కాల్ ద్వారా ఫార్వార్డ్ చేస్తేrequestDispatcher.forward() , కంటైనర్ లోపల కొత్త అభ్యర్థన చేయబడుతుంది మరియు మీ సర్వ్‌లెట్ దాని ప్రతిస్పందనను బ్రౌజర్ (క్లయింట్)కి మీ సర్వ్‌లెట్ ప్రతిస్పందనగా పంపుతుంది. ఈ సందర్భంలో, బ్రౌజర్ కొత్త సర్వ్‌లెట్ నుండి ప్రతిస్పందనను అందుకుంటుంది, కానీ బ్రౌజర్‌లోని లింక్ మారదు.