How does Servlet/JSP MVC patterns translate to JSF/Facelets (in particular the service and controller parts)?

Question

Let us take a basic example. In a servlet app I would have those classes: - app.domain.User: domain or model POJO, would contain fields and getters/setters - app.service.UserService: would contain methods that operate on User instances, such as `Register(User)`. Would call the DAO. - app.dao.UserDao: would be called by service to actually, say, insert a User in the DB. - app.servlets.RegisterController: a servlet intercepting requests to www.app/registration and calling the methods in app.service.UserService. It would then redirect to `WEB-INF\JSPs\registration.jsp` which would take care of the view. All this made perfect sense to me and clearly separated the concerns. I have tried since to wrap my head around the JSF/Facelets way of thinking. I have went through many excellent resources here in SO and otherplaces but there is not any place that addresses this simple question - namely how does the dao/service/controller/view pattern translate into JSF. To continue my example - I have…

Accepted Answer

There are two levels of MVC in JSF 2:

- Model = `@ManagedBean`, View = Facelets/xhtml, Controller = `FacesServlet` if you look only at jsf

- Model = Entities + Services, Controller = `@ManagedBean`, View = xhtml if you look at your application at a whole.

The typical package layout in a JSF application is the same:

- `com.foo.domain.featurex.service` <- model

- `com.foo.domain.featurex.model` <- model

- `com.foo.presentation.featurex` <- controller

- xhtml files <- view

Not that big of a difference here except that your controller is now the `FacesServlet` (the heart of JSF) together with your `@ManagedBean/@Named` which would reside in a class like `com.foo.presentation.featurex.Controller/Handler` or something like that.

Example for a simple registration:

```
// we talk about the big picture here, not about how jsf is built 
// but how your app is built

// model
package com.foo.domain.registration.entity;

@Entity
public class User { 
    // fields
}

package com.foo.domain.registration.service;

// also model
@Stateless
public class RegistrationService {

@PersistenceContext 
    EntityManager em;

public void register(User u) { 
        em.persist(u);
    } 
}

package com.foo.presentation

// controller
@Named
@ViewScoped
public class RegistrationController {

@Inject
    RegistrationService rs;

User current = new User();

public void register() { 
        rs.register(u);
    }

// get set for current user
}

// view
// quite a lot boilerplate omitted
// form omitted which displays all the necessary field of your current user
// via value="#{registrationContoller.current.name}"
<h:commandButton value="submit" type="submit" action="#{registrationController.register}" />
```

How does Servlet/JSP MVC patterns translate to JSF/Facelets (in particular the service and controller parts)?

Solution

Problem

Related problems