Como criar um aplicativo da web extensível?

Como você implementaria um aplicativo da web extensível? O que estou pensando é em um aplicativo da Web semelhante ao Jenkins ou Hudson, que fornece suporte a plug-in. Embora seja óbvio para mim como os plug-ins podem ser localizados e carregados, não sei como eles podem ser integrados à arquitetura geral. Eu sou especialmente incerto sobre os seguintes pontos.

Como um plug-in pode alterar a exibição, por exemplo, adicionar elementos de entrada a um formulário?

Minha primeira idéia seria que um plug-in possa registrar parciais / fragmentos para um determinado formulário.

Exemplo: plug-in de boletim informativo que registra um fragmento de caixa de seleção de boletim informativo típico que será renderizado na visualização de registro do usuário.

Como um plug-in pode reagir a solicitações recebidas?

Novamente, uma abordagem direta seria fornecer ouvintes para determinadas solicitações ou ações, por exemplo, solicitação POST para / usuário.

Como um plug-in poderia persistir dados?

Estou assumindo que esta é uma situação em que as soluções de armazenamento de dados NoSQL seriam superiores aos bancos de dados relacionais.

Eu gostaria de receber comentários, idéias e experiências (talvez até exista um padrão de design) que você tenha em relação a aplicativos da web extensíveis.

Sua pergunta contém quase todas as respostas. Você está certo: são todos os plug-ins e seus pontos de extensão para definir o contexto e fazê-los fazer o que quiser. Existem várias maneiras de projetar sistemas de plug-in. Para iniciantes:

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

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

Aqui está um exemplo trivial para ilustrar como um sistema rudimentar com reconhecimento de plug-ins funcionaria:

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);
  }

}