Generazione manuale di un contesto di facce

Question

Ho due sistemi che sto cercando di integrare. Uno è costruito su servlet raw, il nuovo è costruito su JSF con IceFaces. Sto cercando di facilitare l'accesso cross-system. L'idea è che ho un pulsante nel vecchio sistema che invia POST alle informazioni appropriate al nuovo sito e le registra.

Bene, idealmente, mi piacerebbe usare solo un vecchio servlet regolare per facilitare quello sul nuovo sito. Vai al Servlet del nuovo sito, fai ciò che deve fare e l'avanti sul dashboard.

La nostra sicurezza viene gestita tramite un bean gestito. Tuttavia, quando arrivi al Servlet, non c'è un contesto di facce. Quindi, come creerei un nuovo contesto di facce?

Ho un piano di backup in cui posso sempre collegarmi a una pagina fittizia .iface che creerà per me il FacesContext e quindi creare un bean di supporto che eseguirà roba quando verrà instanciata e quindi inoltrerà alla pagina principale . Ma questo sembra molto simile a un hack.

Qualsiasi aiuto sarebbe apprezzato!

MODIFICA: Sono andato con il backup. Fondamentalmente, ho posto a una pagina in questo modo:

<f:view> 
    <ice:outputText value="#{EntryPoint}"/> 
</f:view 

Il backing bean cercando in questo modo ...

public EntryPoint() { 
     try { 
     HttpServletRequest request = (HttpServletRequest) FacesContext.getCurrentInstance().getExternalContext().getRequest(); 
     HttpServletResponse response = (HttpServletResponse) FacesContext.getCurrentInstance().getExternalContext().getResponse(); 
     String loginID = request.getParameter("loginID"); 
     //Do some code to load the user/permissions 
     response.sendRedirect(
      //The appropriate page 
     ); 
     } catch (IOException ex) { 
     logger.error(null, ex); 
     } catch (SQLException ex) { 
     logger.error(null, ex); 
     } 
    } 

Questo si sente ancora come un hack, ma non sono sicuro di come muoversi Questo. Idealmente, POSSO POSTARE a un servlet, ottenere l'ID di accesso, creare l'utente e inserirlo direttamente nel bean gestito. Ma il FacesContext non esiste a quel punto.

Altre idee?

Answer 1

Non sono sicuro di cosa intendi per "sito" in questo contesto.

Un paio di note:

• fagioli Managed saranno mai essere disponibili al di fuori del web app (WAR) in cui sono definiti.
• Faces Le istanze di oggetti concessi vengono alla fine creati e disposti da FacesServlet.service, quindi le richieste devono passare attraverso questo servlet. Il tentativo di creare un contesto in altre circostanze potrebbe portare a un comportamento non definito.

---

Tenendo questo in mente, è possibile creare una sequenza di richiesta come questa:

FacesServlet (mapping: /faces/*) 
-> /faces/jsfPage.jsp (a JSP with JSF controls) 
    -> DispatchBean (calls ExternalContext.dispatch("/AnotherServlet") 
     -> AnotherServlet 

jsfPage.jsp contiene:

<f:view> 
    <h:outputText value="#{dispatchBean.dispatch}" /> 
</f:view> 

La proprietà "spedizione" si risolve in un metodo di fagioli "getDispatch":

public String getDispatch() { 
    FacesContext context = FacesContext.getCurrentInstance(); 
    try { 
     context.getExternalContext().dispatch("/FacesClientServlet"); 
    } catch (IOException e) { 
     throw new FacesException(e); 
    } 
    return null; 
} 

che invia a questo servlet:

public class FacesClientServlet extends javax.servlet.http.HttpServlet 
     implements javax.servlet.Servlet { 

    static final long serialVersionUID = 1L; 

    @Override 
    protected void doGet(HttpServletRequest request, 
      HttpServletResponse response) throws ServletException, IOException { 

     FacesContext context = FacesContext.getCurrentInstance(); 
     ELContext elContext = context.getELContext(); 
     ExpressionFactory expressionFactory = context.getApplication() 
       .getExpressionFactory(); 
     ValueExpression expression = expressionFactory.createValueExpression(
       elContext, "#{myBean.text}", Object.class); 
     Object value = expression.getValue(elContext); 

     ResponseWriter writer = context.getResponseWriter(); 
     writer.write("" + value); 

    } 

} 

che emette il valore da un bean gestito "myBean":

public class MyBean { 

    private final String text = "Hello, World!"; 

    public String getText() { 
     return text; 
    } 

} 

Questo è tutto molto contorto e non lo farei volentieri.

---

Un'alternativa, che può venire con le proprie conseguenze, è quello di creare il proprio contesto come questo:

public class ContextServlet extends javax.servlet.http.HttpServlet implements 
     javax.servlet.Servlet { 
    static final long serialVersionUID = 1L; 

    private FacesContextFactory facesContextFactory; 
    private Lifecycle lifecycle; 

    @Override 
    public void init(ServletConfig config) throws ServletException { 
     super.init(config); 

     LifecycleFactory lifecycleFactory = (LifecycleFactory) FactoryFinder 
       .getFactory(FactoryFinder.LIFECYCLE_FACTORY); 
     facesContextFactory = (FacesContextFactory) FactoryFinder 
       .getFactory(FactoryFinder.FACES_CONTEXT_FACTORY); 
     lifecycle = lifecycleFactory 
       .getLifecycle(LifecycleFactory.DEFAULT_LIFECYCLE); 
    } 

    @Override 
    protected void doGet(HttpServletRequest request, 
      HttpServletResponse response) throws ServletException, IOException { 

     FacesContext context = facesContextFactory.getFacesContext(
       getServletContext(), request, response, lifecycle); 
     try { 
      ELContext elContext = context.getELContext(); 
      ExpressionFactory expressionFactory = context.getApplication() 
        .getExpressionFactory(); 
      ValueExpression expression = expressionFactory 
        .createValueExpression(elContext, "#{myBean.text}", 
          Object.class); 
      Object value = expression.getValue(elContext); 

      PrintWriter pw = response.getWriter(); 
      try { 
       pw.write("" + value); 
      } finally { 
       pw.close(); 
      } 
     } finally { 
      context.release(); 
     } 
    } 

} 

Ancora una volta, vorrei evitare questo approccio, se possibile.