Uso de CRUD MongoDB en linux centos - tomcat - java

En esta entrada al blog quiero dejar una guia para el uso de la base de datos NO-SQL MongoDB del tipo CRUD (Creacion, Lectura, Actulizacion y borrado)  en java

en un servidor Tomcat 9.0, estas pequeñas rutinas son totalmente funcionales y sirve al proposito de ilustar el uso de esta DB en java, a mi por lo menos me genero algunos inconvenientes dado que aunque la documentacion para esta DB hay mucha informacion no la hay tanta para la misma siendo usada en java y menos para el servidor tomcat.

En este ejercicio voy a usar un modelo simplicado DTO - DAO , implementado sobre DWR, en el primer archivo DTO defino todas las variables asi como los set y get que uso luego en el DAO. tambien el modelo cuenta con el archivo de Interface que permite cambiar de modelo de acceso a la DB si se considera pertinente, al fin esta el script de compilacion de las clases java.

En este ejercicio se usa el acceso a uno de los procesos de mi sistema que denomino ActivosTipoDTO.java , ActivosTipoDAO.java y ActivosTipoInterface.java ademas posee el el archivo GestionHandler.java que define los procesos que pueden ser accesados desde el front-end del sistema mediante la utilidad DWR-3.0 (el equivalente AJAX para java tomcat, en un guion javascript vainilla).

Como el modelo esta orientado a DWR la carpeta que se recomienda para

la compilaacion del sistema de lado del servidor deben estar bajo:

/usr/local/tomcat/webapps/gestion/WEB-INF/classes/dwr/gestion

y todas las clases en el paquete : package dwr.gestion    ;

En los casos en que se genera informacion que debe ser desplegada esta

se almacena en bean o un array de bean que se le pasa a DWR para ser

desplegada por el front-end en javascript , mediante el modelo DWR.

Nota: Es aplicacion similar ajax que permite el transito de informacion entre el front-end y el backend de una forma fluido, y a mi parecer baste sencilla eficiente y comoda

Y consta de una parte para el front-end que se programa en javascript y que en general no es mas asignar las variables de interes en un arreglo JSON y pasarlo a algunos de los metodos definidos en el back-end. en este caos contenidos en GestionHandler.java que usa los procedimientos definidos en el DAO.

El metodo de configuracion de DWR es muy basico ya que basta copiar las librerias jar de DWR en la carpeta de librerias de tomcat /lib 

Eventualmente puedese puede percibir como medianamente complejo pero en realidad es mas  por las llamdas a los set y get del modelo para usur los metodos

y sus variables que lo que en realidad corresponde a el uso de mongoDB. 

El modelo aqui planteado tiene como bondad principal que en general

permite configurar de manera rapida un proceso CRUD, simplemente cambiando el nombre ActivoTipo por cualquiera otro pertinente al desarrollo que se tenga, al cual ademas se le pueden agregar mas variables simplemente adicionandolas en el DTO, y ampliando en esencia e metodo aqui denominado ActivosTipoID() , que es el metodo de consulta general para que tenga en cuenta las nuevas variables, y los Procedimintos ActivosTipoEditar() y ActivosTipoCrear() para que las inserte o modifique dentro dentro de la DB. Se convierte entonces el desarrollo en un simple Cortar y pegar.

Se define un script jsp basico para generar una consulta y desplegar los valor

almacenados en la coleccion ActivosTipo.java definida en los metodos

DTO,DAO que se despliegan en una tabla con boostrap 4.

Yo defino todo dento de una variable tipo var de javascript  por comodidad ya que me permite tener bucles,  condicionales y asignaciones mas el acceso a la data que devuelve DWR todo en javascript. Posteriormente muestro el contenido de esta variable mediante una asignacion en un <div id="motrar"></div>, mediante el comando innerHtml.

==================================================

ActivosTipo.jsp

==================================================

  <div id="activoTipoDocumento">
          <!-- Aqui imprime el Informe    -->
  </div>

<script>

function ActivoTipoConsultar()
      {

           //Lass variables Buscar y Sort que se obtienen de  input

          //se le pasan a una variable tipo json que las ejectua en el AJAX-DWR

         // y mediante el Handler devuelve la informacion solicitada.

           activoTipoBuscar = dwr.util.getValue("activoTipoBuscar")                                      ;
        activoTipoSort   = dwr.util.getValue("activoTipoSort")                                          ;

         //la variable usuarioDB pasa al modelo DTO,DAO el nombre de la DB

        // con la cual se establece la conexion en  GestionHandler.java la cual

       //  le pasa dicha conexon a los diferentes metodos Crear, Leer,Actualizar

      //  y borrar,


        var usuarioDB = "PRUEBA01"                     ;
        var c = {

                        activoTipoBuscar:activoTipoBuscar,
                        activoTipoSort:activoTipoSort

                     }                                                       ;

    gestionHandler.ActivosTipoID( usuarioDB,
                                   c,
                                   ActivoTipoInforme
                                 )                                                        ;
      }

function ActivoTipoInforme(activoTipoDatos)
     {

       var activoTipoDocumento = ""                                                             ;
       var activoTipoInfo      = activoTipoDatos                                                      ;
       var f               = ""                                                           ;

       activoTipoDocumento += "<div id='informe' class='printer'"                               ;
       activoTipoDocumento += CabeceraImpresion()                                               ;

       activoTipoDocumento += "<h6 align=center><b> Activos Tipo</b></h6>"                      ;
       activoTipoDocumento += "<div>"                                                           ;
           activoTipoDocumento += "<table class='table table-bordered table-condensed table_estilo' >";

             activoTipoDocumento += "<thead>"                                                   ;
               activoTipoDocumento += "<tr>"                                                    ;
               activoTipoDocumento += "<th> ActivoTipo                </th>"                    ;
               activoTipoDocumento += "</tr>"                                                   ;
             activoTipoDocumento += "</thead>"                                                  ;
            activoTipoDocumento += "<tbody>";

             for ( i = 0 ; i < activoTipoInfo.length ; i++)
                {

                   f = activoTipoInfo[i]                                                        ;

                   activoTipoId   = f.activoTipoId                                                    ;
                   activoTipoDescripcion   = f.activoTipoDescripcion                                  ;
                   activoTipoRegistro = f.activoTipoRegistro                                          ;

               activoTipoDocumento += "<tr>";
                 activoTipoDocumento += "<td align='left'  >" +  activoTipoId  + "</td>"              ;
               activoTipoDocumento += "</tr>"                                                   ;

                }

             activoTipoDocumento += "</tbody>"                                                  ;
           activoTipoDocumento += "</table>"                                                    ;
      activoTipoDocumento += "</div>"                                                           ;
      activoTipoDocumento += "</div>"                                                           ;

       dwr.util.byId("activoTipoDocumento").innerHTML = activoTipoDocumento                           ;

     }

     ActivoTipoConsultar()                                                                      ;

</script>
    ver enlace : DWR y boostrap

===============================================

ActivosTipoDTO.java

===============================================

package dwr.gestion    ;

/*                                                                                                                                         
   25/01/2021                                                                                                                             
*/

public class ActivosTipoDTO
{
   // Variables usadas para almacenar informacion la DB
  private String activoTipoId                                                   ;
  private String activoTipoDescripcion                                   ;
  private String activoTipoDigitador                                       ;
  private String activoTipoRegistro                                         ;
  private String activoTipoEntorno                                         ;
  private String activoTipoTimeStamp                                    ;
  // Otras variables utilizadas para generar consultas y pasar

  //valores a los procedimientos sobre todo en los modelos de

  // linite a las conultas, ordenamiento por diferentes campos

  // inicio y fin de de busqueda.

  private String activoTipoBuscar                                           ;
  private String activoTipoSort                                               ;
  private String activoTipoLimit                                              ;
  private String activoTipoOffSet                                            ;

    public String getActivoTipoId()
    {
        return activoTipoId                                                   ;
    }
    public void setActivoTipoId(String activoTipoId)
    {
        this.activoTipoId = activoTipoId                                      ;
    }

    public String getActivoTipoDescripcion()
    {
        return activoTipoDescripcion                                              ;
    }
    public void setActivoTipoDescripcion(String activoTipoDescripcion)
    {
        this.activoTipoDescripcion = Sos.Upper(activoTipoDescripcion)             ;
    }
    public String getActivoTipoDigitador()
    {
        return activoTipoDigitador                                                ;
    }
    public void setActivoTipoDigitador(String activoTipoDigitador)
    {
        this.activoTipoDigitador = activoTipoDigitador                            ;
    }
    public String getActivoTipoRegistro()
    {
        return activoTipoRegistro                                                 ;
    }
    public void setActivoTipoRegistro(String activoTipoRegistro)
    {
        this.activoTipoRegistro = activoTipoRegistro                              ;
    }

    public String getActivoTipoEntorno()
    {
        return activoTipoEntorno                                                  ;
    }
    public void setActivoTipoEntorno(String activoTipoEntorno)
    {
        this.activoTipoEntorno = activoTipoEntorno                                ;
    }

    public String getActivoTipoTimeStamp()
    {
        return activoTipoTimeStamp                                                ;
    }
    public void setActivoTipoTimeStamp(String activoTipoTimeStamp)
    {
        this.activoTipoTimeStamp = activoTipoTimeStamp                            ;
    }
    public String getActivoTipoBuscar()
    {
        return activoTipoBuscar                                                   ;
    }
    public void setActivoTipoBuscar(String activoTipoBuscar)
    {
        this.activoTipoBuscar = activoTipoBuscar                                  ;
    }

    public String getActivoTipoSort()
    {
        return activoTipoSort                                                     ;
    }
    public void setActivoTipoSort(String activoTipoSort)
    {
        this.activoTipoSort = activoTipoSort                                      ;
    }
    public String getActivoTipoLimit()
    {
        return activoTipoLimit                                                    ;
    }
    public void setActivoTipoLimit(String activoTipoLimit)
    {
        this.activoTipoLimit = activoTipoLimit                                    ;
    }

    public String getActivoTipoOffSet()
    {
        return activoTipoOffSet                                                   ;
    }
    public void setActivoTipoOffSet(String activoTipoOffSet)
    {
        this.activoTipoOffSet = activoTipoOffSet                                  ;
    }

    @Override
    public String toString()
    {
        return this.getActivoTipoId() + "," + this.getActivoTipoDescripcion() + "," + this.getActivoTipoTimeStamp();
    }

================================================

ActivosInterface.java

//Los elementos definidos en la interfasce debe corresponder a los definidos en DAO.

================================================
package dwr.gestion          ;

/*                                                                                                                                         
   25/01/2021                                                                                                                              
*/

import java.io.*                 ;
import java.util.*              ;
import java.text.*             ;
import java.util.List         ;
import dwr.gestion.ActivosTipoDTO ;

import com.mongodb.client.*   ;

public interface ActivosTipoInterface
   {

    public Vector<ActivosTipoDTO>  ActivosTipoID(MongoDatabase mgDB,
                                     ActivosTipoDTO ActivosTipo
                                  )                   ;
    public boolean             ActivosTipoExiste(MongoDatabase mgDB,
                                           ActivosTipoDTO ActivosTipo
                                     )                ;

    public ActivosTipoDTO          ActivosTipoRegistros(MongoDatabase stN,
                                           ActivosTipoDTO ActivosTipo
                                        )             ;
    public ActivosTipoDTO          ActivosTipoConsultar(MongoDatabase mgDB,
                                           ActivosTipoDTO ActivosTipo
                                        )             ;
    public boolean             ActivosTipoBorrar(MongoDatabase stN,
                                          ActivosTipoDTO ActivosTipo
                                          )           ;
    public boolean             ActivosTipoEditar(MongoDatabase stN,
                                           ActivosTipoDTO ActivosTipo
                                         )            ;
    public boolean             ActivosTipoCrear(MongoDatabase mgDB,
                                          ActivosTipoDTO ActivosTipo
                                        )             ;

   }

===============================================

ActivosDAO.java

===============================================

package dwr.gestion                       ;

/*                                                                                                                                         
   25/01/2021                                                                                                                              
*/

import java.io.*                             ;
import java.util.*                           ;
import java.text.*                          ;

import com.mongodb.client.*                        ;
import com.mongodb.client.result.*             ;
import com.mongodb.client.model.Filters.* ;
import org.bson.*;

import java.util.regex.Pattern            ;

/**                                                                                                                                        
   @author  Carlos Arturo Casta&ntilde;o G.                                                                                                
   @version 3.0                                                                                                                            
                                                                                                                                           
*/

public class ActivosTipoDAO implements ActivosTipoInterface
{

   private static final long serialVersionUID = 1006170630081701L            ;


   //Verifica un documento existe en la collection
   public boolean ActivosTipoExiste(MongoDatabase mgDB,
                             ActivosTipoDTO activosTipo
                            )
   {

 
     //Sobre las variables mgWhere,mgFields,mgQuery, myWhereO y myWhere

      //se define las operaciones a efectuarse en la Collection.

      //Observar como en este modleo se pueden agregar los and y or

      //de una forma realmente simple asignado a la variable el valor que se

     //pasar a la estructura a ejecutar

     //De forma similar los campos a consulta que en este ejemplo

     //en realidad se extraen todos los campos y se limita la presentacion

     //del id autogenrado por la DB

     //mgQuery contine un array con todos los condicionante se la consulta

     //compuesta por los AND y OR utilizados.

     //El modelo aqui planteado facilita el uso un CRUD basico de una forma

     //bastante comoda inyectando los valores necesarios a la consulta

     // mediantes sensillos set y get definidos en el DTO.

     boolean   existe                                                                              ;
     MongoCollection<Document> collection =    mgDB.getCollection("ACTIVOSTIPO");
     Document mgWhere  = new Document()                                      ;
     Document mgFields = new Document()                                        ;
     Document mgQuery  = new Document()                                       ;

     ArrayList<Document> myWhereO = new ArrayList<Document>()    ;
     ArrayList<Document> myWhereY = new ArrayList<Document>()     ;

     myWhereO.add(new Document("activoTipoId",activosTipo.getActivoTipoId()));
     myWhereO.add(new Document("registro"   ,activosTipo.getActivoTipoRegistro()));
     mgQuery.append("$or" ,myWhereO)                                         ;

     mgFields.append("registro",1)                                                 ;

     try
        {

          MongoCursor<Document> cursor = collection.find(mgQuery).projection(mgFields).cursor() ;
          if (cursor.hasNext())
            {
              existe = true                                                  ;
            }
          else
            {
              existe = false                                                 ;
            }

          cursor.close()                                                     ;
          return(existe)                                                     ;
       }
    catch(Exception e)
        {
          System.out.println("Error en ActivoTipo Existe : " + e.toString()) ;
          e.printStackTrace(System.out)                                      ;

          return (false)                                                                 ;
        }
   }

    //Cuenta los documentos (registros) hay en la collection
    public ActivosTipoDTO ActivosTipoRegistros(MongoDatabase mgDB,
                                   ActivosTipoDTO activosTipo
                                )
   {

     ActivosTipoDTO activosTipoC = new ActivosTipoDTO()                      ;

     MongoCollection<Document> collection = mgDB.getCollection("ACTIVOSTIPO");

     try
        {

          long registros = collection.countDocuments()                       ;
          activosTipoC.setActivoTipoRegistro(Sos.StrDouble(registros))       ;

          return(activosTipoC)                                               ;
        }
     catch(Exception e)
        {
          System.out.println("Error en ActivoTipo conteo : " + e.toString()) ;
          e.printStackTrace(System.out)                                      ;
          return(activosTipoC)                                                     ;
        }
   }

  //Consulta un documento especifico de la collection y usa

  // el procedmento ActivosTipoID() para extraer la informacion.
  public ActivosTipoDTO ActivosTipoConsultar(MongoDatabase mgDB,
                               ActivosTipoDTO activosTipo
                              )
   {

     ActivosTipoDTO activosTipoC          = new ActivosTipoDTO()             ;
     Vector< ActivosTipoDTO > gDato = new Vector< ActivosTipoDTO >()         ;

     activosTipo.setActivoTipoBuscar(activosTipo.getActivoTipoRegistro())    ;
     activosTipo.setActivoTipoSort("REGISTRO"                )               ;

     gDato = ActivosTipoID(mgDB,
                            activosTipo
                           )                                                                               ;

     activosTipoC = gDato.elementAt(0)                                              ;
     return(activosTipoC)                                                                     ;

}

  //Consulta la informacion de la collection por diferentes campos

  // y los presenta ordenados por la variblable Sort pasada al sistema.
  public Vector<ActivosTipoDTO> ActivosTipoID(MongoDatabase mgDB,
                                 ActivosTipoDTO activosTipo
                                )
   {

     ActivosTipoDTO activosTipoC            = new ActivosTipoDTO()            ;
     Vector< ActivosTipoDTO > gDato   = new Vector< ActivosTipoDTO >()        ;

     String buscar          = activosTipo.getActivoTipoBuscar().trim()    ;
     String sort               = activosTipo.getActivoTipoSort().trim()      ;
     int    limite              = 50000                                       ;
     int    offSet              = 0                                           ;

     Document data     = new Document()                                       ;
     Document mgFields = new Document()                                       ;
     Document mgQuery  = new Document()                                       ;
     Document mgSort   = new Document()                                       ;
     Document mgRegex  = new Document("$regex","(?i)" + Pattern.quote(buscar));

     ArrayList<Document> myWhereO = new ArrayList<Document>()                 ;
     ArrayList<Document> myWhereY = new ArrayList<Document>()                 ;

     if ( activosTipo.getActivoTipoLimit() != null )
       {
         limite = Sos.Val(activosTipo.getActivoTipoLimit())                   ;
       }

     if ( activosTipo.getActivoTipoOffSet() != null )
       {
         offSet = Sos.Val(activosTipo.getActivoTipoOffSet())                  ;
       }

     MongoCollection<Document> collection = mgDB.getCollection("ACTIVOSTIPO") ;
       if ( buscar != null  && !("".equals(sort)))
          {
            if ("ID".equals(sort))          { myWhereO.add(new Document("activoTipoId"         ,mgRegex));}
            if ("DESCRIPCION".equals(sort)) { myWhereO.add(new Document("activoTipoDescripcion",mgRegex));}
            if ("REGISTRO".equals(sort))    { myWhereO.add(new Document("registro"             ,mgRegex));}
          }
       else
          {
              myWhereO.add(new Document("activoTipoId"         ,mgRegex))          ;
              myWhereO.add(new Document("activoTipoDescripcion",mgRegex))          ;
          }

        if ("".equals(sort) )            { mgSort.append("activoTipoId", 1)         ;}
        if ("ID".equals(sort))           { mgSort.append("activoTipoId", 1)         ;}
        if ("DESCRIPCION".equals(sort))  { mgSort.append("activoTipoDescripcion", 1);}
        if ("REGISTRO".equals(sort))     { mgSort.append("registro",1)              ;}

        try
        {

          myWhereY.add(new Document("entorno",activosTipo.getActivoTipoEntorno())) ;

          mgQuery.append("$or" ,myWhereO)                                          ;
        //mgQuery.append("$and",myWhereY)                                          ;                                                       
          mgFields.append("_id",0)                                                 ;

         MongoCursor<Document> cursor = collection.find(mgQuery).projection(mgFields).sort(mgSort).limit(limite).skip(offSet).cursor() ;          while (cursor.hasNext())
            {
              activosTipoC = new ActivosTipoDTO()                                  ;
              data   = cursor.next()                                               ;

              activosTipoC.setActivoTipoId(data.getString("activoTipoId"))         ;
              activosTipoC.setActivoTipoDescripcion(data.getString("activoTipoDescripcion"));
              activosTipoC.setActivoTipoEntorno(data.getString("entorno"))         ;
              activosTipoC.setActivoTipoDigitador(data.getString("digitador"))     ;
              activosTipoC.setActivoTipoRegistro(data.getString("registro"))       ;
              activosTipoC.setActivoTipoTimeStamp(data.getString("timeStamp"))     ;

              gDato.add(activosTipoC)                                              ;

            }

          cursor.close()                                                           ;
          return(gDato)                                                            ;
    }
  catch(Exception e)
    {
      System.out.println("Error ActivoTipo Consultar : " + e.toString())           ;
      e.printStackTrace(System.out)                                                ;

      gDato.add(activosTipoC)                                                      ;
      return (gDato)                                                               ;
    }
 }

  //Borra documento(s) de una collection
  public boolean ActivosTipoBorrar(MongoDatabase mgDB,
                                ActivosTipoDTO activosTipo
                                )
   {

     MongoCollection<Document> collection = mgDB.getCollection("ACTIVOSTIPO")      ;

     Document mgQuery  = new Document()                                            ;

     ArrayList<Document> myWhereO = new ArrayList<Document>()                      ;
     ArrayList<Document> myWhereY = new ArrayList<Document>()                      ;

     myWhereO.add(new Document("registro",activosTipo.getActivoTipoRegistro()))    ;
     myWhereY.add(new Document("entorno" ,activosTipo.getActivoTipoEntorno()))     ;

     mgQuery.append("$or" ,myWhereO)                                               ;
  // mgQuery.append("$and",myWhereY)                                               ;                                                       

     try
        {
          DeleteResult resultado  = collection.deleteMany(mgQuery)                 ;
          long filasAfectadas     = resultado.getDeletedCount()                    ;

          if (filasAfectadas > 0)
            {
              return(true)                                                         ;
            }
          else
            {
              return(false)                                                        ;
            }

  }
  catch(Exception e)
        {

          System.out.println("Error ActivoTipo Borrar : " + e.toString())          ;
          e.printStackTrace(System.out)                                            ;

          return (false)                                                           ;
        }
   }

   //Modifica un documento de una collection
   public boolean ActivosTipoEditar(MongoDatabase mgDB,
                             ActivosTipoDTO activosTipo
                            )
   {

     MongoCollection<Document> collection = mgDB.getCollection("ACTIVOSTIPO")      ;

     Document data     = new Document()                                            ;
     Document mgUpdate = new Document()                                            ;
     Document mgQuery  = new Document()                                            ;

     ArrayList<Document> myWhereO = new ArrayList<Document>()                      ;
     ArrayList<Document> myWhereY = new ArrayList<Document>()                      ;

     myWhereO.add(new Document("registro",activosTipo.getActivoTipoRegistro()))    ;
     myWhereY.add(new Document("entorno",activosTipo.getActivoTipoEntorno()))      ;

     mgQuery.append("$or" ,myWhereO)                                               ;
   //mgQuery.append("$and",myWhereY)                                               ;                                                       

     data.append("activoTipoId"         , activosTipo.getActivoTipoId())           ;
     data.append("activoTipoDescripcion", activosTipo.getActivoTipoDescripcion())  ;
     data.append("digitador"             , activosTipo.getActivoTipoDigitador())   ;
     data.append("timeStamp"             , Sos.TimeStamp())                        ;

     mgUpdate.append("$set",data)                                                  ;

     try
        {

          UpdateResult resultado = collection.updateMany(mgQuery,mgUpdate)         ;
          long filasAfectadas    = resultado.getModifiedCount()                    ;

          if (filasAfectadas > 0)
            {
              return(true)                                                         ;
            }
          else
            {
              return(false)                                                        ;
            }
        }
     catch(Exception e)
        {

         System.out.println("Error ActivoTipo Editar : " + e.toString())           ;
         e.printStackTrace(System.out)                                             ;

         return (false)                                                            ;
       }
   }

   //Crea un nuevo documento en una collection
   public boolean ActivosTipoCrear(MongoDatabase mgDB,
                            ActivosTipoDTO activosTipo
                           )
   {

     MongoCollection<Document> collection = mgDB.getCollection("ACTIVOSTIPO")      ;
     Document data = new Document()                                                ;

        data.append("activoTipoId"          ,activosTipo.getActivoTipoId())        ;
        data.append("activoTipoDescripcion" ,activosTipo.getActivoTipoDescripcion()) ;
        data.append("entorno"               ,activosTipo.getActivoTipoEntorno())   ;
        data.append("digitador"             ,activosTipo.getActivoTipoDigitador()) ;
        data.append("registro"              ,activosTipo.getActivoTipoRegistro())  ;
        data.append("timeStamp"             ,Sos.TimeStamp())                      ;

        try
          {
            collection.insertOne(data)                                             ;
            return (true)                                                          ;
          }
        catch(Exception e)
          {

           System.out.println("Error ActivoTipo Crear : " + e.toString())          ;
           e.printStackTrace(System.out)                                           ;

           return (false)                                                          ;
         }
   }

}

=============================================

GestionHandlet.java

=============================================

package dwr.gestion  ;

/*                                                                                                                                         
   25/01/2021                                                                                                                              
*/

import java.io.*                    ;
import java.util.*                 ;
import java.text.*                ;
import java.math.*              ;
import java.security.MessageDigest ;

import com.mongodb.client.*;

public class GestionHandler
  {

       //     ACTIVOSTIPO                                                                                                                        


     public boolean ActivosTipoExiste(String DB,
                               ActivosTipoDTO activosTipo
                              )
       {
         MongoClient mongoClient = MongoClients.create()                  ;

         try
            {

          ActivosTipoDAO  ActivosTipoDAO   = new ActivosTipoDAO()     ;

           //En este punto el sistema abre una conexion con la DB , sobrela

           //la variable DB que se pasa como parametro desde el <scrip> frond-end 

           //en la variable usuarioDB de la variable JSON.


              MongoDatabase mgDB = ConexionMongo.Conectar( DB , mongoClient);

               //La variable mgDB estable la conexion la conxion y se pasacomo

              // coo para a los metodos , los cuales ya esencialmente son las definiciones

             // de los distintos procesos a ejectar mas la variables involucradas

             // todos siguiendo en general la misma estructura salvo algunos cambios

             // mas de forma que de fondo.

             boolean   existe = false                                    ;

              existe = ActivosTipoDAO.ActivosTipoExiste(mgDB,
                                          activosTipo
                                                        )                 ;

              mongoClient.close()                                         ;
              return existe                                               ;
            }
         catch (Exception e)
            {
             System.out.println("Error, activosTipo Existe: " + e.toString());
             e.printStackTrace(System.out)                                ;
              mongoClient.close()                                         ;
             return false                                                 ;
            }
       }
    public ActivosTipoDTO ActivosTipoRegistros(String DB,
                                    ActivosTipoDTO activosTipo
                                   )
       {
         MongoClient mongoClient = MongoClients.create()                     ;
         ActivosTipoDAO ActivosTipoDAO  = new ActivosTipoDAO()               ;
         ActivosTipoDTO activosTipoInfo = new ActivosTipoDTO()               ;

         try
            {

             MongoDatabase mgDB = ConexionMongo.Conectar( DB , mongoClient)  ;

              activosTipoInfo = ActivosTipoDAO.ActivosTipoRegistros(mgDB,
                                                  activosTipo
                                                 )                           ;

              mongoClient.close()                                            ;
              return activosTipoInfo                                         ;
            }
         catch (Exception e)
            {
             System.out.println("Error, activosTipo Conteo: " + e.toString());
             e.printStackTrace(System.out)                                   ;
             mongoClient.close()                                             ;
             return (activosTipoInfo)                                        ;
            }
       }
     public ActivosTipoDTO ActivosTipoConsultar(String DB,
                                  ActivosTipoDTO activosTipo
                                 )
       {
         MongoClient mongoClient = MongoClients.create()                     ;

         ActivosTipoDAO ActivosTipoDAO  = new ActivosTipoDAO()               ;
         ActivosTipoDTO activosTipoInfo = new ActivosTipoDTO()               ;

         try
            {

             MongoDatabase mgDB = ConexionMongo.Conectar( DB , mongoClient)  ;

             activosTipoInfo = ActivosTipoDAO.ActivosTipoConsultar(mgDB,
                                              activosTipo
                                             )                               ;

              mongoClient.close()                                            ;
             return (activosTipoInfo)                                        ;
            }
         catch (Exception e)
            {
             System.out.println("Error, activosTipo Info : " + e.toString()) ;
             e.printStackTrace(System.out)                                   ;
              mongoClient.close()                                            ;
             return (activosTipoInfo)                                        ;
            }
       }
         catch (Exception e)
            {
             System.out.println("Error, activosTipo Info : " + e.toString()) ;
             e.printStackTrace(System.out)                                   ;
              mongoClient.close()                                            ;
             return (activosTipoInfo)                                        ;
            }
       }
     public boolean ActivosTipoBorrar(String DB,
                               ActivosTipoDTO activosTipo
                              )
       {
         MongoClient mongoClient = MongoClients.create()                    ;
         boolean fueBorrado = false                                         ;

         try
            {

              ActivosTipoDAO ActivosTipoDAO = new ActivosTipoDAO()          ;
              MongoDatabase mgDB = ConexionMongo.Conectar( DB , mongoClient);

              fueBorrado = ActivosTipoDAO.ActivosTipoBorrar(mgDB,
                                              activosTipo
                                             )                            ;
              mongoClient.close()                                         ;
             return (fueBorrado)                                          ;
            }
         catch (Exception e)
            {
             System.out.println("Error, activosTipos Borrar:" + e.toString());
             e.printStackTrace(System.out)                                ;
              mongoClient.close()                                         ;
             return ( false)                                              ;
            }
       }
    public boolean ActivosTipoEditar(String DB,
                               ActivosTipoDTO activosTipo
                              )
       {
         MongoClient mongoClient = MongoClients.create()                  ;

         boolean fueEditado = false                                       ;

         try
            {

              ActivosTipoDAO ActivosTipoDAO     = new ActivosTipoDAO()    ;
              MongoDatabase mgDB  = ConexionMongo.Conectar( DB , mongoClient);

              fueEditado = ActivosTipoDAO.ActivosTipoEditar(mgDB,
                                              activosTipo
                                             )                            ;
              mongoClient.close()                                         ;
             return (fueEditado)                                          ;
            }
         catch (Exception e)
            {
             System.out.println("Error, activosTipo Editar: " + e.toString());
             e.printStackTrace(System.out)                                ;
             mongoClient.close()                                          ;
             return ( false)                                              ;
            }
       }
      public boolean ActivosTipoCrear(String DB,
                               ActivosTipoDTO activosTipo
                              )
       {
         MongoClient mongoClient = MongoClients.create()                  ;

         boolean fueCreada = false                                        ;

         try
            {

              ActivosTipoDAO ActivosTipoDAO  = new ActivosTipoDAO()       ;
              MongoDatabase mgDB = ConexionMongo.Conectar( DB , mongoClient);

              fueCreada = ActivosTipoDAO.ActivosTipoCrear(mgDB,
                                             activosTipo
                                            )                             ;


             mongoClient.close()                                          ;
             return (fueCreada)                                           ;
            }
         catch (Exception e)
            {
             System.out.println("error, activosTipo Crear : " + e.toString());
             e.printStackTrace(System.out)                                ;
             mongoClient.close()                                          ;
             return ( false)                                              ;
            }
       }

 

}

======================================================
Cuando se teng todo definido un script de compilacion podria ser;

javac -Xlint -cp  "/usr/local/tomcat/lib/bson-4.2.0-beta1.jar":/usr/local/tomcat/lib/mongodb-driver-core-4.2.0-beta1.jar":/usr/local/tomcat/lib/mongodb-d\
river-sync-4.2.0-beta1.jar": *.java

Observar que en este caso los jar deben existir en las carpeta mencionadas

de tomcat en el proceso javac en general en tomcat/lib




Comentarios

Entradas populares