{"id":2852,"date":"2020-04-27T18:52:18","date_gmt":"2020-04-27T13:22:18","guid":{"rendered":"https:\/\/www.h2kinfosys.com\/blog\/?p=2852"},"modified":"2020-04-27T22:17:15","modified_gmt":"2020-04-27T16:47:15","slug":"crud-operations-db","status":"publish","type":"post","link":"https:\/\/www.h2kinfosys.com\/blog\/crud-operations-db\/","title":{"rendered":"CRUD Operations on DB"},"content":{"rendered":"

The abbreviation CRUD stands for four basic operations that can be done on persistent storage (create, read, update and delete).\u00a0 Also, these functions are mapped to standard HTTP methods. We are going to review CRUD operations on the database. All operations will be demonstrated on the MySQL database with the support of JDBC.<\/span><\/p>\n

JDBC (Java Database Connectivity<\/a>) is a part of the Java platform. JDBC provides us the possibility to connect from Java application any database (relational or non-relational). To be able to do this, JDBC API needs to utilize specific JDBC drivers.\u00a0<\/span><\/p>\n

As we will work with the MySQL database, we need to download the library with MySQL driver. It is mysql-connector-java-8.0.11.jar. The version of the jar-file can differ.\u00a0 The MySQL driver class name is com.mysql.jdbc.Driver.\u00a0<\/span><\/p>\n

Before starting with CRUD operations, we have to connect to MySQL, to create a database and create a database table.\u00a0<\/span><\/p>\n

Let’s create Java application that will do this for us:<\/span><\/span><\/em><\/p>\n

import<\/b> java.sql.Connection;<\/span>\r\nimport<\/b> java.sql.DriverManager;<\/span>\r\nimport<\/b> java.sql.SQLException;<\/span>\r\nimport<\/b> java.sql.Statement;<\/span>\r\n\r\npublic<\/b> class<\/b> InitDatabaseExample {<\/span>\r\n\r\npublic<\/b> static<\/b> void<\/b> main(String <\/span>args<\/span>[]) {<\/span>\r\ntry<\/b> {<\/span>\r\nConnection <\/span>connection<\/span>= DriverManager.<\/span>getConnection<\/span><\/i>\r\n(<\/span>\"jdbc:mysql:\/\/localhost\/?<\/span>  \u00a0 <\/span> serverTimezone=UTC&useSSL=false&user=root&password=root\"<\/span>);\u00a0<\/span>\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"We are successfully connected to\u00a0 the MySQL \u00a0 <\/span> server.\"<\/span>);<\/span>\r\nStatement <\/span>stmt<\/span>=<\/span>connection<\/span>.createStatement();<\/span>\r\nstmt<\/span>.executeUpdate(<\/span>\"CREATE DATABASE exampledb\"<\/span>);<\/span>\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"A new database with the name exampledb is\u00a0 <\/span> created.\"<\/span>);<\/span>\r\nstmt<\/span>.close();<\/span>\r\n\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"Let's create a new table!\"<\/span>);<\/span>\r\nstmt<\/span> = <\/span>connection<\/span>.createStatement();<\/span>\r\nString <\/span>sql<\/span> = <\/span>\"CREATE TABLE exampledb.USER (ID INT, NAME <\/span>  \u00a0 \u00a0 \u00a0 VARCHAR(50), \"<\/span>\r\n+ <\/span>\"EMAIL VARCHAR(45), CREATION_TIME DATE, PRIMARY <\/span>  \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 KEY (ID))\"<\/span>;<\/span>\r\nstmt<\/span>.execute(<\/span>sql<\/span>);<\/span>\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"The table is created successfully!\"<\/span>);<\/span>\r\nstmt<\/span>.close();<\/span>\r\n\r\n} <\/span>catch<\/b> (SQLException <\/span>e<\/span>) {<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLException: \"<\/span> + <\/span>e<\/span>.getMessage());<\/span>\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLState: \"<\/span> + <\/span>e<\/span>.getSQLState());<\/span>\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"VendorError: \"<\/span> + <\/span>e<\/span>.getErrorCode());<\/span>\r\n      }<\/span>\r\n\r\n    }<\/span>\r\n\r\n}<\/span><\/pre>\n
The output of current applications will be:<\/span><\/span><\/em><\/p>\n
We are successfully connected to the MySQL server.<\/span><\/p>\n
A new database with the name exampledb is created.<\/span><\/p>\n
Let’s create a new table!<\/span><\/p>\n
The table is created successfully!<\/span><\/p>\n
The table doesn’t have data for now. You can see the current state of our database and the table on the screenshot below:<\/span><\/p>\n
\"\"<\/p>\n
Create operation\u00a0<\/b><\/h2>\n
The create operation in a relational database is represented by the SQL statement INSERT. We will go ahead and write a code snippet to create a new User in our table. We will use a PreparedStatement object got from our Connection object. To insert values into the right columns, we will use the column’s index. It worth to remind that column indexing starts from 1.<\/span><\/p>\n
PreparedStatement provides various set methods for each data type. Here are some of them:<\/span><\/p>\n
setString(int parameterIndex, String x)
\n<\/span>setBoolean(int parameterIndex, boolean x)
\n<\/span>setDate(int parameterIndex, Date x)<\/span><\/p>\n
A setXXX() method have to correspond a type of column in the database table.<\/span><\/p>\n
Let’s look at our example:<\/span><\/span><\/em><\/p>\n
import<\/b> java.sql.Connection;<\/span>\r\n\r\nimport<\/b> java.sql.DriverManager;<\/span>\r\nimport<\/b> java.sql.PreparedStatement;<\/span>\r\nimport<\/b> java.sql.SQLException;<\/span>\r\nimport<\/b> java.sql.Date;<\/span>\r\n\r\npublic<\/b> class<\/b> CreationExample {<\/span>\r\n\r\npublic<\/b> static<\/b> void<\/b> main(String <\/span>args<\/span>[]) {<\/span>\r\n\r\ntry<\/b> {<\/span>\r\n\r\nConnection <\/span>connection<\/span>= DriverManager.<\/span>getConnection<\/span><\/i>\r\n\r\n(<\/span>\"jdbc:mysql:\/\/localhost:3306\/exampledb?<\/span> serverTimezone=UTC&useSSL=false&user=root&password=root\"<\/span>);\u00a0<\/span>\r\n\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"We are succesfully connected to the MySQL <\/span> server.\"<\/span>);<\/span>\r\n\r\nString <\/span>sql<\/span> = <\/span>\"INSERT INTO User (id, name, email, creation_time) <\/span> VALUES (?, ?, ?, ?)\"<\/span>;<\/span>\r\n\r\nPreparedStatement <\/span>statement<\/span> = <\/span>connection<\/span>.prepareStatement(<\/span>sql<\/span>);<\/span>\r\n\r\nstatement<\/span>.setInt(1, 1);<\/span>\r\n\r\nstatement<\/span>.setString(2, <\/span>\"TestUser\"<\/span>);<\/span>\r\n\r\nstatement<\/span>.setString(3, <\/span>\"testuser@gmail.com\"<\/span>);<\/span>\r\n\r\nstatement<\/span>.setDate(4, <\/span>new<\/b> Date(<\/span>new<\/b> java.util.Date().getTime()));<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nint<\/b> rowsInserted<\/span> = <\/span>statement<\/span>.executeUpdate();<\/span>\r\n\r\nif<\/b> (<\/span>rowsInserted<\/span> > 0) {<\/span>\r\n\r\n\u00a0 \u00a0 System.<\/span>out<\/i><\/b>.println(<\/span>\"A new user was inserted successfully!\"<\/span>);<\/span>\r\n\r\n}<\/span>\r\n\r\nstatement<\/span>.close();<\/span>\r\n\r\n} <\/span>catch<\/b> (SQLException <\/span>e<\/span>) {<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLException: \"<\/span> + <\/span>e<\/span>.getMessage());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLState: \"<\/span> + <\/span>e<\/span>.getSQLState());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"VendorError: \"<\/span> + <\/span>e<\/span>.getErrorCode());<\/span>\r\n\r\n    }<\/span>\r\n\r\n  }<\/span>\r\n\r\n}<\/span><\/pre>\n
 <\/p>\n
You probably found that we have changed the connection URL string in comparison with the previous example. We added the name of the database.<\/span><\/p>\n
The output of the application will be:<\/span><\/p>\n
We are successfully connected to the MySQL server.<\/span><\/p>\n
A new user was inserted successfully!<\/span><\/p>\n
 <\/p>\n
Read operation\u00a0<\/b><\/h2>\n
Now, we will look at data in our database table User. We are going to check if the new row was added and learn to work with a reading SQL statement . The read operation in a relational database is represented by the SQL statement SELECT. We can select all the data or just data from some particular columns.<\/span><\/p>\n
Here are two equal requests:[box type=”shadow” align=”” class=”” width=””]<\/span><\/p>\n
SELECT * FROM exampledb.user;<\/span><\/p>\n
SELECT user.ID, userNAME, user.EMAIL, user.CREATION_TIME FROM exampledb.user;[\/box]<\/span><\/p>\n
We can skip the database name from the SQL query in case we put the database name into the URL to connect to the MySQL server.\u00a0<\/span><\/p>\n
Let’s look at code example:<\/span><\/em><\/span><\/p>\n
package<\/b> concurrent;<\/span>\r\n\r\nimport<\/b> java.sql.Connection;<\/span>\r\n\r\nimport<\/b> java.sql.DriverManager;<\/span>\r\nimport<\/b> java.sql.PreparedStatement;<\/span>\r\nimport<\/b> java.sql.ResultSet;<\/span>\r\nimport<\/b> java.sql.SQLException;<\/span>\r\nimport<\/b> java.sql.Statement;<\/span>\r\nimport<\/b> java.sql.Date;<\/span>\r\n\r\npublic<\/b> class<\/b> ReadExample {<\/span>\r\npublic<\/b> static<\/b> void<\/b> main(String <\/span>args<\/span>[]) {<\/span>\r\ntry<\/b> {<\/span>\r\nConnection <\/span>connection<\/span>= DriverManager.<\/span>getConnection<\/span><\/i>\r\n(<\/span>\"jdbc:mysql:\/\/localhost:3306\/exampledb?<\/span> serverTimezone=UTC&useSSL=false&user=root&password=root\"<\/span>);\u00a0<\/span>\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"We are successfully connected to the MySQL <\/span> server.\"<\/span>);<\/span>\r\nString <\/span>sql<\/span> = <\/span>\"SELECT * FROM user\"<\/span>;<\/span>\r\nStatement <\/span>statement<\/span> = <\/span>connection<\/span>.createStatement();<\/span>\r\nResultSet <\/span>result<\/span> = <\/span>statement<\/span>.executeQuery(<\/span>sql<\/span>);<\/span>\r\n\r\nwhile<\/b> (<\/span>result<\/span>.next()){<\/span>\r\n\u00a0 \u00a0 <\/span>int<\/b> id<\/span> = <\/span>result<\/span>.getInt(1);<\/span>\r\n \u00a0 String <\/span>name<\/span> = <\/span>result<\/span>.getString(2);<\/span>\r\n\u00a0 \u00a0 String <\/span>email<\/span> = <\/span>result<\/span>.getString(<\/span>\"email\"<\/span>);<\/span>\r\n\u00a0 \u00a0 String <\/span>date<\/span> = <\/span>result<\/span>.getDate(4).toString();<\/span>\r\n\u00a0 \u00a0 String <\/span>output<\/span> = <\/span>\"User #%d: %s - %s - %s\"<\/span>;<\/span>\r\n\u00a0 \u00a0 System.<\/span>out<\/i><\/b>.println(String.<\/span>format<\/span><\/i>(<\/span>output<\/span>, <\/span>id<\/span>, <\/span>name<\/span>, <\/span>email<\/span>, <\/span> date<\/span>));<\/span>\r\n  }<\/span>\r\nstatement<\/span>.close();<\/span>\r\n} <\/span>catch<\/b> (SQLException <\/span>e<\/span>) {<\/span>\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLException: \"<\/span> + <\/span>e<\/span>.getMessage());<\/span>\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLState: \"<\/span> + <\/span>e<\/span>.getSQLState());<\/span>\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"VendorError: \"<\/span> + <\/span>e<\/span>.getErrorCode());<\/span>\r\n     }<\/span>\r\n   }<\/span>\r\n }<\/span><\/pre>\n
 <\/p>\n
The output of out code:<\/em><\/span>
\n<\/span>We are successfully connected to the MySQL server.
\n<\/span>User #1: TestUser – testuser@gmail.com \u2013 2020-04-20<\/span><\/p>\n
After the execution of our SQL query in MySQL Workbench.<\/span><\/p>\n
\"\"<\/p>\n
Let’s look one more time at the last code example. After the execution of the SQL select query, we are getting data to the ResultSet object. We used different getXXX methods to get a property with a corresponding type. Also, there is a possibility to use columns indexes and names. The last way to get a column value by name showed in our example on the email column.\u00a0<\/span><\/p>\n
Update operation\u00a0\u00a0\u00a0<\/b><\/h2>\n
To update data in a relational database we use the SQL statement UPDATE. We can update a single row or a group of rows, selected by some condition. We are going to use PreparedStatement object with the setXXX() methods, the same as we did in the case of creation. Let’s update just the user email for our single user TestUser:<\/span><\/p>\n
package<\/b> concurrent;<\/span>\r\n\r\nimport<\/b> java.sql.Connection;<\/span>\r\nimport<\/b> java.sql.DriverManager;<\/span>\r\nimport<\/b> java.sql.PreparedStatement;<\/span>\r\nimport<\/b> java.sql.ResultSet;<\/span>\r\nimport<\/b> java.sql.SQLException;<\/span>\r\nimport<\/b> java.sql.Statement;<\/span>\r\nimport<\/b> java.sql.Date;<\/span>\r\n\r\npublic<\/b> class<\/b> UpdateExample {<\/span>\r\n\r\npublic<\/b> static<\/b> void<\/b> main(String <\/span>args<\/span>[]) {<\/span>\r\n\r\ntry<\/b> {<\/span>\r\n\r\nConnection <\/span>connection<\/span>= DriverManager.<\/span>getConnection<\/span><\/i>\r\n\r\n(<\/span>\"jdbc:mysql:\/\/localhost:3306\/exampledb?<\/span> serverTimezone=UTC&useSSL=false&user=root&password=root\"<\/span>);\u00a0<\/span>\r\n\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"We are successfully connected to the MySQL <\/span> server.\"<\/span>);<\/span>\r\n\r\nString <\/span>sql<\/span> = <\/span>\"UPDATE User SET email=? WHERE name=?\"<\/span>;<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nPreparedStatement <\/span>statement<\/span> = <\/span>connection<\/span>.prepareStatement(<\/span>sql<\/span>);<\/span>\r\n\r\nstatement<\/span>.setString(1, <\/span>\"newEmail\"<\/span>);<\/span>\r\n\r\nstatement<\/span>.setString(2, <\/span>\"TestUser\"<\/span>);<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nint<\/b> rowsUpdated<\/span> = <\/span>statement<\/span>.executeUpdate();<\/span>\r\n\r\nif<\/b> (<\/span>rowsUpdated<\/span> > 0) {<\/span>\r\n\r\n\u00a0 \u00a0 System.<\/span>out<\/i><\/b>.println(<\/span>\"An existing user was updated <\/span> successfully!\"<\/span>);<\/span>\r\n\r\n}<\/span>\r\n\r\nstatement<\/span>.close();<\/span>\r\n\r\n} <\/span>catch<\/b> (SQLException <\/span>e<\/span>) {<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLException: \"<\/span> + <\/span>e<\/span>.getMessage());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLState: \"<\/span> + <\/span>e<\/span>.getSQLState());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"VendorError: \"<\/span> + <\/span>e<\/span>.getErrorCode());<\/span>\r\n\r\n    }<\/span>\r\n\r\n  }<\/span>\r\n  \r\n}<\/span><\/pre>\n
In this case, the index in the setters of the PreparedStatement is the order to insert values into the SQL query. If we had more than one user with the name TestUser, we would have the value of the rowsUpdated variable >1.<\/span><\/p>\n
The output of our code is:<\/span><\/span><\/em><\/p>\n
We are successfully connected to the MySQL server.
\n<\/span>An existing user was updated successfully!<\/span><\/p>\n
Let’s check if the email for our user was really updated in MySQL Workbench:<\/span><\/p>\n
\"\"<\/p>\n
Yes, we did this, the value was really updated.<\/span><\/p>\n
Delete operation<\/b><\/h2>\n
We can delete data from a relational database with the use of the SQL statement DELETE.<\/span><\/p>\n
Now we are going to delete our single record from the database and check from code if our User table is empty. With DELETE SQL operation we can delete a group of rows, grouped by some condition, and even all rows from a database table.<\/span><\/p>\n
package<\/b> concurrent;<\/span>\r\n\r\nimport<\/b> java.sql.Connection;<\/span>\r\nimport<\/b> java.sql.DriverManager;<\/span>\r\nimport<\/b> java.sql.PreparedStatement;<\/span>\r\nimport<\/b> java.sql.ResultSet;<\/span>\r\nimport<\/b> java.sql.SQLException;<\/span>\r\n\r\nimport<\/b> java.sql.Statement;<\/span>\r\nimport<\/b> java.sql.Date;<\/span>\r\n\r\npublic<\/b> class<\/b> DeleteExample {<\/span>\r\n\r\npublic<\/b> static<\/b> void<\/b> main(String <\/span>args<\/span>[]) {<\/span>\r\n\r\ntry<\/b> {<\/span>\r\n\r\nConnection <\/span>connection<\/span>= DriverManager.<\/span>getConnection<\/span><\/i>\r\n\r\n(<\/span>\"jdbc:mysql:\/\/localhost:3306\/exampledb?serverTimezone=UTC&useSSL=false&user=root&password=root\"<\/span>);\u00a0<\/span>\r\n\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"We are successfully connected to the MySQL server.\"<\/span>);<\/span>\r\n\r\nString <\/span>sql<\/span> = <\/span>\"DELETE FROM user WHERE name=?\"<\/span>;<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nPreparedStatement <\/span>statement<\/span> = <\/span>connection<\/span>.prepareStatement(<\/span>sql<\/span>);<\/span>\r\n\r\nstatement<\/span>.setString(1, <\/span>\"TestUser\"<\/span>);<\/span>\r\n\r\n\u00a0<\/span>\r\n\r\nint<\/b> rowsDeleted<\/span> = <\/span>statement<\/span>.executeUpdate();<\/span>\r\n\r\nif<\/b> (<\/span>rowsDeleted<\/span> > 0) {<\/span>\r\n\r\n\u00a0 \u00a0 System.<\/span>out<\/i><\/b>.println(<\/span>\"The user was deleted successfully!\"<\/span>);<\/span>\r\n\r\n}<\/span>\r\n\r\nstatement<\/span>.close();<\/span>\r\n\r\nsql<\/span> = <\/span>\"SELECT COUNT(*) AS total FROM user\"<\/span>;<\/span>\r\n\r\nStatement <\/span>st<\/span> = <\/span>connection<\/span>.createStatement();<\/span>\r\n\r\nResultSet <\/span>count<\/span> = <\/span>st<\/span>.executeQuery(<\/span>sql<\/span>);<\/span>\r\n\r\nif<\/b>(<\/span>count<\/span>.next() && (<\/span>count<\/span>.getInt(<\/span>\"total\"<\/span>) == 0)) {<\/span>\r\n\r\nSystem.<\/span>out<\/i><\/b>.println(<\/span>\"The User table is empty!\"<\/span>);<\/span>\r\n\r\n}<\/span>\r\n\r\nst<\/span>.close();<\/span>\r\n\r\n} <\/span>catch<\/b> (SQLException <\/span>e<\/span>) {<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLException: \"<\/span> + <\/span>e<\/span>.getMessage());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"SQLState: \"<\/span> + <\/span>e<\/span>.getSQLState());<\/span>\r\n\r\n\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0System.<\/span>out<\/i><\/b>.println(<\/span>\"VendorError: \"<\/span> + <\/span>e<\/span>.getErrorCode());<\/span>\r\n\r\n}<\/span>\r\n\r\n}<\/span>\r\n\r\n}<\/span><\/pre>\n
 <\/p>\n
The output of the application will be:<\/span><\/em><\/span><\/p>\n
We are successfully connected to the MySQL server.<\/span><\/p>\n
The user was deleted successfully!
\n<\/span>The User table is empty!<\/span><\/p>\n
So, we reviewed CRUD operations with the support of the JDBC. Nowadays, there are a lot of frameworks that make our life easier. They can map classes for database schemas, generate all the basic CRUD operations, control transactions. The most popular frameworks for Java are the Java Persistence API, and Spring Data Java Persistence API.\u00a0<\/span><\/p>\n
The main idea is to create simple classes with fields, getters, setters. They are called entities. With the use of annotations, you need to map them to database tables (classes have to correspond tables, fields have to correspond columns). The database relationships between tables are also showing with annotations in entities. All persistence operations exist in the DAO(Data Access Object) layer or Repositories. The basic operations are usually generated by a framework, other you need to add on your own, but it looks simpler than to write just with the support of the JDBC.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
The abbreviation CRUD stands for four basic operations that can be done on persistent storage (create, read, update and delete).\u00a0 Also, these functions are mapped to standard HTTP methods. We are going to review CRUD operations on the database. All operations will be demonstrated on the MySQL database with the support of JDBC. JDBC (Java […]<\/p>\n","protected":false},"author":1,"featured_media":2903,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[42],"tags":[602,601,605,603,604],"class_list":["post-2852","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-tutorials","tag-create-operation","tag-crud-operations","tag-delete-operation","tag-read-operation","tag-update-operation"],"_links":{"self":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2852","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/comments?post=2852"}],"version-history":[{"count":0,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/posts\/2852\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media\/2903"}],"wp:attachment":[{"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/media?parent=2852"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/categories?post=2852"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.h2kinfosys.com\/blog\/wp-json\/wp\/v2\/tags?post=2852"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
We the result of that execution with MySQL Workbench<\/a>. If you had it opened before code execution, you need to reconnect to DBMS. After this, your database with one table will appear.<\/span><\/p>\n