¿Cómo crear una aplicación web extensible?

¿Cómo implementaría una aplicación web extensible? En lo que estoy pensando es en una aplicación web similar a Jenkins o Hudson que proporciona soporte de complementos. Si bien es obvio para mí cómo se pueden ubicar y cargar los complementos, no sé cómo se pueden integrar en la arquitectura general. Estoy especialmente inseguro sobre los siguientes puntos.

¿Cómo puede un complemento cambiar la vista, por ejemplo, agregar elementos de entrada a un formulario?

Mi primera idea sería que un complemento puede registrar parciales / fragmentos para una determinada forma.

Ejemplo: complemento de boletín informativo que registra un fragmento de casilla de verificación de boletín informativo típico que se mostrará en la vista de registro del usuario.

¿Cómo puede reaccionar un complemento a las solicitudes entrantes?

Una vez más, un enfoque directo sería proporcionar oyentes para ciertas solicitudes o acciones, por ejemplo, solicitud POST a / usuario.

¿Cómo podría un complemento conservar datos?

Supongo que esta es una situación en la que las soluciones de almacenamiento de datos NoSQL serían superiores a las bases de datos relacionales.

Agradecería cualquier comentario, idea y experiencia (tal vez incluso haya un patrón de diseño) que tenga con respecto a las aplicaciones web extensibles.

Su pregunta contiene casi todas las respuestas. Estás justo en el estadio: todos los complementos y sus puntos de extensión para establecer el contexto y hacer que hagan lo que quieres. Existen numerosas formas de diseñar sistemas enchufables. Para principiantes:

http://people.clarkson.edu/~dhou/courses/EE564-s07/plugin.pdf

http://blogs.atlassian.com/developer/2011/03/plugin_architecture_episode_i.html

Aquí hay un ejemplo trivial para ilustrar cómo funcionaría un sistema rudimentario compatible con complementos:

public interface Plugin {

  void setEntityManager(EntityManager manager); // this is very course grained and liberal! A plugin would have access to whatever Entity Manager the container gives it. A plugin would then have a carte blanche to do whatever it needs: create, drop, insert, select, delete.

  View renderView(ViewContext context); // a plugin would render or return a view (whatever it is, could be a string in the simplest case) based on the context that the container passed to the plugin

  Action readEvent(Event event); // a plugin performs some Action based on an event as notified by a container

}


public class PluginContainer {

  private List<Plugin> plugins = new ArrayList<Plugin>();

  public void registerPlugins() {
    // loop through plugin descriptors obtained by your preferred mechanism
    // like introspecting libraries (JARs) in a configurable location

    // for each descriptor, load a Plugin dynamically and "register" it with a container
    Plugin p = ClassLoader.getSystemClassLoader().loadClass("com.my.PluginA").newInstance(); 
    p.setEntityManager(entityManager);
    plugins.add(p);
  }

  public void readEvent(AppEvent appEvent) {
    Event e = this.constructPluginSpecificEventFromAppEvent(); // optional
    for (Plugin p : this.plugins) {
      p.readEvent(e); // disregarding Action here
    }
  }
}

public class Application {

  private PluginContainer pContainer;

  private void buttonClicked(AppEvent appEvent) {
    this.showCoolDialog("Thank you for clicking a button!");
    // now let my plugins handle this
    // they can do whatever they want for this event
    // since they have access to EntityManager, they can work with a persistence storage as well
    this.pcContainer.readEvent(appEvent);
  }

}