我的EJB学习历程

哈哈，过了一个轻松的周末，又要開始写东西咯。

周末本来也想写，可是还是认为玩有意思，姑且放几天假。

上次讲的是无状态会话BEAN。

好象还是有点不明确为什么要分无状态和状态会话BEAN这两种BEAN，只是不要紧，看完状态会话BEAN的程序就能明确了。对了，另一点要说的。我周五那天搞了一天的ECLIPSE3，听说他出新版本号了，所以赶紧下载试验试验，他在里边新加了功能叫EJB EDITOR，这个东西不错，有好多新东西。可是唯一另我费解的是为什么用他CREATE CLIENT TEST PROGRAMM的时候却总是报错！所以还是比較的烦躁的！也不知道是ECLIPSE的毛病还是我机器自己执行环境的毛病，大家也试试然后告诉我啊！

我的这个状态会话BEAN还是用ECLIPSE2.1写的拉。

我先把程序写给大家，然后再分析吧，我好象是那种喜欢先看程序然后再看理论的人。不知道是不是有人和我一样。

这是客户端的实现程序：

package com.test.session;

import javax.ejb.*;

/**

 * @ejb.bean name=”Stateful”

 *  jndi–name=”StatefulBean”

 *  type=”Stateful”

 *

 *—

 * This is needed for JOnAS.

 * If you are not using JOnAS you can safely remove the tags below.

 * @jonas.bean ejb–name=”Stateful”

 *  jndi–name=”StatefulBean”

 *

 *—

 **/

public abstract class StatefulBean implements SessionBean {

/**

 * @ejb.create–method

 *  view–type=”remote”

**/

public void ejbCreate(double amout) throws CreateException{

    this.amout=amout;

}

/**

 * @ejb.interface–method

 *  view–type=”remote”

**/

public void addFunds(double amout){

    this.amout+=amout;

}

/**

 * @ejb.interface–method

 *  view–type=”remote”

**/

public void withdrawFunds(double amout){

    this.amout-=amout;

}

/**

 * @ejb.interface–method

 *  view–type=”remote”

**/

public double getBalance(){

 return this.amout;

}

double amout;

}

对了，ejbCreate(double amout)方法是在BEAN生成过程中，容器调用ejbCreate(double amout)方法的。

就好象是初始化的方法一样。

还有你一定要确保在主接口中有个Create（double amout）方法和ejbCreate(double amout)相应啊！这段是必须的，假设不明确的话，赶紧找资料。你这个ejbCreate(double amout)方法在新建的时候要选择CREATE哦！

在把客户端的測试程序给你们：

package com.testing.client;

import java.rmi.RemoteException;

import java.util.Hashtable;

import javax.ejb.CreateException;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import javax.swing.JFrame;

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

import java.text.*;

import com.test.session.*;

/**

 * @author sy

 *

 * 更改所生成类型凝视的模板为

 * 窗体 > 首选项 > Java > 代码生成 > 代码和凝视

 */

public class testStateful extends JFrame  implements ActionListener{

    public testStateful(){

        super(“fund manger”);

    }

    private com.test.session.StatefulHome getHome() throws NamingException {

        return (com.test.session.StatefulHome) getContext().lookup(

            com.test.session.StatefulHome.JNDI_NAME);

    }

    private InitialContext getContext() throws NamingException {

        Hashtable props = new Hashtable();

        props.put(

            InitialContext.INITIAL_CONTEXT_FACTORY,

            “org.jnp.interfaces.NamingContextFactory”);

        props.put(InitialContext.PROVIDER_URL, “jnp://127.0.0.1:1099”);

        // This establishes the security for authorization/authentication

        // props.put(InitialContext.SECURITY_PRINCIPAL,”username”);

        // props.put(InitialContext.SECURITY_CREDENTIALS,”password”);

        InitialContext initialContext = new InitialContext(props);

        return initialContext;

    }

    public void CreateFund() {

        try {

            myBean = getHome().create(1000);

            //————————————–

            //This is the place you make your calls.

            //System.out.println(myBean.callYourMethod());

        } catch (RemoteException e) {

            e.printStackTrace();

        } catch (CreateException e) {

            e.printStackTrace();

        } catch (NamingException e) {

            e.printStackTrace();

        }

    }

    public void testBean() {

            buildGUI();

            addWindowListener(new WindowAdapter(){public void WindowClosing(WindowEvent evt){System.exit(0);}});

            CreateFund();

            addFund.addActionListener(this);

            withdraw.addActionListener(this);

            currencyFomat=NumberFormat.getCurrencyInstance();

            try{

            String currency=currencyFomat.format(myBean.getBalance());

            status.setText(msg+currency);

            }catch(Exception e){}

            pack();

            show();

        }

        public void actionPerformed(ActionEvent e){

            String str=amout.getText();

            try{

                if(e.getSource()==addFund){

                    myBean.addFunds(Double.parseDouble(str));

                    currencyFomat=NumberFormat.getCurrencyInstance();

                    strBar=currencyFomat.format(myBean.getBalance());

                    status.setText(msg+strBar);

                }

                if(e.getSource()==withdraw){

                    myBean.withdrawFunds(Double.parseDouble(str));

                    currencyFomat=NumberFormat.getCurrencyInstance();

                    strBar=currencyFomat.format(myBean.getBalance());

                    status.setText(msg+strBar);

                }          

            }catch(Exception ex){}

        }

    public void buildGUI(){

            GridBagLayout gl=new GridBagLayout();

            GridBagConstraints gc=new GridBagConstraints();

            Container container=getContentPane();

            container.setLayout(gl);

            gc.fill=GridBagConstraints.BOTH;

            JLabel label=new JLabel(“enter amout”);

            gl.setConstraints(label,gc);

            container.add(label);

            gc.gridwidth=GridBagConstraints.REMAINDER;

            gl.setConstraints(amout,gc);

            container.add(amout);

            gl.addLayoutComponent(addFund,gc);

            container.add(addFund);

            gl.addLayoutComponent(withdraw,gc);

            container.add(withdraw);

            status=new JLabel(msg);

            gl.addLayoutComponent(status,gc);

            container.add(status);     

        }

        double balance=100;

        JTextField amout=new JTextField(10);

        JButton addFund=new JButton(“add funds”);

        JButton withdraw=new JButton(“withdraw funds”);

        String msg=“current funds is:”;

        String strBar=“0”;

        JLabel status;

    Stateful myBean;

        NumberFormat currencyFomat;

    public static void main(String[] args) {

        testStateful test = new testStateful();

        test.testBean();

    }

}

看出来门道了吗？我最终知道为什么这个要叫做：状态会话BEAN了。由于，由于。。。。。哈哈，他有个amout变量，这个全然是EJB内部的变量，在EJB容器中保存！而和那个无状态会话BEAN不一样的地方就是，无状态会话BEAN是在客户端保存数据。非常大的差别！这就是问题的关键！也不知道你们看懂了没有！反正我认为真的非常明显。

下边这个是我在IBM文章库里找的一副图，感觉不错，全然讲明确了状态BEAN是怎么回事拉：

这些是些解说，和书上的差点儿相同，省得我打字了。

有状态会话 Bean 生命周期：

• Bean 在下列情况下被回收:
  
  • 超时 (不管是激活的或钝化的)
    
  • 被调用 remove()
    
• Passivation 是依据 Least-Recently-Used 算法
  
• Activation 由对 Bean 的方法调用产生
  
• afterBegin()
  beforeCompletion()
  afterCompletion()
  方法仅对实现 SessionSynchronization 接口的 Bean 有效
  
• 在一个事务环境下，调用的方法必需具有同样的事务类型
  

OK，状态会话BEAN就是这么回事。应该是非常easy的东西，全然能够理解。

呵呵，大家看见了那个总回我帖子的QUGHOST了吗？他是我的好朋友。

他有好多的搞笑故事，我和他商议了一下，准备把他的搞笑经历发在我的一个新版块里，可是不知道他允许不允许。

OK，话归正传。我立即就要把第三章结束了，事实上第三章的会话BEAN到5就已经讲完了，可是这里边另一个非常关键的东西，那就是序列化。

序列化 (Serialization)

• Java 序列化机制能够将整个对象的状态输出到一个流上
  
• 对象能够再从其原始状态又一次构建回来
  

事实上非常easy了，就是把某个对象的全部东西都输出到一个文件上。这里也能够是别的东西。好多。

然后当你还想用他的时候，就再在这个文件上把这个对象的状态等等的一些信息全部找回来。

真正发生了什么

• Bean 的实例没有被序列化
  假设 Bean 实例本身被序列化，当它被又一次构建时一个新的实例须要被创建这就丢失了实例池的意义
  
• Bean 的状态被序列化
  每个属性须要被单独考虑
  

什么会被序列化?

• 一个可序列化 (serializable) 的对象
  
• 一个 null
  
• 对特定不可序列化对象的直接引用:
  
  • 一个 Bean 的 home 或 remote 接口的引用
    
  • 对 SessionContext 的引用
    
• 对不可序列化部分的直接引用的序列化
  
  • 容器必需对不可序列化的 EJB 在钝化时保存它们的 remote 和 home 接口
    
  • 或许依赖于 Java 的 java.io.ObjectOutputStream 和 java.io.ObjectInputStream 中的对象替换技术来实现
    

部分序列化

• 构成状态的每样属性必需是可序列化的
  
• 全部属性的内容必需包含可序列化的值
  
• Helper 类
  
• 否则容器能够选择在钝化时回收该 Bean 实例
  

这些全是我从IBM抄下来的。希望对大家理解序列化有帮助。

把我的程序也给你们吧，我用的还是那个状态会话BEAN的那个EJB。

/*

 * 创建日期 2004-7-5

 *

 * 更改所生成文件模板为

 * 窗体 > 首选项 > Java > 代码生成 > 代码和凝视

 */

package com.testing.client;

import java.rmi.RemoteException;

import java.util.Hashtable;

import javax.ejb.CreateException;

import javax.naming.InitialContext;

import javax.naming.NamingException;

import com.test.session.*;

import java.io.*;

import javax.ejb.Handle;

/**

 * @author sy

 *

 * 更改所生成类型凝视的模板为

 * 窗体 > 首选项 > Java > 代码生成 > 代码和凝视

 */

public class HandleTest {

    private com.test.session.StatefulHome getHome() throws NamingException {

        return (com.test.session.StatefulHome) getContext().lookup(

            com.test.session.StatefulHome.JNDI_NAME);

    }

    private InitialContext getContext() throws NamingException {

        Hashtable props = new Hashtable();

        props.put(

            InitialContext.INITIAL_CONTEXT_FACTORY,

            “org.jnp.interfaces.NamingContextFactory”);

        props.put(InitialContext.PROVIDER_URL, “jnp://127.0.0.1:1099”);

        // This establishes the security for authorization/authentication

        // props.put(InitialContext.SECURITY_PRINCIPAL,”username”);

        // props.put(InitialContext.SECURITY_CREDENTIALS,”password”);

        InitialContext initialContext = new InitialContext(props);

        return initialContext;

    }

    public void testBean() {

        try {

            com.test.session.Stateful myBean = getHome().create(1000);

            //System.out.println(“adding 1000”);

            myBean.addFunds(1000);

            System.out.println(“adding 1000”);

            System.out.println(“Now Account is:”+myBean.getBalance());

            myBean.withdrawFunds(100);

            System.out.println(“withdrawing 100”);

            System.out.println(“Now Account is:”+myBean.getBalance());

            System.out.println(“saving Handle”);

            saveHandle(myBean);

            System.out.println(“saving success”);

            myBean=null;

            System.out.println(“loading Handle”);

            myBean=loadHandle();

            System.out.println(“loading success”);

            System.out.println(“Now Account is:”+myBean.getBalance()+“,withdrawing 100”);

            myBean.withdrawFunds(100);

            System.out.println(“Now Account is:”+myBean.getBalance());

            //————————————–

            //This is the place you make your calls.

            //System.out.println(myBean.callYourMethod());

        } catch (RemoteException e) {

            e.printStackTrace();

        } catch (CreateException e) {

            e.printStackTrace();

        } catch (NamingException e) {

            e.printStackTrace();

        }

    }

    public static void main(String[] args) {

        HandleTest test = new HandleTest();

        test.testBean();

    }

    private static void saveHandle(Stateful mybean){

        try{

            FileOutputStream fos=new FileOutputStream(“symic”);

            ObjectOutputStream out=new  ObjectOutputStream(fos);

            out.writeObject(mybean.getHandle());

            out.close();

        }catch(Exception e){}

    }

    private static Stateful loadHandle(){

        try{

            FileInputStream fis =new FileInputStream(“symic”);

            ObjectInputStream in =new ObjectInputStream(fis);

            Handle handle=(Handle)in.readObject();

            Stateful mybean=(Stateful)handle.getEJBObject();

            in.close();

            return mybean;

        }catch(Exception x){}

        return null;

    }

}

事实上非常easy，看我的程序就好，然后找找SYMIC文件，看看他里边写了些什么东西。哈哈~~~~

说点别的，我近期发现原来ITLAY真的是个不错的国家。可是好象在中国根本就没有机会去吧！

ITaly

,SHopper’s DEstinatiON!

在他那买东西非常合适啊！听说PRADA，AMANI在那有非常多TAX REBATE的店啊，仅仅有国内的一半价钱，而且东西全是最TOP 的CLASS。

真想去啊~~~~~~~~~~

ITALY

MY DREAM-PRADISE!

呵呵！~~~