Pattern per il recupero di lotti di oggetti?

Questo sembra essere un requisito ricorrente per me, quindi mi piacerebbe avere un feedback su come implementarlo e quale tipo di codice di test ha senso. Devo recuperare batch di dati e ricucirli per un ulteriore utilizzo aziendale. Devo selezionare tutte le origini dati As from 1 e confrontarle con qualsiasi Bs da una seconda origine dati. A ha un campo ID e B ha un campo ID che può corrispondere ad alcuni ID. Devo restituire tutte le A con i corrispondenti B, se esistono corrispondenze.

Volendo seguire alcune buone pratiche, utilizzo i modelli DAO e Object. Ciò si traduce in qualcosa di simile al seguito. Abbastanza semplice, qualsiasi feedback su questo? Raccomandazioni per il codice di prova: scriverei test di integrazione contro le interfacce dao, ma probabilmente nient'altro? Qual è il nome del pacchetto che le persone usano per i modelli? Com.me.model è ragionevole?

    package com.me.dao;

    class ADao {
      public List<A> getAllAs() {
       return //Select aId, avalue1, value2;
      }
    }

    class BDao {
      public List<B> getAllBs() {
       return //Select bId, bvalue1, bvalue2;
      }
    }

   package com.me.model;

    class A {
      long Id
      avalue1;
      avalue2;
    } 

    class B {
      long aId
      bvalue1;
      bvalue2;
    } 

    class AWithB {
      A a;
      List<B> b;
    }

Inoltre, dove dovrebbe essere il seguente codice. Questo sembra che sarebbe un uso improprio di un modello di fabbrica, suggerimenti su ciò che è appropriato qui? Consigli per unità testare questo codice?

List<AWithB> getAllAsWithBs {
  List<A> as = aDao.getAllAs();
  List<B> bs = bDAo.getAllBs();

  return combineAsAndBs(as, bs);
}

List<AWithB> combineAsAndBs(List<A> as, List<B> bs) {
  List<AWithB> aWithBs =new List<>;

  foreach (A a : as) {
    aWithBs.add(createAWithBs(List<B> bs));
  }

  return aWithBs;
}

List<B> createAWithB(A a, List<B> bs) {
  AWithB aWithB = new AWithB;

  aWithB.a = a;
  for (B b : bs) {
    if (a.id == b.aId) {
      aWithB.bs.add(b);
    }
  } 

 return aWithB;
}