User: dsundstrom
Date: 01/06/23 20:23:15
Added: src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge
JDBCCMP1xFieldBridge.java JDBCCMP2xFieldBridge.java
JDBCCMPFieldBridge.java JDBCCMRFieldBridge.java
JDBCEntityBridge.java JDBCSelectorBridge.java
Log:
Initial revision of EJB 2.0 CMP.
Revision Changes Path
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCCMP1xFieldBridge.java
Index: JDBCCMP1xFieldBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
import java.lang.reflect.Field;
import java.util.Map;
import javax.ejb.EJBException;
import org.jboss.ejb.DeploymentException;
import org.jboss.ejb.EntityEnterpriseContext;
import org.jboss.ejb.plugins.cmp.CMPStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldMetaData;
import org.jboss.logging.Log;
/**
* JDBCCMP1xFieldBridge is a concrete implementation of JDBCCMPFieldBridge for
* CMP version 1.x. Getting and setting of instance fields set the
* corresponding field in bean instance. Dirty checking is performed by
* storing the current value in the entity persistence context when ever
* setClean is called, and comparing current value to the original value.
*
* Life-cycle:
* Tied to the EntityBridge.
*
* Multiplicity:
* One for each entity bean cmp field.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
public class JDBCCMP1xFieldBridge extends JDBCCMPFieldBridge {
protected Field field;
public JDBCCMP1xFieldBridge(JDBCStoreManager manager, JDBCCMPFieldMetaData
metadata, Log log) throws DeploymentException {
super(manager, metadata, log);
try {
field =
metadata.getJDBCEntity().getEntityClass().getField(getFieldName());
} catch(NoSuchFieldException e) {
// Non recoverable internal exception
throw new DeploymentException("No field named '" +
getFieldName() + "' found in entity class.");
}
}
public Object getInstanceValue(EntityEnterpriseContext ctx) {
try {
return field.get(ctx.getInstance());
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error getting instance field
" + getFieldName() + ": " + e);
}
}
public void setInstanceValue(EntityEnterpriseContext ctx, Object value) {
try {
field.set(ctx.getInstance(), value);
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error setting instance field
" + getFieldName() + ": " + e);
}
}
/**
* Has the value of this field changes since the last time clean was called.
*/
public boolean isDirty(EntityEnterpriseContext ctx) {
// read only and primary key fields are never dirty
if(isReadOnly() || isPrimaryKeyMember()) {
return false;
}
// has the value changes since setClean
return changed(getInstanceValue(ctx),
getFieldState(ctx).originalValue);
}
/**
* Mark this field as clean.
* Saves the current state in context, so it can be compared when isDirty is
called.
*/
public void setClean(EntityEnterpriseContext ctx) {
FieldState fieldState = getFieldState(ctx);
fieldState.originalValue = getInstanceValue(ctx);
// update last read time
if(isReadOnly()) {
fieldState.lastRead = System.currentTimeMillis();
}
}
public boolean isReadTimedOut(EntityEnterpriseContext ctx) {
if(isReadOnly()) {
long readInterval = System.currentTimeMillis() -
getFieldState(ctx).lastRead;
return readInterval > metadata.getReadTimeOut();
}
// if we are read/write then we are always timed out
return true;
}
public void resetPersistenceContext(EntityEnterpriseContext ctx) {
if(isReadTimedOut(ctx)) {
Map fieldStates =
((CMPStoreManager.PersistenceContext)ctx.getPersistenceContext()).fieldState;
fieldStates.put(this, new FieldState());
}
}
private FieldState getFieldState(EntityEnterpriseContext ctx) {
Map fieldStates =
((CMPStoreManager.PersistenceContext)ctx.getPersistenceContext()).fieldState;
FieldState fieldState = (FieldState)fieldStates.get(this);
if(fieldState == null) {
fieldState = new FieldState();
fieldStates.put(this, fieldState);
}
return fieldState;
}
private static class FieldState {
Object originalValue;
long lastRead = -1;
}
}
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCCMP2xFieldBridge.java
Index: JDBCCMP2xFieldBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
import java.util.Map;
import javax.ejb.EJBException;
import org.jboss.ejb.DeploymentException;
import org.jboss.ejb.EntityEnterpriseContext;
import org.jboss.ejb.plugins.cmp.CMPStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldMetaData;
import org.jboss.logging.Log;
/**
* JDBCCMP2xFieldBridge is a concrete implementation of JDBCCMPFieldBridge for
* CMP version 2.x. Instance data is stored in the entity persistence context.
* When every a field is changed it is compared to the current value and sets
* a dirty flag if the value has changed.
*
* Life-cycle:
* Tied to the EntityBridge.
*
* Multiplicity:
* One for each entity bean cmp field.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
public class JDBCCMP2xFieldBridge extends JDBCCMPFieldBridge {
public JDBCCMP2xFieldBridge(JDBCStoreManager manager, JDBCCMPFieldMetaData
metadata, Log log) throws DeploymentException {
super(manager, metadata, log);
}
public Object getInstanceValue(EntityEnterpriseContext ctx) {
FieldState fieldState = getFieldState(ctx);
if(!fieldState.isLoaded) {
manager.loadField(this, ctx);
if(!fieldState.isLoaded) {
throw new EJBException("Could not load field value: "
+ getFieldName());
}
}
return fieldState.value;
}
public void setInstanceValue(EntityEnterpriseContext ctx, Object value) {
FieldState fieldState = getFieldState(ctx);
// short-circuit to avoid repetive comparisons
// if it is not currently loaded or it is already dirty or if it has
changed
fieldState.isDirty = !fieldState.isLoaded || fieldState.isDirty ||
changed(fieldState.value, value);
// we are loading the field right now so it isLoaded
fieldState.isLoaded = true;
// update current value
fieldState.value = value;
}
/**
* Has the value of this field changes since the last time clean was called.
*/
public boolean isDirty(EntityEnterpriseContext ctx) {
// read only and primary key fields are never dirty
if(isReadOnly() || isPrimaryKeyMember()) {
return false;
}
return getFieldState(ctx).isDirty;
}
/**
* Mark this field as clean.
* Saves the current state in context, so it can be compared when isDirty is
called.
*/
public void setClean(EntityEnterpriseContext ctx) {
FieldState fieldState = getFieldState(ctx);
fieldState.isDirty = false;
// update last read time
if(isReadOnly()) {
fieldState.lastRead = System.currentTimeMillis();
}
}
public void resetPersistenceContext(EntityEnterpriseContext ctx) {
if(isReadTimedOut(ctx)) {
Map fieldStates =
((CMPStoreManager.PersistenceContext)ctx.getPersistenceContext()).fieldState;
fieldStates.put(this, new FieldState());
}
}
public boolean isReadTimedOut(EntityEnterpriseContext ctx) {
if(isReadOnly()) {
long readInterval = System.currentTimeMillis() -
getFieldState(ctx).lastRead;
return readInterval > metadata.getReadTimeOut();
}
// if we are read/write then we are always timed out
return true;
}
private FieldState getFieldState(EntityEnterpriseContext ctx) {
Map fieldStates =
((CMPStoreManager.PersistenceContext)ctx.getPersistenceContext()).fieldState;
FieldState fieldState = (FieldState)fieldStates.get(this);
if(fieldState == null) {
fieldState = new FieldState();
fieldStates.put(this, fieldState);
}
return fieldState;
}
private static class FieldState {
Object value;
boolean isLoaded = false;
boolean isDirty = false;
long lastRead = -1;
}
}
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCCMPFieldBridge.java
Index: JDBCCMPFieldBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
import java.lang.reflect.Field;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.ejb.EJBException;
import org.jboss.ejb.DeploymentException;
import org.jboss.ejb.EntityEnterpriseContext;
import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldMetaData;
import org.jboss.ejb.plugins.cmp.bridge.CMPFieldBridge;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCType;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCUtil;
import org.jboss.logging.Log;
/**
* JDBCCMPFieldBridge represents one CMP field. This class handles setting
* statement parameters and loading results for instance values and primary
* keys. Most of the heavy lifting of this command is handled by JDBCUtil.
* It is left to subclasses to implement the logic for getting and setting
* instance values and dirty checking, as this is dependent on the CMP
* version used.
*
* Life-cycle:
* Tied to the EntityBridge.
*
* Multiplicity:
* One for each entity bean cmp field.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
public abstract class JDBCCMPFieldBridge implements CMPFieldBridge {
protected JDBCStoreManager manager;
protected JDBCCMPFieldMetaData metadata;
protected JDBCType jdbcType;
protected Log log;
public JDBCCMPFieldBridge(JDBCStoreManager manager, JDBCCMPFieldMetaData
metadata, Log log) throws DeploymentException {
this.manager = manager;
this.metadata = metadata;
this.log = log;
jdbcType = manager.getJDBCTypeFactory().getFieldJDBCType(metadata);
}
public JDBCCMPFieldMetaData getMetaData() {
return metadata;
}
public String getFieldName() {
return metadata.getFieldName();
}
public Class getFieldType() {
return metadata.getFieldType();
}
public boolean isReadOnly() {
return metadata.isReadOnly();
}
public abstract boolean isReadTimedOut(EntityEnterpriseContext ctx);
public boolean isPrimaryKeyMember() {
return metadata.isPrimaryKeyMember();
}
public Object getPrimaryKeyValue(Object primaryKey) throws
IllegalArgumentException {
if(!isPrimaryKeyMember()) {
throw new IllegalArgumentException(getFieldName() + " is not a
member of the primary key.");
}
try {
if(metadata.getPrimaryKeyField() != null) {
// Extract this field's value from the primary key.
return metadata.getPrimaryKeyField().get(primaryKey);
} else {
// This field is the primary key, so no extraction is
necessary.
return primaryKey;
}
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error getting primary key
field member " + getFieldName() + ": " + e);
}
}
public Object setPrimaryKeyValue(Object primaryKey, Object value) throws
IllegalArgumentException {
if(!isPrimaryKeyMember()) {
throw new IllegalArgumentException(getFieldName() + " is not a
member of the primary key.");
}
try {
if(metadata.getPrimaryKeyField() != null) {
// Extract this field's value from the primary key.
metadata.getPrimaryKeyField().set(primaryKey, value);
return primaryKey;
} else {
// This field is the primary key, so no extraction is
necessary.
return value;
}
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error setting instance field
" + getFieldName() + ": " + e);
}
}
public abstract void resetPersistenceContext(EntityEnterpriseContext ctx);
/**
* Set CMPFieldValue to Java default value (i.e., 0 or null).
*/
public void initInstance(EntityEnterpriseContext ctx) {
if(!isReadOnly()) {
Object value;
if(getFieldType().equals(boolean.class)) {
value = Boolean.FALSE;
} else if(getFieldType().equals(byte.class)) {
value = new Byte((byte)0);
} else if (getFieldType().equals(int.class)) {
value = new Integer(0);
} else if (getFieldType().equals(long.class)) {
value = new Long(0L);
} else if (getFieldType().equals(short.class)) {
value = new Short((short)0);
} else if (getFieldType().equals(char.class)) {
value = new Character('\u0000');
} else if (getFieldType().equals(double.class)) {
value = new Double(0d);
} else if (getFieldType().equals(float.class)) {
value = new Float(0f);
} else {
value = null;
}
setInstanceValue(ctx, value);
}
}
public JDBCType getJDBCType() {
return jdbcType;
}
public int setInstanceParameters(PreparedStatement ps, int parameterIndex,
EntityEnterpriseContext ctx) {
Object instanceValue = getInstanceValue(ctx);
return setArgumentParameters(ps, parameterIndex, instanceValue);
}
public int setPrimaryKeyParameters(PreparedStatement ps, int parameterIndex,
Object primaryKey) throws IllegalArgumentException {
if(!isPrimaryKeyMember()) {
throw new IllegalArgumentException(getFieldName() + " is not a
member of the primary key.");
}
Object primaryKeyValue = getPrimaryKeyValue(primaryKey);
return setArgumentParameters(ps, parameterIndex, primaryKeyValue);
}
public int setArgumentParameters(PreparedStatement ps, int parameterIndex,
Object arg) {
try {
int[] jdbcTypes = getJDBCType().getJDBCTypes();
for(int i=0; i<jdbcTypes.length; i++) {
Object columnValue = getJDBCType().getColumnValue(i,
arg);
JDBCUtil.setParameter(log, ps, parameterIndex++,
jdbcTypes[i], columnValue);
}
return parameterIndex;
} catch(SQLException e) {
// Non recoverable internal exception
throw new EJBException("Internal error setting parameters for
field " + getFieldName() + ": " + e);
}
}
public int loadInstanceResults(ResultSet rs, int parameterIndex,
EntityEnterpriseContext ctx) {
try {
Object value = getFieldType().newInstance();
Class[] javaTypes = getJDBCType().getJavaTypes();
for(int i=0; i<javaTypes.length; i++) {
Object columnValue = JDBCUtil.getResult(log, rs,
parameterIndex++, javaTypes[i]);
value = getJDBCType().setColumnValue(i, value,
columnValue);
}
setInstanceValue(ctx, value);
return parameterIndex;
} catch(EJBException e) {
// to avoid double wrap of EJBExceptions
throw e;
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error getting results for
field " + getFieldName() + ": " + e);
}
}
public int loadPrimaryKeyResults(ResultSet rs, int parameterIndex, Object[]
pkRef) throws IllegalArgumentException {
if(!isPrimaryKeyMember()) {
throw new IllegalArgumentException(getFieldName() + " is not a
member of the primary key.");
}
try {
// get this field's value object from the pk
Object value = this.getPrimaryKeyValue(pkRef[0]);
// update the value from the result set
Class[] javaTypes = getJDBCType().getJavaTypes();
for(int i=0; i<javaTypes.length; i++) {
Object columnValue = JDBCUtil.getResult(log, rs,
parameterIndex++, javaTypes[i]);
value = getJDBCType().setColumnValue(i, value,
columnValue);
}
// set the value back into the pk
pkRef[0] = setPrimaryKeyValue(pkRef[0], value);
return parameterIndex;
} catch(SQLException e) {
// Non recoverable internal exception
throw new EJBException("Internal error getting results for
primary key field member " + getFieldName() + ": " + e);
}
}
protected final boolean changed(Object current, Object old) {
return
(current == null && old != null) || // TRUE if I am null and
I wasn't before
(current != null && // TRUE if I was null and now
I'm not
( old == null || (!current.equals(old)) ) // TRUE if
i'm not equal to my oldstate
); // tied to last
check to assure that current is not null
}
}
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCCMRFieldBridge.java
Index: JDBCCMRFieldBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
import java.util.HashSet;
import org.jboss.ejb.plugins.cmp.bridge.CMRFieldBridge;
import org.jboss.ejb.EntityEnterpriseContext;
/**
* JDBCCMRFieldBridge a bean relationship.
*
* Life-cycle:
* Haven't decided yet.
*
* Multiplicity:
* Haven't decided yet. Will be either one per bean relationship role, or
* one per relationship (shared between two beans).
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
public class JDBCCMRFieldBridge implements CMRFieldBridge {
protected String fieldName;
protected Class fieldType;
public String getFieldName() {
return fieldName;
}
public Class getFieldType() {
return fieldType;
}
public Object getValue(EntityEnterpriseContext ctx) {
return new HashSet(0);
}
public void setValue(EntityEnterpriseContext ctx, Object value) {
}
}
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCEntityBridge.java
Index: JDBCEntityBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import javax.ejb.EJBException;
import org.jboss.ejb.DeploymentException;
import org.jboss.ejb.EntityEnterpriseContext;
import org.jboss.ejb.plugins.cmp.CMPStoreManager;
import org.jboss.ejb.plugins.cmp.jdbc.JDBCStoreManager;
import org.jboss.ejb.plugins.cmp.bridge.EntityBridge;
import org.jboss.ejb.plugins.cmp.bridge.EntityBridgeInvocationHandler;
import org.jboss.ejb.plugins.cmp.bridge.CMPFieldBridge;
import org.jboss.ejb.plugins.cmp.bridge.CMRFieldBridge;
import org.jboss.ejb.plugins.cmp.bridge.SelectorBridge;
import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCEntityMetaData;
import org.jboss.ejb.plugins.cmp.jdbc.metadata.JDBCCMPFieldMetaData;
import org.jboss.proxy.Proxies;
import org.jboss.proxy.InvocationHandler;
import org.jboss.logging.Log;
/**
* JDBCEntityBridge follows the Bridge pattern [Gamma et. al, 1995].
* The main job of this class is to construct the bridge from entity meta data.
*
* Life-cycle:
* Undefined. Should be tied to CMPStoreManager.
*
* Multiplicity:
* One per cmp entity bean type.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
public class JDBCEntityBridge implements EntityBridge {
protected JDBCEntityMetaData metadata;
protected JDBCStoreManager manager;
protected JDBCCMPFieldBridge[] cmpFields;
protected Map cmpFieldsByName;
protected JDBCCMPFieldBridge[] primaryKeyFields;
protected JDBCCMRFieldBridge[] cmrFields;
protected JDBCSelectorBridge[] selectors;
protected JDBCCMPFieldBridge[] eagerLoadFields;
protected ArrayList lazyLoadGroups;
protected Log log;
public JDBCEntityBridge(JDBCEntityMetaData metadata, Log log, JDBCStoreManager
manager) throws DeploymentException {
this.metadata = metadata;
this.log = log;
this.manager = manager;
loadCMPFields(metadata);
loadEagerLoadFields(metadata);
loadLazyLoadGroups(metadata);
loadCMRFields(metadata);
loadSelectors(metadata);
}
protected void loadCMPFields(JDBCEntityMetaData metadata) throws
DeploymentException {
// map between field names and field objects
cmpFieldsByName = new HashMap(metadata.getCMPFieldCount());
// non primary key cmp fields
ArrayList cmpFieldList = new ArrayList(metadata.getCMPFieldCount());
// primary key cmp fields
ArrayList pkFieldList = new ArrayList(metadata.getCMPFieldCount());
// create each field
Iterator iter = metadata.getCMPFields();
while(iter.hasNext()) {
JDBCCMPFieldMetaData cmpFieldMetaData =
(JDBCCMPFieldMetaData)iter.next();
JDBCCMPFieldBridge cmpField = createCMPField(metadata,
cmpFieldMetaData);
cmpFieldsByName.put(cmpField.getFieldName(), cmpField);
if(cmpField.isPrimaryKeyMember()) {
pkFieldList.add(cmpField);
} else {
cmpFieldList.add(cmpField);
}
}
// save the pk fields in the pk field array
primaryKeyFields = new JDBCCMPFieldBridge[pkFieldList.size()];
primaryKeyFields =
(JDBCCMPFieldBridge[])pkFieldList.toArray(primaryKeyFields);
// add the pk fields to the front of the cmp list, per guarantee above
cmpFieldList.addAll(0, pkFieldList);
// save the cmp fields in the cmp field array
cmpFields = new JDBCCMPFieldBridge[cmpFieldList.size()];
cmpFields = (JDBCCMPFieldBridge[])cmpFieldList.toArray(cmpFields);
}
protected void loadEagerLoadFields(JDBCEntityMetaData metadata) throws
DeploymentException {
ArrayList fields = new ArrayList(metadata.getCMPFieldCount());
Iterator iter = metadata.getEagerLoadFields();
while(iter.hasNext()) {
JDBCCMPFieldMetaData field = (JDBCCMPFieldMetaData)iter.next();
fields.add(getExistingCMPFieldByName(field.getFieldName()));
}
eagerLoadFields = new JDBCCMPFieldBridge[fields.size()];
eagerLoadFields =
(JDBCCMPFieldBridge[])fields.toArray(eagerLoadFields);
}
protected void loadLazyLoadGroups(JDBCEntityMetaData metadata) throws
DeploymentException {
lazyLoadGroups = new ArrayList();
Iterator groups = metadata.getLazyLoadGroups();
while(groups.hasNext()) {
ArrayList group = new ArrayList();
Iterator fields = ((ArrayList)groups.next()).iterator();
while(fields.hasNext()) {
JDBCCMPFieldMetaData field =
(JDBCCMPFieldMetaData)fields.next();
group.add(getExistingCMPFieldByName(field.getFieldName()));
}
lazyLoadGroups.add(group);
}
}
protected JDBCCMPFieldBridge createCMPField(JDBCEntityMetaData metadata,
JDBCCMPFieldMetaData cmpFieldMetaData)
throws DeploymentException {
if(metadata.isCMP1x()) {
return new JDBCCMP1xFieldBridge(manager, cmpFieldMetaData,
log);
} else {
return new JDBCCMP2xFieldBridge(manager, cmpFieldMetaData,
log);
}
}
protected void loadCMRFields(JDBCEntityMetaData metadata) {
cmrFields = new JDBCCMRFieldBridge[0];
}
protected void loadSelectors(JDBCEntityMetaData metadata) {
selectors = new JDBCSelectorBridge[0];
}
public String getEntityName() {
return metadata.getName();;
}
public JDBCEntityMetaData getMetaData() {
return metadata;
}
public Class getPrimaryKeyClass() {
return metadata.getPrimaryKeyClass();
}
public CMPFieldBridge[] getPrimaryKeyFields() {
return primaryKeyFields;
}
public JDBCCMPFieldBridge[] getJDBCPrimaryKeyFields() {
return primaryKeyFields;
}
public CMPFieldBridge[] getCMPFields() {
return cmpFields;
}
public JDBCCMPFieldBridge[] getEagerLoadFields() {
return eagerLoadFields;
}
public Iterator getLazyLoadGroups() {
return lazyLoadGroups.iterator();
}
public JDBCCMPFieldBridge[] getJDBCCMPFields() {
return cmpFields;
}
public JDBCCMPFieldBridge getCMPFieldByName(String name) {
return (JDBCCMPFieldBridge)cmpFieldsByName.get(name);
}
protected JDBCCMPFieldBridge getExistingCMPFieldByName(String name) throws
DeploymentException {
JDBCCMPFieldBridge cmpField = getCMPFieldByName(name);
if(cmpField == null) {
throw new DeploymentException("cmpField not found: " + name);
}
return cmpField;
}
public CMRFieldBridge[] getCMRFields() {
return cmrFields;
}
public JDBCCMRFieldBridge[] getJDBCCMRFields() {
return cmrFields;
}
public SelectorBridge[] getSelectors() {
return selectors;
}
public JDBCSelectorBridge[] getJDBCSelectors() {
return selectors;
}
public void initInstance(EntityEnterpriseContext ctx) {
for(int i=0; i<cmpFields.length; i++) {
cmpFields[i].initInstance(ctx);
}
}
public void setClean(EntityEnterpriseContext ctx) {
for(int i=0; i<cmpFields.length; i++) {
cmpFields[i].setClean(ctx);
}
}
public CMPFieldBridge[] getDirtyFields(EntityEnterpriseContext ctx) {
ArrayList dirtyFields = new ArrayList(cmpFields.length);
for(int i=0; i<cmpFields.length; i++) {
if(cmpFields[i].isDirty(ctx)) {
dirtyFields.add(cmpFields[i]);
}
}
JDBCCMPFieldBridge[] dirtyFieldArray = new
JDBCCMPFieldBridge[dirtyFields.size()];
return (JDBCCMPFieldBridge[])dirtyFields.toArray(dirtyFieldArray);
}
public void initPersistenceContext(EntityEnterpriseContext ctx) {
log.debug("Initializing persistence context id="+ctx.getId());
// If we have an EJB 2.0 dynaymic proxy,
// notify the handler of the assigned context.
Object instance = ctx.getInstance();
if(instance instanceof Proxies.ProxyTarget) {
InvocationHandler handler =
((Proxies.ProxyTarget)instance).getInvocationHandler();
if(handler instanceof EntityBridgeInvocationHandler) {
((EntityBridgeInvocationHandler)handler).setContext(ctx);
}
}
ctx.setPersistenceContext(new CMPStoreManager.PersistenceContext());
}
/**
* This is only called in commit option B
*/
public void resetPersistenceContext(EntityEnterpriseContext ctx) {
log.debug("Reseting persistence context id="+ctx.getId());
for(int i=0; i<cmpFields.length; i++) {
cmpFields[i].resetPersistenceContext(ctx);
}
}
public void destroyPersistenceContext(EntityEnterpriseContext ctx) {
log.debug("Destroying persistence context id="+ctx.getId());
// If we have an EJB 2.0 dynaymic proxy,
// notify the handler of the assigned context.
Object instance = ctx.getInstance();
if(instance instanceof Proxies.ProxyTarget) {
InvocationHandler handler =
((Proxies.ProxyTarget)instance).getInvocationHandler();
if(handler instanceof EntityBridgeInvocationHandler) {
((EntityBridgeInvocationHandler)handler).setContext(null);
}
}
ctx.setPersistenceContext(null);
}
public CMPStoreManager.PersistenceContext
getPersistenceContext(EntityEnterpriseContext ctx) {
return (CMPStoreManager.PersistenceContext)ctx.getPersistenceContext();
}
// JDBC Specific Information
public int setInstanceParameters(PreparedStatement ps, int parameterIndex,
EntityEnterpriseContext ctx) {
return setInstanceParameters(ps, parameterIndex, ctx, cmpFields);
}
public int setInstanceParameters(PreparedStatement ps, int parameterIndex,
EntityEnterpriseContext ctx, JDBCCMPFieldBridge[] fields) {
for(int i=0; i<fields.length; i++) {
parameterIndex = fields[i].setInstanceParameters(ps,
parameterIndex, ctx);
}
return parameterIndex;
}
public int setPrimaryKeyParameters(PreparedStatement ps, int parameterIndex,
Object primaryKey) {
for(int i=0; i<primaryKeyFields.length; i++) {
parameterIndex =
primaryKeyFields[i].setPrimaryKeyParameters(ps, parameterIndex, primaryKey);
}
return parameterIndex;
}
public int loadInstanceResults(ResultSet rs, int parameterIndex,
EntityEnterpriseContext ctx) {
for(int i=0; i<cmpFields.length; i++) {
parameterIndex = cmpFields[i].loadInstanceResults(rs,
parameterIndex, ctx);
}
return parameterIndex;
}
public int loadNonPrimaryKeyResults(ResultSet rs, int parameterIndex,
EntityEnterpriseContext ctx) {
for(int i=primaryKeyFields.length; i<cmpFields.length; i++) {
parameterIndex = cmpFields[i].loadInstanceResults(rs,
parameterIndex, ctx);
}
return parameterIndex;
}
public int loadPrimaryKeyResults(ResultSet rs, int parameterIndex, Object[]
pkRef) {
for(int i=0; i<primaryKeyFields.length; i++) {
parameterIndex = primaryKeyFields[i].loadPrimaryKeyResults(rs,
parameterIndex, pkRef);
}
return parameterIndex;
}
public Object extractPrimaryKeyFromInstance(EntityEnterpriseContext ctx) {
try {
Object pk = getPrimaryKeyClass().newInstance();
for(int i=0; i<primaryKeyFields.length; i++) {
Object fieldValue =
primaryKeyFields[i].getInstanceValue(ctx);
// updated pk object with return form set primary key
value to
// handle single valued non-composit pks and more
complicated behivors.
pk = primaryKeyFields[i].setPrimaryKeyValue(pk,
fieldValue);
}
return pk;
} catch(EJBException e) {
// to avoid double wrap of EJBExceptions
throw e;
} catch(Exception e) {
// Non recoverable internal exception
throw new EJBException("Internal error extracting primary key
from instance: " + e);
}
}
public void injectPrimaryKeyIntoInstance(EntityEnterpriseContext ctx, Object
pk) {
for(int i=0; i<primaryKeyFields.length; i++) {
Object fieldValue = primaryKeyFields[i].getPrimaryKeyValue(pk);
primaryKeyFields[i].setInstanceValue(ctx, fieldValue);
}
}
}
1.1
jboss/src/main/org/jboss/ejb/plugins/cmp/jdbc/bridge/JDBCSelectorBridge.java
Index: JDBCSelectorBridge.java
===================================================================
/*
* JBoss, the OpenSource EJB server
*
* Distributable under LGPL license.
* See terms of license at gnu.org.
*/
package org.jboss.ejb.plugins.cmp.jdbc.bridge;
/**
* JDBCSelectorBridge represents one ejbSelect method.
*
* Life-cycle:
* Tied to the EntityBridge.
*
* Multiplicity:
* One for each entity bean ejbSelect method.
*
* @author <a href="mailto:[EMAIL PROTECTED]";>Dain Sundstrom</a>
* @version $Revision: 1.1 $
*/
import org.jboss.ejb.plugins.cmp.bridge.SelectorBridge;
public class JDBCSelectorBridge implements SelectorBridge {
protected String selectorName;
protected Class returnType;
public String getSelectorName() {
return selectorName;
}
public Class getReturnType() {
return returnType;
}
public Object execute(Object[] args) {
return null;
}
}
_______________________________________________
Jboss-development mailing list
[EMAIL PROTECTED]
http://lists.sourceforge.net/lists/listinfo/jboss-development
