`

EJB学习总结

    博客分类:
  • EJB
阅读更多
EJB 3.0
Sun App/JBoss/Weblogic
-----------------------------------------------------------
Day1

1. What is EJB
   EJB(Enterprise JavaBean)是JavaEE应用的业务层技术标准, 以这项技术开发的组件叫做EJB组件,常常简称EJB
   EJB架构是一个用于开发和部署基于组件的分布式业务应用的组件架构。
   采用EJB架构编写的应用是可伸缩的、事务性的、多用户安全的。
   可以一次编写这些应用,然后部署到任何支持EJB规范的应用服务器平台上。

   特点(和JavaBean比较):
    1)提供远程访问的能力
    2)可扩展、可插拔的能力
    3)必须在EJB服务器上运行, 可享受服务器提供的事务、安全等服务
      (Jboss, Weblogic, Websphere, Sun Application server)

名词解析:
   1.分布式计算:
       1)把大任务分成小块,分发给大家分别地做,再把每个人的计算结果汇总。
         特点:分解工作,减轻成员的负担,成员之间做到职责分明。
       2)充分利用网络上空闲的计算机的计算能力。
     分布式组件:
       1)分布对象技术是伴随网络而发展起来的一种面向对象的技术。
         以前的计算机系统多是单机系统,多个用户是通过联机终端来访问的,没有网络的概念。
         网络出现后,产生了C/S、B/S的计算服务模式。
       2)分布式对象技术主要使用了面向对象技术的封装性,组件可以分布在网络的任何位置。
         对外界来说,它所需关心的只是组件的界面(接口),至于内部是如何实现的则无需考虑,
         远程客户通过方法调用来访问它。这是分布式对象技术和传统的面向对象技术的最大不同点。
   2.组件:可独立发布的二进制单元
   3.框架,即framework。其实就是某种应用的半成品,就是一组组件,供你选用完成你自己的系统;
         代表:Struts,Spring,Hibernate…
   4.中间件,是一种独立的系统软件或服务程序,分布式应用软件借助这种软件在不同的技术之间共享资源;
         代表:Weblogic,WebSphere,Sun App Server…
   5.容器:
     EJB的家。 离开容器,EJB就失去了它的生命和意义

   EJB分布式对象的基础
       JRMI(Java Remote Method Invocation) (远程方法调用)
           --- 使用远程消息交换协议JRMP(Java Remote Messaging Protocol) 进行通讯
       CORBA对象调用
           --- 使用IIOP(Internet Inter-ORB Protocal)


2. Why EJB
   简化大型分布式系统的开发过程。
     1)利用网络中多台计算机的计算能力,构建瘦客户端(简化分布式访问)
     2)使用EJB服务器提供的系统级的企业服务(事务、安全、对象池....),开发人员需要写业务组件
     3)EJB组件具有热部署的能力(可插拔)
     4)可以扩展现有系统的JavaBean
   优点:可维护性、重用性、可扩展性、可插拔性
    1)缩短开发时间:  编程人员可将先行开发的部件装配到新的程序中,从而加速了新程序的开发
    2)降低集成费用:  在将组件集成为一个完整的方案时,不同开发商采用了一致的标准接口,减少了特殊的定制工作
    3)开发更具灵性:  只需简单调整全部应用的一些组件,即可为企业不同领域的应用提供特定的解决方案
    4)降低维护费用:  各组件的软件功能是相对独立的,在维护和升级一个组件时,不必变动整个应用。维护简便


3. When to use EJB
   少量的需要分布式技术支持的大型项目,比如:
   1)应付巨大的客户访问量     2)和已有的系统做集成

   EJB可以做什么?
    1)服务器端的业务层框架    2)遵循EJB规范的标准组件    3)分布式组件
    4)持久化数据支持         5)事务性支持             6)支持并发多用户安全

技术选择:
    表现层技术:Servlet, JSP     MVC框架:Struts,Tapestry,MyFaces...
    业务层组件:JavaBean         集成层: Spring,EJB
    持久层技术:JDBC             ORM框架:Hibernate,TopLink,OpenJPA,EJB JPA...
常见技术组合:
    Struts/MyFaces + EJB(JDBC)
      需要分布式技术的大型项目,大并发访问量,性能要求高
    Struts/MyFaces + Spring + Hibernate
      多数中小型项目

EJB 3.0
   1)会话Bean:对业务逻辑建模
     分类: 有状态,能分辨不同的客户;无状态,不能分辨不同的客户
   2)实体(Entity)
        POJO
   3)消息Bean
     支持异步通信。没有直接的客户端,由消息触发(驱动)


4. First EJB开发步骤:
   EJB组件开发:
    1)安装JBoss,并启动
      默认端口:8080;可以修改 %jboss_home%/server/default/deploy/jboss-web.deployer 的server.xml
      把 <Service name="jboss.web"> 的 <Connector port="8080" ... 改成想要的就行
    2)开发一个普通的Java组件
    3)classpath加上Java EE 5 Libraries(MyEclipse自带类库)
    4)加EJB的标注,声明为EJB组件
      IHello.java (接口标注:@Remote )
      HelloBean.java (无状态会话bean标注:@Stateless )
    5)编译,在 FirstEJB/bin 运行命令: jar cvf HelloEJB.jar .
    6)拷贝HelloEJB.jar到%jboss_home%/server/default/deploy目录下
      这是正常发布方法。需要启动%jboss_home%/bin/run.jar (win下用run.bat,linux用run.sh启动)
    7)确认组件已部署(控制台没有异常)

   EJB客户端开发:
    1)classpath加上jbossall-client.jar(这个包在 %jboss_home%/client/ 下)
      引入这个jar包之后才可以初始化上下文(context)
    2)引入IHello.class
    3)Client.java

5. JNDI(Java 命名和目录服务接口)
   JNDI为JavaEE平台提供了一个通过名字查找网络中一切对象的标准机制
   是一套为开发者提供通过名字方便查找用户、机器、网络、对象和服务的 Java API
   JNDI实现了EJB对象位置的透明性,客户端只要能访问JNDI服务,便可以调用EJB服务。
   1) 部署ejb的时候,容器将会把EJB对象绑定到命名服务
   2) 像JDBC可以访问不同的数据库,可以通过JNDI访问不同的JNDI服务
      a.设置上下文工厂
      b.设置JNDI服务提供者的url
   3) JNDI的API的使用
      初始化上下文(Context ctx = new InitialContext() )
          --- 不同的应用服务器初始化上下文的工厂类是不同的,协议也可能不一样!!!查文档吧
      三种方式初始化上下文:
        a)设置系统属性(Test.java中)
          System.setProperty(Context.INITIAL_CONTEXT_FACTORY,
                org.jnp.interfaces.NamingContextFactory.class.getName());
          上句也可以这样写: System.setProperty("java.naming.factory.initial",
                "org.jnp.interfaces.NamingContextFactory");
          System.setProperty(Context.PROVIDER_URL, "localhost");
                //"localhost" 也可以写: jnp://127.0.0.1:1099
        b)通过命令行设置
        c)在类路径下添加jndi.properties  ---名字不能修改!!
         jboss中:
          java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
          java.naming.provider.url=jnp://localhost:1099
         Sun App Server 9.0 中:
          java.naming.factory.initial=com.sun.enterprise.naming.SerialInitContextFactory
          java.naming.provider.url=iiop://127.0.0.1:3700
   4) JNDI API(javax.naming.Context接口) 主要方法的使用
      void bind(String name, Object object);   //将名称绑定到对象。如果已经存在,则抛出异常。
      void rebind(String name, Object object); //将名称绑定到对象。如果存在,重写所有绑定。
      void rename(String oldName,String newName); //把某一个已经绑定的旧名称改新名字
      void unbind(String name); //取消指定对象的绑定。
      Object lookup(String name); //查找指定的对象。
      注意:这4个方法都 throws NamingException;
   5) JBoss下配置JNDI名称
      在jboss下配置bean的JNDI名可以采取三种方式:
      第一种:也是默认的,"beanname/remote"
      第二种:使用@RemoteBinding注释。(导入jboss-annotations-ejb3.jar)
             @RemoteBinding(jndiBinding="jndiName")  --- 这种方式不好,与JBoss耦合!!!
      第三种:使用jboss.xml文件,此文件要放在src\META-INF目录下。具体内容见下面:
<jboss>  
   <enterprise-beans>  
      <session>  
         <ejb-name>BeanName</ejb-name>  
         <jndi-name>jnidname</jndi-name>  
      </session>    
   </enterprise-beans>  
</jboss>


6. 远程调用的原理
   1)使用Socket进行网络通信
   2)使用代理模式,使得调用服务器端的远程对象,看起来像调用本地对象一样
   3)客户端的代理叫做Stub(桩)
   4)服务端的Skeleton(框架)
   5)调用过程: Client -> Stub(远程接口) -> Skeleton -> EJB Object(也叫远程对象)

   RMI简介
    1)RMI(Remote Method Invocation,远程方法调用)是用Java在JDK1.1中实现的,它增强了开发分布式应用的能力。
    2)Java RMI 则支持存储于不同地址空间的程序级对象之间彼此进行通信,实现远程对象之间的无缝远程调用。
    3)RMI目前使用Java远程消息交换协议JRMP(Java Remote Messaging Protocol)进行通信。
    4)用Java RMI开发的应用系统可以部署在任何支持JRE(Java Run Environment,Java运行环境)的平台上。但由于JRMP是专为Java对象制定的,因此,RMI 对于用非Java语言开发的应用系统的支持不足。不能与用非Java语言书写的对象进行通信。

   RMI架构
    1) Stub/Skeleton层
       该层提供了客户程序和服务程序彼此交互的接口。
    2) 远程引用层(Remote Reference)
       中间层,负责处理远程对象引用的创建和管理。
    3) 传输协议(Transport Protocal)
       提供了数据协议,用以通过线路传输客户程序和远程对象间的请求和应答。

   编写RMI的程序
    1) 定义远程接口
       通过扩展 java.rmi.Remote 接口,并定义所需的业务方法实现
       远程方法必须声明抛出 java.rmi.RemoteException 异常;或者这异常的父类
       远程方法的参数和返回值必须是实现序列化接口的类(基本类型也可以)
    2) 定义远程接口的实现类
       即实现上一步所定义的接口,给出业务方法的具体实现逻辑。
    3) 编写运行 Skeleton 引导程序注册RMI服务 (定义协议,并等待客户端调用)
    4) 编写客户端 Stub;(遵守协议的端口、读取发送信息的方式;供调用)
       使用动态类加载机制(反射机制)
    5) 编写客户端Client,调用远程对象


7. Local接口和EJB组件的依赖注入
   1)本地接口: @Local
   2)EJB组件的依赖注入:@EJB(mappedName="EJB Name/remote")

  ejb客户端开发步骤:
    1)引入ejb远程接口(a方式.引入ejb工程, b.把远程接口直接Copy过来)
    2)引入jbossall-client.jar
    3)保证src目录下面有一个jndi.properties
    4)客户代码,如:Test.java

8. Remote 和 Local
    Local(默认方式)            Remote
    使用@Local标注             使用@Remote标注
    只能本地调用,远程不行        既可以本地调用,也可以远程调用
    避免网络交换过程             无法避免网络交换过程,性能差
    允许传递未序列化的参数        不允许传递未序列化的参数

    注意:要调用实现Local接口的sessionbean,客户端程序和EJB必须在同一JVM的服务器环境。
    远程客户端也可以通过 与EJB在同一JVM的代理去访问(如Stub/Skeleton;或者用一个@Remote的Bean间接调用)

-----------------------------------------------------------
Day2

1. EJB的Web客户
   在web项目中调用EJB
   web项目在tomcat部署:
     web项目中必须包含远程接口
     web项目必须导入jbossall-client.jar
   web项目在jboss部署: (在同一台服务器上部署)
     web项目: 不需要 远程接口和jbossall-client.jar(注意: 一个JBoss中不能出现两个相同的类)

2. EJB编程模型

3. EJB的分类(2.X分类)
   1)Session Bean(会话Bean)  (Stateless和Stateful)       --- 对业务逻辑建模
   2)Entity Bean(实体Bean,3.0使用JPA替代)  -- POJO        ---对领域模型建模
   3)Message Driven Bean(消息驱动Bean)                   --- 支持异步通讯,没有直接的客户端,由消息驱动

4.EJB的系统服务
   1)事务
   2)安全
   3)对象池


5. 部署描述符和标注
   早期版本使用配置文件开发EJB, EJB3.0使用Annotation简化开发
   1)开发阶段:开发人员使用Annotation开发
   2)部署阶段:部署人员使用部署描述符部署(将覆盖annotation配置)

   部署描述符:
    1) 标准部署描述符:ejb-jar.xml
       <ejb-jar version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd ">
       <enterprise-beans>
         <session>
            <ejb-name>BeanName</ejb-name>
            <remote>package.IBeanName</remote>
            <local>package.IBeanName</local>
            <ejb-class>package.IBeanImplements</ejb-class>
            <session-type>Stateless</session-type>
            <transaction-type>Container</transaction-type>
          </session>
        </enterprise-beans>
       </ejb-jar>
    2) 特定应用服务器部署描述符:
        JBoss:jboss.xml
        Weblogic:weblogic-ejb-jar.xml
        Sun:sun-ejb-jar.xml

    标注和部署描述符的区别:
        标注                      部署描述符
    简单便利,直观               复杂,容易出错
    分散管理,无法应付复杂应用     集中管理,可以应付较复杂应用
    EJB提供者和部署者不是同一人    适合于EJB提供者和部署者不是同一人的情况
    容易出错

    注意:标注与部署描述符同时使用,部署描述符的优先级更高,会覆盖标注!!!


6. Session Bean(会话Bean)
   业务组件: 由客户端程序调用的一段业务逻辑, 作用相当于Spring管理的服务组件。一个EJB组件在容器中可能包含多个实例。
   会话Bean:对业务逻辑建模:用程序模拟处理一件事情的流程和步骤

7. 会话Bean的分类:
   Stateless Sesssion Bean(无状态会话Bean,简称:SLSB)
    1)一次方法调用代表一次会话
    2)多次方法请求之间不保存状态 (只能调用方法,不能访问属性)
    3)Bean的对象实例可以被任何客户调用

   Stateful session Bean(有状态会话Bean,简称:SFSB)
    1)会话贯穿于多次方法调用之间
    2)多次方法请求之间保存状态
      SFSB像servlet中的Session对象,可以访问SFSB的属性,SFSB的属性值会自动保留,供下次访问
    3)只有一个客户能访问这个Bean的对象实例和它的状态


8. 无状态会话Bean的对象和并发服务
   1)实例数量是容器根据客户端数量,来创建的。创建以后不会销毁,容器销毁或删除此项目时才销毁
   2)不能区分不同的客户。由哪个实例响应客户端,是由容器决定的。按静态方法来使用。
   3)实例可共享,和客户stub是多对多。不能拥有实例变量,即使有,也不能暴露给客户
   4)生命周期:不存在 -> 就绪
   5)回调方法和Remove方法
   6)并发访问
     a.没有状态,因此也无需做并发处理
     b.串行共享
     c.对象池   --- 容器会初始化n个Bean对象应付成千上万的客户端的并发请求。
9. 无状态会话Bean的生命周期(状态图)
   1)不存在 -> 就绪
     过程: 1创建Bean实例 2依赖注入 3@PostConstrcut回调方法)
   2)就绪 -> 不存在
     过程: @PreDestroy回调方法
   3)回调方法@PostConstrcut和@PreDestroy,可以定义在Bean类中,也可以定义在单独的类中
     @PostConstrcut 进行初始化工作,比如获取一些不能用依赖注入获得的资源
     @PreDestroy 释放初始化时获得的资源
   4)独立的回调类
     @Interceptors(Callback.class)


10.有状态会话Bean的对象池和并发服务
   1)能区分不同的客户,可以记住客户信息
   2)跨越多个请求(方法调用),维护会话状态(bean类的实例变量)
   3)Bean对象和stub一对一
   4)生命周期:不存在 -> 就绪 -> 钝化
     状态包括:
      成员变量是非transient类型的java基本类型或对象
      本地或者远程接口的EJB引用
      容器管理的资源
      JNDI命名上下文Context
   5)回调方法和Remove方法(初始化实例变量,获得或关掉外部资源等)
   6)多用户并发访问:
     a.容器考虑,开发人员无需处理并发
     b.钝化和激活过程
     c.容器的并发策略(annotaion和DD)
       需导包:jboss-annotation-ejb3.jar (这个包在 %jboss_home%/client/ 下)
     d.Bean编写的要求,必须具备序列化能力(serializable)
   7)占用更多资源:cpu(查找bean、激活、钝化)和内存(有多少个在线用户就有多少stateful bean)

    有状态会话Bean:
    1.一个Stub就是一个客户,lookup到Stub以后,保存在servlet的session中
    2.EJB重新部署之后,需要lookup一个新的Stub

    生命周期:不存在 -> 就绪 -> 钝化
    1.当客户端lookup时,Bean并不存在;直到客户端首次请求调用时,服务器才构造bean实例,并调用postConstruct方法进入就绪状态;然后客户端才可以正常调用
    2.如果客户端太久不用,服务器会调用prePassivate方法使bean钝化;当客户端再次请求调用时,又构造新实例,调用postActivate重新激活;然后客户端才正常调用
    3.客户端调用remove后,服务器端会调用preDestroy方法令bean不存在;此后不能再使用这个bean,如需再用要再次lookup


11. 示例:购物篮
    购物篮EJB组件
    包含状态:产品信息(产品,数量)
    业务功能:1添加产品 2生成订单

   数据源 模板的位置:  %jboss_home%/docs/examples/jca/
   数据源配置文件位置: %jboss_home%/server/default/deploy/mysql-ds.xml
   mysql驱动程序位置: %jboss_home%/server/default/lib/

   issue:
    无法访问数据库时,注意:
    1. 检查数据库驱动程序
    2. 检查mysql-ds.xml是否正确(url,username,password);放到 %jboss_home%/server/default/deploy/
    3. 检查数据源是否部署成功,JNDI引用名称是否正确( 以 "java:/" 开始)



-----------------------------------------------------------
Day3
1. JPA(Java Persistence API)简介
   1)ORM(object relational mapping):  实现对象到关系数据库中的表的自动持久化(翻译)
     通过元数据描述对象于数据库间的映射。
   2)JPA, Sun提出的又一套Java持久化规范标准
   3)整合当前各种ORM框架和技术,为各种ORM框架提供统一编程接口
   4)只是一套接口,要求持久化提供商实现支持
   5)使用Annotation和XML描述对象和关系表的关系
   6)EJB和普通Java程序都可使用

2. JPA编程
   EntityManager接口
   J2SE环境下JPA 编程步骤:
    a.导入包: Java EE 5 Libraries(MyEclipse的类库,javaee.jar);
      数据库驱动包;  PP(持久化提供者)的包
    b.配置persistence.xml(名字固定)
      提供访问数据库的信息 和指定具体的PP(persistence provider)
    c.开发实体(注解或orm.xml)
      1)在POJO类上添加@Entity
      2)实体必须声明主键@Id,(可以使用@GeneratedValue配置主键产生的策略)
      3)默认情况下,实体类名和属性名等同于表的字段名(可用@Table/@Column 加上(name="new_name")另外起名)
      //4)实体能够包括业务方法(不建议这么做,会导致实体的职责不清)
    d.Session Bean(注入EntityManager)
    e.开发客户程序

3. JPA支持两种事务类型
    本地资源事务(RESOURCE_LOCAL):使用JDBC驱动管理的本地事务。不需发布。
    Java事务API(JTA):容器管理的事务。要使用JTA必须使用服务器的DataSource。

    JavaEE环境下
        容器管理的EntityManager(@PersistenceContext注入)必须使用JTA事务。
        应用程序管理的EntityManager可以使用本地资源事务,也可以使用JTA事务
    在JavaSE环境下,使用本地资源事务

   比较 Hibernate 与 JPA 的开发过程:
        Hibernate             jpa
     1.POJO(entity)        1.entity
     2.xxx.hbm.xml         2.Annotation(orm.xml)
     3.hibernate.cfg.xml   3.persistence.xml
     4.SessionFactory      4.EntityManagerFactory



-----------------------------------------------------------
Day4

4. EntityManager接口
    find(Class<T> entityClass, Object primaryKey):<T> T    //根据主键查找,没有符合条件记录,返回null
        Hibernate:get();
    getReference(Class<T> entityClass,Object primaryKey):<T>T //根据主键查找,没有符合条件记录,抛出异常
        Hibernate:load();                                  //EntityNotFoundException
    persist(Object entity):void        //将实体变成受管态,并持久化它,将在数据库中增加一条记录
        Hibernate:save();
    merge(T entity):T                  //合并一个实体到持久化上下文中,将更新数据库记录,并返回持久化对象
        Hibernate:merge();
    remove(Object entity):void         //删除一个实体,将删除数据库记录
    clear():void                       //清除持久化上下文,将导致托管态对象变成游离态对象
    contains(Object entity):boolean    //检查一个实体对象是否包在持久化上下文中
    close();                           //关闭持久化上下文
    flush();                           //对象同步到数据库,有两种同步方式
        FlushModeType.AUTO             //事务提交和执行查询时同步
        FlushModeType.COMMIT;          //只有事务提交时同步
        setFlushMode(FlushModeType flushMode)    //设置同步方式
    refresh();                         //数据库同步到对象
    getTransaction().begin();          //开启事务
    getTransaction().commit();         //提交事务,事务结束

5. 持久化上下文和实体的生命周期
   新建 -> 托管(受管) -> 脱管(游离) -> 删除
    1) 新建new:new Instance persist(); 新建一个实体对象,还未持久化,没有持久化标志
    2) 托管managed:数据库里和持久化上下文中都有 实体对象
    3) 游离detached:持久化上下文中没有,但是又具有持久化标志(oid)  可调用merge(),不能调用persist();
    4) 删除removed:hibernate没有(数据库中和持久化上下文中都有,但是通过remove()标志实体是被删除的)
   总结:
    1) 不调用persist, 而是调用merge持久保存entity对象
    2) 在事务当中(ejb默认一个方法是一个事务)或者持久化上下文中,先查询entity, 再进行操作
    3) 调用find方法, 不要调用getReference()

6. 持久化上下文类型
    容器管理的上下文
    @PersistenceContext(type=PersistenceContextType.TRANSACTION)
    1)事务范围的(默认方式):
            事务结束时(一个方法默认为一个事务),上下文被关闭
    @PersistenceContext(type=PersistenceContextType.EXTENDED)
    2)扩展范围的(多个事务):
            上下文跨越多个事务(事务结束时,上下文并不关闭)
            *只有*有状态会话Bean适用,SFSB销毁时,上下文关闭
     应用程序管理的上下文,是扩展的上下文
    EntityManagerFactory emf;
    EntityManager em = emf.createEntityManager();

7. 实体回调
   1)注解方法
     @PrePersist    //insert into SQL执行之前调用
     @PostPersist   //insert into SQL执行之后调用
     @PreUpdate     //update SQL执行之前调用
     @PostUpdate    //update SQL执行之后调用
     @PreRemove     //delete SQL执行之前调用
     @PostRemove    //delete SQL执行之后调用
     @PostLoad      //加载实体之后,select SQL执行之后调用 (只有这个没有之前执行的)
   2)独立的回调类
     @EntityListeners(Callback.class)
     回调方法多一个Object 参数,如:
       Callback.java 里写:                     entity.java里写:
       @PreUpdate                              @PreUpdate
       public void preUpdate (Object obj);     public void preUpdate ();

8. JPA查询(JPQL)
    1)javax.persistence.Query接口
      Query query = em.createQuery("select 别名 from entity类 别名"); //也可写 "from entity类"
       List<entity类> list = query.getResultList();
       for(entity类 obj : list){System.out.println(obj.getOid() + " : " + obj.getName());}
    2)本地查询
      Query query = em.createNativeQuery("select * from 表名", entity类.class);
      List<entity类> list = query.getResultList();
      for(entity类 obj :list){System.out.println(obj.getOid() + " : " + obj.getName());}
    3)命名查询
      a)在Entity里添加标注
        @NamedQuery(name="命名1", query="select h from entity类 h where h.age>?2 and h.name like ?1")
        //上面 ?1 ?2 的数字决定参数下标。也可以只用 ? ,但代码得保证对应这语句的顺序。(h是 entity类 的别名)
        //query 语句也可写成:"from entity类 where age>:age and name like :name"
        //分号表示用名称代号代替之前的下标,来表示参数。这种方式更常用,不易出错
      b)查询代码
        Query query = em.createNamedQuery("命名1");
        query.setParameter(1, "%始%"); //如果query 语句用分号的,则query.setParameter("name", str);
        query.setParameter(2, 70);
        List<entity类> list = (List) query.getResultList();
        for (entity类 obj : list){
            System.out.println(obj.getOid() + " : " + obj.getName());}
    4)本地命名查询
      a)在Entity里添加标注
        @NamedNativeQuery(name="命名2", query="select * from 表名", resultClass=entity类.class)
      b)查询代码
        Query query = em.createNamedQuery("命名2");
        List<entity类> list = (List)query.getResultList();
        for (entity类 obj : list){System.out.println(obj.getOid() + " : " + obj.getName());}

   JPA(Java Persistence API)简介
     1)ORM(object relational mapping):
       实现对象到关系数据库中的表的自动持久化(翻译),通过元数据描述对象于数据库间的映射。
     2)JPA, Sun提出的又一套Java持久化规范标准
     3)整合当前各种ORM框架和技术,为各种ORM框架提供统一编程接口
     4)使用Annotation和XML描述对象和关系表的关系
     5)只是一套接口,要求持久化提供商实现支持
     6)EJB和普通Java程序都可使用

   数据库库同步
     flush();
     FlushModeType.AUTO 和 FlushModeType.COMMIT;
     refresh();


9. O/R mapping metadata
    @Entity  //用于类名前。表明他是pojo类
    @Table(name="t_film") //用于类名。这个类对应的表名,可以不写
    @Column(name="filmName") //用于属性。表中的字段名,不写则跟属性名一样(大小写也一样)
    @Id  //用于属性。表明他是id;要求一定要有ID
    @GeneratedValue //用于id属性。指定需要框架自动产生主键

    //主键生成策略
    @GeneratedValue(strategy=GenerationType.AUTO, generator="generatorName")
        GenerationType.AUTO            //默认
        GenerationType.IDENTITY        //Mysql,Sql Server适用

        GenerationType.SEQUENCE        //Oracle
        @SequenceGenerator(name="generatorName", sequenceName="")
        //Oracle: create SEQUENCE SEQ_ID INCREMENT BY 1 START WITH 1)
       
        GenerationType.TABLE           //Mysql,Oracle 适用
        @TableGenerator( name="generatorName",  table="ID_GEN",  pkColumnName="entityName",
            valueColumnName="IdValue",  allocationSize=1 )

    //Annotation
    @Basic(optional=false) //属性可选
    @Transient             //瞬态属性;不会持久化到数据库
    @Lob                   //大字段类型属性
    @Embedded              //复合组件(属性)  @Enumerated的手误???

   复合主键和复合组件
    @IDClass(复合主键)
    @EmbeddedID(复合主键)
    @Embeddable
    @Embedded(复合组件)



-----------------------------------------------------------
Day5

10.继承映射策略
   1)每个类对应一个表
     @Inheritance(strategy=InheritanceType.JOINED) //用于父类,还需有@Entity
     优点: 符号面向对象;支持多态;没有数据冗余
     缺点: 表的数量过多,不方便维护;连接查询速度慢
   2)每个具体类对应一个表
     @MappedSuperclass   //用于父类,子类继承父类的id,而父类没有表
     @AttributeOverrides({
        @AttributeOverride(name="prepertyName1", column=@Column(name="fieldName1")),
        @AttributeOverride(name="prepertyName2", column=@Column(name="fieldName2"))  })
     优点:查询速度快
     缺点:数据定义存在冗余
   3)整个类层次结构对应一个表
     @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
     @DiscriminatorColumn(name="discriminatorField")
     @DiscriminatorValue("discriminatorValue")
      优点:容易理解和维护;最快的查询数度
      缺点:最大的冗余


11.实体关联关系
    //多对一与一对多
    @ManyToOne  //主动,只有他不能放弃维护关系。加上mappedBy就编译不通过
      @JoinColumn(name="外键字段名") //指定外键;Many的一方不需另外建表,只需增加字段就可以维护关系
    //被动。写mappedBy后就不再另外建表维护OneToMany的关系(默认建One_Many表)
    @OneToMany(mappedBy = "", cascade={}, fetch=FetchTYPE.EAGER)
      @JoinTable(name="One_Many关系表名" //反映 One_Many 关系的一个表。不写则不建
        ,joinColumns={@JoinColumn(name="One_id1")} //这个关系表的主键字段,可以用复合主键(One端)
        ,inverseJoinColumns={@JoinColumn(name="Many_id")}) //这个关系表的成员的字段(Many端)

    //一对一
    @OneToOne   //主动
      @JoinColumn(name="外键字段名")
    @OneToOne(mappedBy="")     //任意一方加上mappedBy后,变被动;他不可以再维护关系了

    //多对多
    @ManyToMany //主动
      @JoinTable(name="innerTableName"
          , joinColumns={@JoinColumn(name="foreign_key")}
          , inverseJoinColumns={@JoinColumn(name="otherColumn")})
    @ManyToMany(mappedBy="")  //加上mappedBy后,变成 ManyToOne 的 One方

   三大要点:
    a.维护关系(没有mappedBy的默认都是维护关系(设置外键或者设置中间表记录))
      加上mappedBy后,他就不可以再维护关系了
    b.fetch //设置加载方式
      (FetchType.EAGER时, 查询主表记录,并查询从表纪录,两条SQL语句;对 One 的一方)
         对于基本属性,使用 fetch=FetchType.EAGER (通常配合二级缓存使用),会提高效率(默认 EAGER)
      (FetchType.LAZY时, 只查询主表记录, 只有一条SQL语句;对 Many 的一方)
         对于集合属性,一般设置为 fetch=FecthcType.LAZY 加载;为了提高效率         
    c.cascade
      对一边执行操作时,是否要对另一端也行操作(只能用于 One端,用于Many端时编译不通过)
      cascade={CascadeType.REMOVE, CascadeType.REFRESH, CascadeType.RERSIST,
           CascadeType.MERGE, CascadeType.ALL}  //级联操作,小心使用
      例如: persist()一个对象时(执行insert语句),是否同时persist关联对象


12. EJBQL (又称 JPQL)
    类似HQL(Hibernate的SQL语句),这是EJB的SQL语句,又称JAVA的SQL语句
    1)批量删除、更新(delete from Entity),需要 em.clear();
    2)连接查询(关联对象之间使用 join fetch,只能给有关联的类使用)
      left join/inner join (select u from User u inner join u.dept)
      inner join/left join(select u from User u left join u.dept)
      只能给有关联的表作级联操作。(功能不如SQL,SQL可以给所有表作级联操作)
      inner join fetch/left join fetch (查出所有关联实体)
    3)group by 和 having 语句
    4)投影:(要求构造函数才可以根据投影返回对象)
      如:select u.userName from User ;查询之后返回对象数组
      select new User(u.userName) from User u ;返回实体对象(要求有对应的构造函数)
    5)子查询:只能在where子句中出现(功能不如SQL,SQL可任意子查询)


13. 并发访问
    乐观锁
    悲观锁(只有数据库的锁才是悲观锁)
    @Version //加在Entity类的版本属性里




The basic of JPA (II)  
-----------------------------------------------------------
Day6 事务

1. 事务概念:
   1)事务产生的动机
     使用事务保证原子操作,避免应网络故障或机器故障,导致数据状态不一致,保证多用户并发访问数据库的问题
   2)事务过程的参与者:
     事务对象:包含事务的应用组件,如EJB组件
     事务管理器:负责管理应用组件的事务操作,如J2EE应用服务器
     资源:一个可供读写的永久性的存储库,如数据库
     资源管理器:负责管理资源,如一个数据库管理系统
   3)事务的ACID属性:
     原子性(Atomicity)
           事务中的数据库修改操作,要么全部成功,要么全部不成功。
     一致性(Consistency)
           事务执行之前,和事务结束之后,数据库都必须满足全部完整性要求。
     隔离性(Isolation)
           一个事务的处理不能影响另一个事务的处理。(有多个隔离级别)
     持久性(Durability)
           指一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。以后其他操作或故障不对其有任何影响。

2. 分布式事务
   1)事务的类型:JDBC事务 和 JTA事务
   2)分布式事务和两阶段提交协议
     分布式事务:事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的布式系统的不同(机器)节点之上
     为了实现分布式事务需要使用两阶段提交协议。
   两阶段提交协议(后台实现)
     阶段一:开始向事务涉及到的全部资源发送提交前信息。各资源服务器进行“预提交”。
     阶段二:只在阶段一没有异常结束的时候才会发生

   数据源配置文件位置(固定): %jboss_home%/server/default/deploy/ 目录放
     mysql-xa-ds.xml 以及 oracle-xa-ds.xml (为每个需要调用的数据库都配置)
   驱动: %jboss_home%/server/default/lib/ 目录下放 mysql 和 Oracle 的驱动

3. EJB事务
   1)Bean(EJB Object)管理事务(BMT)(编程性事务)
   2)容器管理事务(CMT)(声明式事务)
   3)客户端管理事务

4. Bean管理事务
   1)由EJB实现类显示调用事务代码(编程式事务)
     @TransactionManagement(TransactionManagementType.BEAN)
     @Resource(mappedName = "UserTransaction")
     UserTransaction userTx;
   2)优点:支持细粒度事务控制
   3)缺点:需要编写事务代码,业务逻辑代码和事务代码耦合在一起,不利于维护

5. 容器管理事务(默认)
   1)由容器为我们管理事务(声明式事务)
     @TransactionManagement(TransactionManagementType.CONTAINER)
   2)类级别声明和方法级别声明
     @TransactionAttribute(TransactionAttributeType.REQUIRED|TransactionAttributeType.REQUIRED)
   3)六种事务属性
     REQUIRED: 一定有事务(调用者有事务,加入;调用者没有事务,创建一个事务)
     REQUIRES_NEW: 总是创建新事务
     SUPPORTS:支持事务,和调用者一致
     MANDATORY:调用者,必须有事务(客户端没事务就抛出异常)
     NOT_SUPPORTED:挂起原事务(如果有), 运行本方法,恢复原事务
     NERVER: 调用者不允许有事务
   4)优点:解耦业务逻辑代码和事务代码
   5)缺点:对事务控制的最小粒度受限制(方法级),不够灵活

6. 客户端管理事务
   1)由客户端负责事务管理(编程式事务)
     UserTransaction utx = (UserTransaction)ctx.lookup("UserTransaction");
   2)EJB本身必须是CMT事务,否则客户端事务无法远程传递到EJB
   3)优点:事务在客户端,对于网络等问题造成的问题能进行处理(其他事务在这种情况下不知道事务是否成功)
   4)缺点:跨越网络的长事务将导致严重的性能问题


-----------------------------------------------------------
part5 消息技术和消息驱动Bean
1. 什么是消息和消息技术
   广义来讲是程序或者计算机之间,进行通信的数据,有消息两种:同步消息和异步消息。
       消息中间件技术中的消息是狭义的消息,特指异步消息。
   消息技术拓扑图和消息技术作用
       1)异步通信(接收、存储、转发):非阻塞
       2)不同应用系统集成:松耦合
       3)可靠性:重发
       4)多发送者同时发送和多接收者同时接收

2. 消息系统中重要概念
   消息中间件(Message-Oriented Middleware):对信息进行管理/控制,提供异步传输能力,各系统之间信息传递的基本平台
   消息:MOM系统中基本的数据传输单元 
        消息结构:消息头(目的地、发送人、优先级) 和 消息体(真正想发送的数据)
   消息目的和消息域(Domain,即消息处理类型)
        a.点对点:消息发送者发送的消息只能提供给一个消费者一次消费(类似手机短信),目的地:队列(Queue)
        b.发布/订阅:消息发送者发送的一条消息可以提供多个消费者即时消费(类似广播),目的地:主题(topic)

3. JMS(Java Message Servic)
   以前:不同的消息中间件服务器提供不同的编程接口,每次换一个中间件服务器必须学改服务器的API
   现在:统一编程接口,不同的JMS Provider不用学习不同的MOM API

4. JMS API编程模型
   //服务器配置
   1)连接工厂,获取连接
     %JBOSS_HOME%/server/default/deploy/jms/uil2-service.xml
     配置<attribute name="ConnectionFactoryJNDIRef">ConnectionFactory</attribute>
   2)目的地
     %JBOSS_HOME%/server/default/deploy/jms/jbossmq-destinations-service.xml
     配置队列目的地:
       <mbean code="org.jboss.mq.server.jmx.Queue"
          name="jboss.mq.destination:service=Queue,name=tarenaQueue"> //tarenaQueue是个自定义名字
          <depends optional-attribute-name="DestinationManager">
           jboss.mq:service=DestinationManager</depends>
       </mbean>
     配置主题目的地
       <mbean code="org.jboss.mq.server.jmx.Topic"
           name="jboss.mq.destination:service=Topic,name=tarenaTopic">
          <depends optional-attribute-name="DestinationManager">
           jboss.mq:service=DestinationManager</depends>
       </mbean>

   //发送消息
   1)获取连接工厂(服务器端需配置连接工厂)   //这一步之前已经学过(熟透了吧)
     System.setProperty(Context.INITIAL_CONTEXT_FACTORY,
     "org.jnp.interfaces.NamingContextFactory");
     System.setProperty(Context.PROVIDER_URL, "localhost");
     Context ctx = new InitialContext();
     ConnectionFactory cf = (ConnectionFactory)ctx.lookup("ConnectionFactory");//跟之前唯一的不同
   2)创建连接
     Connection conn = cf.createConnection();
   3)创建会话
     Session sess = con.createSession(false, Session.AUTO_ACKNOWLEDGE);
     //false:不使用事务;Session.AUTO_ACKNOWLEDGE:收到消息后,自动确认消息(有时会要求接收者确认收到消息)
   4)获取目的地(服务器端需配置目的地)
     Destination dest = (Destination)ctx.lookup("queue/tarenaQueue");
     //lookup是队列跟主题唯一的区别,主题用"topic/tarenaTopic"
   5)创建生产者(Message Producer)
     MessageProducer mp = sess.createProducer(dest);
   6)创建消息
     TextMessage msg = sess.createTextMessage("无语了...");
     msg.setStringProperty("sender", "发言者名字");//这句话,标识自己在发言,让人监听;没有监听者则免了
   7)发送消息
     mp.send(msg);
  关闭资源(一般都把前7步放到 try 代码块里,再 catch(JMSException);而这第8步放到 finally 代码块里)
     try { mp.close(); } catch (JMSException e) {e.printStackTrace();}
     try {sess.close();} catch (JMSException e) {e.printStackTrace();}
     try {conn.close();} catch (JMSException e) {e.printStackTrace();}

   //接受消息 (前4步跟发送一样)
   1)获取连接工厂(服务器端需配置连接工厂)
   2)创建连接
   3)创建会话
   4)获取目的地(服务器端需配置目的地)
   5)创建消费者(Message Consumer)
     MessageConsumer mc = sess.createConsumer(dest);
   6)启动连接(Connection.close())
     conn.start();
   7)接受消息(recive()或者佣人MessageListener)
     Message msg = mc.receive(2000);
     // 2000是接收信息的时间(毫秒),在这段时间内收不到就不收了;不写时间则一直等待
  处理消息
     if(msg instanceof TextMessage) System.out.println(((TextMessage)msg).getText());
     // Message 是 TextMessage 的父类
   9)关闭资源
     这一步跟发送消息的相同

   //ConnectionFactory的接口
     createConnection();
     createSession(boolean transacted, int acknowledge);
        transacted: JMS消息是否使用事务
        acknowledge:Session.AUTO_ACKNOWLEDGE    //收到消息时,自动确认消息
                    Session.Client_ACKNOWLEDGE  //到消息时,调用Message.acknowledge()确认消息
                    Session.DUPS_OK_ACKNOWLEDGE //延时确认消息,(批量确认消息,提高性能)
   //JMS消息结构
    消息头:消息的标识/路由信息    --系统设置的属性
    消息体:真正的消息内容        --程序设置
    标识属性:给消息的接收有一个过滤的关键字(可选)--程序设置
        message.setStringProperty("sender", "maxwell"); //设置发送者属性(属性名称也是任意的)


5. 消息驱动Bean
   容器收消息,收到后调用消息驱动Bean
     1)和Stateless SessionBean一样表示无状态的业务逻辑
     2)和SessionBean的区别,不由客户调用,由消息驱动,也没有返回值
     3)毒消息(由于一直不能确认收到消息,服务器不断的发送重复消息)
       解决方法: a.使用Bean管理的事务,不使用默认的CMT事务
                b.不要抛出系统异常,try{} catch{} 捕获异常
                b.JMX控制台设置重复次数: jboss.mq.destination

   继承 javax.jms.MessageListener 接口
   消息驱动Bean的生命周期
        不存在 -> 就绪
        @PostConstruct //当被监听的人第一次发信息时调用;其他人发信息不理会
        @PreDestroy    //当工程销毁或者关闭服务器时调用

   @MessageDriven(activationConfig = { //写在监听类前面
        @ActivationConfigProperty    //信息类型
          (propertyName = "destinationType", propertyValue = "javax.jms.Topic") //队列用"Queue"
        ,@ActivationConfigProperty(propertyName = "destination", propertyValue = "topic/tt")
        ,@ActivationConfigProperty    //指定只接收某个人的;不写这句则接收所有人
          (propertyName = "messageSelector", propertyValue = "sender='Lily'") })
        //接收 Queue 消息时,如果有接收者,则直接发给接受着,不会发给监听者


-----------------------------------------------------------
Day7  part6 标注,定时器和拦截器

1. 标注
   //常规标注:
    @Stateless(name="ejb name")
    @Stateful
    @MessageDriven
    @Remote({If1.class})   //如果这个类实现多个接口,可以只指定其中某个接口是远程接口;默认所有接口都是远程的
    @Local(会话Bean接口标注,1.标注远程接口, 2.列出远程接口)

   //依赖注入标注
    @Resoure(mappedName="JNDI name")
    @EJB(beanName="ejb name")
    @PersistenceContext(unitName="unit name")  //persistence.xml包含多个持久化单元,必须指定unitName

   //JPA标注
    参看文档

2. 拦截器
   拦截器中定义的方法能够在EJB方法调用时自动调用
   //四种拦截器:
    1)缺省拦截器    部署在 ejb-jar.xml 中;最外层拦截
    2)类拦截器      拦截方法写在另一个类,在Bean类名前加 @Interceptors(拦截器类.class);对整个类的方法都有效
    3)方法拦截器    拦截方法写在另一个类,在需要拦截的方法前加 @Interceptors(拦截器类.class);仅对这方法有效
    4)自我拦截器    拦截方法定义在Bean本身(一个Bean只能有一个自我拦截方法)

    @Interceptors(Class.clas)    //注册拦截类
    @ArrounInvoke                //拦截类中的拦截方法
    public Object someMethod(InvocationContext ic);        //返回值是Object

   //拦截器链:
    所有拦截器组成了一个拦截器链
        ic.proceed();            //调用一下个拦截方法处理
    调用顺序:
        缺省拦截器,类拦截器,方法拦截器,自我拦截器;同级别拦截器,按声明顺序调用


-----------------------------------------------------------
part7 安全管理
1. 保证安全的四个环节
   1)身份验证。  要求用户标识自己的身份,提供证明自己身份的依据,计算机系统对其进行鉴别
   2)授权。     一旦用户身份验证通过,系统给用户分配访问资源的权限
   3)访问控制。  比较用户具有的权限和访问资源所需的权限
   4)安全审计。  记录和分析历史操作事件及数据,查找系统漏洞和可以改进的地方。
     目的是保证系统安全,保护数据,防止有意或无意的人为错误,防范和发现计算机网络犯罪活动。

2. JAAS(Java Authentication and Authorization Services )(java验证与授权服务)
   专门处理 身份验证(authentication) 及 权限管控(authorization) 的标准服务
   1)常用接口:
     Subject (包含用户信息:Princial, Credential等)
     Principal      //身份,授权信息
     Credential     //密码

     LoginContext   //登录上下文,用来选择验证模块
          使用LoginContext对象来验证Subject对象。LoginContext从配置文件中加载配置信息,这些配置信息告诉LoginContext对象在登录时使用哪一个LoginModule对象。
          login() 进行登录操作。该方法激活了配置中制定的所有LoginModule对象。如果成功,它将创建一个经过了验证的Subject对象;否则抛出LoginException异常。
          getSubject() 返回经过验证的Subject对象
         logout() 注销Subject对象,删除与之相关的Principal对象和凭证
     LoginModule      //登录模块
     CallbackHandler  //用来和用户交互,要求用户输入用户名和密码


3. web安全验证
   //1 服务器端配置安全域
    %Jboss_home%/server/default/conf/login-config.xml
    1) 基于属性文件的安全域
    2) 基于数据库的安全域

   //2 WebRoot/WEB-INF/jboss-web.xml 选择安全域
    <?xml version="1.0" encoding="UTF-8"?>
    <jboss-web>
        <!-- java:/jaas/固定格式,后面的是login-config.xml中配置安全域名称 -->
        <security-domain>java:/jaas/websecurity_db</security-domain>
    </jboss-web>

   //3 WEB-INF/web.xml
    1)选择验证方法
      表单验证(名称要求,固定写法)
        表单name="j_security_check"
        用户输入框name="j_user"
        密码输入框name="j_password"
      Basic验证(弹出一个系统对话框)
    2)定义安全约束;限制访问资源的用户
      <security-constraint>
         <!-- 配置受保护的资源 -->
         <web-resource-collection>
            <web-resource-name>Director</web-resource-name>
            <url-pattern>/admin/*</url-pattern> //定义可以访问的资源
            <http-method>POST</http-method>
            <http-method>GET</http-method>
         </web-resource-collection>
         <auth-constraint>
            <role-name>director</role-name>      //定义什么角色有效(可多个)
         </auth-constraint>
      </security-constraint>
    3)申明安全约束使用的角色
      <security-role> <role-name>director</role-name> </security-role>
      <security-role> <role-name>trainer</role-name>  </security-role>
      <security-role> <role-name>student</role-name>  </security-role>

   //4 基于属性的安全域,web项目的类路径提供用户和角色属性文件
    users.properties
    roles.properties
    备注:基于表单的验证方式不能直接访问login.html
   //5 基于数据库的安全域,配置数据库


   //编程式授权方式
    String role = request.isUserInRole();


4. EJB安全验证
   1)选择安全域
     (1)部署描述符jboss.xml(优先级高)
     (2)标注(jboss-annotations-ejb3.jar)@SecurityDoamin("domain")
   2)访问控制
     (1)RoleAllowed("role1","role2",)
        类级别
        方法级别(覆盖类级别设置)
     (2)PermitAll
        类级别(默认)
        方法级别(覆盖类级别设置)
     (3)DenyAll()
        只能在方法级别上使用
     (4)RunAs("other")
        用户可以被当作other角色访问资源
   3)客户端
     SecurityAssociation
       setPrincipal   (SimplePrincipal)
       setCredential   (String)
     这个帮助类会进行登陆验证,并返回一个Subject,此Subject对象会自动与ctx上下文自动关联




补充:定时器
特定时间执行的某项任务
//1 单动定时器;只运行一次
createTimer(Date expiration, String info)  //expiration 指定时间, info 任务的描述信息
createTimer(int duration, String info)     //duration 指定多久之后执行任务

//2 多动定时器
createTimer(Date initialExpiration,intervalDuration,info) //intervalDuration:每隔多久执行一次
createTimer(initialDuration, intervalDuration, info)

cancel() //取消任务
@Timeout //定时方法上标注


分享到:
评论

相关推荐

    ejb 总结ejb 总结,ejb 总结

    - **学习曲线**:EJB规范复杂,需要深入理解才能有效利用。 - **性能**:早期版本的EJB可能对资源消耗较大,但现代版本已显著改善。 总之,EJB是Java EE的重要组成部分,它为企业级应用提供了一套完整的解决方案...

    Weblogic Ejb 学习笔记

    WebLogic EJB学习笔记主要涵盖了企业级Java Bean(Enterprise JavaBeans,简称EJB)在Oracle WebLogic Server中的应用和管理。EJB是Java EE(Java Platform, Enterprise Edition)平台的核心组件,用于构建可扩展、...

    达内EJB3.0总结

    EJB3.0是EJB规范的一个重要版本,它在EJB2.1的基础上进行了大量的简化和改进,使得开发过程更加高效,同时也降低了学习曲线。 EJB3.0引入了以下几个关键特性: 1. **注解驱动**:在EJB3.0中,开发者可以使用注解...

    JavaEE5学习笔记07-Web层与EJB集成总结

    ### JavaEE5学习笔记07-Web层与EJB集成总结 #### 一、JavaEE5框架中的Web层与EJB集成概述 在JavaEE5(即Java Platform, Enterprise Edition 5)中,Web层与EJB(Enterprise JavaBeans)的集成是构建企业级应用的...

    EJB3.0总结.doc

    EJB(Enterprise JavaBeans)是Java EE(Enterprise Edition)平台的核心组成部分,用于构建可扩展、事务处理和安全的分布式企业...开发者可以通过学习EJB3.0,掌握构建可扩展、事务处理和安全的企业级应用程序的技术。

    J2EE的EJB实践总结包

    EJB实践的服务器是用SUN的服务器,也有用weblogic的一些例子。包里还包括EJB调用EJB、连接数据库、命令行布署EJB等总结。另外,还包括对Jasmine购物系统的分析及总结。是学习EJB很好的总结。

    JavaEE5学习笔记05-EJB之会话Bean总结

    ### JavaEE5学习笔记05-EJB之会话Bean总结 #### EJB(Enterprise JavaBeans)简介 EJB(Enterprise JavaBeans)是Java EE平台的一部分,用于开发和部署可重用的服务组件。EJB规范定义了如何编写、部署以及管理企业...

    EJB3.0学习心得

    ### EJB 3.0 学习心得及关键技术解析 #### EJB 3.0 概述 EJB (Enterprise JavaBeans) 是一种基于 Java 的企业级应用开发模型,它为构建可伸缩、可移植且健壮的企业级应用程序提供了一种标准化的方法。随着技术的...

    EJB3.0学习总结(二)--EJB3.0容器模型的WEB服务

    **EJB 3.0 学习总结(二)——EJB 3.0 容器模型的 WEB 服务** EJB(Enterprise JavaBeans)3.0 是 Java 平台企业版(Java EE)中的一项核心技术,它为构建可扩展、安全且易于管理的企业级应用程序提供了强大的支持...

    Weblogic EJB 学习笔记

    总结来说,Weblogic EJB的学习需要理解EJB的基本概念,掌握不同类型的bean及其特点,熟悉配置描述器的使用,以及如何在Weblogic环境中管理和控制事务。这些都是开发企业级Java应用程序的关键技能。在实际应用中,...

    JPA学习笔记-EJB-04JPA关联映射总结

    在EJB(Enterprise JavaBeans)框架中,JPA被广泛使用,提供了一种面向对象的方式来处理数据库交互。本篇笔记主要聚焦于JPA的关联映射,这是JPA中一个重要的概念,用于定义实体之间的关系。 关联映射允许我们将...

    ejb2.0与ejb3.0的区别

    例如,可以使用POJO(Plain Old Java Object)风格的EJB,这降低了学习曲线并提高了生产力。 - **EJB 3.0**:增强了消息驱动Bean的功能,使其能够更灵活地处理异步消息传递。 - **EJB 3.0**:引入了新的注解,如`@...

    EJB3 学习笔记

    学习EJB3过程中自己总结的一些关于学习EJB3的技术点,以及可能遇到的问题

    EJB应用开发详解

    总结,EJB应用开发详解的内容涵盖了EJB的核心概念、类型、编程模型、容器服务、分布式特性和与其他技术的集成,是学习和精通企业级Java开发的重要参考资料。通过深入学习,开发者可以构建出高效、可靠且易于维护的...

    EJB 和WEBLOGIC 结合例子

    总结起来,EJB和WebLogic的结合是构建大型企业系统的关键技术,它允许开发者专注于业务逻辑,同时享受Java EE平台带来的各种便利。深入学习和实践这个主题,将有助于提升Java EE应用的开发和管理能力。

    ejb 学习笔记

    ### EJB学习笔记知识点梳理 #### 一、EJB概览 **EJB**(Enterprise JavaBeans)是一种Java EE技术,用于开发、部署服务器端的分布式应用组件。它旨在简化企业级应用程序的开发过程,通过将复杂的底层服务(如事务...

    东北大学EJB实验报告

    在本次实验中,我们将深入学习EJB的基本概念、类型以及它们如何在分布式环境中协同工作。 ### EJB基础知识 1. **EJB概念**:EJB是Java EE(Enterprise JavaBeans)的一部分,是一种服务器端组件模型,它提供了一种...

    EJB教程(技术规范)

    Enterprise JavaBeans (EJB) 是Java平台上用于...学习EJB不仅能够帮助开发者深入理解分布式系统的设计,也为理解现代框架提供了历史背景和理论基础。阅读"EJB.chm"文件,将有助于你全面掌握EJB技术规范及其应用场景。

    传智播客ejb3.0教学ppt

    ### 传智播客EJB 3.0教学PPT知识点总结 #### 一、EJB 3.0概述 - **定义**:EJB(Enterprise JavaBeans)是一种用于构建分布式业务应用程序的标准服务端组件模型。EJB 3.0是EJB标准的一个重大更新,简化了许多先前...

Global site tag (gtag.js) - Google Analytics