How to use

getInstance

method

in

org.restlet.engine.Engine

/**
 * Returns the class object for the given name using the engine classloader.
 * 
 * @param className
 *            The class name to lookup.
 * @return The class object or null if the class was not found.
 * @see #getClassLoader()
 */
public static Class<?> loadClass(String className)
    throws ClassNotFoundException {
  return getInstance().getClassLoader().loadClass(className);
}

/**
 * Returns the classloader resource for a given name/path.
 * 
 * @param name
 *            The name/path to lookup.
 * @return The resource URL.
 */
public static java.net.URL getResource(String name) {
  return getInstance().getClassLoader().getResource(name);
}

private static void replaceConverter(
    Class<? extends ConverterHelper> converterClass,
    ConverterHelper newConverter) {
  // TODO java 8-ify
  List<ConverterHelper> converters = Engine.getInstance().getRegisteredConverters();
  for (ConverterHelper converter : converters) {
    if (converter.getClass().equals(converterClass)) {
      converters.remove(converter);
      break;
    }
  }
  converters.add(newConverter);
}

/**
 * Registers the helpers for a given bundle.
 * 
 * @param bundle
 *            The bundle to inspect.
 * @param helpers
 *            The helpers list to update.
 * @param constructorClass
 *            The class to use as constructor parameter.
 * @param descriptorUrl
 *            The descriptor URL to inspect.
 */
private void registerHelper(final Bundle bundle, List<?> helpers,
    Class<?> constructorClass, URL descriptorUrl) {
  Engine.getInstance().registerHelpers(new ClassLoader() {
    @Override
    public Class<?> loadClass(String name)
        throws ClassNotFoundException {
      return bundle.loadClass(name);
    }
  }, descriptorUrl, helpers, constructorClass);
}

/**
 * Returns an anonymous logger. By default it calls {@link #getLogger(String)} with a "" name.
 * 
 * @return The logger.
 */
public static Logger getAnonymousLogger() {
  return getInstance().getLoggerFacade().getAnonymousLogger();
}

/**
 * Returns a logger based on the given logger name.
 * 
 * @param loggerName
 *            The logger name.
 * @return The logger.
 */
public static Logger getLogger(String loggerName) {
  return getInstance().getLoggerFacade().getLogger(loggerName);
}

/**
 * Returns a logger based on the class name of the given object.
 * 
 * @param clazz
 *            The parent class.
 * @return The logger.
 */
public static Logger getLogger(Class<?> clazz) {
  return getInstance().getLoggerFacade().getLogger(clazz);
}

/**
 * Wraps the client resource to proxy calls to the given Java interface into
 * Restlet method calls. Use the {@link org.restlet.engine.Engine}
 * classloader in order to generate the proxy.
 * 
 * @param <T>
 * @param resourceInterface
 *            The annotated resource interface class to proxy.
 * @return The proxy instance.
 */
public <T> T wrap(Class<? extends T> resourceInterface) {
  return wrap(resourceInterface, org.restlet.engine.Engine.getInstance()
      .getClassLoader());
}

/**
 * Returns a logger based on the class name of the given object.
 * 
 * @param clazz
 *            The parent class.
 * @param defaultLoggerName
 *            The default logger name to use if no one can be inferred from
 *            the class.
 * @return The logger.
 */
public static Logger getLogger(Class<?> clazz, String defaultLoggerName) {
  return getInstance().getLoggerFacade().getLogger(clazz,
      defaultLoggerName);
}

/**
 * Returns a logger based on the class name of the given object.
 * 
 * @param object
 *            The parent object.
 * @param defaultLoggerName
 *            The default logger name to use if no one can be inferred from
 *            the object class.
 * @return The logger.
 */
public static Logger getLogger(Object object, String defaultLoggerName) {
  return getInstance().getLoggerFacade().getLogger(object,
      defaultLoggerName);
}

/**
 * Returns the list of object classes that can be converted from a given
 * variant.
 * 
 * @param source
 *            The source variant.
 * @return The list of object class that can be converted.
 */
public List<Class<?>> getObjectClasses(Variant source) {
  List<Class<?>> result = null;
  List<Class<?>> helperObjectClasses = null;
  for (ConverterHelper ch : Engine.getInstance()
      .getRegisteredConverters()) {
    helperObjectClasses = ch.getObjectClasses(source);
    if (helperObjectClasses != null) {
      if (result == null) {
        result = new ArrayList<Class<?>>();
      }
      result.addAll(helperObjectClasses);
    }
  }
  return result;
}

  /**
   * Wraps the client resource to proxy calls to the given Java interface into
   * Restlet method calls.
   * 
   * @param <T>
   * @param resourceInterface
   *            The annotated resource interface class to proxy.
   * @return The proxy instance.
   */
  @SuppressWarnings("unchecked")
  public <T> T wrap(Class<? extends T> resourceInterface) {
    T result = null;

    // Create the client resource proxy
    java.lang.reflect.InvocationHandler h = new org.restlet.ext.jaxrs.internal.client.JaxRsClientInvocationHandler<T>(
        this, resourceInterface);

    // Instantiate our dynamic proxy
    result = (T) java.lang.reflect.Proxy.newProxyInstance(
        org.restlet.engine.Engine.getInstance().getClassLoader(),
        new Class<?>[] { ClientProxy.class, resourceInterface }, h);

    return result;
  }
}

  /**
   * Updates the media type preferences with available conversion capabilities
   * for the given entity class.
   * 
   * @param preferences
   *            The media type preferences.
   * @param entity
   *            The entity class to convert.
   */
  public void updatePreferences(List<Preference<MediaType>> preferences,
      Class<?> entity) {
    for (ConverterHelper ch : Engine.getInstance()
        .getRegisteredConverters()) {
      ch.updatePreferences(preferences, entity);
    }
  }
}

  @Override
  public void onEvent(Event event, Object source, Object data)
  {
    for (ConverterHelper converter : Engine.getInstance().getRegisteredConverters()) {
      if (converter instanceof JacksonConverter) {
        JacksonConverter jconverter = (JacksonConverter) converter;
        jconverter.getObjectMapper().configure(Feature.WRITE_DATES_AS_TIMESTAMPS, false);
      }
    }
  }
}

/**
 * Registers the helpers for a given bundle.
 * 
 * @param bundle
 *            The bundle to inspect.
 */
private void registerHelpers(Bundle bundle) {
  // Register server helpers
  registerHelper(bundle, Engine.getInstance().getRegisteredServers(),
      Server.class, Engine.DESCRIPTOR_SERVER_PATH);
  // Register client helpers
  registerHelper(bundle, Engine.getInstance().getRegisteredClients(),
      Client.class, Engine.DESCRIPTOR_CLIENT_PATH);
  // Register authentication helpers
  registerHelper(bundle, Engine.getInstance()
      .getRegisteredAuthenticators(), null,
      Engine.DESCRIPTOR_AUTHENTICATOR_PATH);
  // Register converter helpers
  registerHelper(bundle, Engine.getInstance().getRegisteredConverters(),
      null, Engine.DESCRIPTOR_CONVERTER_PATH);
}

  @Override
  public void onEvent(Event event, Object source, Object data)
  {
    for (ConverterHelper converter : Engine.getInstance().getRegisteredConverters()) {
      if (converter instanceof JacksonConverter) {
        JacksonConverter jconverter = (JacksonConverter) converter;
        jconverter.getObjectMapper().setSerializationInclusion(Inclusion.NON_NULL);
      }
    }
  }
}

/**
 * Returns the best converter helper matching the given parameters.
 * 
 * @param <T>
 *            The target class.
 * @param source
 *            The source representation variant.
 * @param target
 *            The target class.
 * @param resource
 *            The parent resource.
 * @return The matched converter helper or null.
 */
public static <T> ConverterHelper getBestHelper(Representation source,
    Class<T> target, Resource resource) {
  ConverterHelper result = null;
  float bestScore = -1.0F;
  float currentScore;
  for (ConverterHelper ch : Engine.getInstance()
      .getRegisteredConverters()) {
    if (ch != null) {
      currentScore = ch.score(source, target, resource);
      if (currentScore > bestScore) {
        bestScore = currentScore;
        result = ch;
      }
    }
  }
  return result;
}

@Override
public void init() throws ServletException {
  String facade = getInitParameter(LOGGER_FACADE_ATTRIBUTE, LOGGER_FACADE_ATTRIBUTE_DEFAULT_VALUE);
  
  if (!Boolean.FALSE.toString().equalsIgnoreCase(facade)) {
    try {
      Class<?> facadeClass = Class.forName(facade);
      Engine.getInstance().setLoggerFacade((LoggerFacade) facadeClass.newInstance());
    } catch (ClassNotFoundException ex) {
      log("[Restlet] OntopiaServlet could not find logger facade class '" + facade + "'");
    } catch (InstantiationException ex) {
      log("[Restlet] OntopiaServlet could not instantiate logger facade of class '" + facade + "'");
    } catch (IllegalAccessException ex) {
      log("[Restlet] OntopiaServlet could not access logger facade class '" + facade + "'");
    }
  }
  
  super.init();
}

@Override
public void onEvent(Event event, Object source, Object data)
{
  for (ConverterHelper converter : Engine.getInstance().getRegisteredConverters()) {
    if (converter instanceof JacksonConverter) {
      JacksonConverter jconverter = (JacksonConverter) converter;
      SimpleModule m = new SimpleModule("org.json", new Version(1, 0, 0, null));
      m.addSerializer(JSONObject.class, new JSONObjectSerializer());
      m.addSerializer(JSONArray.class, new JSONArraySerializer());
      jconverter.getObjectMapper().registerModule(m);
    }
  }
}

/**
 * Constructor.
 */
public Component() {
  super();
  this.hosts = new CopyOnWriteArrayList<VirtualHost>();
  this.clients = new ClientList(null);
  this.servers = new ServerList(null, this);
  this.realms = new CopyOnWriteArrayList<Realm>();
  this.services = new ServiceList(getContext());
  if (Engine.getInstance() != null) {
    // To be done before setting the helper...
    this.services.add(new org.restlet.service.TaskService());
    this.helper = new ComponentHelper(this);
    Context childContext = getContext().createChildContext();
    this.defaultHost = new VirtualHost(childContext);
    this.internalRouter = new InternalRouter(childContext);
    this.services.add(new LogService());
    getLogService().setContext(childContext);
    this.services.add(new StatusService());
    getStatusService().setContext(childContext);
    this.clients.setContext(childContext);
    this.servers.setContext(childContext);
  }
}