accountbean.java

学习J2EE的好事例

//定义本接口在包examples.ejb.basic.beanManaged
package examples.ejb.basic.beanManaged;
//本类用到的其他类。javax.ejb.*是开发EJB应用需要的类库。javax.naming.*是实现JNDI服务需要的类库
import java.io.Serializable;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Vector;

import javax.ejb.CreateException;
import javax.ejb.DuplicateKeyException;
import javax.ejb.EJBException;
import javax.ejb.EntityBean;
import javax.ejb.EntityContext;
import javax.ejb.FinderException;
import javax.ejb.NoSuchEntityException;
import javax.ejb.ObjectNotFoundException;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
 * AccountBean是实体EJB,它演示了：
 * 	EJBean管理的JDBC持续性管理和事务管理；
 *      在这个文件中的代码直接访问数据库；
 */
 //这个类是实体Bean,必须实现接口 EntityBean
public class AccountBean implements EntityBean {
//设置是否打印控制台
  final static private boolean VERBOSE = true;
//声明实体上下文变量
  private EntityContext ctx;
  private String accountId; // 这也是主键类
  private double balance;
  /**
   * 为EJBean设置实体EJB上下文
   * 
   * @参数 ctx               EntityContext 
   */
  public void setEntityContext(EntityContext ctx) {
    log("setEntityContext called");
    this.ctx = ctx;
  }

  /**
   * 取消实体上下文设置
   * 
   */
  public void unsetEntityContext() {
    log("unsetEntityContext (" + id() + ")");
    this.ctx = null;
  }
/**
   * 这是本类必须实现的方法，在本例中没有用到
   *
   */
  public void ejbActivate() {
    log("ejbActivate (" + id() + ")");
  }

  /**
   * 这是本类必须实现的方法，在本例中没有用到
   *
   */
  public void ejbPassivate() {
    log("ejbPassivate (" + id() + ")");
  }

  /**
   * 从数据库中加载EJB
   * 
   * @异常               javax.ejb.NoSuchEntityException
   *                          如果在数据库中没有找到Bean
   * @异常               javax.ejb.EJBException
   *                          通讯或系统错误
   */
  public void ejbLoad() {
    log("ejbLoad: (" + id() +  ")");
	//声明数据库连接对象
    Connection con = null;
    //声明SQL命令预处理对象
    PreparedStatement ps = null;
    //找到账号主键
    accountId = (String) ctx.getPrimaryKey();

    try {
    	//获取数据库连接
      con = getConnection();
      //设置SQL命令，读取记录
      ps  = con.prepareStatement("select bal from ejbAccounts where id = ?");
      //设置SQL命令
      ps.setString(1, accountId);
      //执行SQL
      ps.executeQuery();
      //获取SQL结果
      ResultSet rs = ps.getResultSet();
      if (rs.next()) {
      	//取得数据
        balance = rs.getDouble(1);
      } else {
        String error = "ejbLoad: AccountBean (" + accountId + ") not found";
        log(error);
        throw new NoSuchEntityException (error);
       }
    } catch (SQLException sqe) {
    	//数据库异常处理
      log("SQLException:  " + sqe);
      throw new EJBException(sqe);
    } finally {
      cleanup(con, ps);
    }
  }

  /**
   * 数据库中存入EJBean
   * 
   * @异常               javax.ejb.NoSuchEntityException
   *                          如果在数据库中没有找到Bean
   * @异常               javax.ejb.EJBException
   *                          通讯或系统错误
   */
  public void ejbStore() {
    log("ejbStore (" + id() + ")");
     //声明数据库连接对象
    Connection con = null;
    //声明SQL命令预处理对象
    PreparedStatement ps = null;

    try {
    	//获取数据库连接
      con = getConnection();
      //设置SQL命令,更新数据库
      ps = con.prepareStatement("update ejbAccounts set bal = ? where id = ?");
      //设置SQL命令
      ps.setDouble(1, balance);
      ps.setString(2, accountId);
       //执行SQL
      if (!(ps.executeUpdate() > 0)) {
        String error = "ejbStore: AccountBean (" + accountId + ") not updated";
        log(error);
        throw new NoSuchEntityException (error);
      }
    } catch(SQLException sqe) {
    	///数据库次操作异常处理
      log("SQLException:  " + sqe);
      throw new EJBException (sqe);
    } finally {
      cleanup(con, ps);
    }
  }


  /**
   * 这个方法和"AccountBean.java"中定义的的Bean的"ejbCreate"方法相对应
   * 这两个方法的参数应该相同。当客户端调用"TraderHome.create()"方法时，EJB容器
   * 会找到EJBean的实例，并调用它的"ejbCreate()"方法。
   * 对容器管理的ejb,ejbCreate方法返回为null，而bean管理的ejb，返回的是主键类。
   * @参数 accountID         String 账号ID
   * @参数 initialBalance    double 初始化结算值
   * @参数 type              String 账号类型
   * @异常               javax.ejb.CreateException
   *                          创建bean错误时抛出的异常
   */
  public String ejbCreate(String accountId, double initialBalance) 
    throws CreateException
  {
    //日志信息	
    log("AccountBean.ejbCreate( id = accountId" + ", " + "initial balance = $ " + initialBalance + ")");
    this.accountId = accountId;
    this.balance = initialBalance;
    //声明数据库连接
    Connection con = null;
    PreparedStatement ps = null;

    try {
      //获取数据库连接
      con = getConnection();
      //执行sql语句，插入记录
      ps = con.prepareStatement("insert into ejbAccounts (id, bal) values (?, ?)");
      ps.setString(1, accountId);
      ps.setDouble(2, balance);
      if (ps.executeUpdate() != 1) {
        String error = "JDBC did not create any row";
        log(error);
        throw new CreateException (error);
      }

      return accountId;
    } catch (SQLException sqe) {
    	//异常处理
      try {
      	//查找主键
        ejbFindByPrimaryKey(accountId);
      } catch(ObjectNotFoundException onfe) {
        String error = "SQLException: " + sqe;
        log(error);
        throw new CreateException (error);
      }
      String error = "An Account already exists in the database with Primary Key " + accountId;
      log(error);
      throw new DuplicateKeyException(error);
    } finally {
      cleanup(con, ps);
    }
  }

  /**
   * 这是本类必须实现的方法，在本例中没有用到   
   */
  public void ejbPostCreate(String accountId, double initialBalance) {
    log("ejbPostCreate (" + id() + ")");
  }

  /**
   * 从数据库中删除EJBean
   * 
   * @异常               javax.ejb.NoSuchEntityException
   *                          如果数据库中没找到这个ejb
   * @异常               javax.ejb.EJBException
   *                          通信错误抛出的异常
   */
  public void ejbRemove() {
    log("ejbRemove (" + id() + ")");
    //声明数据库连接
    Connection con = null;
    PreparedStatement ps = null;

    try {
    //获取连接	
      con = getConnection();
      //获取主键
      accountId = (String) ctx.getPrimaryKey();
      //执行SQL语句，删除记录
      ps = con.prepareStatement("delete from ejbAccounts where id = ?");
      ps.setString(1, accountId);
      if (!(ps.executeUpdate() > 0)) {
        String error = "AccountBean (" + accountId + " not found";
        log(error);
        throw new NoSuchEntityException (error);
      }
    } catch (SQLException sqe) {
    //异常处理
      log("SQLException:  " + sqe);
      throw new EJBException (sqe);
    } finally {
    //清除	
      cleanup(con, ps);
    }
  }

  /**
   * 给定主键查找EJBean
   * 
   * @参数 pk                String 主键
   * @返回                  String 主键
   * @异常               javax.ejb.ObjectNotFoundException
   *                          EJBean没发现抛出的异常
   * @异常               javax.ejb.EJBException
   *                          if there is a communications or systems failure
   */
  public String ejbFindByPrimaryKey(String pk)
    throws ObjectNotFoundException
  {
    log("ejbFindByPrimaryKey (" + pk + ")");
    //声明数据库连接
    Connection con = null;
    PreparedStatement ps = null;

    try {
    //获取连接	
      con = getConnection();
      //查询主键对应的记录
      ps  = con.prepareStatement("select bal from ejbAccounts where id = ?");
      ps.setString(1, pk);
      ps.executeQuery();
      //获取结果集
      ResultSet rs = ps.getResultSet();
      if (rs.next()) {
        balance = rs.getDouble(1);
      } else {
      //没有发现这个主键值的ejb
        String error = "ejbFindByPrimaryKey: AccountBean (" + pk + ") not found";
        log(error);
        //抛出异常
        throw new ObjectNotFoundException (error);
       }
    } catch (SQLException sqe) {
    //异常处理	
      log("SQLException:  " + sqe);
      throw new EJBException (sqe);
    } finally {
    //清除	
      cleanup(con, ps);
    }

    log("ejbFindByPrimaryKey (" + pk + ") found");
    return pk;
  }

  /**
   * 查找所有结算大于给定值的EJBeans
   * 返回主键枚举
   *
   * @参数 balanceGreaterThan double Test Amount
   * @返回                   主键枚举
   * @异常                javax.ejb.EJBException
   *                           通信错误抛出的异常
   */
  public Enumeration ejbFindBigAccounts(double balanceGreaterThan) {
    log("ejbFindBigAccounts (balance > " + balanceGreaterThan + ")");
    //声明数据库连接
    Connection con = null;
    PreparedStatement ps = null;

    try {
    //获取连接		
      con = getConnection();
      ps = con.prepareStatement("select id from ejbAccounts where bal > ?");
      ps.setDouble(1, balanceGreaterThan);
      ps.executeQuery();
      //获取结果集
      ResultSet rs = ps.getResultSet();
      Vector v = new Vector();
      String pk;
      while (rs.next()) {
        pk = rs.getString(1);
        v.addElement(pk);
      }
      //返回枚举
      return v.elements();
    } catch (SQLException sqe) {
    //异常处理
      log("SQLException: " + sqe);
      throw new EJBException (sqe);
    } finally {
    //清除
      cleanup(con, ps);
    }
  }

  /**
   * 存入一定数量
   *
   * @参数 amount            double Amount
   * @返回                  double 结算
   */
  public double deposit(double amount) {
    log("Depositing $" + amount + " into '" + accountId + "'");
    balance += amount;
    return balance;
  }

  /**
   * 提取
   *
   * @参数 amount            double 数量
   * @返回                  double 结算
   * @异常               ProcessingErrorException
   *                          如果数量大于结算
   */
  public double withdraw(double amount)
    throws ProcessingErrorException
  {
    log("Withdrawing $" + amount + " from '" + accountId + "'");
    if (amount > balance) {
      String error = "Request to withdraw $" + amount + 
        " more than balance " + balance + " in account " + accountId;
      log(error);
      throw new ProcessingErrorException(error);
    }

    balance -= amount;
    return balance;
  }

  /**
   * 返回当前结算值
   *
   * @返回                  double 结算
   */
  public double balance() {
    return balance;
  }

  /**
   * 从连接池中获取当前连接
   *
   * @返回                  连接
   * @异常               javax.ejb.EJBException
   *                          通信错误
   */
  private Connection getConnection()
    throws SQLException
  {
  //声明初始化上下文	
    InitialContext initCtx = null;
    try {
      initCtx = new InitialContext();
      //查找数据源
      DataSource ds = (javax.sql.DataSource)
        initCtx.lookup("java:comp/env/jdbc/demoPool");
      //返回数据源连接  
      return ds.getConnection();
    } catch(NamingException ne) {
    //有异常	
      log("UNABLE to get a connection from demoPool!");
      log("Please make sure that you have setup the connection pool properly");
      throw new EJBException(ne);
    } finally {
      try {
        if(initCtx != null) initCtx.close();
      } catch(NamingException ne) {
        log("Error closing context: " + ne);
        throw new EJBException(ne);
      }
    }
  }

  // 也可以使用WebLogic的日志服务
  private void log(String s) {
    if (VERBOSE) System.out.println(s);
  } 

  // 返回这个beans的id
  private String id() {
    return "PK = " + (String) ctx.getPrimaryKey();
  }
  //清除
  private void cleanup(Connection con, PreparedStatement ps) {
    try {
      if (ps != null) ps.close(); 
    } catch (Exception e) {
      log("Error closing PreparedStatement: "+e);
      throw new EJBException (e);
    }

    try {
      if (con != null) con.close(); 
    } catch (Exception e) {
      log("Error closing Connection: " + e);
      throw new EJBException (e);

    }
  }
}