tarena学习EJB笔记

EJB day1 Wednesday 2007.3.28
Enterprise JavaBeans
写EJB项目步骤：
1.建立EJB项目的路径。
2.设置CLASSPATH(类路径)：
EJB目录/lib/javaee.jar //编译时
EJB目录/lib/appserv-rt.jar //运行时
如：liunx下配置
export CLASSPATH=.:opt/EJB/lib/javaee.jar:opt/EJB/lib/appserv-rt.jar:$CLASSPATH
3.写bean类，需要暴露的接口：Remote,Local
必须要有接口与实现类；远程通过接口中暴露的方法，向服务器发起调用，用服务器调用具体的实现类
public interface BeanRemote{
  String m1(String v);
  }
  //只在服务器端有
  //无状态模式
@Stateless
@Remote(BeanRemote.class)
public Bean implements BeanRemote{
  String m1(String v){
   //方法实现的代码
  };
}
4.编译bean类。
5.打成jar包
6.部署到服务器上
7.(可选)写一个测试类测试
public class BeanTest {
    public BeanTest() {}
    public static void main(String[] args) throws NamingException {
      //设置远程访问的IP地址
        System.setProperty("org.omg.CORBA.ORBInitialHost","192.168.12.41");
        InitialContext context=new InitialContext();
   //在上下文中查询
        BeanRemote beanRemote=(BeanRemote) context.lookup(BeanRemote.class.getName());
        //调用BeanRemote的方法
    String s=beanRemote.m1("abc");
    }
}
==============================================================================================

EJB day2 Thursday 2007.3.29

1.Stateless Session Bean
特点：存入Bean pool，无成员属性保存数据
Stateful Session Bean
特点：存入cache中,成员属性保存数据,只供各自客户端使用

2.Lifecycle of Session Bean(生命周期)
------------------------------------------------
Stateless and Stateful 注释
@Stateless :声明该Session Bean是无状态的
@Stateful :声明该Session Bean是有状态的

*写这些注释的方法的标准：public void method()  //只有method可自己命名
@PostConstruct :在Session Bean创建后，调用该方法
@PreDestroy :在Session Bean销毁前，调用该方法
@Remove :(Stateless 中无用)接口中暴露该方法，由客户端主动调用该方法，调用后会销毁Session Bean,销毁前会调用@PreDestroy(有则调用）

Stateful 注释
@PrePassivate :内存cache中Session Bean被用完时，回根据配置的策略选一个Session Bean存到磁盘中（叫遁化）前调用该方法
@PostActivate :从磁盘中取回数据到内存cache中后，调用该方法

三中策略：
LRU:最近最少使用策略
FIFO:先进先出策略
NRU:（Not Recently Used）这种近似LRU算法，已经退化成一种"最近不用"的算法

3.NetBeans 5.5使用
一般端口设置：
  Admin port:4848
  Domain Http port:8080
  ORB Listener Port:3700
  HTTPS port 8181

用NetBeans写EJB
选择新建项目：企业(Enterprise)->企业应用(EnterpriseApplication)[选择创建EJB模块，客户段模块]
在EJB模块->源包(Source)中建一个会话bean(Session bean)
1).//远程借口类session class
  @Remote
  public interface CountRemote{
   int count();
   @Remove
   void remove();
  }
2).//接口实现类session class
  @Stateful
  //如果使用拦截器，需要在这里配置，拦截器的类
  @Interceptors({CountInterceptor.class})
  public class CountBean implements CountRemote{
   private int val;
   public int count(){//实现代码};

   @Remove
   public void remove(){//实现代码};

   /*
   //如果拦截器中有了该方法就不用写在该类中了
   @Postconstruct
   public void construct(){//实现代码};
   */
  }
3).//拦截器(可选)java class
  public class CountInterceptor{
   @PostConstruct
   public void construct(){//实现代码};
   @preDestroy
   public void destroy(){//实现代码};
   @PrePassivate
   public void passivate(){//实现代码};
   @PostActivate
   public void activate(){//实现代码};
  }

4).//测试类(可选) java main
  创建Enterprise Applicaton Client(不通用,只有sun公司提供),提供了EJB运行环境容器
public class CountTest {
  //创建EJB Session bean
  //注入的方式创建bean,提供了运行环境容器
    @EJB
    private static CountRemote countRemote;
    public CountTest() {
    }
    public static void main(String[] args) {
    //可以直接使用，不关心如何获得
      int i=countRemote.count();
      countRemote.remove();
      }
  }
5.//配置EJB配置文件下的sun-ejb-jar.xml
  Bean pool:(Stateless)
  稳定池大小：
  调整数量：
  最大池数量：
  池空闲超时秒数：
  Bean cache:(Stateful)
  最大缓存大小：
  调整数量：
  是否允许缓存溢出：(有些不支持)
  缓存空闲超时秒数：
  删除超时秒数：>100
  牺牲者选择策略：LRU
==============================================================================================
EJB day3 Friday 2007.3.30
WebService:主要目标是跨平台的可互操作性。为了达到这一目标，WebService完全基于XML（可扩展标记语言）、XSD（XMLSchema）等独立于平台、独立于软件供应商的标准，是创建可互操作的、分布式应用程序的新平台。
1.用EJB生成WebService
   1)写Session Bean(声明为WebService);
   @Stateless
   //声明生成WebService发布,服务名(serviceName):AdderService,(portName):AdderSerevicePort
   @WebService(serviceName="AdderService",portName="AdderServicePort")
   public class AdderBean implements AdderLocal {

       /** Creates a new instance of AdderBean */
       public AdderBean() {
       }
    //声明该方法在WebService中发布,如果所有的方法都不加,默认都发布
       @WebMethod
       public int add(int a, int b) {
           //TODO implement add
           return a+b;
       }
   }
   2).部署(Deploy)到服务器上.在浏览器上获取他的地址(http://localhost:8080/AdderService/AdderBean?WSDL)
    生成的是xml文档
   3).在客户端创建Web Service Client->WSDL URL:http://localhost:8080/AdderService/AdderBean?WSDL
    创建成功会访问服务器把应用下载到本地,生成相关的java.class和*.java等文件.包括:
    AdderService.java:连接WebService的静态类，获取AdderBean的实体
    AdderBean.java:只是接口(暴露所提供的方法),以便我们调用
   4).(可选)写一个测试类,创建一个java main class
    package test;
    import java.net.MalformedURLException;
    import java.net.URL;
    import javax.xml.namespace.QName;
    import javax.xml.ws.Service;
    public class AdderTest {
        public AdderTest() {}
        public static void main(String[] args) throws MalformedURLException {
            //静态
     /获取服务对象
            AdderService service=new AdderService();
     //获得Session Bean
            AdderBean adderBean=(AdderBean)service.getAdderServicePort();
     //调用他暴露的方法
            System.out.println(adderBean.add(12,23));
            //动态
            URL wsdlURL=new URL("http://localhost:8080/AdderService/AdderBean?WSDL");
            QName serviceName=new QName("http://day03/", "AdderService");
            Service service2=Service.create(wsdlURL,serviceName);
            adderBean=(AdderBean)service.getAdderServicePort();
           System.out.println(adderBean.add(12,23));
        }
    }

2.Message Service(JMS)
创建queue message服务(点对点),发送者,接收者
发送者->queue message->一个接收者
1).在sun java System Application Server上创建消息转发:
  Application Server->Resources->JMS Resources->Connection Factories->new[JNDI Name=jms/cfA Type=javax.jms.ConnectionFactory{自动区别queue或topic}]
  Application Server->Resources->JMS Resources->Destination Resources->new[JNDI Name=jms/queueA Type=javax.jms.Queue name={必须有,随便输}]
2).客户端必须创建Enterprise Applicaton Client下创建发送者,和接收者
   import javax.jms.Connection;
   import javax.jms.ConnectionFactory;
   import javax.jms.MessageProducer;
   import javax.jms.Queue;
   import javax.jms.Session;
   import javax.jms.TextMessage;
   import javax.naming.Context;
   import javax.naming.InitialContext;
   import javax.naming.NamingException;
   public class Sender {
       public Sender() {}
       public static void main(String[] args) throws Exception {
    System.setProperty("jndi.factory","com.sun.jndi.cosnaming.CNCtxFactory");
    System.setProperty("jndi.provider.url","corbaloc::localhost:3700/NameService");
           Context context=new InitialContext();
           ConnectionFactory cf=(ConnectionFactory) context.lookup("jms/cfA");
           /*
           //等价上面2行
           context context2=context.lookup("jms");
           ConnectionFactory cf2=context2.lookup("cfA");
           */
           Queue queueA=(Queue) context.lookup("jms/queueA");
           Connection con=cf.createConnection();
           //false不支持事务(自动通知接收者),手动通知
           Session session=con.createSession(false,Session.AUTO_ACKNOWLEDGE);
           MessageProducer producor=session.createProducer(queueA);
           TextMessage msg=session.createTextMessage();
           msg.setText("***********");
           producor.send(msg);
           System.out.println("send completed!!!");
     //关闭连接
           con.close();
       }
   }
    3.接收者
   public class Receiver {
       public Receiver() {}
       public static void main(String[] args) throws Exception {
    System.setProperty("jndi.factory","com.sun.jndi.cosnaming.CNCtxFactory");
    System.setProperty("jndi.provider.url","corbaloc::localhost:3700/NameService");
           Context context=new InitialContext();
           ConnectionFactory cf=(ConnectionFactory) context.lookup("jms/cfA");
           Queue queueA=(Queue) context.lookup("jms/queueA");
           Connection con=cf.createConnection();
           //false不支持事务(自动通知接收者),手动通知
           Session session=con.createSession(false,Session.AUTO_ACKNOWLEDGE);
           MessageConsumer consumer=session.createConsumer(queueA);
           //必需告诉消息服务器,准备好了
           con.start();
           //没有接收到消息则阻塞,每次只接收一条消息
           TextMessage msg=(TextMessage) consumer.receive();
           System.out.println(msg.getText());
            con.close();
       }
   }
==============================================================================================
EJB day4 Friday 2007.4.2
1.Message Service(JMS)监听器（监听者、接收者）
1).Message-Driven Bean(MDB)：需要实现两个接口：
  javax.jms.MessageListener
  javax.ejb.MessageDrivenBean(可选)
  它一般是无状态bean.生命周期有：@PostConstruct、@PreDestroy
  用NetBeans写MDB
   选择新建文件：[EJB 模块]->Enterprise->Message-Driven Bean(MDB)->[类名、包名、消息类别]
  //mappedName:表示服务器上的DNJI名。
  @MessageDriven(mappedName = "jms/queueA", activationConfig = {
   //
      @ActivationConfigProperty(propertyName = "acknowledgeMode", propertyValue = "Auto-acknowledge"),
      //消息的类型；Queue:队列、Topic:主题
      @ActivationConfigProperty(propertyName = "destinationType", propertyValue = "javax.jms.Queue"，
      //（可选）消息选择器，JMSType='1':该监听器只接收类型为‘1’的消息，需要在发送者发送消息时著名类型：
      @ActivationConfigProperty(propertyName = "messageSelector", propertyValue = "JMSType='1'"
      )
  })
  public class Inserter implements MessageListener {

      @Resource(name = "jdbc/sample")
      private DataSource jdbcSample;

      /** Creates a new instance of Inserter */
      public Inserter() {
      }

      public void onMessage(Message message) {
          if(message instanceof TextMessage){
            //文本消息
              TextMessage msg=(TextMessage) message;
              //对象消息
//       ObjectMessage msg=(ObjectMessage)message4;
              request = msg.getText();
              }
          }
      }
  }
2. Return Results Back to Message Producers(发送者发送消息，并接收返回消息)

3.The Entity Class(实体)
  1).用NetBeans写MDB
   选择新建文件：[EnterpriseApplication-app-client]->Persistence(持久性)->Entity class->[类名、包名、创建持久性单元（选择数据库）]
  2).为实体类写一个stateless Session Bean
@Stateless
public class AccountSLBean implements AccountSLRemote {
  //注入持久性管理器
    @PersistenceContext
    private EntityManager em;

    /** Creates a new instance of AccountSLBean */
    public AccountSLBean() {
    }

public void doSomething(){
        Account a1=new Account();
        a1.setBalance(1000);
        a1.setOwerName("yoogo");
        //持久化到数据库
        em.persist(a1);
    }

    public Account findByPrimaryKey(Long id){
        return em.find(Account.class,id);
    }

    public List findAll(){
        String s="select a from Account a";
        return em.createQuery(s).getResultList();
    }
}

==============================================================================================
EJB day5 Tuesday 2007.04.03
1.EntityManager(实体管理器)中的方法

1). EntityManager.createQuery(String s);//等效于JDBC中的PreparedStatement()
     Query query=entityManager.createQuery("select a from Acount a where name= :name");
     query.setParamenter("name","hiloo");

2). EntityManager.createNameQuery("select * from acount");//直接使用SQL语句
3). EntityManager.createNamedQuery();//
     类前面声明namedQuery
     @NamedQuery(name="findAll",query="select a from Account a")
     class AccountBean{
     //....中间代码
     Query query=entityManager.createNamedQuery("findAll");

2.实体管理器注释
@PersistenceContext(type=PersistenceContextType.EXTENDED)   //用于stateful session bean
@PersistenceContext(type=PersistenceContextType.TRANSACTION)   //用于stateless session bean

@Stateful
public class AccountSFBean implements AccountSFRemote {
     unitName="EntityBean1-
     @PersistenceContext(type=PersistenceContextType.EXTENDED)
     private EntityManager em;
     Account a;
     public AccountSFBean() {}
     public Account open(Long id,String name){
         a=em.find(Account.class,id);
         if(a==null){
             a=new Account();
             a.setOwerName(name);
             em.persist(a);
         }
         return a;
     }
     public void deposit(double amount){
         a.setBalance(a.getBalance()+amount);
     }
     public void withdraw(double amount){
         a.setBalance(a.getBalance()-amount);
     }
}

3.Entity Life cycle(实体的声明周期)
@PrePersist   //持久化前调用该方法
@PostPersist   //持久化后调用该方法
@PreUpdate   //更新前调用该方法
@PostLoad   //加载后调用该方法
举例:
     1).写一个EntityListener(实体监听器)
public class AccountListener{
     @PrePersist
     public void prePersist(Account a){//代码块}
     @Postpersist
     //.... 同PrePersist
}
     2).在Entity中注册EntityListener
@Entity
@EntityListeners(AccountListener.class)
public class Account implements Serializable{
     @Id
     @GeneratedValue(strategy=GenerationType.AUTO)
     private Long accountno;
     @Cloumn
     private String name;
     //...
}

实体的状态

new新建，也就是新建的实体实例，其信息还没有持久到数据库中。
managed受管状态，也就是实体已经持久化到数据库中，并且已经和持久化上下文进行了关联。
detached分离状态，也就是与持久化上下文解除关联的实体的状态
removed删除，此时实体和持久化上下文进行了关联，但是要从数据库中删除这个实体。

new      persist()    中止PersistenceContext >
——>新建————>受管========================分离
                     ||/   < merge()
            remove()/|| persist()
                    删除

@PersistenceContext，持久化上下文是内存中的实例和数据库间的连接枢纽，就像是一快缓冲区，但这个缓冲区是由容器来进行管理的，在这个缓冲区中的实体是处在受管理状态。

@PersistenceContext(type=PersistenceContextType.EXTENDED,unitName="PetPU")
type属性使用来标识持久化上下文的类型的，持久化上下文有两种类型事务范围和扩展的。这两种类型的持久化上下文的生命周期不同。unitName属性是指定持久化单元的名字，其值是在持久化单元定义文件中persistence-unit标签中的name属性的值。

事务范围的持久化上下文应用到无状态SessionBean，一旦事务终结，就销毁，其中的实体也会变成分离状态。
扩展的持久化上下文应用在有状态的SessionBean，只有在有状态的SessionBean被容器销毁是才会销毁持久化上下文，也就使实体一直是被管理的。

持久化单元的定义文件，这个文件是描述数据库连接和事务管理的文件

<persistence version="1.0" xmlns="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">
    
<persistence-unit name="PetPU" transaction-type="JTA">
    
    <provider>oracle.toplink.essentials.ejb.cmp3.EntityManagerFactoryProvider</provider>
    
    <jta-data-source>my.jdbc</jta-data-source>
     
    <properties>
      <property name="toplink.ddl-generation" value="create-tables"/>
    </properties>
</persistence-unit>
</persistence>

EntityManager实体管理器，它是用来管理实体的，如果使用容器管理实体，容器就会注入EntityManager，EntityManager可以提供实体类生命周期管理，实现数据的同步，和实体的数据的查询。

实体生命周期回调方法

实体的生命周期回调方法不是通用的。
在实体类中定义时，只在方法前加标注，并且方法的返回值为void，方法为public
也就是：

@PrePersist
public void save(){}
在另外的类中写生命周期回调方法时，就需要以这个实体类为参数了
class AcountListenter{
@PrePersist
public void save(Acount a){}
}

@Entity
@EntityListenters(AcountListenter.class)
class Acount...

PostPersist
PreRemove
PostRemove
PreUpdate
PostUpdate
PostLoad

tarena学习EJB笔记相关推荐

Spring5学习详细笔记
学习链接 Spring5学习详细笔记 Spring学习总结 - 工厂第一章 :引言 1. 什么是spring 2. 设计模式 3. 工厂设计模式 3.1 什么是工厂设计模式 3.2 简单工厂的设计 ...
python神经结构二层_《python深度学习》笔记---8.3、神经风格迁移
<python深度学习>笔记---8.3.神经风格迁移一.总结一句话总结: 神经风格迁移是指将参考图像的风格应用于目标图像,同时保留目标图像的内容. 1."神经风格迁移是指将 ...
tensorflow学习函数笔记
为什么80%的码农都做不了架构师?>>> [TensorFlow教程资源](https://my.oschina.net/u/3787228/blog/1794868](htt ...
CSDN技术主题月----“深度学习”代码笔记专栏
from: CSDN技术主题月----"深度学习"代码笔记专栏 2016-09-13 nigelyq 技术专题 Hi,各位用户 CSDN技术主题月代码笔记专栏会每月在CODE博客为 ...
深度学习-最优化笔记
深度学习-最优化笔记作者:杜客链接:https://zhuanlan.zhihu.com/p/21360434 来源:知乎著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明出处. 译 ...
深度学习入门教程UFLDL学习实验笔记三：主成分分析PCA与白化whitening
深度学习入门教程UFLDL学习实验笔记三:主成分分析PCA与白化whitening 主成分分析与白化是在做深度学习训练时最常见的两种预处理的方法,主成分分析是一种我们用的很多的降维的一种手段,通 ...
深度学习入门教程UFLDL学习实验笔记一：稀疏自编码器
深度学习入门教程UFLDL学习实验笔记一:稀疏自编码器 UFLDL即(unsupervised feature learning & deep learning).这是斯坦福网站上的一篇 ...
学习LOAM笔记——特征点提取与匹配
学习LOAM笔记--特征点提取与匹配学习LOAM笔记--特征点提取与匹配 1. 特征点提取 1.1 对激光点按线束分类 1.2 计算激光点曲率 1.3 根据曲率提取特征点 2. 特征点匹配 2.1 ...
学习MSCKF笔记——后端、状态预测、状态扩增、状态更新
学习MSCKF笔记--后端.状态预测.状态扩增.状态更新学习MSCKF笔记--后端.状态预测.状态扩增.状态更新 1. 状态预测 2. 状态扩增 3. 状态更新学习MSCKF笔记--后端.状态预测 ...

tarena学习EJB笔记

tarena学习EJB笔记相关推荐

最新文章

热门文章