Objecten opslaan in de database

Volledige lijst met JDBC-gegevenstypen

Naast de gegevenstypen die u kent, kunt u met JDBC werken met veel native gegevenstypen voor het DBMS. Hieronder zal ik de typen en de functies om ze te krijgen opsommen:

We hebben al primitieve typen overwogen. Laten we nu proberen met objecten te werken.

BLOB-gegevenstype

Als u een object in de database wilt opslaan, is de eenvoudigste manier om dit te doen het SQL BLOB-type te gebruiken. JDBC heeft zijn tegenhanger genaamd Blob.

BLOB staat voor Binary L arge Object . Het wordt gebruikt om een ​​reeks bytes op te slaan. Het Blob-type in JDBC is een interface en u kunt er op twee manieren gegevens in plaatsen (en ontvangen):

• InputStream gebruiken
• Een reeks bytes gebruiken

Voorbeeld: kolom nummer 3 bevat het type BLOB:

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

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

Om uw eigen Blob-object te maken, moet u de functie createBlob() gebruiken . Voorbeeld:

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();

Er zijn twee manieren om een ​​Blob met gegevens te vullen. De eerste is via OutputSteam :

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

En de tweede - door te vullen met bytes:

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

Een Java-object opslaan in een database

We hebben geleerd hoe we binaire objecten in de database kunnen opslaan: byte-arrays, bytestreams, enzovoort. Hoe zit het met Java-objecten? Hoe slaan we een Java-object op in een database?

Laten we zeggen dat we een Employee Java-klasse hebben die een medewerker van een bedrijf beschrijft:

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

Hoe kunnen we een object van deze klasse opslaan in de database met JDBC?

Eigenlijk weet je al alles wat je moet weten. Eerst moet u een tabel in de database maken die overeenkomt met deze klasse. Bijvoorbeeld deze:

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

En laten we nu de code schrijven die een object van onze Employee- klasse aan de basis zal toevoegen:

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;
    }

Eenvoudig en duidelijk. De methode zal geweldig werken.

Een Java-object uit een database lezen

We hebben geleerd hoe we een object naar de database kunnen schrijven, laten we nu de code schrijven om het object uit de database te lezen. Laten we beginnen met de code die een object uit de database leest op basis van zijn 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;
}

En als we niet één object nodig hebben, maar meerdere? Zo'n verzoek is ook gemakkelijk te schrijven. Laten we alle medewerkers van ons bedrijf:

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;
}

Trouwens, als er veel van dergelijke methoden zijn, dan moet je in elk ervan dezelfde code schrijven voor het converteren van de ResultSet- string naar een objectmedewerker. Deze code kan dus naar een aparte methode worden verplaatst.

Dit kan met name handig zijn als de klasse Employee complexe velden bevat, zoals Enum, InputStream of verwijzingen naar andere objecten die we ook in de database willen opslaan.