Quelle est la meilleure façon de créer une application Web Java modulaire? [Fermé]

Question

Je construis un petit site Web en Java (Spring MVC avec vues JSP) et j'essaie de trouver la meilleure solution pour créer et inclure quelques modules réutilisables (comme "dernières nouvelles", "événements à venir" ...).

La question est donc: des portlets, des tuiles ou une autre technologie?

Answer 1

Si vous utilisez Spring MVC, je vous recommanderais d'utiliser des portlets. Au printemps, les portlets ne sont que des contrôleurs légers, car ils ne sont responsables que d'un fragment de la page et sont très faciles à écrire. Si vous utilisez Spring 2.5, vous pouvez profiter de tous les avantages du nouveau support d'annotation et ils s'intègrent parfaitement à l'ensemble de l'application Spring avec l'injection de dépendances et les autres avantages de son utilisation.

Un contrôleur de portlet est à peu près le même qu'un contrôleur de servlet, voici un exemple simple:

@RequestMapping("VIEW")
@Controller
public class NewsPortlet {

    private NewsService newsService;

    @Autowired
    public NewsPortlet(NewsService newsService) {
        this.newsService = newsService;
    }

    @RequestMapping(method = RequestMethod.GET)
    public String view(Model model) {
        model.addAttribute(newsService.getLatests(10));
        return "news";        
    }
}

Ici, un NewsService sera automatiquement injecté dans le contrôleur. La méthode view ajoute un objet List au modèle, qui sera disponible en tant que $ {newsList} dans le fichier JSP. Spring cherchera une vue nommée news.jsp en fonction de la valeur de retour de la méthode. RequestMapping indique à Spring que ce contrôleur est pour le mode VIEW du portlet.

La configuration XML doit uniquement spécifier l'emplacement de la vue et des contrôleurs:

<!-- look for controllers and services here -->
<context:component-scan base-package="com.example.news"/>

<!-- look for views here -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/jsp/news/"/>
    <property name="suffix" value=".jsp"/>
</bean>

Si vous souhaitez simplement incorporer les portlets dans votre application existante, vous pouvez regrouper un conteneur de portlet, tel que eXo , Sun , ou Apache . Si vous souhaitez créer votre application sous la forme d'un ensemble de portlets, vous pouvez envisager une solution complète, telle que Portail Liferay .

Answer 2

Les carreaux peuvent être pénibles. Vaste amélioration par rapport à ce qui était auparavant (c'est-à-dire rien), mais plutôt restrictive.

Wicket pourrait être ce que vous cherchez, à moins que vous n'ayez opté pour JSP.

Answer 3

Je ne recommande pas d'utiliser des portlets à moins que votre application ne soit réellement un portail Web .

Si vous souhaitez simplement "utiliser des composants réutilisables" utilisez les fichiers de balises JSP , ils sont extrêmement simples, mais extrêmement puissants, car ils sont identiques aux JSP classiques.

J'ai déjà utilisé des tuiles et la complexité que cela implique n'en vaut simplement pas la peine.

Answer 4

Je suis un grand fan de GWT . Il vous permet d’écrire vos composants sous forme de classes Java normales, puis de les insérer à volonté dans vos pages. Le tout finit par être compilé sur Javascript.

Voici un exemple:

public class MyApplication implements EntryPoint, HistoryListener
{
    static final String INIT_STATE = "status";

    /**
     * This is the entry point method.  Instantiates the home page.
     */
    public void onModuleLoad ()
    {
        RootPanel.get ().setStyleName ("root");
        initHistorySupport ();
    }

    private void initHistorySupport ()
    {
        History.addHistoryListener (this);

        // check to see if there are any tokens passed at startup via the browser’s URI
        String token = History.getToken ();
        if (token.length () == 0)
        {
            onHistoryChanged (INIT_STATE);
        }
        else
        {
            onHistoryChanged (token);
        }
    }


    /**
     * Fired when the user clicks the browser's 'back' or 'forward' buttons.
     *
     * @param historyToken the token representing the current history state
     */
    public void onHistoryChanged (String historyToken)
    {
        RootPanel.get ().clear ();
        Page page;
        if (Page1.TOKEN.equalsIgnoreCase (historyToken))
        {
            page = new Page1 ();
        }
        else if (Page2.TOKEN.equalsIgnoreCase (historyToken))
        {
            page = new Page2 ();
        }
        else if (Page3.TOKEN.equalsIgnoreCase (historyToken))
        {
            page = new Page3 ();
        }
        RootPanel.get ().add (page);
    }
}

Answer 5

J’ai beaucoup d’expérience avec les portlets en association avec Ajax JSF (IceFaces) et Liferay Portal et je ne les recommanderais à personne. Tout semble bien en lisant un tutoriel et un véritable enfer dans la pratique. Bien sûr, je pense qu’ils sont beaucoup plus pratiques et légers avec Spring MVC et JSP, mais de toute façon, les portlets ne sont pas bien pris en charge par la technologie.

Answer 6

Je ne suis pas sûr à 100% de ce que " composants réutilisables " signifie dans ce contexte, mais si vous voulez que certains éléments communs apparaissent sur chaque page, tels que la bannière, le pied de page, les liens de navigation, etc., ne cherchez pas plus loin que SiteMesh . Mon équipe l’a utilisé avec succès sur quelques applications Web internationalisées.

Answer 7

Tapestry est un cadre d'applications Web Java mettant l'accent sur la création facile de composants réutilisables.

J’ai utilisé sitemesh. C’est bien pour encapsuler un ensemble de pages dans les en-têtes et les pieds de page standard, mais Tapestry convient mieux à la création de composants utilisés sur plusieurs pages, éventuellement plusieurs fois par page. Les composants Tapestry peuvent prendre d'autres composants en tant que paramètres, ce qui permet le wrapping de style Sitemesh.