单身类的现场注入

Question

I have interface:

public interface DataStorage {
    boolean setData(String dataName);

    boolean unsetData(String dataName);

    Map getData();
}

And his implementation:

public class DataStorageImpl implements DataStorage {

    private Map dataMap = new HashMap<>();

    public synchronized boolean setData(String dataName) {
        dataMap.put(dataName, true);

        return true;
    }

    public synchronized boolean unsetData(String dataName) {
        dataMap.put(dataName, false);

        return true;
    }

    public synchronized Map getData() {
        return dataMap;
    }
}

Guice module implementation:

public class DataStorageModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(DataStorage.class).annotatedWith(Names.named("DataStorage")).to(DataStorageImpl.class).in(Singleton.class);
    }

}

I'm trying to inject DataStorage to my Netty request handler. Request handler code:

public class DataMethodsHandler {
    @Inject @Named("DataStorage")
    private DataStorage dataStorage;

    public String version() {
        return "0.0.1";
    }

    public Map list_data() {
        return dataStorage.getData();
    }

    public boolean set_data(String dataName) {
        return dataStorage.setData(dataName);
    }

    public boolean unset_data(String dataName) {
        return dataStorage.unsetData(dataName);
    }
}

And code responsible for binding request handler to Netty:

    PropertyHandlerMapping phm = new CustomPropertyHandlerMapping();
    phm.setVoidMethodEnabled(true);
    try {
        phm.addHandler("", dataMethodsHandler.class);
    } catch (XmlRpcException e) {
        e.printStackTrace();
    }

When I'm calling XMLRPC method "set_data" request fails, because dataStorage field in DataMethodsHandler is null. What I'm doing wrong?

Answer 1

I found solution. First of all we should replace default RequestProcessorFactoryFactory method getRequestProcessorFactory which call Class.newInstance() with this code:

public class XmlRpcServerClientRequestProcessorFactoryFactory implements RequestProcessorFactoryFactory {

    @Inject
    private Injector injector;
    @Inject
    public XmlRpcServerClientRequestProcessorFactoryFactory(Injector injector) {
        this.injector = injector;
    }

    @Override
    public RequestProcessorFactory getRequestProcessorFactory(final Class pClass)
            throws XmlRpcException {
        return new RequestProcessorFactory() {
            @SuppressWarnings("unchecked")
            @Override
            public Object getRequestProcessor(XmlRpcRequest pRequest)
                    throws XmlRpcException {
                return injector.getInstance(pClass);
            }
        };
    }
}

Create module for Guice:

public class NettyXmlRpcModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(NettyXmlRpcModule.class);
        bind(XmlRpcServerClientRequestProcessorFactoryFactory.class).in(Singleton.class);
        bind(Integer.TYPE).annotatedWith(Names.named("xmlrpc.port")).toInstance(3133);
    }


    @Provides
    @Singleton
    Log providesLog(){
        return LogFactory.getLog(NettyXmlRpcWebServer.class);
    }

    @Provides
    InetAddress providesInetAddress() throws UnknownHostException {
        return InetAddress.getLocalHost();
    }
}

And than set new factory for handler:

PropertyHandlerMapping phm = new CustomPropertyHandlerMapping();
        phm.setRequestProcessorFactoryFactory(xmlRpcServerClientRequestProcessorFactoryFactory);

phm.setVoidMethodEnabled(true);
try {
    phm.addHandler("", methodsHandler);
} catch (XmlRpcException e) {
    e.printStackTrace();
}
xmlRpcServer.setHandlerMapping(phm);

Now handler will catch all requests, all fields with annotations will be injected.