Erstellen eines Faces Context manuell

Question

Ich habe zwei Systeme, die ich integrieren möchte. Einer basiert auf rohen Servlets, der neue auf JSF mit IceFaces. Ich versuche, die systemübergreifende Anmeldung zu erleichtern. Die Idee ist, dass ich eine Schaltfläche im alten System habe, die die entsprechenden Informationen an die neue Site sendet und sie anmeldet.

Nun, im Idealfall würde ich nur ein normales altes Servlet verwenden, um dies auf der neuen Website zu erleichtern. Gehen Sie zum Servlet der neuen Website, tun Sie, was Sie tun müssen, und gehen Sie auf das Dashboard.

Unsere Sicherheit wird über eine gemanagte Bean gehandhabt. Wenn Sie jedoch das Servlet erreichen, gibt es keinen Kontext für Gesichter. Wie würde ich also einen Kontext für neue Gesichter erstellen?

Ich habe einen Backup-Plan in dem ich immer auf eine Dummy .iface-Seite verlinken kann, die den FacesContext für mich erstellen und dann eine Backing-Bean erstellen wird, die Sachen macht, wenn es instanziiert und dann auf die Hauptseite weitergeleitet wird . Aber das fühlt sich sehr nach einem Hack an.

Jede Hilfe wäre willkommen!

EDIT: Ich ging mit dem Back-up-Weg. Grundsätzlich schreibe ich auf eine Seite wie folgt:

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

Die Backing Bean wie so suchen ...

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

Dieses immer noch wie ein Hack fühlt, aber ich bin nicht sicher, wie zu umgehen Dies. Im Idealfall würde ich an ein Servlet POST senden, die loginID abrufen, den Benutzer erstellen und ihn direkt in die Managed Bean schreiben. Aber der FacesContext existiert zu diesem Zeitpunkt nicht.

Irgendwelche anderen Ideen?

Answer 1

Ich bin mir nicht sicher, was Sie mit "Website" in diesem Zusammenhang meinen.

Ein paar Anmerkungen:

• Managed Bohnen werden nie außerhalb des Web-App (IST) zur Verfügung, in dem sie definiert sind.
• FacesContext-Objektinstanzen werden letztendlich von FacesServlet.service erstellt und entsorgt, sodass Anforderungen dieses Servlet durchlaufen sollten. Der Versuch, unter anderen Umständen einen Kontext zu erstellen, kann zu undefiniertem Verhalten führen.

---

dass Bedenkt man, könnten Sie eine Anforderungssequenz wie folgt erstellen:

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

jsfPage.JSP enthält:

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

Die "Dispatch" Eigenschaft auf eine Bean-Methode "getDispatch" auflöst:

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

die zu diesem Servlet entsendet:

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

    } 

} 

der den Wert von a aussendet verwaltete Bohne "myBean":

public class MyBean { 

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

    public String getText() { 
     return text; 
    } 

} 

Das ist alles sehr verworren und ich würde nichts davon tun.

---

Eine Alternative, die mit ihren eigenen Konsequenzen kommen können, ist Ihren eigenen Kontext wie diese zu erstellen:

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

} 

Auch ich diesen Ansatz zu vermeiden, wenn möglich.