com.github.nill14.utils.init.impl.LazyPojo Maven / Gradle / Ivy

Go to download
package com.github.nill14.utils.init.impl;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;

import javax.inject.Provider;

import com.github.nill14.utils.init.api.ILazyPojo;
import com.github.nill14.utils.init.api.IPojoFactory;
import com.github.nill14.utils.init.api.IPropertyResolver;
import com.google.common.reflect.TypeToken;

@SuppressWarnings("serial")
public final class LazyPojo implements ILazyPojo {

	
	public static  ILazyPojo forSingleton(T singleton) {
		return forSingleton(singleton, IPropertyResolver.empty());
	}
	
	public static  ILazyPojo forSingleton(T singleton, IPropertyResolver resolver) {
		IPojoFactory pojoFactory = BeanInstancePojoFactory.singleton(singleton);
		return new LazyPojo(pojoFactory, resolver);
	}
	
	public static  ILazyPojo forBean(Class beanClass) {
		return forBean(beanClass, IPropertyResolver.empty());
	}
	
	public static  ILazyPojo forBean(Class beanClass, IPropertyResolver resolver) {
		IPojoFactory factory = new BeanTypePojoFactory<>(TypeToken.of(beanClass));
		return new LazyPojo<>(factory, resolver);
	}
	
	public static > ILazyPojo forProvider(Class providerClass) {
		return forProvider(providerClass, IPropertyResolver.empty());
	}
	
	public static > ILazyPojo forProvider(
			Class providerClass, IPropertyResolver resolver) {
		
		TypeToken providerType = TypeToken.of(providerClass);
		ProviderTypePojoFactory factoryAdapter = new ProviderTypePojoFactory(providerType);
		return new LazyPojo<>(factoryAdapter, resolver);
	}
	
	public static  ILazyPojo forProvider(TypeToken returnType,
			Provider provider) {
		return forProvider(returnType, provider, IPropertyResolver.empty());
	}
	
	public static  ILazyPojo forProvider(TypeToken returnType,
			Provider provider, IPropertyResolver resolver) {
		IPojoFactory pojoFactory = new ProviderInstancePojoFactory<>(returnType, provider);
		return new LazyPojo<>(pojoFactory, resolver);
	}
	
	public static  ILazyPojo forFactory(
			IPojoFactory pojoFactory, IPropertyResolver resolver) {
		return new LazyPojo<>(pojoFactory, resolver);
	}
	
	private final IPojoFactory factory;
	private final IPropertyResolver resolver;
	private volatile transient T instance;

	public LazyPojo(IPojoFactory factory, IPropertyResolver resolver) {
		this.factory = factory;
		this.resolver = resolver;
	}
	
	@Override
	public TypeToken getType() {
		return factory.getType();
	}

	@Override
	public T getInstance() {
		T instance = this.instance;
		if (instance == null) {
			
			synchronized (this) {
				instance = this.instance;
				if (instance == null) {
					
					instance = factory.newInstance(resolver);
					this.instance = instance;
				}
			}
		}
		return instance;
	}

	@Override
	public boolean freeInstance() {
		boolean released = false;
		T instance;
		
		synchronized (this) {
			instance = this.instance;
			this.instance = null;
		}
		
		if (instance != null) {
			resolver.destroyBean(factory.getDescriptor(), instance);
			released = true;
		}
		
		return released;
	}

	@Override
	public Future init(ExecutorService executor) {
		return executor.submit(new Callable() {

			@Override
			public T call() throws Exception {
				return getInstance();
			}
		});
	}

	@Override
	public Future destroy(ExecutorService executor) {
		return executor.submit(new Callable() {

			@Override
			public Boolean call() throws Exception {
				return freeInstance();
			}
		});
	}
	
	private void writeObject(ObjectOutputStream stream) throws IOException {
		stream.defaultWriteObject();
		synchronized (this) {
			if (instance instanceof Serializable) {
				stream.writeObject(instance);
			} else {
				stream.writeObject(null);
			}
		}
	}

	@SuppressWarnings("unchecked")
	private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
		stream.defaultReadObject();
		Object obj = stream.readObject();
		synchronized (this) {
			if (obj != null) {
				this.instance = (T) obj;
			}
		}
	}
	
	@Override
	public String toString() {
		return String.format("%s(%s)@%s", 
				getClass().getSimpleName(), 
				factory.getType().toString(), 
				Integer.toHexString(System.identityHashCode(this)));
	}
	
	@Override
	public Provider toProvider() {
		return provider;
	}

	
	private transient Provider provider = new Provider() {

		@Override
		public T get() {
			return getInstance();
		}
	};

}