emecas commented on a change in pull request #760:
URL:
https://github.com/apache/tomee/pull/760#discussion_r567471778##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
Review comment:
es simplemente un pojo
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
Review comment:
`encima` does not make any sense here!!
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
+
+## Inyección vía @PersistenceContext
+
+Lo `EntityManager` sí mismo es creado por el contenedor utilizando la información en el `persistence.xml`, así que para usarlo en
Review comment:
El `EntityManager` en si mismo
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
Review comment:
ayudar a realizar
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
Review comment:
como la entidad
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
Review comment:
para crear y actulizar los datos en una base de datos
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
Review comment:
Note que la entidad
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
Review comment:
" puede crear, eliminado, actualizado o eliminado a través de un objeto" is redundant
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
+
+## Inyección vía @PersistenceContext
+
+Lo `EntityManager` sí mismo es creado por el contenedor utilizando la información en el `persistence.xml`, así que para usarlo en
+tiempo de ejecución, simplemente necesitamos solicitar que se inyecte en uno de nuestros componentes. Nosotros hacer esto a través de `@PersistenceContext`
+
+La anotación `@PersistenceContext` se puede utilizar en cualquier bean CDI, EJB, Servlet, Servlet Listener, Servlet Filter, o JSF ManagedBean.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.ejb.Stateful;
+ import javax.persistence.EntityManager;
+ import javax.persistence.PersistenceContext;
+ import javax.persistence.PersistenceContextType;
+ import javax.persistence.Query;
+ import java.util.List;
+
+ @Stateful
+ public class Movies {
+
+ @PersistenceContext(unitName = "movie-unit", type = PersistenceContextType.EXTENDED)
+ private EntityManager entityManager;
+
+ public void addMovie(Movie movie) throws Exception {
+ entityManager.persist(movie);
+ }
+
+ public void deleteMovie(Movie movie) throws Exception {
+ entityManager.remove(movie);
+ }
+
+ public List<Movie> getMovies() throws Exception {
+ Query query = entityManager.createQuery("SELECT m from Movie as m");
+ return query.getResultList();
+ }
+ }
+
+Este particular `EntityManager` se inyecta como un contexto de persistencia `EXTENDED`, lo que simplemente significa que el `EntityManager` se crea cuando el `@Stateful` el frijol se crea y destruye cuando el `@Stateful` frijol es destruido. En pocas palabras, el datos en el `EntityManager` se almacena en caché durante la vida útil del bean `@Stateful`.
Review comment:
el frijol lol !!!! el Bean
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
+
+## Inyección vía @PersistenceContext
+
+Lo `EntityManager` sí mismo es creado por el contenedor utilizando la información en el `persistence.xml`, así que para usarlo en
Review comment:
El `EntityManager` en si mismo
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
+
+ <persistence xmlns="
http://java.sun.com/xml/ns/persistence" version="1.0">
+
+ <persistence-unit name="movie-unit">
+ <jta-data-source>movieDatabase</jta-data-source>
+ <non-jta-data-source>movieDatabaseUnmanaged</non-jta-data-source>
+ <class>org.superbiz.injection.jpa.Movie</class>
+
+ <properties>
+ <property name="openjpa.jdbc.SynchronizeMappings" value="buildSchema(ForeignKeys=true)"/>
+ </properties>
+ </persistence-unit>
+ </persistence>
+
+Note que el entidad `Movie` aparece a través de un elemento `<class>`. Esto no es necesario, pero puede ayudar al realizar la prueba o cuando clase `Movie` se encuentra en un jar diferente que el jar que contiene el archivo `persistence.xml`.
+
+## Inyección vía @PersistenceContext
+
+Lo `EntityManager` sí mismo es creado por el contenedor utilizando la información en el `persistence.xml`, así que para usarlo en
+tiempo de ejecución, simplemente necesitamos solicitar que se inyecte en uno de nuestros componentes. Nosotros hacer esto a través de `@PersistenceContext`
Review comment:
--> Nosotros hacer esto a través de .....
change by
Nosotros [podemos hacer esto a través de
or
Podemos hacer esto a través de
##########
File path: examples/xa-datasource/README_es.adoc
##########
@@ -0,0 +1,326 @@
+:index-group: DataSources
+:jbake-type: page
+:jbake-status: status=published
+= Inyeccion del EntityManager
+
+En éste ejemplo y se muestra el uso de `@PersistenceContext` para tener um `EntityManager` con un
+persistence context `EXTENDED`, inyecctado en un bean `@Stateful`. Un bean del tipo `@Entity` JPA, se
+utiliza con el `EntityManager` para crear, inserir e alterar datos en un banco de datos.
+
+## La creación de una entidad JPA
+
+La entidad por sí es simple un pojo con la anotación `@Entity`. Nosotros creamos una llamada `Movie` Lo que podemos usar para mantener registros de películas.
+
+ package org.superbiz.injection.jpa;
+
+ import javax.persistence.Entity;
+
+ @Entity
+ public class Movie {
+
+ @Id @GeneratedValue
+ private long id;
+
+ private String director;
+ private String title;
+ private int year;
+
+ public Movie() {
+ }
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public Movie(String director, String title, int year) {
+ this.director = director;
+ this.title = title;
+ this.year = year;
+ }
+
+ public String getDirector() {
+ return director;
+ }
+
+ public void setDirector(String director) {
+ this.director = director;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public int getYear() {
+ return year;
+ }
+
+ public void setYear(int year) {
+ this.year = year;
+ }
+ }
+
+## Configure el EntityManager a través de un archivo persistence.xml
+
+La entidad `Movie` encima se puede crear, eliminado, actualizado o eliminado a través de un objeto `EntityManager`. Lo `EntityManager` sí mismo es configurado a través de un archivo `META-INF/persistence.xml` que se coloca en el mismo jar como el entidad `Movie`.
Review comment:
" puede crear, eliminado, actualizado o eliminado a través de un objeto" is redundant
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[hidden email]
Locked
