JAVA JPA - Обычное решение для сохранения всех объектов в проекте

Question

Я работаю над бэкэндом, который создает нового пользователя, новости, различные данные и т. Д.

До сих пор я мог создавать и сохранять нового пользователя в базе данных.Я думаю, что будет много других организаций, также с отношениями.На данный момент я вижу только два способа сохранения данных:

• создание классов CreateXY, UpdateXY и DeleteXY
• или кодирование метода постоянства в каждом объекте сущности

Я думаю, что писать излишки снова и снова - это просто излишне.Есть хороший способ сохранить объекты хорошим способом?

Main.java

package database;

import java.util.logging.Level;
import java.util.logging.Logger;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

import backend.User;

public class Main {
    private static final Logger LOGGER = Logger.getLogger("JPA");

    public static void main(String[] args) {
        Main main = new Main();
        main.run();
    }

    public void run() {
        EntityManagerFactory factory = null;
        EntityManager entityManager = null;
        try {
            System.out.println("START");
            factory = Persistence.createEntityManagerFactory("shareiffUnit");
            System.out.println("END");
            entityManager = factory.createEntityManager();
            persistPerson(entityManager);
        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, e.getMessage(), e);
            e.printStackTrace();
        } finally {
            if (entityManager != null) {
                entityManager.close();
            }
            if (factory != null) {
                factory.close();
            }
        }
    }

    private void persistPerson(EntityManager entityManager) {
        EntityTransaction transaction = entityManager.getTransaction();
        try {
            transaction.begin();
            User person = new User();
            person.setName("Homer");
            person.setPassword("Simpson");
            entityManager.persist(person);
            transaction.commit();
        } catch (Exception e) {
            if (transaction.isActive()) {
                transaction.rollback();
            }
        }
    }

}

User.java

package backend;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table
public class User {

    @Id
    @GeneratedValue
    private int id;
    private String name;
    private String password;
    private Boolean isActive = false;


    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Boolean isActive() {
        return isActive;
    }
    public void setActive(boolean isActive) {
        this.isActive = isActive;
    }

}

Answer 1

большое спасибо.Это выглядит действительно хорошо.Я просто попытался использовать его в своем проекте.Выглядит так далекоЕдинственное, что я не понимаю, это где обязательства.Я думал, что после упорства

Main.java

public class Main {
     public static void main(String[] args) {

        /*
         * just create a user to persist
         */     
        User aUser = new User();
        aUser.setActive(true);
        aUser.setName("Hans");
        aUser.setPassword("Müller");        
        GenericDao dao = new GenericDao();        
        dao.update(aUser);     
        System.out.println("PERSIST?");
    }
}

DaoInterface.java

public interface IGenericDao<E> {
    void create(E entity);
    E read(Integer id);
    void update(E entity);
    void delete(E entity);
}

Dao.java

public class GenericDao<E> implements IGenericDao<E> {

    @PersistenceContext
    private static EntityManager entityManager;

    private EntityManager getEntityManager() {
        return entityManager;
    }

    public void create(E entity) {
        getEntityManager().persist(entity);
    }

    public E read(Integer id) {
        // TODO Auto-generated method stub
        return null;
    }

    public void update(E entity) {
        // TODO Auto-generated method stub

    }

    public void delete(E entity) {
        // TODO Auto-generated method stub

    }
}

Спасибо ваванс

Answer 2

У меня, как правило, есть набор классов, похожих на менеджеров, и база для каждого класса менеджеров.База выглядит примерно так:

public class SomeBaseWritableDAO<T> {
    @PersistenceContext
    private EntityManager entityManager;

    protected EntityManager getEntityManager() {
        return entityManager;
    }

    public void save(T entity) {
        getEntityManager().persist(entity);
    }

    public T update(T entity) {
        return getEntityManager().merge(entity);
    }

    public void delete(T entity) {
        getEntityManager().remove(entity);
    }
}

, которая заботится о любом типе @Entity.Затем, если мне нужно больше, чем базовые операции CRUD, я создам менеджер, специфичный для класса:

public class SpecificDAO extends SomeBaseWritableDAO<SpecificEntity> {

    public SpecificEntity findBySomeCode(String inviteCode) {
        final String queryString = "select model from SomeEntity model " +
                "where model.code= :inviteCode";

        Query query = getEntityManager().createQuery(queryString);
        query.setParameter("inviteCode", inviteCode);

        try {
            return (SomeEntity) (query.getSingleResult());
        }
        catch( NoResultException nre ) {
            return null;
        }
    }
}

Есть и другие способы сделать это, но этот шаблон хорошо работал в прошлом.Если у вас есть правильно спроектированная база данных со ссылочной целостностью, то хороший инструмент обратного инжиниринга, такой как Eclipse или IntelliJ, может генерировать ваши отношения один к одному и один ко многим.