欲說還休

3.2 Bean Scopes

Wed, 28 Sep 2016 00:00:00 +0000

Bean scopes: singleton and prototype

1. singleton

Only one instance in Spring IoC container. Only return the same Bean.

One instance of the bean is created for the entire application.

Two ways to implement, we could learn how Spring work through the code bellow:

Define static attribute to hold the instance:

package cn.javass.spring.chapter3.bean;  
public class Singleton {  
    //1. Private constructor  
    private Singleton() {}  

    private static class InstanceHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    //3.Global accession  
    public static Singleton getInstance() {  
        return InstanceHolder.INSTANCE;  
    }  
}

Via SingletonBeanRegistry:

import java.util.HashMap;
import java.util.Map;
import org.springframework.beans.factory.config.SingletonBeanRegistry;

public class SingletonBeanRegister implements SingletonBeanRegistry {
	private final Map<String, Object> BEANS = new HashMap<String, Object>();

	public boolean containsSingleton(String beanName) {
		return BEANS.containsKey(beanName);
	}

	public Object getSingleton(String beanName) {
		return BEANS.get(beanName);
	}
	@Override
	public int getSingletonCount() {
		return BEANS.size();
	}
	@Override
	public String[] getSingletonNames() {
		return BEANS.keySet().toArray(new String[0]);
	}
	@Override
	public void registerSingleton(String beanName, Object bean) {
		if (BEANS.containsKey(beanName)) {
			throw new RuntimeException("[" + beanName + "] is exist");
		}
		BEANS.put(beanName, bean);
	}
}

JUnit Test:

import org.junit.Test;

public class SingletonTest {
	@Test
	public void testRegister() {
		SingletonBeanRegister register = new SingletonBeanRegister();
		register.registerSingleton("bean1", new HelloImpl2());
		HelloImpl2 bean1 = (HelloImpl2) register.getSingleton("bean1");
		bean1.sayHello();

		try {
			register.registerSingleton("bean1", new HelloImpl2());
		}
		catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}
}

We could define singleton in xml:

In most time, singleton is default in Spring.

  class="cn.javass.spring.chapter3.bean.Printer" scope="singleton"/>

2. prototype

Return new Bean when container request a Bean. Contrast with singleton, prototype would not cache Bean.

One instance of the bean is created every time the bean is injected into or retrieved from the Spring application context.

Here is the implement of prototype in Spring:

Bean definition:

public class BeanDefinition {
	//singleton
	public static final int SCOPE_SINGLETON = 0;
	//prototype
	public static final int SCOPE_PROTOTYPE = 1;
	//identity
	private String id;

	private String clazz;
	//Scope
	private int scope = SCOPE_SINGLETON;

	public void setId(String id) {
		this.id = id;
	}
	public String getId() {
		return this.id;
	}

	public void setClazz(String clazz) {
		this.clazz = clazz;
	}
	public String getClazz() {
		return this.clazz;
	}

	public void setScope(int scope) {
		this.scope = scope;
	}
	public int getScope() {
		return this.scope;
	}
}

Bean registry, also use Map:

public class BeanDifinitionRegister {
	private final Map<String, BeanDefinition> DEFINITIONS = new HashMap<String, BeanDefinition>();
	public void registerBeanDefinition(String name, BeanDefinition bd) {
		if (DEFINITIONS.containsKey(bd.getId())) {
			throw new RuntimeException("Bean definition is exist!");
		}
		DEFINITIONS.put(bd.getId(), bd);
	}
	public BeanDefinition getBeanDefinition(String beanName) {
		return DEFINITIONS.get(beanName);
	}
	public boolean containsBeanDefinition(String beanName) {
		return DEFINITIONS.containsKey(beanName);
	}
}

Bean factory checks in the registry so that the Bean is new every time:

public class DefaultBeanFactory {
	//Bean registry
	private BeanDifinitionRegister DEFINITIONS = new BeanDifinitionRegister();

	//singleton registry
	private final SingletonBeanRegistry SINGLETONS = new SingletonBeanRegister();

	public Object getBean(String beanName) {
		//is Bean definition exist?
		if (!DEFINITIONS.containsBeanDefinition(beanName)) {
			throw new RuntimeException("Not exist[" + beanName + "]Bean difinition");
		}
		//get Bean definition
		BeanDefinition bd = DEFINITIONS.getBeanDefinition(beanName);
		//is it singleton?
		if (bd.getScope() == BeanDefinition.SCOPE_SINGLETON) {
			//yes
			if (SINGLETONS.containsSingleton(beanName)) {
				return SINGLETONS.getSingleton(beanName);
			}
			//no
			SINGLETONS.registerSingleton(beanName, createBean(bd));
			return SINGLETONS.getSingleton(beanName);
		}
		//if it is prototype, construct new one every time.
		if (bd.getScope() == BeanDefinition.SCOPE_PROTOTYPE) {
			return createBean(bd);
		}
		throw new RuntimeException("UNKNOWN Definition!");
	}

	public void registerBeanDefinition(BeanDefinition bd) {
		DEFINITIONS.registerBeanDefinition(bd.getId(), bd);
	}

	private Object createBean(BeanDefinition bd) {
		//new Bean
		try {
			Class clazz = Class.forName(bd.getClazz());
			return clazz.getConstructor().newInstance();
		} catch (ClassNotFoundException e) {
			throw new RuntimeException("Not found Bean[" + bd.getId());
		} catch (Exception e) {
			throw new RuntimeException("New Bean[" + bd.getId() + "] failed");
		}
	}
}

Junit test:

public class BeanFatoryTest {
	@Test
	public void testPrototype() throws Exception {
		//new Bean factory
		DefaultBeanFactory bf = new DefaultBeanFactory();
		//new Bean definition
		BeanDefinition bd = new BeanDefinition();
		bd.setId("bean");
		bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
		bd.setClazz(HelloImpl2.class.getName());
		bf.registerBeanDefinition(bd);
		System.out.println(bf.getBean("bean") != bf.getBean("bean"));

	}
}

We could define prototype in xml:

  class="cn.javass.spring.chapter3.bean.Printer" scope="prototypes"/>

Bean Scopes in Web application

1. request

In a web application, one instance of the bean is created for each request.

2. session

In a web application, one instance of the bean is created for each session.

4.1 Resource

Wed, 28 Sep 2016 00:00:00 +0000

Resource

1. Resource API

public interface InputStreamSource {  
    InputStream getInputStream() throws IOException;  
}

public interface Resource extends InputStreamSource {  
       boolean exists();  
       boolean isReadable();  
       boolean isOpen();  
       URL getURL() throws IOException;  
       URI getURI() throws IOException;  
       File getFile() throws IOException;  
       long contentLength() throws IOException;  
       long lastModified() throws IOException;  
       Resource createRelative(String relativePath) throws IOException;  
       String getFilename();  
       String getDescription();  
}

InputStreamSource:
getInputStream: Return new java.io.InputStream which needs close after used.
Resource extends InputStreamSource:
exists: Resource exists?
isReadable: Resource readable?
isOpen: Resource open?
getURL: java.util.URL.
getURI: java.util.URI.

URIs identify and URLs locate; however, locators are also identifiers, so every URL is also a URI, but there are URIs which are not URLs.

getFile: java.io.File.
contentLength: Resource length.
lastModified_: Modified date.
createRelateive: create file in Resource.
getFilename: ONLY return file path.
getDescription return full file path.

4.2 Using Resource

Wed, 28 Sep 2016 00:00:00 +0000

Using Resource

1. ByteArrayResource

Junit test:

import org.junit.Test;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;

public class ResourceTest {

	@Test
	public void testByteArraryResorce() {
		Resource resource = new ByteArrayResource("Hello World!".getBytes());
		if (resource.exists()) {
			dumpStream(resource);
		}
		Assert.assertEquals(false, resource.isOpen());
	}

	private void dumpStream(Resource resource) {
		InputStream inputStream = null;
		try {
			inputStream = resource.getInputStream();
			byte [] descByte = new byte [inputStream.available()];
			inputStream.read(descByte);
			System.out.println(new String(descByte));
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				inputStream.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

NOTE: ByteArrayResource can be used repeatedly, because isOpen() always returns false.

2. InputStreamResource:

@Test
public void testInputStreamResource() {
		ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream("Hello World!".getBytes());
		Resource resource = new InputStreamResource(byteArrayInputStream);
		if (resource.exists()) {
			dumpStream(resource);
		}
		Assert.assertEquals(true, resource.isOpen());
}

NOTE: InputStreamResource can be used only one time, because isOpen() always returns true.

3. FileSystemResource:

@Test
public void testFileResource() {
		File file = new File("d:/test.txt");
		Resource resource = new FileSystemResource(file);
		if (resource.exists()) {
			dumpStream(resource);
		}
		Assert.assertEquals(false, resource.isOpen());
}

NOTE: FileSystemResource can be used repeatedly, because isOpen() always returns false.

4. ClassPathResource:

ClassPathResource replaces Class and ClassLoader to give a uniform implement. The resource can be used repeatedly, because isOpen() always returns false.

Here are three constructors in ClassPathResource:

public ClassPathResource(String path): using default ClassLoader to load resource.
public ClassPathResource(String path, ClassLoader classLoader): using specified ClassLoader to load path resource.
_ public ClassPathResource(String path, Class clazz)_: using Class path to load resource.

For example, if the Class path is “cn.javass.spring.ResourceTest”, the path is “cn/javass/spring/ResourceTest”.

public ClassPathResource(String path):

@Test
public void testClasspathResourceBydefaultClassLoader() throws IOException {
		Resource resource = new ClassPathResource("cn/javass/spring/chapter4/test.properties");
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource.isOpen());
}

public ClassPathResource(String path, ClassLoader classLoader):

@Test
public void testClasspathResourceByClassLoader() throws IOException {
		ClassLoader classLoader = this.getClass().getClassLoader();
		Resource resource = new ClassPathResource("cn/javass/spring/chapter4/test.properties", classLoader);
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource.isOpen());
}

_ public ClassPathResource(String path, Class clazz)_:

@Test
public void testClasspathResourceByClass() throws IOException {
		Class clazz = this.getClass();
		Resource resource1 = new ClassPathResource("cn/javass/spring/chapter4/test.properties", clazz);
		if (resource1.exists()) {
			dumpStream(resource1);
		}
		System.out.println("path:" + resource1.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource1.isOpen());

		Resource resource2 = new ClassPathResource("cn/javass/spring/chapter4/test.properties", this.getClass());
		if (resource2.exists()) {
			dumpStream(resource2);
		}
		System.out.println("path:" + resource2.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource1.isOpen());
}

If not provide the full path, it will search in the resource folder. If not found in the resource folder, it will search in other package folders.

@Test
public void classpathResourceTestFromJar() throws IOException {
		Resource resource = new ClassPathResource("overview.html");
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println("path:" + resource.getURL().getPath());
		Assert.assertEquals(false, resource.isOpen());
}

5. UrlResource:

isOpen() always return false. Supporting three ways to load resources:

http
ftp
file: For example, new UrlResource(“file:d:/test.txt“).

6. ServletContextResource:

To simplize the ServletContext of servlet.

7. VfsResource:

JBoss AS is now provide on http://wildfly.org/downloads/.

@Test
public void testVfsResourceForRealFileSystem() throws IOException {
		//New virtual path
		VirtualFile home = VFS.getChild("/home");
		//Mapping physical path
		VFS.mount(home, new RealFileSystem(new File("d:")));
		//Load resource from virtual path
		VirtualFile virtualFile = home.getChild("test.txt");
		Resource resource = new VfsResource(virtualFile);
		if (resource.exists()) {
			dumpStream(resource);
		}
		System.out.println(resource.getFile().getAbsolutePath());
		Assert.assertEquals(false, resource.isOpen());
}

4.3 Access Resource

Wed, 28 Sep 2016 00:00:00 +0000

Access Resource

1. ResourceLoader

Spring has a DefaultResourceLoader which can return ClassPathResource, UrlResource, and ServletContextResourceLoader which extends all functions of DefaultResourceLoader.

@Test
public void testResourceLoad() throws IOException {
	ResourceLoader loader = new DefaultResourceLoader();
	Resource resource = loader.getResource("classpath:cn/javass/spring/chapter4/test.txt");
	Assert.assertEquals(ClassPathResource.class, resource.getClass());
}

In ApplicationContext also can implement ResourceLoader:

ClassPathXmlApplicationContext
FileSystemXmlApplicationContext
WebApplicationContext

2. ResourceLoaderAware

Injection via ApplicationContext:

import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.ResourceLoader;

public class ResourceBean implements ResourceLoaderAware {
	private ResourceLoader resourceLoader;

	@Override
	public void setResourceLoader(ResourceLoader resourceLoader) {
		this.resourceLoader = resourceLoader;
	}

	public ResourceLoader getResourceLoader() {
		return resourceLoader;
	}
}

 class="cn.javass.spring.chapter4.ResourceBean" />

JUnit test:

@Test
public void test() {
		ApplicationContext context = new ClassPathXmlApplicationContext("chapter4/resourceLoaderAware.xml");
		ResourceBean bean = context.getBean(ResourceBean.class);
		ResourceLoader loader = bean.getResourceLoader();
		Assert.assertTrue(loader instanceof ApplicationContext);
}

3. Resource Injection

import org.springframework.core.io.Resource;

public class ResourceBean3 {
	private Resource resource;

	public Resource getResource() {
		return this.resource;
	}

	public void setResource(Resource resource) {
		this.resource = resource;
	}
}

 id="resourceBean1" class="cn.javass.spring.chapter4.ResourceBean3">
	 name="resource" value="cn/javass/spring/chapter4/test.properties"/>


 id="resourceBean2" class="cn.javass.spring.chapter4.ResourceBean3">
	 name="resource" value="classpath:cn/javass/spring/chapter4/test.properties"/>

JUnit test:

@Test
public void test() {
		ApplicationContext context = new ClassPathXmlApplicationContext("chapter4/resourceInject.xml");

		ResourceBean3 resourceBean1 = context.getBean("resourceBean1", ResourceBean3.class);

		ResourceBean3 resourceBean2 = context.getBean("resourceBean2", ResourceBean3.class);

		Assert.assertTrue(resourceBean1.getResource() instanceof ClassPathResource);
		Assert.assertTrue(resourceBean2.getResource() instanceof ClassPathResource);
}