Código de Java - Servidor de archivos y bases de datos

Imágen de perfil
Val: 493
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Servidor de archivos y bases de datosgráfica de visualizaciones


Java

Publicado el 16 de Julio del 2018 por Rafael Angel
1.502 visualizaciones desde el 16 de Julio del 2018. Una media de 35 por semana
Permite registrar texto de acuerdo a sus campos, sin importar si el texto tiene saltos de linea o no.
Es seguro y robusto.
Pero se publica aquí con el gusto de compartirselo a usted para que lo modifique, experimente, para que lo mejore.
Para que se base en esto para crear algo mejor.
Es lindo tener el propio servidor de bases de datos personalizado, asi fue como empezaron las grandes empresas de bases de datos.
No baya a creer que de una vez lanzaron algo potentisimo como lo que tienen ahora.
Comenzaron con prototipos muy similares a este.
Lo se porque en mi aprendizage vi los prototipos de servidores de bases de datos al estilo SQLServer y otros.
Ademas, asi no tendrá usted que estar migrando su base de datos cada sierto tiempo o incluso exponerse que el dia de mañana te cobren por el moton de informacion en una base de datos ya que las licencias; se esta poniendo de moda que las licencias expiran cada año.
Eso es feo...
Por eso es mejor que cada uno empise a crear e investigar como crear servidores de bases de datos y mejor aun, basados en el camino ya andado por los grandes.

Requerimientos

NetBeans 8.2 preferiblemente.

1.0

Actualizado el 19 de Julio del 2018 (Publicado el 16 de Julio del 2018)gráfica de visualizaciones de la versión: 1.0
1.503 visualizaciones desde el 16 de Julio del 2018. Una media de 35 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

Esta version se usará tanto para exponerla aqui como para crear más aplicasiones en casa.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
//Autor: rafael Angel Montero Fernández.
//Fecha: Domingo 15 de Julio del 2018.
//
//El siguente codigo permite crear aplicasiones al estilo de bases de datos personalizadas.
//Ya no tendras que preocuparte si actualizan al servidor y tu base de datos debe migrar.
//¿Por qué mejor no crear la de uno mismo personalmente?
//No lleva interfaz grafica porque no se necesita. Solo se esta publicando lo que usted pueda integrar a su proyecto.
//Sin embargo mejor si le hago una interfaz grafica.
//pero para ello el registro debe ser más simplificado.
 
//Necesarios para escribir archivos
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import javax.swing.JOptionPane;
 
//Necesario para leer archivos
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import javax.swing.JOptionPane;
 
//Necesario para crear el registro.
import java.util.ArrayList;
import javax.swing.table.DefaultTableModel;
 
/**
Y ahora los objetos class y sus objetos internos.
*/
 
abstract class Continium extends Leer_archivo
{
    /**
     *Permite guardar las lineas de registros.
     */
    protected String mRegistros[]={};
    /**
     * Permite guardar los datos ceparados de acuerdo a sus propiedades.
     */
    protected String mPropiedades[]={};
    private Escribir_archivo escribir=null;
 
    public Continium(String nuevo_nombre_de_archivo)
    {
 
        escribir=new Escribir_archivo(nuevo_nombre_de_archivo);
        this.setNombre_de_archivo(nuevo_nombre_de_archivo);
        leer_archivo();
    }
    /**
     * Sirve para proporcionar a algun modelo los datos o el objeto almacenado en alguna lista.
     * @param id Indice del registro, cuando se escribe. 
     */
    protected abstract void escribiendo_un_registro(int id);
    /**
     * 
     * @param id Indice de la propiedad, depende de como las haya enumerado usted.
     * @return Retorna los datos de esa propiedad pero dentro de escribir...
     */
    public abstract String getDatos_de_la_propiedad(int id);
    /**
     * Escribe informacion en un archivo.
     * @param nueva_cantidad_de_registros Una cantidad para identificar cuantos registros hay en su objeto.
     * Recuerde proporcionarlo con length-1 o con size()-1.
     * @param nueva_cantidad_de_propiedades Cuantas propiedades tiene su objeto modelo.
     * Recuerde contar desde cero o sea si su objeto tiene 4 propiedades entonces proporcione el numero 3.
     */
    public void escribir(int nueva_cantidad_de_registros, int nueva_cantidad_de_propiedades)
    {
        String datos="";
        for(int i=0; i<=nueva_cantidad_de_registros; i++)
        {
            this.escribiendo_un_registro(i);
            int id=0;
            while(id<=nueva_cantidad_de_propiedades)
            {
                datos+= getDatos_de_la_propiedad(id) + this.CEPARADOR_DE_PROPIEDADES;
                id++;
            }
            datos+=this.CEPARADOR_DE_REGISTROS;
        }
        escribir.escribir_archivo(datos);
    }
    /**
     * Por si quiere hacer que el archivo actue como una base de datos.
     * Use esta constante para ceparar los registros.
     */
    public final String CEPARADOR_DE_REGISTROS=" endRegistro ";
    /**
     * Por si quiere hacer que el archivo actue como una base de datos.
     * Use esta constante para ceparar las propiedades o etiquetas de los datos.
     */
    public final String CEPARADOR_DE_PROPIEDADES=" endpropiedad ";
 
    @Override
    public void recorriendo_datos(String datos) {
 
    }
 
    /**
     * 
     * @param propiedad Datos de la propiedad correspondiente al indice.
     * @param id Numero de indice de la propiedad.
     */
    public abstract void recorriendo_propiedades(String propiedad, int id);
    /**
     * Se repita hasta que se recorran todos los registros.
     * @param max Se carga con el macimo de las propiedades, en el procedimiento recorrido_finalizado.
     */
    public abstract void cantidad_de_propiedades(int max);
 
    /**
     * 
     * @param max Se carga con el macimo de los registros, en el procedimiento recorrido_finalizado.
     */
    public abstract void cantidad_de_registros(int max);
 
    @Override
    public void recorrido_finalizado(String todo_el_bloque_de_datos) {
        mRegistros=todo_el_bloque_de_datos.split(this.CEPARADOR_DE_REGISTROS);
        this.cantidad_de_registros(mRegistros.length);
        for(int i=0; i<=mRegistros.length-1; i++)
        {
            mPropiedades=mRegistros[i].split(this.CEPARADOR_DE_PROPIEDADES);
            this.cantidad_de_propiedades(mPropiedades.length);
            int id=0;
            while(id<=mPropiedades.length-1)
            {
                try{
                    this.recorriendo_propiedades(mPropiedades[id], id);
                }catch(Exception ex){}
                id++;
            }
        }
        this.recorrido_terminado();
    }
 
    /**
     * Sucede al final de recorrido_finalizado.
     */
    public abstract void recorrido_terminado();
}
 
/////////////////////////////////////////////////////
 
abstract class Leer_archivo
{
    /**
     * Le da la extencion al archivo, a mi preferencia .txt
     */
    private final String EXTENCION_DE_ARCHIVO=".txt";
    private File flArchivo;
    private String Ruta_del_archivo="";
    //private FileDialog fdAbrir;
    private FileReader frArchivo =null;
    private BufferedReader bwLector=null;
    private String mDatos[];
    private String nombre_de_archivo=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
     * Evento del class, sucede cuando se recorren los datos en leer_archivo().
     * Cada llamada recupera una linea de datos. En este caso sería un bloque entero de datos por linea.
     * @param datos Bloque entero de datos.
     */
    public abstract void recorriendo_datos(String datos);
    /**
     * Sucede al finalizar el recorrido de los datos en leer_archivo().
     * Uselo es más efectivo.
     * @param todo_el_bloque_de_datos Se pasa por parametro todos los datos compilados en la lectura.
     */
    public abstract void recorrido_finalizado(String todo_el_bloque_de_datos);
 
    public Leer_archivo()
    {
        //fdAbrir=new FileDialog(fdAbrir, "Abrir archivo", FileDialog.LOAD);
//        Ruta_del_archivo="";
        try{ frArchivo =new FileReader("Archivo"+ this.EXTENCION_DE_ARCHIVO);}catch(IOException ex){/*mensaje de error por si se quiere verificar que sucede*/}
       setNombre_de_archivo("Archivo");
    }//constructor.
 
    public Leer_archivo(String nombre_de_archivo)
    {
        this.setNombre_de_archivo(nombre_de_archivo+ this.EXTENCION_DE_ARCHIVO);
        try{ frArchivo =new FileReader(this.getNombre_de_archivo());}catch(FileNotFoundException ex){/*mensaje de error por si se quiere verificar que sucede*/}
    }//constructor.
 
    public String leer_archivo()
    {
        String respuesta="";
        flArchivo=new File(this.getNombre_de_archivo() + this.EXTENCION_DE_ARCHIVO);
        if(flArchivo.exists()==true)
        {
            //Este bloque de codigo obligatoriamente debe ir dentro de un try.
            try{
                frArchivo=new FileReader(flArchivo);
                bwLector=new BufferedReader (frArchivo);
            }catch(Exception e){}
 
            String linea_de_texto="";
            try{
                while ((linea_de_texto=bwLector.readLine())!=null)
                {
                    this.recorriendo_datos(linea_de_texto);
                    respuesta+=linea_de_texto+"\n";//Se le pone "\n" al final porque el codigo lo abre pero omitiendo los saltos de liena, entonces, deben volverse a escribir los saltos de linea.
                }
            }catch(Exception ex){}
            this.recorrido_finalizado(respuesta);
            try{
                bwLector.close();//Se cierra el archivo.
            }catch(Exception c){}
        //Este condicional no afecta en nada la forma de guardar el archivo pero si es bueno usarlo para no borrar un trabajo previo.
 
            //respuesta+="El archivo ya existia y ha sido sobreescrito posiblemente con informacion diferente. \nEn la direccion: " +  flArchivo.getPath( ) ;
        }//if
        else
        {
            JOptionPane.showMessageDialog(null, "El archivo "+ this.getNombre_de_archivo() + this.EXTENCION_DE_ARCHIVO + " no existe.");
        }
        return respuesta;
    }
 
 
    public String []getList_de_datos()
    {
        return mDatos;
    }//get
 
    public ArrayList<String> getRegistros()
    {
        //De esta manera se evita escribir codigo extra en el class formulario.
        //Se crea un ArrayList local
        ArrayList<String> rsRespuesta=new ArrayList<String>();
        //Se recorre mDatos.
        //i<=mDatos.length-2 para no agregar el ultimo elemento que esta en blanco.
        for (int i=0; i<=mDatos.length-2; i++)
        {
            rsRespuesta.add(mDatos[i]);//Se carga el ArrayList local con los datos del vector mDatos.
        }//for
 
        return rsRespuesta;
    }//get
 
    public void setNombre_de_archivo(String nuevo_nombre_de_archivo)
    {
    /* //Propiedad para guardar la direccion del archivo.*/
        nombre_de_archivo=  nuevo_nombre_de_archivo;//Debe escribir un valor aqui.
    }//setDireccion
    public String getNombre_de_archivo()
    {
    /*//Propiedad para guardar la direccion del archivo.*/
        return nombre_de_archivo;
    }//getDireccion	
}
 
////////////////////////////////////////////
 
class Escribir_archivo
{
    /**
     * Le da la extencion al archivo, a mi preferencia .txt
     */
    private final String EXTENCION_DE_ARCHIVO=".txt";
    private File file_Archivo;
    private String nombre_de_archivo="";
    private BufferedWriter bwEscritor;
    private FileWriter fwArchivo_en_el_que_escribir;
    //private FileDialog fdGuardar;
    private String vDireccion=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
 
    public Escribir_archivo()
    {
        //fdGuardar=new FileDialog(fdGuardar, "Guardar como", FileDialog.SAVE);
        nombre_de_archivo="";
        file_Archivo=new File("Archivo"+EXTENCION_DE_ARCHIVO);
    }//Constructor
 
    public Escribir_archivo(String nuevo_nombre_de_archivo)
    {
        nombre_de_archivo=nuevo_nombre_de_archivo;
        file_Archivo=new File(nombre_de_archivo+EXTENCION_DE_ARCHIVO);
        this.setNombre_de_archivo(nombre_de_archivo);
    }//Constructor
 
    /**
     *  Escribe datos en un archivo de texto.
     * @param texto_a_guardar Datos que se guardarán en el archivo.
     * @return Retorna informacion relacionada con las acciones tomadas para guardar el archivo.
     */ 
    public String escribir_archivo(String texto_a_guardar)
    {
        String mTextos[]=texto_a_guardar.split("\n");//Se detecta end_rs, se va colocando en el vector.
        file_Archivo=new File(nombre_de_archivo + this.EXTENCION_DE_ARCHIVO);
        try{
            //Este bloque de codigo obligatoriamente debe ir dentro de un try.
            fwArchivo_en_el_que_escribir=new FileWriter(file_Archivo);//De momento se deja hasta aqui, listo para escribir, se escribe en el momento de dar la orden.
            for (int i=0; i<=mTextos.length-1;i++)
            {
                //Se va escribiendo cada linea en el archivo de texto.
                fwArchivo_en_el_que_escribir.write(mTextos[i] + "\r\n" );//"\r\n" significa enter y retorno de carro.
            }//for
            //Este metodo escribe el archivo en el disco duro.
            bwEscritor=new BufferedWriter(fwArchivo_en_el_que_escribir);
            bwEscritor.close();//Se cierra el archivo.		
        }catch(Exception ex){JOptionPane.showMessageDialog(null,ex.getMessage());}
        String respuesta="";
        //Este condicional no afecta en nada la forma de guardar el archivo pero si es bueno usarlo para no borrar un trabajo previo.
        if(file_Archivo.exists())
        {
            respuesta="El archivo ya existia y ha sido sobreescrito posiblemente con informacion diferente. \nEn la direccion: " +  file_Archivo.getPath( ) ;
        }//if
        else
        {
            respuesta="El archivo ha sido creado exitosamente.\nEn la direccion: " +  file_Archivo.getPath( ) ;
        }//else*/
        return respuesta;
    }//escribir_archivo
 
    /**
     * Propiedad para guardar la direccion del archivo.
     * @param nuevo_nombre_de_archivo Un texto que represente una url o el nombre del archivo.
     */
    public void setNombre_de_archivo(String nuevo_nombre_de_archivo)
    {
        vDireccion=  nuevo_nombre_de_archivo;//Debe escribir un valor aqui.
    }//setDireccion
    /**
     * Propiedad para guardar la direccion del archivo.
     * @return Retorna la direccion donde se guardan los archivos.
     */
    public String getNombre_de_archivo()
    {
        return vDireccion;
    }//getDireccion	
}
 
/////////////////////////////////////////////////////
 
interface Rs<R>
{
 
 
 
    /**
     * 
     * @param nuevo Nuevo objeto a ser agregado.
     */
    public void agregar(R nuevo);
 
    /**
    * 
    * @param nuevo El codigo del producto pasado por parametro.
    * @return Busca la informacion, la encuentra y retorna true. No la encuentra retorna false.
    */
    public R buscar(String nuevo);
    /**
    * Elimina el registrado de acuerdo a la ultima busqueda realizada.
     * @param nuevo
    */
    public void eliminar(String nuevo);
    /**
    * 
    * @return Retorna un objeto DefaultTableModel cargado de datos para mostrarlos en una tabla.
    */
    public DefaultTableModel getReporte();
 
    /**
     * 
     * @param nuevo Un objeto con los datos actualizados para modificar un registro existente.
     */
    public void modificar(R nuevo);
 
    /**
     * 
     * @return El total de registros del objeto.
     */
    public int getTotal_de_registros();
 
    /**
     * Se puede usar en un for.
     * Recorre el ArrayList... devolviendo un objeto a la vez.
     * @param id Un numero que represente el indice de algun registro.
     * @return Retorna un objeto con datos.
     */
    public R get(int id);
}
 
///////////////////////////////////////////////////
//En esta parte va un pequeño ejemplo acerca de como implementarlo.
//Bueno ni tan pequeño porque es un poco grande pero servirá para visualizar todas las funcionalidades del codigo.
 
class Examen
{
 
    public final String EXAMEN="Examen";
    public final String PROFESOR="Profesor";
    public final String AULA="Aula";
    public final String PABELLON="Pabellon";
    public final String DIA="Dia";
    public final String HORA="Hora";
 
    public Examen()
    {
        this.setExamen("");
        this.setFecha("");
        this.setHora("");
        this.setPabellon("");
        this.setAula("");
        this.setProfesor("");
    }
 
    public Examen(String nuevo_Nombre_del_examen, String nuevo_Dia, String nuevo_Hora, String nuevo_Pabellon, String nuevo_Numero_de_aula, String nuevo_Nombre_del_profesor)
    {
        this.setExamen(nuevo_Nombre_del_examen);
        this.setFecha(nuevo_Dia);
        this.setHora(nuevo_Hora);
        this.setPabellon(nuevo_Pabellon);
        this.setAula(nuevo_Numero_de_aula);
        this.setProfesor(nuevo_Nombre_del_profesor);
    }
 
    private String vNombre_del_examen=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
    */
    public void setExamen(String nuevo_Nombre_del_examen)
    {
        vNombre_del_examen=  nuevo_Nombre_del_examen;//Debe escribir un valor aqui.
    }//setNombre_del_examen
    /**
    *            
     * @return 
    */
    public String getExamen()
    {
        return vNombre_del_examen;
    }//getNombre_del_examen
 
    private String vNombre_del_profesor=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
     * @param nuevo_Nombre_del_profesor
    */
    public void setProfesor(String nuevo_Nombre_del_profesor)
    {
        vNombre_del_profesor=  nuevo_Nombre_del_profesor;//Debe escribir un valor aqui.
    }//setNombre_del_profesor
    /**
    *            
     * @return 
    */
    public String getProfesor()
    {
        return vNombre_del_profesor;
    }//getNombre_del_profesor
 
    private String vNumero_de_aula=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
     * @param nuevo_Numero_de_aula
    */
    public void setAula(String nuevo_Numero_de_aula)
    {
        vNumero_de_aula=  nuevo_Numero_de_aula;//Debe escribir un valor aqui.
    }//setNumero_de_aula
    /**
    *            
     * @return 
    */
    public String getAula()
    {
        return vNumero_de_aula;
    }//getNumero_de_aula
 
    private String vPabellon=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
     * @param nuevo_Pabellon
    */
    public void setPabellon(String nuevo_Pabellon)
    {
        vPabellon=  nuevo_Pabellon;//Debe escribir un valor aqui.
    }//setPabellon
    /**
    *            
     * @return 
    */
    public String getPabellon()
    {
        return vPabellon;
    }//getPabellon
 
    private String fecha=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
     * @param nuevo_Dia
    */
    public void setFecha(String nueva_fecha)
    {
        fecha=  nueva_fecha;//Debe escribir un valor aqui.
    }//setDia
    /**
    *            
     * @return 
    */
    public String getFecha()
    {
        return fecha;
    }//getDia
 
    private String vHora=""; //Esta variable puede ser pasada al encavezado del class o quedarse aqui.
    /**
    *            
     * @param nuevo_Hora
    */
    public void setHora(String nuevo_Hora)
    {
        vHora=  nuevo_Hora;//Debe escribir un valor aqui.
    }//setHora
    /**
    *            
     * @return 
    */
    public String getHora()
    {
        return vHora;
    }//getHora
}
 
//El registro.
 
class Examenes extends Continium implements Rs<Examen>
{
    /**
     * 
     */
    public Examenes()
    {
        super("Examenes");
        this.leer_archivo();
    }
 
    private Examen un_examen=new Examen();
    @SuppressWarnings("unchecked")
    private ArrayList<Examen> rsExamenes=new ArrayList();
 
    @Override
    public void recorriendo_propiedades(String propiedad, int id) {
//        System.out.println("\nId de la propiedad " + id + "\nDatos=" + propiedad);
        switch(id)
        {
            case 0:
                un_examen.setExamen(propiedad);
                break;
            case 1:
                un_examen.setFecha(propiedad);
                break;
            case 2:
                un_examen.setHora(propiedad);
                break;
            case 3:
                un_examen.setPabellon(propiedad);
                break;
            case 4:
                un_examen.setAula(propiedad);
                break;
            case 5:
                un_examen.setProfesor(propiedad);
                this.rsExamenes.add(un_examen);
                un_examen=new Examen();
                break;
        }
    }
 
    @Override
    public void cantidad_de_propiedades(int max) {
//        System.out.println("Cantidad de propiedades " + max);
    }
 
    @Override
    public void cantidad_de_registros(int max) {
//        System.out.println("Cantidad de registros " + max);
    }
 
    @Override
    public void recorrido_terminado() {
//        System.out.println("Finalizó el recorrido de datos\n/////////////////////////////");
    }
 
    @Override
    public void agregar(Examen nuevo) {
        if(buscar(nuevo.getExamen()).getExamen().equals("")==true)
        {
            rsExamenes.add(nuevo);
        }
        else
        {
//            System.out.println("No se pudo agregar.");
        }
    }
 
    @Override
    public Examen buscar(String nuevo) {
        for(int i=0; i<=rsExamenes.size()-1; i++)
        {
            if (rsExamenes.get(i).getExamen().equalsIgnoreCase(nuevo)==true)
            {
                return rsExamenes.get(i);
            }
        }
        return new Examen();
    }
 
    @Override
    public void eliminar(String nuevo) {
        for(int i=0; i<=rsExamenes.size()-1; i++)
        {
            if (rsExamenes.get(i).getExamen().equalsIgnoreCase(nuevo)==true)
            {
                rsExamenes.remove(i);
            }
        }
    }
 
    @Override
    public DefaultTableModel getReporte() {
        DefaultTableModel dtmModelo=new DefaultTableModel();
        String etiquetas_de_columnas[]={this.un_examen.EXAMEN, un_examen.DIA, un_examen.HORA, un_examen.PABELLON, un_examen.AULA, un_examen.PROFESOR};
        String mExamen[]=new String[this.rsExamenes.size()], mDia[]=new String[this.rsExamenes.size()], mHora[]=new String[this.rsExamenes.size()], mPabellon[]=new String[this.rsExamenes.size()], mAula[]=new String[this.rsExamenes.size()], mProfesor[]=new String[this.rsExamenes.size()];
        for (int i=0; i<=this.rsExamenes.size()-1; i++)
        {
            mExamen[i]=rsExamenes.get(i).getExamen();
            mDia[i]=rsExamenes.get(i).getFecha();
            mHora[i]=rsExamenes.get(i).getHora();
            mPabellon[i]=rsExamenes.get(i).getPabellon()+"";
            mAula[i]=rsExamenes.get(i).getAula();
            mProfesor[i]=rsExamenes.get(i).getProfesor();
        }
        dtmModelo.addColumn(etiquetas_de_columnas[0], mExamen);
        dtmModelo.addColumn(etiquetas_de_columnas[1], mDia);
        dtmModelo.addColumn(etiquetas_de_columnas[2], mHora);
        dtmModelo.addColumn(etiquetas_de_columnas[3], mPabellon);
        dtmModelo.addColumn(etiquetas_de_columnas[4], mAula);
        dtmModelo.addColumn(etiquetas_de_columnas[5], mProfesor);
        return dtmModelo;
    }
 
    @Override
    public void modificar(Examen nuevo) {
        this.eliminar(nuevo.getExamen());
        this.agregar(nuevo);
    }
 
    @Override
    public int getTotal_de_registros() {
        return this.rsExamenes.size();
    }
 
    @Override
    public Examen get(int id) {
        return rsExamenes.get(id);
    }
    /**
     *  @return Retorna los datos en un formato plano capaz de ser leídos en un reporte no cuadriculado.
     * Pero si al estilo de una hoja de texto.
     */
    @Override
    public String toString()
    {
        String bloque_de_datos="";
        for(int i=0; i<=this.rsExamenes.size()-1; i++)
        {
//            bloque_de_datos+= rsExamenes.get(i).getExamen() + this.CEPARADOR_DE_PROPIEDADES + rsExamenes.get(i).getFecha() + this.CEPARADOR_DE_PROPIEDADES + rsExamenes.get(i).getHora() + this.CEPARADOR_DE_PROPIEDADES + rsExamenes.get(i).getPabellon() + this.CEPARADOR_DE_PROPIEDADES + rsExamenes.get(i).getAula() + this.CEPARADOR_DE_PROPIEDADES + rsExamenes.get(i).getProfesor() + this.CEPARADOR_DE_PROPIEDADES + this.CEPARADOR_DE_REGISTROS;
              bloque_de_datos+="Examen: " +  rsExamenes.get(i).getExamen() + "\nDia: " + rsExamenes.get(i).getFecha() + "\nHora: " + rsExamenes.get(i).getHora() + "\nPabellon: " + rsExamenes.get(i).getPabellon() + "\nAula: " + rsExamenes.get(i).getAula() + "\nprofesor: " + rsExamenes.get(i).getProfesor() + "\n\n\n";
        }
        return bloque_de_datos;
    }
 
    public void guardar_en_disco()
    {
        this.setNombre_de_archivo("Examenes");
        this.escribir(this.rsExamenes.size()-1, 5);
    }
 
    @Override
    public String getDatos_de_la_propiedad(int id) {
        switch(id)
        {
            case 0:
                return un_examen.getExamen();
            case 1:
                return un_examen.getFecha();
            case 2:
                return un_examen.getHora();
            case 3:
                return un_examen.getPabellon();
            case 4:
                return un_examen.getAula();
            case 5:
                return un_examen.getProfesor();
        }
        return "";
    }
 
    @Override
    protected void escribiendo_un_registro(int id) {
        un_examen=this.rsExamenes.get(id);
    }
}
 
//Un pequeño main para demostrar que funciona.
/**
Comentar que a lo largo de los años he ido conociendo acerca del funcionamiento de las bases de datos.
Los motores de servidores de bases de datos, lo cual me ha dado ideas y conocimientos suficientes como para crear mi propio servidor de bases de datos.
Se que el lector y muchas personas pueden crear codigos mucho más superiores y por una razon u otra no pueden hacerlos publicos.
Una muy dura es la razon del egoismo, pero el egoismo regresa porque no podrá ser visto por otros que lo puedan mejorar y republicar.
Ademas, otra razon es, ordenes de la empresa o coorporacion que proiben que sus empleados publiquen cualquier codigo, incluso de hechos por ellos mismos.
En mi caso no pertenesco a ninguna empresa ni me interesa pertenecer, asi que con gusto publico mis investigaciones, porque eso regresa.
Quizas alguien con mucho más habilidades podrá basarse en esto para crear algo realmente marabilloso.

El archivo se escribirá en la raíz del proyecto.

*/
 
public class Principal
    {
        private Examen un_examen=new Examen();
        private Examenes rsExamenes=new Examenes();
 
        public static void main(String args [])
        {
            un_examen=new Examen("Matematicas", "lunes 16 de julio del 2018", "9:00am", "2", "4A", "Yerico");
            rsExamenes.agregar(un_examen);
            un_examen=new Examen("Estadistica", "lunes 16 de julio del 2018", "1:00pm", "4", "1A", "Karina");
            rsExamenes.agregar(un_examen);
            System.out.println("Reporte\n" + rsExamenes.toString());
            rsExamenes.guardar_en_disco();
            rsExamenes.leer_archivo();
            System.out.println("Reporte despues de la lectura del archivo\n" + rsExamenes.toString());
        }
    }



Comentarios sobre la versión: 1.0 (0)


No hay comentarios
 

Comentar la versión: 1.0

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios
Es necesario revisar y aceptar las políticas de privacidad

http://lwp-l.com/s4717
Revisar política de publicidad