| /******************************************************************************* |
| * Copyright (c) 2001, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.jst.j2ee.model.internal.validation; |
| |
| import java.util.HashSet; |
| |
| import org.eclipse.jem.java.JavaClass; |
| import org.eclipse.jem.java.JavaHelpers; |
| import org.eclipse.jem.java.JavaParameter; |
| import org.eclipse.jem.java.Method; |
| import org.eclipse.jst.j2ee.ejb.EnterpriseBean; |
| import org.eclipse.jst.j2ee.ejb.Entity; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| |
| |
| /** |
| * This class checks entity home classes for errors or potential errors. |
| * If any problems are found, an error, warning, or info marker is added to the task list. |
| * |
| * Enterprise JavaBeans Specification ("Specification") |
| * Version: 1.1 |
| * Status: Final Release |
| * Release: 12/17/99 |
| * URL: http://java.sun.com/products/ejb/docs.html |
| * Section: 9.2.8 |
| */ |
| public abstract class AValidateEntityHome extends AValidateHome { |
| private HashSet findByPKMethods = null; |
| |
| public AValidateEntityHome() { |
| findByPKMethods = new HashSet(); |
| } |
| |
| @Override |
| public void reset() { |
| super.reset(); |
| findByPKMethods.clear(); |
| } |
| |
| protected void incrementFindByPrimaryKeyCount(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) { |
| if (method == null) { |
| return; |
| } |
| |
| // Need to track number of findByPrimaryKey methods for the |
| // validateMethodExists() checks. Do not check only the current |
| // class, or a findByPrimaryKey which is inherited from a parent interface |
| // will not be detected. |
| if (method.getName().equals(IMethodAndFieldConstants.METHODNAME_FINDBYPRIMARYKEY)) { |
| findByPKMethods.add(method); |
| } |
| } |
| |
| /** |
| * This method returns true if the given method returns the remote interface, |
| * and false otherwise. |
| */ |
| public boolean isSingleObjectFinder(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return false; |
| } |
| |
| // The findByPrimaryKey method is always a single-object finder. |
| JavaClass remoteIntf = bean.getRemoteInterface(); |
| ValidationRuleUtility.isValidTypeHierarchy(bean, remoteIntf); |
| |
| if (!ValidationRuleUtility.isAssignableFrom(method.getReturnType(), remoteIntf)) { |
| return false; |
| } |
| |
| // The method is a single-object finder. |
| return true; |
| } |
| |
| /** |
| * This method checks that the entity home's methods comply with the EJB 1.1 specification. |
| * Section: 9.2.8 |
| */ |
| @Override |
| public void primValidate(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method hiMethod) throws InvalidInputException { |
| // Can't invoke an abstract method |
| // super.primValidate(hiMethod); |
| |
| vc.terminateIfCancelled(); |
| |
| String name = hiMethod.getName(); |
| |
| // Each method defined in the home interface must be one of the following: |
| // - A create method. |
| // - A finder method. |
| if (name.equals(IMethodAndFieldConstants.METHODNAME_CREATE)) |
| validateCreateMethod(vc, bean, clazz, hiMethod); |
| else if (name.startsWith(IMethodAndFieldConstants.PREFIX_FIND)) |
| validateFindMethod(vc, bean, clazz, hiMethod); |
| else { |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2005, IEJBValidationContext.ERROR, bean, clazz, hiMethod, this); |
| vc.addMessage(message); |
| } |
| } |
| |
| /** |
| * Checks to see if @ejbMethod is one of the required methods. |
| */ |
| @Override |
| protected void primValidateExistence(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method ejbMethod) throws InvalidInputException { |
| // Can't invoke an abstract method |
| //super.validateExistence(ejbMethod); |
| |
| if (IMethodAndFieldConstants.METHODNAME_FINDBYPRIMARYKEY.equals(ejbMethod.getName())) |
| incrementFindByPrimaryKeyCount(vc, bean, clazz, ejbMethod); |
| } |
| |
| /** |
| * EJB 1.1 specification |
| * Section: 9.2.8 |
| */ |
| @Override |
| public void validateClass(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException { |
| super.validateClass(vc, bean, clazz); |
| // The superclass checks that the home extends javax.ejb.EJBHome, |
| // and that the interface inheritance complies with RMI-IIOP rules. |
| } |
| |
| /** |
| * Checks that the create method on the entity home follows the EJB 1.1. specification. |
| * Section: 9.2.8 |
| */ |
| public void validateCreateMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return; |
| } |
| |
| // Each create method must be named "create", and it must match one of the |
| // ejbCreate methods defined in the enterprise Bean class. The matching |
| // ejbCreate method must have the same number and types of its arguments. |
| // (Note that the return type is different.) |
| // |
| // All the exceptions defined in the throws clause of the matching ejbCreate |
| // and ejbPostCreate methods of the enterprise Bean class must be included in |
| // the throws clause of the matching create method of the home interface |
| // (i.e the set of exceptions defined for the create method must be a superset |
| // of the union of exceptions defined for the ejbCreate and ejbPostCreate methods) |
| validateCreateMethod_beanDep(vc, bean, clazz, method); |
| |
| vc.terminateIfCancelled(); |
| |
| // The return type for a create method must be the entity bean's remote interface type. |
| validateCreateMethod_remoteDep(vc, bean, clazz, method); |
| |
| // The throws clause of a create method must include the javax.ejb.CreateException. |
| if (!ValidationRuleUtility.throwsCreateException(bean, method)) { |
| String[] msgParm = { ITypeConstants.CLASSNAME_JAVAX_EJB_CREATEEXCEPTION }; |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2414, IEJBValidationContext.ERROR, bean, clazz, method, msgParm, this); |
| vc.addMessage(message); |
| } |
| |
| // The methods defined in this interface must follow the rules for RMI-IIOP. |
| // This means that their argument and return types must be of valid types for |
| // RMI-IIOP, and that their throws clause must include the java.rmi.RemoteException. |
| validateLegalRMIMethod(vc, bean, clazz, method); |
| |
| } |
| |
| /** |
| * Checks that the create method on the entity home follows the EJB 1.1. specification. |
| * Section: 9.2.8 |
| */ |
| @Override |
| public void validateCreateMethod_beanDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return; |
| } |
| |
| // Each create method must be named "create", and it must match one of the |
| // ejbCreate methods defined in the enterprise Bean class. The matching |
| // ejbCreate method must have the same number and types of its arguments. |
| // (Note that the return type is different.) |
| super.validateCreateMethod_beanDep(vc, bean, clazz, method); |
| |
| // |
| // All the exceptions defined in the throws clause of the matching ejbCreate |
| // and ejbPostCreate methods of the enterprise Bean class must be included in |
| // the throws clause of the matching create method of the home interface |
| // (i.e the set of exceptions defined for the create method must be a superset |
| // of the union of exceptions defined for the ejbCreate and ejbPostCreate methods) |
| validateMatchingBeanPostCreateMethod(vc, bean, clazz, method); |
| } |
| |
| /** |
| * In addition to regular find rules, findByPrimaryKey needs to follow some other rules. |
| * EJB 1.1 specification |
| * Section: 9.2.8 |
| */ |
| public void validateFindByPrimaryKeyMethod_keyDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return; |
| } |
| |
| boolean hasValidFBPKMethod = false; |
| Entity entityBean = (Entity) bean; // bean is checked for null in AValidateEJB.validate() method, so don't need to check for it here. |
| JavaClass keyClass = entityBean.getPrimaryKey(); |
| |
| ValidationRuleUtility.isValidTypeHierarchy(bean, keyClass); |
| |
| vc.terminateIfCancelled(); |
| |
| // The method must declare the primary key class as the method argument. |
| // This check also validates case 9.4.7.3 (CMP unknown primary key class, |
| // which must be declared as java.lang.Object.) |
| JavaParameter[] parms = method.listParametersWithoutReturn(); |
| if (parms.length == 1) { |
| JavaHelpers type = parms[0].getJavaType(); |
| if (ValidationRuleUtility.isAssignableFrom(type, keyClass)) { |
| // check that it's a single-object finder |
| if (isSingleObjectFinder(vc, bean, clazz, method)) { |
| hasValidFBPKMethod = true; |
| } |
| } |
| else { |
| // check if it's java.lang.Object. If it is, this could be a case of 9.4.7.3. |
| if (ValidationRuleUtility.isSameType(type, ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVA_LANG_OBJECT, entityBean))) { |
| hasValidFBPKMethod = true; |
| } |
| } |
| } |
| |
| if (!hasValidFBPKMethod) { |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2405, IEJBValidationContext.WARNING, bean, clazz, method, new String[] { keyClass.getQualifiedName()}, this); |
| vc.addMessage(message); |
| } |
| } |
| |
| /** |
| * In addition to regular find rules, findByPrimaryKey needs to follow some other rules. |
| * EJB 1.1 specification |
| * Section: 9.2.8 |
| */ |
| public void validateFindByPrimaryKeyMethod_remoteDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (!isSingleObjectFinder(vc, bean, clazz, method)) { |
| String remoteIntfName = bean.getRemoteInterface().getName(); // Can assume that remote interface isn't null, or isSingleObjectFinder would have thrown an InvalidInputException. |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2403, IEJBValidationContext.WARNING, bean, clazz, method, new String[] { remoteIntfName }, this); |
| vc.addMessage(message); |
| } |
| } |
| |
| /** |
| * Checks that the finder method on the entity home class follows the EJB 1.1 specification. |
| * Section: 9.2.8 |
| */ |
| public void validateFindMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return; |
| } |
| |
| // The return type for a find<METHOD> method must be the entity bean's remote |
| // interface type (for a single-object finder), or a collection thereof (for a |
| // multi-object finder). |
| // |
| // Whether or not the parameter is a type or an array of types, the following |
| // call will return the base type. i.e., if it's an array of "MyClass", |
| // the returnTypeName will be set to "MyClass", not an array type. |
| validateFindMethod_remoteDep(vc, bean, clazz, method); |
| |
| // The throws clause of a finder method must include the javax.ejb.FinderException. |
| if (!ValidationRuleUtility.throwsFinderException(bean, method)) { |
| String[] msgParm = { ITypeConstants.CLASSNAME_JAVAX_EJB_FINDEREXCEPTION }; |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2414, IEJBValidationContext.ERROR, bean, clazz, method, msgParm, this); |
| vc.addMessage(message); |
| } |
| |
| // The home interface must always include the findByPrimaryKey method, which is |
| // always a single-object finder. The method must declare the primary key class |
| // as the method argument. |
| boolean validateRMIParameters = true; // should the parameters be validated to see if they follow RMI-IIOP rules? |
| boolean validateRMIRetType = true; // should the return type be validated to see if it follows RMI-IIOP rules? |
| if (method.getName().equals(IMethodAndFieldConstants.METHODNAME_FINDBYPRIMARYKEY)) { |
| // - The home interface must always include the findByPrimaryKey method, which is |
| // always a single-object finder. The method must declare the primary key class |
| // as the method argument. |
| // |
| // The findByPrimaryKey method is always a single-object finder. |
| // The call to validateFindByPrimaryKeyMethod_remoteDep is done in |
| // validateFindMethod_remoteDep(method); |
| //validateFindByPrimaryKeyMethod_remoteDep(method); |
| |
| // The method must declare the primary key class as the method argument. |
| validateFindByPrimaryKeyMethod_keyDep(vc, bean, clazz, method); |
| |
| if(ValidationRuleUtility.usesUnknownPrimaryKey(bean)) { |
| validateRMIParameters = false; |
| } |
| } |
| |
| // The methods defined in this interface must follow the rules for RMI-IIOP. |
| // This means that their argument and return types must be of valid types for |
| // RMI-IIOP, and that their throws clause must include the java.rmi.RemoteException. |
| // However, the return type of "Enumeration" or "Collection" is exempted from this |
| // check, because the spec states, in 9.1.8.2, that Enumeration or Collection must be returned |
| // for multi-object finders. |
| JavaHelpers retType = method.getReturnType(); |
| validateRMIRetType = !((ValidationRuleUtility.isAssignableFrom(retType, ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVA_UTIL_ENUMERATION, bean))) || |
| (ValidationRuleUtility.isAssignableFrom(retType, ValidationRuleUtility.getType(ITypeConstants.CLASSNAME_JAVA_UTIL_COLLECTION, bean)))); |
| |
| if(validateRMIParameters) { |
| validateLegalRMIMethodArguments(vc, bean, clazz, method); |
| } |
| |
| if(validateRMIRetType) { |
| validateLegalRMIMethodReturnType(vc, bean, clazz, method); |
| } |
| |
| validateLegalRMIMethodExceptions(vc, bean, clazz, method); |
| } |
| |
| /** |
| * Checks that the finder method on the entity home class follows the EJB 1.1 specification. |
| * Section: 9.2.8 |
| */ |
| public void validateFindMethod_remoteDep(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| if (method == null) { |
| return; |
| } |
| |
| // The return type for a find<METHOD> method must be the entity bean's remote |
| // interface type (for a single-object finder), or a collection thereof (for a |
| // multi-object finder). |
| // |
| // Whether or not the parameter is a type or an array of types, the following |
| // call will return the base type. i.e., if it's an array of "MyClass", |
| // the returnTypeName will be set to "MyClass", not an array type. |
| JavaClass remoteIntf = bean.getRemoteInterface(); |
| ValidationRuleUtility.isValidTypeHierarchy(bean, remoteIntf); |
| |
| // Perform this check for all finders but the findByPrimaryKey method. |
| // The findByPrimaryKey method must return the remote interface, because the method is |
| // a single-object finder method; but other finders may return a Collection or Enumeration. |
| if (!method.getName().equals(IMethodAndFieldConstants.METHODNAME_FINDBYPRIMARYKEY)) { |
| JavaHelpers returnType = method.getReturnType(); |
| |
| if (! (ValidationRuleUtility.isAssignableFromCollection(returnType, bean) || |
| ValidationRuleUtility.isAssignableFromEnumeration(returnType, bean) || |
| ValidationRuleUtility.isAssignableFrom(returnType, remoteIntf))) { |
| String[] msgParm = { remoteIntf.getName()}; |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IEJBValidatorMessageConstants.CHKJ2403, IEJBValidationContext.WARNING, bean, clazz, method, msgParm, this); |
| vc.addMessage(message); |
| } |
| } |
| |
| // The home interface must always include the findByPrimaryKey method, which is |
| // always a single-object finder. The method must declare the primary key class |
| // as the method argument. |
| if (method.getName().equals(IMethodAndFieldConstants.METHODNAME_FINDBYPRIMARYKEY)) { |
| validateFindByPrimaryKeyMethod_remoteDep(vc, bean, clazz, method); |
| } |
| } |
| |
| @Override |
| public void validateMatchingBeanCreateMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method method) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| |
| super.validateMatchingBeanCreateMethod(vc, bean, clazz, method); |
| JavaClass beanClass = bean.getEjbClass(); |
| Method ejbCreateMethod = ValidationRuleUtility.getMethodExtended(beanClass, method, IMethodAndFieldConstants.METHODNAME_EJBCREATE); |
| if (ejbCreateMethod == null) { |
| // already reported in super |
| return; |
| } |
| } |
| |
| /** |
| * Checks that the finder method on the entity home class follows the EJB 1.1 specification. |
| * Section: 9.2.8 |
| */ |
| public void validateMatchingBeanFindMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method homeMethod) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| |
| if (homeMethod == null) { |
| return; |
| } |
| |
| // Each finder method must be named "find<METHOD>" (e.g. findLargeAccounts), and it |
| // must match one of the ejbFind<METHOD> methods defined in the entity bean class |
| // (e.g. ejbFindLargeAccounts). The matching ejbFind<METHOD> method must have the |
| // same number and types of arguments. (Note that the return type may be different.) |
| String findMethodName = IMethodAndFieldConstants.PREFIX_EJBF + (homeMethod.getName()).substring(1); // e.g. if the home method is named findX, then the bean method will be named ejbFindX |
| |
| JavaClass beanClass = bean.getEjbClass(); |
| ValidationRuleUtility.isValidTypeHierarchy(bean, beanClass); |
| |
| Method beanMethod = ValidationRuleUtility.getMethodExtended(beanClass, homeMethod, findMethodName); |
| if (beanMethod == null) { |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2030, IEJBValidationContext.ERROR, bean, clazz, homeMethod, new String[] { beanClass.getName()}, this); |
| vc.addMessage(message); |
| return; |
| } |
| |
| // Check if return types match |
| vc.terminateIfCancelled(); |
| JavaHelpers homeRetType = homeMethod.getReturnType(); |
| JavaHelpers beanRetType = beanMethod.getReturnType(); |
| if (!ValidationRuleUtility.isAssignableFrom(homeRetType, beanRetType)) { |
| // emit the error only if it's a multi-finder. Single-finders are supposed to have different return types on the home & bean class. |
| boolean homeRetTypeIsRemote = ValidationRuleUtility.isAssignableFrom(homeRetType, bean.getRemoteInterface()); |
| boolean beanRetTypeIsKey = ValidationRuleUtility.isAssignableFrom(beanRetType, ((Entity)bean).getPrimaryKey()); |
| if(!(homeRetTypeIsRemote && beanRetTypeIsKey)) { |
| JavaHelpers retType = (beanRetTypeIsKey) ? bean.getRemoteInterface() : beanRetType; // if the bean class returns a key, the home must return the remote; if the bean class returns a Coll/Enum, the home must return the same |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2415, IEJBValidationContext.ERROR, bean, clazz, homeMethod, new String[] { retType.getJavaName(), beanClass.getName()}, this); |
| vc.addMessage(message); |
| } |
| } |
| |
| // All the exceptions defined in the throws clause of an ejbFind method of the |
| // entity bean class must be included in the throws clause of the matching find |
| // method of the home interface. |
| /* |
| // Don't check for the exceptions here - let the bean class do it. When the home |
| // changes, a "dependent" validation of the bean's checks should be done automatically. |
| // If it is checked in this method as well, there are duplicate messages on the task list. |
| HashSet exceptions = getNotSubsetExceptions(homeMethod, beanMethod); |
| if(exceptions.size() > 0) { |
| Iterator iterator = exceptions.iterator(); |
| while(iterator.hasNext()) { |
| JavaClass exc = (JavaClass)iterator.next(); |
| String[] msgParm = {exc.getQualifiedName()}; |
| addValidationMessage(IEJBValidationContext.ERROR, IMessagePrefixEjb11Constants.EJB_METHOD_THROW_NOTHI_EXCEP, msgParm, beanMethod, EJB_BEAN_GROUP); |
| } |
| } |
| */ |
| } |
| |
| /** |
| * Checks that the create method on the entity home has a matching ejbCreate and ejbPostCreate on the bean. |
| * EJB 1.1 specification |
| * Section: 9.2.8 |
| */ |
| public void validateMatchingBeanPostCreateMethod(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz, Method homeMethod) throws InvalidInputException { |
| vc.terminateIfCancelled(); |
| |
| if (homeMethod == null) { |
| return; |
| } |
| |
| // Each create method must be named "create", and it must match one of the |
| // ejbCreate methods defined in the enterprise Bean class. The matching |
| // ejbCreate method must have the same number and types of its arguments. |
| // (Note that the return type is different.) |
| JavaClass beanClass = bean.getEjbClass(); |
| ValidationRuleUtility.isValidTypeHierarchy(bean, beanClass); |
| |
| Method beanMethod = ValidationRuleUtility.getMethodExtended(beanClass, homeMethod, IMethodAndFieldConstants.METHODNAME_EJBPOSTCREATE); |
| if (beanMethod == null) { |
| // Let the bean class report this message. Otherwise, when the bean class reports it, this message looks like a duplicate. |
| /* |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2031, IEJBValidationContext.WARNING, bean, clazz, homeMethod, new String[] { beanClass.getName()}, this); |
| vc.addMessage(message); |
| */ |
| return; |
| } |
| |
| // All the exceptions defined in the throws clause of the matching ejbCreate |
| // and ejbPostCreate methods of the enterprise Bean class must be included in |
| // the throws clause of the matching create method of the home interface |
| // (i.e the set of exceptions defined for the create method must be a superset |
| // of the union of exceptions defined for the ejbCreate and ejbPostCreate methods) |
| /* |
| // Don't check for the exceptions here - let the bean class do it. When the home |
| // changes, a "dependent" validation of the bean's checks should be done automatically. |
| // If it is checked in this method as well, there are duplicate messages on the task list. |
| HashSet exceptions = getNotSubsetExceptions(homeMethod, beanMethod); |
| if(exceptions.size() > 0) { |
| Iterator iterator = exceptions.iterator(); |
| while(iterator.hasNext()) { |
| JavaClass exc = (JavaClass)iterator.next(); |
| String[] msgParm = {exc.getQualifiedName()}; |
| addValidationMessage(IEJBValidationContext.ERROR, IMessagePrefixEjb11Constants.EJB_METHOD_THROW_NOTHI_EXCEP, msgParm, beanMethod, EJB_BEAN_GROUP); |
| } |
| } |
| */ |
| } |
| |
| /** |
| * EJB 1.1 specification |
| * Section: 9.2.8 |
| */ |
| @Override |
| protected void validateMethodExists(IEJBValidationContext vc, EnterpriseBean bean, JavaClass clazz) throws InvalidInputException { |
| // - The home interface must always include the findByPrimaryKey method, which is |
| // always a single-object finder. The method must declare the primary key class |
| // as the method argument. |
| if (findByPKMethods.size() == 0) { |
| // must have one findByPrimaryKey method |
| IMessage message = MessageUtility.getUtility().getMessage(vc, IMessagePrefixEjb11Constants.CHKJ2011, IEJBValidationContext.ERROR, bean, clazz, new String[] { clazz.getQualifiedName()}, this); |
| vc.addMessage(message); |
| } |
| /* |
| // Not sure if this check is useful or not, because it is legal for a child home to declare a findByPrimaryKey, |
| // and also for a parent home to declare a findByPrimaryKey. |
| else if ( findByPKMethods.size() > 1 ) { |
| // if the home interface has multiple findByPrimaryKey methods (implied by 9.2.8) |
| Iterator iterator = findByPKMethods.iterator(); |
| while(iterator.hasNext()) { |
| addValidationMessage(IEJBValidationContext.WARNING, IMessagePrefixEjb11Constants.EJB_HAS_MULTIPLE_PK_METHODS, (Method)iterator.next()); |
| } |
| } |
| */ |
| } |
| } |