Behalten Sie Java-Objekte zur Speicherung mithilfe der JPA-Technologie in der MySQL-Datenbank bei

JPA (Java Persistence API) ist eine ORM-Spezifikation, die in Java EE 5.0 eingeführt wurde. Ihr Zweck besteht darin, die Zuordnung von Objekten und relationalen Datenbanken zu vereinfachen und Java-Entwicklern dabei zu helfen, Java-Objekte einfacher in relationalen Datenbanken zu speichern. JPA verbirgt die Zuordnung zwischen Java-Objekten und relationalen Datenbanken, indem es das Konzept der Daten abstrahiert. Entwickler können sich auf das Schreiben von Geschäftscode konzentrieren, ohne auf die Details der Datenspeicherung zu achten.

In diesem Artikel stellen wir vor, wie Sie die JPA-Technologie verwenden, um Java-Objekte zur Speicherung in einer MySQL-Datenbank beizubehalten.

Zuerst müssen wir ein Datenmodell definieren, beispielsweise eine einfache Schülerklasse.

@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方法
}

Im obigen Code verwenden wir JPA-Annotationen, um eine Entitätsklasse zu definieren, wobei die @Entity-Annotation verwendet wird, um diese Klasse als JPA-Entitätsklasse zu markieren, die @Id-Annotation angibt, dass das Feld der Primärschlüssel ist, und die Die Annotation @GeneratedValue gibt an, dass das Feld ein automatisch generierter Primärschlüssel ist. Die Annotation @Column wird verwendet, um die Datenbankspalteninformationen anzugeben, die diesem Feld entsprechen.

Als nächstes müssen wir in unserem Projekt die von JPA bereitgestellte EntityManager-Instanz verwenden, um Entitätsklassenoperationen durchzuführen. Bevor wir JPA verwenden, müssen wir die Datenquelle und JPA-bezogene Konfigurationsinformationen in der Konfigurationsdatei angeben.

<?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 der obigen Konfigurationsdatei verwenden wir die von Hibernate bereitgestellte Implementierung und geben unsere Datenquelle und JPA-bezogene Konfigurationsinformationen an.

Dann führen wir in unserem Java-Code Entitätsklassenoperationen über die EntityManager-Instanz durch.

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

Im obigen Code haben wir eine StudentManager-Klasse erstellt, um Entity-Klassenoperationen durchzuführen. Dabei wurde eine EntityManager-Instanz über die EntityManagerFactory-Instanz erstellt und die C(R)UD-Operation der Entity-Klasse durch Betreiben der Instanz implementiert.

Abschließend können wir unseren Code mit dem folgenden Code testen:

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
}

Anhand des obigen Codes können wir sehen, dass JPA eine sehr praktische und benutzerfreundliche Schnittstelle für die Beibehaltung von Java-Objekten bereitstellt. Entwickler müssen lediglich Entitätsklassen definieren, Datenquellen und JPA-Informationen durch einfache Anmerkungen konfigurieren und können dann Java-Objekte direkt in relationalen Datenbanken zur Speicherung speichern. Dies reduziert den für Entwickler erforderlichen Codierungsaufwand erheblich, verbessert die Entwicklungseffizienz und vermeidet potenzielle Sicherheitsrisiken, die durch handgeschriebene SQL-Anweisungen verursacht werden.

Das obige ist der detaillierte Inhalt vonBehalten Sie Java-Objekte zur Speicherung mithilfe der JPA-Technologie in der MySQL-Datenbank bei. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!