Oi, fiz um programa que salva uma tabela com dados de coisas que já assisti, tem uma coluna para o código do conteúdo, outra para o nome, outra para a temporada e outra para os episódios. Tudo isso é salvo com banco de dados (MySQL), gostaria de saber se há alguma forma de salvar os arquivos em algum diretório ou algo parecido, pois é muito ruim ter que sempre abrir o banco de dados para ver o programa e também se torna inacessível para alguma outra pessoa que queira utilizar, se alguém puder me ajudar já agradeço.
Você pode usar a serialização:
Mas é melhor usar o sqlite, pois a serialização é sensível à atualização do código fonte.
1 curtida
Serialização é sensível à atualização de código???
Depende. Pra que serve esse seu programa? É só um programa de brinquedo ou vc vai vendê-lo? Tem alguma utilidade real? Há inúmeras opções, desde gravar um arquivo de texto cru ou distribuir o SGBD com o instalador. Explica melhor aí o que vc pretende fazer com seu programa, aí fica mais fácil dar um norte.
Melhor então usar Excel ou Planilha do Google. Nem precisa perder tempo criando e mantendo esse programa.
Se ele adicionar um novo atributo na classe a ser serializada isso implicará em um InvalidClassException quando tentar ler a serialização salva antes da modificação, por isso a serialização é sensível à manutenção do código.
Não senhor. Se for feito direito, não. Eu provo para você.
Copia o código abaixo, compila e executa. Não remova os comentários. A classe Foo vai ser serializada e deserializada.
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
*
* @author David
*/
public class Serializacao {
public static class Foo implements Serializable {
private static final long serialVersionUID = 1;
private int x;
//private int y;
public Foo( int x ) {
this.x = x;
}
}
public static void main( String[] args )
throws FileNotFoundException, IOException, ClassNotFoundException {
salvar();
carregar();
}
private static void salvar() throws FileNotFoundException, IOException {
Foo f = new Foo( 1 );
try ( ObjectOutputStream os = new ObjectOutputStream( new FileOutputStream( "foo" ) ) ) {
os.writeObject( f );
}
}
private static void carregar() throws FileNotFoundException, IOException, ClassNotFoundException {
try ( ObjectInputStream is = new ObjectInputStream( new FileInputStream( "foo" ) ) ) {
Foo f = (Foo) is.readObject();
System.out.println( "x: " + f.x );
//System.out.println( "y: " + f.y );
}
}
}
Agora, no mesmo arquivo, substitui o conteúdo por esse aqui, compila e executa. Não mexa nos comentários. A classe Foo está diferente, mas o arquivo serializado é da versão antiga. O código abaixo vai carregar o arquivo de serialização que tem a “versão antiga” da classe, mas para uma classe “nova”. Deu erro? Não. Pq foi indicada a versão da serialização da classe.
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
*
* @author David
*/
public class Serializacao {
public static class Foo implements Serializable {
private static final long serialVersionUID = 1;
private int x;
private int y;
public Foo( int x ) {
this.x = x;
}
}
public static void main( String[] args )
throws FileNotFoundException, IOException, ClassNotFoundException {
//salvar();
carregar();
}
private static void salvar() throws FileNotFoundException, IOException {
Foo f = new Foo( 1 );
try ( ObjectOutputStream os = new ObjectOutputStream( new FileOutputStream( "foo" ) ) ) {
os.writeObject( f );
}
}
private static void carregar() throws FileNotFoundException, IOException, ClassNotFoundException {
try ( ObjectInputStream is = new ObjectInputStream( new FileInputStream( "foo" ) ) ) {
Foo f = (Foo) is.readObject();
System.out.println( "x: " + f.x );
System.out.println( "y: " + f.y );
}
}
}
Outro caso em que não haverá erro ao alterar os membros de instância é inserir membros transientes. Da forma que você disse vc simplesmente ignorou esses dois fatos, afirmando que qq alteração em membros vai dar problema não foi? Claro, membros de classe (static) também não são serializados, por motivos óbvios.
Esta certo, é esta linha que mantém a consistência da serialização.
De fato eu não a usava.