Para criarmos uma conexão, crie uma nova aplicação Java, sem classe principal. E nas bibliotecas, entre com o botão direito e adicione a biblioteca do Driver JDBC do MYSQL, que é um jar baixado daqui: http://www.java2s.com/Code/Jar/c/Downloadcommysqljdbc515jar.htm
Crie também um pacote com o nome connection e dentro dela, uma classe com o nome ConnectionFactory.
Esse é o código básico da classe:
package connection;
public class ConnectionFactory {
private static final String DRIVER = "com.mysql.jdbc";
private static final String URL = "jdbc:mysql://localhost:3306/dbloja";
private static final String USER = "root";
private static final String PASS = "";
}
Na parte DRIVER, você coloca o nome do local que estiver a classe DRIVER, no caso, com.mysql.jdbc, dentro da biblioteca de Driver Mysql.
Na parte URL, você coloca a porta do MYSQL e o nome do banco. Atenção pra documentação do tipo de banco de dados, já que acada um usa um nome de conexão diferente, no caso, usamos jdbc:mysql
Nas partes USER e PASS, login e senha do banco.
PS: Caso use o PostgreSQL, importe a biblioteca do Driver JDBC do PostgreSQL (geralmente já incluída no Netbeans, mas também pode ser baixada aqui: https://jdbc.postgresql.org/download/), e coloque o código assim:
private static final String DRIVER = "org.postgresql.jdbc";
private static final String URL = "jdbc:postgresql://localhost:5432/dbloja";
private static final String USER = "postgres";
private static final String PASS = "admin"; // A senha configurada
E no caso do SQLite, coloque a biblioteca jar baixando ela aqui: https://github.com/xerial/sqlite-jdbc/releases, e coloque o código assim:
private static final String DRIVER = "org.sqlite.jdbc";
private static final String URL = "jdbc:sqlite:dbloja.db3"; // Pode estar numa pasta também
Para criarmos a conexão, temos que usar um método que pegará essa conexão, da classe Connection (deverá importar java.sql.Connection, tudo será usado do sql, preste atenção). Esse será o código básico:
public class ConnectionFactory {
private static final String DRIVER = "com.mysql.jdbc";
private static final String URL = "jdbc:mysql://localhost:3306/dbloja";
private static final String USER = "root";
private static final String PASS = "";
public static Connection getConnection() { // Importar java.sql
Class.forName(DRIVER);
}
}
O código completo do getConnection fica assim:
public static Connection getConnection() {
try {
return DriverManager.getConnection(URL, USER, PASS); // Não deixe o Class.forName aqui, tirar USER e PASS caso use SQLite. Importar java.sql
}
catch(SQLException ex) { // Importar java.sql
throw new RuntimeException(ex);
}
}
Agora, criaremos abaixo, um método void para fechar a conexão, na verdade, serão três, com sobrecarga e invocação de outros métodos, veja o primeiro abaixo:
public static void closeConnection(Connection con) {
if(con != null) {
try {
con.close();
}
catch(SQLException ex) {
System.err.println("ERRO: " + ex.getMessage()); // Esse imprime em vermelho!
}
}
}
Esse é o código completo da classe:
package connection;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
// Isso define os dados pra conexão:
public class ConnectionFactory {
private static final String DRIVER = "com.mysql.jdbc";
private static final String URL = "jdbc:mysql://localhost:3306/dbloja";
private static final String USER = "root";
private static final String PASS = "";
// Isso cria a conexão:
public static Connection getConnection() { // Importar java.sql.Connection
try {
return DriverManager.getConnection(URL, USER, PASS); // Importar
}
catch(SQLException ex) {
throw new RuntimeException(ex);
}
}
// Isso fecha a conexão:
public static void closeConnection(Connection con) {
if(con != null) {
try {
con.close();
}
catch(SQLException ex) {
System.err.println("ERRO: " + ex.getMessage()); // Esse imprime em vermelho!
}
}
}
public static void closeConnection(Connection con, PreparedStatement stmt) { // Importar java.sql.PreparedStatement
if(stmt != null) {
try {
stmt.close();
}
catch(SQLException ex) {
System.err.println("ERRO: " + ex.getMessage());
}
}
closeConnection(con); // Invocação do primeiro método, que fecha a tal conexão.
}
public static void closeConnection(Connection con, PreparedStatement stmt, ResultSet rs) { // Importar java.sql.ResultSet
if(rs != null) {
try {
rs.close();
}
catch(SQLException ex) {
System.err.println("ERRO: " + ex.getMessage());
}
}
closeConnection(con, stmt); // Invocação do segundo método, que fecha a tal conexão.
}
}
PS: Ao compilar um programa Java com Banco de Dados, assegure-se que a pasta lib estará junta dentro da pasta do arquivo executável Java, já que dentro da lib tem as bibliotecas jar que farão a conexão com o banco de dados. Uma mesma biblioteca de uma pasta lib pode ser compartilhada com inúmeros aplicativos, desde que utilizem o mesmo tipo de banco de dados e estejam no caminho certo. Verifique se a sintaxe Java 8 está selecionada, mesmo se estiver usando um JDK superior.
Para essa parte, crie um pacote denominado model.bean, e nela crie uma classe com o nome Categoria, com esse código:
package model.bean;
public class Categoria {
private int id;
private String descricao;
// Ambos os categorias são construtores, com sobrecarga:
public Categoria() {
}
public Categoria(String descricao) {
this.descricao = descricao;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
}
No mesmo pacote, crie a classe produto, com esse código:
package model.bean;
public class Produto {
private int id;
private String descricao;
private int qtd;
private double valor;
private Categoria cate;
// Também tem sobrecarga nos construtores:
public Produto() {
}
public Produto(String descricao, int qtd, double valor, Categoria cate) {
this.descricao = descricao;
this.qtd = qtd;
this.valor = valor;
this.cate = cate;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public int getQtd() {
return qtd;
}
public void setQtd(int qtd) {
this.qtd = qtd;
}
public double getValor() {
return valor;
}
public void setValor(double valor) {
this.valor = valor;
}
public Categoria getCate() {
return cate;
}
public void setCate(Categoria cate) {
this.cate = cate;
}
}
Crie um novo pacote denominado model.dao, e uma classe com o nome CategoriaDAO.
Basicamente, seria isso:
package model.dao;
import connection.ConnectionFactory;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import model.bean.Categoria;
public class CategoriaDAO {
private Connection con = null; // Importar
public CategoriaDAO() {
con = ConnectionFactory.getConnection(); // Isso faz a conexão, importe connection.ConnectionFactory
}
public boolean save(Categoria cate) { // Importar model.bean.Categoria
String sql = "insert into categoria (descricao) values (?)";
PreparedStatement stmt = null; // Importar;.
stmt = con.prepareStatement(sql); // Circundar com try catch
}
}
Esse é o código completo:
package model.dao;
import connection.ConnectionFactory;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import model.bean.Categoria;
public class CategoriaDAO {
private Connection con = null; // Importar
public CategoriaDAO() throws SQLException {
con = ConnectionFactory.getConnection(); // Isso faz a conexão, importe connection.ConnectionFactory
}
public boolean save(Categoria cate) { // Importar model.bean.Categoria
String sql = "insert into categoria (descricao) values (?)";
PreparedStatement stmt = null; // Importar.
try {
stmt = con.prepareStatement(sql);
stmt.setString(1, cate.getDescricao());
stmt.executeUpdate(); // Isso é responsável pelo insert, update e delete no banco.
return true;
}
catch(SQLException ex) {
System.err.println("Erro: " + ex);
return false;
}
finally { // Isso fecha a conexão
ConnectionFactory.closeConnection(con, stmt);
}
}
}
PS: Nos comandos SQL do Java, o conteúdo a ser inserido no banco é representado pelo ponto de interrogação. Isso são consultas preparadas, para prevenir SQL Injection.