readme.txt

Preface
	我们的目标是自己动手写一个类似于Spring的框架，包含IoC，MVC，JDBCTemplat，AOP等基础特性。
	这个框架是演示性质的，为了学习而建，但是并不简陋，所以是一个可以运行使用的框架。这个框架
	还有一个目的，为了引导人去读Spring源代码，所以目录结构，Class名Interface名与Spring的
	名字是一样的，甚至内部的method和field名字也是基本一样的。
	这个小的框架叫做Minis（mini-Spring）

-----------------------------------IOC--------------------------------------
1.
	Spring框架的核心是IoC（注意，核心不是Core），所以我们也从构建一个IoC容器开始构建Minis。
	在我们的术语中，IoC和DI同义，并不做概念上的区分。客户程序用到的bean交给Minis去注入。
	我们把IoC容器管理的程序对象叫做bean。容器启动时，为所有声明的bean创建实例并统一管理。

	这个IoC容器就表现为一个简单的ClassPathXmlApplicationContext类，内部记录beandefinition以及存放bean的map：
    private List<BeanDefinition> beanDefinitions=new ArrayList<BeanDefinition>();
    private Map<String, Object> singletons =new HashMap<String, Object>();

	beandefinition是bean的定义声明，现在只是简单记录id和class name。
    	private String id;
    	private String className;

	为了让用户灵活配置bean，用一个外部的XML文件进行配置，格式如下：
	<?xml version="1.0" encoding="UTF-8"?>
	<beans>
		<bean id="aservice" class="com.beginner.test.AServiceImpl"></bean>
	</beans>
	Minis启动的时候，从外部XML文件中读取bean的定义，生成beandefinition对象并存放到beanDefinitions list中。
	（通过dom4j解析XML文件，要用到第三方包dom4j-1.6.1.jar）

  	Minis通过Class.forName加载bean，加载后立即 new instance（非Lazy模式，以后再考虑Lazy模式），并放到bean map中：
    singletons.put(beanDefinition.getId(),Class.forName(beanDefinition.getClassName()).newInstance());

	这个负责存放bean的map，我们起名叫singletons，这个名字隐含的意思是现在Minis中bean是singleton单例的，
	未来再考虑prototype特性。

	这样，ClassPathXmlApplicationContext一新建，就装载并实例化了所有的bean。

	客户程序使用Minis容器，目前采用编程式。
	先创建一个容器，将beans.xml作为参数，这个文件里面是所有声明的bean。
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

 	然后客户程序再通过编程式从context中获取bean
   	AService aService=(AService)ctx.getBean("aservice");

	到此有了一个微型的容器了。
	不足：beandefinitin信息太少；装载XML的方法不能override；需要客户程序编程式初始化容器；不能自动注入bean；没有创建bean的API接口。


2.
	微型容器的代码写在一个类中ClassPathXmlApplicationContext，我们要进一步扩展它，使得它更加强大
	更加可配置。
	按照各负其责的思路，把独立的功能都各自独立出去，用ClassPathXmlApplicationContext集成。

	首先把读写XML文件的程序独立出来，	文件中的内容抽象成Resource的概念，用ClassPathXmlResource
	来负责文件格式解析，把XML文件中读取出来的内容放在Resource中。
	用类XmlBeanDefinitionReader从ClassPathXmlResource中读取数据，组成beandefinition注册到容器中。
	数据的演变路径：XML文件 - Resource - Bean Definition

	增加NoSuchBeanDefinitionException

	管理bean的容器核心功能也单独放在一个类BeanFactory中，接口如下：
		Object getBean(String beanName) throws NoSuchBeanDefinitionException;
		void registerBeanDefinition(BeanDefinition bd);
	我们用SimpleBeanFactory类实现，把以前放在ClassPathXmlApplicationContext里面的数据放在这个类里面：
	    private List<BeanDefinition> beanDefinitions=new ArrayList<>();
    	private List<String> beanNames=new ArrayList<>();
    	private Map<String, Object> singletons =new HashMap<>();

	最基本的getBean()实现了延后new instance：
    public Object getBean(String beanName) throws NoSuchBeanDefinitionException{
        Object singleton = singletons.get(beanName);
        if (singleton == null) {
        	int i = beanNames.indexOf(beanName);
        	if (i == -1) {
        		throw new NoSuchBeanDefinitionException();
        	}
        	else {
        		BeanDefinition bd = beanDefinitions.get(i);
            	singleton=Class.forName(bd.getClassName()).newInstance();
				singletons.put(bd.getId(),singleton);
        	}
        }
        return singleton;
    }

	这样原本ClassPathXmlApplicationContext就演变成了一个集成环境，包含了 BeanFactory，使用reader装载:
    public ClassPathXmlApplicationContext(String fileName){
    	Resource res = new ClassPathXmlResource(fileName);
    	BeanFactory bf = new SimpleBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(bf);
        reader.loadBeanDefinitions(res);
        this.beanFactory = bf;
    }
    constructor里面仅仅加载了bean的定义，没有生成bean实例，实例由getBean方法延迟加载。

	并由它代理访问beanfactory里面的getBean()方法：
	public Object getBean(String beanName) throws NoSuchBeanDefinitionException {
		return this.beanFactory.getBean(beanName);
	}

	Minis的package结构演变成了:
	com.minis.beans
	com.minis.context
	com.minis.core

	客户程序没有变化，还是采用编程式。


3.
	把从BeanFactory里面进一步抽取出DefaultSingletonBeanRegistry，registry里面放beans/singletons:
	    protected List<String> beanNames=new ArrayList<>();
    	protected Map<String, Object> singletons =new ConcurrentHashMap<>(256);

    	void registerSingleton(String beanName, Object singletonObject);
    	Object getSingleton(String beanName);
    	boolean containsSingleton(String beanName);
    	String[] getSingletonNames();
	Registry相当于一个仓库，只负责保有beans/singletons，BeanFactory提供对外的接口getBean().
	注：考虑多线程，此处用的ConcurrentHashMap。

	SimpleBeanFactory新定义如下，继承DefaultSingletonBeanRegistry：
	public class SimpleBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory{
    	private Map<String,BeanDefinition> beanDefinitions=new ConcurrentHashMap<>(256);

    	Object getBean(String name) throws BeansException;
		boolean containsBean(String name);
		void registerBean(String beanName, Object obj);
    }

	ClassPathXmlApplicationContext构建的时候只读了bean的定义信息，没有生成bean。
	在BeanFactory的接口getBean()中判断，还没有生成bean就现生成。

	增加了BeanException.

	此处我们准备了AplicationEvent和ApplicationEventPublisher为后来使用。


4.
	进一步丰富BeanDefinition, 有了新的属性：
		String SCOPE_SINGLETON = "singleton";
		String SCOPE_PROTOTYPE = "prototype";
		private String scope=SCOPE_SINGLETON;
		private boolean lazyInit = false;
		private String[] dependsOn;
		private ArgumentValues constructorArgumentValues;
		private PropertyValues propertyValues;
		private String initMethodName;
		private volatile Object beanClass;
	    private String id;
	    private String className;
	主要的新增属性是constructorArguments和propertyValues.用于反映bean中的构造方法和属性，以备后用。

	抽取出一个管理beandefinition的接口：
		public interface BeanDefinitionRegistry {
			void registerBeanDefinition(String name, BeanDefinition bd);
			void removeBeanDefinition(String name);
			BeanDefinition getBeanDefinition(String name);
			boolean containsBeanDefinition(String name);
		}

	BeanFactory提供了更多接口：
	    Object getBean(String name) throws BeansException;
		boolean containsBean(String name);
		boolean isSingleton(String name);
		boolean isPrototype(String name);
		Class<?> getType(String name);

	扩展核心实现类SimpleBeanFactory，新定义如下：
	class SimpleBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory,BeanDefinitionRegistry

	核心的getBean()方法，new instance的单独抽出来ingleton=createBean(bd)：
    public Object getBean(String beanName) throws BeansException{
        Object singleton = this.getSingleton(beanName);
        if (singleton == null) {
        		BeanDefinition bd = beanDefinitionMap.get(beanName);
            	singleton=createBean(bd);
				this.registerBean(beanName, singleton);
        }
        if (singleton == null) {
        	throw new BeansException("bean is null.");
        }
        return singleton;
    }
    createBean()方法，现在还是只简单地new instance。
    private Object createBean(BeanDefinition bd) {
		Object obj = null;
		try {
    		obj = Class.forName(bd.getClassName()).newInstance();
		}
		return obj;
	}
	后面会结合构造方法和属性，扩展成一个更加完善的createBean().


5.
	增强createBean()，实现了通过特定的构造方法创建bean，并可以设置Property。
	Bean的XML配置如下：
	<bean id="aservice" class="com.minis.test.AServiceImpl">
		<constructor-arg type="String" name="name" value="abc"/>
		<constructor-arg type="int" name="level" value="3"/>
        <property type="String" name="property1" value="Someone says"/>
        <property type="String" name="property2" value="Hello World!"/>
	</bean>

	从beandefinition中获取构造方法和Property
	    	//handle constructor
    		ArgumentValues constructorArgumentValues = bd.getConstructorArgumentValues();
    		if (!constructorArgumentValues.isEmpty()) {
        		Class<?>[] paramTypes = new Class<?>[constructorArgumentValues.getArgumentCount()];
        		Object[] paramValues =   new Object[constructorArgumentValues.getArgumentCount()];
    			for (int i=0; i<constructorArgumentValues.getArgumentCount(); i++) {
    				ArgumentValue constructorArgumentValue = constructorArgumentValues.getIndexedArgumentValue(i);
    				if ("String".equals(constructorArgumentValue.getType()) || "java.lang.String".equals(constructorArgumentValue.getType())) {
    					paramTypes[i] = String.class;
        				paramValues[i] = constructorArgumentValue.getValue();
    				}
    				else if ("Integer".equals(constructorArgumentValue.getType()) || "java.lang.Integer".equals(constructorArgumentValue.getType())) {
    					paramTypes[i] = Integer.class;
        				paramValues[i] = Integer.valueOf((String) constructorArgumentValue.getValue());
    				}
    				else if ("int".equals(constructorArgumentValue.getType())) {
    					paramTypes[i] = int.class;
        				paramValues[i] = Integer.valueOf((String) constructorArgumentValue.getValue()).intValue();
    				}
    				else {
    					paramTypes[i] = String.class;
        				paramValues[i] = constructorArgumentValue.getValue();
    				}
    			}
				try {
					con = clz.getConstructor(paramTypes);
					obj = con.newInstance(paramValues);
				}
			}
		从上面代码可以看出，目前我们采用的是argumentValues.getIndexedArgumentValue()这个方法，按照构造方法参数的
		索引值使用参数。并且目前只支持String和integer类型。

		//handle properties
		PropertyValues propertyValues = bd.getPropertyValues();
		if (!propertyValues.isEmpty()) {
			for (int i=0; i<propertyValues.size(); i++) {
				PropertyValue propertyValue = propertyValues.getPropertyValueList().get(i);
				String pName = propertyValue.getName();
				String pType = propertyValue.getType();
    			Object pValue = propertyValue.getValue();

    			Class<?>[] paramTypes = new Class<?>[1];
				if ("String".equals(pType) || "java.lang.String".equals(pType)) {
					paramTypes[0] = String.class;
				}
				else if ("Integer".equals(pType) || "java.lang.Integer".equals(pType)) {
					paramTypes[0] = Integer.class;
				}
				else if ("int".equals(pType)) {
					paramTypes[0] = int.class;
				}
				else {
					paramTypes[0] = String.class;
				}

				Object[] paramValues =   new Object[1];
				paramValues[0] = pValue;

    			String methodName = "set" + pName.substring(0,1).toUpperCase() + pName.substring(1);

    			Method method = null;
				try {
					method = clz.getMethod(methodName, paramTypes);
					method.invoke(obj, paramValues);
				}
			}
		}
		从上面代码可以看出，我们是通过调用setProperty()这一类方法设置的属性值，要求bean的属性有Setter。
		目前也只支持String和integer类型。

	ClassPathXmlApplicationContext仍然是一个集成环境，通过外部的XML文件加载beandefinition。
	并不立刻创建bean instance，而是在getBean()的时候创建。
	public ClassPathXmlApplicationContext(String fileName){
    	Resource res = new ClassPathXmlResource(fileName);
    	SimpleBeanFactory bf = new SimpleBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(bf);
        reader.loadBeanDefinitions(res);
        this.beanFactory = bf;
    }


6.
	到目前为止，ClassPathXmlApplicationContext初始化的时候只是加载了beandefinition，
	并没有立刻创建bean的instance。在此，提供一个容器的refresh()方法创建所有的bean instance，
	context初始化的时候可以调用beanfactory的refresh()。
	public ClassPathXmlApplicationContext(String fileName, boolean isRefresh){
    	Resource res = new ClassPathXmlResource(fileName);
    	SimpleBeanFactory bf = new SimpleBeanFactory();
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(bf);
        reader.loadBeanDefinitions(res);
        this.beanFactory = bf;

        if (isRefresh) {
        	this.beanFactory.refresh();
        }
    }
	看上面的代码，可以把isRefresh标志理解为Lazy模式的实现。

	而beanfactory里的refresh()很简单，就是对所有的bean调用了一次getBean()，利用getBean()方法
	中的创建bean instance把容器中所有的bean instance创建出来。
	public void refresh() {
    	for (String beanName : beanDefinitionNames) {
    		try {
				getBean(beanName);
			} catch (BeansException e) {
				e.printStackTrace();
			}
    	}
    }

	bean里面的Property的ref可以支持引用了，即可以是引用另一个bean：
	<bean id="basebaseservice" class="com.minis.test.BaseBaseService">
	    <property type="com.minis.test.AServiceImpl" name="as" ref="aservice"/>
	</bean>
	我们改造一下以前的createBean()方法，抽取出一个单独的处理属性的方法来：
	void handleProperties(BeanDefinition bd, Class<?> clz, Object obj);
	//is ref, create the dependent beans
    	try {
			paramTypes[0] = Class.forName(pType);
			paramValues[0] = getBean((String)pValue);
		}
	从上面代码可以看到实现的思路，就是对ref所指向的另一个bean再次调用getBean()方法。
	如果有多级引用，形成一个多级的getBean()调用链。
	因为getBean的时候,会判断容器中是否包含了bean instance，没有的话会现创建，所以XML
	中声明bean的先后次序是任意的。

	但是这样会引出一个循环引用的问题，比如A引用到B，B又引用到C，而C又引用到A。这种情况下，
	创建的过程会成为死结，我们必须想办法打破这个循环。如：
	<bean id="basebaseservice" class="com.minis.test.BaseBaseService">
	    <property type="com.minis.test.AServiceImpl" name="as" ref="aservice"/>
	</bean>
	<bean id="aservice" class="com.minis.test.AServiceImpl">
		<constructor-arg type="String" name="name" value="abc"/>
		<constructor-arg type="int" name="level" value="3"/>
        <property type="String" name="property1" value="Someone says"/>
        <property type="String" name="property2" value="Hello World!"/>
        <property type="com.minis.test.BaseService" name="ref1" ref="baseservice"/>
	</bean>
	<bean id="baseservice" class="com.minis.test.BaseService">
	        <property type="co
	        m.minis.test.BaseBaseService" name="bbs" ref="basebaseservice"/>
	</bean>

	我们的做法是给容器中引入一个临时的结构Map<String, Object> earlySingletonObjects：
	public class SimpleBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory,BeanDefinitionRegistry{
    	private Map<String,BeanDefinition> beanDefinitionMap=new ConcurrentHashMap<>(256);
    	private List<String> beanDefinitionNames=new ArrayList<>();
		private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
	这个earlySingletonObjects中保存的是毛胚状态的bean instance,所谓毛胚状态，就是bean已经创建了instance但是
	property都还没有设置，等着后续处理。
	我们从createBean()方法中单独抽取一个doCreateBean(bd)方法来专门负责毛胚bean的创建，创建好
	毛胚bean后放到临时的earlySingletonObjects结构中，然后再调用handleProperties补齐这些property的值：
	private Object createBean(BeanDefinition bd) {
		Class<?> clz = null;

		Object obj = doCreateBean(bd);
		this.earlySingletonObjects.put(bd.getId(), obj);
		clz = Class.forName(bd.getClassName());

		handleProperties(bd, clz, obj);

		return obj;
	}

	在getBean()的时候，就要判断earlySingletonObjects有没有毛胚bean：
	public Object getBean(String beanName) throws BeansException{
        Object singleton = this.getSingleton(beanName);

        if (singleton == null) {
        	singleton = this.earlySingletonObjects.get(beanName);
        	if (singleton == null) {
        		BeanDefinition bd = beanDefinitionMap.get(beanName);
            	singleton=createBean(bd);
				this.registerBean(beanName, singleton);

        	}
        }

        return singleton;
    }



7.
	createBean()里面不直接handleProperties()了，而是扩充一下概念，调用一个新方法：
		populateBean(bd, clz, obj);
		目前阶段，populateBean()只做一件事情：调用handleProperties()
		private void populateBean(BeanDefinition bd, Class<?> clz, Object obj) {
			handleProperties(bd, clz, obj);
		}

	增强getBean()，在createBean()之后，支持beanpostprocessor和init-method:
		//beanpostprocessor
		//step 1 : postProcessBeforeInitialization
		applyBeanPostProcessorsBeforeInitialization(singleton, beanName);

		//step 2 : init-method
		if (bd.getInitMethodName() != null && !bd.getInitMethodName().equals("")) {
			invokeInitMethod(bd, singleton);
		}

		//step 3 : postProcessAfterInitialization
		applyBeanPostProcessorsAfterInitialization(singleton, beanName);

	为了扩展性，把SimpleBeanFactory分成了AbstractBeanFactory和AutowireCapableBeanFactory。
	AbstractBeanFactory中applyBeanPostProcessorsBeforeInitialization和applyBeanPostProcessorsAfterInitialization
	是abstract的。需要在AutowireCapableBeanFactory中去实现，这个类实现了自动注入。(AutowireCapableBeanFactory通过BeanPostProcessor实现了Autowired)

	定义如下：
	public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory,BeanDefinitionRegistry;
	public class AutowireCapableBeanFactory extends AbstractBeanFactory{
		private final List<AutowiredAnnotationBeanPostProcessor> beanPostProcessors = new ArrayList<AutowiredAnnotationBeanPostProcessor>();
	}
	这个AutowireCapableBeanFactory扩展出来的功能是支持Autowired自动注入,所以里面有一个list存放了AutowiredAnnotationBeanPostProcessor。

	Autowired注解定义如下：
	@Target(ElementType.FIELD)
	@Retention(RetentionPolicy.RUNTIME)
	public @interface Autowired {
	}

	BeanPostProcessor接口提供两个方法：
		Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
		Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

	我们在postProcessBeforeInitialization()方法中利用Java的reflection机制进行属性设置，达到自动注入的目的。
	因此可以看出，在bean的initmethod被调用之前，这些该注入的属性都已经设置好了。

	实际的注入代码实现如下：
		String fieldName = field.getName();
		Object autowiredObj = this.getBeanFactory().getBean(fieldName);
		field.set(bean, autowiredObj);
	可以看出，目前我们支持的是按照名称匹配进行注入，这点与Spring的默认模式不一样。后期可以扩展为可配置项。

	到此，类已经比较多了，我们参照Spring的目录重新组织了一下bzuieans目录结构如下：
	com.minis
	com.minis.beans
	com.minis.beans.factory
	com.minis.beans.factory.annotation
	com.minis.beans.factory.config
	com.minis.beans.factory.support
	com.minis.beans.factory.xml

	最后，ClassPathXmlApplicationContext仍然是一个集成环境，给refresh()增加一个功能registerBeanPostProcessors():
	public void refresh() throws BeansException, IllegalStateException {
		// Register bean processors that intercept bean creation.
		registerBeanPostProcessors(this.beanFactory);

		// Initialize other special beans in specific context subclasses.
		onRefresh();
	}
	private void registerBeanPostProcessors(AutowireCapableBeanFactory bf) {
		//if (supportAutowire) {
			bf.addBeanPostProcessor(new AutowiredAnnotationBeanPostProcessor());
		//}
	}
	private void onRefresh() {
		this.beanFactory.refresh();
	}
	我们暂时只有自动注入这么一个beanpostprocessor.

	我们还为ClassPathXmlApplicationContext提供了一个BeanFactoryPostProcessor：
		private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors =
			new ArrayList<BeanFactoryPostProcessor>();
	别的程序可以利用这个结构来执行一些预处理工作。


8.
	为了扩展性，进一步提出几个interface：
	ListableBeanFactory接口扩展beanfactory，提供一些bean集合的方法。
	public interface ListableBeanFactory extends BeanFactory {
		boolean containsBeanDefinition(String beanName);
		int getBeanDefinitionCount();
		String[] getBeanDefinitionNames();
		String[] getBeanNamesForType(Class<?> type);
		<T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
	}
	ConfigurableBeanFactory接口扩展BeanFactory,SingletonBeanRegistry，提供BeanPostProcessor和dependent方法：
	public interface ConfigurableBeanFactory extends BeanFactory,SingletonBeanRegistry {
		String SCOPE_SINGLETON = "singleton";
		String SCOPE_PROTOTYPE = "prototype";
		void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
		int getBeanPostProcessorCount();
		void registerDependentBean(String beanName, String dependentBeanName);
		String[] getDependentBeans(String beanName);
		String[] getDependenciesForBean(String beanName);
	}
	AutowireCapableBeanFactory接口提供通过beanpostprocessor实现Autowired方法：
	public interface AutowireCapableBeanFactory  extends BeanFactory{
		int AUTOWIRE_NO = 0;
		int AUTOWIRE_BY_NAME = 1;
		int AUTOWIRE_BY_TYPE = 2;
		Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
				throws BeansException;
		Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
				throws BeansException;
	}
	再用一个interface ConfigurableListableBeanFactory把上面的三个interface集成在一起。
	public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
	}

	这是设计的原则之一：接口隔离。 每个接口提供单一功能，可以组合选择实现那些接口。

	最后实现了DefaultListableBeanFactory：
	public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
					implements ConfigurableListableBeanFactory
	这个类现在成了IoC的引擎。

	ClassPathXmlApplicationContext仍然是集成环境，里面现在包含了一个DefaultListableBeanFactory：
	public class ClassPathXmlApplicationContext implements ApplicationContext{
		DefaultListableBeanFactory beanFactory;
		private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors =
				new ArrayList<BeanFactoryPostProcessor>();
	}

	为了扩展性，把ClassPathXmlApplicationContext做成一个真正的容器，具有上下文，提出下面的接口：
	public interface ApplicationContext
		extends EnvironmentCapable, ListableBeanFactory, ConfigurableBeanFactory, ApplicationEventPublisher{
	}
	支持上下文环境，支持事件发布。


9.
	丰富ApplicationContext接口，现在具有了很多容器的基本方法了：
	public interface ApplicationContext
			extends EnvironmentCapable, ListableBeanFactory, ConfigurableBeanFactory, ApplicationEventPublisher{
		String getApplicationName();
		long getStartupDate();
		ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
		void setEnvironment(Environment environment);
		Environment getEnvironment();
		void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);
		void refresh() throws BeansException, IllegalStateException;
		void close();
		boolean isActive();
	}

	提供ApplicationListener：
	public class ApplicationListener implements EventListener {
		void onApplicationEvent(ApplicationEvent event) {
			System.out.println(event.toString());
		}
	}
	使用到了ApplicationEvent.

	AbstractApplicationContext的refresh规范化成几步(注意步骤之间的先后次序)：
		postProcessBeanFactory(getBeanFactory());
		registerBeanPostProcessors(getBeanFactory());
		initApplicationEventPublisher();
		onRefresh();
		registerListeners();
		finishRefresh();
	并把这几步定义成abstract的：
		abstract void postProcessBeanFactory(ConfigurableListableBeanFactory bf);
		abstract void registerBeanPostProcessors(ConfigurableListableBeanFactory bf);
		abstract void initApplicationEventPublisher();
		abstract void onRefresh();
		abstract void registerListeners();
		abstract void finishRefresh();

	ClassPathXmlApplicationContext仍然是集成环境，不过现在简化了，继承了AbstractApplicationContext，
	实现了这些abstract方法。
	finishRefresh中会publishEvent(new ContextRefreshEvent("Context Refreshed..."));

	至此，我们的IoC就小有模样了。



-----------------------------------MVC--------------------------------------
MVC的基本思路是屏蔽servlet的概念，让应用程序员只需要了解很少的servlet，主要写业务逻辑。浏览器访问的
URL通过映射机制找到实际的业务逻辑方法。
按照servlet规范，可以通过Filter拦截，也可以通过Servlet拦截。实际的实现过程中，我通过DispatcherServlet
拦截所有请求，处理映射关系，调用业务逻辑代码，处理返回值回递给浏览器。
程序员写的业务逻辑程序，我们叫做bean。

1.
	写了一个DispatcherServlet，由它来处理所有请求，初始化的时候从外部xml文件读取mapping信息：
	  <servlet>
	    <servlet-name>minisMVC</servlet-name>
	    <servlet-class>com.minis.web.DispatcherServlet</servlet-class>
	    <init-param>
	      <param-name>contextConfigLocation</param-name>
	      <param-value> /WEB-INF/minisMVC-servlet.xml </param-value>
	    </init-param>
	    <load-on-startup>1</load-on-startup>
	  </servlet>
	  <servlet-mapping>
	    <servlet-name>minisMVC</servlet-name>
	    <url-pattern>/</url-pattern>
	  </servlet-mapping>

	定义外部minisMVC-servlet.xml文件格式：
	<bean id="/helloworld" class="com.minis.test.HelloWorldBean" value="doGet" />


	DispatcherServlet内部记录在三个Map中，记录了URL对应的类对象和方法
	    private Map<String,MappingValue> mappingValues;
    	private Map<String,Class<?>> mappingClz = new HashMap<>();
    	private Map<String,Object> mappingObjs = new HashMap<>();

    init()的核心代码：
    public void init(ServletConfig config) throws ServletException {
    	super.init(config);

        sContextConfigLocation = config.getInitParameter("contextConfigLocation");

        URL xmlPath = null;
		xmlPath = this.getServletContext().getResource(sContextConfigLocation);
		Resource rs = new ClassPathXmlResource(xmlPath);
        XmlConfigReader reader = new XmlConfigReader();
        mappingValues = reader.loadConfig(rs);
        Refresh();
    }
	从上述代码可以看出，这个DispatcherServlet初始化的时候，由config(通过容器如Tomcat传入)
	从外部的文件(由contextConfigLocation初始化参数定义)读取资源，把minisMVC-servlet.xml
	定义的bean定义转换成内存结构Map<String,MappingValue> mappingValues。
	读取外部文件，解析XML，生成内部结构，这些操作由ClassPathXmlResource和XmlConfigReader完成，
	这个实现接近于IoC中的相应功能。
	最后调用它Refresh()实际创建bean.

	protected void Refresh() {
    	for (Map.Entry<String,MappingValue> entry : mappingValues.entrySet()) {
    		String id = entry.getKey();
    		String className = entry.getValue().getClz();
    		Object obj = null;
    		Class<?> clz = null;

			clz = Class.forName(className);
			obj = clz.newInstance();

			mappingClz.put(id, clz);
    		mappingObjs.put(id, obj);
    	}
    }
    Refresh()就是通过读取mappingValues中的bean定义，加载类，创建实例。

	这个servlet负责所有请求，我们先实现doGet:
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		String sPath = request.getServletPath();

		Class<?> clz = this.mappingClz.get(sPath);
		Object obj = this.mappingObjs.get(sPath);
		String methodName = this.mappingValues.get(sPath).getMethod();
		Object objResult = null;

		Method method = clz.getMethod(methodName);
		objResult = method.invoke(obj);

		response.getWriter().append(objResult.toString());
	}
	这是一个框架实现，它从mappingClz，mappingObjs和mappingValues获取与当前请求url关联的bean信息，
	然后调用实例的相关方法，返回结构通过response返回。

	这个实现很简陋，调用的方法没有参数，返回值只是String，回写直接通过response。


2.
	通过	定义外部minisMVC-servlet.xml文件格式：
	<bean id="/helloworld" class="com.minis.test.HelloWorldBean" value="doGet" />
	每个业务逻辑的方法都要定义一次，很麻烦。

	我们现在支持<component-scan base-package="com.minis.test"/>扫描所有的相关类
	并支持注解   @RequestMapping 来实现url和方法的映射。

	先修改minisMVC-servlet.xml文件格式：
	<components>
	<component-scan base-package="com.minis.test"/>
	</components>
	不再一个类一个类一个方法一个方法声明了，简单地写一个package就可以了。
	packages里面的类，我们不把它们叫bean，而是用一个特殊的名字controller.

	同时提供注解,将url与这个方法进行映射：
	@Target(value={ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface RequestMapping {
	    String value() default "";
	}
	目前，我们不提供类级别的RequestMapping.

	DispatcherServlet中用如下结构保存映射声明：
		private List<String> packageNames = new ArrayList<>();
	    private Map<String,Object> controllerObjs = new HashMap<>();
	    private List<String> controllerNames = new ArrayList<>();
	    private Map<String,Class<?>> controllerClasses = new HashMap<>();
	    private List<String> urlMappingNames = new ArrayList<>();
	    private Map<String,Object> mappingObjs = new HashMap<>();
	    private Map<String,Method> mappingMethods = new HashMap<>();
	packageNames是需要扫描的package列表；
	urlMappingNames是定义的 @RequestMapping名字（url名字）列表；
	mappingObjs保有的是url名字与对象的映射；
	mappingObjs保有的是url名字与方法的映射；
	controllerNames是controller的名字列表；
	controllerClasses是controller名字与类的映射；
	controllerObjs是controller名字与对象的映射；

	我们不再用ClassPathXmlResource和XmlConfigReader提供bean的注册，而是用一个
	XmlScanComponentHelper类扫描minisMVC-servlet.xml，拿到List<String> packages。
	private List<String> scanPackage(String packageName) {
    	List<String> tempControllerNames = new ArrayList<>();
        URL url  =this.getClass().getClassLoader().getResource("/"+packageName.replaceAll("\\.", "/"));
        File dir = new File(url.getFile());
        for (File file : dir.listFiles()) {
            if(file.isDirectory()){
            	scanPackage(packageName+"."+file.getName());
            }else{
                String controllerName = packageName +"." +file.getName().replace(".class", "");
                tempControllerNames.add(controllerName);
            }
        }
        return tempControllerNames;
    }
	考虑目录下还有子目录，所以用到了递归。
	结果就是把package下所有的类的全名加到tempControllerNames列表中返回。

	Refresh()分成两步：
	protected void Refresh() {
    	initController();  //初始化controller
    	initMapping(); //初始化url映射
    }

	初始化controller对扫描到的每一个类进行加载和实例化，放到map中，以类名为key。
    protected void initController() {
    	this.controllerNames = scanPackages(this.packageNames);

    	for (String controllerName : this.controllerNames) {
    		Object obj = null;
    		Class<?> clz = null;

			clz = Class.forName(controllerName);
			this.controllerClasses.put(controllerName,clz);

			obj = clz.newInstance();
			this.controllerObjs.put(controllerName, obj);
    	}
    }

	初始化url映射，找到定义了@RequestMapping的方法，url存放到urlMappingNames中，映射的对象
	存放到mappingObjs中，映射的方法存放到mappingMethods中。
    protected void initMapping() {
    	for (String controllerName : this.controllerNames) {
    		Class<?> clazz = this.controllerClasses.get(controllerName);
    		Object obj = this.controllerObjs.get(controllerName);
    		Method[] methods = clazz.getDeclaredMethods();
    		if(methods!=null){
    			for(Method method : methods){
    				boolean isRequestMapping = method.isAnnotationPresent(RequestMapping.class);
    				if (isRequestMapping){
    					String methodName = method.getName();
    					String urlmapping = method.getAnnotation(RequestMapping.class).value();
    					this.urlMappingNames.add(urlmapping);
    					this.mappingObjs.put(urlmapping, obj);
    					this.mappingMethods.put(urlmapping, method);
    				}
    			}
    		}
    	}
    }
	所以这一部分程序就取代了以前的bean解析出来的映射。

	doGet方法还是没有变化。



3.
	现在我们把IoC和MVC结合在一起。使得mvc controller这一层可以引用到内部的bean。

	以前我们IoC容器用了一个main()运行启动，现在不用了，我们可以用JavaEE服务器的启动机制，
	这里我用到了Listener机制。

	增加ContextLoaderListener，持有一个WebApplicationContext：
		public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";
		private WebApplicationContext context;
	启动时注册WebApplicationContext，并设置到servletContext的Attribute中：
	public void contextInitialized(ServletContextEvent event) {
		initWebApplicationContext(event.getServletContext());
	}
	private void initWebApplicationContext(ServletContext servletContext) {
		String sContextLocation = servletContext.getInitParameter(CONFIG_LOCATION_PARAM);
		WebApplicationContext wac = new AnnotationConfigWebApplicationContext(sContextLocation);
		wac.setServletContext(servletContext);
		this.context = wac;
		servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
	}
	最关键的是创建了一个AnnotationConfigWebApplicationContext wac。这个wac与容器的servletContext互相引用。

	WebApplicationContext定义如下：
	public interface WebApplicationContext extends ApplicationContext {
		String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
		ServletContext getServletContext();
		void setServletContext(ServletContext servletContext);
	}
	public class AnnotationConfigWebApplicationContext
					extends ClassPathXmlApplicationContext implements WebApplicationContext{
		private ServletContext servletContext;
	}
	我们可以看出，AnnotationConfigWebApplicationContext实际上就是一个IoC中的ClassPathXmlApplicationContext，并且
	加入了servletContext信息，构成一个适合web场景的上下文。这样Listener启动的时候IoC容器启动了，通过刷新装载了所有管理的beans.

	合在一起后，就有两个配置文件了，一个给DispatcherServlet, 一个给ContextLoaderListener：
	applicationContext.xml:
	<?xml version="1.0" encoding="UTF-8"?>
	<beans>
		<bean id="bbs" class="com.minis.test.service.BaseBaseService">
		    <property type="com.minis.test.service.AServiceImpl" name="as" ref="aservice"/>
		</bean>
		<bean id="aservice" class="com.minis.test.service.AServiceImpl">
			<constructor-arg type="String" name="name" value="abc"/>
			<constructor-arg type="int" name="level" value="3"/>
	        <property type="String" name="property1" value="Someone says"/>
	        <property type="String" name="property2" value="Hello World!"/>
	        <property type="com.minis.test.service.BaseService" name="ref1" ref="baseservice"/>
		</bean>
		<bean id="baseservice" class="com.minis.test.service.BaseService">
		</bean>
	</beans>

	minisMVC-servlet.xml:
	<?xml version="1.0" encoding="UTF-8" ?>
	<components>
		<component-scan base-package="com.minis.test"/>
	</components>

	Dispatcher初始化的时候获取上面注册的Context,这样也就可以从servlet中拿到listener时启用的WebApplicationContext了:
    	this.webApplicationContext = (WebApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

	然后再常规的扫描Controller
        sContextConfigLocation = config.getInitParameter("contextConfigLocation");
        this.packageNames = XmlScanComponentHelper.getNodeValue(xmlPath);
        Refresh();

	到此为止，我们的WebApplicationContext和Dispatcher都准备好了。并且从Dispatcher可以访问到WebApplicationContext，
	但是注意，反过来是拿不到的，这个单向的引用必须记住。


4.
	现在有了AnnotationConfigWebApplicationContext和DispatcherServlet，我们按照分工，整理一下代码。
	我们希望DispatcherServlet最后只负责解析request请求，解析，分发，处理返回。而ApplicationContext
	则负责业务逻辑beans。
	注意到由于web的引入，业务逻辑程序分层了两层：controller和service，原理上这两层是可以完全分开的。
	为了使得结构化更好，我们引入两个application context：一个针对controller层，一个针对service层。
	service层的由listener启动的application context容器负责，而controller层的由DispatcherServlet负责启动。
	按照时序，listener先启动，我们把它叫做parentApplicationContext。DispatcherServlet启动的webapplicationcontext
	持有对parentApplicationContext的引用。

	程序实现上，分别用的XmlWebApplicationContext和AnnotationConfigWebApplicationContext。

	DispatcherServlet类中使用两个变量：
	private WebApplicationContext webApplicationContext;
	private WebApplicationContext parentApplicationContext;

	初始化的时候先从servletcontext中拿属性WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE，
	获得listener存放在这里的parentApplicationContext；然后通过contextConfigLocation配置文件创建一个新的
	webApplicationContext。
	代码如下：
    public void init(ServletConfig config) throws ServletException {
    	super.init(config);
    	this.parentApplicationContext =
    			(WebApplicationContext) this.getServletContext().getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

        sContextConfigLocation = config.getInitParameter("contextConfigLocation");
    	this.webApplicationContext = new AnnotationConfigWebApplicationContext(sContextConfigLocation,this.parentApplicationContext);

        Refresh();
    }

	扩充AnnotationConfigWebApplicationContext，把DispatcherServlet中一部分与扫描包有关的代码挪到这里.
	public class AnnotationConfigWebApplicationContext
						extends AbstractApplicationContext implements WebApplicationContext{
		private WebApplicationContext parentApplicationContext;
		private ServletContext servletContext;
		DefaultListableBeanFactory beanFactory;
		private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors =
				new ArrayList<BeanFactoryPostProcessor>();
	}

	public WebApplicationContext(String fileName, WebApplicationContext parentApplicationContext) {
		this.parentApplicationContext = parentApplicationContext;
		this.servletContext = this.parentApplicationContext.getServletContext();
        URL xmlPath = null;

		xmlPath = this.getServletContext().getResource(fileName);
        List<String> packageNames = XmlScanComponentHelper.getNodeValue(xmlPath);
        List<String> controllerNames = scanPackages(packageNames);

    	DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
        this.beanFactory = bf;
        this.beanFactory.setParent(this.parentApplicationContext.getBeanFactory());
        loadBeanDefinitions(controllerNames);

		refresh();
	}

	至此，web环境下的两个applicationcontext都构建好了，WebApplicationContext持有对parentApplicationContext的引用，
	反过来并不持有，单向的引用。
	所以会在WebApplicationContext和parentApplicationContext分别包含beans，这样getBean()的时候要考虑这一层关系，
	先从WebApplicationContext中拿，拿不到的话，再从parentApplicationContext拿。



5.
	我们接下来继续扩展dispatcher。
	以前是在doGet()中进行的如下实现：
		Method method = this.mappingMethods.get(sPath);
		obj = this.mappingObjs.get(sPath);
		objResult = method.invoke(obj);
		response.getWriter().append(objResult.toString());
	简单地根据uri找对应的method和object，然后调用，最后把返回值写到response里。
	增加了RequestMappingHandlerMapping和RequestMappingHandlerAdapter，分别负责
	包装请求对应的映射和具体的处理过程。

	以前在dispatcher中存放的映射数据如下：
	private List<String> urlMappingNames = new ArrayList<>();
    private Map<String,Object> mappingObjs = new HashMap<>();
    private Map<String,Method> mappingMethods = new HashMap<>();

	现在不再放在dispatcher中了，取而代之的是在dispatcher中存放：
	private HandlerMapping handlerMapping;
	private HandlerAdapter handlerAdapter;

	在	handlerMapping中通过MappingRegistry存放映射数据：
	public class RequestMappingHandlerMapping implements HandlerMapping {
		WebApplicationContext wac;
		private final MappingRegistry mappingRegistry = new MappingRegistry();
	}
	public class MappingRegistry {
	    private List<String> urlMappingNames = new ArrayList<>();
	    private Map<String,Object> mappingObjs = new HashMap<>();
	    private Map<String,Method> mappingMethods = new HashMap<>();
    }

	初始化过程：
	DispatcherServlet中refresh()	{
    	initController();

		initHandlerMappings(this.webApplicationContext);
		initHandlerAdapters(this.webApplicationContext);
    }
    protected void initHandlerMappings(WebApplicationContext wac) {
    	this.handlerMapping = new RequestMappingHandlerMapping(wac);
    }
    protected void initHandlerAdapters(WebApplicationContext wac) {
    	this.handlerAdapter = new RequestMappingHandlerAdapter(wac);
    }

	类RequestMappingHandlerMapping对外提供一个getHandler，通过uri拿到method调用。
    public HandlerMethod getHandler(HttpServletRequest request) throws Exception {
		String sPath = request.getServletPath();

		Method method = this.mappingRegistry.getMappingMethods().get(sPath);
		Object obj = this.mappingRegistry.getMappingObjs().get(sPath);
		HandlerMethod handlerMethod = new HandlerMethod(method, obj);

		return handlerMethod;
	}

	具体的调用方法包装成
	public HandlerMethod(Method method, Object obj) {
		this.setMethod(method);
		this.setBean(obj);
	}

	dispatcher在分发的时候变成通过：
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerMethod handlerMethod = this.handlerMapping.getHandler(processedRequest);
		HandlerAdapter ha = this.handlerAdapter;

		ha.handle(processedRequest, response, handlerMethod);
	}
	即通过handlerMapping拿到对应的handlerMethod，然后通过HandlerAdapter进行处理。

	HandlerAdapter通过反射invoke具体的方法并处理返回数据(现在仍然只是简单地写到response)：
		Method method = handler.getMethod();
		Object obj = handler.getBean();
		Object objResult = null;
		objResult = method.invoke(obj);
		response.getWriter().append(objResult.toString());



6.
	提供WebDataBinder,代表的是内部的一个目标对象:
	public WebDataBinder(Object target, String targetName) {
		this.target = target;
		this.objectName = targetName;
		this.clz = this.target.getClass();
	}

	WebDataBinder通过doBind()把Request里面的参数自动转成一个对象，过程如下：
	先从request中把参数转成内部的PropertyValues，经过整理(addBindValues())：
	public void bind(HttpServletRequest request) {
		PropertyValues mpvs = assignParameters(request);
		addBindValues(mpvs, request);
		doBind(mpvs);
	}
	注1：PropertyValues是复用了IoC中的。
	注2：assignParameters()简单地拿到request中所有参数，所以这里对多个对象处理不好

	然后调用doBind():
	private void doBind(PropertyValues mpvs) {
		applyPropertyValues(mpvs);
	}
	protected void applyPropertyValues(PropertyValues mpvs) {
		getPropertyAccessor().setPropertyValues(mpvs);
	}
	protected BeanWrapperImpl getPropertyAccessor() {
		return new BeanWrapperImpl(this.target);
	}

	BeanWrapperImpl实现了PropertyEditorRegistrySupport，这个里面事先注册了CustomNumberEditor
	和StringEditor。
		this.defaultEditors.put(int.class, new CustomNumberEditor(Integer.class, false));
		this.defaultEditors.put(Integer.class, new CustomNumberEditor(Integer.class, true));
		this.defaultEditors.put(long.class, new CustomNumberEditor(Long.class, false));
		this.defaultEditors.put(Long.class, new CustomNumberEditor(Long.class, true));
		this.defaultEditors.put(float.class, new CustomNumberEditor(Float.class, false));
		this.defaultEditors.put(Float.class, new CustomNumberEditor(Float.class, true));
		this.defaultEditors.put(double.class, new CustomNumberEditor(Double.class, false));
		this.defaultEditors.put(Double.class, new CustomNumberEditor(Double.class, true));
		this.defaultEditors.put(BigDecimal.class, new CustomNumberEditor(BigDecimal.class, true));
		this.defaultEditors.put(BigInteger.class, new CustomNumberEditor(BigInteger.class, true));

		this.defaultEditors.put(String.class, new StringEditor(String.class, true));
	这些Editor关键是实现如下方法：
		void setAsText(String text);
		void setValue(Object value);
		Object getValue();
		String getAsText();
	把格式字符串与Object进行转换，这样支持不同的数字时间格式，把一个串写进去，读一个object出来。

	BeanWrapperImpl用这些Editor这么实现值的写入：
	public void setPropertyValue(PropertyValue pv) {
		//拿到合适的getter和setter handler
		BeanPropertyHandler propertyHandler = new BeanPropertyHandler(pv.getName());
		//拿到一个相应类型的Editor
		PropertyEditor pe = this.getDefaultEditor(propertyHandler.getPropertyClz());
		pe.setAsText((String) pv.getValue());
		propertyHandler.setValue(pe.getValue());
	}


	有了这个WebDataBinder,我们再提供一个WebDataBinderFactory包装一下：
	public class WebDataBinderFactory {
		public WebDataBinder createBinder(HttpServletRequest request, Object target, String objectName) {
			WebDataBinder wbd= new WebDataBinder(target,objectName);
			initBinder(wbd, request);
			return wbd;
		}
		protected void initBinder(WebDataBinder dataBinder, HttpServletRequest request){
		}
	}

	在RequestMappingHandlerAdapter中handleInternal改写方法：
	protected void invokeHandlerMethod(HttpServletRequest request,
						HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
		WebDataBinderFactory binderFactory = new WebDataBinderFactory();

		//获取调用方法的所有参数
		Parameter[] methodParameters = handlerMethod.getMethod().getParameters();
		Object[] methodParamObjs = new Object[methodParameters.length];
		int i = 0;
		for (Parameter methodParameter : methodParameters) {
			//对某个参数，新创建一个空的对象，这个就是要bind的目标
			Object methodParamObj = methodParameter.getType().newInstance();
			//对这个参数实现bind
			WebDataBinder wdb = binderFactory.createBinder(request, methodParamObj, methodParameter.getName());
			wdb.bind(request);
			methodParamObjs[i] = methodParamObj;
			i++;
		}
		//至此bind了方法中的所有参数，可以调用了
		Method invocableMethod = handlerMethod.getMethod();
		Object returnobj = invocableMethod.invoke(handlerMethod.getBean(), methodParamObjs);

		response.getWriter().append(returnobj.toString());
	}

	至此，我们就通过RequestMappingHandlerAdapter中的invokeHandlerMethod把request中的参数自动
	转成了内部的对象。
	但是我们的实现不好，对多个参数处理不好，另外如果方法中有HttpRequest参数也没有跳过。



7.
	支持自定义的CustomEditor，实现PropertyEditor接口：
	public interface PropertyEditor {
		void setAsText(String text);
		void setValue(Object value);
		Object getValue();
		String getAsText();
	}
	把格式字符串与Object进行转换，这样支持不同的数字时间或者别的类型的格式，把一个串写进去，读一个object出来，
	如CustomDateEditor。

	系统提供一个WebBindingInitializer接口，用它注册自定义的CustomEditor:
	public interface WebBindingInitializer {
		void initBinder(WebDataBinder binder);
	}

	应用程序员自己实现一个WebBindingInitializer，在initBinder中注册自定义Editor，如自定义日期格式：
	public class DateInitializer implements WebBindingInitializer{
	@Override
	public void initBinder(WebDataBinder binder) {
		binder.registerCustomEditor(Date.class, new CustomDateEditor(Date.class,"yyyy-MM-dd", false));
	}
	这个CustomDateEditor类的构造方法：
		public CustomDateEditor(Class<Date> dateClass,
				String pattern, boolean allowEmpty) throws IllegalArgumentException {
			this.dateClass = dateClass;
			this.datetimeFormatter = DateTimeFormatter.ofPattern(pattern);
			this.allowEmpty = allowEmpty;
		}

	RequestMappingHandlerAdapter中增加一个属性：
		WebBindingInitializer webBindingInitializer
	构造方法中从getBean("webBindingInitializer")
	public RequestMappingHandlerAdapter(WebApplicationContext wac) {
		this.wac = wac;
		this.webBindingInitializer = (WebBindingInitializer) this.wac.getBean("webBindingInitializer");
	}
	也就是说用户通过applicationContext.xml配置webBindingInitializer：
		<bean id="webBindingInitializer" class="com.minis.test.DateInitializer">
		</bean>

	然后HandlerAdapter修改为：
		protected void invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		for (Parameter methodParameter : methodParameters) {
			//对某个参数，新创建一个空的对象，这个就是要bind的目标
			Object methodParamObj = methodParameter.getType().newInstance();
			//对这个参数实现bind
			WebDataBinder wdb = binderFactory.createBinder(request, methodParamObj, methodParameter.getName());
			webBindingInitializer.initBinder(wdb); //注册binder中的editor
			wdb.bind(request);
			methodParamObjs[i] = methodParamObj;
			i++;
		}

	BeanWrapperImpl所继承的类 PropertyEditorRegistrySupport 增加customEditors属性：
		private Map<Class<?>, PropertyEditor> defaultEditors;
		private Map<Class<?>, PropertyEditor> customEditors;

	最后BeanWrapperImpl修改为先取CustomEditor再取DefaultEditor：
	public void setPropertyValue(PropertyValue pv) {
		BeanPropertyHandler propertyHandler = new BeanPropertyHandler(pv.getName());
		PropertyEditor pe = this.getCustomEditor(propertyHandler.getPropertyClz());
		if (pe == null) {
			pe = this.getDefaultEditor(propertyHandler.getPropertyClz());

		}
		if (pe != null) {
			pe.setAsText((String) pv.getValue());
			propertyHandler.setValue(pe.getValue());
		}
		else {
			propertyHandler.setValue(pv.getValue());
		}
	}

	这样，就支持了用户自定义的CustomEditor.



8.
	支持@ResponseBody
	增加从controller返回给前端的字符流数据格式转换支持。
	public interface HttpMessageConverter {
		void write(Object obj, HttpServletResponse response) throws IOException;
	}
	给了一个默认的实现：DefaultHttpMessageConverter，把object转成Json串。
		String defaultContentType = "text/json;charset=UTF-8";
		String defaultCharacterEncoding = "UTF-8";
		ObjectMapper objectMapper;

		public void write(Object obj, HttpServletResponse response) throws IOException {
	        response.setContentType(defaultContentType);
	        response.setCharacterEncoding(defaultCharacterEncoding);
	        writeInternal(obj, response);
	        response.flushBuffer();
		}
		private void writeInternal(Object obj, HttpServletResponse response) throws IOException{
			String sJsonStr = this.objectMapper.writeValuesAsString(obj);
			PrintWriter pw = response.getWriter();
			pw.write(sJsonStr);
		}


	定义一个ObjectMapper:
		public interface ObjectMapper {
			void setDateFormat(String dateFormat);
			void setDecimalFormat(String decimalFormat);
			String writeValuesAsString(Object obj);
		}
	给了一个默认的实现：DefaultObjectMapper，在	writeValuesAsString中拼JSon串。
			if (value instanceof Date) {
				LocalDate localDate = ((Date)value).toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
				strValue = localDate.format(this.datetimeFormatter);
			}
			else if (value instanceof BigDecimal || value instanceof Double || value instanceof Float){
				strValue = this.decimalFormatter.format(value);
			}
			else {
				strValue = value.toString();
			}
	目前为止，我们也只支持Date, Number和String三种类型。

	RequestMappingHandlerAdapter增加两个属性：
	public class RequestMappingHandlerAdapter implements HandlerAdapter {
		private WebBindingInitializer webBindingInitializer = null;
		private HttpMessageConverter messageConverter = null;

	方法invokeHandlerMethod()增加	messageConverter 处理:
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

			... ...

			if (invocableMethod.isAnnotationPresent(ResponseBody.class)){ //ResponseBody
		        this.messageConverter.write(returnObj, response);
			}

			... ...
	}


	这些webBindingInitializer和messageConverter都通过配置注入：
	<bean id="handlerAdapter" class="com.minis.web.servlet.RequestMappingHandlerAdapter">
	 <property type="com.minis.web.HttpMessageConverter" name="messageConverter" ref="messageConverter"/>
	 <property type="com.minis.web.WebBindingInitializer" name="webBindingInitializer" ref="webBindingInitializer"/>
	</bean>

	<bean id="webBindingInitializer" class="com.minis.test.DateInitializer" />

	<bean id="messageConverter" class="com.minis.web.DefaultHttpMessageConverter">
	 <property type="com.minis.web.ObjectMapper" name="objectMapper" ref="objectMapper"/>
	</bean>
	<bean id="objectMapper" class="com.minis.web.DefaultObjectMapper" >
	 <property type="String" name="dateFormat" value="yyyy/MM/dd"/>
	 <property type="String" name="decimalFormat" value="###.##"/>
	</bean>

	DispatcherServlet中通过getBean获取handlerAdapter（约定一个名字）。
	protected void initHandlerAdapters(WebApplicationContext wac) {
 		this.handlerAdapter = (HandlerAdapter) wac.getBean(HANDLER_ADAPTER_BEAN_NAME);
    }

	客户程序HelloWorldBean:
		@RequestMapping("/test7")
		@ResponseBody
		public User doTest7(User user) {
			user.setName(user.getName() + "---");
			user.setBirthday(new Date());
			return user;
		}

	完成数据的转换之后，我们接着实现ModelAndView：
	public class ModelAndView {
		private Object view;
		private Map<String, Object> model = new HashMap<>();
	}

	类RequestMappingHandlerAdapter的	方法invokeHandlerMethod() 返回值改为ModelAndView:
		protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

			... ...

			ModelAndView mav = null;
			if (invocableMethod.isAnnotationPresent(ResponseBody.class)){ //ResponseBody
		        this.messageConverter.write(returnObj, response);
			}
			else {
				if (returnObj instanceof ModelAndView) {
					mav = (ModelAndView)returnObj;
				}
				else if(returnObj instanceof String) {
					String sTarget = (String)returnObj;
					mav = new ModelAndView();
					mav.setViewName(sTarget);
				}
			}

			return mav;
		}

	DispatcherServlet修改：
	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerMethod handlerMethod = null;
		ModelAndView mv = null;

		handlerMethod = this.handlerMapping.getHandler(processedRequest);
		mv = ha.handle(processedRequest, response, handlerMethod);

		render(processedRequest, response, mv);
	}

	//用jsp 进行render
	protected void render( HttpServletRequest request, HttpServletResponse response,ModelAndView mv) throws Exception {
		if (mv == null) { //@ResponseBody
			response.getWriter().flush();
			response.getWriter().close();
			return;
		}
		//获取model，写到request的Attribute中：
		Map<String, Object> modelMap = mv.getModel();
		for (Map.Entry<String, Object> e : modelMap.entrySet()) {
			request.setAttribute(e.getKey(),e.getValue());
		}

		String sTarget = mv.getViewName();
		String sPath = "/" + sTarget + ".jsp";
		request.getRequestDispatcher(sPath).forward(request, response);
	}

	客户程序HelloWorldBean:
		@RequestMapping("/test5")
		public ModelAndView doTest5(User user) {
			ModelAndView mav = new ModelAndView("test","msg",user.getName());
			return mav;
		}



9.
	支持前端View，核心是render().
	public interface View {
		void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response);
	}
	Controller返回值增加ModelAndView：
	public class ModelAndView {
		private Object view;
		private Map<String, Object> model = new HashMap<>();
	}

	DispatcherServlet增加属性：
		private ViewResolver viewResolver;

	DispatcherServlet初始化后刷新：
		protected void Refresh() {
			initHandlerMappings(this.webApplicationContext);
			initHandlerAdapters(this.webApplicationContext);
			initViewResolvers(this.webApplicationContext);
    	}

	RequestMappingHandlerAdapter调用invokeHandlerMethod拿到返回值后进行如下处理：
				if (returnObj instanceof ModelAndView) {
					mav = (ModelAndView)returnObj;
				}
				else if(returnObj instanceof String) {
					String sTarget = (String)returnObj;
					mav = new ModelAndView();
					mav.setViewName(sTarget);
				}

	DispatcherServlet调用RequestMappingHandlerAdapter的invokeHandlerMethod后处理范式的ModelAndView，
		mv = ha.handle(processedRequest, response, handlerMethod);
		render(processedRequest, response, mv);

	render的实现，就是先按照规则找到具体的view(某个jdp页面)，拿到model数据，然后再render：
	protected void render( HttpServletRequest request, HttpServletResponse response,ModelAndView mv) throws Exception {
		String sTarget = mv.getViewName();
		Map<String, Object> modelMap = mv.getModel();
		View view = resolveViewName(sTarget, modelMap, request);
		view.render(modelMap, request, response);
	}

	提供一个默认的JstlView实现：
	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		for (Entry<String, ?> e : model.entrySet()) {
			request.setAttribute(e.getKey(),e.getValue());
		}

		request.getRequestDispatcher(getUrl()).forward(request, response);
	}

	这些也是通过配置注入的：
	<bean id="viewResolver" class="com.minis.web.servlet.view.InternalResourceViewResolver" >
	 <property type="String" name="viewClassName" value="com.minis.web.servlet.view.JstlView" />
	 <property type="String" name="prefix" value="/jsp/" />
	 <property type="String" name="suffix" value=".jsp" />
    </bean>

    另外，我们把容器的listener, beanfactorypostprocessor还有beanpostprocessor都配置化了。
    	<bean id="contextListener" class="com.minis.test.MyListener" />

    	<bean id="beanFactoryPostProcessor" class="com.minis.test.MyBeanFactoryPostProcessor" />

    	<bean id="autowiredAnnotationBeanPostProcessor" class="com.minis.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor" />
    	<bean id="logBeanPostProcessor" class="com.minis.test.LogBeanPostProcessor" />
    名字不重要，是通过类型匹配进行注入的。

    至此，有了完整的MVC实现。



-----------------------------------JDBC--------------------------------------
1.
	提供一个JdbcTemplate抽象类，实现基本JDBC的访问框架代码：
	现在只实现数据查询。
	public Object query(String sql) {
		Connection con = null;
		PreparedStatement stmt = null;
		ResultSet rs = null;
		Object rtnObj = null;

			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
			con = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databasename=DEMO;user=sa;password=Sql2016;");

			stmt = con.prepareStatement(sql);
			rs = stmt.executeQuery();

			rtnObj = doInStatement(rs);

		return rtnObj;
	}

	真正的业务代码留给用户自己实现doInStatement(),如实现User类：
	public class UserJdbcImpl extends JdbcTemplate {
	@Override
	protected Object doInStatement(ResultSet rs) {
		User rtnUser = null;
			if (rs.next()) {
				rtnUser = new User();
				rtnUser.setId(rs.getInt("id"));
				rtnUser.setName(rs.getString("name"));
				rtnUser.setBirthday(new java.util.Date(rs.getDate("birthday").getTime()));
			}

		return rtnUser;
	}

	原有的UserService改成：
	public class UserService {
		public User getUserInfo(int userid) {
			String sql = "select id, name,birthday from users where id="+userid;
			JdbcTemplate jdbcTemplate = new UserJdbcImpl();
			User rtnUser = (User)jdbcTemplate.query(sql);

			return rtnUser;
		}
	}

	这一步仅仅只做到了把JDBC查询语句中的格式化的语句抽离出来，让应用程序员只需要管sql语句并返回数据对象。




2.
	为了不让每个实体类都对应一个UserJdbcImpl类，写成callback模式，让用户自己动态写入：
	public Object query(StatementCallback stmtcallback) {
		Connection con = null;
		Statement stmt = null;

			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
			con = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databasename=DEMO;user=sa;password=Sql2016;");

			stmt = con.createStatement();

			return stmtcallback.doInStatement(stmt);
	}

	同时支持PreparedStatement：
	public Object query(String sql, Object[] args, PreparedStatementCallback pstmtcallback) {
		Connection con = null;
		PreparedStatement pstmt = null;

			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
			con = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databasename=DEMO;user=sa;password=Sql2016;");

			pstmt = con.prepareStatement(sql);
			if (args != null) {
				for (int i = 0; i < args.length; i++) {
					Object arg = args[i];
					if (arg instanceof String) {
						pstmt.setString(i+1, (String)arg);
					}
					else if (arg instanceof Integer) {
						pstmt.setInt(i+1, (int)arg);
					}
					else if (arg instanceof java.util.Date) {
						pstmt.setDate(i+1, new java.sql.Date(((java.util.Date)arg).getTime()));

					}
				}
			}

			return pstmtcallback.doInPreparedStatement(pstmt);
	}

	两个Callback接口如下：
	public interface StatementCallback {
		Object doInStatement(Statement stmt) throws SQLException;
	}
	public interface PreparedStatementCallback {
		Object doInPreparedStatement(PreparedStatement stmt) throws SQLException;
	}

	这样应用程序员就只需要用一个JdbcTemplate类就可以了，不用为每一个业务类单独再做一个.

	用户类改成使用Callback动态匿名类：
	public User getUserInfo(int userid) {
		final String sql = "select id, name,birthday from users where id=?";
		return (User)jdbcTemplate.query(sql, new Object[]{new Integer(userid)},
				(pstmt)->{
					ResultSet rs = pstmt.executeQuery();
					User rtnUser = null;
					if (rs.next()) {
						rtnUser = new User();
						rtnUser.setId(userid);
						rtnUser.setName(rs.getString("name"));
						rtnUser.setBirthday(new java.util.Date(rs.getDate("birthday").getTime()));
					} else {
					}
					return rtnUser;
				}
		);
	}

	由于只需要一个JdbcTemplate，我们就可以事先在IoC容器中声明这个bean，然后自动注入进来。
	<bean id="userService" class="com.minis.test.service.UserService" />
	<bean id="jdbcTemplate" class="com.minis.jdbc.core.JdbcTemplate" />

	public class UserService {
		@Autowired
		JdbcTemplate jdbcTemplate;
	}
	这里采用的是按照名字匹配注入。

	controller再注入service：
	public class HelloWorldBean {
		@Autowired
		UserService userService;

		@RequestMapping("/test8")
		@ResponseBody
		public User doTest8(HttpServletRequest request, HttpServletResponse response) {
			int userid = Integer.parseInt(request.getParameter("id"));
			User user = userService.getUserInfo(userid);
			return user;
		}
	}


3.
	我们看到，JdbcTemplate中获取数据库连接信息仍然是hard coded：
			Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
			con = DriverManager.getConnection("jdbc:sqlserver://localhost:1433;databasename=DEMO;user=sa;password=Sql2016;");
	我们把这一部分代码包装成DataSource：
			con = dataSource.getConnection();

	并通过属性注入：
	public class JdbcTemplate {
		private DataSource dataSource;
	}

	配置文件：
	<bean id="dataSource" class="com.minis.jdbc.datasource.SingleConnectionDataSource">
	<property type="String" name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
	<property type="String" name="url" value="jdbc:sqlserver://localhost:1433;databasename=DEMO;"/>
	<property type="String" name="username" value="sa"/>
	<property type="String" name="password" value="Sql2016"/>
    </bean>

	<bean id="jdbcTemplate" class="com.minis.jdbc.core.JdbcTemplate" >
	<property type="javax.sql.DataSource" name="dataSource" ref="dataSource"/>
	</bean>

	DataSource定义如下：
	public class SingleConnectionDataSource implements DataSource {
		private String driverClassName;
		private String url;
		private String username;
		private String password;
		private Properties connectionProperties;
		private Connection connection;

		@Override
		public Connection getConnection() throws SQLException {
			return getConnectionFromDriver(getUsername(), getPassword());
		}
	}

	这样在bean初始化的时候，设置Property的时候load相应的JDBC Driver，然后注入JdbcTemplate来使用。
	在应用程序dataSource.getConnection()的时候才实际生成数据库连接。


4.
	现在往PreparedStatement中传参数是这么实现的：
				for (int i = 0; i < args.length; i++) {
					Object arg = args[i];
					if (arg instanceof String) {
						pstmt.setString(i+1, (String)arg);
					}
					else if (arg instanceof Integer) {
						pstmt.setInt(i+1, (int)arg);
					}
					else if (arg instanceof java.util.Date) {
						pstmt.setDate(i+1, new java.sql.Date(((java.util.Date)arg).getTime()));
					}
				}
	我们现在修改一下，把jdbc中传参数的代码进行包装：ArgumentPreparedStatementSetter
	通过setValues()把参数传进PreparedStatement.
		public class ArgumentPreparedStatementSetter {
			private final Object[] args;

			public ArgumentPreparedStatementSetter(Object[] args) {
				this.args = args;
			}

			public void setValues(PreparedStatement pstmt) throws SQLException {
				for (int i = 0; i < this.args.length; i++) {
					Object arg = this.args[i];
					doSetValue(pstmt, i + 1, arg);
				}
			}

			protected void doSetValue(PreparedStatement pstmt, int parameterPosition, Object argValue) throws SQLException {
				Object arg = argValue;
				if (arg instanceof String) {
					pstmt.setString(parameterPosition, (String)arg);
				}
				else if (arg instanceof Integer) {
					pstmt.setInt(parameterPosition, (int)arg);
				}
				else if (arg instanceof java.util.Date) {
					pstmt.setDate(parameterPosition, new java.sql.Date(((java.util.Date)arg).getTime()));
				}
			}
		}

	所以，Query()就修改成这个样子：
		public Object query(String sql, Object[] args, PreparedStatementCallback pstmtcallback) {
			Connection con = null;
			PreparedStatement pstmt = null;

			con = dataSource.getConnection();
			pstmt = con.prepareStatement(sql);
			ArgumentPreparedStatementSetter argumentSetter = new ArgumentPreparedStatementSetter(args);
			argumentSetter.setValues(pstmt);

			return pstmtcallback.doInPreparedStatement(pstmt);
		}

	接下来，我们再把接受返回值的代码进行包装：RowMapperResultSetExtractor。
	先提供一个接口RowMapper，把JDBC resultset的某一行数据映射成为一个对象：
	public interface RowMapper<T> {
		T mapRow(ResultSet rs, int rowNum) throws SQLException;
	}
	再提供一个接口ResultSetExtractor，把JDBC ResultSet数据映射为一个集合对象：
	public interface ResultSetExtractor<T> {
		T extractData(ResultSet rs) throws SQLException;
	}
	利用上面的两个接口，我们事先RowMapperResultSetExtractor：
	public class RowMapperResultSetExtractor<T> implements ResultSetExtractor<List<T>> {
		private final RowMapper<T> rowMapper;

		public RowMapperResultSetExtractor(RowMapper<T> rowMapper) {
			this.rowMapper = rowMapper;
		}

		public List<T> extractData(ResultSet rs) throws SQLException {
			List<T> results = new ArrayList<>();
			int rowNum = 0;
			while (rs.next()) {
				results.add(this.rowMapper.mapRow(rs, rowNum++));
			}
			return results;
		}
	}

	有了传入和返回数据的包装，query()修改如下：
	public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper) {
		RowMapperResultSetExtractor<T> resultExtractor = new RowMapperResultSetExtractor<>(rowMapper);
		Connection con = null;
		PreparedStatement pstmt = null;
		ResultSet rs = null;

		con = dataSource.getConnection();

		pstmt = con.prepareStatement(sql);
		ArgumentPreparedStatementSetter argumentSetter = new ArgumentPreparedStatementSetter(args);
		argumentSetter.setValues(pstmt);
		rs = pstmt.executeQuery();

		return resultExtractor.extractData(rs);
	}

	那么应用程序的service层改成这样：
	public List<User> getUsers(int userid) {
		final String sql = "select id, name,birthday from users where id>?";
		return (List<User>)jdbcTemplate.query(sql, new Object[]{new Integer(userid)},
						new RowMapper<User>(){
							public User mapRow(ResultSet rs, int i) throws SQLException {
								User rtnUser = new User();
								rtnUser.setId(rs.getInt("id"));
								rtnUser.setName(rs.getString("name"));
								rtnUser.setBirthday(new java.util.Date(rs.getDate("birthday").getTime()));

								return rtnUser;
							}
						}
		);
	}

	到此为止，JdbcTemplate就提供三种query()了：
	public Object query(StatementCallback stmtcallback) {}
	public Object query(String sql, Object[] args, PreparedStatementCallback pstmtcallback) {}
	public <T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper){}




5.
	支持PooledConnection，用Active表示是否忙着，实际上永不close：
	public PooledConnection(Connection connection, boolean active) {
		this.connection = connection;
		this.active = active;

		public void setActive(boolean active) {
			this.active = active;
		}
		public void close() throws SQLException {
			this.active = false;
		}

	把DataSource改成PooledDataSource，初始化的时候激活所有的数据库链接：
	public class PooledDataSource implements DataSource{
		private List<PooledConnection> connections = null;
		private String driverClassName;
		private String url;
		private String username;
		private String password;
		private int initialSize = 2;
		private Properties connectionProperties;

		private void initPool() {
			this.connections = new ArrayList<>(initialSize);
			for(int i = 0; i < initialSize; i++){
				Connection connect = DriverManager.getConnection(url, username, password);
				PooledConnection pooledConnection = new PooledConnection(connect, false);
				this.connections.add(pooledConnection);
			}
		}

		获取数据库连接的代码如下：
		PooledConnection pooledConnection= getAvailableConnection();
		while(pooledConnection == null){
			pooledConnection = getAvailableConnection();
			if(pooledConnection == null){
				try {
					TimeUnit.MILLISECONDS.sleep(30);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		return pooledConnection;
	可以看出，策略是死等这一个有效的连接。

	获取有效的连接的代码：
		private PooledConnection getAvailableConnection() throws SQLException{
			for(PooledConnection pooledConnection : this.connections){
				if (!pooledConnection.isActive()){
					pooledConnection.setActive(true);
					return pooledConnection;
				}
			}

			return null;
		}
	可以看出，其实是拿一个空闲标志的数据库连接。

	通过配置注入这个datasource：
	<bean id="dataSource" class="com.minis.jdbc.pool.PooledDataSource">
                <property name="url" value="jdbc:sqlserver://localhost:1433;databasename=DEMO"/>
                <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
                <property name="username" value="sa"/>
                <property name="password" value="Sql2016"/>
                <property type="int" name="initialSize" value="3"/>
    </bean>

	别的程序没有任何变化。



-----------------------------------AOP--------------------------------------
1.
	第一步先直接用Java 动态代理编程实现Aop：
	代理interface上的doAction()方法。
	public class DynamicProxy {
		private Object subject = null;

		public DynamicProxy(Object subject) {
				this.subject = subject;
		}

		public Object getProxy() {
			return Proxy.newProxyInstance(DynamicProxy.class
					.getClassLoader(), subject.getClass().getInterfaces(),
					new InvocationHandler() {
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					if (method.getName().equals("doAction")) {
						 System.out.println("before call real object........");
						 return method.invoke(subject, args);
					}
					return null;
				}
			});
		}
	}

	Java的机制是在interface上代理，所以我们定义一个接口：
	public interface IAction {
		void doAction();
	}

	应用程序利用代理进行包装，实际的工作类注入。
	<bean id="action" class="com.minis.test.service.Action1" />

	应用程序：
	@Autowired
	IAction action;

	@RequestMapping("/testaop")
	public void doTestAop(HttpServletRequest request, HttpServletResponse response) {
		DynamicProxy proxy = new DynamicProxy(action);
		IAction p = (IAction)proxy.getProxy();
		p.doAction();
	}


2.
	直接写Proxy，对应用程序有介入，不是好方案，要考虑非介入式的。

	我们通过配置一个ProxyFactoryBean实现aop
	<bean id="action" class="com.minis.aop.ProxyFactoryBean" >
        <property type="java.lang.Object" name="target" ref="realaction"/>
	</bean>
	factorybean的特点是它里面包含有一个target，指向真正工作的对象，在容器里面放入的是这个 FactoryBean,
	而不是实际上工作的那个bean。当getBean()的时候，对于factorybean进行特殊处理，返回指向的这个真正工作的对象。
	FactoryBean接口定义如下：
	public interface FactoryBean<T> {
		T getObject() throws Exception;
		Class<?> getObjectType();
	}

	改写AbstractBeanFactory：	AbstractBeanFactory extends FactoryBeanRegistrySupport
	在AbstractBeanFactory的getBean()的时候特殊处理FactoryBean，不是返回这个FactoryBean本身，而是返回它里面生成的object：
	    if (singleton instanceof FactoryBean) {
        	return this.getObjectForBeanInstance(singleton, beanName);
        }

	getObjectForBeanInstance()进一步调用到  FactoryBeanRegistrySupport里面的    getObjectFromFactoryBean
    private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName) {
		return factory.getObject();
	}
	通过这个手段，拿到factorybean指向的那个object。

	实际上这个object也并不是真正工作的那个object，如果那样就不能插入额外的逻辑了，所以其实是这个object的一个代理。
	ProxyFactoryBean在getObject()中生成了一个代理getProxy(createAopProxy())，所以实际上BeanFactory
	对于这个ProxyFactoryBean,它拿到的是一个动态代理类代理了target。
	public Object getObject() throws Exception {
		return getSingletonInstance();
	}
	private synchronized Object getSingletonInstance() {
		if (this.singletonInstance == null) {
			this.singletonInstance = getProxy(createAopProxy());
		}
		return this.singletonInstance;
	}
	protected Object getProxy(AopProxy aopProxy) {
		return aopProxy.getProxy();
	}
	protected AopProxy createAopProxy() {
		return getAopProxyFactory().createAopProxy(target);
	}

	程序中默认了一个代理工厂，直接创建JdkDynamicAopProxy（预留了CglibAopProxy的支持）：
	public class DefaultAopProxyFactory implements AopProxyFactory {
		public AopProxy createAopProxy(Object target) {
			//if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(target);
			//}
			//return new CglibAopProxy(config);
		}
	}

	JdkDynamicAopProxy利用Java的动态代理技术代理了target：
	public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
		Object target;

		public JdkDynamicAopProxy(Object target) {
			this.target = target;
		}

		@Override
		public Object getProxy() {
			Object obj = Proxy.newProxyInstance(JdkDynamicAopProxy.class.getClassLoader(), target.getClass().getInterfaces(), this);
			return obj;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if (method.getName().equals("doAction")) {
				 System.out.println("-----before call real object, dynamic proxy........");
				 return method.invoke(target, args);
			}
			return null;
		}
	}

	应用程序，就不需要写死Proxy代码了：
	@Autowired
	IAction action;

	@RequestMapping("/testaop")
	public void doTestAop(HttpServletRequest request, HttpServletResponse response) {
		action.doAction();
	}

	配置文件：
	<bean id="realaction" class="com.minis.test.service.Action1" />
	<bean id="action" class="com.minis.aop.ProxyFactoryBean" >
        <property type="java.lang.Object" name="target" ref="realaction"/>
	</bean>



3.
	增加了interceptor支持，接口如下：
	public interface MethodInterceptor extends Interceptor{
		Object invoke(MethodInvocation invocation) throws Throwable;
	}
	public interface Interceptor extends Advice {}
	public interface Advice {}
	接口来自于一个tag：Advice.

	再提供一个Advisor接口：
	public interface Advisor {
		MethodInterceptor getMethodInterceptor();
		void setMethodInterceptor(MethodInterceptor methodInterceptor);
	}

	ProxyFactoryBean中增加advisor属性:
	private Advisor advisor;

	这个接口调用一个MethodInvocation，定义如下：
	public interface MethodInvocation {
		Method getMethod();
		Object[] getArguments();
		Object getThis();
		Object proceed() throws Throwable;
	}

	应用程序员再invoke()中实现自己的业务拦截代码，中间的proceed()才十真正的目标对象的方法调用：
	public class TracingInterceptor implements MethodInterceptor {
		public Object invoke(MethodInvocation i) throws Throwable {
			System.out.println("method "+i.getMethod()+" is called on "+
	                        i.getThis()+" with args "+i.getArguments());
			Object ret=i.proceed();
			System.out.println("method "+i.getMethod()+" returns "+ret);
			return ret;
	   }
	}
	public Object proceed() throws Throwable {
		return this.method.invoke(this.target, this.arguments);
	}

	应用程序员可以给业务逻辑加上自己的拦截，配置如下：
	<bean id="myInterceptor" class="com.minis.test.service.TracingInterceptor" />

	<bean id="realaction" class="com.minis.test.service.Action1" />
	<bean id="action" class="com.minis.aop.ProxyFactoryBean" >
        <property type="java.lang.Object" name="target" ref="realaction"/>
        <property type="String" name="interceptorName" value="myInterceptor"/>
	</bean>

	为了实现目标对象调用前的拦截，我们在ProxyFactoryBean的getObject()中initializeAdvisor():
	public Object getObject() throws Exception {
		initializeAdvisor();
		return getSingletonInstance();
	}
	private synchronized void initializeAdvisor() {
		Object advice = null;
		MethodInterceptor mi = null;

		advice = (MethodInterceptor)this.beanFactory.getBean(this.interceptorName);

		advisor = new DefaultAdvisor();
		advisor.setMethodInterceptor((MethodInterceptor)advice);
	}
	把应用程序自定义的拦截器获取到advisor中。

	修改接口，增加advisor参数：
	public interface AopProxyFactory {
		AopProxy createAopProxy(Object target,Advisor advisor);
	}

	默认实现也增加这个参数：
	public class DefaultAopProxyFactory implements AopProxyFactory {
		public AopProxy createAopProxy(Object target, Advisor advisor) {
			return new JdkDynamicAopProxy(target, advisor);
		}
	}

	实际调用某个方法的时候，不是直接调用method，而是先拿到advisor里面的interceptor,
	再把正常的method调用包装成ReflectiveMethodInvocation，然后调用interceptor.invoke(invocation)：
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		if (method.getName().equals("doAction")) {
			Class<?> targetClass = (target != null ? target.getClass() : null);
			MethodInterceptor interceptor = this.advisor.getMethodInterceptor();
			MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass);

			return interceptor.invoke(invocation);
		}
		return null;
	}




4.
	advice增加到三种，除了methodinterceptor之外，再支持methodbeforeadvice, afterreturningadvice
	public interface MethodBeforeAdvice extends BeforeAdvice{
		void before(Method method, Object[] args, Object target) throws Throwable;
	}
	public interface AfterReturningAdvice extends AfterAdvice {
		void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable;
	}

	我们在ProxyFactoryBean的getObject()中initializeAdvisor()修改为支持三种类型的advice:
	private synchronized void initializeAdvisor() {
		Object advice = null;
		MethodInterceptor mi = null;

		advice = this.beanFactory.getBean(this.interceptorName);

		if (advice instanceof BeforeAdvice) {
			mi = new MethodBeforeAdviceInterceptor((MethodBeforeAdvice)advice);
		}
		else if (advice instanceof AfterAdvice){
			mi = new AfterReturningAdviceInterceptor((AfterReturningAdvice)advice);
		}
		else if (advice instanceof MethodInterceptor) {
			mi = (MethodInterceptor)advice;
		}

		advisor = new DefaultAdvisor();
		advisor.setMethodInterceptor(mi);
	}
	统一用Interceptor进行了包装。

	AfterReturningAdviceInterceptor包装：
	public class AfterReturningAdviceInterceptor implements MethodInterceptor, AfterAdvice {
		private final AfterReturningAdvice advice;
		public AfterReturningAdviceInterceptor(AfterReturningAdvice advice) {
			this.advice = advice;
		}
		public Object invoke(MethodInvocation mi) throws Throwable {
			Object retVal = mi.proceed();
			this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
			return retVal;
		}
	}
	可以看出是调用了目标对象返回后再调用了afterReturning（应用程序员自定义），这个时候可以用返回值retVal。

	MethodBeforeAdviceInterceptor包装：
	public class MethodBeforeAdviceInterceptor implements MethodInterceptor {
		private final MethodBeforeAdvice advice;
		public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
			this.advice = advice;
		}
		public Object invoke(MethodInvocation mi) throws Throwable {
			this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
			return mi.proceed();
		}
	}
	可以看出是调用目标对象之前调用了before（应用程序员自定义），所以是拿不到retVal的。

	应用程序的自定义工作：
	public class MyAfterAdvice implements AfterReturningAdvice{
		public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
			System.out.println("----------my interceptor after method call----------");
		}
	}
	public class MyBeforeAdvice implements MethodBeforeAdvice{
		public void before(Method method, Object[] args, Object target) throws Throwable {
			System.out.println("----------my interceptor befor method call----------");
		}
	}
	public class MyInterceptor implements MethodInterceptor{
		public Object invoke(MethodInvocation invocation) throws Throwable {
			System.out.println("method "+invocation.getMethod()+" is called on "+
					invocation.getThis()+" with args "+invocation.getArguments());
			Object ret=invocation.proceed();
			System.out.println("method "+invocation.getMethod()+" returns "+ret);

			return ret;
		}
	}

	配置文件不变，可以用上面的三类advice：
	<bean id="myInterceptor" class="com.minis.test.service.MyInterceptor" />
	<bean id="realaction" class="com.minis.test.service.Action1" />
	<bean id="action" class="com.minis.aop.ProxyFactoryBean" >
        <property type="java.lang.Object" name="target" ref="realaction"/>
        <property type="String" name="interceptorName" value="myInterceptor"/>
	</bean>


5.
	到现在为止，我们invoke目标对象的时候，还是写死的method名，程序代码如下：
		if (method.getName().equals("doAction")) {
		}
	我们需要改造这一点，通过某个给定的规则找到合适的method。

	所以实现了pointcut，按照方法名匹配规则来匹配advice
	<bean id="realaction" class="com.minis.test.service.Action1" />
	<bena id="beforeAdvice" class="com.minis.test.service.MyBeforeAdvice" />

	<bean id="advisor" class="com.minis.aop.NameMatchMethodPointcutAdvisor">
        <property type="com.minis.aop.Advice" name="advice" ref="beforeAdvice"/>
        <property type="String" name="mappedName" value="do*"/>
    </bean>

    <bean id="action" class="com.minis.aop.ProxyFactoryBean">
        <property type="String" name="interceptorName" value="advisor" />
        <property type="java.lang.Object" name="target" ref="realaction"/>
    </bean>
 	配置文件中，advisor用了NameMatchMethodPointcutAdvisor，进行名称匹配。

 	类的定义：
 	public class NameMatchMethodPointcutAdvisor implements PointcutAdvisor{
		private Advice advice = null;
		private MethodInterceptor methodInterceptor;
		private String mappedName;
		private final NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
	}
	它里面除了advice和methodInterceptor之外，多了一个mappedName和pointcut。
	如上面的配置例子， <property type="String" name="mappedName" value="do*"/>
	匹配所有do开头的method。

	匹配的工作交给NameMatchMethodPointcut来完成：
	public class NameMatchMethodPointcut implements MethodMatcher,Pointcut{
		private String mappedName = "";

		public boolean matches(Method method, Class<?> targetClass) {
			if (mappedName.equals(method.getName()) || isMatch(method.getName(), mappedName)) {
				return true;
			}
			return false;
		}
		protected boolean isMatch(String methodName, String mappedName) {
			return PatternMatchUtils.simpleMatch(mappedName, methodName);
		}
	}
	其实就是进行字符串的匹配判断。

	有了这个匹配器，JdkDynamicAopProxy的invoke修改如下：
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Class<?> targetClass = (target != null ? target.getClass() : null);

		//if (method.getName().equals("doAction")) {
		if (this.advisor.getPointcut().getMethodMatcher().matches(method, targetClass)) {
			MethodInterceptor interceptor = this.advisor.getMethodInterceptor();
			MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass);

			return interceptor.invoke(invocation);
		}
		return null;
	}
	以前直接判断method名字，现在改成：
	this.advisor.getPointcut().getMethodMatcher().matches(method, targetClass))


6.
	到现在为止，AOP基本实现了，不过有一个很大的问题，我们看配置文件就知道了：
    <bean id="action" class="com.minis.aop.ProxyFactoryBean">
        <property type="String" name="interceptorName" value="advisor" />
        <property type="java.lang.Object" name="target" ref="realaction"/>
    </bean>
	我们的ProxyFactoryBean有一个target属性，上面的例子给的值是realaction。如果还有
	第二个第三个目标对象，那么我们要相应地进行配置。一个规模软件，目标对象成百上千，这样的话，
	配置太麻烦了。

	所以我们来考虑自动生成代理，用beanpostprocessor实现。
	将传进来的bean外面包装一个ProxyFactoryBean，改头换面塞进beanfactory。
	public class BeanNameAutoProxyCreator implements BeanPostProcessor{
		public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
			if (isMatch(beanName, this.pattern)) {  //简单地根据bean name进行匹配
				ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
				proxyFactoryBean.setTarget(bean);
				proxyFactoryBean.setBeanFactory(beanFactory);
				proxyFactoryBean.setAopProxyFactory(aopProxyFactory);
				proxyFactoryBean.setInterceptorName(interceptorName);
				bean = proxyFactoryBean;
				return proxyFactoryBean;
			}
			else {
				return bean;
			}
		}
	}

	这样也要相应修改AbstractBeanFactory的getBean():
			//beanpostprocessor
			//step 1 : postProcessBeforeInitialization
			singleton = applyBeanPostProcessorsBeforeInitialization(singleton, beanName);
			//这一步将bean改头换面成proxyfactorybean

			//step 2 : init-method
			if (bd.getInitMethodName() != null && !bd.getInitMethodName().equals("")) {
					invokeInitMethod(bd, singleton);
			}

			//step 3 : postProcessAfterInitialization
			applyBeanPostProcessorsAfterInitialization(singleton, beanName);

			this.removeSingleton(beanName);
			this.registerBean(beanName, singleton);

	配置文件既不需要逐个声明proxyfactorybean了，只要声明这个autoProxyCreator就可以了
	<bean id="autoProxyCreator" class="com.minis.aop.framework.autoproxy.BeanNameAutoProxyCreator" >
        <property type="String" name="pattern" value="action*" />
        <property type="String" name="interceptorName" value="advisor" />
    </bean>

	利用这个机制，动态生成ProxyFactoryBean。
	这样完整实现了AOP。

到此为止，我们实现了简单的IoC + MVC + JDBCTemplate + AOP

未来可以进一步扩展：
1 CGLIB支持
2 AspectJ支持
3 Expression Language
4 List型的ioc注入
5 多种数据类型的convert和bind
6 支持JMS
7 完善Exception体系
8 完善Event体系
9 支持reactive编程
10 Transaction
11 Scripting
12 threadpool
13 高并发
14 RESTful


-----------------------------------ThreadPool--------------------------------------
1.
	基于Java ThreadPoolExecutor实现ThreadPoolTaskExecutor

	Java中的java.util.concurrent.ThreadPoolExecutor已经进行打下了很好的基础，
	我们直接包装ThreadPoolExecutor:
	public class ThreadPoolTaskExecutor{
		private int corePoolSize = 1;
		private int maxPoolSize = Integer.MAX_VALUE;
		private int keepAliveSeconds = 60;
		private int queueCapacity = Integer.MAX_VALUE;
		private RejectedExecutionHandler rejectedExecutionHandler = new ThreadPoolExecutor.DiscardPolicy();

		private ThreadPoolExecutor threadPoolExecutor;

		public ExecutorService initializeExecutor() {
			BlockingQueue<Runnable> queue = createQueue(this.queueCapacity);

			ThreadPoolExecutor executor;
			executor = new ThreadPoolExecutor(
				this.corePoolSize, this.maxPoolSize, this.keepAliveSeconds, TimeUnit.SECONDS,
				queue,Executors.defaultThreadFactory(),this.rejectedExecutionHandler);

			this.threadPoolExecutor = executor;
			return executor;
		}
		public void execute(Runnable task) {
			Executor executor = getThreadPoolExecutor();
			executor.execute(task);
		}
		public <T> Future<T> submit(Callable<T> task) {
			ExecutorService executor = getThreadPoolExecutor();
			return executor.submit(task);
		}
	}
	提供一个初始化方法initializeExecutor()。
	执行的时候，直接调用Java ExecutorService的execute()和submit()。

	然后把这个包装的类作为一个bean注入:
	<bean id="taskExecutor" class="com.minis.scheduling.concurrent.ThreadPoolTaskExecutor"  init-method="initializeExecutor">
  		<property type="int" name="corePoolSize" value="2" />
   		<property type="int" name="maxPoolSize" value="4" />
   		<property type="int" name="queueCapacity" value="2" />
   		<property type="int" name="keepAliveSeconds" value="60" />
	</bean>

	这一步看起来没有意义，没有给java.util.concurrent.ThreadPoolExecutor添加任何扩展，
	只是一个包装。但是我们接下来会给它里面添加内容。因为java.util.concurrent.ThreadPoolExecutor
	有一个很大的缺陷：它sumbit返回Future<>后，时阻塞的方式，循环尝试返回值，而不能在执行别的逻辑的同时监听是否
	执行完毕，所以，我们可以给java.util.concurrent.ThreadPoolExecutor添加监听功能。

	做一个接口，扩展Future:
	public interface ListenableFuture<T> extends Future<T> {
		void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback);
	}
	给Java的Future添加回调功能，结束时，成功时执行什么，失败时执行什么。
	问题来了：怎么能知道这个异步线程结束了呢？又如何判定成功还是失败呢？
	其实，Java已经做了这样的设计。
	我们来看FutureTask的实现，执行线程最后会执行到run()，核心代码:
		Callable<V> c = callable;
        if (c != null && state == NEW) {
            V result;
            boolean ran;
            try {
                result = c.call();
                ran = true;
            } catch (Throwable ex) {
                result = null;
                ran = false;
                setException(ex);
            }
            if (ran)
                set(result);
        }
		我们看到了，线程执行完毕后，会调用set(result),而 run 方法中的 set 方法
		将线程的执行结果通知出去，在 set 方法中可以发现其调用了 finishCompletion 方法，
		finishCompletion 方法会一直循环判断线程池中的队列的任务是否执行了，一旦执行了
		就会调用 done 方法。

		所以我们就用一个子类ListenableFutureTask，定义如下：
		public class ListenableFutureTask<T> extends FutureTask<T> implements ListenableFuture<T>{
			private final ListenableFutureCallbackRegistry<T> callbacks = new ListenableFutureCallbackRegistry<>();
			public void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback) {
				this.callbacks.addSuccessCallback(successCallback);
				this.callbacks.addFailureCallback(failureCallback);
			}
		}
		我们就可以在ListenableFutureTask类中override 这个done()方法，进行执行结束后的通知。
		@Override
		protected void done() {
		Throwable cause;
		try {
			T result = get();
			this.callbacks.success(result);
			return;
		}
		catch (InterruptedException ex) {
			Thread.currentThread().interrupt();
			return;
		}
		catch (ExecutionException ex) {
			cause = ex.getCause();
			if (cause == null) {
				cause = ex;
			}
		}
		catch (Throwable ex) {
			cause = ex;
		}
		this.callbacks.failure(cause);
		}
		我们在done()方法中调用get(),这是阻塞式的，但是这个时候已经是在另一个异步线程了，所以不会阻塞
		调用主程序。再根据情况调用回调成功方法或者失败方法。

		使用者很简单，先申明一个bean:
		@Autowired
		ThreadPoolTaskExecutor taskExecutor;

		这么调用：
		taskExecutor.submitListenable(()->{
			try {
		        Thread.sleep(2000);
		        System.out.println("Thread " + Thread.currentThread().getName());
		        return 1;
		    } catch (InterruptedException e) {
		        e.printStackTrace();
		    }
			return 0;
		}).addCallback(data->{System.out.println("sucess "+data);},
					ex->System.out.println("sucess "+ex));

	由于我们在result中给定callback，而这又是异步时序，所以可能碰到在程序主体执行完后callback还有没加上的情况。
	这就是为什么ListenableFutureCallbackRegistry中要判断state的原因。
	public void addSuccessCallback(SuccessCallback<? super T> callback) {
		synchronized (this.mutex) {
			switch (this.state) {
				case NEW:
					this.successCallbacks.add(callback);
					break;
				case SUCCESS:
					notifySuccess(callback);
					break;
			}
		}
	}

	public void addFailureCallback(FailureCallback callback) {
		synchronized (this.mutex) {
			switch (this.state) {
				case NEW:
					this.failureCallbacks.add(callback);
					break;
				case FAILURE:
					notifyFailure(callback);
					break;
			}
		}
	}

	我希望JDK以后能改进一下，不要让Future影响业务逻辑，应该提供一个关键字。

	另外，我们还注意到一个task一旦reject之后，默认就是被抛弃了，Java内置提供了四种策略，都是抛弃。
	我们也可以提供一个可重入的策略：
	其实也很简单,java的RejectedExecutionHandler接口提供rejectedExecution，我们override就可以了：
	public class ReentryRejectedExecutionHandler implements RejectedExecutionHandler {
	@Override
	public void rejectedExecution(Runnable worker, ThreadPoolExecutor executor) {
        if (!executor.isShutdown()) {
    	    try{
                executor.getQueue().put(worker);
    	    }
    	    catch(Exception e) {
    	        System.out.println("Failure to Re-exicute "+e.getMessage());
    	    }
        }
	}
	}
	也就是将这个任务简单地再放到等待队列中即可。


2. 增加@Async注解
	现在使用者这么调用，还是自己手工用executor：
	public void sayHello() {
		taskExecutor.submit(()->{
			try {
		        Thread.sleep(2000);
		        System.out.println("say hello. Thread " + Thread.currentThread().getName());
		    } catch (InterruptedException e) {
		        e.printStackTrace();
		    }
		});
	}

	我们希望业务程序不用管异步线程的问题，只要把自己声明为异步即可。
	@Async
	public void sayHello() {
	    System.out.println("say hello. Thread " + Thread.currentThread().getName());
	}

	首先定义注解
	@Target({ElementType.TYPE, ElementType.METHOD})
	@Retention(RetentionPolicy.RUNTIME)
	public @interface Async {
		String value() default "";
	}

	然后定义对注解的处理程序,简单地想想，还是用beanpostprocessor:
	public class AsyncAnnotationBeanPostProcessor implements BeanPostProcessor,BeanFactoryAware{
		private BeanFactory beanFactory;
		@Override
		public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
			Object result = bean;

			Class<?> clazz = bean.getClass();
			Method[] methods = clazz.getDeclaredMethods();
			if(methods!=null){
				for(Method method : methods){
					boolean isAsync = method.isAnnotationPresent(Async.class);

					if(isAsync){
						System.out.println("AsyncAnnotationBeanPostProcessor is Async. ");
						... ...
					}
				}
			}
			return result;
		}
	}

	现在的问题是如何实现这个处理？要怎么做才可以让这个@Async方法在线程中异步执行呢？
	肯定还是自动加上executor，给这个方法套一个proxy，于是我么你想到了用以前的AOP.

	回过头看以前的AOP实现，有一个动态代理生成的类：
	public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
		Object target;
		PointcutAdvisor advisor;

		public Object getProxy() {
			Object obj = Proxy.newProxyInstance(JdkDynamicAopProxy.class.getClassLoader(), target.getClass().getInterfaces(), this);
			return obj;
		}

		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			Class<?> targetClass = (target != null ? target.getClass() : null);

			if (this.advisor.getPointcut().getMethodMatcher().matches(method, targetClass)) {
				MethodInterceptor interceptor = this.advisor.getMethodInterceptor();
				MethodInvocation invocation =
							new ReflectiveMethodInvocation(proxy, target, method, args, targetClass);

				return interceptor.invoke(invocation);
			}
			return null;
		}
	}
	里面包含了一个PointcutAdvisor，用于对target进行修饰(interceptor)。
	现在需要扩展了了，我们用一个新的Advisor：AsyncAnnotationAdvisor。
	程序修改为：
	public class JdkDynamicAopProxy implements AopProxy, InvocationHandler {
		Object target;
		Advisor advisor;  //should be a list to support multiple advisors

		public Object getProxy() {
			Object obj = Proxy.newProxyInstance(JdkDynamicAopProxy.class.getClassLoader(), target.getClass().getInterfaces(), this);
			return obj;
		}

		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			Class<?> targetClass = (target != null ? target.getClass() : null);
			if (this.advisor instanceof PointcutAdvisor) {
				if (((PointcutAdvisor)this.advisor).getPointcut().getMethodMatcher().matches(method, targetClass)) {
					MethodInterceptor interceptor = this.advisor.getMethodInterceptor();
					MethodInvocation invocation =
								new ReflectiveMethodInvocation(proxy, target, method, args, targetClass);
					return interceptor.invoke(invocation);
				}
			}
			if (this.advisor instanceof AsyncAnnotationAdvisor) {
				MethodInterceptor interceptor = this.advisor.getMethodInterceptor();
				MethodInvocation invocation =
							new ReflectiveMethodInvocation(proxy, target, method, args, targetClass);
				return interceptor.invoke(invocation);
			}
			return null;
		}
	}
	对PointcutAdvisor和AsyncAnnotationAdvisor分别处理(此处不通用，缺陷)。

	我们再看AsyncAnnotationAdvisor：
	public class AsyncAnnotationAdvisor  implements Advisor{
		MethodInterceptor methodInterceptor;
	}
	它内部就是包含了一个methodInterceptor.在这个interceptor中我们实现异步线程。
	定义：
	public class AsyncExecutionInterceptor implements MethodInterceptor{
		ThreadPoolTaskExecutor executor;

		public Object invoke(final MethodInvocation invocation) throws Throwable {
			Callable<Object> task = () -> {
				try {
					Object result = invocation.proceed();
					if (result instanceof Future) {
						return ((Future<?>) result).get();
					}
				}
				catch (ExecutionException ex) {
					throw ex;
				}
				catch (Throwable ex) {
				}
				return null;
			};

			return doSubmit(task, executor, invocation.getMethod().getReturnType());
		}

		protected Object doSubmit(Callable<Object> task, ThreadPoolTaskExecutor executor, Class<?> returnType) {
			if (ListenableFuture.class.isAssignableFrom(returnType)) {
				return executor.submitListenable(task);
			}
			else if (Future.class.isAssignableFrom(returnType)) {
				return executor.submit(task);
			}
			else {
				executor.submit(task);
				return null;
			}
		}
	}

	有了这些之后，我们就可以在	AsyncAnnotationBeanPostProcessor中，动态生成这个代理，
	public class AsyncAnnotationBeanPostProcessor implements BeanPostProcessor,BeanFactoryAware{
	private BeanFactory beanFactory;

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		Object result = bean;

		Class<?> clazz = bean.getClass();
		Method[] methods = clazz.getDeclaredMethods();
		if(methods!=null){
			for(Method method : methods){
				boolean isAsync = method.isAnnotationPresent(Async.class);

				if(isAsync){
					System.out.println("AsyncAnnotationBeanPostProcessor is Async. ");
					AopProxyFactory proxyFactory = new DefaultAopProxyFactory();
					ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
					Advisor advisor = (Advisor)beanFactory.getBean("asyncAnnotationAdvisor");
					MethodInterceptor methodInterceptor = (AsyncExecutionInterceptor)beanFactory.getBean("asyncExecutionInterceptor");
					advisor.setMethodInterceptor(methodInterceptor);
					proxyFactoryBean.setTarget(bean);
					proxyFactoryBean.setBeanFactory(beanFactory);
					proxyFactoryBean.setAopProxyFactory(proxyFactory);
					proxyFactoryBean.setInterceptorName("asyncAnnotationAdvisor");
					bean = proxyFactoryBean;
					return proxyFactoryBean;
				}
			}
		}

		return result;
	}


	为支持callback，我们实现：
	public class AsyncResult<V> implements ListenableFuture<V> {
	private final V value;
	private final Throwable executionException;

	private AsyncResult(V value, Throwable ex) {
		this.value = value;
		this.executionException = ex;
	}

	public V get() {
		return this.value;
	}

	@Override
	public void addCallback(SuccessCallback<? super V> successCallback, FailureCallback failureCallback) {
		try {
			if (this.executionException != null) {
				failureCallback.onFailure(this.executionException);
			}
			else {
				successCallback.onSuccess(this.value);
			}
		}
		catch (Throwable ex) {
		}
	}
}

	服务类：
	@Async
	public Boolean sayHello(SuccessCallback<? super Boolean> successCallback, FailureCallback failureCallback){
		System.out.println("Base Service says hello.Execute method asynchronously. "
			      + Thread.currentThread().getName());
		ListenableFuture<Boolean> result = new AsyncResult<>(true);
		result.addCallback(successCallback,	failureCallback);

		return true;
	}
	使用者：
		Boolean result =
				baseservice.sayHello(data->{System.out.println("sucess "+data);},
								ex->System.out.println("failure "+ex));

	或者这样：
	服务类：
	@Async
	public ListenableFuture<Boolean> sayHello(){
		System.out.println("Base Service says hello.Execute method asynchronously. "
			      + Thread.currentThread().getName());
		ListenableFuture<Boolean> result = new AsyncResult<>(true);

		return result;
	}
	使用者：
		ListenableFuture<Boolean> result =
				baseservice.sayHello(data->{System.out.println("sucess "+data);},
								ex->System.out.println("failure "+ex)
				).addCallback(successCallback,	failureCallback);

	可以看出，对服务类来讲，线程异步还是介入式的，理想的应该不用管同步异步，估计要给Java增加关键字修改JDK才行。


	另外因为是用的JDK动态代理，只能实现interface上的代理，所以使用者需要实现一个interface:
	public class BaseService implements IService


3. RESTful支持
	REST不是一个实体api，而是一种风格,四个动词GET PUT UPDATE DELETE
	例如：GET /user/{id}
	所以我们只需要MVC的基础上增加这种风格就可以。

	我们希望controller这一层这样写：
	@RequestMapping(value="/testrest/{id}",method="GET")
	@ResponseBody
	public User doTestRestGet(@PathVariable int id, HttpServletRequest request, HttpServletResponse response) {
		User user = userService.getUserInfo(id);
		return user;
	}

	因为在request中要支持这四个动词，所以我们需要改造一下RequestMapping。
	我们将会以method：uri的方式存储这个mapping，我们叫它qualifiedNames：
	public class MappingRegistry {
	    private List<String> urlMappingNames = new ArrayList<>();
	    private List<String> requestMethods = new ArrayList<>();
	    private List<String> qualifiedNames = new ArrayList<>();
	    private Map<String,Object> mappingObjs = new HashMap<>();
	    private Map<String,Method> mappingMethods = new HashMap<>();
	    private Map<String,String> mappingMethodNames = new HashMap<>();
	    private Map<String,Class<?>> mappingClasses = new HashMap<>();
	}

	改写RequestMappingHandlerMapping类：
    for(Method method : methods){
    	boolean isRequestMapping = method.isAnnotationPresent(RequestMapping.class);
    	if (isRequestMapping){
    		String methodName = method.getName();
    		String urlmapping = method.getAnnotation(RequestMapping.class).value();
    		String requestMethod = method.getAnnotation(RequestMapping.class).method();
    		if (requestMethod.equals("")) {
    			requestMethod="GET";
    		}
    		String qualifiedName = requestMethod + ":" + urlmapping;

			this.mappingRegistry.getUrlMappingNames().add(urlmapping);
			this.mappingRegistry.getRequestMethods().add(requestMethod);
			this.mappingRegistry.getQualifiedNames().add(qualifiedName);

			this.mappingRegistry.getMappingObjs().put(qualifiedName, obj);
			this.mappingRegistry.getMappingMethods().put(qualifiedName, method);
			this.mappingRegistry.getMappingMethodNames().put(qualifiedName, methodName);
			this.mappingRegistry.getMappingClasses().put(qualifiedName, clz);
		}
	}

	由上可知，对于以下的声明：
	@RequestMapping(value="/testrest/{id}",method="GET")
	系统中将把qualifiedName存为GET:/testrest/{id}

	这样当来了一个实际的uri请求时，如/testrest/1,我们不能再像以前一样找这个串，因为registry
	里面保存的时{id}，而实际uri是1，所以是要进行模式匹配。
	for (int i=0; i<this.mappingRegistry.getQualifiedNames().size();i++) {
	    if (PatternMatchUtils.URIMatch(this.mappingRegistry.getQualifiedNames().get(i), qualifiedName)) {
	        sPattern = 	this.mappingRegistry.getQualifiedNames().get(i);
	        break;
	    }
	}
	这个PatternMatchUtils.URIMatch()写得很简单，只能处理简单情况，旨在说明问题。

	URI中有参数，我们需要解析这个URI，把参数解析出来，增加@PathVariable。
	我们在bing.annotation包中增加PathVariable注解：
	@Target(ElementType.PARAMETER)
	@Retention(RetentionPolicy.RUNTIME)
	public @interface PathVariable {
	}

	我们在RequestMappingHandlerAdapter类中这么处理这个参数：
		else if (methodParameter.isAnnotationPresent(PathVariable.class)) {
			String sServletPath = request.getServletPath();
			int index = sServletPath.lastIndexOf("/");
			String sParam = sServletPath.substring(index+1);
			if (int.class.isAssignableFrom(methodParameter.getType())) {
			    methodParamObjs[i] = Integer.parseInt(sParam);
			} else if (String.class.isAssignableFrom(methodParameter.getType())) {
			    methodParamObjs[i] = sParam;
			}
		}
	从sServletPath中把这个实际参数获取到并bind到变量中。

	这样，我们就可以支持rest风格了。

-----------------------------------mBatis--------------------------------------
1, 仿iBatis,把SQL语句放到程序外面的配置文件中mapper/User_Mapper.xml：
	<?xml version="1.0" encoding="UTF-8"?>
	<mapper namespace="com.minis.test.entity.User">
	    <select id="getUserInfo" parameterType="java.lang.Integer" resultType="com.minis.test.entity.User">
	        select id, name,birthday
	        from users
	        where id=?
	    </select>
	</mapper>

	我们内部用一个结构来保存系统中的所有SQL语句的定义：
	public class MapperNode {
	    String namespace;
	    String id;
	    String parameterType;
	    String resultType;
	    String sql;
	    String parameter;
	}

	在启动的配置xml中，我们在一个bean(DefaultSqlSessionFactory)的初始化过程中扫描sql定义文件目录：
	public void init() {
	    scanLocation(this.mapperLocations);
	}

	private void scanLocation(String location) {
    	String sLocationPath = this.getClass().getClassLoader().getResource("").getPath()+location;
        File dir = new File(sLocationPath);
        for (File file : dir.listFiles()) {
            if(file.isDirectory()){
            	scanLocation(location+"/"+file.getName());
            }else{
                buildMapperNodes(location+"/"+file.getName());
            }
        }
    }
	扫描的过程中将SQL定义写到内部注册表Map中：
	private Map<String, MapperNode> buildMapperNodes(String filePath) {
        SAXReader saxReader=new SAXReader();
        URL xmlPath=this.getClass().getClassLoader().getResource(filePath);

		Document document = saxReader.read(xmlPath);
		Element rootElement=document.getRootElement();

		String namespace = rootElement.attributeValue("namespace");

        Iterator<Element> nodes = rootElement.elementIterator();;
        while (nodes.hasNext()) {
        	Element node = nodes.next();
            String id = node.attributeValue("id");
            String parameterType = node.attributeValue("parameterType");
            String resultType = node.attributeValue("resultType");
            String sql = node.getText();

            MapperNode selectnode = new MapperNode();
            selectnode.setNamespace(namespace);
            selectnode.setId(id);
            selectnode.setParameterType(parameterType);
            selectnode.setResultType(resultType);
            selectnode.setSql(sql);
            selectnode.setParameter("");

            this.mapperNodeMap.put(namespace + "." + id, selectnode);
        }
	    return this.mapperNodeMap;
	}
	可以看到，map的id是namespace+"."+id,对上例即com.test.entity.User.getUserInfo

	注册上面的bean：
	<bean id="sqlSessionFactory" class="com.minis.batis.DefaultSqlSessionFactory" init-method="init">
        <property type="String" name="mapperLocations" value="mapper"></property>
    </bean>

	用户使用的时候，
	public class UserService {
		@Autowired
		SqlSessionFactory sqlSessionFactory;

		public User getUserInfo(int userid) {
			//final String sql = "select id, name,birthday from users where id=?";
			String sqlid = "com.minis.test.entity.User.getUserInfo";
			SqlSession sqlSession = sqlSessionFactory.openSession();
			return (User)sqlSession.selectOne(sqlid, new Object[]{new Integer(userid)},
					(pstmt)->{
						ResultSet rs = pstmt.executeQuery();
						User rtnUser = null;
						if (rs.next()) {
							rtnUser = new User();
							rtnUser.setId(userid);
							rtnUser.setName(rs.getString("name"));
							rtnUser.setBirthday(new java.util.Date(rs.getDate("birthday").getTime()));
						} else {
						}
						return rtnUser;
					}
			);
		}
	}
	基本于以前直接用jdbc tempalte一样，只是变成了：
	sqlSessionFactory.openSession();
	通过sqlSession.selectOne执行。
	public class DefaultSqlSession implements SqlSession{
		JdbcTemplate jdbcTemplate;
		SqlSessionFactory sqlSessionFactory;

		@Override
		public Object selectOne(String sqlid, Object[] args, PreparedStatementCallback pstmtcallback) {
			String sql = this.sqlSessionFactory.getMapperNode(sqlid).getSql();

			return jdbcTemplate.query(sql, args, pstmtcallback);
		}

		private void buildParameter(){
		}

		private Object resultSet2Obj() {
			return null;
		}
	}
	可以看出，最终还是落到了jdbcTemplate.query(sql, args, pstmtcallback)。