springmvc（2）手写springmvc框架_initspringcontainer-CSDN博客

本文链接：https://blog.csdn.net/Miaoshuowen/article/details/106043212

springmvc手写框架

前置阶段：DispatcherServlet

初始化spring容器
getBeansByType
Aware和BeanFactoryWare
初始化了HandlerMapping集合
初始化处理器类和url的映射关系
初始化了HandlerAdapter集合

1.如何编写处理器代码

制定标准（接口）
HttpRequestHandler接口
SimpleControllerHandler接口

2.如何编写处理器映射器代码

BeanNameURLHandlerMapping
SimpleUrlHandlerMapping

3.如何编写处理器适配器代码

HttpRequestHandlerAdapter
是否适配
SimpleControllerHandlerAdapter

4.使用注解方式去实现处理器

springmvc处理流程图

以下为具体代码

springmvc.servlet包

AbstractServlet 类继承 HttpServlet 类

负责具体的请求分发

public abstract class AbstractServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;

	protected void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		doDispatch(request, response);
	}

	public abstract void doDispatch(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException;

	protected void doPost(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		doGet(request, response);
	}
}

DispatcherServlet 类继承 AbstractServlet类

只需要接收【Servlet请求】、需要【处理结果】，同时负责将请求【分发给具体的处理类】。

public class DispatcherServlet extends AbstractServlet {

	private static final long serialVersionUID = 1L;

	private DefaultListableBeanFactory beanFactory;

	// 存储了各种处理器查找策略
	private List<HandlerMapping> handlerMappings = new ArrayList<HandlerMapping>();
	// 存储了各种适配器策略
	private List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();

	@Override
	public void init(ServletConfig config) throws ServletException {
		String location = config.getInitParameter("contextConfigLocation");
		// 加载spring容器
		initSpringContainer(location);

		// 饿汉式创建所有的spring中的bean实例
		beanFactory.getBeansByType(Object.class);

		// 从spring容器中获取HandlerMapping的实例，然后存储到handlerMappings集合中
		handlerMappings = beanFactory.getBeansByType(HandlerMapping.class);
		handlerAdapters = beanFactory.getBeansByType(HandlerAdapter.class);
	}

	private void initSpringContainer(String location) {
		beanFactory = new DefaultListableBeanFactory();

		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		Resource resource = new ClasspathResource(location);
		InputStream inputStream = resource.getResource();
		beanDefinitionReader.loadBeanDefinitions(inputStream);
	}

	@Override
	public void doDispatch(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		try {
			// 根据请求找到具体处理该请求的处理类(springmvc不是要指定处理器标准)
			// springmvc要求：当扩展一种处理器类型的时候，提供对应的适配器就可以。

			// Handler：处理器类
			// springmvc提供了几种类型的写法：HttpServletRequestHandler\SimpleController\纯注解(@Controller)
			Object handler = getHandler(request);

			if (handler == null) {
				return;
			}

			// 处理器处理请求(我们的处理器类和DispatcherServlet不兼容)---需要使用好的方式方法让他们可以一起工作。
			// 例子：handler就好比笔记本电脑。谁生产的这个电脑，谁给我匹配一个电源适配器，目的是让电脑和插座可以一起兼容工作。

			// 根据找到的处理器，去查找对应的处理器适配器
			HandlerAdapter ha = getHandlerAdapter(handler);
			if (ha == null) {
				return;
			}
			// 找到处理器适配器之后，让它去执行对应的处理器。
			ha.handleRequest(handler, request, response);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private HandlerAdapter getHandlerAdapter(Object handler) {
		if (handlerAdapters != null && handlerAdapters.size() > 0) {
			for (HandlerAdapter ha : handlerAdapters) {
				if (ha.supports(handler)) {
					return ha;
				}
			}
		}
		return null;
	}

	private Object getHandler(HttpServletRequest request) {
		// 映射关系存放在properties文件中
		// Object handler = null;
		// handler = getHandlerFromProperties(uri);
		// 如果handler不为null，返回handler
		// 如果handler为null，那么继续
		// 映射关系存放在xml文件中
		// handler = getHandlerFromXml(uri);
		// 如果handler不为null，返回handler
		// 如果handler为null，那么继续
		// 映射关系存放在xml文件中
		// handler = getHandlerFromXml(uri);、

		if (handlerMappings != null && handlerMappings.size() > 0) {
			for (HandlerMapping hm : handlerMappings) {
				Object handler = hm.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		// 使用HandlerMapping面向对象的思维加上策略模式去解决扩展性的问题。
		return null;
	}
}

spring.bean.aware 包

Aware 接口

public interface Aware {
}

BeanFactoryAware 继承 Aware

public interface BeanFactoryAware extends Aware {

	public void setBeanFactory(DefaultListableBeanFactory beanFactory);
}

spring.bean.factory 包

BeanFactory 接口

根据bean的名称去ioc容器中获取实例

public interface BeanFactory {

	Object getBean(String name);

	Object getBean(Class<?> type, String name);
}

AutowireCapableBeanFactory 接口继承 BeanFactory接口

具体负责BeanFactory的Bean实例的创建和装配

public interface AutowireCapableBeanFactory extends BeanFactory{

}

ListableBeanFactory 接口继承BeanFactory 接口

获取指定类型的所有子类的bean实例集合

public interface ListableBeanFactory extends BeanFactory {

	<T> List<T> getBeansByType(Class<T>clazz);
}

spring.bean.factory.support 包

AbstractBeanFactory 抽象类继承DefaultSingletonBeanRegistry 实现BeanFactory 接口

一个接口中同名方法设计重载时，更多的是为了更方便的给使用者使用
DefaultSingletonBeanRegistry 此类具体代码链接

public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements BeanFactory {

	@Override
	public Object getBean(String name) {
		Object bean = doGetBean(name, null);
		return bean;
	}

	@Override
	public Object getBean(Class<?> type, String name) {
		Object bean = doGetBean(name, type);
		return bean;
	}

	private Object doGetBean(String name, Class<?> type) {
		// 先查询单例bean集合是否存在该bean实例
		Object singleton = getSingleton(name);
		// 有则直接返回
		if (singleton != null) {
			return singleton;
		}
		// 没有则需要查询BeanDefinition集合中是否存在该BeanDefinition
		BeanDefinition beanDefinition = getBeanDefinition(name);
		// 没有BeanDefinition则返回null
		if (beanDefinition == null) {
			return null;
		}
		// 有BeanDefinition则判断是单例还是多例
		if (beanDefinition.isSingleton()) {
			singleton = createBean(beanDefinition);

			addSingleton(name, singleton);
		} else if (beanDefinition.isPrototype()) {
			singleton = createBean(beanDefinition);
		}
		return singleton;
	}

	public abstract Object createBean(BeanDefinition beanDefinition);

	public abstract BeanDefinition getBeanDefinition(String name);
}

AbstractAutowireCapableBeanFactory 抽象类继承 AbstractBeanFactory抽象类

该工厂是负责Bean的创建和装配的

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {

	@Override
	public Object createBean(BeanDefinition beanDefinition) {
		// 实例化 new
		Object bean = createInstance(beanDefinition);
		if (bean == null)
			return null;
		// 属性填充 set
		populateBean(bean, beanDefinition);
		// 初始化 init
		initBean(bean, beanDefinition);
		return bean;
	}

	private void initBean(Object bean, BeanDefinition beanDefinition) {
		//Aware接口会在此时被处理
		if(bean instanceof Aware) {
			if(bean instanceof BeanFactoryAware) {
				((BeanFactoryAware) bean).setBeanFactory((DefaultListableBeanFactory) this);
			}
		}

		invokeInitMethod(bean, beanDefinition);
	}

	private void invokeInitMethod(Object bean, BeanDefinition beanDefinition) {
		// bean标签配置了init-method属性
		String initMethod = beanDefinition.getInitMethod();
		if (initMethod == null || initMethod.equals("")) {
			return;
		}
		ReflectUtils.invokeMethod(bean, initMethod);
		// TODO bean标签实现了InitializingBean接口
	}

	private void populateBean(Object bean, BeanDefinition beanDefinition) {
		List<PropertyValue> propertyValues = beanDefinition.getPropertyValues();
		for (PropertyValue pv : propertyValues) {
			String name = pv.getName();
			Object value = pv.getValue();
			Object valueToUse = null;
			if (value instanceof TypedStringValue) {
				TypedStringValue typedStringValue = (TypedStringValue) value;
				String stringValue = typedStringValue.getValue();
				Class<?> targetType = typedStringValue.getTargetType();
				if (targetType == String.class) {
					valueToUse = stringValue;
				} else if (targetType == Integer.class) {
					valueToUse = Integer.parseInt(stringValue);
				} // ....
			} else if (value instanceof RuntimeBeanReference) {
				RuntimeBeanReference reference = (RuntimeBeanReference) value;
				String ref = reference.getRef();

				// 创建一个bean的时候，根据依赖注入情况，自动去创建另一个bean去注入
				valueToUse = getBean(ref);
			}
			ReflectUtils.setProperty(bean, name, valueToUse);
		}
	}

	private Object createInstance(BeanDefinition beanDefinition) {
		// TODO 可以通过静态工厂去创建？？？？
		// TODO 可以通过实例工厂去创建？？？？

		try {
			String clazzName = beanDefinition.getClazzName();
			Class<?> clazzType = resolveClass(clazzName);
			Object bean = ReflectUtils.createObject(clazzType);

			return bean;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	private Class<?> resolveClass(String clazzName) {
		try {
			Class<?> clazz = Class.forName(clazzName);
			return clazz;
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return null;
	}
}

DefaultListableBeanFactory 类继承AbstractAutowireCapableBeanFactory 抽象类实现BeanDefinitionRegistry，ListableBeanFactory 接口

封装xml中的bean标签表示的信息 -beanDefinition对象
BeanDefinitionRegistry此类具体代码链接

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements BeanDefinitionRegistry,ListableBeanFactory {

	
	private Map<String, BeanDefinition> beanDefinitions = new HashMap<String, BeanDefinition>();

	@Override
	public BeanDefinition getBeanDefinition(String name) {
		return this.beanDefinitions.get(name);
	}

	@Override
	public void registerBeanDefinition(String name, BeanDefinition beanDefinition) {
		this.beanDefinitions.put(name, beanDefinition);
	}

	@Override
	public <T> List<T> getBeansByType(Class<T> clazz) {
		List<T> results = new ArrayList<T>();
		for(BeanDefinition bd: beanDefinitions.values()) {
			String clazzName = bd.getClazzName();
			Class<?> type = resolveClassName(clazzName);
			if(clazz.isAssignableFrom(type)) {
				//判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同
				Object bean = getBean(bd.getBeanName());
				results.add((T) bean);
			}
		}
		return results;
	}

	private Class resolveClassName(String clazzName) {
		try {
			Class<?> type = Class.forName(clazzName);
			return type;
		} catch (ClassNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return null;
	}

	@Override
	public List<BeanDefinition> getBeanDefinitions() {
		List<BeanDefinition> beanDefinitionList = new ArrayList<>();
		// TODO 自动生成的方法存根
		for(BeanDefinition beanDefinition : beanDefinitions.values()) {
			beanDefinitionList.add(beanDefinition);
		}
		return beanDefinitionList;
	}
}

springmvc.mapping.iface包

HandlerMapping 接口

public interface HandlerMapping {

	Object getHandler(HttpServletRequest request);
}

springmvc.mapping 包

BeanNameUrlHandlerMapping 类实现了HandlerMapping, BeanFactoryAware

处理器映射器的实现类：
1.对外提供根据请求查找处理器的功能
2.初始化请求和处理器的映射集合

public class BeanNameUrlHandlerMapping implements HandlerMapping, BeanFactoryAware {
	private Map<String, Object> urlHandlers = new HashMap<String, Object>();

	private DefaultListableBeanFactory beanFactory;

	/**
	 * 初始化方法，需要配置bean标签的时候，指定一下。
	 */
	public void init() {
		// 读取springmvc.xml获取其中的bean标签信息
		List<BeanDefinition> beanDefinitions = beanFactory.getBeanDefinitions();
		for (BeanDefinition beanDefinition : beanDefinitions) {
			String beanName = beanDefinition.getBeanName();
			if (beanName.startsWith("/")) {
				urlHandlers.put(beanName, beanFactory.getBean(beanName));
			}
		}
		// 解析bean标签的name属性和class属性，然后将映射关系存储到map集合中
	}

	@Override
	public Object getHandler(HttpServletRequest request) {
		String uri = request.getRequestURI();
		return urlHandlers.get(uri);
	}

	public void setBeanFactory(DefaultListableBeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}
}

RequestMappingHandlerMapping 实现 HandlerMapping接口

注解方式处理器映射器的实现类：
1.对外提供根据请求查找处理器的功能
2.初始化请求和处理器的映射集合

public class RequestMappingHandlerMapping implements HandlerMapping, BeanFactoryAware {

	private Map<String, HandlerMethod> urlHandlerMethods = new HashMap<>();
	private DefaultListableBeanFactory beanFactory;

	/**
	 * 初始化方法，需要配置bean标签的时候，指定一下。
	 */
	public void init() {
		// 获取所有的BeanDefinition信息
		List<BeanDefinition> beanDefinitions = beanFactory.getBeanDefinitions();
		// 遍历BeanDefinition集合
		for (BeanDefinition beanDefinition : beanDefinitions) {

			// 获取BeanDefinition中的class类型信息
			String clazzName = beanDefinition.getClazzName();
			// 获取对应的Class对象
			Class<?> clazz = getClass(clazzName);
			// 判断是否是处理器类型（通过反射判断该类是否被@Controller注解）
			if (isHandler(clazz)) {
				// 如果是，则从该类中获取所有的方法
				Method[] methods = clazz.getDeclaredMethods();
				for (Method method : methods) {
					// 判断方法是否被RequestMapping注解
					if (isRequestMethod(method)) {
						// 解析RequestMapping注解，获取其中的url
						StringBuffer sb = new StringBuffer();
						// 类上的URL
						RequestMapping requestMapping = clazz.getAnnotation(RequestMapping.class);
						if (requestMapping != null) {
							String firstUrl = requestMapping.value();
							if (firstUrl != null && !firstUrl.equals("")) {
								sb.append(firstUrl);
								sb.append("/");
							}
						}
						requestMapping = method.getAnnotation(RequestMapping.class);
						String secondUrl = requestMapping.value();
						sb.append(secondUrl);

						// 根据Controller的bean的名称去ioc容器中获取Controller实例对象
						String beanName = beanDefinition.getBeanName();
						Object controller = beanFactory.getBean(beanName);

						// 当前正在被解析的方法，就是Method方法对象
						// 将Controller对象和Method对象封装到HandlerMethod类中
						HandlerMethod handlerMethod = new HandlerMethod(controller, method);
						// 建立url和HandlerMethod的映射关系
						urlHandlerMethods.put(sb.toString(), handlerMethod);
					}
				}
			}

		}

	}

	private boolean isRequestMethod(Method method) {
		return method.isAnnotationPresent(RequestMapping.class);//如果指定类型的注释存在于此元素上，则返回 true，否则返回 false
	}

	private boolean isHandler(Class<?> clazz) {
		return clazz.isAnnotationPresent(Controller.class);
	}

	private Class<?> getClass(String clazzName) {
		try {
			return Class.forName(clazzName);
		} catch (Exception e) {
			// TODO: handle exception
		}
		return null;
	}

	@Override
	public Object getHandler(HttpServletRequest request) {
		String uri = request.getRequestURI();
		return this.urlHandlerMethods.get(uri);
	}

	@Override
	public void setBeanFactory(DefaultListableBeanFactory beanFactory) {
		this.beanFactory = beanFactory;
	}

}

HandlerMethod 类

封装Controller对象和对应的Method对象

public class HandlerMethod {

	// Controller对象
	private Object controller;

	// Method方法
	private Method method;

	public Object getController() {
		return controller;
	}

	public void setController(Object controller) {
		this.controller = controller;
	}

	public Method getMethod() {
		return method;
	}

	public void setMethod(Method method) {
		this.method = method;
	}

	public HandlerMethod(Object controller, Method method) {
		super();
		this.controller = controller;
		this.method = method;
	}
}

SimpleUrlHandlerMapping 实现 HandlerMapping 接口

处理器映射器的实现类：
1.对外提供根据请求查找处理器的功能
2.初始化请求和处理器的映射集合

public class SimpleUrlHandlerMapping implements HandlerMapping {

	private Map<String, Object> urlHandlers = new HashMap<String, Object>();

	/**
	 * 初始化方法，需要配置bean标签的时候，指定一下。
	 */
	public void init() {
		urlHandlers.put("/queryUser", new QueryUserHandler());
		urlHandlers.put("/addUser", null);
	}

	@Override
	public Object getHandler(HttpServletRequest request) {
		String uri = request.getRequestURI();
		return urlHandlers.get(uri);
	}
}

springmvc.adapter.iface 包

HandlerAdapter 接口

查看处理器和当前的适配器是否适配

public interface HandlerAdapter {

	boolean supports(Object handler);
	void handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception;

}

springmvc.adapter 包

HttpRequestHandlerAdapter 实现HandlerAdapter

public class HttpRequestHandlerAdapter implements HandlerAdapter {

	@Override
	public void handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		((HttpRequestHandler) handler).handleRequest(request, response);
	}

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HttpRequestHandler);
	}
}

RequestMappingHandlerAdapter 实现HandlerAdapter

注解方式处理器适配器

public class RequestMappingHandlerAdapter implements HandlerAdapter {

	@Override
	public void handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response)
			throws Exception {

		// 从HandlerMethod对象中获取Controller对象和Method对象，目的是利用反射执行该方法
		HandlerMethod handlerMethod = (HandlerMethod) handler;
		Object controller = handlerMethod.getController();
		Method method = handlerMethod.getMethod();

		// 将请求参数，赋值给Controller类中带有RequestMapping注解的方法参数上面
		Object[] args = resolveParameters(request, method);
		Object returnValue = method.invoke(controller, args);

		// 对于执行之后的结果，可以针对@ResponseBody注解进行处理
		handleReturnValue(returnValue, method, response);
	}

	private void handleReturnValue(Object returnValue, Method method, HttpServletResponse response) {
		try {
			if (method.isAnnotationPresent(ResponseBody.class)) {
				if (returnValue instanceof Map) {
					response.setContentType("application/json;charset=utf-8");
					response.getWriter().write(JsonUtils.object2Json(returnValue));
				} else if (returnValue instanceof String) {
					response.setContentType("text/plain;charset=utf-8");
					response.getWriter().write(returnValue.toString());
				}
			} else {
				// 页面处理
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private Object[] resolveParameters(HttpServletRequest request, Method method) {

		List<Object> params = new ArrayList<Object>();

		// 获取请求中的所有参数和参数值的映射集合
		Map<String, String[]> parameterMap = request.getParameterMap();

		if (parameterMap.isEmpty()) {
			return null;
		}

		// 从Method对象中获取参数信息
		Parameter[] parameters = method.getParameters();
		for (Parameter parameter : parameters) {
			String name = parameter.getName();
			Class<?> type = parameter.getType();

			String[] strings = parameterMap.get(name);

			// 类型处理
			handleParameterType(strings, type, params);

		}
		return params.toArray();
	}

	private void handleParameterType(String[] strings, Class<?> type, List<Object> params) {
		// TODO
		if (type == Integer.class) {
			params.add(Integer.parseInt(strings[0]));
		} else if (type == String.class) {
			params.add(strings[0]);
		} // ...
	}

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof HandlerMethod);
	}

}

SimpleControllerHandlerAdapter 实现HandlerAdapter

public class SimpleControllerHandlerAdapter implements HandlerAdapter {

	@Override
	public void handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response)
			throws Exception {
		((SimpleControllerHandler) handler).handleRequest(request, response);
	}

	@Override
	public boolean supports(Object handler) {
		return (handler instanceof SimpleControllerHandler);
	}
}

springmvc.handler.iface包

HttpRequestHandler 接口

最开始springmvc不要求我们突然对于Servlet编程有太大的转变

public interface HttpRequestHandler {

	void handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

SimpleControllerHandler 接口

我们返回一个ModelAndView对象的目的，是可以针对处理结果和要响应的视图进行拦截处理

public interface SimpleControllerHandler {

	ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception;
}

spring.handle 包

QueryUserHandler 类实现HttpRequestHandler 接口

按照HttpRequestHandler的标准去处理请求

public class QueryUserHandler implements HttpRequestHandler {

	@Override
	public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		response.setContentType("text/plain;charset=utf8");
		response.getWriter().print("开课吧NB。。。。QueryUserHandler11111");
	}
}

QueryUserHandler 类实现HttpRequestHandler 接口

按照HttpRequestHandler的标准去处理请求

public class QueryUserHandler2 implements HttpRequestHandler {

	@Override
	public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		response.setContentType("text/plain;charset=utf8");
		response.getWriter().print("开课吧NB。。。。QueryUserHandler2");
	}
}

springmvc.annotation 包

Controller

@Retention(RUNTIME)
@Target(TYPE)
public @interface Controller {

	//@Controller(value="")
	String value() default "";
}

RequestMaping

@Retention(RUNTIME)
@Target({ TYPE, METHOD })
public @interface RequestMapping {
	String value() default "";
}

ResponseBody

@Retention(RUNTIME)
@Target(METHOD)
public @interface ResponseBody {

}

springmvc.controller 包

UserController

使用注解的方式去编写处理器代码，但是UserController不是我们真正的处理器类。

此种写法，真正的处理器类是UserController类中的某一个使用RequestMapping注解的方法。
也就是说，真正的处理器类是HandlerMethod（Controller类+Method方法）

@Controller
public class UserController {

	@RequestMapping("/queryUser3")
	@ResponseBody
	public Map<String, Object> queryUser(Integer id, String name) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("id", id);
		map.put("name", name);
		return map;
	}
	@RequestMapping("/queryUser3")
	@ResponseBody
	public Map<String, Object> queryUser2(Integer id, String name) {
		Map<String, Object> map = new HashMap<String, Object>();
		map.put("id", id);
		map.put("name", name);
		return map;
	}

	@RequestMapping("/saveUser")
	@ResponseBody
	public String saveUser() {
		return "添加成功";
	}
}

springmvc.utils 包

JsonUtils 工具类

SON工具类（使用的是jackson实现的）

public class JsonUtils {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    /**
     * 将对象转换成json字符串。
     * @param data
     * @return
     */
    public static String object2Json(Object data) {
    	try {
			String string = MAPPER.writeValueAsString(data);
			return string;
		} catch (JsonProcessingException e) {
			e.printStackTrace();
		}
    	return null;
    }
    
    /**
     * 将json结果集转化为对象
     * 
     * @param jsonData json数据
     * @param clazz 对象中的object类型
     * @return
     */
    public static <T> T json2Pojo(String jsonData, Class<T> beanType) {
        try {
            T t = MAPPER.readValue(jsonData, beanType);
            return t;
        } catch (Exception e) {
        	e.printStackTrace();
        }
        return null;
    }
    
    /**
     * 将json数据转换成pojo对象list
     * @param jsonData
     * @param beanType
     * @return
     */
    public static <T>List<T> json2List(String jsonData, Class<T> beanType) {
    	JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
    	try {
    		List<T> list = MAPPER.readValue(jsonData, javaType);
    		return list;
		} catch (Exception e) {
			e.printStackTrace();
		}
    	
    	return null;
    }    
}

xml文件

spring.xml文件代码

<beans>
	<bean name="/queryUser2"
		class="com.kkb.springmvc.handler.QueryUserHandler2"></bean>
	<bean name="/queryUser"
		class="com.kkb.springmvc.handler.QueryUserHandler"></bean>
		

	<!-- 使用注解方式编写的处理器类 -->
	<bean class="com.kkb.springmvc.controller.UserController"></bean>

	<!-- 处理器映射器的配置 -->
	<bean class="com.kkb.springmvc.mapping.BeanNameUrlHandlerMapping"
		init-method="init"></bean>
	<bean class="com.kkb.springmvc.mapping.SimpleUrlHandlerMapping"
		init-method="init"></bean>
	<bean
		class="com.kkb.springmvc.mapping.RequestMappingHandlerMapping"
		init-method="init"></bean>

	<!-- 处理器适配器的配置 -->
	<bean class="com.kkb.springmvc.adapter.HttpRequestHandlerAdapter"></bean>
	<bean
		class="com.kkb.springmvc.adapter.SimpleControllerHandlerAdapter"></bean>
	<bean
		class="com.kkb.springmvc.adapter.RequestMappingHandlerAdapter"></bean>
</beans>

pom.xml文件

<project xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.kkb</groupId>
	<artifactId>springmvc-custom12</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>

	<dependencies>
		<!-- servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>dom4j</groupId>
			<artifactId>dom4j</artifactId>
			<version>1.6.1</version>
		</dependency>
		<dependency>
			<groupId>com.kkb</groupId>
			<artifactId>spring-framework-custom-12</artifactId>
			<version>0.0.1-SANPSHOT</version>
		</dependency>

		<!-- jackson依赖 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.6</version>
		</dependency>
		<!-- 专门用来进行xpath语法解析 -->
		<dependency>
			<groupId>jaxen</groupId>
			<artifactId>jaxen</artifactId>
			<version>1.1.6</version>
		</dependency>

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.5</version>
		</dependency>
		<dependency>
			<groupId>com.kkb</groupId>
			<artifactId>spring-framework-custom-12</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<!-- 配置Maven的JDK编译级别 -->
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.2</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
					<encoding>UTF-8</encoding>
					<!-- 通过反射获取方法参数时，需要设置以下参数才能保证获取到的方法参数是有意义的 -->
					<compilerArgs>
						<arg>-parameters</arg>
					</compilerArgs>
				</configuration>
			</plugin>

			<!-- 配置tomcat7插件，不需要安装本地tomcat -->
			<plugin>
				<groupId>org.apache.tomcat.maven</groupId>
				<artifactId>tomcat7-maven-plugin</artifactId>
				<version>2.2</version>
				<configuration>
					<port>80</port>
					<path>/</path>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>