org.apache.xbean.recipe.Option Java Examples

@Override
public <T> T create(final Class<T> aClass) {
    if (recipe
            .getProperties()
            .keySet()
            .stream()
            .map(it -> it.toLowerCase(ROOT))
            .collect(toSet())
            .size() == recipe.getProperties().size()) {
        recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    }
    try {
        return aClass.cast(recipe.create(Thread.currentThread().getContextClassLoader()));
    } catch (final RuntimeException re) {
        throw new IllegalArgumentException(re);
    }
}
 

public static Object build(final Collection<ServiceInfo> services, final ServiceInfo info, final ObjectRecipe serviceRecipe) {
    if ("org.apache.openejb.config.sys.MapFactory".equals(info.className)) {
        return info.properties;
    }

    if (!info.properties.containsKey("properties")) {
        info.properties.put("properties", new UnsetPropertiesRecipe());
    }

    // we can't ask for having a setter for existing code
    serviceRecipe.allow(Option.FIELD_INJECTION);
    serviceRecipe.allow(Option.PRIVATE_PROPERTIES);

    setProperties(services, info, serviceRecipe);

    final Object service = serviceRecipe.create();

    SystemInstance.get().addObserver(service); // TODO: remove it? in all case the observer should remove itself when done
    Assembler.logUnusedProperties(serviceRecipe, info);

    return service;
}
 

@Override
public void injectJavaEEResources(final Object managedBeanInstance) {
    if (managedBeanInstance == null) {
        return;
    }

    final Class<?> managedBeanInstanceClass = managedBeanInstance.getClass();
    if (ejbPlugin.isSessionBean(managedBeanInstanceClass)) { // already done
        return;
    }

    final ObjectRecipe receipe = PassthroughFactory.recipe(managedBeanInstance);
    receipe.allow(Option.FIELD_INJECTION);
    receipe.allow(Option.PRIVATE_PROPERTIES);
    receipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    receipe.allow(Option.NAMED_PARAMETERS);

    fillInjectionProperties(receipe, managedBeanInstance);

    receipe.create();
}
 

@Override
public ObjectFactoryInstance withProperties(final Map<String, ?> map) {
    if (recipe.getOptions().contains(Option.FIELD_INJECTION)
            && recipe.getOptions().contains(Option.PRIVATE_PROPERTIES)) {
        map.forEach(recipe::setFieldProperty);
    } else {
        recipe.setAllProperties(map);
    }
    return this;
}
 

private void createANewDelegate() {
    final CommonDataSource old = delegate.get();
    try {
        final ObjectRecipe recipe = new ObjectRecipe(DataSourceFactory.class.getName(), "create", FACTORY_ARGS);
        recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
        recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
        recipe.allow(Option.NAMED_PARAMETERS);
        recipe.allow(Option.PRIVATE_PROPERTIES);
        recipe.setAllProperties(config.properties);

        recipe.setProperty("resettableHandler", resettableHandler);
        recipe.setProperty("flushableHandler", this);

        updateDataSource(CommonDataSource.class.cast(recipe.create()));
    } catch (final Exception e) {
        LOGGER.error("Can't recreate the datasource, keeping old one", e);
        return;
    }

    if (DataSourceFactory.knows(old)) {
        try {
            DataSourceFactory.destroy(old);
        } catch (final Throwable t) {
            //Ignore
        }
    }
}
 

public static ObjectRecipe prepareRecipe(final ServiceInfo info) {
    final String[] constructorArgs = info.constructorArgs.toArray(new String[info.constructorArgs.size()]);
    final ObjectRecipe serviceRecipe = new ObjectRecipe(info.className, info.factoryMethod, constructorArgs, null);
    serviceRecipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    serviceRecipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    serviceRecipe.allow(Option.PRIVATE_PROPERTIES);
    return serviceRecipe;
}
 

private ObjectRecipe newObjectRecipe(final String template) {
    final ObjectRecipe recipe = new ObjectRecipe(template);
    recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    recipe.allow(Option.PRIVATE_PROPERTIES);
    recipe.allow(Option.FIELD_INJECTION);
    recipe.allow(Option.NAMED_PARAMETERS);
    recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    return recipe;
}
 

public static Object createMeFromSystemProps(final String prefix, final String suffix, final Class<?> clazz) {
    final Properties props = SystemInstance.get().getProperties();
    final Map<String, Object> usedOnes = new HashMap<>();

    for (final Map.Entry<Object, Object> entry : props.entrySet()) {
        final String key = entry.getKey().toString();
        if (prefix != null && !key.startsWith(prefix)) {
            continue;
        }
        if (suffix != null && !key.endsWith(suffix)) {
            continue;
        }

        String newKey = key;
        if (prefix != null) {
            newKey = newKey.substring(prefix.length());
        }
        if (suffix != null) {
            newKey = newKey.substring(0, newKey.length() - suffix.length());
        }
        usedOnes.put(newKey, entry.getValue());
    }

    final ObjectRecipe recipe = new ObjectRecipe(clazz);
    recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    recipe.allow(Option.PRIVATE_PROPERTIES);
    recipe.allow(Option.FIELD_INJECTION);
    recipe.allow(Option.NAMED_PARAMETERS);
    recipe.setAllProperties(usedOnes);
    return recipe.create();
}
 

private void buildCache() throws Exception {
    if (properties == null) {
        throw new IllegalArgumentException("No cache defined for StatefulContainer " + id);
    }

    // get the cache property
    Object cache = getProperty("Cache");
    if (cache == null) {
        throw new IllegalArgumentException("No cache defined for StatefulContainer " + id);
    }

    // if property contains a live cache instance, just use it
    if (cache instanceof Cache) {
        this.cache = (Cache<Object, Instance>) cache;
        return;
    }

    // build the object recipe
    final ObjectRecipe serviceRecipe = new ObjectRecipe((String) cache);
    serviceRecipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    serviceRecipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    serviceRecipe.allow(Option.NAMED_PARAMETERS);
    serviceRecipe.setAllProperties(properties);

    // invoke recipe
    /* the cache should be created with container loader to avoid memory leaks
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    if (classLoader == null) getClass().getClassLoader();
    */
    ClassLoader classLoader = StatefulContainerFactory.class.getClassLoader();
    if (!((String) cache).startsWith("org.apache.tomee")) { // user impl?
        classLoader = Thread.currentThread().getContextClassLoader();
    }
    cache = serviceRecipe.create(classLoader);

    // assign value
    this.cache = (Cache<Object, Instance>) cache;
}
 

@Override
public ObjectFactoryInstance withFieldInjection() {
    recipe.allow(Option.FIELD_INJECTION);
    recipe.allow(Option.PRIVATE_PROPERTIES);
    return this;
}
 

@Override
public ObjectFactoryInstance withoutFieldInjection() {
    recipe.disallow(Option.FIELD_INJECTION);
    return this;
}
 

@Override
public ObjectFactoryInstance ignoreUnknownProperties() {
    recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
    return this;
}
 

private static ObjectRecipe newRecipe(final String clazz) {
    final ObjectRecipe recipe = new ObjectRecipe(clazz);
    recipe.allow(Option.FIELD_INJECTION);
    recipe.allow(Option.PRIVATE_PROPERTIES);
    return recipe;
}
 

private static ObjectRecipe newRecipe(final String clazz) {
    final ObjectRecipe recipe = new ObjectRecipe(clazz);
    recipe.allow(Option.FIELD_INJECTION);
    recipe.allow(Option.PRIVATE_PROPERTIES);
    return recipe;
}
 

public static void main(final String[] args) throws Exception {
    if (args.length != 1) {
        System.err.println("Pass the base url as parameter");
        return;
    }

    final ConsoleReader reader = new ConsoleReader(System.in, new OutputStreamWriter(System.out));
    reader.addCompletor(new FileNameCompletor());
    reader.addCompletor(new SimpleCompletor(CommandManager.keys().toArray(new String[CommandManager.size()])));

    String line;
    while ((line = reader.readLine(PROMPT)) != null) {
        if (EXIT_CMD.equals(line)) {
            break;
        }

        Class<?> cmdClass = null;
        for (Map.Entry<String, Class<?>> cmd : CommandManager.getCommands().entrySet()) {
            if (line.startsWith(cmd.getKey())) {
                cmdClass = cmd.getValue();
                break;
            }
        }

        if (cmdClass != null) {
            final ObjectRecipe recipe = new ObjectRecipe(cmdClass);
            recipe.setProperty("url", args[0]);
            recipe.setProperty("command", line);
            recipe.setProperty("commands", CommandManager.getCommands());

            recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
            recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
            recipe.allow(Option.NAMED_PARAMETERS);

            try {
                final AbstractCommand cmdInstance = (AbstractCommand) recipe.create();
                cmdInstance.execute(line);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            System.err.println("sorry i don't understand '" + line + "'");
        }
    }
}
 

private void recipeOptions(final ObjectRecipe recipe) { // important to not set "properties" attribute because pools often use it for sthg else
    recipe.allow(Option.CASE_INSENSITIVE_PROPERTIES);
    recipe.allow(Option.IGNORE_MISSING_PROPERTIES);
}