Persist Java objects to MySQL database for storage through JPA technology

JPA (Java Persistence API) is an ORM specification introduced in Java EE 5.0. Its purpose is to simplify the mapping of objects and relational databases and help Java developers more easily persist Java objects into relational databases. JPA hides the mapping between Java objects and relational databases by abstracting the concept of data. Developers can focus on writing business code without paying attention to the details of data storage.

In this article, we will introduce how to use JPA technology to persist Java objects into a MySQL database for storage.

First, we need to define a data model, such as a simple student class.

@Entity
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private Integer age;

    // 省略构造函数、getter和setter方法
}

In the above code, we use JPA annotations to define an entity class, where the @Entity annotation is used to mark this class as a JPA entity class, the @Id annotation indicates that the field is the primary key, and the @GeneratedValue annotation Indicates that the field is an automatically generated primary key, and the @Column annotation is used to specify the database column information corresponding to the field.

Next, in our project we need to use the EntityManager instance provided by JPA to perform entity class operations. Before using JPA, we need to specify the data source and JPA-related configuration information in the configuration file.

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence 
             http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">
    <persistence-unit name="myPU" transaction-type="RESOURCE_LOCAL">
        <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <class>com.example.Student</class>
        <properties>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/test"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="password"/>
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

In the above configuration file, we use the implementation provided by Hibernate and specify our data source and JPA-related configuration information.

Then, in our Java code, the entity class is operated through the EntityManager instance.

public class StudentManager {

    private EntityManagerFactory emf = Persistence.createEntityManagerFactory("myPU");

    public void save(Student student) {
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            em.persist(student);
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }
    }

    public Student getById(Long id) {
        EntityManager em = emf.createEntityManager();
        try {
            return em.find(Student.class, id);
        } finally {
            em.close();
        }
    }

    public List<Student> getAll() {
        EntityManager em = emf.createEntityManager();
        try {
            CriteriaBuilder cb = em.getCriteriaBuilder();
            CriteriaQuery<Student> cq = cb.createQuery(Student.class);
            Root<Student> rootEntry = cq.from(Student.class);
            CriteriaQuery<Student> all = cq.select(rootEntry);
            TypedQuery<Student> allQuery = em.createQuery(all);
            return allQuery.getResultList();
        } finally {
            em.close();
        }
    }

    public void update(Student student) {
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            em.merge(student);
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }
    }

    public void deleteById(Long id) {
        EntityManager em = emf.createEntityManager();
        EntityTransaction tx = em.getTransaction();
        try {
            tx.begin();
            Student student = em.find(Student.class, id);
            em.remove(student);
            tx.commit();
        } catch (Exception e) {
            tx.rollback();
        } finally {
            em.close();
        }
    }
}

In the above code, we created a StudentManager class to perform entity class operations, in which an EntityManager instance was created through the EntityManagerFactory instance, and the C(R)UD operation of the entity class was implemented by operating the instance.

Finally, we can test our code through the following code:

public static void main(String[] args) {
    StudentManager studentManager = new StudentManager();
    Student s1 = new Student("Tom", 18);
    studentManager.save(s1);

    Student s2 = studentManager.getById(1L);
    System.out.println(s2.getName()); // 输出：Tom

    List<Student> students = studentManager.getAll();
    System.out.println(students.size()); // 输出：1

    s2.setName("Jerry");
    studentManager.update(s2);
    s2 = studentManager.getById(1L);
    System.out.println(s2.getName()); // 输出：Jerry

    studentManager.deleteById(1L);
    students = studentManager.getAll();
    System.out.println(students.size()); // 输出：0
}

Through the above code, we can see that JPA does provide very convenience and ease of use when persisting Java objects Interface. Developers only need to define entity classes, configure data sources and JPA information through simple annotations, and then they can directly persist Java objects into relational databases for storage. This greatly reduces the amount of coding required by developers, improves development efficiency, and avoids potential security risks caused by handwritten SQL statements.

The above is the detailed content of Persist Java objects to MySQL database for storage through JPA technology. For more information, please follow other related articles on the PHP Chinese website!