as i understand MVC pattern as post MVC question
-
the Model is the part of the code that knows things
the View is the part of the code that shows the things the Model
knows
the Controller is the part of the code that gets commands from the
user and tells the View what to show and the Model what to know.
in spring-mvc we have DispatcherServlet which acts as controller gets command from client, also we have developer written controllers which serve commands and resolve the view and prepare Model for that view
in spring-mvc what exactly acts as controller DispatcherServlet or developer written controllers
Your #Controller annotated classes are your controllers. Think of the DispatcherServlet - as the name tells you - as dispatcher to your controllers.This is the same approach other MVC frameworks also choose (like Struts 2).
Related
I am designing a REST controller layer with the concept of different versioning which might happen in the future.
I am thinking of having separate classes with version number as follows.
#RequestMapping("/v1/api")
#RestController
class V1RestController {
}
#RequestMapping("/v2/api")
#RestController
class V2RestController {
}
Or V2RestController might extend V1RestController depending on the requirements. This is just a draft idea. But my question is if there is any Spring MVC api which can catch the URL and look up the version '/v1/api or /v2/api' and delegate the request to the right controller.
Based on my research, the best way is to make it backward-compatible, but i am sure that the reality is different and there would be some cases to have different implementations.
I know that there are other ways to design the rest controller layer for different versioning, but for now, i would like to take this approach.
Any help would be appreciated.
But my question is if there is any Spring MVC api which can catch the URL and look up the version '/v1/api or /v2/api' and delegate the request to the right controller.
DispatcherServlet intercepts the request (what to intercept it looks in "web.xml" ), and then DispatcherServlet looks at the request URL and looks for the controller whose "value" parameter (the "#RequestMapping" annotation) matches the request URL, if a match is found: control is transferred in the corresponding controller. Something like this.
Since REST based controller methods only return objects ( not views ) to the client based on the request, how can I show view to my user ? Or maybe better question what is a good way to combine spring-mvc web app with REST, so my user always get the answer, not in just ( for example ) JSON format, but also with the view ?
So far as I understood, REST based controller would be perfectly fitting to the mobile app ( for example twitter ), where views are handled inside the app and the only thing server has to worry about is to pass the right object to the right request. But what about the web app ?
I might be wrong in several things ( correct me if I am ), since I am trying to understand REST and I am still learning.
To simplify things - you basically have two options:
1) Build Spring MVC application.
2) Build REST backend application.
In case of first option - within your application you will have both backend and frontend (MVC part).
In case of second option you build only backend application and expose it through REST API. In most cases, you will need to build another application - REST client for your application. This is more flexible application because it gives you opportunity to access your backend application from various clients - for example, you can have Android, IOS applications, you can have web application implemented using Angular etc...
Please note, that thins are not so simple, you can within one application have both REST backend and REST client etc... This is just very very simplified in order that you get some general picture. Hope this clarified a little things.
There is some additional clarification related to REST and views worth learning. From your question, I can see that you mean "view" in a sense of UI(user interface) and typical MVC usage. But "view" can mean different things in a different contexts.
So:
JSON can be considered as a view for data
JSON is a representation of the resource, just like HTML is
JSON doesn't have style (unless you are not using a browser
extension, which most the users are not using)
The browser is recognizing HTML as a markup language and applying a
style to it
Both are media types
Both JSON and HTML are data formats
Both can be transferred over the wire
This method returns a view
#RequestMapping("/home")
String home(Model model) {
return "home"; // resources\templates\home.html
}
This method Returns String
#RequestMapping(value = "/home")
#ResponseBody
public String home() {
return "Success";
}
If you annotate a method with #ResponseBody, Spring will use a json mapper to generate the response. Instead of annotating every method with #ResponseBody you can annotate your class with #RestController.
If you want to return a view, you need to annotate the class with #Controller instead of #RestController and configure a viewresolver. Bij default spring will use thymeleaf as a viewresolver if you have spring-web as a dependency on the classpath. The return type of the method is a String that references the template to be rendered. The templates are stored in src/main/resources/templates.
You can find a guide on the spring website: https://spring.io/guides/gs/serving-web-content/
Im new to jsp and MVC. Im studying this application that registers a customer into the database and then searches for it. The files that Im creating are Customer.java, Customer.jsp, CustomerDAO.java, CustomerContrtoller.java, CustomerService.java, result.jsp and ConnectionManager.java. How does this follow the MVC model? How do I know what is the model, view and controller in this app?
The MVC applies as follows to Jsps:
The model is your Customer.java. This model is used by the Jsp to render Html. The Jsp is the view. The CustomerController is the controller. The controller handles actions, like clicks, of the user, prepares the model and sends it to the Jsp.
Your confusion comes from the CustomerDao, I think. You have to understand that MVC is a frontend pattern. The model used in MVC can be the same as the Dao from the database, but most of the time it's not. Just the interaction between the Jsp, the controller and the model displayed on the Jsp is part of the MVC concept.
I want to use Spring MVC 3.0 to build interfaces for AJAX transactions. I want the results to be returned as JSON, but I don't necessarily want the web pages to be built with JSP. I only want requests to the controllers to be intercepted/routed through the DispatcherServlet and the rest of the project to continue to function like a regular Java webapp without Spring integration.
My thought was to define the servlet-mapping url pattern in web.xml as being something like "/controller/*", then have the class level #RequestMapping in my controller to be something like #RequestMapping("/controller/colors"), and finally at the method level, have #RequestMapping(value = "/controller/colors/{name}", method = RequestMethod.GET).
Only problem is, I'm not sure if I need to keep adding "/controller" in all of the RequestMappings and no matter what combo I try, I keep getting 404 requested resource not available errors.
The ultimate goal here is for me to be able to type in a web browser "http://localhost:8080/myproject/controller/colors/red" and get back the RGB value as a JSON string.
You are not correct about needing to add the entire path everywhere, the paths are cumulative-
If you have a servlet mapping of /controller/* for the Spring's DispatcherServlet, then any call to /controller/* will be handled now by the DispatcherServlet, you just have to take care of rest of the path info in your #RequestMapping, so your controller can be
#Controller
#RequestMapping("/colors")
public class MyController{
#RequestMapping("/{name}
public String myMappedMethod(#PathVariable("name") String name, ..){
}
}
So now, this method will be handled by the call to /controller/colors/blue etc.
I don't necessarily want the web pages to be built with JSP
Spring MVC offers many view template integration options, from passthrough to raw html to rich templating engines like Velocity and Freemarker. Perhaps one of those options will fit what you're looking for.
Hello i am developing a web app...i am using MVC architecture in my design.
i have one form add_Flat.jsp in which admin enter the flat details and it will be stored in database (MS-Access) no other jsp page would be open on submit button.just a message displayed on add_Flat.jsp.
How can i achieve this by using MVC pattern ? do i have to write different servlet for every jsp page ? and model class for database connectivity ?
How can i achieve this by using MVC pattern ?
Let the form submit to a servlet which sets the message in the request scope and forwards back to the JSP.
do i have to write different servlet for every jsp page ?
Not necessarily. You can write a single servlet which acts as a front controller, or just use an existing MVC framework like JSF, Spring MVC, etc.
and model class for database connectivity ?
A model class should not be aware about any DB connectivity. A model class should be a simple Javabean class.
See also:
Our servlets wiki page - Contains Hello World examples and links to in-depth answers on servlet related questions here.