[jira] [Commented] (FELIX-4614) Factory create() method should have access to the component definition

["Pierre De Rop (JIRA)" <ji...@apache.org>]

    [ https://issues.apache.org/jira/browse/FELIX-4614?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14112203#comment-14112203 ] 

Pierre De Rop commented on FELIX-4614:
--------------------------------------

In order to make sure I understand, can we discuss about the following example: for instance, assume that you want to create an aspect service as a java DynamicProxy.

To do so, you can use a Factory object instance with a create method, and that Factory has to hold the necessary informations in order to create the dynamic proxy (at least we need the aspect interface class, but the Factory could hold more data, if necessary, like a label in the following example):

{code}
public class Activator extends DependencyActivatorBase {  
    public static interface ServiceInterface {
        public void invoke();
    }
    
    public static class ServiceProvider implements ServiceInterface {
        public void invoke() {
            System.out.println("ServiceProvider.invoke");
        }
    }
    
    public static class ServiceConsumer  {
        volatile ServiceInterface m_service;
        public void start() {
            System.out.println("ServiceConsumer.start");
            m_service.invoke();
        }
    }

    static class AspectProxy implements InvocationHandler {
        private volatile ServiceInterface m_service;
        private final String m_label;
        
        public AspectProxy(String label) {
            m_label = label;
        }
        
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("AspectProxy.invoke (label=" + m_label + ")");
            Method m = m_service.getClass().getMethod(method.getName(), method.getParameterTypes());
            return m.invoke(m_service, args);
        }
    }
        
    public static class AspectProxyFactory {
        private Class m_class;
        private final String m_label;

        public AspectProxyFactory(Class clazz, String label) {
            m_class = clazz;
            m_label = label;
        }
        
        public Object create() {
            return Proxy.newProxyInstance(m_class.getClassLoader(), new Class[] { m_class }, new AspectProxy(m_label));
        }
    }
    
    @Override
    public void init(BundleContext context, DependencyManager mgr) throws Exception {
        mgr.add(createComponent()
            .setInterface(ServiceInterface.class.getName(), null)
            .setImplementation(ServiceProvider.class));

        mgr.add(createAspectService(ServiceInterface.class, null, 10, "m_service")
           .setFactory(new AspectProxyFactory(ServiceInterface.class, "label"), "create"));

        mgr.add(createComponent()
            .setImplementation(ServiceConsumer.class)
            .add(createServiceDependency().setService(ServiceInterface.class).setRequired(true)));        
    }
}
{code}

so, in the above example, the AspectProxyFactory class holds the ServiceInterface class in its "m_class" attribute (needed to create the DynamicProxy), as well as a "m_label" field, which will be passed to the DynamicProxy constructor.

So, can you please modify the example above in order to let me understand what kind of improvement you would like to have ? 

Do you mean that the org.apache.felix.dm.Component object (for the aspect) should be passed to the create method and then the Factory could do a class.forName on the aspect interface (that can be accessed from Component.getComponentDeclaration().getServices() method in dependency manager 4.0.0, from the sanbdox) in order to be able to create the java DynamicProxy ?

But yet, we still have to hold the "label" context in the Factory object, in order to pass it to the AspectProxy constructor ...
So, it is not exaclty what may be you would like to have, but I wonder about the following improvement: instead of having a setFactory(Object factoryInstance method, String create method), we could then introduce a simple interface in DM API that would only have a create method, and notice that having one single method would allow to use a nice lambda in java8, since it would be compatible with a functional interface:

Something like

{code}
package org.apache.felix.dm;

// @FunctionalInterface
public interface Factory {
    Object create();
}
{code}

then we could introduce a new setFactory(Factory factory) method in the Component interface:

{code}
interface Component {
    ...
    void setFactory(Factory factory);
}
{code}

and given the initial example, we could then do something like this (in java8 style):

{code}
        mgr.add(createAspectService(ServiceInterface.class, null, 10, "m_service")
           .setFactory(() -> 
               new Proxy.newProxyInstance(ServiceInterface.class.getClassLoader(), 
                                                                new Class[] {ServiceInterface.class }, new AspectProxy("label"));
           );
{code}

and in java7:

{code}
        mgr.add(createAspectService(ServiceInterface.class, null, 10, "m_service")
           .setFactory(new Factory() {
               public Object create() {
                     return new Proxy.newProxyInstance(ServiceInterface.class.getClassLoader(), 
                                                                                new Class[] {ServiceInterface.class }, new AspectProxy("label"));
              }
           }));
{code}

(not sure if this is making sense or if this is really what you would like to have, please let me know what you think ...)

/pierre



> Factory create() method should have access to the component definition
> ----------------------------------------------------------------------
>
>                 Key: FELIX-4614
>                 URL: https://issues.apache.org/jira/browse/FELIX-4614
>             Project: Felix
>          Issue Type: Improvement
>          Components: Dependency Manager
>            Reporter: Paul Bakker
>
> Currently the factory mechanism uses a _create()_ method without arguments. Because of this there is not enough context to create instances. For example creating a Proxy is not possible because we don't know which interface to use for the Proxy. 
> The _create()_ method should support an argument to get access to the component definition. 



--
This message was sent by Atlassian JIRA
(v6.2#6252)