Java 如何在JSP中调用EJB3会话bean？

我正在使用EJB和JPA在Eclipse中开发一个应用程序

我的会话bean是：

    package itso.bank.session;

import itso.bank.entities.Account;
import itso.bank.entities.Customer;
import itso.bank.entities.Transaction;
import itso.bank.exception.ITSOBankException;
import itso.bank.service.EJBBankService;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.List;

import javax.ejb.Stateless;
import javax.persistence.*;

/**
 * Session Bean implementation class EJBBankBean
 */
@Stateless
public class EJBBankBean implements EJBBankService {

    @PersistenceContext (unitName="RAD8JPA", type=PersistenceContextType.TRANSACTION)
    private EntityManager entityMgr;
    /**
     * Default constructor. 
     */
    public EJBBankBean() {
        // TODO Auto-generated constructor stub
    }

    public void addCustomer(Customer customer) throws ITSOBankException {
        System.out.println("addCustomer: " + customer.getSsn());
        entityMgr.persist(customer);
    }

    public void closeAccount(String ssn, String id) throws ITSOBankException {
        System.out.println("closeAccount: " + id + " of customer " + ssn);

        Account account = getAccount(id);
        Transaction[] trans = getTransactions(id);
        for (Transaction tx : trans) {
            entityMgr.remove(tx);
        }
        entityMgr.remove(account);
        System.out.println("closed account with " + trans.length + " transactions");
    }

    public void deleteCustomer(String ssn) throws ITSOBankException {
        System.out.println("deleteCustomer: " + ssn);
        Customer customer = getCustomer(ssn);
        Account[] accounts = getAccounts(ssn);
        for (Account acct : accounts) {
            closeAccount(ssn, acct.getId());
        }
        entityMgr.remove(customer);
    }

    public void deposit(String id, BigDecimal amount) throws ITSOBankException {
        System.out.println("deposit: " + id + " amount " + amount);
        Account account = getAccount(id);
        try {
            Transaction tx = account.processTransaction(amount, Transaction.CREDIT);
            entityMgr.persist(tx);
        } catch (Exception e) {
            throw new ITSOBankException(e.getMessage());    
        }
    }

    public Account getAccount(String id) throws ITSOBankException {
        System.out.println("getAccount: " + id);
        try {
            return entityMgr.find(Account.class, id);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            throw new ITSOBankException(id);
        }
    }

    public Account[] getAccounts(String ssn) throws ITSOBankException {
        System.out.println("getAccounts: " + ssn);
        Query query = null;
        try {
            query = entityMgr.createNamedQuery("getAccountsBySSN"); 
            query.setParameter(1, ssn);
            List<Account> accountList = query.getResultList();
            Account[] array = new Account[accountList.size()];
            return accountList.toArray(array);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            throw new ITSOBankException(ssn);
        }
    }

    public Customer getCustomer(String ssn) throws ITSOBankException {
        System.out.println("getCustomer: " + ssn);
        //Query query = null;
        try {
            //query = entityMgr.createNamedQuery("getCustomerBySSN");   
            //query.setParameter(1, ssn);
            //return (Customer)query.getSingleResult();
            return entityMgr.find(Customer.class, ssn);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            throw new ITSOBankException(ssn);
        }
    }

    public Customer[] getCustomers(String partialName) throws ITSOBankException {
        System.out.println("getCustomer: " + partialName);
        Query query = null;
        try {
            query = entityMgr.createNamedQuery("getCustomersByPartialName");
            query.setParameter(1, partialName);
            List<Customer> beanlist = query.getResultList();
            Customer[] array = new Customer[beanlist.size()];
            return beanlist.toArray(array);
        } catch (Exception e) {
            throw new ITSOBankException(partialName);
        } 
    }

    public Customer[] getCustomersAll() {
        System.out.println("getCustomers: all");
        Query query = null;
        try {
            query = entityMgr.createNamedQuery("getCustomers"); 
            List<Customer> beanlist = query.getResultList();
            Customer[] array = new Customer[beanlist.size()];
            return beanlist.toArray(array);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            return null;
        }
    }

    public Transaction[] getTransactions(String accountID) throws ITSOBankException {
        System.out.println("getTransactions: " + accountID);
        Query query = null;
        try {
            query = entityMgr.createNamedQuery("getTransactionsByID");  
            query.setParameter(1, accountID);
            List<Transaction> transactionsList = query.getResultList();
            Transaction[] array = new Transaction[transactionsList.size()];
            return transactionsList.toArray(array);
        } catch (Exception e) {
            System.out.println("Exception: " + e.getMessage());
            e.printStackTrace();
            throw new ITSOBankException(accountID);
        }
    }

    public String openAccount(String ssn) throws ITSOBankException {
        System.out.println("openAccount: " + ssn);
        Customer customer = getCustomer(ssn);
        int acctNumber = (new java.util.Random()).nextInt(899999) + 100000;
        String id = "00" + ssn.substring(0, 1) + "-" + acctNumber;
        Account account = new Account();
        account.setId(id);
        entityMgr.persist(account);

        List<Customer> custSet = Arrays.asList(customer);
        account.setCustomers(custSet);
        System.out.println("openAccount: " + id);
        return id;
    }

    public void transfer(String idDebit, String idCredit, BigDecimal amount) throws ITSOBankException {
        System.out.println("transfer: " + idCredit + " " + idDebit + " amount " + amount);
        withdraw(idDebit, amount);
        deposit(idCredit, amount);
    }

    public void updateCustomer(String ssn, String title, String firstName, String lastName) throws ITSOBankException {
        System.out.println("updateCustomer: " + ssn);
        Customer customer = getCustomer(ssn);
        customer.setTitle(title);
        customer.setLastName(lastName);
        customer.setFirstName(firstName);
        System.out.println("updateCustomer: " + customer.getTitle() + " " + customer.getFirstName() + " " + customer.getLastName());
    }

    public void withdraw(String id, BigDecimal amount) throws ITSOBankException {
        System.out.println("withdraw: " + id + " amount " + amount);
        Account account = getAccount(id);
        try {
            Transaction tx = account.processTransaction(amount, Transaction.DEBIT);
            entityMgr.persist(tx);
        } catch (Exception e) {
            throw new ITSOBankException(e.getMessage());    
        }
    }


}

包itso.bank.session；
导入itso.bank.entities.Account；
导入itso.bank.entities.Customer；
导入itso.bank.entities.Transaction；
导入itso.bank.exception.itsobankeexception；
导入itso.bank.service.EJBBankService；
导入java.math.BigDecimal；
导入java.util.array；
导入java.util.List；
导入javax.ejb.Stateless；
导入javax.persistence.*；
/**
*会话Bean实现类EJBBankBean
*/
@无国籍
公共类EJBBankBean实现EJBBankService{
@PersistenceContext（unitName=“RAD8JPA”，type=PersistenceContextType.TRANSACTION）
私人实体管理者实体GR；
/**
*默认构造函数。
*/
公共EJBBankBean（）{
//TODO自动生成的构造函数存根
}
public void addCustomer（Customer-Customer）抛出其异常{
System.out.println（“addCustomer:+customer.getSsn（））；
entityMgr.persist（客户）；
}
public void closeAccount（字符串ssn，字符串id）引发ITSOBankException{
系统输出打印项次（“结账账户：+id+”客户“+ssn）；
Account=getAccount（id）；
事务[]trans=getTransactions（id）；
用于（事务发送：trans）{
整体移除（tx）；
}
entityMgr.remove（账户）；
System.out.println（“具有“+trans.length+”交易的封闭账户”）；
}
public void deleteCustomer（字符串ssn）引发ITSOBankException{
System.out.println（“删除客户：+ssn”）；
客户=getCustomer（ssn）；
账户[]账户=获取账户（ssn）；
对于（科目：科目）{
closeAccount（ssn，acct.getId（））；
}
entityMgr.移除（客户）；
}
公共无效存款（字符串id，BigDecimal金额）抛出其SobankException{
系统输出打印项次（“存款：+id+“金额”+金额）；
Account=getAccount（id）；
试一试{
交易记录tx=账户.processTransaction（金额，交易记录.信用）；
实体持久性（tx）；
}捕获（例外e）{
抛出新的ITSOBankException（例如getMessage（））；
}
}
公共帐户getAccount（字符串id）引发其异常{
System.out.println（“getAccount:+id”）；
试一试{
返回entityMgr.find（Account.class，id）；
}捕获（例外e）{
System.out.println（“异常：+e.getMessage（））；
抛出新的ITSOBankException（id）；
}
}
公共帐户[]getAccounts（字符串ssn）引发其异常{
System.out.println（“getAccounts:+ssn”）；
Query=null；
试一试{
query=entityMgr.createNamedQuery（“getAccountsBySSN”）；
query.setParameter（1，ssn）；
List accountList=query.getResultList（）；
Account[]数组=新帐户[accountList.size（）]；
返回accountList.toArray（数组）；
}捕获（例外e）{
System.out.println（“异常：+e.getMessage（））；
抛出新的ITSOBankException（ssn）；
}
}
公共客户getCustomer（字符串ssn）抛出其SobankException{
System.out.println（“getCustomer:+ssn”）；
//Query=null；
试一试{
//query=entityMgr.createNamedQuery（“GetCustomerBySN”）；
//query.setParameter（1，ssn）；
//return（Customer）query.getSingleResult（）；
返回entityMgr.find（Customer.class，ssn）；
}捕获（例外e）{
System.out.println（“异常：+e.getMessage（））；
抛出新的ITSOBankException（ssn）；
}
}
公共客户[]getCustomers（字符串partialName）抛出其ObankException{
System.out.println（“getCustomer:+partialName”）；
Query=null；
试一试{
query=entityMgr.createNamedQuery（“GetCustomerByPartialName”）；
query.setParameter（1，partialName）；
List beanlist=query.getResultList（）；
Customer[]数组=新客户[beanlist.size（）]；
返回beanlist.toArray（数组）；
}捕获（例外e）{
抛出新的ITSOBankException（partialName）；
} 
}
公共客户[]GetCustomerAll（）{
System.out.println（“getCustomers:all”）；
Query=null；
试一试{
query=entityMgr.createNamedQuery（“getCustomers”）；
List beanlist=query.getResultList（）；
Customer[]数组=新客户[beanlist.size（）]；
返回beanlist.toArray（数组）；
}捕获（例外e）{
System.out.println（“异常：+e.getMessage（））；
返回null；
}
}
公共事务[]getTransactions（字符串accountID）引发其ObankException{
System.out.println（“getTransactions:+accountID”）；
Query=null；
试一试{
query=entityMgr.createNamedQuery（“getTransactionsByID”）；
query.setParameter（1，accountID）；
List TransactionList=query.getResultList（）；
事务[]数组=新事务[TransactionList.size（）]；
返回TransactionList.toArray（数组）；
}捕获（例外e）{
System.out.println（“异常：+e.getMessage（））；
e、 printStackTrace（）；
抛出新的ITSOBankException（accountID）；
}
}
公共字符串openAccount（字符串ssn）引发其异常{
System.out.println（“openAccount:+ssn”）；
客户=getCustomer（ssn）；
int acctNumber=（new java.util.Random（））.nextInt（899999）+100000；
字符串id=“00”+ssn.子字符串（0，1）+“-”+账号；
账户=新账户（）；
帐户设置id（id）；
entityMgr.persist（账户）；
List custSet=Arrays.asList（cu
<ejb-local-ref>
    <ejb-ref-name>MyBeanName</ejb-ref-name>
    <ejb-ref-type>Session</ejb-ref-type>
    <local>com.myapp.ejb.MyBeanLocal</local>
</ejb-local-ref>

<%
String lookupUrl = "java:comp/env/MyBeanName";
Context ctx = new javax.naming.InitialContext();
MyBeanNameLocal ejbLocal = (MyBeanNameLocal) ctx.lookup(lookupUrl);

String output = ejbLocal.myBusinessMethod();
%>

@Stateless
@Named("eJBBankBean")
public class EJBBankBean implements EJBBankService {....}