Salvataggio di oggetti nel database

Elenco completo dei tipi di dati JDBC

Oltre ai tipi di dati che conosci, JDBC ti consente di lavorare con molti tipi di dati nativi per il DBMS. Di seguito elencherò le tipologie e le funzioni per ottenerli:

Abbiamo già considerato i tipi primitivi. Proviamo ora a lavorare con gli oggetti.

Tipo di dati BLOB

Se vuoi salvare qualche oggetto nel database, il modo più semplice per farlo è usare il tipo BLOB SQL. JDBC ha la sua controparte chiamata Blob.

BLOB è l' acronimo di Binary Large Object . Viene utilizzato per memorizzare un array di byte. Il tipo Blob in JDBC è un'interfaccia e puoi inserire (e ricevere) dati al suo interno in due modi:

• Utilizzo di InputStream
• Utilizzo di un array di byte

Esempio: la colonna numero 3 contiene il tipo BLOB:

Statement statement = connection.createStatement();
    ResultSet results = statement.executeQuery("SELECT * FROM user");
    results.first();

    Blob blob = results.getBlob(3);
    InputStream is = blob.getBinaryStream();

Per creare il tuo oggetto Blob, devi utilizzare la funzione createBlob() . Esempio:

String insertQuery = “INSERT INTO images(name, image) VALUES (?, ?)”;
PreparedStatement statement = connection.prepareStatement(insertQuery);

// Create a Blob object and get an OtputStream from it to write data to it
Blob blob = connection.createBlob();

// Populate the Blob with data...
OutputStream os = blob.setBinaryStream(1);

// Passing Blob as query parameter
statement.setBlob(2, blob);
statement.execute();

Esistono due modi per popolare un BLOB con i dati. Il primo è tramite OutputSteam :

Path avatar = Paths.get("E:\\images\\cat.jpg");
OutputStream os = blob.setBinaryStream(1);
Files.copy(avatar, os);

E il secondo - attraverso il riempimento di byte:

Path avatar = Paths.get("E:\\images\\cat.jpg");
byte[] content = Files.readAllBytes(avatar);
blob.setBytes(1, content);

Salvataggio di un oggetto Java in un database

Abbiamo imparato come salvare oggetti binari nel database: array di byte, flussi di byte e così via. E gli oggetti Java? Come salviamo un oggetto Java in un database?

Supponiamo di avere una classe Java Employee che descrive un dipendente di un'azienda:

public class Employee {
    public Integer id;
    public String name;
    public String occupation;
    public Integer salary;
    public Date joinDate;
}

Come possiamo salvare un oggetto di questa classe nel database usando JDBC?

In effetti, sai già tutto ciò che devi sapere. Per prima cosa devi creare una tabella nel database che corrisponda a questa classe. Ad esempio, questo:

CREATE TABLE employee {
    id INT PRIMARY KEY NOT NULL,
    name VARCHAR(100),
    occupation VARCHAR(100),
    salary INT,
    join_date DATE
}

E ora scriviamo il codice che aggiungerà alla base un oggetto della nostra classe Employee :

public static boolean addEmployee(Connection connection, Employee employee) throws Exception {
    	// Create and prepare a query to insert data into the table
    	String insertQuery = "INSERT INTO employee(name, occupation, salary, join_date ) VALUES (?, ?, ?, ?)";
    	PreparedStatement statement = connection.prepareStatement(insertQuery);

    	// Populate the query with data from the Employee object
    	statement.setString(1, employee.name);
    	statement.setString(2, employee.occupation);
    	statement.setInt(3, employee.salary);
    	statement.setDate(4, employee.joinDate);

    	// Execute our query and it returns true if a new row has been added
    	int count = statement.executeUpdate();
    	return count > 0;
    }

Semplice e chiaro. Il metodo funzionerà alla grande.

Lettura di un oggetto Java da un database

Abbiamo imparato come scrivere un oggetto nel database, ora scriviamo il codice per leggere l'oggetto dal database. Iniziamo con il codice che legge un oggetto dal database tramite il suo ID:

public static Employee getEployeeById(Connection connection, int id) throws Exception {
    	// Create and prepare a query to get an employee from the table
    	PreparedStatement statement = connection.prepareStatement("SELECT * FROM employee WHERE id = ?");
    	statement.setInt(1, id);

    	// Execute our query and it returns null if there are no rows in the query result
    	ResultSet results = statement.executeQuery();
    	if (!results.first())
        	return null;

    	// Populate the Employee object with the data from the ResultSet
    	Employee employee = new Employee();
    	employee.id = results.getInt(1);
    	employee.name = results.getString(2);
    	employee.occupation = results.getString(3);
    	employee.salary = results.getInt(4);
    	employee.joinDate = results.getDate(5);
    	return employee;
}

E se non abbiamo bisogno di un oggetto, ma di diversi? Tale richiesta è anche facile da scrivere. Prendiamo tutti i dipendenti della nostra azienda:

public static List<Employee> getAllEployees(Connection connection) throws Exception {
	// Create and execute a query to get employees from the table
	Statement statement = connection.createStatement();
	ResultSet results = statement.executeQuery("SELECT * FROM employee");

	ArrayList<Employee> list = new ArrayList<Employee>();
	while (results.next()) {
        // Populate the Employee object with the data from the current row of the ResultSet
	        Employee employee = new Employee();
	        employee.id = results.getInt(1);
	        employee.name = results.getString(2);
	        employee.occupation = results.getString(3);
	        employee.salary = results.getInt(4);
	        employee.joinDate = results.getDate(5);

	        list.add(employee);
	}
	return list;
}

A proposito, se ci sono molti di questi metodi, in ognuno di essi dovrai scrivere lo stesso codice per convertire la stringa ResultSet in un oggettodipendente. Quindi questo codice può essere spostato in un metodo separato.

Questo può essere particolarmente utile se la classe Employee contiene campi complessi come Enum, InputStream o riferimenti ad altri oggetti che vogliamo anche memorizzare nel database.