package examples;
import javax.ejb.*;
/**
* Entity Bean which demonstrates Container-Managed persistence.
*
* This is a product that's persistent. It has an ID #, a name,
* a description, and a base price.
*/
public abstract class ProductBean implements EntityBean {
protected EntityContext ctx;
public ProductBean() {
}
//----------------------------------------------------------------
// Begin abstract get/set methods
//----------------------------------------------------------------
public abstract String getName();
public abstract void setName(String name);
public abstract String getDescription();
public abstract void setDescription(String description);
public abstract double getBasePrice();
public abstract void setBasePrice(double price);
public abstract String getProductID();
public abstract void setProductID(String productID);
//----------------------------------------------------------------
// End abstract get/set methods
//----------------------------------------------------------------
//----------------------------------------------------------------
// Begin EJB-required methods. The methods below are called
// by the Container, and never called by client code.
//----------------------------------------------------------------
/**
* Called by Container.
* Implementation can acquire needed resources.
*/
public void ejbActivate() {
System.out.println("ejbActivate() called.");
}
/**
* EJB Container calls this method right before it
* removes the Entity Bean from the database.
* Corresponds to when client calls home.remove().
*/
public void ejbRemove() {
System.out.println("ejbRemove() called.");
}
/**
* Called by Container.
* Releases held resources for passivation.
*/
public void ejbPassivate() {
System.out.println("ejbPassivate () called.");
}
/**
* Called from the Container. Updates the entity bean
* instance to reflect the current value stored in
* the database.
*
* Since we're using Container-Managed Persistence, we
* can leave this method blank. The EJB Container will
* automatically set our public fields to the correct values.
*/
public void ejbLoad() {
System.out.println("ejbLoad() called.");
}
/**
* Called from the Container. Updates the database to
* reflect the current values of this in-memory Entity Bean
* instance representation.
*
* Since we're using Container-Managed Persistence, we can
* leave this method blank. The EJB Container will
* automatically save our public fields into the database.
*/
public void ejbStore() {
System.out.println("ejbStore() called.");
}
/**
* Called by Container. Associates this Bean instance with
* a particular context. Once done, we can query the
* Context for environment info
*/
public void setEntityContext(EntityContext ctx) {
System.out.println("setEntityContext called");
this.ctx = ctx;
}
/**
* Called by Container. Disassociates this Bean instance
* with a particular context environment.
*/
public void unsetEntityContext() {
System.out.println("unsetEntityContext called");
this.ctx = null;
}
/**
* Called after ejbCreate(). Now, the Bean can retrieve
* its EJBObject from its context, and pass it as a 'this'
* argument.
*/
public void ejbPostCreate(String productID, String name, String description, double basePrice) {
System.out.println("ejbPostCreate() called");
}
/**
* This is the initialization method that corresponds to the
* create() method in the Home Interface.
*
* When the client calls the Home Object's create() method,
* the Home Object then calls this ejbCreate() method.
*
* NOTE: Since we're using Container-Managed persistence,
* this method returns void. With Bean-Managed Persistence,
* we returned the PK. This is because our Bean was
* responsible for dealing with PKs and accessing
* the database. Now that we let the Container handle
* persistence, the Container makes the Primary Key.
*
* We still need to initialize our Bean's fields with the
* parameters passed from the client, so that the Container
* can inspect our Bean and create the corresponding database
* entries.
*/
public String ejbCreate(String productID, String name, String description, double basePrice) {
System.out.println("ejbCreate() called");
setProductID(productID);
setName(name);
setDescription(description);
setBasePrice(basePrice);
return productID;
}
// No finder methods - they are implemented by Container
//----------------------------------------------------------------
// End EJB-required methods
//----------------------------------------------------------------
}