MySQL Connector/J: A JDBC Driver for MySQL
If you are developing a Java application that needs to interact with a MySQL database, you might be wondering how to do it. One of the most popular and easy ways is to use MySQL Connector/J, a JDBC driver that allows Java programs to communicate with MySQL servers. In this article, we will explain what MySQL Connector/J is, why you should use it, how to download and install it, how to use it to connect and query a MySQL database, and how to troubleshoot some common errors and solutions.
What is MySQL Connector/J and why use it?
MySQL Connector/J is a Java library that allows Java applications to communicate with MySQL databases
JDBC (Java Database Connectivity) is an API that defines how Java applications can access and manipulate data in various types of databases. A JDBC driver is a software component that implements the JDBC API for a specific database system. MySQL Connector/J is the official JDBC driver for MySQL, which means it supports all the features and functionality of the MySQL database system.
mysql connector java 5.1 46 bin jar download
MySQL Connector/J provides benefits such as compatibility, performance, security, and ease of use
Some of the benefits of using MySQL Connector/J are:
Compatibility: MySQL Connector/J is compatible with all MySQL versions starting from 5.6 and supports both JDBC 4.2 and X DevAPI standards. It also works with various Java platforms and frameworks such as Java SE, Java EE, Spring, Hibernate, Tomcat, etc.
Performance: MySQL Connector/J is optimized for performance and scalability. It uses efficient data types, caching mechanisms, connection pooling, load balancing, failover, compression, and other techniques to improve the speed and reliability of data transfer.
Security: MySQL Connector/J supports various security features such as SSL/TLS encryption, authentication plugins, password hashing algorithms, firewall integration, etc. It also handles SQL injection prevention and data sanitization.
Ease of use: MySQL Connector/J is easy to use and configure. It provides a simple and intuitive API for executing SQL statements and retrieving results. It also supports advanced features such as prepared statements, stored procedures, batch updates , transactions, metadata, etc.
How to download and install MySQL Connector/J?
Download the mysql-connector-java-5.1.46.jar file from the official website or Maven Central
The first step to use MySQL Connector/J is to download the jar file that contains the driver class and other resources. You can download the latest version of MySQL Connector/J from the official website or from Maven Central. The file name should be something like mysql-connector-java-5.1.46.jar, where 5.1.46 is the version number. You can also download older versions if you need to support legacy applications or databases.
Add the jar file to your project classpath or WEB-INF/lib folder
The next step is to add the jar file to your project classpath or WEB-INF/lib folder, depending on the type of application you are developing. A classpath is a list of directories and files that tell the Java compiler and runtime where to find the classes and resources needed by your application. A WEB-INF/lib folder is a special directory that contains the libraries and dependencies required by a web application deployed on a servlet container such as Tomcat.
If you are using an IDE such as Eclipse, NetBeans, or IntelliJ IDEA, you can easily add the jar file to your project classpath by right-clicking on the project, selecting Properties, and then adding the jar file as an external library or dependency. If you are using a build tool such as Maven, Gradle, or Ant, you can specify the jar file as a dependency in your pom.xml, build.gradle, or build.xml file respectively.
If you are developing a web application, you can simply copy the jar file to your WEB-INF/lib folder and restart your servlet container. The servlet container will automatically load the jar file and make it available to your web application.
Load the driver class using Class.forName("com.mysql.jdbc.Driver") or let the DriverManager automatically load it
The final step is to load the driver class using Class.forName("com.mysql.jdbc.Driver") or let the DriverManager automatically load it. The driver class is the main entry point for MySQL Connector/J and it implements the java.sql.Driver interface. Loading the driver class registers it with the DriverManager, which is a class that manages the available JDBC drivers and handles the creation of connection objects.
mysql connector java 5.1 46 bin jar download link
mysql connector java 5.1 46 bin jar download free
mysql connector java 5.1 46 bin jar download windows
mysql connector java 5.1 46 bin jar download linux
mysql connector java 5.1 46 bin jar download mac
mysql connector java 5.1 46 bin jar download source
mysql connector java 5.1 46 bin jar download maven
mysql connector java 5.1 46 bin jar download eclipse
mysql connector java 5.1 46 bin jar download netbeans
mysql connector java 5.1 46 bin jar download intellij
mysql connector java 5.1 46 bin jar install guide
mysql connector java 5.1 46 bin jar install tutorial
mysql connector java 5.1 46 bin jar install error
mysql connector java 5.1 46 bin jar install problem
mysql connector java 5.1 46 bin jar install solution
mysql connector java 5.1 46 bin jar license information
mysql connector java 5.1 46 bin jar license agreement
mysql connector java 5.1 46 bin jar license key
mysql connector java 5.1 46 bin jar license type
mysql connector java 5.1 46 bin jar license version
mysql connector java 5.1 46 bin jar documentation pdf
mysql connector java 5.1 46 bin jar documentation online
mysql connector java 5.1 46 bin jar documentation example
mysql connector java 5.1 46 bin jar documentation reference
mysql connector java 5.1 46 bin jar documentation api
mysql connector java 5.1 46 bin jar changelog history
mysql connector java 5.1 46 bin jar changelog update
mysql connector java 5.1 46 bin jar changelog bugfix
mysql connector java 5.1 46 bin jar changelog feature
mysql connector java 5.1 46 bin jar changelog release
mysql connector java jdbc driver version compatibility matrix
mysql connector java jdbc driver version comparison chart
mysql connector java jdbc driver version upgrade guide
mysql connector java jdbc driver version downgrade guide
mysql connector java jdbc driver version support policy
how to use mysql connector java in spring boot application
how to use mysql connector java in hibernate framework
how to use mysql connector java in jsp servlet project
how to use mysql connector java in struts2 web application
how to use mysql connector java in jsf primefaces application
how to configure mysql connector java in tomcat server
how to configure mysql connector java in jboss server
how to configure mysql connector java in glassfish server
how to configure mysql connector java in websphere server
how to configure mysql connector java in weblogic server
You can load the driver class explicitly by calling Class.forName("com.mysql.jdbc.Driver") in your code before obtaining a connection object. This will ensure that the driver class is loaded and registered with the DriverManager. Alternatively, you can let the DriverManager automatically load the driver class by using the Service Provider mechanism introduced in JDBC 4.0. This mechanism allows JDBC drivers to be discovered and loaded dynamically without requiring explicit registration. To use this mechanism, you need to have a file named META-INF/services/java.sql.Driver in your jar file that contains the name of the driver class (com.mysql.jdbc.Driver) as its only line. How to use MySQL Connector/J to connect and query a MySQL database?
Create a connection URL with the format jdbc:mysql://host:port/database?parameters
Once you have loaded the driver class, you can use it to create a connection URL that specifies the location and properties of the MySQL database you want to connect to. The connection URL has the following format:
jdbc:mysql://host:port/database?parameters
where:
host is the name or IP address of the MySQL server
port is the port number where the MySQL server is listening (default is 3306)
database is the name of the database you want to access
parameters are optional key-value pairs that define additional connection properties such as user, password, encoding, timezone, etc.
For example, a connection URL for a MySQL database named test on a local server with user root and password secret could be:
jdbc:mysql://localhost:3306/test?user=root&password=secret
Obtain a connection object using DriverManager.getConnection(url, username, password)
After creating a connection URL, you can use it to obtain a connection object using the DriverManager.getConnection(url, username, password) method. The connection object represents a physical connection to the MySQL database and implements the java.sql.Connection interface. You can use the connection object to create and execute SQL statements, manage transactions, obtain metadata, etc.
The DriverManager.getConnection(url, username, password) method takes three parameters:
url is the connection URL that you created in the previous step
username is the username for the MySQL database (optional if specified in the connection URL)
password is the password for the MySQL database (optional if specified in the connection URL)
For example, to obtain a connection object for the test database on the local server with user root and password secret, you can write:
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?user=root&password=secret");
Create a statement object using connection.createStatement() or connection.prepareStatement(sql)
Once you have a connection object, you can use it to create a statement object that represents an SQL statement that you want to execute on the MySQL database. There are two types of statement objects: regular statements and prepared statements. A regular statement is a simple SQL statement that does not have any parameters or placeholders. A prepared statement is an SQL statement that has one or more parameters or placeholders that can be replaced with actual values at runtime. Prepared statements are more efficient and secure than regular statements because they are compiled only once and prevent SQL injection attacks.
To create a regular statement object, you can use the connection.createStatement() method. This method returns an object that implements the java.sql.Statement interface. You can use this object to execute simple SQL queries or updates that do not have any parameters.
To create a prepared statement object, you can use the connection.prepareStatement(sql) method. This method takes an SQL statement as a parameter and returns an object that implements the java.sql.PreparedStatement interface. You can use this object to execute parameterized SQL queries or updates that have one or more placeholders marked with question marks (?).
For example, to create a regular statement object that executes a query to select all records from a table named users, you can write:
Statement statement = connection.createStatement(); ResultSet resultset = statement.executeQuery("SELECT * FROM users");
To create a prepared statement object that executes an update to insert a record into a table named users with three columns: id, name, and email, you can write:
PreparedStatement statement = connection.prepareStatement("INSERT INTO users (id, name, email) VALUES (?, ?, ?)"); statement.setInt(1, 1); // set the first parameter to 1 statement.setString(2, "Alice"); // set the second parameter to "Alice" statement.setString(3, "alice@example.com"); // set the third parameter to "alice@example.com" int rows = statement.executeUpdate(); // execute the update and get the number of affected rows Execute a query using statement.executeQuery(sql) or statement.executeUpdate(sql)
After creating a statement object, you can use it to execute a query on the MySQL database using the statement.executeQuery(sql) or statement.executeUpdate(sql) method. The statement.executeQuery(sql) method executes an SQL query that returns a result set, which is a collection of rows that match the query criteria. The statement.executeUpdate(sql) method executes an SQL update that modifies the data in the database and returns the number of affected rows.
The statement.executeQuery(sql) method takes an SQL query as a parameter and returns an object that implements the java.sql.ResultSet interface. You can use this object to iterate over the rows in the result set and retrieve the values of each column using various getXXX methods. You can also use the resultset.next() method to move the cursor to the next row and check if there are more rows in the result set.
The statement.executeUpdate(sql) method takes an SQL update as a parameter and returns an int value that represents the number of rows affected by the update. You can use this value to check if the update was successful or not.
For example, to execute a query that selects all records from a table named users and prints their names and emails, you can write:
Statement statement = connection.createStatement(); ResultSet resultset = statement.executeQuery("SELECT * FROM users"); while (resultset.next()) // loop through the rows in the result set String name = resultset.getString("name"); // get the value of the name column as a String String email = resultset.getString("email"); // get the value of the email column as a String System.out.println(name + " - " + email); // print the name and email resultset.close(); // close the result set
To execute an update that deletes a record from a table named users with id 1, you can write:
Statement statement = connection.createStatement(); int rows = statement.executeUpdate("DELETE FROM users WHERE id = 1"); // execute the update and get the number of affected rows if (rows > 0) // check if the update was successful System.out.println("Record deleted successfully"); // print a success message else System.out.println("Record not found"); // print an error message
Process the result set using resultset.next(), resultset.getXXX(column), and resultset.close()
As mentioned above, you can use the resultset.next(), resultset.getXXX(column), and resultset.close() methods to process the result set returned by a query. The resultset.next() method moves the cursor to the next row in the result set and returns true if there is a next row or false if there is no more row. The resultset.getXXX(column) method retrieves the value of a column in the current row as a specific data type, such as String, int, boolean, etc. The column parameter can be either an int value that represents the column index (starting from 1) or a String value that represents the column name or alias. The resultset.close() method closes the result set and releases any resources associated with it.
It is important to close the result set after you are done with it, otherwise you might encounter memory leaks or connection errors. You can use a try-with-resources statement to automatically close the result set when it is no longer needed.
For example, to process a result set that contains two columns: name and age, you can write:
try (ResultSet resultset = statement.executeQuery("SELECT name, age FROM users")) // create and use a try-with-resources statement while (resultset.next()) // loop through the rows in the result set String name = resultset.getString(1); // get the value of the first column as a String int age = resultset.getInt(2); // get the value of the second column as an int System.out.println(name + " is " + age + " years old"); // print the name and age catch (SQLException e) // catch any SQL exception e.printStackTrace(); // print the stack trace
How to troubleshoot common errors and solutions for MySQL Connector/J?
Server configuration denies access to data source: check the grant tables and firewall settings on the MySQL server
If you encounter an error like this:
java.sql.SQLException: Access denied for user 'root'@'localhost' (using password: YES)
It means that your MySQL server configuration does not allow your user to access your database from your host. This could be because your user does not have the proper privileges, your password is incorrect, your host is not allowed, or your firewall is blocking the connection. To fix this error, you need to check the grant tables and firewall settings on your MySQL server and make sure that your user can access your database from your host. You can use the following commands to check and modify the grant tables on your MySQL server:
SHOW GRANTS FOR 'root'@'localhost'; // show the privileges for the user root from the host localhost GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' WITH GRANT OPTION; // grant all privileges to the user root from the host localhost FLUSH PRIVILEGES; // reload the grant tables
You also need to check your firewall settings and make sure that your MySQL server port (usually 3306) is open for incoming connections from your host. You can use the following commands to check and modify the firewall settings on your Linux server:
sudo iptables -L -n // list the current firewall rules sudo iptables -A INPUT -p tcp --dport 3306 -j ACCEPT // allow incoming tcp connections on port 3306 sudo iptables-save // save the firewall rules
No suitable driver: check the jar file location, classpath settings, and driver class name
If you encounter an error like this:
java.sql.SQLException: No suitable driver found for jdbc:mysql://localhost:3306/test
It means that your Java application cannot find or load the MySQL Connector/J driver class. This could be because your jar file location is wrong, your classpath settings are incorrect, or your driver class name is misspelled. To fix this error, you need to check the following things:
Jar file location: make sure that your mysql-connector-java-5.1.46.jar file is in a directory that is accessible by your Java application. If you are using an IDE, add the jar file as an external library or dependency to your project. If you are using a build tool, specify the jar file as a dependency in your build file. If you are developing a web application, copy the jar file to your WEB-INF/lib folder.
Classpath settings: make sure that your mysql-connector-java-5.1.46.jar file is included in your classpath. A classpath is a list of directories and files that tell the Java compiler and runtime where to find the classes and resources needed by your application. You can set the classpath using an environment variable (CLASSPATH), a command-line option (-cp or -classpath), or a manifest file (META-INF/MANIFEST.MF).
Driver class name: make sure that you are using the correct driver class name for MySQL Connector/J, which is com.mysql.jdbc.Driver. You can load the driver class explicitly by calling Class.forName("com.mysql.jdbc.Driver") in your code before obtaining a connection object. Alternatively, you can let the DriverManager automatically load the driver class by using the Service Provider mechanism introduced in JDBC 4.0.
Communications link failure: check the network connectivity, server status, and connection parameters
If you encounter an error like this:
java.sql.SQLException: Communications link failure The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.
It means that your Java application cannot establish or maintain a connection to the MySQL server. This could be because of network connectivity issues, server status issues, or connection parameter issues. To fix this error, you need to check the following things:
Network connectivity: make sure that your network connection is working properly and that there are no firewalls or proxies blocking or interfering with your connection. You can use tools such as ping, traceroute, telnet, or netstat to test and diagnose your network connectivity.
Server status: make sure that your MySQL server is running and listening on the correct port (usually 3306). You can use tools such as mysqladmin, ps, or netstat to check and monitor your MySQL server status.
Connection parameters: make sure that your connection URL and credentials are correct and match with your MySQL server configuration. You can use tools such as mysql or mysqlshow to test and verify your connection parameters.
ER_NET_PACKET_TOO_LARGE: increase the max_allowed_packet size on the server or reduce the size of the binary blob
If you encounter an error like this:
java.sql.SQLException: Packet for query is too large (4739923 > 104857 6)). You have to change some columns to TEXT or BLOBs
It means that your Java application is trying to send or receive a binary large object (BLOB) that exceeds the maximum allowed packet size on the MySQL server. A BLOB is a data type that can store large amounts of binary data, such as images, videos, documents, etc. The maximum allowed packet size is a server variable that defines the largest amount of data that can be transmitted in a single network packet. The default value of this variable is 4 MB, but you can change it to a higher value if you need to handle larger BLOBs.
To fix this error, you have two options: increase the max_allowed_packet size on the server or reduce the size of the BLOB. To increase the max_allowed_packet size on the server, you can use one of the following methods:
Edit the my.cnf or my.ini file on your MySQL server and add or modify the following line under the [mysqld] section: max_allowed_packet=16M (or any value larger than your BLOB size)
Restart your MySQL server to apply the changes
Alternatively, you can set the max_allowed_packet size dynamically without restarting the server by using the following command: SET GLOBAL max_allowed_packet=16777216 (or any value larger than your BLOB size in bytes)
To reduce the size of the BLOB, you can use one of the following methods:
Compress the BLOB data before sending or receiving it using a compression algorithm such as gzip, zip, or deflate
Split the BLOB data into smaller chunks and send or receive them separately using multiple SQL statements
Change some columns to TEXT or BLOBs, as suggested by the error message, if they are not already. TEXT and BLOB are data types that can store large amounts of text or binary data, respectively. They differ from other data types such as VARCHAR or VARBINARY in that they are stored separately from the rest of the row and only a pointer is stored in the row. This reduces the row size and allows larger packets to be transmitted.
Conclusion
In this article, we have learned what MySQL Connector/J is, why we should use it, how to download and install it, how to use it to connect and query a MySQL database, and how to troubleshoot some common errors and solutions. We hope that this article has helped you understand and use MySQL Connector/J better and that you can now develop Java applications that interact with MySQL databases more easily and efficiently.
FAQs
What is the difference between MySQL Connector/J and MySQL Connector/ODBC?
MySQL Connector/J and MySQL Connector/ODBC are both JDBC drivers that allow Java applications to communicate with MySQL databases. However, they differ in how they implement the JDBC API. MySQL Connector/J is a native JDBC driver that directly communicates with the MySQL server using its own protocol. MySQL Connector/ODBC is a bridge JDBC driver that uses an ODBC driver to communicate with the MySQL server using the ODBC protocol. Generally, MySQL Connector/J is faster, more reliable, and more compatible than MySQL Connector/ODBC.
How can I check the version of MySQL Connector/J that I am using?
You can check the version of MySQL Connector/J that you are using by calling the getDriverVersion() method on the driver class. For example:
Class.forName("com.mysql.jdbc.Driver"); // load the driver class System.out.println(com.mysql.jdbc.Driver.getDriverVersion()); // print the driver version
How can I enable logging and debugging for MySQL Connector/J?
You can enable logging and debugging for MySQL Connector/J by setting some connection parameters in your connection URL or properties object. Some of these parameters are:
logger: specifies the name of the logger class to use for logging messages. The default value is com.mysql.jdbc.log.StandardLogger, which logs messages to System.err. You can also use other logger classes such as com.mysql.jdbc.log.Slf4JLogger or com.mysql.jdbc.log.Jdk14Logger.
logLevel: specifies the level of logging messages to output. The possible values are OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE, and ALL. The default value is INFO.
profileSQL: specifies whether to log each SQL statement executed by MySQL Connector/J. The possible values are true or false. The default value is false.
useSSL: specifies whether to use SSL/TLS encryption for communication with the MySQL server. The possible values are true or false. The default value is false.
For example, to enable logging and debugging for MySQL Connector/J with the logger class com.mysql.jdbc.log.Slf4JLogger, the log level DEBUG, and the profileSQL option true, you can write:
Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?user=root&password=secret&logger=com.mysql.jdbc.log.Slf4JLogger&logLevel=DEBUG&profileSQL=true");
How can I use MySQL Connector/J with X DevAPI?
X DevAPI is a modern and cross-platform API that allows developers to work with MySQL as a document store using JSON documents and collections. MySQL Connector/J supports X DevAPI since version 8.0 and provides a new set of classes and interfaces to use it. Some of these classes and interfaces are:
com.mysql.cj.xdevapi.Client: represents a client that can create and manage sessions with the MySQL server
com.mysql.cj.xdevapi.Session: represents a session that can perform operations on the MySQL server
com.mysql.cj.xdevapi.Schema: represents a schema (database) that contains collections and tables
com.mysql.cj.xdevapi.Collection: represents a collection of JSON documents
com.mysql.cj.xdevapi.DbDoc: represents a JSON document
com.mysql.cj.xdevapi.FindStatement: represents a statement that can find documents in a collection
com.mysql.cj.xdevapi.AddStatement: represents a statement that can add documents to a collection
com.mysql.cj.xdevapi.ModifyStatement: represents a statement that can modify documents in a collection
com.mysql.cj.xdevapi.RemoveStatement: represents a statement that can remove documents from a collection
To use MySQL Connector/J with X DevAPI, you need to use a different connection URL format and driver class name than the ones used for JDBC. The connection URL format for X DevAPI is:
xdevapi://user:password@host:port/database?parameters
The driver class name for X DevAPI is:
com.mysql.cj.xdevapi.Driver
For example, to create a client and a session for X DevAPI, you can write:
Client client = new ClientFactory().getClient("xdevapi://root:secret@localhost:33060/test"); // create a client Session session = client.getSession(); // get a session
How can I use MySQL Connector/J with JPA and Hibernate?
JPA (Java Persistence API) is an API that defines how Java applications can persist and access data in various types of databases using an object-relational mapping (ORM) approach. Hibernate is one of the most popular implementations of JPA that provides additional features and functionality. To use MySQL Connector/J with JPA and Hibernate, you need to configure some properties in your persistence.xml file or your hibernate.cfg.xml file. Some of these properties are:
javax.persistence.jdbc.driver: specifies the driver class name for MySQL Connector/J, which is com.mysql.jdbc.Driver or com.mysql.cj.jdbc.Driver depending on the version
javax.persistence.jdbc.url: specifies the connection URL for MySQL Connector/J, which has the format jdbc:mysql://host:port/database?parameters
javax.persistence.jdbc.user: specifies the username for the MySQL database
javax.persistence.jdbc.password: specifies the password for the MySQL database
hibernate.dialect: specifies the dialect class name for Hibernate, which is org.hibernate.dialect.MySQLDialect or org.hibernate.dialect.MySQL8Dialect depending on the version of MySQL
hibernate.hbm2ddl.auto: specifies the schema generation strategy for Hibernate, which can be create, update, validate, or none
For example, to configure MySQL Connector/J with JPA and Hibernate using a persistence.xml file, you can write:
<persistence-unit name="test"> <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider> <properties> <property name="javax.persistence.jdbc.driver" value="com.mysql.cj.jdbc.Driver"/> <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test?user=root&password=secret"/> <property name="hibernate.dialect" value="org.hibernate.dialect.MySQL8 using the EntityManager object. For example, to insert a new User entity into the users table, you can write:
User user = new User(); // create a new User object user.setName("Bob"); // set the name user.setEmail("bob@example.com"); // set the email em.getTransaction().begin(); // start a transaction em.persist(user); // persist the User object em.getTransaction().commit(); // commit the transaction
To retrieve a User entity from the users table by its id, you can write:
int id = 1; // the id of the user to find User user = em.find(User.class, id); // find the User object by its id if (user != null) // check if the user exists System.out.println(user.getName() + " - " + user.getEmail()); // print the name and email else System.out.println("User not found"); // print an error message
To update a User entity in the users table, you can write:
User user = em.find(User.class, 1); // find the User object by its id if (user != null) // check if the user exists user.setName("Bob Smith"); // change the name user.setEmail("bob.smith@example.com"); // change the email em.getTransaction().begin(); // start a transaction em.merge(user); // merge the User object em.getTransaction().commit(); // commit the transaction System.out.println("User updated successfully"); // print a success message else System.out.println("User not found"); // print an error message
To delete a User entity from the users table, you can write:
User user = em.find(User.class, 1); // find the User object by its id if (user != null) // check if the user exists em.getTransaction().begin(); // start a transaction em.remove(user); // remove the User object em.getTransaction().commit(); // commit the transaction System.out.println("User deleted successfully"); // print a success message else System.out.println("User not found"); // print an error message
To query a list of User entities from the users table using JPQL (Java Persistence Query Language), you can write:
String jpql = "SELECT u FROM User u WHERE u.name LIKE :name"; // create a JPQL query string with a named parameter :name Query query = em.createQuery(jpql); // create a Query object using the JPQL string query.setParameter("name", "%Bob%"); // set the value of the named parameter :name to "%Bob%" List users = query.getResultList(); // get a list of User objects that match the query criteria for (User user : users) // loop through the list of users System.out.println(user.getName() + " - " + user.getEmail()); // print the name and email of each user 44f88ac181
Comments