Setting the session when link is clicked in JSP

Question

I have a jsp page which recieves a Map from a java class function. It retireves the element from the map and displays it onto the page as a link. Now what I want to do is whenever any link is clicked then I want to put the map in the session. How can I do that in the same page????
I do not want to already set the session becoz that gives me problem later on.

Answer 1

Ok, I understand what you are trying to do now. Unfortunately, I still don't think you have much choice. Essentially you will only ever have 4 ways of persisting the data:
1. In memory on the server (eg Session)
2. On disk on the server (eg database)
3. In memory on the client (eg Applet or maybe Javascript)
4. On disk on the client (eg signed applet writing to local file system)
The "standard" approach is to store all of this sort of stuff on the server, so you have a choice between 1 and 2.
I assume your "Employee" data is in a database or LDAP directory? (or some form of "on disk" persistence), and you are querying this data store to populate the objects in memory?
If so, there is a way you can avoid persisting in memory for a long time, but because you will have to persist "somewhere" you will only have option 2 left.. on disk.
In the code where you initially retrieve the data from the data store for the first JSP, you can put the Map in the HttpServletRequest object rather than the session (request.setAttribute()), then access this in the first JSP to render the list. When you get to the second JSP however, this object will be out of scope and you won't have access to it anymore so you will have to query the datastore again for the specific record (based on an ID passed from the first JSP). So when you hit "back", the first JSP should execute again and requery the entire list again.
This approach "shifts" the load from a memory load to a disk load (and you will also be affected by database performance issues), so you may not solve your performance desires.
Alternatively, if the list of Employees is the same for all users (ie, it is an entire list and not a "filtered" list based on some search criteria), then you could store the list in memory at "application scope". Basically you would just load the Map on application start-up and put it into a static variable somewhere. I suspect this won't meet your needs as typically the list you generate would be based on a specific query (I am guessing here).
All that being said, your concerns about memory usage and performance may be unwarranted. If you do some quick calculations about the memory usage of each Employee object, you may find it is a trivial amount. (Of course you won't be able to tell definatively how much memory it is using, but you may be able to hazard an educated guess). Remember also that things like Strings are "immutable" (never change) and are drawn from a "pool" of Strings. So, if you have two objects which contain the String "Java", they will actually both be using the same bit of memory.
Also, a word of warning: If you choose to maintain your "in memory" model, you may run into concurrency issues. Consider the situation where the initial query generates a list of Employees. The user traverses the list looking at the details of each employee. Meanwhile, another user is changing the details of an Employee on disk, but the first user hasn't looked at the details of this Employee from their list yet. Because the list the first user is viewing is in memory, it won't reflect any alterations made since it was generated. So when the first user views the details of the Employee that the second user altered on disk, they will see the "old" details for that Employee.
So, in summary the only two choices I can think of that are reasonable are:
1. Keep things the same but don't destroy the Map in the session so the first page always has it, and suffer the memory issues. (remembering the warning above)
2. Limit the scope of the data to the "request" only, and re-query every time. This will have poorer performance from a "response-time" perspective but avoids concurrency issues.
My recommendation:
If the list is "small" (sub 100 items), and you don't care about the risk of viewing "old" data, keep it in the Session. If the list is too big, perhaps you could look at only storing the first X number or records in the session and only displaying the first X number of records in the first JSP (like a search engine does)
If the list is big, and/or you DO care about viewing old data, maintain the persistence on disk. If you choose this option, performance can be enhanced by using connection pools, stored procedures etc.
At the end of the day, memory will only cause a performance issue if you "run out". Maybe the solution is to simply add more memory to the server?
Hope some of this helps.