Java - Introducir datos en una base de datos con Java

 
Vista:

Introducir datos en una base de datos con Java

Publicado por Manuel Jesus (25 intervenciones) el 02/01/2020 10:32:02
Buenas! He creado una base de datos con 4 campos que serian:

 Almacenes:
o ID
o Nombre
o Ubicación.

 Productos
o ID
o Nombre
o Precio unitario

 Productos-Almaces
o ID_almacen
o ID_producto
o Stock

 Ventas
o ID_venta
o ID_producto
o ID_almacen
o Fecha_de_venta (año de venta)


Quisiera saber como podria, a traves de Java, realizar las siguientes consultas:

-Introducir 100 Productos. Numerados del 1 al 100, nombrados como
PRODUCTO_1,…,PRODUCTO_100, y con un precio unitario aleatorio entre 1 y 100€.

-Cada producto estará en dos almacenes aleatorio, con un stock aleatorio entre 1 y 10
unidades.

-1000 ventas. Numeradas del 1 al 1000, eligiendo un producto y un almacén aleatorio y
un año de venta entre 2015 y 2020.


Gracias anticipadas
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de pablo
Val: 814
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Introducir datos en una base de datos con Java

Publicado por pablo (224 intervenciones) el 02/01/2020 14:22:04
Hola Manuel Jesús, pues primero busca el jar correspondiente de acuerdo a la base de datos con la que estes trabajando, una vez lo tengas lo integras a tu proyecto y realizas un pool de conexiones. Y realizas tus respectivas consultas. Aquí te anexo un ejemplo para que te guíes más o menos de como lo podrías lograr.

http://www.chuidiang.org/java/mysql/EjemploJava.php

Cualquier cosa comentas.

Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Introducir datos en una base de datos con Java

Publicado por Manuel Jesus (25 intervenciones) el 02/01/2020 15:10:34
Principalmente tengo dudas en el 3er y 4to apartado. A la hora de introducir datos aleatorios. Podriaís orientarme? gracias
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de pablo
Val: 814
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Introducir datos en una base de datos con Java

Publicado por pablo (224 intervenciones) el 02/01/2020 17:00:32
Hola qué tal bueno eso lo puedes lograr de la siguiente manera una vez creada tu conexión por ejemplo:

1
2
3
Connection con = null;
Class.forName(sDriver).newInstance();
con = DriverManager.getConnection(sURL,"root","password");

Luego viene por lo menos un insert a una tabla

1
stmt = con.prepareStatement("INSERT INTO libros VALUES (?,?,?,?,?)");

luego los valores que deseamos introducir son colocados por el ? que será sustituido más adelante por la variable que deseas que sea insertada en la tabla

1
2
3
4
5
6
7
8
9
10
11
String sISBN = "84-9815-212-7";
String sTitulo = "Yo, Claudio";
String sDescripcion= "Supuesta autobiografía de Claudio...";
String sCategoria = "novela histórica";
int idAutor = 3;
 
stmt.setString(1,sISBN);
stmt.setInt(2,idAutor);
stmt.setString(3,sTitulo);
stmt.setString(4,sDescripcion);
stmt.setString(5,sCategoria);

Luego que tengas tus variables con el objeto stmt o el preparedStatement que creaste llamas a el método setString o setInt, setXXX donde XXX será el valor que necesitas insertar en tu base de datos, como este método recibe dos parámetros donde el número será la posición dada por los parentesis que allás definido en tu insert.

luego ejecutas la sentencia con:

1
stmt.executeUpdate();

Y listo verificas que los datos se hayan insertado correctamente en tu base de datos.

Cualquier duda, avisas.

Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

Introducir datos en una base de datos con Java

Publicado por Manuel Jesus (25 intervenciones) el 02/01/2020 19:07:52
Perfecto, y ya para nota, Si quisieramos hacer la consulta de que cada idAutor, tuviera dos titulos aleatorios, ¿ como lo realizarias? gracias

Es un poco lo que me faltaria en los apartados 3 y 4 de mi ejercicio. No consigo introducir datos aleatorios. Muchas gracias por todo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de pablo
Val: 814
Bronce
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Introducir datos en una base de datos con Java

Publicado por pablo (224 intervenciones) el 02/01/2020 19:19:00
Bueno podrías crear dos variables y con esas dos variables que tienes le pasas un número aleatorio que vaya del 1 al 100 con la librería Math.Random algo como:
1
(int) (Math.random()*10)  // Te devuelve un numero entre 0 y 10

Luego al crear tus dos variables le pasarías un select que sea algo como:
1
select * from productos where productos_id in(?,?)
Donde por supuesto el valor de las interrogante será el valor que hayas guardado las variables, y luego lo pasas como anteriormente te expliqué en el comentario de arriba.

De esa manera es la que se me ocurre a mi pero puede quizar existir otro camino más fácil que consigas a medida que lo vas programando.

Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.002
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Introducir datos en una base de datos con Java

Publicado por Billy Joel (594 intervenciones) el 02/01/2020 19:12:46
Cuantos almacenes hay?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Billy Joel
Val: 2.002
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

[SOLUCION] Introducir datos en una base de datos con Java

Publicado por Billy Joel (594 intervenciones) el 03/01/2020 04:33:48
Lo primero es lo primero, crear las tablas en la base de datos. Supongo que tienes una base de datos con usuario y password, Bueno así definí yo las tablas:
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
DROP TABLE IF EXISTS `m_almacenes`;
CREATE TABLE IF NOT EXISTS `m_almacenes` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nombre` varchar(50) COLLATE latin1_general_cs NOT NULL,
  `ubicacion` varchar(50) COLLATE latin1_general_cs NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=5 DEFAULT CHARSET=latin1 COLLATE=latin1_general_cs;
 
 
DROP TABLE IF EXISTS `m_productos`;
CREATE TABLE IF NOT EXISTS `m_productos` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `nombre` varchar(50) COLLATE latin1_general_cs NOT NULL,
  `precioUnitario` decimal(10,2) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=101 DEFAULT CHARSET=latin1 COLLATE=latin1_general_cs;
 
 
DROP TABLE IF EXISTS `m_productos_almacenes`;
CREATE TABLE IF NOT EXISTS `m_productos_almacenes` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `id_almacen` int(11) NOT NULL,
  `id_producto` int(11) NOT NULL,
  `stock` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=201 DEFAULT CHARSET=latin1 COLLATE=latin1_general_cs;
 
DROP TABLE IF EXISTS `m_ventas`;
CREATE TABLE IF NOT EXISTS `m_ventas` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `id_producto` int(11) NOT NULL,
  `id_almacen` int(11) NOT NULL,
  `fecha` int(11) NOT NULL COMMENT 'año',
  PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1001 DEFAULT CHARSET=latin1 COLLATE=latin1_general_cs;

Luego es delegar las tareas de conexión ejecución y consultas a la base de datos en una clase.
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
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
public class ConexionBD {
 
    private static ConexionBD myConnection;
    private static final String HOST = "localhost";
    private static final String CATALOG = "nombre_base_de_datos";
    private static final String USER = "usuario_db";
    private static final String PASSWORD = "clave_db";
    private Connection cn = null;
 
    /**
     * Constructor de la clase Se encarga de cargar el driver a la base de datos
     */
    private ConexionBD() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException ex) {
            ex.printStackTrace(System.out);
        }
    }
 
    /**
     * Devuelve una instancia de la clase
     *
     * @return
     */
    public static ConexionBD getInstance() {
        if (myConnection == null) {
            myConnection = new ConexionBD();
        }
        return myConnection;
    }
 
    public void openConnection() {
        try {
            cn = DriverManager.getConnection("jdbc:mysql://" + HOST + ":3306/" + CATALOG, USER, PASSWORD);
        } catch (SQLException ex) {
            ex.printStackTrace(System.out);
        }
    }
 
    public void closeConnection() {
        try {
            if (cn != null && !cn.isClosed()) {
                cn.close();
            }
        } catch (SQLException ex) {
            ex.printStackTrace(System.out);
        }
    }
 
    /**
     * Metodo utilizado para probar la conexion a la base de datos
     *
     * @return
     */
    public boolean testConnection() {
        boolean b = false;
        try {
            openConnection();
            b = cn != null && !cn.isClosed();
        } catch (SQLException ex) {
            System.out.println("Error al probar conexion");
            System.out.println(ex);
        } finally {
            try {
                if (cn != null) {
                    cn.close();
                }
            } catch (SQLException ex) {
                ex.printStackTrace(System.out);
            }
        }
        return b;
    }
 
    /**
     * Ejecuta un comando SQL
     *
     * @param sqlCommand
     * @return
     */
    public boolean executeSql(String sqlCommand) {
        return executeSql(sqlCommand, "");
    }
 
    /**
     * Ejecuta un comando a la base de datos con 1 parámetro
     *
     * @param sqlCommand
     * @param param
     * @return
     */
    public boolean executeSql(String sqlCommand, String param) {
        return executeSql(sqlCommand, new String[]{param});
    }
 
    /**
     * Ejecuta un comnado a la base de datos
     *
     * @param sqlCommand
     * @param params
     * @return
     */
    public boolean executeSql(String sqlCommand, String[] params) {
        PreparedStatement pst;
        int afectados = 0;
        try {
            openConnection();
            pst = cn.prepareStatement(sqlCommand);
            if (params != null && sqlCommand.contains("?")) {
                for (int i = 0; i < params.length; i++) {
                    pst.setObject(i + 1, params[i]);
                }
            }
            afectados = pst.executeUpdate();
            if (!pst.isClosed()) {
                pst.close();
            }
        } catch (SQLException ex) {
            System.out.println("Error al ejecutar sentencia: " + sqlCommand);
            System.out.println("Parametros: ");
            if (params != null) {
                for (String param : params) {
                    System.out.println(param);
                }
            }
            ex.printStackTrace(System.out);
        } finally {
            closeConnection();
        }
        return afectados > 0;
    }
 
    /**
     * Inserta un registro en la base de datos y devuelve el id generado por la
     * base de datos
     *
     * @param sqlCommand
     * @param params
     * @return
     */
    public Integer executeInsert(String sqlCommand, String[] params) {
        PreparedStatement pst;
        int key = -1;
        try {
            openConnection();
            pst = cn.prepareStatement(sqlCommand, PreparedStatement.RETURN_GENERATED_KEYS);
            if (params != null && sqlCommand.contains("?")) {
                for (int i = 0; i < params.length; i++) {
                    pst.setObject(i + 1, params[i]);
                }
            }
            if (pst.executeUpdate() > 0) {
                ResultSet rs = pst.getGeneratedKeys();
                if (rs.next()) {
                    key = rs.getInt(1);
                }
            }
            if (!pst.isClosed()) {
                pst.close();
            }
        } catch (SQLException ex) {
            System.out.println("Error al ejecutar sentencia: " + sqlCommand);
            System.out.println("Parametros: ");
            if (params != null) {
                for (String param : params) {
                    System.out.println(param);
                }
            }
            ex.printStackTrace(System.out);
        } finally {
            closeConnection();
        }
        return key;
    }
 
    /**
     * Ejecuta una consulta a la base de datos sin parámetros Devuelve un mapa
     * con los datos de la consulta. El mapa consta de dos elementos
     *
     * @param sqlCommand
     * @return
     */
    public List<String[]> executeQuery(String sqlCommand) {
        return executeQuery(sqlCommand, "");
    }
 
    /**
     * Ejecuta una consulta a la base de datos con 1 parámetro Devuelve un mapa
     * con los datos de la consulta. El mapa consta de dos elementos
     *
     * @param sqlCommand
     * @param param
     * @return
     */
    public List<String[]> executeQuery(String sqlCommand, String param) {
        return executeQuery(sqlCommand, new String[]{param});
    }
 
    /**
     * Ejecuta una consulta a la base de datos. Devuelve un mapa con los datos
     * de la consulta. El mapa consta de dos elementos
     *
     * @param sqlCommand
     * @param params
     * @return
     */
    public List<String[]> executeQuery(String sqlCommand, String[] params) {
        PreparedStatement pst;
        ResultSet rs;
        List<String[]> rows = null;
        try {
            openConnection();
            pst = cn.prepareStatement(sqlCommand);
            if (params != null && sqlCommand.contains("?")) {
                for (int i = 0; i < params.length; i++) {
                    pst.setObject(i + 1, params[i]);
                }
            }
            rs = pst.executeQuery();
            int cols = rs.getMetaData().getColumnCount();
            String[] row;
            rows = new ArrayList();
            while (rs.next()) {
                row = new String[cols];
                for (int i = 0; i < row.length; i++) {
                    row[i] = rs.getString(i + 1);
                }
                rows.add(row);
            }
            if (!pst.isClosed()) {
                pst.close();
            }
        } catch (SQLException ex) {
            System.out.println("Error al ejecutar query: " + sqlCommand);
            ex.printStackTrace(System.out);
        } finally {
            closeConnection();
        }
        return rows;
    }
}

Con esa clase ejecutamos los inserts.

Ahora vamos con la clase principal:
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
import java.util.Objects;
import java.util.Random;
 
public class Principal {
 
    static Integer nextIdProducto = 1;
 
    /**
     * Devuelve un número aleatorio entre los límites
     *
     * @param min
     * @param max
     * @return
     */
    public static Integer getRandomNumber(int min, int max) {
        return new Random().nextInt(max - min + 1) + min;
    }
 
    public static Producto getNewProducto() {
        int id = nextIdProducto;
        nextIdProducto++;
        String nombre = "Producto_" + id;
        Producto p = new Producto();
        p.setId(id);
        p.setNombre(nombre);
        p.setPrecioUnitario(Double.parseDouble(getRandomNumber(1, 100).toString()));
        return p;
    }
 
    public static void main(String[] args) {
        //Registramos los almacenes
        ConexionBD.getInstance().executeInsert("insert into m_almacenes (nombre, ubicacion) values (?,?)", new String [] {"Los Pueblos", "Juan Diaz"});
        ConexionBD.getInstance().executeInsert("insert into m_almacenes (nombre, ubicacion) values (?,?)", new String [] {"Maracana", "Via de los poetas"});
        ConexionBD.getInstance().executeInsert("insert into m_almacenes (nombre, ubicacion) values (?,?)", new String [] {"Westland Mall", "Vista Alegre"});
        ConexionBD.getInstance().executeInsert("insert into m_almacenes (nombre, ubicacion) values (?,?)", new String [] {"MARKET PLAZA", "LA CHORRERA"});
 
        //Registramos los productos
        for (int i = 0; i < 100; i++) {
            Producto p = getNewProducto();
            ConexionBD.getInstance().executeSql("insert into m_productos (id, nombre, `precioUnitario`) values (?,?,?)", new String[]{
                p.getId().toString(),
                p.getNombre(),
                p.getPrecioUnitario().toString()
            });
            Integer almacen_1 = getRandomNumber(1, 4);
            Integer almacen_2;
            do {
                almacen_2 = getRandomNumber(1, 4);
            } while (Objects.equals(almacen_2, almacen_1));
            //Registramos el producto en el almacen 1
            ConexionBD.getInstance().executeInsert("insert into m_productos_almacenes (id_almacen, id_producto, stock) values (?,?,?)", new String[]{
                almacen_1.toString(),
                p.getId().toString(),
                getRandomNumber(1, 10).toString()
            });
            //Registramos el producto en el almacen 2
            ConexionBD.getInstance().executeInsert("insert into m_productos_almacenes (id_almacen, id_producto, stock) values (?,?,?)", new String[]{
                almacen_2.toString(),
                p.getId().toString(),
                getRandomNumber(1, 10).toString()
            });
        }
 
        for (int i = 0; i < 1000; i++) {
            ConexionBD.getInstance().executeInsert("insert into m_ventas (id_producto, id_almacen, fecha) values (?,?,?)", new String[]{
                getRandomNumber(1, 100).toString(),
                getRandomNumber(1, 4).toString(),
                getRandomNumber(2015, 2020).toString()
            });
        }
    }
}

Y así queda resuelto el enunciado...
Saludos,
Billy Joel
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar