Hibernate JPA avec JTA et le Serveur d'Application Glassfish ne semble pas commettre

Je suis nouveau sur mise en veille prolongée et je veux qu'il à utiliser la connexion de base de données depuis le serveur d'application via JNDI.

La chose Étrange, c'est qu'elle crée mes tables dans la base de données, mais il n'a pas d'enregistrer l'entité. Il semble, qu'il n'a pas commis.

Quelqu'un a eu des problèmes similaires avec mise en veille prolongée?

C'est un petit test-servlet:

public class WriteTest extends HttpServlet
{
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response)
    {
        /*try
        { 
            User user = new User("Hans", "Maulwurf", "[email protected]");

            InitialContext ctx = new InitialContext();
            UserFacadeBean bean = (UserFacadeBean) ctx.lookup("ejb/UserFacadeBeanService");
            bean.persist(user);
        }
        catch (NamingException e)
        {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }*/

        EntityManager em = JpaUtil.getEntityManagerFactory().createEntityManager();
        //em.getTransaction().begin();

        System.out.println("Begin transfer");

        User user = new User("Hans", "Maulwurf", "[email protected]");
        Adress adress = new Adress("Deppenstraße 3","Deppingen");
        //user.setAddress(adress);

        System.out.println("Save User 'Hans Maulwurf'");

        em.persist(user);
        //em.persist(adress);
        //em.getTransaction().commit();
        em.close();

        System.out.println("Everything went better than expected!");
    }
}

C'est le little helper-catégorie:

public class JpaUtil
{
    private static final EntityManagerFactory emf;

    static
    {
        try
        {
            System.out.println("Initialize EntityManagerFactory...");
            emf = Persistence.createEntityManagerFactory("testPU");
        }
        catch (Throwable ex)
        {
            System.err.println("Initial EntityManagerFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static EntityManagerFactory getEntityManagerFactory()
    {
        return emf;
    }
}

Mon utilisateur-objet:

@Entity
@Table(name = "T_UserJpa")
public class User implements Serializable
{
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Embedded
@AttributeOverrides(
{
@AttributeOverride(name = "street", column =
@Column(name = "user_street")),
@AttributeOverride(name = "city", column =
@Column(name = "user_city", length = 50))
})
private Adress adress;
private String firstname;
private String lastname;
private String email;
public User()
{
}
public User(String firstname, String lastname, String email)
{
this.firstname = firstname;
this.lastname = lastname;
this.email = email;
}
public Long getId()
{
return id;
}
public void setId(Long id)
{
this.id = id;
}
public Adress getAddress()
{
return adress;
}
public void setAddress(Adress adress)
{
this.adress = adress;
}
public String getFirstname()
{
return firstname;
}
public void setFirstname(String firstname)
{
this.firstname = firstname;
}
public String getLastname()
{
return lastname;
}
public void setLastname(String lastname)
{
this.lastname = lastname;
}
public String getEmail()
{
return email;
}
public void setEmail(String email)
{
this.email = email;
}
@Override
public boolean equals(Object obj)
{
if (this == obj)
{
return true;
}
if (!(obj instanceof User))
{
return false;
}
final User user = (User) obj;
return !(email != null ? !email.equals(user.email) : user.email != null);
}
@Override
public int hashCode()
{
return 29 * (email != null ? email.hashCode() : 0);
}
}

Mon persistence.xml:

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence">
<persistence-unit name="testPU" transaction-type="JTA">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<jta-data-source>jdbc/testdb</jta-data-source>
<properties>
<property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/>
<property name="hibernate.show_sql" value="true"/>
<property name="hibernate.transaction.factory_class" value="org.hibernate.transaction.JTATransactionFactory"/>
<property name="hibernate.hbm2ddl.auto" value="update"/>
<property name="hibernate.connection.autocommit" value="true"/>
</properties>
</persistence-unit>
</persistence>

Edit: j'ai oublié de mentionner que j'ai déjà utilisé les renseignements fournis dans ce fil: Ressources d'apprentissage pour la Configuration d'Hibernate JPA 2.0 sur le serveur Glassfish

OriginalL'auteur mw88 | 2011-08-01

6

Dans un serveur d'applications, vous pouvez avoir un container managed EntityManager (aka, un contexte de persistance) ou d'une application gérée EntityManager. Dans les deux cas, vous devez associer le contexte de persistance avec une Transaction est une Transaction JTA, ou plaine JDBC transaction.

À l'égard de votre problème à portée de main, les points suivants doivent être considérés:
- Votre persistence.xml fichier indique que vous avez l'intention d'utiliser une source de données JTA et, par conséquent, JTA opérations à effectuer le travail transactionnel.
- Aussi, votre JpaUtil de classe est responsable de la création de l'application géré EntityManager instances.
À la lumière de ces deux déclarations et le comportement démontré par votre application, il semblerait que votre EntityManager instance n'est pas associée à une transaction JTA. Par conséquent, toutes les modifications apportées dans le contexte de persistance, sera tout simplement pas être vidées à la base de données. C'est simplement dû au fait que le fournisseur JPA va s'appuyer sur la transaction JTA et engagé des ressources pour effectuer le travail transactionnel; si aucun n'est trouvé, aucun travail ne sera effectué (contrairement au cas des Ressources Locales les transactions où le pool de connexion et de ressources de l'enrôlement est effectuée par le fournisseur JPA lui-même).

Le point est donc que le EntityManager ou le contexte de persistance doit être associé à une transaction active, avant d'effectuer tout changement d'entités, de sorte que toutes les modifications apportées aux entités dans le contexte de persistance peut être vidé à la base de données. Pour résoudre votre problème, vous devez:
- démarrer une nouvelle transaction JTA. Vous pouvez opter pour soit gérée par le conteneur des transactions ou gérées par l'application des opérations.
  - Gérée par le conteneur des opérations comme le nom l'indique, sont entièrement gérés par le conteneur. Vous ne pouvez pas appeler les Api pour commencer et mettre fin à de telles transactions. Au lieu de cela, vous devez effectuer toutes les opérations que dans les Ejb. L'Ejb en question doit être configuré en exigeant gérée par le conteneur des transactions. Démonstration de l'utilisation des Ejb pour effectuer le travail transactionnel dans votre scénario serait hors des limites de cette réponse. Je suggère la lecture sur les Ejb si vous n'avez pas à apprendre à écrire encore.
  - Application ou un Bean géré les transactions sont gérées par l'application elle-même et
    pas par le conteneur. Tout cela pourrait sembler approprié dans votre cas, ne remarque que vous êtes maintenant responsable de la gestion des transactions; le plus souvent, cette stratégie d'erreurs, et assez souvent, il n'est pas bien comprise par les développeurs avec le résultat qu'il est souvent considéré comme une mauvaise pratique dans la plupart des projets. Si vous souhaitez utiliser Bean géré transactions, alors vous aurez besoin pour démarrer une Transaction à l'aide de la un usertransaction la classe de l'API comme indiqué ci-dessous:
    
    public class WriteTest extends HttpServlet { @Resource UserTransaction tx; //a UserTransaction reference is injected like a any other resource. It can also be looked up from JNDI. public void doGet(HttpServletRequest request, HttpServletResponse response) { ... tx.begin(); //Start a new JTA BMT EntityManager em = JpaUtil.getEntityManagerFactory().createEntityManager(); ... User user = new User("Hans", "Maulwurf", "[email protected]"); Adress adress = new Adress("Deppenstraße 3","Deppingen"); //user.setAddress(adress); em.persist(user); em.close(); ... tx.commit(); //Commit the JTA BMT } }
    
    Le code ci-dessus n'est pas exactement le prêt à la production. Par exemple, il n'effectue pas de gestion des exceptions, et ne porte explicitement la reprise des changements dans l'éventualité d'un échec de l'application.
- rejoindre le EntityManager exemple avec la transaction JTA, si le EntityManager n'est pas déjà associé à la transaction JTA. Ce n'est pas nécessaire si vous commencez la transaction JTA premier (ce qui est fait dans l'exemple ci-dessus impliquant Bean Géré transactions), mais si vous créez le EntityManager la première utilisation de votre JpaUtil classe, puis de démarrer une transaction, vous devez utiliser le EntityManager.joinTransaction() méthode de rejoindre le contexte de persistance avec la transaction JTA. De toute évidence, toutes les modifications sont nettoyés dans le contexte de persistance n'est pas associée à une transaction, sera ignoré.
Cela m'a bien aidé! Merci

OriginalL'auteur Vineet Reynolds

Vous devez utiliser le support de transaction par le conteneur. C'est un des exemples du livre Pro JPA 2 la maîtrise de la Java Persistence API). J'espère que cela aide:

public class EmployeeServlet extends HttpServlet {
@PersistenceUnit(unitName="EmployeeService")
EntityManagerFactory emf;
@Resource UserTransaction tx;
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//...
int id = Integer.parseInt(request.getParameter("id"));
String name = request.getParameter("name");
long salary = Long.parseLong(request.getParameter("salary"));
tx.begin();
EntityManager em = emf.createEntityManager();
try {
EmployeeService service = new EmployeeService(em);
service.createEmployee(id, name, salary);
} finally {
em.close();
}
tx.commit();
//...
}
}

OriginalL'auteur Edwin Dalorzo

1

Ce document d'orientation pour l'intégration de la mise en veille prolongée.4.3.5 et EJB et JTA et GlassFish.4.0 dans NetBeans.8.0 IDE. Créer un projet web en net beans (attention: ne pas faire de projet web avec maven, car il y a un bug dans Netbeans.8.0 IDE ) et ajouter hibernate fichiers jar du projet, d'autres paramètres liés à la configuration de MySql et glassfish est très simple(il suffit de définir un Pool de Connexion JDBC et en Ressources>JDBC:Connexion JDBC Piscines & Ressources JDBC, des conseils pour ce qui est dans le web, si vous rechercher)(attention: pour la définition d'un JNDI correct, d'abord créer un projet temporaire qui dépend de JNDI comme JPA projet glassfish, puis copier les paramètres qui est créé dans Glassfish pour ce Projet car il y a un bug dans glassfish lorsque vous allez obtenir une table de ping à MySQl dans la création de votre première Connexion de la Piscine si vous créez par vous-même à l'intérieur de la glassfish) donc je n'ai pas de décrire dans cet article puis créer persistence.xml fichier comme suit :
```
<persistence-unit name="omidashouriPU" transaction-type="JTA">
<provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
<jta-data-source>jdbc/yourJNDI (which you defined in glassfish) </jta-data-source>
<exclude-unlisted-classes>false</exclude-unlisted-classes>
<properties>
<property name="hibernate.archive.autodetection" value="class"/>
<property name="hibernate.connection.driver_class"  value="com.mysql.jdbc.Driver"/>
<property name="hibernate.transaction.jta.platform" value="org.hibernate.service.jta.platform.internal.SunOneJtaPlatform"/>
<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
<property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/YourSchemaName"/>
<property name="hibernate.connection.username" value="root"/>
<property name="hibernate.connection.password" value="yourpassword"/>
<property name="hibernate.show_sql" value="true"/>
</properties>
</persistence-unit>
```
Dans Votre EJB classe (classe annotée avec @Stateless) pour la création de l'EntityManager utiliser la syntaxe suivante :
```
@PersistenceContext(unitName = " omidashouriPU ")
EntityManager em;
em.persist(YourEntityObject);
```
Comme vous le Savez, lorsque vous êtes à l'aide de “transaction-type="JTA", la gestion de la transaction n'est pas avec vous, signifie que, la gestion de l'ouverture et de la clôture de la transaction est le serveur d'application (Ici GlassFish). En effet, si vous vérifiez votre persistence.xml en mode conception, en face de fournisseur de persistance de la liste déroulante, vous pouvez voir hibernate est maintenant ajouté.

OriginalL'auteur user2875754
0

Commettre lorsque vous maunally valider vos changé c'est à dire lorsque vous supprimez le commentaire de la validation de la ligne?

Aussi essayer de vérifier votre configuration est définie par

toggleAutoCommit = session.connexion().getAutoCommit();

Lorsque j'utilise em.getTransaction (), j'obtiens cette exception: java.lang.IllegalStateException: JTA EntityManager ne peut pas utiliser getTransaction()
je crois que ce que u besoin de faire est de em.getsession et vérifier que vous ne pouvez pas utiliser le getTransaction que vous arent l'utilisation de cette api
L'EntityManager n'a pas cette méthode car elle semble gérer la session et de la transaction et ne m'autorise pas à y accéder. J'ai joué un peu avec chasse d'eau, mais c'est déjà réglé sur auto.
Je voudrais éviter de l'utilisation de l'auto s'engager dans la configuaration que c'est très dangereux et peut conduire à cassé les entités et a des problèmes avec certaines db pilotes à partir de l'expérience, si vous avez configuré votre servket à s'engager pour vous , de la manière habituelle est d'avoir cette couche comme un DAO qui n'ces opérations pour vous

OriginalL'auteur Chris

Vous devez vous connecter pour publier un commentaire.