/** * 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); } }