http://www.micmiu.com/j2ee/ejb/ejb-jpa-entity-crud-demo/
EJB+JPA演示实体类基本操作CRUD的实现
本文详细介绍EJB+JPA实现Entity的CRUD基本操作。
目录
- 创建POJO：BlogVo
- 创建Entity：Blog
- 配置persistence.xml
- 定义Remote接口
- 创建SessionBean实现类
- 配置datasource数据源
- 部署EJB工程
- 创建客户端测试类
- 运行测试类
[一]、创建POJO：BlogVo.java
[二]、创建Entity：Blog.java
[三]、配置persistence.xml
修改配置文件 src: META-INF/persistence.xml
ps：<jta-data-source></jta-data-source>配置的值“java:/micmiuOracleDS”需要和JBOSS_HOME/server/default/conf/tandardjbosscmp-jdbc.xml 中配置的<datasource></datasource>一致，详见 下面 第[六]部分 配置datasource数据源
[四]、定义Remote接口
BlogBeanRemote.java
[五]、创建SessionBean实现类
BlogBean.java
ps:
- @PersistenceContext 用来注入 EntityManager
- unitName 的值”micmiuJPA” 和配置文件persistence.xml 中定义的名称一致
[六]、配置datasource数据源
本文以JBoss 5.0.1.GA 、Oracle 数据库为例，介绍JBoss下部署EJB如何配置datasource。
以 JBOSS_HOME 表示JBoss 本地的根目录 ，默认配置部署在 JBOSS_HOME/server/default/下。
- 创建配置文件：oracle-ds.xml
- 配置数据库驱动
- 配置 datasource 名称
- 部署EJB工程
1. 创建配置文件：oracle-ds.xml
从 JBOSS_HOEM/docs/examples/jca/ 目录下找到Oracle数据源的配置模板文件：oracle-ds.xml ，copy一份到目录 JBOSS_HOME/server/default/deploy/ 目录下，并根据具体的Oracle参数修改配置文件如下：
2. 配置数据库驱动
把数据库对应驱动的lib包（比如：ojdbc6-11.2.0.3.0.jar）copy 到目录 JBOSS_HOME/server/default/lib 下。
3.配置 datasource 名称
把JBOSS_HOME/server/default/conf/tandardjbosscmp-jdbc.xml 中的
修改成：
注意：<datasource>java:/micmiuOracleDS</datasource> 的值 java:/micmiuOracleDS 要和EJB工程中persistence.xml 配置文件中的<jta-data-source>java:/micmiuOracleDS</jta-data-source> 配置要一致。
4. 部署EJB工程
把EJB工程打包后，copy到目录 JBOSS_HOME/server/default/deploy 下发布即可。
[七]、部署EJB工程
导出EJB工程打包，copy 到 JBOSS_HOME/server/default/deploy 默认发布配置下,启动JBOSS即可，能看的类似如下的日志信息：
09:39:43,291 INFO [SessionSpecContainer] Starting jboss.j2ee:jar=EJB-HelloWorld.jar,name=BlogBean,service=EJB3
09:39:43,298 INFO [EJBContainer] STARTED EJB: com.micmiu.ejb.BlogBean ejbName: BlogBean
09:39:43,306 INFO [JndiSessionRegistrarBase] Binding the following Entries in Global JNDI:BlogBean/remote – EJB3.x Default Remote Business Interface
BlogBean/remote-com.micmiu.ejb.BlogBeanRemote – EJB3.x Remote Business Interface
[八]、创建客户端测试类
把EJB工程中的Remote接口以及引用到的Vo类导出JAR包，copy到客户端工程中，然后创建客户端调用类：BlogBeanClientTest.java
[九]、运行测试类
运行后日志信息如下：
>>>> InitialContext
>>>> lookup
>>>> 操作之前 query michael’s Blog
query result size = 1
BlogVo [id=1, title=Michael的博客, url=http://www.micmiu.com, author=michael]
>>>> create new blog
BlogVo [id=114, title=图文演示Eclipse+JBoss创建第一个EJB项目, url=http://www.micmiu.com/j2ee/ejb/eclipse-jboss-ejb-demo/, author=michael]
>>>> read exit blog
BlogVo [id=1, title=Michael的博客, url=http://www.micmiu.com, author=michael]
>>>> update blog
update title Michael的博客 to 大大&&小小
>>>> 操作之后 query michael’s Blog
>>>> 结果 = 2
BlogVo [id=1, title=大大&&小小, url=http://www.micmiu.com, author=michael]
BlogVo [id=114, title=图文演示Eclipse+JBoss创建第一个EJB项目, url=http://www.micmiu.com/j2ee/ejb/eclipse-jboss-ejb-demo/, author=michael]
本文介绍到此结束@Michael Sun.
Jpa （EJB3 Entity Bean） 好东西就顺便拿来了
作者：黄海波(Charles Huang)
Java EE5作为新一代Java企业开发平台的规范，从开始设计就引来了整个java开发社区的注目，引起无数的辩论和带来了众多的期盼。Java EE5作为J2EE平台诞生几近6年后的第4代规范重点关注的是目前java开发的几个热点：开发效率，运行效率和企业应用整合。目标也是让J2EE开发简单，简单再简单。那我们就看看J2EE5规范到底有什么，是否真的能给开发者/企业带来真正的实惠？
Java EE5规范是一个所谓的雨伞规范(Umbrella)，在其下是一系列的子规范,主要包括：
| EJB 3.0 (JSR 220) Java Persistence API 1.0 (JSR 220) JSP 2.1 (JSR 245) JSF 1.2 (JSR 252) JAX-WS 2.0 (JSR 224) StAX 1.0 (JSR 173) JAXB 2.0 (JSR 222) Web Services Annotations 1.0 (JSR 181) Common Annotations 1.0 (JSR 250) SAAJ 1.3 maintenance | JTA 1.1 maintenance JavaMail 1.4 & JAF 1.1 maintenance JSTL 1.2 maintenance Java EE Mgmt maintenance JACC maintenance Servlet maintenance Java EE Deployment maintenance WSEE maintenance |
Java Persistence API 1.0( EJB3 Entity Bean) 在Java EE5中, Entity Bean做为EJB规范中负责持久化的组件将逐渐成为一个历史名词了，作为J2EE 4规范中最为人所垢病的Entity Bean在Java EE5中被推到重来，取而代之的是java开发的通用持久化规范Java Persistence API 1.0, 其实就是完全重新定义了的Entity Bean规范（目前在很多场合中，由于历史原因我们仍然使用ejb3持久化来称呼这个规范）。JPA作为java中负责关系数据持久化的组件已经完全独立出来成为一个单独的规范，而不再属于Enterprise Java Bean的范畴(EJB更多的是指Stateless/Stateful session bean和Message Driven Bean)。
Java Persistence AP(JPA)可以说是java持久化技术的一个集大成者，它吸取了Hiberante,JDO,TopLink等优秀技术和框架，将这几年发展成熟起来的基于POJO模型的O/R Mapping技术标准化，成为在J2EE和J2SE环境中通用的java持久化API。值得注意的是Java Persistence API并不是J2EE环境专用，而是在java中的通用API。意味着我们可以在任何需要访问关系数据库的地方使用JPA，甚至包括swing开发的桌面应用。JPA也不要求一定在J2EE容器中才能运行，而是任何有JVM的环境都可以运用。 这就使得我们可以很容易的把JPA作为一个持久化组件自由的和各种容器／框架（EJB3容器, Spring等等）组合。
JPA如何简化原来EJB2中Entity Bean的开发，看一个简单对比：
| EJB2.0 | EJB3.0(JPA) | |
| Business Interface | public inerface HelloWold extends EJBLocalObject{
Public String getResult();
}
| 无需定义接口 |
| 映射配置文件 | 编写EJB3 Deployment descriptor | 可选 |
| EJB实现 | public class HelloWorldEntityBean
implements HelloWold, EntityBean{
private int id;
private String result;
private EntityContext txt;
public HelloWorldEntityBean(){}
public void setEntityContext( EntityContext text ){
txt = text;
}
public String getResult(){
Return result;
}
public int getId(){
return id;
}
public void setResult( String result ){
this.result = result;
}
public String cretaeByName( String name ) throws EJBException{
.....
}
}
| @Entity
@Table(name=”hellotable”)
public class HelloWoldEntity{
@Id
private int id; p
private String result;
public HelloWoldEntity(){}
public String getResult(){
return result;
}
public int getId(){
return id;
}
public void setResult( String result ){
this.result = result;
}
}
|
在JPA 中，ejb3的Entity Bean就是一个简单的java bean，即POJO( Plain Old Java Object)。不象EJB2中的EntityBean需要跟容器有密切的关联（EJB2中必须有EntityContext），EJB3 中的entityBean和容器无关，事实上在JPA中，EntityBean也不再称为EntityBean,而是Entity，和Session Bean/Message Driven Bean的仍然存在的EJB区别开来。
为了简化O/R Mapping的配置，JPA大量采用JDK1.5的最重要的新特性annotaion直接在java代码中进行配置的标注。 采用annotation标注O/R Mapping配置可以大幅度减少以往使用xml配置O/R Mapping工作量，提高效率和可维护性。
下面是一个最简单的一对一关联关系采用annotation和xml的配置比较。
| Java Persistence API(EJB3 Persistence) | Hiberante | |
| 配置文件 | 可选 | 需要 |
| One-To-One配置 | 可选 | <one-to-one
name="address"
class="com.foo.Address"
cascade="All"
lazy="false"/>
|
| Java代码 | public class Order{
@OneToOne(cascade=CascadeType.ALL,fetch=FetchType.LAZYL)
Address address;
......
}
| public class Order{
Address address;
......
}
|
- 减少了配置文件的数量，特别是在实体(Entity)比较多的系统中，维护大量的O/R Mapping xml配置文件是不少的工作量。
- 减少了配置需要标注的内容。由于annotation由java compiler来编译解析，很多需要在xml配置中显式声明的内容不再需要（比如变量名称，类型，集合中的对象类型等）。
- Annotation的编译期检查可以避免xml文件中容易出现的配置语法错误，在IDE中及时发现和纠正。
- 无需在xml配置文件和java代码中切换，较少思维的跳跃，提高了开发效率。
- annotation被编译到java bytecode中，省略了xml的解析过程，极大的提升应用的启动速度和内存占用（特别是Entity多的情况）。
public interface EntityManager {
public void persist(Object entity);
public T merge(T entity);
public void remove(Object entity);
public T find(Class entityClass, Object primaryKey);
public T getReference(Class entityClass, Object primaryKey);
public void flush();
public void setFlushMode(FlushModeType flushMode);
public FlushModeType getFlushMode();
public void lock(Object entity, LockModeType lockMode);
public void refresh(Object entity);
public void clear();
public boolean contains(Object entity);
public Query createQuery(String ejbqlString);
public Query createNamedQuery(String name);
public Query createNativeQuery(String sqlString);
public Query createNativeQuery(String sqlString, Class result-
Class);
public Query createNativeQuery(String sqlString, String result-
SetMapping);
public void close();
public boolean isOpen();
public EntityTransaction getTransaction();
}
那又如何获得EntityManagerFactory呢？不管是在J2EE或者J2SE中，都需要通过一个persistence.xml配置文件对EntityMangaerFactory进行配置。下面是一个最简单的persistence.xml的范例。
<entity-manager>
<name>myEntityManager>/name>
<provider>com.redsoft.ejb3.PersistenceProviderImpl>/provider>
<class>com.redsoft.samples.HelloEntityBean>/class>
<properties>
<property name="ConnectionDriverName" value="com.mysql.jdbc.Driver"/>
<property name="ConnectionURL" value="jdbc:mysql://localhost/EJB3Test"/>
<property name="ConnectionUserName" value="ejb3"/>
<property name="ConnectionPassword" value="ejb3"/>
>/properties>
</entity-manager>
}
name – 定了当前这个EntityMangaerFactory的名字，我们可以在一个persistence.xml中定义多个EntityManagerFactory。
Provider – 定了提供EntityManagerFactory的具体实现类。这个实现类由不同的持久化产品开发商提供。例子中采用的是国产红工场的ejb3持久化实现的 EntityManagerFactory实现类。如如果我们需要更换成其他厂商的产品，就需要更换具体的实现类。
class – 列出所有需要被JPA管理的实体类。为了保证在J2SE/J2EE中的通用性和可移植性，JPA要求这里必须列出所有被JPA管理的实体类。
properties – 由持久化厂商自行定义的属性。
如果使用JTA事务，也可以使用 myDataSource定义。
在J2EE容器环境中和J2SE环境中，都是通过读取这个配置文件来初始化EntityMangaerFactory。在J2EE容器环境下，ejb3容器负责读取persistence.xml并初始化EntityManagerFactory，并将EntityManagerFactory帮定到JDNI中，这样我们就可以通过访问JNDI获得EntityManagerFactory, 进而获得EntityManager。由于EJB3容器支持IOC模式，我们也可以通过IOC将EntityMangerFactory直接注射给需要的使用JPA持久化的java类。通过IOC注射的方式获得EntityManagerFactory或者EntityManager是更方便，合理和推荐的方式。
而在J2SE环境中，我们可以通过标准的javax.persistence.Persistence类来获得EntityManagerFactory。Javax.persistence.Persistence会在当前classpath或者jar包的META-INF/下搜索并读persistence.xml后初始化EntityManagerFactory。
下面是一个简单的示例如何在J2SE环境中获得EntityManagerFactory并获得EntityManager,运用EntityManager持久化HelloWorldEntityBean.
public class HelloWorld {
public static void main( final String[] args ){
/*
* Obtain an EJB3 entity manager
*/
final EntityManagerFactory emf = Persistence.createEntityManagerFactory();
final EntityManager entityManager = emf.createEntityManager();
// Construct a HelloEntityBean
final HelloEntityBean hello = new HelloEntityBean( 1, "foo" );
EntityTransaction trans = entityManager.getTransaction();
trans.begin();
entityManager.persist( hello );
trans.commit();
System.out.println( "Successfully persist hello: " + hello );
// Look up the HelloEntityBean by primarky key
final HelloEntityBean anotherHello = entityManager.find( HelloEntityBean.class, new Integer( hello.getId() ) );
System.out.println( "Found hello: " + anotherHello );
// close the EntityManager
entityManager.close();
emf.close();
}
}
在上面HelloWorld的例子中我们需要显式调用javax.persistence.Persistence.createEntityManagerFactory, 并且显式地开始事务和关闭事务。在今天大量使用IOC托管容器的时代，这样的编码已经显得落后。
作为J2EE一个部分的JPA自然可以利用EJB3的IOC容器托管事务和注射资源，同样的也可以使用开源IOC容器spring来托管事务和注射资源。红工场也提供了一个开源的 spring DAO扩展 http://sourceforge.net/projects/ejb3daosupport是来支持JPA和Spring的结合。
下面是一个如何在Spring中托管事务和在DAO中注入EntityManager的配置范例：
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "file://spring-beans.dtd"> <beans> <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName"><value>com.mysql.jdbc.Driver</value></property> <property name="url"><value>jdbc:mysql://localhost/EJB3Test</value></property> <property name="username"><value>ejb3</value></property> <property name="password"><value>ejb3</value></property> </bean> <bean id="entityManagerFactory" class="org.springframework.orm.ejb3.LocalEntityManagerFactoryBean"> <property name="persistenceInfo"><ref local="persistenceInfo"/></property> </bean> <bean id="persistenceInfo" class="com.redsoft.ejb3.PersistenceInfoImpl"> <property name="nonJtaDataSource"><ref local="dataSource"/></property> <property name="entityManagerName"><value>myEntityManager</value></property> <property name="persistenceProviderClassName"> <value> com.redsoft.ejb3.PersistenceProviderImpl </value> </property> <property name="entityClassNames"> <list> <value>com.redsoft.ejb3.spring.Child</value> <value>com.redsoft.ejb3.spring.Father</value> </list> </property> <property name="properties"> <props> <prop key="javax.jdo.PersistenceManagerFactoryClass"> com.redsoft.jdo.PersistenceManagerFactoryImpl </prop> </props> </property> </bean> <bean id="transactionManager" class="org.springframework.orm.ejb3.EJB3TransactionManager" singleton="true"> <property name="entityManagerFactory"> <ref local="entityManagerFactory" /> </property> </bean> <bean id="dao" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean" singleton="true"> <property name="transactionManager"> <ref local="transactionManager" /> </property> <property name="target"> <bean class="com.redsoft.ejb3.spring.DAOImpl"> <property name="entityManagerFactory"> <ref local="entityManagerFactory" /> </property> </bean> </property> <property name="transactionAttributes"> <props> <prop key="save*">PROPAGATION_REQUIRED</prop> <prop key="remove*">PROPAGATION_REQUIRED</prop> <prop key="del*">PROPAGATION_REQUIRED</prop> <prop key="update*">PROPAGATION_REQUIRED</prop> <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop> <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop> </props> </property> </bean> </beans>
===================================================
转载自：http://blog.csdn.net/starshus/article/details/5892845
1.本文主要技术采用了Servlet + JSP + EJB 3.0 + JPA，开发环境用的是EclipseHelios + JDK 1.6 + JBOSS 5.1 +MySQL 5.1数据库。
2. 2. 示例场景：用户通过Web页面对Employee进行创建、查找和删除。这个小例子重点是演示JPA的使用。JPA是JavaPersistence API的缩写，主要是将关系数据库的操作对象化，它的j2ee的标准规范，由于其自身简单易用的优点，也是SAP推荐使用的数据库技术。
3. 3.准备工作：
(1) 安装JBOSS 5.1
(2) 安装MySQL 5.1
(3) 给Jboss配置数据源
首先启动mysql后，创建一个数据库叫ejbtest，然后创建一个用户jboss，密码是password，并将ejbtest的权限赋给它。
然后在路径jboss-5.1.0.GA/server/default/deploy下放入mysql-ds.xml文件。
Mysql-ds.xml:
<datasources>
<local-tx-datasource>
<jndi-name>MySqlDS</jndi-name>
<connection-url>jdbc:mysql://localhost:3306/ejbtest</connection-url>
<driver-class>com.mysql.jdbc.Driver</driver-class>
<user-name>jboss</user-name>
<password>password</password>
</local-tx-datasource>
</datasources>
4. 4.开发
4.1先创建一个EJB Project，名字叫EmployeeEJB。
然后在META-INF目录下新建一个persistence.xml文件
<?xmlversion="1.0"encoding="UTF-8"?>
<persistencexmlns="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_1_0.xsd"
version="1.0">
<persistence-unitname="EmployeeDS">
<jta-data-source>java:/MySqlDS</jta-data-source>
<properties>
<propertyname="hibernate.hbm2ddl.auto"value="update"/>
</properties>
</persistence-unit>
</persistence>
4.2开始创建我们的Entity Bean：Employee类，它是一个简单的Java Bean。
package com.sap.demo.ejb.employee.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Employee {
@Id
private int id;
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;
}
private String name;
}
4.3 在ejb项目中创建一个Local的SessionBean，名字叫EmployeeServicel，它的主要功能是对employee进行数据的操作，包括创建、查找、删除。
接口声明：
package com.sap.demo.ejb.employee.ejb;
import javax.ejb.Local;
importcom.sap.demo.ejb.employee.model.Employee;
@Local
public interface EmployeeServiceLocal {
public Employee createEmployee(int id, String name);
public Employee findEmployee(int id);
public void deleteEmployee(int id);
}
这里是接口的实现：
package com.sap.demo.ejb.employee.ejb;
import javax.ejb.Stateless;
import javax.ejb.TransactionAttribute;
import javax.ejb.TransactionAttributeType;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
importcom.sap.demo.ejb.employee.model.Employee;
/**
*Session Bean implementation class EmployeeService
*/
@Stateless
public class EmployeeService implements EmployeeServiceLocal {
@PersistenceContext(unitName= "EmployeeDS")
private EntityManager em;
@Override
public Employee createEmployee(int id, String name) {
Employeeemp = new Employee();
emp.setId(id);
emp.setName(name);
em.persist(emp);
returnemp;
}
@Override
@TransactionAttribute(TransactionAttributeType.SUPPORTS)
public Employee findEmployee(int id) {
return em.find(Employee.class, new Integer(id));
}
@Override
public void deleteEmployee(int id) {
Employee emp = findEmployee(id);
if(emp != null) {
em.remove(emp);
}
}
}
这样EJB项目就创建完毕了。
4 4.4 然后创建Web Project，名字叫EmployeeWeb。这个项目很简单，包含一个Servlet和两个页面index.jsp和result.jsp。用户在index.jsp对employee进行创建、查找、删除，然后由result.jsp负责展示结果。
Index.jsp
<%@pagelanguage="java"contentType="text/html;charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPEhtmlPUBLIC"-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<metahttp-equiv="Content-Type"content="text/html; charset=ISO-8859-1">
<title>Insert titlehere</title>
</head>
<body>
<FORMACTION="ShowResult">
Id:
<INPUTTYPE="text"NAME="id"/><P>
Name:
<INPUTTYPE="TEXT"NAME="name"/>
<INPUTTYPE="hidden"NAME="method"VALUE="create"/>
<INPUTTYPE="SUBMIT"VALUE="Createemployee and show result.">
</FORM>
<FORMACTION="ShowResult">
Id:
<INPUTTYPE="text"NAME="id"/>
<inputTYPE="hidden"NAME="method"VALUE="find"/>
<INPUTTYPE="SUBMIT"VALUE="Find employeeand show result.">
</FORM>
<FORMACTION="ShowResult">
Id:
<INPUTTYPE="text"NAME="id"/>
<inputTYPE="hidden"NAME="method"VALUE="delete"/>
<INPUTTYPE="SUBMIT"VALUE="Deleteemployee and show result.">
</FORM>
</body>
</html>
result.jsp
<%@pagelanguage="java"contentType="text/html;charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPEhtmlPUBLIC"-//W3C//DTDHTML 4.01 Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<metahttp-equiv="Content-Type"content="text/html; charset=ISO-8859-1">
<title>Insert titlehere</title>
</head>
<body>
<jsp:useBeanid="employee"type="com.sap.demo.ejb.employee.model.Employee"scope="request"/>
id:<jsp:getPropertyname="employee"property="id"/>,
name:<jsp:getPropertyname="employee"property="name"/>
</body>
</html>
最后是Servlet ShowResult:
package com.sap.demo.ejb.servlets;
import java.io.IOException;
import javax.ejb.EJB;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
import com.sap.demo.ejb.employee.ejb.EmployeeServiceLocal;
importcom.sap.demo.ejb.employee.model.Employee;
/**
*Servlet implementation class ShowResult
*/
public class ShowResult extends HttpServlet {
private static final long serialVersionUID = 1L;
@EJB
privateEmployeeServiceLocal service;
/**
*@see HttpServlet#HttpServlet()
*/
public ShowResult() {
super();
// TODO Auto-generated constructor stub
}
/**
* @see HttpServlet#doGet(HttpServletRequestrequest, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {
String method = request.getParameter("method");
if(method.equals("create")) {
Stringname = request.getParameter("name");
Stringids = request.getParameter("id");
intid = Integer.parseInt(ids);
Employeeem = service.createEmployee(id, name);
request.setAttribute("employee",em);
}else if (method.equals("find")) {
Stringids = request.getParameter("id");
intid = Integer.parseInt(ids);
Employeeem = service.findEmployee(id);
request.setAttribute("employee",em);
}else if (method.equals("delete")){
Stringids = request.getParameter("id");
intid = Integer.parseInt(ids);
Employeeem = service.findEmployee(id);
if(em != null){
service.deleteEmployee(id);
request.setAttribute("employee",em);
}
}
RequestDispatcher dispatcher = request.getRequestDispatcher("result.jsp");
dispatcher.forward(request,response);
}
/**
* @see HttpServlet#doPost(HttpServletRequestrequest, HttpServletResponse response)
*/
protected void doPost(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {
//TODO Auto-generated method stub
}
}
5. 5.部署程序、运行：
首先输入一个编号和用户名，点击创建
然后可以看到创建完毕。
然后输入编号，点查找
找到了结果。
最后看一下数据库，数据在数据库中
6. 6.小结
一共是三个项目，EmpoyeeESR,EmployeeEJB, EmployeeWeb。关于部署和运行的细节我就不细说了。这个例子虽然很简单，但是麻雀虽小，五脏俱全。有几个地方值得注意：
（1）首先它还是演示了EJB3.0的诸多优点，Employee虽然是一个EntityBean，但是它只是一个普通的javabean,不过加了一个@Entity的注释。另外在Servelt中，我们使用SessionBean EmployeeServiceLocal的时候是通过Inception的方式，非常简单。
（2）EJB项目里的persistent.xml保存了一些关于数据源的信息。在使用JPA的EntityManager来进行数据操作时，必须首先声明persistentunit。
（3）Session Bean EmployeeService值得注意，它使用了JPA的EntityManger，也是通过注入的方式。然后对数据库的操作也就是transaction都由服务器自动管理。对于find方法，我们使用了这样的注释：@TransactionAttribute(TransactionAttributeType.SUPPORTS)
这是指不用使用transaction。默认是自动打开事务并提交到数据库。
这个例子前端采用jsp展示，业务逻辑有EJB来实现，持久层使用了JPA来对业务对象进行操作。下一部分，我想使用SAP的CAF来完成同样的功能。
5028
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
