首先从缓冲中获得代理实例，如果没有，通过动态代理生成。
@param EJBDefinition
@return
328291
public Object getService(TargetMetaDef targetMetaDef) {

    Debug.logVerbose("[JdonFramework] --> enter getService from dynamicProxy", module);

    Object dynamicProxy = _proxyCache.get(targetMetaDef);
    if (dynamicProxy == null) {
      dynamicProxy = getServiceFromProxy(targetMetaDef);
      _proxyCache.put(targetMetaDef, dynamicProxy);
    }
    return dynamicProxy;

  }
229763
public List<EjbRefType<WebFragmentDescriptor>> getAllEjbRef()
   {
      List<EjbRefType<WebFragmentDescriptor>> list = new ArrayList<EjbRefType<WebFragmentDescriptor>>();
      List<Node> nodeList = model.get("ejb-ref");
      for(Node node: nodeList)
      {
         EjbRefType<WebFragmentDescriptor>  type = new EjbRefTypeImpl<WebFragmentDescriptor>(this, "ejb-ref", model, node);
         list.add(type);
      }
      return list;
   }
122138
protected static BeanDefinition getServerConfigurationBeanDefinition(){
        String className = ServerConfiguration.class.getName();
        GenericBeanDefinition result = new GenericBeanDefinition();
        result.setAutowireCandidate(true);
        result.setScope(BeanDefinition.SCOPE_SINGLETON);
        result.setBeanClass(Server.class);
        result.setFactoryMethodName("getConfig");
        result.setAttribute("id", className);
        result.setAttribute("name", className);
        return result;
    }
47119
public String generateModelClass(DBDefinition dbDefinition) {
    StringGrabber sgOutputModelCalssText = new StringGrabber();

    sgOutputModelCalssText.append("@DBTable(tableName=" + DQ + dbDefinition.dbTableName + DQ + ")");

    sgOutputModelCalssText.newLine();
    sgOutputModelCalssText.append("public class " + dbDefinition.javaClassName + " implements D6Model");
    sgOutputModelCalssText.newLine();
    sgOutputModelCalssText.append("{");
    sgOutputModelCalssText.newLine();

    final int columnCount = dbDefinition.columnList.size();
    for (int i = 0; i < columnCount; i++) {

      DBColumnDef column = dbDefinition.columnList.get(i);

      StringGrabber sg = new StringGrabber();
      sg.append("columnName=" + DQ + column.dbColumnName + DQ);
      sg.append(", ");
      sg.append("columnType=" + DQ + column.dbColumnType + DQ);
      sg.append(", ");
      if (column.isNullable) {
        if (IS_DISPLAY_THOSE_OPTIONAL_ON_DB_COLUMN) {
          // NOT NEED TO SHOW
          sg.append("isNullable=");
          sg.append("true");
          sg.append(", ");
        }
      } else {
        sg.append("isNullable=");
        sg.append("false");
        sg.append(", ");

      }
      if (column.isPrimaryKey) {
        sg.append("isPrimaryKey=");
        sg.append("true");
        sg.append(", ");
      } else {
        if (IS_DISPLAY_THOSE_OPTIONAL_ON_DB_COLUMN) {
          // NOT NEED TO SHOW
          sg.append("isPrimaryKey=");
          sg.append("true");
          sg.append(", ");
        }
      }

      if (column.isUnique) {
        sg.append("isUnique=");
        sg.append("true");
        sg.append(", ");
      } else {
        if (IS_DISPLAY_THOSE_OPTIONAL_ON_DB_COLUMN) {
          // NOT NEED TO SHOW
          sg.append("isUnique=");
          sg.append("true");
          sg.append(", ");
        }
      }
      if (column.isAutoIncrement) {
        sg.append("isAutoIncrement=");
        sg.append("true");
        sg.append(", ");
      } else {
        if (IS_DISPLAY_THOSE_OPTIONAL_ON_DB_COLUMN) {
          sg.append("isAutoIncrement=");
          sg.append("false");
          sg.append(", ");
        }
      }
      sg.removeTail(2);

      String codeLine0 = "@DBColumn(" + sg.toString() + ")";
      String codeLine1 = "public " + column.javaType + " " + column.javaField + ";";

      sgOutputModelCalssText.append(codeLine0);
      sgOutputModelCalssText.newLine();
      sgOutputModelCalssText.append(codeLine1);
      sgOutputModelCalssText.newLine();
      sgOutputModelCalssText.newLine();

    }

    sgOutputModelCalssText.newLine();
    sgOutputModelCalssText.append("}");

    return sgOutputModelCalssText.toString();
  }
745330
public String getWebServiceEndpointProxyClassName()
    {
        StringBuilder result = new StringBuilder();

        // Use the package of the EJB implementation.
        String packageName = packageName(ivBeanClass);

        if (packageName != null) {
            result.append(packageName);
            result.append('.');
        }

        result.append(endpointPrefix); // WSEJBProxy
        result.append(ivBeanType); // SL/SF/BMP/CMP, etc.
        result.append(ivBeanName); // First 32 characters
        result.append('_');
        result.append(ivHashSuffix); // 8 digit hashcode

        return result.toString();
    }
27910
private Map<InterceptorMethodKind, List<InterceptorProxy>> createInterceptorProxyMap(final Class<?> interceptorOrEjbClass, int index)
                    throws EJBConfigurationException
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
        {
            Tr.entry(tc, "createInterceptorProxyMap: " + interceptorOrEjbClass.getName() + ", " + index);
        }

        // Create a LIFO LinkedList of Class objects starting with the interceptor or EJB class
        // itself and then each its the super classes. We create a LIFO so that the interceptor
        // methods in the most general superclass are invoked first as required by the
        // EJB specification.
        LinkedList<Class<?>> supers;
        supers = InterceptorMetaDataHelper.getLIFOSuperClassesList(interceptorOrEjbClass);

        // Get the EnumMap of interceptor methods to be processed.
        EnumMap<InterceptorMethodKind, List<Method>> enumMap = null;

        // Determine if this is the EJB class
        boolean ejbClass = (index < 0); //d451021
        if (ejbClass)
        {
            if (isTraceOn && tc.isDebugEnabled()) // d404960
            {
                Tr.debug(tc, "processing EJB class, ivHasComponentInterface = " + ivHasComponentInterface);
            }

            // EJB class, call helper to get the EnumMap for the EJB only
            // if there is a WCCM EnterpriseBean object for this EJB.
            // If null, then this EJB must be annotated rather than defined
            // in ejb-jar.xml file.
            EnterpriseBean bean = ivBmd.wccm.enterpriseBean;
            if (bean != null)
            {
                enumMap = InterceptorMetaDataHelper.getEJBInterceptorMethods(ivEjbClass, bean, supers, ivBmd.j2eeName);
            }
        }
        else
        {
            // Get EnumMap for this interceptor class. The EnumMap is built from
            // processing Interceptors stanza in ejb-jar.xml to get list of each
            // interceptor method specified via xml.
            IdentityHashMap<Class<?>, EnumMap<InterceptorMethodKind, List<Method>>> interceptorsMap;
            interceptorsMap = ivEJBModuleMetaDataImpl.ivInterceptorsMap;
            if (interceptorsMap != null) // d438904
            {
                enumMap = interceptorsMap.get(interceptorOrEjbClass);
            }
        }

        Map<InterceptorMethodKind, List<InterceptorProxy>> proxyMap =
                        new HashMap<InterceptorMethodKind, List<InterceptorProxy>>(); // d630717

        // For each class in the interceptor class inheritance tree.
        for (Class<?> superClass : supers)
        {
            Map<InterceptorMethodKind, InterceptorProxy> proxies =
                            new EnumMap<InterceptorMethodKind, InterceptorProxy>(InterceptorMethodKind.class); // F743-17763

            // If there were no Interceptor methods defined via xml, then EnumMap
            // is null.  So only process EnumMap if not null.
            if (enumMap != null)
            {
                // F743-17763 - Iterate over all interceptor kinds, and look for
                // interceptors of that type defined in XML.
                for (InterceptorMethodKind kind : InterceptorMethodKind.values())
                {
                    // Get methods specified via xml.
                    List<Method> methodList = enumMap.get(kind);
                    if (methodList != null)
                    {
                        for (Method m : methodList)
                        {
                            // Is the method overridden?
                            if (!InterceptorMetaDataHelper.isMethodOverridden(m, supers)) // d469514
                            {
                                if (kind.isLifecycle() && ejbClass && kind.isEJBCallbackMethodValidationRequired(this))
                                {
                                    validateEJBCallbackMethod(kind, m, false);
                                }

                                // Not overridden, so process the method.
                                if (m.getDeclaringClass() == superClass)
                                {
                                    // Validate.
                                    if (proxies.containsKey(kind))
                                    {
                                        // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                        String className = superClass.getName();
                                        Object[] data = new Object[] { className, kind.getXMLElementName() };
                                        Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                        throw new EJBConfigurationException("Only one " + kind.getXMLElementName()
                                                                            + " interceptor method is allowed in class " + className);
                                    }

                                    // Create an InterceptorProxy for it.
                                    addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                }
                            }
                        }
                    }
                }
            }

            // Provided that metadata-complete is false, process annotation
            // in the superClass to determine if there is any interceptor
            // method to add that was not added already via xml.
            if (!ivMetadataComplete)
            {
                // For each method of the class.
                // For each method in a class of EJB class inheritance.
                Method[] methods = superClass.getDeclaredMethods();
                for (Method m : methods)
                {
                    // F743-17763 - Iterate over all interceptor kinds, and look for
                    // interceptors of that type defined in XML.
                    for (InterceptorMethodKind kind : InterceptorMethodKind.values())
                    {
                        // Does this method have the annotation?
                        Class<? extends Annotation> annotationClass = kind.getAnnotationClass();
                        if (annotationClass != null && m.isAnnotationPresent(annotationClass))
                        {
                            // Yes, is the method overridden?
                            if (!InterceptorMetaDataHelper.isMethodOverridden(m, supers)) // d469514
                            {
                                // Not overridden, so validate its signature if necessary.
                                if (kind.isLifecycle())
                                {
                                    if (ejbClass && kind.isEJBCallbackMethodValidationRequired(this))
                                    {
                                        validateEJBCallbackMethod(kind, m, true);
                                    }

                                    InterceptorMetaDataHelper.validateLifeCycleSignature(kind,
                                                                                         annotationClass.getSimpleName(),
                                                                                         m, ejbClass, ivBmd.j2eeName);
                                }
                                else
                                {
                                    InterceptorMetaDataHelper.validateAroundSignature(kind, m, ivBmd.j2eeName);
                                }

                                // Validate.
                                InterceptorProxy proxy = proxies.get(kind);
                                if (proxy == null)
                                {
                                    // Create an InterceptorProxy for it.
                                    addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                }
                                else if (!m.equals(proxy.ivInterceptorMethod))
                                {
                                    // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                    String className = superClass.getName();
                                    Object[] data = new Object[] { className, kind.getXMLElementName() };
                                    Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                    throw new EJBConfigurationException("Only one " + kind.getXMLElementName()
                                                                        + " interceptor method is allowed in class " + className);
                                }
                            }
                        }
                        else if (kind.isLifecycle() && ejbClass && kind.isNonAnnotatedEJBCallbackMethodValidationRequired(this))
                        {
                            if (m.getName().equals(kind.getLifecycleCallbackMethodName()) &&
                                m.getParameterTypes().length == 0 &&
                                m.getReturnType() == java.lang.Void.TYPE) // d404960
                            {
                                InterceptorProxy proxy = proxies.get(kind);
                                if (proxy == null)
                                {
                                    addInterceptorProxy(kind, m, index, proxies, proxyMap);
                                }
                                else if (!m.equals(proxy.ivInterceptorMethod)) // d453498
                                {
                                    // CNTR0223E: Only one method in the {0} class is allowed to be a {1} interceptor method.
                                    String className = superClass.getName();
                                    Object[] data = new Object[] { className, kind.getXMLElementName() };
                                    Tr.error(tc, "DUPLICATE_INTERCEPTOR_METHOD_CNTR0223E", data);
                                    throw new EJBConfigurationException("Only one post-construct interceptor method is " +
                                                                        "allowed for class " + className + ". Both " +
                                                                        proxy.ivInterceptorMethod.getName() +
                                                                        " and " + m.getName() +
                                                                        " are configured as post-construct methods.");
                                }
                            }
                        }
                    }
                }
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
        {
            Tr.exit(tc, "createInterceptorProxyMap");
        }

        return proxyMap;
    }
981997
public static ApiDefinitionBean unmarshallApiDefinition(Map<String, Object> source) {
        if (source == null) {
            return null;
        }
        ApiDefinitionBean bean = new ApiDefinitionBean();
        bean.setData(asString(source.get("data")));
        postMarshall(bean);
        return bean;
    }
98971
@Nonnull
  public static EbInterfaceWriter <Ebi40InvoiceType> ebInterface40 ()
  {
    final EbInterfaceWriter <Ebi40InvoiceType> ret = EbInterfaceWriter.create (Ebi40InvoiceType.class);
    ret.setNamespaceContext (EbInterface40NamespaceContext.getInstance ());
    return ret;
  }
467579
@Override
    public ITypedReferenceableInstance getEntityDefinition(String guid) throws AtlasException {
        guid = ParamChecker.notEmpty(guid, "entity id");

        final ITypedReferenceableInstance instance = repository.getEntityDefinition(guid);
        return instance;
    }
581590
private void initializeSFSBInitMethodMap(BeanMetaData bmd, Method[] methods) throws EJBConfigurationException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        String ejbName = bmd.enterpriseBeanName;

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

        // Get the init-method from ejb-jar.xml if there is an ejb-jar.xml file.
        // Note, eb is set to null if there is no ejb-jar.xml file.
        List<InitMethod> initList = null;
        EnterpriseBean eb = bmd.wccm.enterpriseBean;
        if (eb != null) {
            // Get init-method list for this Session bean from WCCM and process.
            Session sb = (Session) eb;
            List<InitMethod> imList = sb.getInitMethod();
            initList = imList;
        }

        // Populate HashMap of all of the Init methods for SFSB.
        HashMap<String, String> map = new HashMap<String, String>();
        boolean isSessionBean = (SessionBean.class).isAssignableFrom(bmd.enterpriseBeanClass);
        if (isSessionBean) {
            // The bean is written to EJB 2.1 API or earlier, so the ejbCreate<METHOD> are the
            // only methods that can be annotated as a Init method, but is not required
            // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
            // in the EJB 3 core specifications.
            String ejbCreate = "ejbCreate";
            int ejbCreateLength = ejbCreate.length();

            // Process any init-method from ejb-jar.xml file and verify an init-method
            // provided only specifies a ejbCreate method name.
            if (initList != null) {
                if (isTraceOn && tc.isDebugEnabled()) {
                    Tr.debug(tc, "verify init-method is for ejbCreate of bean written to EJB 2.1 API");
                }

                // Verify an init-method provided only specifies a ejbCreate method name.
                for (InitMethod im : initList) {
                    // Get SFSB method name and verify it is ejbCreate. Don't bother with
                    // verifying whether method exists by signature specified. The code
                    // below automatically treats all ejbCreate methods as an init method.
                    // The JITDeploy code has to match up method signature of the init-method
                    // with the create method on the home.  It will provide an error message if
                    // signature does not match.
                    String method = im.getBeanMethod().getMethodName();
                    if (!ejbCreate.equals(method)) {
                        // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                        // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                        // cannot be applied to the {0} method of the {1} enterprise bean.
                        Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                        Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                        throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                            "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it " +
                                                            "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                    }
                }
            }

            // For each public method of the bean.
            if (isTraceOn && tc.isDebugEnabled()) {
                Tr.debug(tc, "processing public ejbCreate methods written to EJB 2.1 API");
            }

            for (Method m : methods) {
                // Is the method a ejbCreate<METHOD>?
                String methodName = m.getName();
                if (methodName.startsWith(ejbCreate)) {
                    // It is a ejbCreate<METHOD>, so insert a map entry using
                    // create<METHOD> + JDIMethodSignature as the key and
                    // METHOD as the value.
                    String key;
                    if (methodName.length() <= ejbCreateLength) {
                        key = "create" + MethodAttribUtils.jdiMethodSignature(m);
                    } else {
                        String suffix = methodName.substring(ejbCreateLength);
                        key = "create" + suffix + MethodAttribUtils.jdiMethodSignature(m);
                    }

                    map.put(key, m.getName());
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "added key: " + key
                                     + ", for method name = " + m.getName());
                    }
                } else {
                    // Don't bother to look for annotations if all config data
                    // came from xml.
                    if (!bmd.metadataComplete) {
                        // The bean is written to EJB 3 API,  or earlier, so the ejbCreate<METHOD> are the
                        // only methods that can be annotated as a Init method, but is not required
                        // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
                        // in the EJB 3 core specifications.
                        // Not a ejbCreate<METHOD>.  Verify it is not annotated as a Init method.
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {

                            // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                            // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                            // cannot be applied to the {0} method of the {1} enterprise bean.
                            String method = m.toGenericString();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                            throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                                "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it "
                                                                +
                                                                "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                        }
                    } else {
                        if (isTraceOn && tc.isDebugEnabled()) {
                            Tr.debug(tc, "metadata complete, skipping Init annotations");
                        }
                    }
                }
            }
        } else {
            // The bean is written to EJB 3 API, so any method can be annotated as an Init method.
            // We only need to populate the HashMap if the EJB 3 bean has either a remote or
            // local home interface. If it has neither,  Init method will never be called,
            // so do not bother populating the map in that case.
            if (bmd.homeInterfaceClass != null || bmd.localHomeInterfaceClass != null) {
                // We have a remote or local home interface, so we need process init methods.
                // Always process any init-method from ejb-jar.xml file.
                if (initList != null) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing init-method from ejb-jar.xml for bean written to EJB 3.0 API");
                    }
                    for (InitMethod im : initList) {
                        // Attempt to find Method object for the InitMethod.
                        NamedMethod namedMethod = im.getBeanMethod();
                        Method m = DDUtil.findMethod(namedMethod, methods);

                        // Method found for InitMethod?
                        if (m == null) {
                            // CNTR0236E: The {1} enterprise bean has an init-method element, which specifies
                            //  the {0} method. This method is not a public method of this bean.
                            String method = namedMethod.getMethodName();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INIT_METHOD_NOT_FOUND_CNTR0236E", data);
                            throw new EJBConfigurationException("CNTR0236E: The " + bmd.enterpriseBeanName + " enterprise bean has an init-method element, which " +
                                                                "specifies the " + method + " method. This method is not a public method of this bean.");
                        } else {
                            // Method found. Create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = im.getCreateMethod().getMethodName();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                }

                // Don't bother to look for annotations if all config data
                // came from xml.
                if (!bmd.metadataComplete) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing Init annotations for bean written to EJB 3.0 API");
                    }

                    // Not metadata-complete, so we need to process all public methods
                    // to look for Init annotation.
                    for (Method m : methods) {
                        // Is this method annotated as an Init method?
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {
                            // Yes it is, so create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = initMethod.value();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                } else {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "metadata complete, skipping Init annotations for bean written to EJB 3.0 API");
                    }
                }
            }
        }

        // Put map in BeanMetaData if map is not empty. Otherwise, leave BMD
        // set to null.
        if (!map.isEmpty()) {
            bmd.ivInitMethodMap = map;
        }

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

    }
394018
private static Map<String, String> findServiceBeanDefinitions(ConfigurableListableBeanFactory beanFactory) {
		final Map<String, String> serviceBeanNames = new HashMap<>();
		for (String beanName : beanFactory.getBeanDefinitionNames()) {
			JsonRpcService jsonRpcPath = beanFactory.findAnnotationOnBean(beanName, JsonRpcService.class);
			if (hasServiceAnnotation(jsonRpcPath)) {
				String pathValue = jsonRpcPath.value();
				logger.debug("Found JSON-RPC path '{}' for bean [{}].", pathValue, beanName);
				if (isNotDuplicateService(serviceBeanNames, beanName, pathValue))
					serviceBeanNames.put(pathValue, beanName);
			}
		}
		collectFromParentBeans(beanFactory, serviceBeanNames);
		return serviceBeanNames;
	}
73116
private com.buschmais.xo.spi.reflection.AnnotatedElement<?> getRelationDefinitionElement(PropertyMethod propertyMethod) {
        if (propertyMethod.getByMetaAnnotationOfProperty(RelationDefinition.class) != null) {
            return propertyMethod;
        }
        Annotation[] declaredAnnotations = propertyMethod.getAnnotationsOfProperty();
        for (int i = 0; i < declaredAnnotations.length; i++) {
            com.buschmais.xo.spi.reflection.AnnotatedElement<?> annotationTypeElement = new AnnotatedType(declaredAnnotations[i].annotationType());
            if (annotationTypeElement.getByMetaAnnotation(RelationDefinition.class) != null) {
                return annotationTypeElement;
            }
        }
        return propertyMethod;
    }
664808
@Nullable
    protected <T> BeanRegistration<T> getActiveBeanRegistration(BeanDefinition<T> beanDefinition, Qualifier qualifier) {
        if (beanDefinition == null) {
            return null;
        }
        return singletonObjects.get(new BeanKey(beanDefinition, qualifier));
    }
959901
JsonObject getDefinitions() {
        final JsonObjectBuilder builder = Json.createObjectBuilder();
        jsonDefinitions.entrySet().stream().sorted(mapKeyComparator()).forEach(e -> builder.add(e.getKey(), e.getValue().getRight()));
        return builder.build();
    }
430231
public static void traceEJBCallEntry(String methodDesc)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
        {
            StringBuffer sbuf = new StringBuffer();

            sbuf
                            .append(BeanLifeCycle_EJBCallEntry_Type_Str).append(DataDelimiter)
                            .append(BeanLifeCycle_EJBCallEntry_Type).append(DataDelimiter)
                            .append(methodDesc);

            Tr.debug(tc, sbuf.toString());
        }
    }
800178
private MethodDeclaration generateToBuilderMethod(String builderClassName, String builderImplClassName, EclipseNode type, TypeParameter[] typeParams, ASTNode source) {
		int pS = source.sourceStart, pE = source.sourceEnd;
		long p = (long) pS << 32 | pE;
		
		MethodDeclaration out = new MethodDeclaration(((CompilationUnitDeclaration) type.top().get()).compilationResult);
		out.selector = TO_BUILDER_METHOD_NAME;
		out.modifiers = ClassFileConstants.AccPublic;
		out.bits |= ECLIPSE_DO_NOT_TOUCH_FLAG;
		
		TypeReference[] wildcards = new TypeReference[] {new Wildcard(Wildcard.UNBOUND), new Wildcard(Wildcard.UNBOUND) };
		out.returnType = new ParameterizedSingleTypeReference(builderClassName.toCharArray(), mergeToTypeReferences(typeParams, wildcards), 0, p);
		
		AllocationExpression newClass = new AllocationExpression();
		newClass.type = namePlusTypeParamsToTypeReference(builderImplClassName.toCharArray(), typeParams, p);
		MessageSend invokeFillMethod = new MessageSend();
		invokeFillMethod.receiver = newClass;
		invokeFillMethod.selector = FILL_VALUES_METHOD_NAME;
		invokeFillMethod.arguments = new Expression[] {new ThisReference(0, 0)};
		out.statements = new Statement[] {new ReturnStatement(invokeFillMethod, pS, pE)};
		
		out.traverse(new SetGeneratedByVisitor(source), ((TypeDeclaration) type.get()).scope);
		return out;
	}
297624
public static void getAnnotationCMCLockType(LockType[] lockType, Method[] ejbMethods, BeanMetaData bmd)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
        {
            Tr.entry(tc, "getAnnotationCMCLockType: "
                         + " methods = " + Arrays.toString(ejbMethods)); //F743-7027.1
        }

        LockType methodLockType = null;
        boolean metadataComplete = bmd.metadataComplete;

        // For each of the business methods, determine the lock type
        // value to use if not already set by the ejb-jar.xml processing.
        for (int i = 0; i < ejbMethods.length; i++)
        {
            Method beanMethod = ejbMethods[i];

            // Only use the value from annotations if it is not already set
            // from value in ejb-jar.xml (e.g. obtained via WCCM).
            methodLockType = lockType[i];
            if (methodLockType == null)
            {
                // ejb-jar.xml did not contain the lock type for this method.
                // Metadata complete in XML?
                if (metadataComplete)
                {
                    // metadata complete is true in ejb-jar.xml file, so use the default value for LockType.
                    methodLockType = LockType.WRITE;
                }
                else
                {
                    // metadata complete is false, so see if there is a @Lock annotation on this method.
                    Lock annotation = beanMethod.getAnnotation(Lock.class);
                    if (annotation == null)
                    {
                        // No @Lock annotation on method, see if there is one at class level of
                        // the class that declared this method object.
                        Class<?> c = beanMethod.getDeclaringClass();
                        annotation = c.getAnnotation(Lock.class);

                        if (isTraceOn && tc.isDebugEnabled() && annotation != null)
                        {
                            Tr.debug(tc, beanMethod.getName() + " from class " + c.getName());
                        }
                    }

                    // Did we find a @Lock annotation at method or class level?
                    if (annotation == null)
                    {
                        // no @Lock annotation found, so use default lock type.
                        methodLockType = LockType.WRITE;
                    }
                    else
                    {
                        // there is a @Lock annotation, so use it.
                        methodLockType = annotation.value();
                    }

                } // end if ( metadataComplete )

                // Set the lock type for this method as determined by above logic.
                lockType[i] = methodLockType; //F743-1752CodRev

                if (isTraceOn && tc.isDebugEnabled())
                {
                    Tr.debug(tc, beanMethod.getName() + " = " + methodLockType);
                }

            } // end if ( methodLockType == null )
            else
            {
                // The ejb-jar.xml did specify a lock type for this method. Check
                // to see if overriding an explicit lock ty0e specified by the
                // Bean Provider via annotation.  EJB spec that DD should not
                // override an explicitly provided value by Bean Provider, but
                // we can not tell whether DD is from Bean Provider vs application
                // assembler.  Even if application assembler, it could be Bean Provider
                // is fixing an application error via the DD rather than changing the
                // annotations. So we will doing nothing more that trace the fact
                // that it occured.
                boolean traceEnabled = isTraceOn && (tcDebug.isDebugEnabled() || tc.isDebugEnabled());
                if (traceEnabled)
                {
                    // Is there an annotation for this method to use?
                    Lock annotation = beanMethod.getAnnotation(Lock.class);
                    if (annotation == null)
                    {
                        // No, is one specified at declaring class level for this method?
                        Class<?> c = beanMethod.getDeclaringClass();
                        annotation = c.getAnnotation(Lock.class);
                    }

                    // If an annotation for lock type was specified and it was overridden by DD to
                    // be a different value, then we want to trace that it was changed since it could
                    // potentially be causing an application failure.  It could also be fixing an
                    // application error, which is why we only trace the occurance.
                    if (annotation != null && (annotation.value().equals(methodLockType) == false))
                    {
                        // Change in lock type, build a warning message and trace it.
                        String msg;
                        if (methodLockType == LockType.WRITE)
                        {
                            msg = "ejb-jar.xml is overriding a @Lock(READ) with a write lock. This may cause a deadlock to occur.";
                        }
                        else
                        {
                            msg = "ejb-jar.xml is overriding a @Lock(WRITE) with a read lock. This may cause data integrity problems.";
                        }
                        StringBuilder sb = new StringBuilder();
                        sb.append("warning, for the ").append(beanMethod.toString()).append(" method, the ").append(msg);

                        if (tcDebug.isDebugEnabled())
                        {
                            Tr.debug(tcDebug, sb.toString());
                        }
                        else
                        {
                            Tr.debug(tc, sb.toString());
                        }
                    }
                }
            }
        } // end for

        if (isTraceOn && tc.isEntryEnabled())
        {
            Tr.exit(tc, "getAnnotationCMCLockType", Arrays.toString(lockType));
        }
    }