Examples with ObjectFactory javax.naming.spi.ObjectFactory used on opensource projects

Example 56 with ObjectFactory

use of javax.naming.spi.ObjectFactory in project tomcat by apache.

the class EjbFactory method getDefaultFactory.

@Override
protected ObjectFactory getDefaultFactory(Reference ref) throws NamingException {
    ObjectFactory factory;
    String javaxEjbFactoryClassName = System.getProperty("jakarta.ejb.Factory", Constants.OPENEJB_EJB_FACTORY);
    try {
        factory = (ObjectFactory) Class.forName(javaxEjbFactoryClassName).getConstructor().newInstance();
    } catch (Throwable t) {
        if (t instanceof NamingException) {
            throw (NamingException) t;
        }
        if (t instanceof ThreadDeath) {
            throw (ThreadDeath) t;
        }
        if (t instanceof VirtualMachineError) {
            throw (VirtualMachineError) t;
        }
        NamingException ex = new NamingException("Could not create resource factory instance");
        ex.initCause(t);
        throw ex;
    }
    return factory;
}

Example 57 with ObjectFactory

use of javax.naming.spi.ObjectFactory in project tomcat by apache.

the class FactoryBase method getObjectInstance.

/**
 * Creates a new object instance.
 *
 * @param obj The reference object describing the object to create
 */
@Override
public final Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
    if (isReferenceTypeSupported(obj)) {
        Reference ref = (Reference) obj;
        Object linked = getLinked(ref);
        if (linked != null) {
            return linked;
        }
        ObjectFactory factory = null;
        RefAddr factoryRefAddr = ref.get(Constants.FACTORY);
        if (factoryRefAddr != null) {
            // Using the specified factory
            String factoryClassName = factoryRefAddr.getContent().toString();
            // Loading factory
            ClassLoader tcl = Thread.currentThread().getContextClassLoader();
            Class<?> factoryClass = null;
            try {
                if (tcl != null) {
                    factoryClass = tcl.loadClass(factoryClassName);
                } else {
                    factoryClass = Class.forName(factoryClassName);
                }
            } catch (ClassNotFoundException e) {
                NamingException ex = new NamingException(sm.getString("factoryBase.factoryClassError"));
                ex.initCause(e);
                throw ex;
            }
            try {
                factory = (ObjectFactory) factoryClass.getConstructor().newInstance();
            } catch (Throwable t) {
                if (t instanceof NamingException) {
                    throw (NamingException) t;
                }
                if (t instanceof ThreadDeath) {
                    throw (ThreadDeath) t;
                }
                if (t instanceof VirtualMachineError) {
                    throw (VirtualMachineError) t;
                }
                NamingException ex = new NamingException(sm.getString("factoryBase.factoryCreationError"));
                ex.initCause(t);
                throw ex;
            }
        } else {
            // Check for a default factory
            factory = getDefaultFactory(ref);
        }
        if (factory != null) {
            return factory.getObjectInstance(obj, name, nameCtx, environment);
        } else {
            throw new NamingException(sm.getString("factoryBase.instanceCreationError"));
        }
    }
    return null;
}

Example 58 with ObjectFactory

use of javax.naming.spi.ObjectFactory in project tomcat by apache.

the class LookupFactory method getObjectInstance.

/**
 * Create a new Resource env instance.
 *
 * @param obj The reference object describing the DataSource
 */
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
    String lookupName = null;
    Object result = null;
    if (obj instanceof LookupRef) {
        Reference ref = (Reference) obj;
        ObjectFactory factory = null;
        RefAddr lookupNameRefAddr = ref.get(LookupRef.LOOKUP_NAME);
        if (lookupNameRefAddr != null) {
            lookupName = lookupNameRefAddr.getContent().toString();
        }
        try {
            if (lookupName != null) {
                if (!names.get().add(lookupName)) {
                    String msg = sm.getString("lookupFactory.circularReference", lookupName);
                    NamingException ne = new NamingException(msg);
                    log.warn(msg, ne);
                    throw ne;
                }
            }
            RefAddr factoryRefAddr = ref.get(Constants.FACTORY);
            if (factoryRefAddr != null) {
                // Using the specified factory
                String factoryClassName = factoryRefAddr.getContent().toString();
                // Loading factory
                ClassLoader tcl = Thread.currentThread().getContextClassLoader();
                Class<?> factoryClass = null;
                if (tcl != null) {
                    try {
                        factoryClass = tcl.loadClass(factoryClassName);
                    } catch (ClassNotFoundException e) {
                        NamingException ex = new NamingException(sm.getString("lookupFactory.loadFailed"));
                        ex.initCause(e);
                        throw ex;
                    }
                } else {
                    try {
                        factoryClass = Class.forName(factoryClassName);
                    } catch (ClassNotFoundException e) {
                        NamingException ex = new NamingException(sm.getString("lookupFactory.loadFailed"));
                        ex.initCause(e);
                        throw ex;
                    }
                }
                if (factoryClass != null) {
                    try {
                        factory = (ObjectFactory) factoryClass.getConstructor().newInstance();
                    } catch (Throwable t) {
                        if (t instanceof NamingException) {
                            throw (NamingException) t;
                        }
                        NamingException ex = new NamingException(sm.getString("lookupFactory.createFailed"));
                        ex.initCause(t);
                        throw ex;
                    }
                }
            }
            // Note: No defaults here
            if (factory != null) {
                result = factory.getObjectInstance(obj, name, nameCtx, environment);
            } else {
                if (lookupName == null) {
                    throw new NamingException(sm.getString("lookupFactory.createFailed"));
                } else {
                    result = new InitialContext().lookup(lookupName);
                }
            }
            Class<?> clazz = Class.forName(ref.getClassName());
            if (result != null && !clazz.isAssignableFrom(result.getClass())) {
                String msg = sm.getString("lookupFactory.typeMismatch", name, ref.getClassName(), lookupName, result.getClass().getName());
                NamingException ne = new NamingException(msg);
                log.warn(msg, ne);
                // Close the resource we no longer need if we know how to do so
                if (result instanceof AutoCloseable) {
                    try {
                        ((AutoCloseable) result).close();
                    } catch (Exception e) {
                    // Ignore
                    }
                }
                throw ne;
            }
        } finally {
            names.get().remove(lookupName);
        }
    }
    return result;
}

Example 59 with ObjectFactory

use of javax.naming.spi.ObjectFactory in project tomcat by apache.

the class NamingContext method lookup.

/**
 * Retrieves the named object.
 *
 * @param name the name of the object to look up
 * @param resolveLinks If true, the links will be resolved
 * @return the object bound to name
 * @exception NamingException if a naming exception is encountered
 */
protected Object lookup(Name name, boolean resolveLinks) throws NamingException {
    // Removing empty parts
    while ((!name.isEmpty()) && (name.get(0).length() == 0)) {
        name = name.getSuffix(1);
    }
    if (name.isEmpty()) {
        // If name is empty, a newly allocated naming context is returned
        return new NamingContext(env, this.name, bindings);
    }
    NamingEntry entry = bindings.get(name.get(0));
    if (entry == null) {
        throw new NameNotFoundException(sm.getString("namingContext.nameNotBound", name, name.get(0)));
    }
    if (name.size() > 1) {
        // number of subcontexts.
        if (entry.type != NamingEntry.CONTEXT) {
            throw new NamingException(sm.getString("namingContext.contextExpected"));
        }
        return ((Context) entry.value).lookup(name.getSuffix(1));
    } else {
        if ((resolveLinks) && (entry.type == NamingEntry.LINK_REF)) {
            String link = ((LinkRef) entry.value).getLinkName();
            if (link.startsWith(".")) {
                // Link relative to this context
                return lookup(link.substring(1));
            } else {
                return new InitialContext(env).lookup(link);
            }
        } else if (entry.type == NamingEntry.REFERENCE) {
            try {
                Object obj = null;
                if (!GRAAL) {
                    obj = NamingManager.getObjectInstance(entry.value, name, this, env);
                } else {
                    // NamingManager.getObjectInstance would simply return the reference here
                    // Use the configured object factory to resolve it directly if possible
                    // Note: This may need manual constructor reflection configuration
                    Reference reference = (Reference) entry.value;
                    Class<?> factoryClass = getClass().getClassLoader().loadClass(reference.getFactoryClassName());
                    ObjectFactory factory = (ObjectFactory) factoryClass.getDeclaredConstructor().newInstance();
                    obj = factory.getObjectInstance(entry.value, name, this, env);
                }
                if (entry.value instanceof ResourceRef) {
                    boolean singleton = Boolean.parseBoolean((String) ((ResourceRef) entry.value).get("singleton").getContent());
                    if (singleton) {
                        entry.type = NamingEntry.ENTRY;
                        entry.value = obj;
                    }
                }
                if (obj == null) {
                    throw new NamingException(sm.getString("namingContext.failResolvingReference"));
                }
                return obj;
            } catch (NamingException e) {
                throw e;
            } catch (Exception e) {
                String msg = sm.getString("namingContext.failResolvingReference");
                log.warn(msg, e);
                NamingException ne = new NamingException(msg);
                ne.initCause(e);
                throw ne;
            }
        } else {
            return entry.value;
        }
    }
}