Test Foro de elhacker.net SMF 2.1

Hola. Buenas tardes, estoy haciendo un ejercicio con persistencia. Y tengo problemas para grabar los objetos en un archivo. Voy agregando los objetos de a uno, ya que tengo un menu. Cuando agrego el primer objeto se lee bien, pero cuando agrego el segundo ya no se lee ninguno. Nose que estoy haciendo mal

public class MiObjectOutputStream extends ObjectOutputStream{ //clase q hereda de objectoutputstream para no sobreescribir la cabecera

public void writeStreamHeader() {
//nada
}

public MiObjectOutputStream() throws IOException {
super();
}

public MiObjectOutputStream (FileOutputStream fileOutputStream) throws IOException {
// TODO Auto-generated constructor stub
super(fileOutputStream);
}

}


//Los metodos guardar y recuperar estan en otra clase

public void guardar (Jugador j) throws IOException {
File f= new File("jugador.objeto");
if( f.exists()){
MiObjectOutputStream salida= new MiObjectOutputStream(new FileOutputStream(f));
salida.writeObject(j);
salida.close();
} else {
ObjectOutputStream salida= new ObjectOutputStream(new FileOutputStream(f,true));
salida.writeObject(j);
salida.close();
}


}

public void recuperar() throws FileNotFoundException, IOException, EOFException, ClassNotFoundException {
ObjectInputStream entrada=null;
try{ entrada = new ObjectInputStream(new FileInputStream("jugador.objeto"));

while (true) {
Jugador j = ( Jugador) entrada.readObject();
System.out.println(j.getNombre());



}
} catch(IOException io){
} finally {
try {
entrada.close();
} catch (Exception exp) {
}


}

MOD: Etiqueta GeSHi

Usa GeShI


Para escribir objetos de manera binaria con ObjectInput/Output Stream, esta diseñada para escribir solo una vez socio, sino tendrias que reimplemantar una clase tu mismo.


/**
* @implSpec THREAD-SAFE
*  @autor rub'n
*/
@Value
@Builder
public class Persona implements Serializable {
    String nombre;
    String apellido;
    String correo;
}

/**
* @autor rub'n
*/
@Slf4j
public class ConObjectIOStream {

    private static final String RUTA_FICHERO = "./temporal.tmp";

    private ConObjectIOStream() {
        throw new IllegalAccessError("Constructor privado");
    }

    /**
     * Para leer desde el fichero
     *
     * @return List<Persona>
     */
    private static List<Persona> readFromFile() {
        final List<Persona> listaPersona = new CopyOnWriteArrayList<>();
        final Path pathAlimento = Paths.get(RUTA_FICHERO);
        if(pathAlimento.toFile().exists()) {
            try (final BufferedInputStream bin = new BufferedInputStream(Files.newInputStream(pathAlimento));
                 final ObjectInputStream ob = new ObjectInputStream(bin)) {

                while (Boolean.TRUE) {
                    synchronized (ConObjectIOStream.class) { //en caso de que readFrom se invoque desde un Thread()
                        final Object object = ob.readObject();
                        if (object instanceof Persona) {
                            listaPersona.add((Persona) object);
                        }
                    }
                }
                ob.reset();
            } catch (IOException | ClassNotFoundException e) {
                //no hacer nada EOFException
                log.error("Error al leer {}", e);
            }
        } else {
            log.error("Error al leer del fichero {}", pathAlimento.toFile());
        }

        return List.copyOf(listaPersona)
                .stream()
                .sorted(Comparator.comparing(Persona::getNombre))
                .collect(Collectors.toList());
    }

    /**
     * Para escribir en el fichero
     */
    private static void writePersonToTempFile(final Persona ...persona) {
        final Path pathTem = Paths.get(RUTA_FICHERO);
        try (final OutputStream out = Files.newOutputStream(pathTem, StandardOpenOption.CREATE);
             final BufferedOutputStream bos = new BufferedOutputStream(out);
             final ObjectOutputStream ob = new ObjectOutputStream(bos)) {

            synchronized (ConObjectIOStream.class) {
                Arrays.stream(persona)
                        .forEach((Persona p) -> writeObject(ob, p));
            }
            ob.reset();
        } catch (IOException e) {
            log.error("Error al escribir en archivo {} ", e);
        }
    }

    private static void writeObject(final ObjectOutputStream ob, final Persona persona) {
        try {
            ob.writeObject(persona);
        } catch (IOException e) {
            log.error("Error al escribir objecto {} ", e);
        }
    }

    public static void main(String[] args) {

        final Persona persona1 = Persona.builder()
                .nombre("ruben")
                .apellido("La muerte")
                .correo("rrara@gmail.com")
                .build();

        final Persona persona2 = Persona.builder()
                .nombre("El loco")
                .apellido("La locura")
                .correo("crazyGuy@gmail.com")
                .build();

        /*
         * Para escribir
         */
        ConObjectIOStream.writePersonToTempFile(persona1, persona2);

        /*
         * Leer
         */
        ConObjectIOStream.readFromFile()
                .forEach((Persona persona) -> log.info("Persona {}", persona));

    }

}