snowblacksoul:
Fala Nicolas blz, cara como fazer no modo MVC?!
Você fala em tirar a classe do banco de dados e criar uma connectionfactory isso?!
acho que só faltou isso!! ou tem mais?!
Quase, snow!
Criar uma ConnectionFactory também, mas digo separar as coisas em camadas:
- Criar a camada de persistência:
1. Criar a classe de gerenciamento de conexões:
public class GerenciadorConexoes {
private GerenciadorConexoes instancia = new GerenciadorConexoes();
private Connection connection;
private GerenciadorConexoes() {
connection = null;
}
public static GerenciadorConexoes getInstance() {
return instancia;
}
public Connection recuperarConnection() {
if (connection == null) {
Class.forName("oracle.jdbc.OracleDriver");
connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl11g","system","11g");
connection.setAutoCommit(false);
}
return connection;
}
public void concluirOperacoes() {
connection.commit();
connection = null;
}
public void cancelarOperacoes() {
connection.rollback();
connection = null;
}
}
2. Criar uma classe de persistência de livros:
public class PersistenciaLivro {
public void adicionar(Livro livro) throws SQLException {
String sentenca = "insert into system.livros(isbn,titulo,edicao_num,ano_publicacao,descricao) values (?,?,?,?,?)";
Connection connection = GerenciadorConexoes.getInstance().recuperarConnection();
PreparedStatement statementInsert = connection.prepareStatement(sentenca);
statementInsert.setString(1, livro.getIsbn());
statementInsert.setString(2, livro.getTitulo());
statementInsert.setString(3, livro.getEdicao_num());
statementInsert.setString(4, livro.getAno_publicacao());
statementInsert.setString(5, livro.getDescricao());
statementInsert.execute();
statementInsert.close();
}
}
3. Criar uma classe de persistência de texto:
public class PersistenciaTexto {
public List<String> recuperarLinhasArquivo(String caminho) throws IOException {
File file = new File(caminho);
FileReader fileReader = new FileReader(file);
BufferedReader bufferedReader = new BufferedReader(fileReader);
List<String> linhasRecuperadas = new ArrayList<String>();
while (bufferedReader.ready()) {
linhasRecuperadas.add(bufferedReader.readLine());
}
return linhasRecuperadas;
}
}
4. Uma classe de serviços de livros:
public class ServicosLivro {
public List<Livro> converterStringsEmObjetos(List<String> linhas) {
List<Livro> livros = new ArrayList<Livro>();
for (String linha : linhas) {
String[] array= linha.split(";"); // separa os dados por seu delimitador...
Livro livro = new Livro();
livro.setIsbn(arrayLinha[0]);
livro.setTitulo(arrayLinha[1]);
livro.setEdicao_num(arrayLinha[2]);
livro.setAno_publicacao(arrayLinha[3]);
livro.setDescricao(arrayLinha[4]);
livros.add(livro);
}
return livros;
}
//FINALMENTE, O MÉTODO QUE FAZ CHAMARÁ OS OUTROS!
public void importarArquivoLivros(String caminho) throws IOException, SQLException {
PersistenciaLivro persistenciaLivro = new PersistenciaLivro();
PersistenciaTexto persistenciaTexto = new PersistenciaTexto();
List<String> linhasRecuperadas = persistenciaTexto.recuperarLinhasArquivo(caminho);
List<Livro> livros = this.converterStringsEmObjetos(linhasRecuperadas);
for (Livro livro : livros) {
persistenciaLivro.adicionar(livro);
}
}
public void concluirOperacoes() {
GerenciadorConexoes.getInstance().concluirOperacoes();
}
public void cancelarOperacoes() {
GerenciadorConexoes.getInstance().cancelarOperacoes();
}
}
6. E não pode faltar o Main:
public class Main {
public static void main(String[] args) {
ServicosLivro servicosLivro = new ServicosLivro();
try {
servicosLivro.importarArquivoLivros("C:\ArquivoImportacao.txt");
servicosLivro.concluirOperacoes();
}
catch (IOEception errIO) {
errIO.printStackTrace();
servicosLivro.cancelarOperacoes();
}
catch (SQLException errSQL) {
errSQL.printStackTrace();
servicosLivro.cancelarOperacoes();
}
}
}
Muitas classes, a primeira vista, não?
Mas, na hora de dar manutenção, de passar o código para outros, de adequar à padrões de arquitetura, será assim mesmo!
O que acha dessa ideia? Não fica tudo mais claro e separadinho?
Abraços!
