registerbean.java

21天精通Java,这是一本英文书

package agency;

import java.rmi.*;
import java.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.* ;
import javax.sql.*;
import javax.transaction.* ;

import data.*;

public class RegisterBean implements SessionBean
{
	private ApplicantLocalHome applicantHome;
	private SkillLocalHome skillHome;
	private LocationLocalHome locationHome;

	private ApplicantLocal applicant;

	public void updateDetails (String name, String email, String locationName, String summary, String[] skillNames) {

		int initialTranStatus = beginTransactionIfRequired();

        if (skillNames == null) {
            skillNames = new String[0];
        }
        List skillList;
        try {
            skillList = skillHome.lookup(Arrays.asList(skillNames));
        } catch(FinderException ex) {
            error("Invalid skill", ex); // throws an exception
            return;
        }

        LocationLocal location = null;
		if (locationName != null) {
	        try {
	            location = locationHome.findByPrimaryKey(locationName);
	        } catch(FinderException ex) {
	            error("Invalid location", ex); // throws an exception
	            return;
	        }
		}

        applicant.setName(name);
		applicant.setEmail(email);
		applicant.setLocation(location);
		applicant.setSummary(summary);
		applicant.setSkills( skillList );

		completeTransactionIfRequired(initialTranStatus);
	}

	public String getLogin() {
		int initialTranStatus = beginTransactionIfRequired();

        String login = applicant.getLogin();

		completeTransactionIfRequired(initialTranStatus);
        return login;
	}

	public String getName() {
		int initialTranStatus = beginTransactionIfRequired();

        String name = applicant.getName();

		completeTransactionIfRequired(initialTranStatus);
        return name;
	}

	public String getEmail() {
		int initialTranStatus = beginTransactionIfRequired();

		String email = applicant.getEmail();

		completeTransactionIfRequired(initialTranStatus);
        return email;
	}

	public String getLocation() {
		int initialTranStatus = beginTransactionIfRequired();

        LocationLocal location = applicant.getLocation();
		String locationName = (location!=null)?location.getName():null;

		completeTransactionIfRequired(initialTranStatus);
        return locationName;
	}

	public String getSummary() {
		int initialTranStatus = beginTransactionIfRequired();

		String summary = applicant.getSummary();

		completeTransactionIfRequired(initialTranStatus);
        return summary;
	}

	public String[] getSkills() {
		int initialTranStatus = beginTransactionIfRequired();

		Collection col = applicant.getSkills();
		String[] res = new String[col.size()];
		int i = 0;
		for(Iterator iter = col.iterator(); iter.hasNext(); ) {
			Object o = iter.next();
			SkillLocal skill = (SkillLocal)o;
			res[i++] = skill.getName();
		}

		completeTransactionIfRequired(initialTranStatus);
		return res;
	}

	private void error (String msg, Exception ex) {
		String s = "RegisterBean: "+msg + "\n" + ex;
		System.out.println(s);
		throw new EJBException(s,ex);
	}

	// EJB methods start here

	public void ejbCreate (String login) throws CreateException {
		try {
			applicant = applicantHome.findByPrimaryKey(login);
		}
		catch (FinderException ex) {
			error ("Cannot find applicant: "+login,ex);
		}
	}

	public void ejbActivate(){
	}

	public void ejbPassivate(){
	}

	public void ejbRemove(){
		applicant = null;
		applicantHome = null;
	}

	private SessionContext ctx;

	public void setSessionContext(SessionContext ctx) {
		this.ctx = ctx;
		InitialContext ic = null;
		try {
			ic = new InitialContext();
			applicantHome = (ApplicantLocalHome)ic.lookup("java:comp/env/ejb/ApplicantLocal");
			skillHome = (SkillLocalHome)ic.lookup("java:comp/env/ejb/SkillLocal");
			locationHome = (LocationLocalHome)ic.lookup("java:comp/env/ejb/LocationLocal");
		}
		catch (NamingException ex) {
			error("Error looking up depended EJB or resource",ex);
		}
	}

	// transaction management helper methods

	private String statusAsString(int status) {
		switch(status) {
        case Status.STATUS_ACTIVE:
			return "STATUS_ACTIVE";
		case Status.STATUS_NO_TRANSACTION:
			return "STATUS_NO_TRANSACTION";
		case Status.STATUS_UNKNOWN:
			return "STATUS_UNKNOWN";
		case Status.STATUS_COMMITTING:
			return "STATUS_COMMITTING";
		case Status.STATUS_MARKED_ROLLBACK:
			return "STATUS_MARKED_ROLLBACK";
		case Status.STATUS_PREPARED:
			return "STATUS_PREPARED";
		case Status.STATUS_PREPARING:
			return "STATUS_PREPARING";
		case Status.STATUS_ROLLING_BACK:
			return "STATUS_ROLLING_BACK";
		case Status.STATUS_COMMITTED:
			return "STATUS_COMMITTED";
		case Status.STATUS_ROLLEDBACK:
			return "STATUS_ROLLEDBACK";
        default:
            return "unknown STATUS (" + status +")";
        }
    }

	private int beginTransactionIfRequired() {

		UserTransaction tran = this.ctx.getUserTransaction();
		// start a new transaction if needed, else just use existing.
        // (simulates trans-attribute of REQUIRED)
        int initialTranStatus;
        try {
	        initialTranStatus = tran.getStatus();
	        switch(initialTranStatus) {
	        case Status.STATUS_ACTIVE:
	            // just use
	            break;
			case Status.STATUS_NO_TRANSACTION:
	            // create
		        try {
			        tran.begin();
		        } catch(NotSupportedException ex) {
		            // shouldn't happen (only thrown if asking for nested exception
	                // and is not supported by the resource manager; not attempting
	                // to do this here).
	                throw new EJBException("Unable to begin transaction", ex);
		        }
	        	break;
			case Status.STATUS_COMMITTING:
			case Status.STATUS_PREPARED:
			case Status.STATUS_PREPARING:
			case Status.STATUS_ROLLING_BACK:
	            throw new EJBException(
	                	"Transaction in progress of completing, status = " +
	                	statusAsString(initialTranStatus));
			case Status.STATUS_MARKED_ROLLBACK:
	            throw new EJBException(
	                	"Transaction marked for rollback, can't be used.");
			case Status.STATUS_COMMITTED:
			case Status.STATUS_ROLLEDBACK:
		         // heuristics probably exist, otherwise status would have returned
	             // NO_TRANSACTION
	            throw new EJBException(
	                	"Current transaction completed, heuristics probably exist; status = " +
	                	statusAsString(initialTranStatus));
			case Status.STATUS_UNKNOWN:
	            // transient condition, shouldn't occur
	        	throw new EJBException("Transaction status unknown, retry.");
	        default:
	        	throw new EJBException(
	            "Transaction status invalid, status = " + statusAsString(initialTranStatus));
			}
        } catch(SystemException ex) {
            throw new EJBException("Unable to begin transaction", ex);
        }

        return initialTranStatus;
    }

	/**
    * expects initialTranStatus to be either STATUS_NO_TRANSACTION or STATUS_ACTIVE;
    * semantics undefined otherwise
    */
	private void completeTransactionIfRequired(int initialTranStatus) {

		UserTransaction tran = this.ctx.getUserTransaction();

		// if transaction was started, then commit / rollback as needed.
        // (simulates trans-attribute of REQUIRED)
		if (initialTranStatus == Status.STATUS_NO_TRANSACTION) {
	        try {
	            if (tran.getStatus() == Status.STATUS_MARKED_ROLLBACK) {
	                tran.rollback();
	            } else {
	                tran.commit();
                }
            } catch(Exception ex) {
                throw new EJBException("Unable to complete transaction", ex);
            }
        }
    }

}