We need some input on what is a good design pattern on using AJAX in a Java application.
Consider a simple scenario:
User clicks a button which sends a request to a Java method to fetch data from DB.
Java object is returned by method and needs to be converted into a HTML table.
HTML table is shown on JSP.
What we currently do:
On a JSP page, user clicks "Show Users" button
Button using Prototype.js calls a "middleman" JSP which forwards the request to the Java method to get the data from the DB.
The method returns the Java object to the "middleman" JSP which converts the Java object into HTML (since the AJAX call from the calling JSP won't be able to handle the Java object directly).
The HTML is then returned to the Prototype call which updates the div on the calling JSP.
Our concerns are:
We would like to keep the separation of business/presentation logic and would prefer no HTML/JavaScript code inside our Java methods.
Keeping (1) in mind, is having a "middleman" JSP an OK way to do this? Or should we return the Java object as XML/XSLT to the AJAX request?
The above way we're doing has very little JavaScript and works in all browsers.
We looked at some other packages - DWR, GWT, but either there was too much dependency on JavaScript or required UI components to be present in the Java classes.
Is our way of doing things above OK? Or is there another preferable way?
Any help/thoughts would be appreciated.
Thanks,
SP
Sounds fine. You are separating view components from model components. It shouldn't matter how the call comes to the server, AJAX or not, it should be received by a controller (a servlet say) that interacts with the model, thats your Java classes that get the data from the database and forward to a JSP page for rendering the view.
There are frameworks that could simplify the boilerplate code but the design you describe sounds fine.
I'm not sure if you noticed, but there's one significant difference between your solution and what Vincent proposed. This is that the request should be initially received by a servlet (or controller, or Struts action, etc.) rather than a "middleman" JSP.
MVC dictates that JSPs should really only we used for generating the view from the model data, flow control is better handled in Java code.
Related
I have 10 different jsp, each of them have similar tag <div class="content"/>
Different only style. Each jsp have Label,3 button, and couple forms.
I want know, must show tag <div class="content"/> or not depends of 2 buttons and 1 form, if they are fill, I need show CONTENT.
Question where better create checking conditions, in each jsp using JSTL or in Java method, and in each jsp call this method ?
PS I using Slice Framework
It is always advisable to not write any logic in presentation layer according to MVC(Model View Controller) structure. So, in this scenario JAVA is more preferable than writing logic in JSP.
It is the standard to not write logic in JSP but if you are using JSTL not scriptlets for logic it is also ok.
It is always recomended to use Presentation layer(HTML,JSP etc) only
to perform client validation , showing contents from Model layer , recieving user
inputs and displaying outputs.
The business logic recomended to be wrapped in java side. So in your
case go ahead with Java part
The question is about ideology of the MVC design pattern. By definition, the view is communicating with the controller directly. For instance, in JSF as well as ASP.NET web-forms, we can bind the property of the controller to a specific area of a web-page. But in this case we're doing that by directly wirte an expression like
<h:outputText value="#{partnerController.lastAccessDate}"/>
Would it be useful to create a mediator between views and controllers? I need, for instance, "send a message" to a several controller in a specific way.
In a traditional web application where a JSP page (or PHP or some other HTML generator) generates a form which is filled by the user and posted back to the server, this does not make a lot of sence. The posted form is sent directly to a controller which handels the data.
In fat client environment this makes a lot fo sence. The fat client can be something like SWING or a JavaScript framework like Angular. Here the controller acutally is a mediator. What it does is often called data binding. It makes sure the data entered into the GUI is stored in the business objects which gets eventually sent accros the wire or persisted.
I've been writing this very easy Webapp. It receives two parameters, a word and a letter. It counts how many times the letter can be found in said word.
I have a Dynamic Web Project in Eclipse with the following:
OccurencesCounter.java : has the method count with two params: word and letter. it returns the count (amount of times letter found)
OccurencesServlet.java In here I create an OccurencesCounter obj, I get the params, I call the function count etc, and I forwards request/response to result.jsp
result.jsp I show the results I've calculated.
This has been done for an exercice on Parameters and MVC.
According to the MVC pattern, I can change this webapp easily in a desktop application.
I know i need to change my view, result.jsp.
I need a main class. The rest of the code should stay the same.
My question is the following: What do I use the servlet for? I can't fathom how I could still need it.
I think I can use JOptionPane to input my parameters ("HelloWorld" , "o"), but bypass the servlet alltogether. I'd just need the OccurencesCounter class and my main class.
Is this normal? Or should I use the servlet (in some unknown way to me).
I'm confused, as this is an assignment telling me: We only want you to adjust the view when you create a desktop application, as it is requested by the MVC pattern. Make sure you have one model that works for both assignments.
Thank you
A Servlet listens to http requests and executes Java code, if the requests url matches the servlet mapping. This is useful when working with HTTP (server side/web application) but not in a desktop application (event driven).
We only want you to adjust the view (not your class) when you create a desktop
application, as it is requested by the MVC pattern.
They want you to reuse your OccurencesCounter class in both environments. Thats always possible, if that class does not include any kind of technique, related to the environment, for example a Servlet.
Make sure you have one model that works for both assignments.
Actually, you class is not a "model", from MVCs point of view. Its more of a service, that can be called (delegation) by a controller, returning the result (model) and displaying it on any kind of view.
So just create a class with a main method and run your OccurencesCounter class from there.
If you followed the MVC pattern in you web application you should have :
Model : a set of service, dao, and business classes that will be reused in the desktop application
Controller : a set of servlet (or controllers if you used a framework) -> al that is UI related and have to be rewritten
View : a set of HTML, JSP, CSS, etc. -> must be rewritten
The MVC model allows to (almost) easily replace the view part, if you want to migrate from JSP to Velocity or Thymeleaf but still in a web application
We have a Struts2 application using the <sx:tabbedpanel>. I know this has since been deprecated, but we have not yet had time to replace it.
We're populating the tabs by using the <sx:div> tag and specifying the href attribute, which makes an asynchronous call to the server to populate the contents of the tab. The downside to this is that we lose validation information like <s:actionerror>.
Here's what we think is happening... when the user performs an invalid action, the action class returns validation errors. When the resulting jsp is loaded, the validation messages are available. However, the <sx:div> then makes the asynchronous call back to the server to reload the contents. This time, the action class is just loading data to display, so it doesn't generate any validation messages. The results of this ajax call are then displayed in the browser, without any validation messages.
I've seen many examples on the web of using the <sx:div> tag this way within the tabbedpanel, so I'm guessing this is a problem that has been solved before, we just haven't found it.
Does anyone know of tutorials or examples that show how to do validation in this case?
Thanks for the help, I really appreciate it.
Would it make sense to put the errors outside of the tabbedpanel like:
<s:fielderror />
<sx:tabbedpanel...>
...
</sx:tabbedpanel>
Perhaps we can assist you a bit more if you can post some sample code or provide more info as to what kind of errors are expected and what the content of the tabbed panel is.
We found that we could populate the divs by using the <s:action> tag instead. This gets rendered at the time of the initial request, it does not make an ajax call later. Therefore, the JSPs have access to the validation messages and errors.
Lately I've been running into the same issue with my Spring MVC applications over and over again, and I'm trying to come up with a long term solution.
The problem is that in a standard Spring 3 controller, you add model objects, you specify the view name (either inline or from some injected field) and return. The problem I've run into is that if you have a request that returns a page with a person, and their pets you have something like (not compilable, psuedo):
#RequestMapping( value="personOverview", method="GET" )
public String getPersonOverview(model) {
model.add(personRepo.getPerson( theName ));
model.add(petRepo.getPetsForPerson( thePerson ));
return "personOverviewViewName";
}
Now, in your view you will be able to render all of this information. However, the issue arises when someone updates the "pets" for the person, and you just want to re-render the part of the page that shows the pets.
Not only do you need to rewrite the rendering logic in a JSP fragment or in JavaScript, but also you will need to duplicate the controller code for each portion of the getPersonOverview method. If you were to break the controller methods up into smaller chunks, then you will not be able to render the full page, but will have to render each chunk with a separate request.
In a normal ModelViewController pattern, the solution to this is that the view has access to the model, but in Spring MVC the model is in Java and lies behind the request layer, so you need to build request handlers for each model object.
I know this question may seem a bit abstract, but what I'm looking for is patterns or principles that can be used to allow me to build full pages with many model objects, but also be able to update portions of the page with ajax without duplication.
Not used it myself, but have you considered Tiles?