使用 Apache OpenJPA 开发 EJB 3

合集下载

EJB3学习笔记

EJB是企业级系统的核心部分，用于运行业务逻辑，是处理业务逻辑的一种方案（O/R Mapping）。

EJB有下面3种类型：Session Bean分为Stateless Session Bean和Stateful Session Bean两种Entity Bean分为Bean-Managed Persistence Entity Bean（BMP）和Container-Managed Persistence Entity Bean（CMP）。

BMP要在Bean中包含访问数据库的SQL代码，故称为Bean-Managed；后者不需要编写SQL代码，SQL代码由Container或者包含Container的服务器自动产生，故称为Container-Managed。

Message-Driven Bean专门接收和处理消息，而发送消息可以是一般的Session Bean、Entity Bean或者其他类型的程序。

JPA（Java Persistence API）是EJB 3.0（JSR220）持久层的实现规范。

JPA式样在制定的过程中，充分借鉴了Hibernate的优点，JPA的很多概念都可以从Hibernate中找到原型。

目前，JPA规范有三种实现方案：Hibernate EntityManager、OpenJPA、Oracle TopLink Essentials。

Hibernate EntityManager实现了EJB3.0 JPA规范。

Hibernate EntityManager封装了成熟具有强大功能Hibernate core功能，你可以在Hibernate EntityManager里使用Hibernate API，SQL，JDBC等。

事实上，可以通过Hibernate EntityManager，非常容易地把一个Hibernate 应用改造成JPA应用。

Hibernate EntityManager可以作为一个标准的Java Persistence provider，使用在任何Java EE 5.0应用服务器以及标准EJB 3.0容器中，或者JDK 5.0环境中。

Java的EJB3

Java的EJB3.0规范第一章：引言EJB（Enterprise JavaBeans）是一个用于构建分布式企业级应用程序的Java 规范。

EJB旨在简化企业应用程序的开发和部署过程，并提供一种标准化的方法来处理事务管理、持久化和安全性等关键功能。

本文将重点介绍EJB的最新版本——EJB3.0规范，探讨其特性和用法。

第二章：EJB3.0规范概述EJB3.0规范于2006年发布，是Java EE 5.0规范的一部分。

EJB3.0的目标是简化EJB的编程模型，通过引入注解和依赖注入等新特性来减少开发人员的工作量。

相比于之前的版本，EJB3.0提供了更加简洁、轻量级的编程模型，使得开发分布式应用程序更加容易。

第三章：EJB3.0的新特性3.1 注解驱动开发模式EJB3.0引入了注解驱动的开发模式，取代了之前版本中的繁琐的XML配置。

开发人员可以使用注解来描述EJB的属性、行为和依赖关系，简化了开发过程，并提高了代码的可读性和可维护性。

3.2 依赖注入依赖注入是EJB3.0中的一个重要特性。

通过使用注解，开发人员可以在EJB中声明依赖关系，由容器负责注入相应的资源或其他EJB实例。

这样一来，开发人员可以很容易地实现解耦，提高代码的可测试性和可重用性。

3.3 持久化EJB3.0规范还引入了Java Persistence API（JPA），提供了一种标准化的方法来进行对象持久化。

开发人员可以使用注解来描述实体类和持久化对象之间的映射关系，让开发和维护数据库相关的代码变得更加简单和直观。

3.4 拦截器EJB3.0规范引入了拦截器机制，允许开发人员在EJB的方法调用前后插入逻辑。

开发人员可以使用注解来声明拦截器，灵活地处理事务管理、安全性等非业务逻辑的需求。

第四章：EJB3.0的应用场景4.1 企业级应用程序开发EJB3.0规范的简化和灵活性使其成为构建复杂企业级应用程序的理想选择。

开发人员可以使用EJB3.0来处理事务管理、安全性、持久化等关键功能，从而实现高度可靠和可扩展的应用程序。

第18章 EJB 3

26
第18章
主要内容：
EJB3的新特性 EJB的组成部分有状态会话Bean 有状态会话Bean 消息驱劢Bean
EJB 3
EJB的上下文和环境
拦截器 ejb-jar文件
18.1 EJB3的新特性
Java语言元注释的使用：例如，要声明一个无状态会话Bean，
使用@Stateless声明这个类即可。
挃定程序的缺省设置：例如，当Bean类实现了一个接口，这个
接口默认就是EJB的业务接口。
对于环境资源的访问比以前的版本要简单的多。下面的代码访
问EJB的业务方法：
@EJB private static PersonalRevenue personalRevenue; personalRevenue.getPersonalRevenue(3000,1600);
使用MessageDriven注释或者在部署描述器中使用message-
driven声明
消息驱劢Bean的生命周期回调方法
PostConstruct和PreDestroy
依赖注入：可以注入需要的资源
18.8 EJB的上下文和环境
EJB的上下文包括容器上下文和资源、环境上下文。
Bean可以获取对资源以及其它环境实体的引用，这些引用是
setter注入
引用的资源的类型由属性确定
@Resource(name="customerDB") public void setDataSource(DataSource myDB) { this.ds = myDB; }
引用的资源的名字和类型由属性的名字和类型确定
@Resource public void setCustomerDB(DataSource myDB) { this.customerDB = myDB; }

EJB3.0 开发平台配置和开发原理

EJB3.0开发平台安装 and开发原理（1）. 《EJB3.0开发平台配置》第一步：开发平台的搭建1、下载与安装JDK2、下载与安装Eclipse3、下载与安装JBoss第二步：运行Eclipse，新建一个普通的Java项目：4、菜单操作路径：File-New-Projcet；5、进入新建项目向导窗口，选择Java-Java Project；6、点击next,输入Project name：HelloStudy（名字可以任意取），再按Finish；7、在项目名称上面按右建选择Properties;8、单击左窗格中的Java Build Path；文件，再点击打开；择javaee.jar，再点击打开,再点击OK；11、菜单操作路径：File-New-Class12、分别输入package：com.foshanshop.ejb3，以及Name：HelloWorld后，点击Finish；的HelloWorld.java，打开该文件，按照书上的内容输入代码；14、菜单操作路径：File-New-Class15、分别输入package：com.foshanshop.ejb3.impl，以及Name：HelloWorldBean后，点击Finish；16、双击左侧框HelloStudy项目下的com.foshanshop.ejb3.impl，再双击com.foshanshop.ejb3.impl下面的HelloWorldBean.java，打开该文件，按照书上的内容输入代码；17、在HelloStudy项目上右击，选择Export，在弹出的Export对话框中选择JAR file；18、单击Next按钮，在弹出的JAR Export对话框的select the resources to export（选择要导出的资源）列表框中展开你的项目并选择需要打包的文件。

然后选择一个存放目录及文件夹名，单击Finish按钮结束打包；第七步：当项目打包成jar文件后，将它发布到Jboss：19、发布前先检查JBoss是否已经启动，如果没有启动，打开DOS命令符窗口，进入“JBoss安装目录/bin”，运行run.bat启动JBoss。

Struts2.1+Spring3.0+JPA1.0(Hibernate3.3实现)例子

Struts2.1+Spring3.0+JPA1.0(Hibernate3.3实现)例子文章分类:Java编程本文代码是传智播客黎活明老师所讲的《Spring2.5视频教程》各种示例的综合，在此把所有框架升级到最新版本整合一下。

/blog/582117所用jar包：Struts：struts-2.1.8.1\lib下除了各种plugin(保留struts2-spring-plugin-2.1.8.1.jar)的所有文件Spring：spring-framework-3.0.0.RELEASE\dist下的所有文件Hibernate：hibernate-distribution-3.3.2.GA下的hibernate3.jar\lib\bytecode\cglib下的cglib-2.2.jar\lib\optional\ehcache下的ehcache-1.2.3.jar\lib\required下的所有文件hibernate-annotations-3.4.0.GA下的hibernate-annotations.jar\lib下的ejb3-persistence.jar，hibernate-commons-annotations.jar hibernate-entitymanager-3.4.0.GA下的hibernate-entitymanager.jar \lib\test下的log4j.jar，slf4j-log4j12.jarMySQL：mysql-connector-java-5.1.10-bin.jarJUnit：4JDK：jdk-6u14-windows-i586.exeTomcat：apache-tomcat-6.0.18.zip项目名：testPerson.javaJava代码package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;@Entitypublic class Person implements Serializable {private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}}package com.test.bean;import java.io.Serializable;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue; import javax.persistence.Id;@Entitypublic class Person implements Serializable { private Integer id;private String name;public Person(){}public Person(String name){ = name;}@Id @GeneratedValuepublic Integer getId() {return id;}public void setId(Integer id) {this.id = id;}@Column(length=10,nullable=false)public String getName() {return name;}public void setName(String name) { = name;}@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + ((id == null) ? 0 : id.hashCode());return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)return true;if (obj == null)return false;if (getClass() != obj.getClass())return false;final Person other = (Person) obj;if (id == null) {if (other.id != null)return false;} else if (!id.equals(other.id))return false;return true;}} PersonService.javaJava代码package com.test.service;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();}package com.test.service;import java.util.List;import com.test.bean.Person;public interface PersonService {public void save(Person person);public void update(Person person);public void delete(Integer personid);public Person getPerson(Integer personid);@SuppressWarnings("unchecked")public List<Person> getPersons();} PersonServiceBean.javaJava代码package com.test.service.impl;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Person o").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}}package com.test.service.impl;import java.util.List;import javax.persistence.EntityManager;import javax.persistence.PersistenceContext;import org.hibernate.exception.SQLGrammarException;import org.springframework.transaction.annotation.Propagation; import org.springframework.transaction.annotation.Transactional; import com.test.bean.Person;import com.test.service.PersonService;@Transactionalpublic class PersonServiceBean implements PersonService { @PersistenceContext EntityManager em;public void delete(Integer personid) {em.remove(em.getReference(Person.class, personid));}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)public Person getPerson(Integer personid) {return em.find(Person.class, personid);}@Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)@SuppressWarnings("unchecked")public List<Person> getPersons() throws SQLGrammarException {return em.createQuery("select o from Persono").getResultList();}public void save(Person person) {em.persist(person);}public void update(Person person) {em.merge(person);}} PersonAction.javaJava代码package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) { this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) { this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}package com.test.web.action;import java.util.List;import javax.annotation.Resource;import com.test.bean.Person;import com.test.service.PersonService;public class PersonAction {@Resource PersonService personService;private String message;private List<Person> persons;private Person person;public Person getPerson() {return person;}public void setPerson(Person person) {this.person = person;}/*** 人员列表显示*/public String list(){this.persons = personService.getPersons();return "list";}/*** 人员添加界面*/public String addUI(){return "add";}/*** 人员添加*/public String add(){this.personService.save(this.person);this.message="添加成功";return "message";}public List<Person> getPersons() {return persons;}public void setPersons(List<Person> persons) {this.persons = persons;}public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}}PersonServiceTest.javaJava代码package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);}@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}}package junit.test;import java.util.List;import org.junit.BeforeClass;import org.junit.Test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationConte xt;import com.test.bean.Person;import com.test.service.PersonService;public class PersonServiceTest {private static PersonService personService;@BeforeClasspublic static void setUpBeforeClass() throws Exception { try {ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");personService = (PersonService) applicationContext.getBean("personService");} catch (RuntimeException e) {e.printStackTrace();}}@Testpublic void testSave() {personService.save(new Person("小张"));}@Testpublic void testUpdate() {Person person = personService.getPerson(1);person.setName("小丽");personService.update(person);@Testpublic void testGetPerson() {Person person = personService.getPerson(2);System.out.println(person.getName());try {System.out.println("请关闭数据库");Thread.sleep(1000 * 15);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("第二次开始获取");person = personService.getPerson(2);System.out.println(person.getName());}@Testpublic void testDelete() {personService.delete(1);}@Testpublic void testGetPersons() {List<Person> persons = personService.getPersons();for (Person person : persons) {System.out.println(person.getName());}}} META-INF\persistence.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="1234"/><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&char acterEncoding=UTF-8"/><property name="hibernate.max_fetch_depth" value="3"/><property name="hibernate.hbm2ddl.auto" value="update"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.format_sql" value="true"/><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence><?xml version="1.0" encoding="UTF-8"?><persistence xmlns="/xml/ns/persistence" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/persistence/xml/ns/persistence/persistence_1_0.xsd"version="1.0"><persistence-unit name="test" transaction-type="RESOURCE_LOCAL"><properties><property name="hibernate.dialect" value="org.hibernate.dialect.MySQL5Dialect"/><property name="hibernate.connection.driver_class" value="org.gjt.mm.mysql.Driver"/><property name="ername" value="root"/><property name="hibernate.connection.password" value="1234"/><property name="hibernate.connection.url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&char acterEncoding=UTF-8"/><property name="hibernate.max_fetch_depth" value="3"/><property name="hibernate.hbm2ddl.auto" value="update"/><property name="hibernate.show_sql" value="true"/><property name="hibernate.format_sql" value="true"/><property name="e_second_level_cache" value="true"/><property name="e_query_cache" value="false"/><property name="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/></properties></persistence-unit></persistence> src\beans.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans><?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance" xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd /schema/context/schema/context/spring-context-3.0.x sd/schema/aop/schema/aop/spring-aop-3.0.xsd /schema/tx/schema/tx/spring-tx-3.0.xsd"> <context:annotation-config/><bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBea n"><property name="persistenceUnitName" value="test"/></bean><bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager"> <property name="entityManagerFactory" ref="entityManagerFactory"/></bean><tx:annotation-driven transaction-manager="txManager"/><bean id="personService" class="com.test.service.impl.PersonServiceBean"/><bean id="personAction" scope="prototype" class="com.test.web.action.PersonAction" /></beans> src\ehcache.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache><?xml version="1.0" encoding="UTF-8"?><ehcache><diskStore path="C:\cache"/><defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"timeToIdleSeconds="120"timeToLiveSeconds="180"diskPersistent="false"diskExpiryThreadIntervalSeconds="60"/><cache name="com.test.bean.Person" maxElementsInMemory="100" eternal="false"overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/></ehcache>src\struts.xmlXml代码<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC"-//Apache Software Foundation//DTD Struts Configuration 2.1//EN""/dtds/struts-2.1.dtd"><struts><constant name="struts.i18n.encoding" value="UTF-8"/><!-- 该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。

EJB3.0快速入门项目开发步骤

E J B3.0开发步骤1.开发环境IDE开发工具：Eclipse Java EE IDE for Web DevelopersEJB容器：jboss-4.2.3.GA(将jboss-4.2.3.GA.rar解压缩到任意一个分区下) 后台数据库：MysQL5.12.开发步骤2.1在Eclipse中配置jboss-4.2.3.GA1.点击小三角，选中New server2.选中JBOSS AS4.23.点击ADD，进行JBOSS配置4.在Home Directory中，点击Browser选择JBOSS4.2的安装目录，在JRE中配置JRE的安装目录，点击finish在finish，即可完成对ＪＢＯＳＳ在Ｅｃｌｉｐｓｅ中的配置。

2.2新建EJB3.0工程titan1.右键－>Ｎｅｗ->Project2.选择EJB Project next3.Project name为“titan”，Target runtime选择配置好的JBOSS4.2，EJB module version选择3.0，然后finish。

新的EJB3.0工程创建成功。

2.3项目开发2.3.1开发Cabin实体Beanpackage com.titan.domain;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.Id;import javax.persistence.Table;@Entity//告知persistence provider这是一个映射到数据的实体类，并且可以受管于EntityManager服务。

@Table(name="CABIN") //告知EJB容器，bean class 应该被映射到哪一张数据库表。

public class Cabin implements java.io.Serializable{private static final long serialVersionUID = 1L;private int id;private String name;private int deckLevel;private int shipId;private int bedCount;@Id//表示CAbin实体的主键，主键标志是必须的@Column(name="ID") //定义如何将成员属性映射到数据库表CABIN中的字段。

EJB3.0开发Session Bean

Jbuilder 2007开发EJB3.0 Session Bean罗代均 ldj_work# 2007年8月一. 准备开发环境Jbuilder 2007,新版JBuilder2007基于Eclipse平台,与以往的JBuilder版本完全不同.借助于Eclipse的开放平台以及丰富的插件,使得JBulider对当前的流行的框架支持非常好,同时支持EJB3.0的可视化开发.Jboss 4.0, Jbuilder 2007自带,在JBuilder安装目录下的thirdparty目录下.二. 在JBuilder 2007中配置JBoss4.02.1选择菜单Window | Preferences...2.2 配置Server2.2.1左边选择servler,单击右边的 [Add] 按钮2.2.2在弹出的”New Server Runtime”对话框中,选择JBoss 4.0 for EJB3.02.2.3 单击[Next]按钮,选择JBoss的目录,在JBuilder安装目录下的thirdparty目录下三. 建立EJB3.0工程3.1 选择菜单 File | New | Project...在弹出对话框中.选择ejb Modeling Project项目3.2 单击[Next]按钮,输入工程名称 EJB3Demo3.3 选择EJB版本,EJB Module选择3.0,java选择5.03.4 单击[Finish]按钮,打开建模透视图四. 开发Session Bean4.1 新建Session Bean选择Session Bean图标,然后在右边画图区单击鼠标,修改Session Bean的属性4.2新增业务方法其实ejb3.0的session bean只是普通java类,所以我们手工编写业务方法即可打开Java透视图打开IHelloSessionRemote.java,添加方法sayHello IhelloSessionRemote.java内容如下package demo;@javax.ejb.Remotepublic interface IHelloSessionRemote {void sayHello();}打开HelloSession.java,实现sayHello方法HelloSession.java的内容如下package demo;import javax.ejb.Stateless;@Stateless(name="HelloSession")public class HelloSession implements IHelloSessionRemote {public void sayHello() {System.out.println("Hello,我是Luo Dai jun!!");}}4.3导出jar包选择菜单File | Export,弹出对话框选择JAR File单击[Next]按钮.选择jar包导出的位置单击[Finish]按钮,完成导出五.部署及测试5.1 部署EJB把我们刚才导出的jar文件.放到JBoss下的server\default\deploy目录,我这里是D:\JBuilder2007\thirdparty\jboss-4.0.5.GA\server\default\deploy下ok,ejb部署好了.下面我们写一个servlet测试一下5.2 测试EJB5.2.1新建动态web项目选择菜单 File | new | Project ,在弹出对话框中选择web|Dynamic Web Project单击[Next]按钮,填写工程名称单击{Finish]按钮,完成.5.2.2 新建Servlet单击右键.选择New | Servlet弹出对话框中,按下图填写单击[Finish]按钮完成5.2.3 在TestServlet的doGet方法中,编写测试EJB的代码TestServlet.java内容如下package test;import java.io.IOException;import javax.naming.InitialContext;import javax.naming.NamingException;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import demo.IHelloSessionRemote;public class TestServlet extends javax.servlet.http.HttpServlet implementsjavax.servlet.Servlet {private static final long serialVersionUID = 1L;protected void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {try {InitialContext ctx = new InitialContext();IHelloSessionRemote helloSession =(IHelloSessionRemote) ctx.lookup("HelloSession/remote");// HelloSession,就是SessionBean的类名，不包括包名// 调用sayHello方法看看??helloSession.sayHello();} catch (NamingException e) {e.printStackTrace();}}protected void doPost(HttpServletRequest request,HttpServletResponse response)throws ServletException, IOException {}}5.2.4 运行TestServlet,测试效果 ^_^右键, 选择 Run As | Run on server选择JBoss 4.0 for EJB3.0单击[Finish]按钮,完成打开IE浏览器,输入 http://localhost:8080/TestEJB/TestServlet嗯..看看JBuilder 的控制台吧嗯.结束,打完收工!!。

EJB3[1].0讲授

1.会话会话bean(session bean) 会话
负责与客户端交互,是编写业务逻辑的地方,在会话bean中可以通过 jdbc直接操作数据库,但大多数情况下都是通过实体bean来完成对数据库的操作.
2.实体实体bean(entity bean) 实体
它实际上属于java持久化规范(简称JPA)里的技术, JPA的出现主要是为了简化现有的持久化开发工作和整合ORM技术,结束现在Hibernate, TopLink等ORM框架各自为营的局面.
客户端
EJB
在这个过程中我们看到,有网络通信的开销,协议解析的开销,对象序列化的开销.因为ejb是分布式技术,它允许客户端与ejb应用在不同一机器上面,所以这些性能开销也是必然的.但是在实际生产中,不可避免存在这种情况:客户端与EJB应用运行在同一个jboss中.这时候客户端访问ejb是否有必要走上面的网络通信呢?据我们所知,这时候客户端与ejb是在同一个jvm内,他们之间完全可以通过内存进行交互,这样就可以避免网络通信的性能开销.既然我们都想到了这一点,EJB专家组也想到了这一点,所以引入了本地接口.通过本地接口调用ejb,直接在内存中交互,这样就能避免因网络通信所造成的各种性能开销.但是有一点,大家必须注意,只有客户端与EJB应用在同一个JVM内运行的时候,我们才能调用本地接口,否则只能调用远程接口.谈到这里,有同学会问什么情况下客户端与EJB应用是在同一个JVM?简单地说只要客户端与ejb发布在同一个jboss内, 我们就认为他们是在同一个JVM
Jboss默认生成的JNDI 名称
当EJB发布到Jboss 时,如果我们没有为它指定全局JNDI名称或修改过其默认EJB名称,Jboss就会按照默认的命名规则为EJB生成全局JNDI名称,默认的命名规则如下: 如果把EJB作为模块打包进后缀为*.ear的JAVA EE企业应用文件,默认的全局JNDI名称是本地接口:EAR-FILE-BASE-NAME/EJB-CLASS-NAME/local 远程接口:EAR-FILE-BASE-NAME/EJB-CLASS-NAME/remote EAR-FILE-BASE-NAME为ear文件的名称,EJB-CLASS-NAME为EJB的非限定类名. 例:把HelloWorld应用作为EJB模块打包进名为HelloWorld.ear的企业应用文件,它的远程接口的JNDI 名称是:HelloWorld/HelloWorldBean/remote 如果把EJB应用打包成后缀为*.jar的模块文件,默认的全局JNDI名称是本地接口:EJB-CLASS-NAME/local 远程接口:EJB-CLASS-NAME/remote 例:把HelloWorld应用打包成HelloWorld.jar文件,它的远程接口的JNDI名称是: HelloWorldBean/remote

JPA简介

JPA简介1.JPA简介：Java持久化规范，是从EJB2.x以前的实体Bean(Entity bean)分离出来的，EJB3以后不再有实体bean，而是将实体bean放到JPA中实现。

JPA是sun提出的一个对象持久化规范，各JavaEE应用服务器自主选择具体实现，JPA的设计者是Hibernate框架的作者，因此Hibernate作为Jboss服务器中JPA的默认实现，Oracle的Weblogic使用EclipseLink(以前叫TopLink)作为默认的JPA实现，IBM的Websphere和Sun的Glassfish默认使用OpenJPA(Apache的一个开源项目)作为其默认的JPA实现。

JPA的底层实现是一些流行的开源ORM(对象关系映射)框架，因此JPA其实也就是java实体对象和关系型数据库建立起映射关系，通过面向对象编程的思想操作关系型数据库的规范。

2.JPA的持久化策略文件：根据JPA规范要求，在实体bean应用中，需要在应用类路径(classpath)的META-INF目录下加入持久化配置文件——persistence.xml，该文件就是持久化策略文件。

其内容如下：注意：可以在持久化策略文件中配置多个持久化单元persistence-unit，在使用分布式数据库时经常配置多个持久化单元。

3.实体Bean的开发：JPA规范中定义的实体bean开发的基本规范：(1).在实体bean上添加”@Entity”注解，标识该bean为实体bean。

(2).实体bean必须序列化。

(3).使用”@Table(name=数据库表名)”注解，标识该实体bean映射到关系型数据库中的表名，如果不指定则JPA实现会自动生成默认的表名称。

(4).必须有一个使用”@Id”注解标识的主键，如指定自增主键的写法为：注意：@Id和@GeneratedValue两个注解必须同时使用，标识了注解之后，要主键的生成策略。

IBM WAS V8.0新特性介绍

IBM WebSphere Application Server V8.0 中的新特性引言WebSphere Application Server 产品从V6.1 开始，以功能部件包(Feature Pack) 的形式向客户提供新的功能，而下一个大版本都会融合上一个版本Feature Pack 提供的功能，并对其进行进一步改进。

举例来说，WebSphere Application Server V6.1 有三个功能部件包，其中的EJB 3.0 和Web Services 功能部件包被集成到WebSphere Application Server V7.0 中，并且其功能进一步得到增强。

WebSphere Application Server V7.0 有六个Feature Pack，其中CEA, XML, SCA, OSGi 应用和JPA 2.0 和Modern Batch 这五个功能部件包的功能被集成到了V8.0 版本中，并对其进行了改进。

而Web 2.0 & Mobile 和Dynamic Scripting 这两个编程模型以WebSphere Application Server V8 的功能部件包的形式提供给用户。

与IBM Rational Application Developer 开发工具结合使用，WebSphere Application Server V8.0 支持Java EE 6、OSGi 应用、Mobile、SCA、SIP/CEA、XML、Batch 等应用的开发，成为名副其实的，为客户提供了最广泛的编程模型的应用服务器（参看图1）。

图 1. WebSphere Application Server 支持的编程模型IBM 提供了一款免费的应用迁移工具(Application Migration Toolkit) [2]，支持将您的Java EE 应用快速地迁移到WebSphere Application Server V8.0 上来。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

使用 Apache OpenJPA 开发 EJB 3.0 应用，第 1 部分: OpenJPA 与 EJB 3.02007 年 5 月 24 日Java Persistence API（JPA）是 EJB 3.0 新引入的数据持久化编程模型，它利用 Java 5 中的注释（Annotation）和对象/关系映射，为数据持久化提供了更简单、易用的编程方式。

本系列文章将全面介绍其开源实现— Apache OpenJPA，将为学习 JPA 标准和使用 OpenJPA 进行实际的应用开发提供详细的指南。

本文是系列文章的第一部分，概述了关系型数据库和面向对象之间的阻抗失谐（impedance mismatch），介绍了 EJB 3.0 JPA 标准的相应解决方案，并对OpenJPA 进行了初步介绍。

关系型数据库与面向对象几乎所有的企业应用都需要持久化数据，没有数据持久化需求的企业应用在现在的市场环境下几乎是不可能出现的。

由于关系型数据的普及，通常我们提到数据持久化时，一般指的是将数据持久化到关系型数据库中。

关系型数据是一种结构化的数据管理方式，开发者只能通过 SQL 来操作数据库。

Java 语言天生就是一门面向对象的编程语言，在 Java 的世界中，被处理的内容都被组织成一个一个的对象，对象和对象之间存在着继承、引用关系，这样的关系无法通过简单的方式直接反应到关系型数据库中。

因此在关系型数据库与面向对象之间便存在着阻抗失谐（impedance mismatch）。

我们通过一个简单的例子来说明这种阻抗失谐给企业应用开发者带来的困难。

假设在企业应用中存在三个 Java 类：Animal、Fish 和 Dog，其中 Fish、Dog 都是 Animal 的子类。

在 Java 世界中，Fish、Dog 都可以被作为 Animal 对象处理。

但是如果我们换到关系型数据库中，这三个对象通常都保存在各自对应的表中，假设分别对应 Animal 表、Fish 表和 Dog 表，如果要维护 Animal 和 Fish 的继承关系，我们就需要使用 SQL 的联合查询语句查出 Animal 的所有属性和Fish 的所有属性，并且使用某种外键进行关联：Select animal.*,fish.* form animal,fish where animal.id = fish.id从这个简单的例子中我们就可以看出，一个企业应用开发者需要同时掌握面向对象和关系型数据库的两种思想，而且还必须保证它们之间的映射是正确的，否则无法保证企业应用的正确性，这对于企业应用开发者是个挑战，因此 Java 社区一直在寻求如何将面向对象和关系型数据库思想简单的统一起来的途径，这方面的努力促进了持久化技术的发展。

回页首发展中的持久化技术持久化是企业应用开发的核心需求之一，最近几年以来，它也成为 Java 社区中最热门的话题之一，在 Java 社区努力解决持久化数据管理的过程中，曾经涌现出了非常多的技术方案试图解决这个问题，从最早的序列化，到 JDBC、JDO、ORM、对象数据库、EJB 2.X，然而这些技术都存在着各种各样的局限，影响他们成为最好的选择。

下面我们简单的回顾一下 Java 社区中那些曾经试图为持久化数据管理提供完整解决方案的技术。

序列化序列化是最早出现的、管理持久化数据的实现方案，也是 Java 语言中内置的数据持久化解决方案。

它的工作原理是将对象转化为字节流，生成的字节流能够通过网络传输或者保存在文件中。

序列化非常易于使用，但是局限性也非常大，由于序列化必须一次将所有对象全部取出，这限制了它在处理大量数据情形下的应用，同时它也无法在更新失败的情况下撤销对对象的修改，这使它无法用于对数据一致性要求严格的应用中。

多线程或者多个应用不能同时并发地、互不冲突地读写同一个序列化数据，也不能提供查询功能。

JDBC很多企业应用的开发者选择使用 JDBC 管理关系型数据库中的数据。

相对序列化而言，JDBC 克服了很多缺点：它支持处理大量的数据，能够保证数据的一致性，支持信息的并发访问，提供 SQL 查询语言查找数据。

不幸的是，JDBC 没有提供序列化所具有的易用性。

JDBC 所使用的关系模型不是为保存对象而设计的，因此迫使开发者选择在处理持久数据时放弃面向对象编程，或者自己去开发将面向对象特性（比如：类之间的继承）和关系型数据库进行映射的专有解决方案。

关系对象映射（Object Relational Mapping，ORM）ORM 是目前完成对象和关系数据表之间的映射最好的一种技术，这些 ORM 框架处理对象和关系数据库之间的协调工作，将开发者从这部分工作中解脱出来，集中精力处理对象模型。

阻碍 ORM 发展的问题是，现有的每一种 ORM 产品都有自己特有的 API，开发者只能将自己的代码绑定到某一个框架提供商的接口上，这种状况形成了厂商锁定，意味着一旦该框架提供商无法解决系统中出现的严重错误，或者因为其它的原因转而采用其它的框架，将会给开发者的企业应用带来极大的困难，唯一的解决办法是重写所有的持久化代码。

对象数据库（Object DataBase）已经有一些软件公司选择了开发为保存对象而特别设计的对象数据库，而不是选择将对象映射到关系型数据库上。

这种解决方案通常比使用对象/关系映射更加易于使用。

和 ORM 相同的问题是，对象数据库的访问接口并没有标准化，因此非常容易形成厂商锁定的局面。

与此同时，放弃已经成熟的关系数据库而转向未知的对象数据库让非常多的企业决策者犹豫不决。

而且目前为对象数据库而设计的分析工具太少，无法满足企业的需求。

而且现实情况下，每一个企业基本上都有大量的已有数据保存在关系数据库中，要从关系数据库转向对象数据库对企业而言也需要大量工作。

EJB 2.XEJB 2.X 实体 Bean 是管理持久化数据的组件框架，和 ORM 解决方案一样，EJB 2.X 实体 Bean 提供持久化数据的面向对象视图。

和 ORM 解决方案不一样的是，EJB 2.X 实体 Bean 不仅仅局限于数据库，它展示的信息可能来自于 EIS （Enterprise Information System）或者其他持久化设备。

EJB 2.X 实体 Bean 最大的局限是规定了太过于严格的标准，这些标准保证了企业应用能够在不同的EJB 容器之间可以移植，但是也让 EJB2.X 实体 Bean 规范变得非常复杂并难于使用。

而且 EJB 2.X 标准在面向对象特性处理方面的支持非常有限，无法支持继承、多态和复杂关系等面向对象的高级特性。

EJB 2.X 实体 Bean 只能在重量级的、价格昂贵的 EJB 容器中运行，这对应用 EJB 2.X 实体 Bean 开发企业应用提出了更高的要求，加重了企业的经济压力。

Java 数据对象（Java Data Object，JDO）JDO 是 Java EE 标准中另外一个支持管理持久化数据的规范，JDO 规范使用和JPA 非常类似的 API，只是通常是通过 JCA 技术集成到应用服务器上。

但是 JDO 是针对轻量级容器而设计的，不能够支持容器级别的声明式安全、事务特性，也无法对远程方法调用提供支持。

回页首EJB 3.0 规范2006 年 5 月 2 日，EJB 3.0 规范最终版由 JCP（Java Community Process）正式公布，标准号为 JSR（Java Specification Request）220。

EJB 3.0 规范的发布为企业应用开发者提供了一种全新的、简化的 API。

制定这组 API 的目标是让开发变得更加容易，相对于以前版本的 EJB 规范，这组 API 也更加简单。

Java Persistence API 是 EJB 3.0 中负责处理持久化数据管理的部分，目标是为开发者处理持久化数据库管理提供标准支持，也成为 Java EE 容器提供商必须遵守的标准。

EJB 3.0 规范由三部分组成：EJB3.0 Simplified API、EJB 核心规范（EJB Core Contracts and Requirements）和 JPA（Java Persistence API）。

Simplified APISimplified API 部分主要规定了基于 EJB 3.0 标准开发企业应用时所需要遵守的 Bean 类和接口要求、这些 API 的使用方式以及容器支持等多方面的内容。

还详细的规定了 EJB3.0 中除 Java Persistence API 部分之外的 EJB 实现所支持的注释（Annotation）。

规范中还有专门章节讲解 EJB 3.0 和此前的 EJB 规范如何同时工作，以及如何将此前已经开发好的企业应用移植到 EJB 3.0 容器中。

其中的 Persistence 的内容放在了 JPA 规范中。

EJB 核心规范EJB 核心规范中首先描述了 EJB 在企业应用中的角色、EJB 规范的体系结构，确定了支持 EJB 标准的容器应该遵守的准则和要求。

随后从多个角度详细的介绍了 EJB 体系中各部分的功能需求和实现要求，包括 Session Bean、消息驱动Bean（Message-Driven Bean）、事务、安全管理、部署描述符等。

其中的Persistence 的内容放在了 JPA 规范中。

由于 EJB 3.0 规范并不排斥之前的EJB 规范，因此 EJB 2.X 和 EJB 1.X 中的内容也保留在了 EJB 核心规范中。

Java Persistence API（JPA）EJB 2.X 和 EJB 1.X 规范中的实体 Bean（EntityBean）部分都难以使用，使持久化成为 EJB 规范的一个软肋，影响了 EJB 标准发挥更大的作用，自然而然的，JPA 成为了 EJB3.0 规范中被关注最多的部分。

JPA 规范部分详细的介绍了 JPA 中实体 Bean 新的定义，并介绍了实体 Bean 支持的注释、全新的查询语言、实体管理接口、容器实现规范等内容。

JPA 标准中引入了新的实体概念，每一个实体都是一个普通的 Java 类，不需要继承任何其他的接口或者扩展某个指定类，这个 Java 类必须使用javax.persistence.Entity 进行注释。

JPA 标准中还提供了包括javax.persistence.Table、javax.persistence.Id 等在内的多个注释，用于完成实体和数据库之前的映射。

JPA 中引入了新的查询语言 JPQL（Java Persistence Query Language），JPQL 允许开发者采用面向对象的查询语言来查找实体，这些实体持久化在关系型的数据库中，”select a from Animal a where =’a’” 是一个 JPQL 的例子。