4.1 HttpSession పరిచయం
ఒకే క్లయింట్ నుండి అనేక అభ్యర్థనలు వచ్చినట్లయితే, క్లయింట్ మరియు సర్వర్ మధ్య సెషన్ ఏర్పాటు చేయబడిందని వారు చెప్పారు. ఈ ప్రక్రియను నియంత్రించడానికి, కంటైనర్‌లో ప్రత్యేక HttpSession వస్తువు ఉంటుంది.
క్లయింట్ సర్వ్‌లెట్‌కి అభ్యర్థన చేసినప్పుడు, సెషన్ ID పరామితి అభ్యర్థనలో ఉందో లేదో చూడటానికి సర్వ్లెట్ కంటైనర్ తనిఖీ చేస్తుంది. అటువంటి పరామితి లేకుంటే (ఉదాహరణకు, క్లయింట్ మొదటిసారిగా సర్వర్‌ని సంప్రదిస్తున్నారు), అప్పుడు సర్వ్లెట్ కంటైనర్ కొత్త HttpSession ఆబ్జెక్ట్‌ను సృష్టిస్తుంది మరియు దానికి ఒక ప్రత్యేక IDని కూడా కేటాయిస్తుంది.
సెషన్ ఆబ్జెక్ట్ సర్వర్‌లో నిల్వ చేయబడుతుంది మరియు క్లయింట్‌కు ప్రతిస్పందనగా ID పంపబడుతుంది మరియు డిఫాల్ట్‌గా క్లయింట్‌లో కుక్కీలో నిల్వ చేయబడుతుంది. అప్పుడు, అదే క్లయింట్ నుండి కొత్త అభ్యర్థన వచ్చినప్పుడు, సర్వ్లెట్ కంటైనర్ దాని నుండి IDని తిరిగి పొందుతుంది మరియు ఆ ID ద్వారా సర్వర్‌లో సరైన HttpSession ఆబ్జెక్ట్‌ను కనుగొంటుంది.
మీరు సెషన్ ఆబ్జెక్ట్‌ను అభ్యర్థన (HttpServletRequest ఆబ్జెక్ట్) నుండి పొందవచ్చు, దానిపై మీరు getSession() పద్ధతికి కాల్ చేయాలి. ఇది HttpSession వస్తువును అందిస్తుంది.
సెషన్ ఎందుకు అవసరం? ఇది కాల్‌ల మధ్య క్లయింట్ గురించి సమాచారాన్ని నిల్వ చేయగలదు. ఆమె లోపల హాష్‌మ్యాప్ వంటిది ఉంది, దీనిలో మీరు కీల ద్వారా వస్తువులను నిల్వ చేయవచ్చు. మరియు దీని కోసం కొన్ని పద్ధతులు:
| పద్ధతులు | వివరణ | |
|---|---|---|
| 1 | setAttribute(String name, Object o) |
సెషన్‌కు ఒక వస్తువును జోడిస్తుంది |
| 2 | getAttribute(String name) |
సెషన్ నుండి ఒక వస్తువును పొందుతుంది |
| 3 | removeAttribute(String name) |
సెషన్ నుండి ఒక వస్తువును తీసివేస్తుంది |
వివిధ అభ్యర్థనల నుండి పంపబడిన అన్ని సంఖ్యలను సంగ్రహించే సర్వ్‌లెట్‌ను వ్రాద్దాం:
public class CalculatorServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
// Get the "sum" attribute from the session
HttpSession session = request.getSession();
Integer sum = (Integer) session.getAttribute("sum");
//Handling the situation when the session does not yet have such an attribute
if (sum == null)
sum = 0;
// Get the "n" parameter from the request
String n = request.getParameter("n");
sum += Integer.parseInt(n);
// Write the "sum" attribute to the session
session.setAttribute("sum", sum);
// Print the HTML as a response to the browser
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head> <title> CalculatorServlet </title> </head>");
out.println("<body>");
out.println("<h1> Sum == " + sum + "</h1>");
out.println("</body>");
out.println("</html>");
}
}4.2 HttpSession గురించి మరింత
HttpSession ఆబ్జెక్ట్ గురించి మనం చెప్పనిది ఏదైనా ఉందా?
మొదట, ఇది J SESSION ID పేరు . దాని కింద సెషన్ ID కుక్కీలలో నిల్వ చేయబడుతుంది. మీరు చూడగలిగినట్లుగా, గుర్తుంచుకోవడం చాలా సులభం: J+SESSION+ID.
రెండవది, సెషన్‌లో మరికొన్ని ఉపయోగకరమైన పద్ధతులు ఉన్నాయి:
| పద్ధతులు | వివరణ | |
|---|---|---|
| 1 | getAttributeNames() |
సెషన్‌లో నిల్వ చేయబడిన అన్ని కీల జాబితాను అందిస్తుంది |
| 2 | getId() |
సెషన్ ID (స్ట్రింగ్)ని అందిస్తుంది |
| 3 | isNew() |
ప్రస్తుత అభ్యర్థనలో సెషన్ ఆబ్జెక్ట్ సృష్టించబడితే ఒప్పు అని చూపుతుంది |
| 4 | setMaxInactiveInterval(int seconds) |
సెషన్ నిష్క్రియ విరామాన్ని సెకన్లలో సెట్ చేస్తుంది |
| 5 | invalidate() |
సెషన్ నుండి అన్ని వస్తువులను తొలగిస్తుంది |
ఇక్కడ అన్ని పద్ధతులు స్పష్టంగా ఉన్నాయి, కానీ setMaxInactiveInterval()మేము కొంచెం ఎక్కువ మాట్లాడతాము.
సర్వర్ గత నెలలో సందర్శించిన క్లయింట్‌ల డేటాతో సహా పదివేల సెషన్‌లను నిల్వ చేస్తే, అది కేవలం మెమరీ అయిపోతుంది. అందువల్ల, "సెషన్ జీవితకాలం" సెట్ చేయడానికి ఒక మార్గం ఉంది.
సెషన్‌ను ఎవరూ సమయం విరామం కోసం ఉపయోగించకపోతే, అది స్వయంగా క్లియర్ అవుతుంది - అది నిల్వ చేసిన అన్ని వస్తువులు దాని నుండి తొలగించబడతాయి. మెమరీని సేవ్ చేయడానికి ఇది జరుగుతుంది.
డిఫాల్ట్‌గా, ఈ విరామం 1800 సెకన్లు == 30 నిమిషాలు. మీరు విలువను -1కి సెట్ చేస్తే, సెషన్ "శాశ్వతమైనది" అవుతుంది మరియు వినియోగదారు బ్రౌజర్ ట్యాబ్‌ను మూసివేసినప్పుడు మాత్రమే తొలగించబడుతుంది (అలాగే, లేదా క్లయింట్ డిస్‌కనెక్ట్ అవుతుంది).
ఉదాహరణలు:
|
|
|