<p>getBeanTypeByName.</p>

@param className a {@link java.lang.String} object.
@param server    a {@link io.ebeaninternal.api.SpiEbeanServer} object.
@return a {@link java.lang.Class} object.
13771
public static Class getBeanTypeByName(String className, SpiEbeanServer server) {
        if (className == null) return null;
        for (BeanDescriptor descriptor : server.getBeanDescriptors()) {
            Class beanClass = descriptor.getBeanType();
            if (beanClass.getName().equalsIgnoreCase(className)
                    || beanClass.getSimpleName().equalsIgnoreCase(className)) {
                return beanClass;
            }
        }
        return null;
    }
1051956
public Class getClassForName(final String className) {
        try {
            final OsgiRegistry osgiRegistry = ReflectionHelper.getOsgiRegistryInstance();

            if (osgiRegistry != null) {
                return osgiRegistry.classForNameWithException(className);
            } else {
                return AccessController.doPrivileged(ReflectionHelper.classForNameWithExceptionPEA(className));
            }
        } catch (final ClassNotFoundException ex) {
            throw new RuntimeException(LocalizationMessages.ERROR_SCANNING_CLASS_NOT_FOUND(className), ex);
        } catch (final PrivilegedActionException pae) {
            final Throwable cause = pae.getCause();
            if (cause instanceof ClassNotFoundException) {
                throw new RuntimeException(LocalizationMessages.ERROR_SCANNING_CLASS_NOT_FOUND(className), cause);
            } else if (cause instanceof RuntimeException) {
                throw (RuntimeException) cause;
            } else {
                throw new RuntimeException(cause);
            }
        }
    }
1087880
def get_jclass(classname):
    
    try:
        return javabridge.class_for_name(classname)
    except:
        return javabridge.static_call(
            "Lweka/core/ClassHelper;", "forName",
            "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Class;",
            javabridge.class_for_name("java.lang.Object"), classname)
782310
public <T> T getBean(K key, Class<T> beanType) {
		final JSONObject obj = getJSONObject(key);
		return (null == obj) ? null : obj.toBean(beanType);
	}
586595
public static Class<?> loadClassByName(String className) throws ClassNotFoundException {
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            return Thread.currentThread().getContextClassLoader().loadClass(className);
        }
    }
1318461
public static ClassName className(String className) {
		int index = className.lastIndexOf(".");
		if (index > 0) {
			return classNameWithSuffix(className.substring(0, index), className.substring(index + 1), "");
		}
		return ClassName.get("", className);

	}
302185
public String[] getDeviceList(final String serverName, final String className) {
        String[] result = new String[0];
        final Server server = servers.get(serverName);
        if (server != null) {
            final String[] devices = server.getDevices(className);
            if (devices != null) {
                result = Arrays.copyOf(devices, devices.length);
            }
        }
        return result;
    }
66385
public final SgClass get(final String className) {
        if (className == null) {
            throw new IllegalArgumentException("The argument 'className' cannot be null!");
        }
        return cache.get(className);
    }
286562
@SuppressWarnings("unchecked")
	public <T> T getInstance(Class<T> beanClass) {
		String[] beanNames = applicationContext.getBeanNamesForType(beanClass);
		if (beanNames.length == 0) {
			return null;
		}
		return (T) applicationContext.getBean(beanNames[0]);
	}
785209
String getClassName(String name) {
        char[] s = new char[name.length()+1];
        char c;
        int j = 0;

        if (!Character.isJavaIdentifierStart(name.charAt(0))) {
            s[j++] = '_';
        }
        for (int i=0; i < name.length(); i++, j++) {
            c = name.charAt(i);
            if ( Character.isJavaIdentifierPart(c) ) {
                s[j] = c;
            } else {
                s[j] = '_';
            }
        }
        return (new String(s)).trim();
     }
1294141
public static Class<?> getClass(ClassLoader classLoader, String className) {
        try {

            final Class<?> clazz;

            if (PRIMITIVE_MAPPING.containsKey(className)) {

                String qualifiedName = "[" + PRIMITIVE_MAPPING.get(className);
                clazz = Class.forName(qualifiedName, true, classLoader).getComponentType();
            } else {
                clazz = Class.forName(determineQualifiedName(className), true, classLoader);
            }
            return clazz;
        } catch (ClassNotFoundException ex) {

            int lastSeparatorIndex = className.lastIndexOf(PACKAGE_SEPARATOR_CHARACTER);

            if (lastSeparatorIndex != -1) {
                return getClass(classLoader, className.substring(0, lastSeparatorIndex) + INNER_CLASS_SEPARATOR_CHAR
                        + className.substring(lastSeparatorIndex + 1));
            }
            throw new IllegalArgumentException("Unable to unmarshall String to Class: " + className);
        }
    }
1022606
@SuppressWarnings("unchecked")
  public static Object getMBean(final Class c,
                                final String name) throws Throwable {
    final MBeanServer server = getMbeanServer();

//    return MBeanProxyExt.create(c, name, server);
    return JMX.newMBeanProxy(server, new ObjectName(name), c);
  }
1327260
String getJsInstancename(String classname) {
		char chars[] = classname.toCharArray();
		chars[0] = Character.toLowerCase(chars[0]);
		return new String(chars);
		//return Introspector.decapitalize(classname);
	}
1228995
public <T> T getBean(Class<T> beanType) throws BeansException {
        return beanType.cast(BeanFactoryUtils.beanOfTypeIncludingAncestors(this, beanType));
    }
975875
public String java(GeneratedPackage generatedPackage, String javaClassName) {
        generatedPackageRestriction(generatedPackage);
        return java(generatedPackage.getPackageName(), javaClassName);
    }
1355271
public <T> T getBean(@NonNull Class<T> cls) {
        return this.ioc.getBean(cls);
    }
1133869
@SuppressWarnings("unchecked")
    public static <E> E getObject(String className) {
        if (className == null) {
            return (E) null;
        }
        try {
            return (E) Class.forName(className).newInstance();
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }