关于Java Servlet与MVC、JSP等相关技术问题咨询

Hey there! Let's break down your questions one by one—these are all key concepts when working with Java web apps, especially if you're coming from Ruby on Rails:

1. Implementing MVC Architecture in Servlets (vs. Ruby on Rails) #

In Rails, MVC is baked right into the framework with clear separation between Models (ActiveRecord), Views (ERB templates), and Controllers (Ruby classes). For Servlets, you'll manually map these roles to different components:

• Model: Use plain Java classes (POJOs) or DAOs (Data Access Objects) to handle business logic and data operations (like fetching/saving data from a database). This is equivalent to Rails' ActiveRecord models, minus the built-in ORM magic (though you can use tools like Hibernate if you want that functionality).
• View: JSP files take this role—they're responsible for rendering HTML/CSS/JS to display data, just like Rails' ERB templates. You'll pass data from the controller to the view using request.setAttribute().
• Controller: Servlets act as controllers. They receive HTTP requests, call the appropriate model methods to process data, then forward the request to a JSP view to display the result.

For example:

1. A user visits /users → the UserListServlet (controller) gets called.
2. The servlet calls UserDAO.getAllUsers() (model) to fetch user data.
3. The servlet adds the user list to the request with request.setAttribute("users", userList).
4. It forwards the request to user-list.jsp (view), which uses JSTL/EL to loop through and display the users.

2. Difference Between JSP Files and Servlets #

While JSPs are technically compiled into Servlets by the server under the hood, they serve very different purposes:

• Servlets: Pure Java classes that extend HttpServlet. They're designed for handling request logic, business processes, and controlling the flow of your app. If you try to write HTML directly in a Servlet, you'll have to use clunky code like response.getWriter().println("<h1>Hello</h1>")—not ideal for views.
• JSPs: Files that mix HTML with Java code (via <% %> tags), EL expressions, or JSTL. They're focused on the view layer—perfect for building UI without writing tons of Java output code. The server converts JSPs to Servlets automatically, but you never have to work with that compiled class directly.

Rule of thumb: Use Servlets for controlling logic and JSPs for displaying content.

3. Where to Place a Form for a Model #

Forms should live in JSP files—they're part of the view layer, responsible for collecting user input. Here's how it works:

1. Create a form in your JSP with an action attribute pointing to a Servlet URL (e.g., <form action="/save-user" method="post">).
2. Add input fields corresponding to your model's attributes (like <input type="text" name="username">).
3. When the user submits the form, the request is sent to the /save-user Servlet.
4. The Servlet retrieves the form parameters (using request.getParameter("username")), creates a model object (e.g., User user = new User(username)), and calls model methods to save it (like UserDAO.save(user)).
5. Finally, the Servlet forwards or redirects the user to a confirmation page (another JSP).

Keeping forms in JSPs keeps your view and controller responsibilities separated—just like how you'd put forms in ERB templates in Rails.

4. Hiding .jsp Extension from URLs (Matching Servlet URL Style) #

To make your URLs clean (like example.com/example instead of example.com/example.jsp), use Servlet forwarding—here's the simplest approach:

1. Create a Servlet mapped to the clean URL (e.g., /example). You can do this with the @WebServlet annotation:

   @WebServlet("/example")
   public class ExampleServlet extends HttpServlet {
       protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
           // Forward the request to your JSP
           request.getRequestDispatcher("/WEB-INF/example.jsp").forward(request, response);
       }
   }
   

2. Move your example.jsp file into the WEB-INF directory. Files in WEB-INF can't be accessed directly by users—they have to go through a Servlet, which prevents direct access to the .jsp file.
3. Now, when users visit example.com/example, the Servlet forwards the request to example.jsp, and the URL stays clean (no .jsp suffix).

Alternatively, you could use URL rewriting filters, but Servlet forwarding is the most straightforward method for this use case.

内容的提问来源于stack exchange，提问作者Soyong