Progettazione del flusso dell'applicazione

Question

Progettazione del flusso dell'applicazione

#1 da (2 voti)
#2 da (1 voti)

1

Sto creando un'applicazione web in java in cui ho bisogno di prendere in giro il seguente flusso.

Quando l'utente attiva un determinato processo (aggiungi prodotto al carrello), ho bisogno di passare attraverso i seguenti passaggi

È necessario vedere nella sessione HTTP se l'utente ha effettuato l'accesso.
Controlla la sessione HTTP se il carrello è lì
Se l'utente esiste nella sessione HTTP e il suo carrello non esiste nella sessione HTTP
Ottieni il carrello degli utenti dal database.
aggiungi l'articolo al carrello e salvalo nella sessione HTTP e aggiorna il carrello nel DB.
Se il carrello non esiste nel DB, crea un nuovo carrello e salva in esso la sessione HTTP.

Anche se mi mancano un sacco di casi d'uso qui (non voglio che la lunghezza delle domande aumenti molto), ma la maggior parte del flusso sarà la stessa che ho descritto nei passaggi precedenti.

Il mio flusso inizierà da Controller e andrà verso Service Layer e terminerà con il livello DAO .

Poiché ci saranno molti casi d'uso in cui ho bisogno di controllare la sessione HTTP e in base alla necessità di chiamare Service layer, stavo progettando di aggiungere un layer Facade che dovrebbe essere responsabile di fare questo per me come controllare Session e interagire con Service layer.

Si prega di suggerire se questo è un approccio valido o qualsiasi altro approccio migliore può essere implementato qui?

Un altro punto in cui sono confuso è come gestire HTTP session nel livello facciata? devo passare l'oggetto sessione HTTP ogni volta che chiamo il mio Facade o qualsiasi altro approccio può essere usato qui?

design java design-patterns

posta Umesh Awasthi 17.04.2013 - 06:06

fonte

2 risposte

Leggi altre domande sui tag design java design-patterns

Meno codice o meno operazioni [chiuso] Coping con il codice di test che diventa troppo complesso [duplicato]

score 2 · Answer 1

Quando guardo al tuo caso d'uso, comincio a pensare alla separazione delle preoccupazioni.

Il controllore non dovrebbe preoccuparsi se il carrello è nella richiesta o meno.
La chiamata di servizio che aggiunge elementi a un carrello non dovrebbe interessare se l'utente ha effettuato l'accesso o meno.

Quindi penso:

Gli oggetti di richiesta sono un rompicapo da testare con
Una facciata è piuttosto vaga per casi d'uso specifici. E se potessimo creare un semplice oggetto di trasferimento dati per ogni caso d'uso che ha i dati necessari?

Quindi vorrei iniziare con qualcosa del tipo:

Regolatore

Status addItemToCart(HttpServletRequest request, Item item) {
  if(request.getSession(false) == null) return needLogin(request)

  UserCart cart = service.addItemToCart(item, new UserCart(session))
  return cart.saveToSession(session)
}

servizio

UserCart addItemToCart(Item item, UserCart userCart) {
  if userCart.needsCart() {
     userCart = cartDAO.getNewCart(userCart)
  }
  userCart.addItem(Item)
  return cartDAO.updateCart(userCart)
}

I test del mio livello di servizio insisterebbero su qualcosa come UserCart per impedirmi di prendere in giro HTTPServletRequests e creare 10 righe di codice di installazione. UserCart è solo un oggetto di trasferimento dati stupido con alcuni metodi di convenienza, ma rende tutto molto più semplice da capire. L'utente ha-un carrello della spesa è importante per questo caso d'uso, quindi è dove il mio cervello va abbastanza rapidamente. Questo ci consente anche di evitare tutti i controlli nulli e i blocchi nidificati che diventano dilaganti quando ti impedisci di creare semplici concetti specifici del dominio.

score 1 · Answer 2

Vorrei sempre codificare la mia domanda nel modo più semplice. Avrei fatto tutto questo nel mio servizio stesso livello. Di seguito è riportato il mio pseudo-codice noob :

 /**
 * @param request HttpServletRequest
 * @param item Item to be added
 */
private void addItemToCart(HttpServletRequest request, Item item) {

    UserVO user = null;
    ShoppingCart cart = null;
    ShoppingCartDAO cartDAO = new ShoppingCartDAO();
    HttpSession session = request.getSession(false);
    // check if its an existing session
    if(session!=null){
        // get the user ifo from the session
        user = (UserVO)session.getAttribute("userVO");
        // try to get the cart from the session
        cart = (ShoppingCart)session.getAttribute("cart");

        if(cart==null) {
            // try to get the cart from DB
            cart = cartDAO.getShoppingCart(user);
            if(cart==null){
                // create a new cart
                ShoppingCart cart = new ShoppingCart(user);
            }
        }
        // add item to the  cart
        cart.addItem(item);
        // set it in session
        session.setAttribute("cart",cart);
        // update the DB
        cartDAO.updateShoppingCart(user);
    }

}

EDIT: credo che puoi creare un Interface per avvolgere l'oggetto request e passare l'implementazione di Interface come argomento al metodo Service .