Patrón de método de plantilla

Question

¿Puedo saber cómo crear clases de niños si el método de mi clásico infantil getInfromDB () y SaveTodb () necesitan hacer una lógica diferente?

public abstract class BaseClass {
    public abstract Object doTransaction();
    public Object executeTrans() {
          //do something
          tx.begin();            
          this.doTransaction();
          tx.commit();

    }
}
public childClass extends BaseClass{
    @Override
    public Object doTransaction(){
        //overide to get something from database so can only be used for getInfoFromDB() and not for saveToDB()
        return something;
    }
    public List<String> getInfoFromDB(){
        super.executeTrans();
    }
    public void saveToDB(){
        super.executeTrans() ;
    }
}

Answer 1

Debe usar el patrón de plantilla en este caso, algo como esto:

public abstract class BaseClass 
{      
  public Object executeTrans(Template template) 
  {
    tx.begin();            
    template.doTransaction();
    tx.commit();    
  }
}

public interface Template
{
  public void doTransaction();
}

public childClass extends BaseClass
{
  public List<String> getInfoFromDB()
  {
    executeTrans(
      new Template()
      {
        public void doTransaction() 
        {
          ...do get info from DB here.
        }
      }
    );
  }

  public void saveToDB()
  {
    executeTrans(
      new Template()
      {
        public void doTransaction() 
        {
          ...do save to DB here.
        }
      }
    );
  }
}

Dicho eso, recomendaría usar las clases de plantilla Spring JDBC en lugar de rodar las suyas: han sido probados y probados y han resuelto los problemas con los que te encontrarás con transacciones anidadas, etc.

Answer 2

Pase un runnable que contiene la lógica diferente al método Executetrans ().

Sin embargo, no estoy seguro de que el patrón de método de plantilla sea realmente lo que necesitas aquí (¿y cómo está manejando reversiones?). Es posible que desee buscar un marco como Spring que permita transacciones declarativas.

Answer 3

Nick, el "TX" que voy a usar se ve a continuación. A juzgar por el código, la mejor práctica, el ciclo de vida está bien, ya que es llamado por SaveTodb () y getInfromDB ()

public abstract class BaseClass 
{      
  public Object executeTrans(Template template) 
  {
        // PersistenceManager pm = ...;
        Transaction tx = pm.currentTransaction();
        try {
            tx.begin();
             template.doTransaction();
            tx.commit();
        } finally {
            if (tx.isActive()) {
                tx.rollback();
            }
        }

  }
}