Last time we find that in the DefaultListableBeanFactory it provides map to save bean definitions. But when getting bean instance, we need to step into DefaultSingletonBeanRegistry. First let’s see the document:

Generic registry for shared bean instances, implementing the SingletonBeanRegistry. Allows for registering singleton instances that should be shared for all callers of the registry, to be obtained via bean name.

Also supports registration of DisposableBean instances, (which might or might not correspond to registered singletons), to be destroyed on shutdown of the registry. Dependencies between beans can be registered to enforce an appropriate shutdown order.

This class mainly serves as base class for BeanFactory implementations, factoring out the common management of singleton bean instances. Note that the ConfigurableBeanFactory interface extends the SingletonBeanRegistry interface.

Note that this class assumes neither a bean definition concept nor a specific creation process for bean instances, in contrast to AbstractBeanFactory and DefaultListableBeanFactory (which inherit from it). Can alternatively also be used as a nested helper to delegate to.

In the class, it has private variable to cache the bean instance:

/** Cache of singleton objects: bean name --> bean instance */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);

AbstractBeanFactory

Again AbstractBeanFactory is very important BeanFactory implementation to get beans, and it is also a SingletonBeanRegistry interface implementation to save beans.

protected <T> T doGetBean(String name,
                          Class<T> requiredType,
                          Object[] args,
                          boolean typeCheckOnly)

When ApplicationContext calls doGetBean(...), it will call getSingleton(...) which is declared in SingletonBeanRegistry interface and implements in DefaultSingletonBeanRegistry.

Return the (raw) singleton object registered under the given name. Only checks already instantiated singletons; does not return an Object for singleton bean definitions which have not been instantiated yet.

The main purpose of this method is to access manually registered singletons (see registerSingleton(java.lang.String, java.lang.Object)). Can also be used to access a singleton defined by a bean definition that already been created, in a raw fashion.

NOTE: This lookup method is not aware of FactoryBean prefixes or aliases. You need to resolve the canonical bean name first before obtaining the singleton instance.

In this method, if the bean exists in concurrent map singletonObjects<String, Object> of DefaultSingletonBeanRegistry, it will call getSingleton(...) and return the bean object; Else the bean isn’t defined, the method will also call getSingleton(...), if the singleton bean is null then it will generate the object of bean.

Create Object of Bean

How does spring create object from bean definition file? In AbstractBeanFactory, it provide an abstract bean creation method:

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
			throws BeanCreationException;

Also see the document:

Create a bean instance for the given merged bean definition (and arguments). The bean definition will already have been merged with the parent definition in case of a child definition.

All bean retrieval methods delegate to this method for actual bean creation.

This method is implemented in AbstractAutowireCapableBeanFactory:

Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the RootBeanDefinition class. Implements the AutowireCapableBeanFactory interface in addition to AbstractBeanFactory’s createBean(java.lang.Class<T>) method.

Provides bean creation (with constructor resolution), property population, wiring (including autowiring), and initialization. Handles runtime bean references, resolves managed collections, calls initialization methods, etc. Supports autowiring constructors, properties by name, and properties by type.

The main template method to be implemented by subclasses is AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor, String, Set, TypeConverter), used for autowiring by type. In case of a factory which is capable of searching its bean definitions, matching beans will typically be implemented through such a search. For other factory styles, simplified matching algorithms can be implemented.

Note that this class does not assume or implement bean definition registry capabilities. See DefaultListableBeanFactory for an implementation of the ListableBeanFactory and BeanDefinitionRegistry interfaces, which represent the API and SPI view of such a factory, respectively.

Now we just move to createBean(...) method and its main method is doCreateBean(...):

Actually create the specified bean. Pre-creation processing has already happened at this point, e.g. checking postProcessBeforeInstantiation callbacks.

Differentiates between default bean instantiation, use of a factory method, and autowiring a constructor.

So we can know from the document that the method just create the specified bean which means it should get class reference in the definition file.

In this method, we find BeanWrapper class which is the central interface of Spring’s low-level JavaBeans infrastructure. The wrapper is initialized with createBeanInstance(...) method which can create a new instance for the specified bean, using an appropriate instantiation strategy: factory method, constructor autowiring, or simple instantiation. Then it call the core instantiation method instantiateBean(...) and it will step into InstantiationStrategy interface.

InstantiationStrategy

Interface responsible for creating instances corresponding to a root bean definition.

This is pulled out into a strategy as various approaches are possible, including using CGLIB to create subclasses on the fly to support Method Injection.

Here we just talk about its SimpleInstantiationStrategy implement class. it has instantiate(...) which can return an instance of the bean with the given name in this factory. First it get the Class<?> clazz of the bean, and call clazz.getDeclaredConstructor(...) to get the Constructor<?> of the bean, then step into BeanUtils class and call instantiateClass(...) method which can call constructor.newInstance(args) and return a new object created by calling the constructor this object represents.

Finally, the object will be saved in the singletonObjects<String, Object> for getBean(...) method to get the object.

What’s Next?

After reading the source code of Spring’s IoC, I find some TODO list.

• ThreadLocal<?>, ConcurrentMap<K, V> and volatile are often appeared in the source, so I need to deal with something about Java Threads;
• Spring Reference is very useful document to read thus I need to focus more with it.

When using Spring framework, we must use Apache Common Logging to print log in console or binary files. As we known, Spring log configuration can change in the web.xml when it works on server. But in these series of articles, we try to analyze the Spring core techniques without works on server. So there should have another way to configure log without web.xml because we want to see the debug informations.

Spring gives Log4jConfigurer.initLogging() method (has been deprecated in Spring 4.2.1) to initialize log4j from the given file location. Note that we always use Maven to build project, but maven might mash src and resources folders to one. Thus we should use classpath: ,without slash, to represent resources folder in the project.

Now Apache Commons Logging (JCL) provides thin-wrapper Log implementations for other logging tools, including Log4J. But Log4jConfigurer.initLogging() calls methods from log4j 1.x. It means that we should add log4j 1.x dependency to make sure that our log configuration file works smoothly.

Here is the configure file log4j.properties, and just opening debug function in org.springframework.beans because we want to know the IOC process:

log4j.rootCategory=INFO, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c:%L - %m%n

log4j.category.org.springframework.beans=DEBUG

As last article, we run the same code but add our log configuration before:

Log4jConfigurer.initLogging("classpath:log4j.properties");
ApplicationContext context = new ClassPathXmlApplicationContext("services.xml");
PetStoreServiceImpl petStoreService = context.getBean("petStore", PetStoreServiceImpl.class);

Now we can follow the log information to know the IOC clearly.

ClassPathXmlApplicationContext

17:23:15,265  INFO main ClassPathXmlApplicationContext org.springframework.context.support.AbstractApplicationContext.prepareRefresh:581 - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@42dafa95: startup date [Fri Oct 21 17:23:15 EDT 2016]; root of context hierarchy

First we step into ClassPathXmlApplicationContext constructor and it calls refresh(). This method is declared in the interface ConfigurableApplicationContext, implements in AbstractApplicationContext, finally called in ClassPathXmlApplicationContext which is a subclass of AbstractApplicationContext.

This method can load or refresh the persistent representation of the configuration, which might an XML file, properties file, or relational database schema. As this is a startup method, it should destroy already created singletons if it fails, to avoid dangling resources. In other words, after invocation of that method, either all or no singletons at all should be instantiated.

As we see in the document, refresh() is used to load and refresh persistent representation configuration. It should be done first of all.

XmlBeanDefinitionReader

17:23:15,555  INFO main XmlBeanDefinitionReader org.springframework.beans.factory.xml.XmlBeanDefinitionReader.loadBeanDefinitions:317 - Loading XML bean definitions from class path resource [services.xml]

The refresh() method calls obtainFreshBeanFactory() in which can tell the subclass to refresh the internal bean factory. So how to let a class to call the method (in this case it is refreshBeanFactory()) in its subclass? It is a very classical design pattern.

First, the AbstractApplicationContext declares:

protected abstract void refreshBeanFactory()

This method is implemented in AbstractRefreshableApplicationContext which is a subclass of AbstractApplicationContext:

@Override
protected final void refreshBeanFactory()

Therefore the father class can call the method which implemented in its subclass.

Here is XmlBeanDefinitionReader:

Bean definition reader for XML bean definitions. Delegates the actual XML document reading to an implementation of the BeanDefinitionDocumentReader interface. Typically applied to a DefaultListableBeanFactory or a GenericApplicationContext.

This class loads a DOM document and applies the BeanDefinitionDocumentReader to it.

The document reader will register each bean definition with the given bean factory, talking to the latter’s implementation of the BeanDefinitionRegistry interface.

loadBeanDefinition() method is used to load bean definitions from the specified XML file.

DefaultDocumentLoader

XmlBeanDefinitionReader calls doLoadDocument() and it has local variable DocumentLoader documentLoader which calls loadDocument().

19:38:23,603 DEBUG main DefaultDocumentLoader org.springframework.beans.factory.xml.DefaultDocumentLoader.loadDocument:73 - Using JAXP provider [com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl]

Here is DefaultDocumentLoader:

Spring’s default {@link DocumentLoader} implementation. Simply loads Document documents using the standard JAXP-configured XML parser. If you want to change the DocumentBuilder that is used to load documents, then one strategy is to define a corresponding Java system property when starting your JVM. For example, to use the Oracle DocumentBuilder, might start your application like as follows:

java -Djavax.xml.parsers.DocumentBuilderFactory=oracle.xml.jaxp.JXDocumentBuilderFactory MyMainClass

DefaultBeanDefinitionDocumentReader

Here is DefaultBeanDefinitionDocumentReader which is used to read bean definitions:

Default implementation of the BeanDefinitionDocumentReader interface that reads bean definitions according to the “spring-beans” DTD and XSD format (Spring’s default XML bean definition format).

The structure, elements, and attribute names of the required XML document are hard-coded in this class. (Of course a transform could be run if necessary to produce this format). <beans> does not need to be the root element of the XML document: this class will parse all bean definition elements in the XML file, regardless of the actual root element.

And registerBeanDefinitions(doc, readerContext):

Read bean definitions from the given DOM document and register them with the registry in the given reader context.

doc the DOM document readerContext the current context of the reader (includes the target registry and the resource being parsed)

DefaultListableBeanFactory

Default implementation of the ListableBeanFactory and BeanDefinitionRegistry interfaces: a full-fledged bean factory based on bean definition objects. Typical usage is registering all bean definitions first (possibly read from a bean definition file), before accessing beans. Bean definition lookup is therefore an inexpensive operation in a local bean definition table, operating on pre-built bean definition metadata objects.

Can be used as a standalone bean factory, or as a superclass for custom bean factories. Note that readers for specific bean definition formats are typically implemented separately rather than as bean factory subclasses: see for example PropertiesBeanDefinitionReader and XmlBeanDefinitionReader.

For an alternative implementation of the ListableBeanFactory interface, have a look at StaticListableBeanFactory, which manages existing bean instances rather than creating new ones based on bean definitions.

It implements the bean register method registerBeanDefinition() which is declared in interface BeanDefinitionRegistry.

Register a new bean definition with this registry. Must support RootBeanDefinition and ChildBeanDefinition.

Now we look at DefaultListableBeanFactory and find that it has some private variables.

/** Map of bean definition objects, keyed by bean name */
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

/** List of bean definition names, in registration order */
private volatile List<String> beanDefinitionNames = new ArrayList<String>(256);

Note that beanDefinitionMap is a java.util.concurrent.ConcurrentHashMap and beanDefinitionNames is a volatile variable.

this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);

TODO: java.util.concurrent.ConcurrentHashMap and volatile variable.

 // create and configure beans
ApplicationContext context =
    new ClassPathXmlApplicationContext(new String[] {"services.xml", "daos.xml"});

// retrieve configured instance
PetStoreService service = context.getBean("petStore", PetStoreService.class);

// use configured instance
List<String> userList = service.getUsernameList();

First of all, we should know the class hierarchy in org.springframework.context.support:

ClassPathXmlApplicationContext implements ApplicationContext and calls its constructor as below:

 /**
 * Create a new ClassPathXmlApplicationContext, loading the definitions
 * from the given XML file and automatically refreshing the context.
 * @param configLocation resource location
 * @throws BeansException if context creation failed
 **/
public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
	this(new String[] {configLocation}, true, null);
}

Step into ClassPathXmlApplicationContext(String[], boolean, ApplicationContext)：

/**
 * Create a new ClassPathXmlApplicationContext with the given parent,
 * loading the definitions from the given XML files.
 * @param configLocations array of resource locations
 * @param refresh whether to automatically refresh the context,
 * loading all bean definitions and creating all singletons.
 * Alternatively, call refresh manually after further configuring the context.
 * @param parent the parent context
 * @throws BeansException if context creation failed
 * @see #refresh()
 **/
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
		throws BeansException {

	super(parent);
	setConfigLocations(configLocations);
	if (refresh) {
		refresh();
	}
}

In this method, it first call super(parent), which is AbstractXmlApplicationContext(parent) –> AbstractRefreshableConfigApplicationContext(parent) –> AbstractRefreshableApplicationContext(parent) –> AbstractApplicationContext(parent).

Then, for the setConfigLocations(configLocations), we need move to AbstractRefreshableConfigApplicationContext, the superclass of ClassPathXmlApplicationContext. It has setConfigLocations(configLocations) that deals with the locations String and save to its private value String[] configLocations.

Now, we get to the refresh() method belong to AbstractApplicationContext that implements the method in the interface ConfigurableApplicationContext

/**
 * Load or refresh the persistent representation of the configuration,
 * which might an XML file, properties file, or relational database schema.
 * <p>As this is a startup method, it should destroy already created singletons
 * if it fails, to avoid dangling resources. In other words, after invocation
 * of that method, either all or no singletons at all should be instantiated.
 * @throws BeansException if the bean factory could not be initialized
 * @throws IllegalStateException if already initialized and multiple refresh
 * attempts are not supported
 */
 @Override
public void refresh() throws BeansException, IllegalStateException {
		synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		prepareBeanFactory(beanFactory);
		// remainder...
		}
}

For this line call obtainFreshBeanFactory() that then calls refreshBeanFactory(), subclass AbstractXmlApplicationContext to refresh bean factory and load bean definitions by calling loadBeanDefinitions(beanFactory), and then it calls loadBeanDefinitions(reader), in which reader is XmlBeanDefinitionReader implements BeanDefinitionReader. This class loads a DOM document and applies the reader to it. The document reader will register each bean definition with the given bean factory, talking to the latter’s implementation of the BeanDefinitionRegistry interface.

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

The reader has the loadBeanDefinitions(configLocations) method and the inner method of XmlBeanDefinitionReader provides a loadBeanDefinitions(encodedResource) where EncodedResource is the resource descriptor for the XML file, allowing to specify an encoding to use for parsing the file.

Method doLoadDocument(inputSource, resource) actually load bean definitions from the specified XML file. DefaultDocumentLoader that implements DocumentLoader loads a Document document from the supplied InputSource source by calling method loadDocument(InputSource, EntityResolver, ...) (that is a classical design pattern).

Further topics: InputSource of Spring Resource,ThreadLocal of Java SE concurrency, context.getBean(...) of how to get instantialization of service.

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.

<bean  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:

<bean  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.

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.

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”.

1. 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());
}

1. 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());
}

1. _ 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());
}

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;
	}
}

<bean 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;
	}
}

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

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

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);
}

9个隐含对象及其常用方法 (虽然为 Java 代码, 但是使用 EL 表达式完全可以进行调用相关 get 方法):

1. Request (HttpServletRequest)

• Attribute 相关:

可以理解在 request 作用域范围内的一个存储空间, 实现方法是将键值对放入一个 HashMap.

Object getAttribute(String name);
void setAttribute(String name, Object o);
void removeAttribute(String name);

• Paramater 相关:

一般用于与 html, jsp页面 及 url 地址传递参数, 仅能传递字符串. 注意: 没有 setParamater 方法.

String getParameter(String name);
String[] getParameterValues(String name);

• Cookie 相关:

作为浏览器端持久化储存的一种实现方法, 由服务器加入 response 中, 并在 request 中取出.

Cookie[] getCookies();

• Session 相关:

作为服务器持久化储存的一种实现方法, 在浏览器第一次访问服务器资源时自动创建.

HttpSession getSession();

• URI 路径:

应用名称 + 页面路径

比如: /day_15/bbs/bbs.jsp .

String getRequestURI();

• URL 路径:

站点地址 + URI路径

比如: http://localhost:8080/day_15/bbs/bbs.jsp

StringBuffer getRequestURL();

• ServletPath 路径:

页面路径

一般用于 filter 进行页面筛选. 比如: /bbs/bbs.jsp

String getServletPath();

• 转发地址:

可以将 request 转发到另一页面或 Servlet. 注意: path 为 Servlet context path.

RequestDispatcher getRequestDispatcher(String path);

• 编码问题:

对于携带中文作为 Paramater 的 request 在打印时会出现乱码, 所以需要进行编码.

void setCharacterEncoding(String env);

2. Response (HttpServletResponse)

• Cookie 相关:

作为浏览器端持久化储存的一种实现方法, 由服务器加入 response 中, 并在 request 中取出.

void addCookie(Cookie cookie)

• 重定向地址

可以跳转到另一页面, 但不转发 request. location 必须包含 application context path 或为 URL.

void sendRedirect(String location);

3. Session (HttpSession)

• Attribute 相关:

和 request 类似, session 也可以携带键值对, 使用方法完全类似.

Object getAttribute(String name);
void setAttribute(String name, Object value);
void removeAttribute(String name);

• 设置生命周期:

从创建到销毁的时间.

void setMaxInactiveInterval(int interval);
int getMaxInactiveInterval();

立即销毁 session:

void invalidate();

• JSessionId:

以 JSessionId 为名称存入 Cookie 中.

获取 JSessionId:

String getId();

• 时间信息:

获取创建与最近访问时间:

long getCreationTime();
long getLastAccessedTime();

• 获取 ServletContext

ServletContext getServletContext();

以上总结的三个隐含对象 request response session, 不只是对于 JSP , 而在整个 Java Web 技术中都极为重要, 对其常用的实现方法必须使用熟练.

4. Application (ServletContext)

• Attribute 相关:

和 request session 类似, Servlet 也可以携带键值对, 使用方法完全类似.

Object getAttribute(String name);
void setAttribute(String name, Object value);
void removeAttribute(String name);

• Paramater 相关:

获取在 web.xml 中设置的 Servlet 初始化参数.

String getInitParameter(String name);

• Servlet Context Path

为服务器应用的路径名, 如: /day_15.

String getContextPath();

仅获取应用名称, 如: day_15.

String getServletContextName();

5. Config (ServletConfig)

ServletContext 可以覆盖其实现的所有功能.

• Paramater 相关:

获取在 web.xml 中设置的 Servlet 初始化参数.

String getInitParameter(String name);

• 获取 ServletContext:

ServletContext getServletContext();

• 获取应用名称:

如: day_15.

String getServletContextName();

6. PageContext (PageContext)

• 可以获取其他所有隐藏对象 Request Response Session ServletContext ServletConfig Out Page Exception:

直接调用 get 方法既可. 因为可以调用所有功能, 多用于 EL 表达式.

7. 其余不常用的三个: Out Page Exception:

以上9个隐藏对象包含 Java Web 最重要的四个作用域:

• Application: 作用于整个 Web 应用, 生命周期为 应用的添加到移除.
• Session: 作用于一次会话, 生命周期为 浏览器第一次访问生成到生命周期结束自动注销.
• Request: 作用于一次请求, 生命周期为 发送请求到请求处理结束.
• Page: 仅作用于本页面, 无生命周期.

转载于 深入理解 HTTP Session

Session 在 web 开发中是一个非常重要的概念, 这个概念很抽象,很难定义,也是最让人迷惑的一个名词, 也是最多被滥用的名字之一, 在不同的场合,session一次的含义也很不相同. 这里只探讨 HTTP Session.

为了说明问题,这里基于 Java Servlet 理解 Session 的概念与原理,这里所说 Servlet 已经涵盖了 JSP 技术,因为 JSP 最终也会被编译为 Servlet,两者有着相同的本质.

在 Java 中, HTTP 的 Session 对象用 javax.servlet.http.HttpSession 来表示.

1. 概念: Session 代表服务器与浏览器的一次会话过程, 这个过程是连续的, 也可以时断时续的. 在 Servlet 中, session 指的是 HttpSession 类的对象, 这个概念到此结束了, 也许会很模糊, 但只有看完本文,才能真正有个深刻理解.
2. Session 创建的时间是:

一个常见的误解是以为 session 在有客户端访问时就被创建, 然而事实是直到某 server 端程序调用 HttpServletRequest.getSession(true) 这样的语句时才被创建,注意如果JSP没有显示的使用 <% @page session="false"%> 关闭 session, 则 JSP 文件在编译成 Servlet 时将会自动加上这样一条语句 HttpSession session = HttpServletRequest.getSession(true); 这也是JSP中隐含的 session对象的来历.

由于 session 会消耗内存资源, 因此, 如果不打算使用 session, 应该在所有的 JSP 中关闭它.

引申:

• 访问 *.html 的静态资源因为不会被编译为 Servlet, 也就不涉及 session 的问题.
• 当 JSP 页面没有显式禁止 session 的时候, 在打开浏览器第一次请求该 jsp 的时候, 服务器会自动为其创建一个 session, 并赋予其一个 sessionID, 发送给客户端的浏览器. 以后客户端接着请求本应用中其他资源的时候, 会自动在请求头上添加: Cookie:JSESSIONID = 客户端第一次拿到的 session ID 这样, 服务器端在接到请求时候, 就会收到 session ID, 并根据 ID 在内存中找到之前创建的 session 对象, 提供给请求使用. 这也是 session 使用的基本原理 —- 搞不懂这个, 就永远不明白session的原理.

3. Session删除的时间是:

• Session 超时: 超时指的是连续一定时间服务器没有收到该 Session 所对应客户端的请求,并且这个时间超过了服务器设置的 Session 超时的最大时间.
• 程序调用 HttpSession.invalidate()
• 服务器关闭或服务停止

4. session 存放在哪里: 服务器端的内存中. 不过 session 可以通过特殊的方式做持久化管理.
5. session 的 id 是从哪里来的, sessionID 是如何使用的: 当客户端第一次请求 session 对象时候, 服务器会为客户端创建一个 session, 并将通过特殊算法算出一个 session 的 ID, 用来标识该session对象, 当浏览器下次 (session 继续有效时) 请求别的资源的时候, 浏览器会偷偷地将sessionID放置到请求头中, 服务器接收到请求后就得到该请求的 sessionID, 服务器找到该 id 的 session 返还给请求者 (Servlet) 使用. 一个会话只能有一个 session 对象, 对 session 来说是只认 id 不认人.
6. session 会因为浏览器的关闭而删除吗？

不会, session 只会通过上面提到的方式去关闭. 7. 同一客户端机器多次请求同一个资源, session 一样吗？

一般来说,每次请求都会新创建一个 session.

其实, 这个也不一定的, 总结下: 对于多标签的浏览器 (比如 Chrome 浏览器) 来说, 在一个浏览器窗口中, 多个标签同时访问一个页面, session是一个. 对于多个浏览器窗口之间, 同时或者相隔很短时间访问一个页面, session是多个的, 和浏览器的进程有关. 对于一个同一个浏览器窗口, 直接录入url访问同一应用的不同资源, session是一样的. 8. session 是一个容器,可以存放会话过程中的任何对象. 9. session 因为请求 (request对象) 而产生, 同一个会话中多个 request 共享了一个 session 对象, 可以直接从请求中获取到 session 对象. 10. 其实, session 的创建和使用总在服务端, 而浏览器从来都没得到过 session 对象. 但浏览器可以请求 Servlet (jsp 也是 Servlet) 来获取 session 的信息. 客户端浏览器真正紧紧拿到的是 session ID, 而这个对于浏览器操作的人来说, 是不可见的, 并且用户也无需关心自己处于哪个会话过程中.

转载于 用 Redis 实现分布式锁 与 实现任务队列

这一次总结和分享用Redis实现分布式锁 与 实现任务队列 这两大强大的功能. 先扯点个人观点, 之前我看了一篇博文说博客园的文章大部分都是分享代码, 博文里强调说分享思路比分享代码更重要 (貌似大概是这个意思, 若有误请谅解) , 但我觉得, 分享思路固然重要, 但有了思路, 却没有实现的代码, 那会让人觉得很浮夸的, 在工作中的程序猿都知道, 你去实现一个功能模块, 一段代码, 虽然你有了思路, 但是实现的过程也是很耗时的, 特别是代码调试, 还有各种测试等等. 所以我认为, 思路+代码, 才是一篇好博文的主要核心.

直接进入主题.

一、前言

双十一刚过不久, 大家都知道在天猫、京东、苏宁等等电商网站上有很多秒杀活动, 例如在某一个时刻抢购一个原价1999现在秒杀价只要999的手机时, 会迎来一个用户请求的高峰期, 可能会有几十万几百万的并发量, 来抢这个手机, 在高并发的情形下会对数据库服务器或者是文件服务器应用服务器造成巨大的压力, 严重时说不定就宕机了, 另一个问题是, 秒杀的东西都是有量的, 例如一款手机只有10台的量秒杀, 那么, 在高并发的情况下, 成千上万条数据更新数据库 (例如10台的量被人抢一台就会在数据集某些记录下 减1) , 那次这个时候的先后顺序是很乱的, 很容易出现10台的量, 抢到的人就不止10个这种严重的问题. 那么, 以后所说的问题我们该如何去解决呢？ 接下来我所分享的技术就可以拿来处理以上的问题： 分布式锁 和 任务队列.

二、实现思路

1.Redis 实现分布式锁思路

思路很简单, 主要用到的 redis 函数是 setnx() , 这个应该是实现分布式锁最主要的函数. 首先是将某一任务标识名 (这里用 Lock:order 作为标识名的例子) 作为键存到 redis 里, 并为其设个过期时间, 如果是还有 Lock:order 请求过来, 先是通过 setnx() 看看是否能将 Lock:order 插入到 redis 里, 可以的话就返回 true, 不可以就返回 false. 当然, 在我的代码里会比这个思路复杂一些, 我会在分析代码时进一步说明.

2.Redis 实现任务队列

这里的实现会用到上面的 Redis 分布式的锁机制, 主要是用到了Redis 里的有序集合这一数据结构. 例如入队时, 通过 zset 的 add() 函数进行入队, 而出对时, 可以用到 zset 的 getScore() 函数. 另外还可以弹出顶部的几个任务.

以上就是实现 分布式锁 和 任务队列 的简单思路, 如果你看完有点模棱两可, 那请看接下来的代码实现.

三、代码分析

(一) 先来分析Redis分布式锁的代码实现

• (1) 为避免特殊原因导致锁无法释放, 在加锁成功后, 锁会被赋予一个生存时间 (通过 lock方法的参数设置或者使用默认值) , 超出生存时间锁会被自动释放锁的生存时间默认比较短 (秒级) , 因此, 若需要长时间加锁, 可以通过 expire 方法延长锁的生存时间为适当时间, 比如在循环内.
• (2) 系统级的锁当进程无论何种原因时出现 crash 时, 操作系统会自己回收锁, 所以不会出现资源丢失, 但分布式锁不用, 若一次性设置很长时间, 一旦由于各种原因出现进程crash 或者其他异常导致unlock未被调用时, 则该锁在剩下的时间就会变成垃圾锁, 导致其他进程或者进程重启后无法进入加锁区域.

先看加锁的实现代码：这里需要主要两个参数, 一个是 $timeout,这个是循环获取锁的等待时间, 在这个时间内会一直尝试获取锁知道超时, 如果为 0, 则表示获取锁失败后直接返回而不再等待；另一个重要参数的 $expire, 这个参数指当前锁的最大生存时间, 以秒为单位的, 它必须大于0, 如果超过生存时间锁仍未被释放, 则系统会自动强制释放. 这个参数的最要作用请看上面的 (1) 里的解释.

这里先取得当前时间, 然后再获取到锁失败时的等待超时的时刻 (是个时间戳), 再获取到锁的最大生存时刻是多少. 这里 redis 的 key 用这种格式：Lock: 锁的标识名, 这里就开始进入循环了, 先是插入数据到redis里, 使用 setnx() 函数, 这函数的意思是, 如果该键不存在则插入数据, 将最大生存时刻作为值存储, 假如插入成功, 则对该键进行失效时间的设置, 并将该键放在 $lockedName 数组里, 返回 true, 也就是上锁成功；如果该键存在, 则不会插入操作了, 这里有一步严谨的操作, 那就是取得当前键的剩余时间, 假如这个时间小于 0, 表示 key 上没有设置生存时间 (key是不会不存在的, 因为前面setnx会自动创建) 如果出现这种状况, 那就是进程的某个实例 setnx 成功后 crash 导致紧跟着的 expire 没有被调用, 这时可以直接设置expire并把锁纳为己用. 如果没设置锁失败的等待时间或者已超过最大等待时间了, 那就退出循环, 反之则隔 $waitIntervalUs 后继续请求. 这就是加锁的整一个代码分析.

/**
     * 加锁
     * @param  [type]  $name           锁的标识名
     * @param  integer $timeout        循环获取锁的等待超时时间，在此时间内会一直尝试获取锁直到超时，为 0表示失败后直接返回不等待
     * @param  integer $expire         当前锁的最大生存时间(秒)，必须大于 0，如果超过生存时间锁仍未被释放，则系统会自动强制释放
     * @param  integer $waitIntervalUs 获取锁失败后挂起再试的时间间隔(微秒)
     * @return [type]                  [description]
     */
    public function lock($name, $timeout = 0, $expire = 15, $waitIntervalUs = 100000) {
        if ($name == null) return false;

        //取得当前时间
        $now = time();
        //获取锁失败时的等待超时时刻
        $timeoutAt = $now + $timeout;
        //锁的最大生存时刻
        $expireAt = $now + $expire;

        $redisKey = "Lock:{$name}";
        while (true) {
            //将rediskey的最大生存时刻存到redis里，过了这个时刻该锁会被自动释放
            $result = $this->redisString->setnx($redisKey, $expireAt);

            if ($result != false) {
                //设置key的失效时间
                $this->redisString->expire($redisKey, $expireAt);
                //将锁标志放到lockedNames数组里
                $this->lockedNames[$name] = $expireAt;
                return true;
            }

            //以秒为单位，返回给定key的剩余生存时间
            $ttl = $this->redisString->ttl($redisKey);

            //ttl小于0 表示key上没有设置生存时间（key是不会不存在的，因为前面setnx会自动创建）
            //如果出现这种状况，那就是进程的某个实例setnx成功后 crash 导致紧跟着的expire没有被调用
            //这时可以直接设置expire并把锁纳为己用
            if ($ttl < 0) {
                $this->redisString->set($redisKey, $expireAt);
                $this->lockedNames[$name] = $expireAt;
                return true;
            }

            /*****循环请求锁部分*****/
            //如果没设置锁失败的等待时间 或者 已超过最大等待时间了，那就退出
            if ($timeout <= 0 || $timeoutAt < microtime(true)) break;

            //隔 $waitIntervalUs 后继续 请求
            usleep($waitIntervalUs);

        }

        return false;
    }