SpringMVC学习笔记
- 手写框架篇
-
- 需求分析
- 自定义SpringMVC框架V1版本
-
- 定义处理器
- 定义处理器映射器
- 定义处理器适配器
- 定义前端控制器
- 配置web.xml
- 自定义SpringMVC框架V2版本
-
- 修改自定义Spring框架整合
- 修改处理器映射器
- 修改前端控制器
- 测试
- 自定义SpringMVC框架V3版本
-
- 自定义注解
- 定义RequestMappingHandlerMapping
- 定义RequestMappingHandlerAdapter
- DispatcherServlet.properties新增配置
- 测试
- 代码实现github地址
手写框架篇
需求分析
- 需求:
* 查询用户:请求URL http://localhost/queryUser
* 添加用户:请求URL http://localhost/savaUser
- 问题:如果按照常规Servlet开发习惯,一个类只会处理一个请求。
- 解决方案:自定义Servlet extends BaseServlet(公共的Servlet)
BaseServlet{
doPost(){
// url中必须带有method参数
// method参数的值就是对应要调用的方法名称
// 通过反射调用制定方法
}
}
MyServlet extends BaseServlet{
query(){
}
save(){
}
}
- 只需要一个Servlet进行请求分发即可,处理请求的类只是一个普通类(不需要实现Servlet相关的类)
自定义SpringMVC框架V1版本
定义处理器
- 处理器接口规范:
public interface HttpRequestHandler {
void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}
/**
* 可以针对返回值进行二次处理
*/
public interface SimpleControllertHandler {
ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}
- 处理器实现类:
/**
* 查询用户处理器
*/
public class QueryUserHandler implements HttpRequestHandler {
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=utf-8");
response.getWriter().write("--- QueryUserHandler ---");
}
}
/**
* 添加用户处理器
*/
public class SaveUserHandler implements SimpleControllertHandler {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=utf-8");
response.getWriter().write("--- SaveUserHandler ---");
return null;
}
}
定义处理器映射器
- 处理器映射器接口规范:
/**
* 它的实现类是用来建立请求和处理类的映射关系
* 该接口的作用是提供对该映射关系的访问,比如说根据请求查找处理类
*/
public interface HandlerMapping {
/**
* 根据请求查找处理类
*/
Object getHandler(HttpServletRequest request) throws Exception;
}
- 处理器映射器实现类:
/**
* <bean name="/queryUser" class="QueryUserHandler的全路径"></bean>
*/
public class BeanNameUrlHandlerMapping implements HandlerMapping {
private Map<String, Object> urlHandlers = new HashMap<>();
public BeanNameUrlHandlerMapping() {
// TODO 暂时先写死
this.urlHandlers.put("/queryUser", new QueryUserHandler());
}
@Override
public Object getHandler(HttpServletRequest request) throws Exception {
String uri = request.getRequestURI();
return this.urlHandlers.get(uri);
}
}
/**
* <bean class="内置的处理器类">
* <props>
* <prop key="url">类的全路径</prop>
* </props>
* </bean>
*/
public class SimpleUrlHandlerMapping implements HandlerMapping {
private Map<String, Object> urlHandlers = new HashMap<>();
public SimpleUrlHandlerMapping() {
// TODO 暂时先写死
this.urlHandlers.put("/saveUser", new SaveUserHandler());
}
@Override
public Object getHandler(HttpServletRequest request) throws Exception {
String uri = request.getRequestURI();
return this.urlHandlers.get(uri);
}
}
定义处理器适配器
- 处理器适配器接口规范:
/**
* 该接口是DispatcherServlet用来调用不同类型处理器的统一类型
* HandlerAdapter和Handler类型是一对一的,就类似于某一个类型的电脑,对应一个统一的电源适配器
*/
public interface HandlerAdapter {
/**
* 用来匹配适配器和处理器
*/
boolean supports(Object handler);
/**
* 调用不同类型的处理器完成请求处理
*/
ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception;
}
- 处理器适配器实现类:
public class HttpRequestHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof HttpRequestHandler);
}
@Override
public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
((HttpRequestHandler) handler).handleRequest(request, response);
return null;
}
}
public class SimpleControllerHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof SimpleControllertHandler);
}
@Override
public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
return ((SimpleControllertHandler) handler).handleRequest(request, response);
}
}
定义前端控制器
- 抽象的Servlet:
public abstract class AbstractServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doPost(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doDispatch(request, response);
}
/**
* 请求分发
*/
public abstract void doDispatch(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
}
- DispatcherServlet:
/**
* springmvc提供的唯一的一个Servlet类
*/
public class DispatcherServlet extends AbstractServlet {
/**
* HandlerMapping的策略集合
*/
private List<HandlerMapping> handlerMappings = new ArrayList<>();
/**
* HandlerAdapter的策略集合
*/
private List<HandlerAdapter> handlerAdapters = new ArrayList<>();
/**
* servlet初始化
*/
@Override
public void init() throws ServletException {
handlerMappings.add(new BeanNameUrlHandlerMapping());
handlerMappings.add(new SimpleUrlHandlerMapping());
handlerAdapters.add(new HttpRequestHandlerAdapter());
handlerAdapters.add(new SimpleControllerHandlerAdapter());
}
@Override
public void doDispatch(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
try {
// 1、根据请求,查找对应的处理类
// 问题1:处理类长啥样?(它和Servlet无关,可以随便写,只是说为了统一,最后指定规范[接口])
// 问题2:去哪找处理类?(也就是请求URL和处理类的关系在哪建立)
Object handler = getHandler(request);
if (handler == null) {
return;
}
// 2、调用处理类的方法,执行请求处理,并返回处理结果
HandlerAdapter ha = getHandlerAdapter(handler);
if (ha == null) {
return;
}
ha.handleRequest(handler, request, response);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
private Object getHandler(HttpServletRequest request) throws Exception {
// 首先 处理类和请求之间 的映射关系可能存储在不同的地方(HandlerMapping)
if (handlerMappings != null) {
for (HandlerMapping hm : handlerMappings) {
Object handler = hm.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
private HandlerAdapter getHandlerAdapter(Object handler) {
if (handlerAdapters != null) {
// 遍历策略集合
for (HandlerAdapter ha : handlerAdapters) {
if (ha.supports(handler)) {
return ha;
}
}
}
return null;
}
}
配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>com.yw.servlet.DispatcherServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
自定义SpringMVC框架V2版本
- 创建一个工程:springmvc-framework-custom,并引入之前手写的Spring框架:
<!-- 引入自定义的Spring框架 -->
<dependency>
<groupId>com.yw.spring.framework</groupId>
<artifactId>spring-framework-custom</artifactId>
<version>1.0</version>
</dependency>
- 将V1版本中的处理器映射器、处理器适配器、前端控制器等复制到该工程下,如下图所示:
修改自定义Spring框架整合
- 新增标记接口:用于BeanFactory容器的注入
public interface Aware {
}
public interface BeanFactoryAware extends Aware {
void setBeanFactory(BeanFactory beanFactory);
}
- 定义接口 InitializingBean:实现该接口可以在 依赖注入 与 初始化Bean 之间完成一些事情
public interface InitializingBean {
void afterPropertiesSet();
}
- 修改AbstractAutowiredCapableBeanFactory中的
方法:initializeBean
public abstract class AbstractAutowiredCapableBeanFactory extends AbstractBeanFactory {
// 省略...
private void initializeBean(Object bean, BeanDefinition beanDefinition) {
// 需要针对Aware接口标记的类进行特殊处理
if (bean instanceof Aware) {
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(this);
}
}
// 可以进行InitializeBean接口的处理
if (bean instanceof InitializingBean) {
((InitializingBean) bean).afterPropertiesSet();
}
ReflectUtils.invokeMethod(bean, beanDefinition.getInitMethod());
}
}
- 修改 ListableBeanFactory 接口
/**
* 对于Bean容器中的Bean可以进行集合操作或者说叫批量操作
*/
public interface ListableBeanFactory extends BeanFactory {
/**
* 可以根据指定类型获取它或者它实现类的对象
*/
<T> List<T> getBeansByType(Class type);
}
- 修改 BeanDefinitionRegistry 接口:新增 getBeanDefinitions 方法
/**
* 1、实现类是封装了BeanDefinition集合信息
* 2、接口类是提供对于其封装的BeanDefinition信息进行添加和获取功能
*/
public interface BeanDefinitionRegistry {
/**
* 获取BeanDefinition
*/
BeanDefinition getBeanDefinition(String beanName);
/**
* 注册BeanDefinition
*/
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
/**
* 获取BeanDefinition集合
*/
List<BeanDefinition> getBeanDefinitions();
}
- DefaultListableBeanFactory 实现 ListableBeanFactory,BeanDefinitionRegistry中的两个方法:
/**
* 既是spring中的真正管理Bean实例的容器工厂
* 同时又是管理BeanDefinition的BeanDefinition注册器
*/
public class DefaultListableBeanFactory extends AbstractAutowiredCapableBeanFactory
implements BeanDefinitionRegistry, ListableBeanFactory {
/**
* 存储BeanDefinition的容器
*/
private Map<String, BeanDefinition> beanDefinitions = new ConcurrentHashMap<>(128);
@Override
public BeanDefinition getBeanDefinition(String beanName) {
return beanDefinitions.get(beanName);
}
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
beanDefinitions.put(beanName, beanDefinition);
}
@Override
public List<BeanDefinition> getBeanDefinitions() {
List<BeanDefinition> results = new ArrayList<>();
for (BeanDefinition bd : beanDefinitions.values()) {
results.add(bd);
}
return results;
}
@Override
public <T> List<T> getBeansByType(Class type) {
List<T> results = new ArrayList<>();
// 获取容器中所有的BeanDefinition,遍历每个BeanDefinition,取出来它的类型
for (BeanDefinition bd : beanDefinitions.values()) {
Class<?> clazzType = bd.getClazzType();
// type如果是clazzType的父类型,则返回true
if (type.isAssignableFrom(clazzType)) {
results.add((T) getBean(bd.getBeanName()));
}
}
return results;
}
}
修改处理器映射器
- BeanNameUrlHandlerMapping 增加实现 InitializingBean 和 BeanFactoryAware 两个接口:体现Spring框架和SpringMVC框架的整合
public class BeanNameUrlHandlerMapping implements HandlerMapping, InitializingBean, BeanFactoryAware {
private Map<String, Object> urlHandlers = new HashMap<>();
private DefaultListableBeanFactory beanFactory;
public BeanNameUrlHandlerMapping() {
}
@Override
public Object getHandler(HttpServletRequest request) throws Exception {
String uri = request.getRequestURI();
return this.urlHandlers.get(uri);
}
@Override
public void afterPropertiesSet() {
List<BeanDefinition> beanDefinitions = beanFactory.getBeanDefinitions();
for (BeanDefinition bd : beanDefinitions) {
String beanName = bd.getBeanName();
if (beanName.startsWith("/")) {
this.urlHandlers.put(beanName, beanFactory.getBean(beanName));
}
}
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = (DefaultListableBeanFactory) beanFactory;
}
}
修改前端控制器
- resources目录下新增 DispatcherServlet.properties 文件:
com.yw.springmvc.framework.mapping.HandlerMapping=com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping
com.yw.springmvc.framework.adapter.HandlerAdapter=com.yw.webmvc.framework.adapter.impl.HttpRequestHandlerAdapter,\
com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter
- 修改DispatcherServlet:整合Spring框架,并从配置文件中加载默认的处理器映射器、处理器适配器等策略
public class DispatcherServlet extends AbstractServlet {
/**
* HandlerMapping的策略集合
*/
private List<HandlerMapping> handlerMappings = new ArrayList<>();
/**
* HandlerAdapter的策略集合
*/
private List<HandlerAdapter> handlerAdapters = new ArrayList<>();
private DefaultListableBeanFactory beanFactory;
private static Properties defaultStrategies;
static {
try {
ClasspathResource resource = new ClasspathResource("DispatcherServlet.properties");
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
@Override
public void init(ServletConfig config) throws ServletException {
// handlerAdapters.add(new HttpRequestHandlerAdapter());
// handlerAdapters.add(new SimpleControllerHandlerAdapter());
//
// handlerMappings.add(new BeanNameUrlHandlerMapping());
// handlerMappings.add(new SimpleUrlHandlerMapping());
String location = config.getInitParameter("contextConfigLocation");
// 初始化spring容器
initContainer(location);
// 初始化策略集合
initStrategies();
}
private void initContainer(String location) {
// 加载spring容器需要的BeanDefinition信息
beanFactory = new DefaultListableBeanFactory();
ClasspathResource resource = new ClasspathResource(location);
InputStream inputStream = resource.getResource();
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
beanDefinitionReader.loadBeanDefinitions(inputStream);
// 注册默认策略BeanDefinition
registerDefaultStrategies();
// 将spring容器中管理的所有单例Bean进行初始化(getBean)
beanFactory.getBeansByType(Object.class);
}
private void registerDefaultStrategies() {
registerDefaultStrategies(HandlerMapping.class);
registerDefaultStrategies(HandlerAdapter.class);
}
private <T> void registerDefaultStrategies(Class<T> strategyInterface) {
String key = strategyInterface.getName();
String value = defaultStrategies.getProperty(key);
if (value == null) {
return;
}
String[] clazzNames = StringUtils.split(value, ",");
for (String clazzName : clazzNames) {
try {
Class<?> clazzType = Class.forName(clazzName);
String beanName = clazzType.getSimpleName();
BeanDefinition beanDefinition = new BeanDefinition(clazzName, beanName);
beanDefinition.setScope("singleton");
beanFactory.registerBeanDefinition(beanName, beanDefinition);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
private void initStrategies() {
initHandlerMappings();
initHandlerAdapters();
}
private void initHandlerMappings() {
handlerMappings = beanFactory.getBeansByType(HandlerMapping.class);
}
private void initHandlerAdapters() {
handlerAdapters = beanFactory.getBeansByType(HandlerAdapter.class);
}
// 省略...
}
测试
- 定义处理器:
public class QueryUserHandler implements HttpRequestHandler {
@Override
public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=utf-8");
response.getWriter().write("--- QueryUserHandler V2 ---");
}
}
public class SaveUserHandler implements SimpleControllerHandler {
@Override
public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
response.setContentType("text/plain;charset=utf-8");
response.getWriter().write("--- SaveUserHandler V2 ---");
return null;
}
}
- 配置springmvc.xml:
<beans>
<!-- 配置处理器映射器 -->
<bean class="com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping"/>
<!-- 配置处理器适配器 -->
<bean class="com.yw.springmvc.framework.adapter.impl.HttpRequestHandlerAdapter"/>
<bean class="com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter"/>
<!-- 配置处理器 -->
<bean name="/queryUser" class="com.yw.springmvc.example.handler.QueryUserHandler" />
<bean name="/saveUser" class="com.yw.springmvc.example.handler.SaveUserHandler" />
</beans>
- 配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
version="2.5">
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servlet-class>com.yw.springmvc.framework.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
自定义SpringMVC框架V3版本
自定义注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Controller {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
public @interface RequestMapping {
String value() default "";
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface ResponseBody {
}
定义RequestMappingHandlerMapping
public class RequestMappingHandlerMapping implements HandlerMapping, InitializingBean, BeanFactoryAware {
private Map<String, HandlerMethod> urlHandlers = new HashMap<>();
private DefaultListableBeanFactory beanFactory;
@Override
public Object getHandler(HttpServletRequest request) throws Exception {
String uri = request.getRequestURI();
return this.urlHandlers.get(uri);
}
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = (DefaultListableBeanFactory) beanFactory;
}
@Override
public void afterPropertiesSet() {
List<BeanDefinition> beanDefinitions = this.beanFactory.getBeanDefinitions();
for (BeanDefinition bd : beanDefinitions) {
Class<?> clazzType = bd.getClazzType();
// 如果类上带有@Controller或者@RequestMapping注解
if (isHandler(clazzType)) {
RequestMapping classMapping = clazzType.getAnnotation(RequestMapping.class);
String classUrl = classMapping.value();
Method[] methods = clazzType.getDeclaredMethods();
for (Method method : methods) {
if (method.isAnnotationPresent(RequestMapping.class)) {
// 建立URL和HandlerMethod对象的映射关系
StringBuilder sb = new StringBuilder();
if (!classUrl.startsWith("/")) {
sb.append("/");
}
sb.append(classUrl);
RequestMapping methodMapping = method.getAnnotation(RequestMapping.class);
String methodUrl = methodMapping.value();
if (!methodUrl.startsWith("/")) {
sb.append("/");
}
sb.append(methodUrl);
// 获取HandlerMethod
HandlerMethod hm = new HandlerMethod(beanFactory.getBean(bd.getBeanName()), method);
this.urlHandlers.put(sb.toString(), hm);
}
}
}
}
}
private boolean isHandler(Class<?> clazzType) {
return (clazzType.isAnnotationPresent(Controller.class)
|| clazzType.isAnnotationPresent(RequestMapping.class));
}
}
定义RequestMappingHandlerAdapter
public class RequestMappingHandlerAdapter implements HandlerAdapter {
@Override
public boolean supports(Object handler) {
return (handler instanceof HandlerMethod);
}
@Override
public ModelAndView handleRequest(Object handler, HttpServletRequest request, HttpServletResponse response) throws Exception {
HandlerMethod hm = (HandlerMethod) handler;
Object controller = hm.getController();
Method method = hm.getMethod();
// 处理请求参数
Object[] args = handleParameters(request, method);
// 通过反射调用方法
Object returnValue = method.invoke(controller, args);
// 处理返回值
handleReturnValue(returnValue, response);
return null;
}
private Object[] handleParameters(HttpServletRequest request, Method method) {
List<Object> args = new ArrayList<>();
// 请求参数KV集合
Map<String, String[]> parameterMap = request.getParameterMap();
// 方法参数数组
Parameter[] parameters = method.getParameters();
for (Parameter parameter : parameters) {
// 取出参数名称(需要特殊处理,否则获取到的就是arg0,arg1这样的参数名称)
String name = parameter.getName();
Class<?> type = parameter.getType();
// 方法参数名称一定要和请求的Key保持一致
String[] strings = parameterMap.get(name);
Object valueToUse = resolveValue(strings, type);
args.add(valueToUse);
}
return args.toArray();
}
private Object resolveValue(String[] strings, Class<?> type) {
if (type == Integer.class) {
return Integer.parseInt(strings[0]);
} else if (type == String.class) {
return strings[0];
}
return null;
}
private void handleReturnValue(Object value, HttpServletResponse response) throws Exception {
if (value instanceof String) {
response.setContentType("text/plain;charset=utf-8");
response.getWriter().write(value.toString());
} else if (value instanceof Map) {
response.setContentType("application/json;charset=utf-8");
response.getWriter().write(JsonUtils.object2Json(value));
}
}
}
DispatcherServlet.properties新增配置
com.yw.springmvc.framework.mapping.HandlerMapping=com.yw.springmvc.framework.mapping.impl.BeanNameUrlHandlerMapping,\
com.yw.springmvc.framework.mapping.impl.RequestMappingHandlerMapping
com.yw.springmvc.framework.adapter.HandlerAdapter=com.yw.webmvc.framework.adapter.impl.HttpRequestHandlerAdapter,\
com.yw.springmvc.framework.adapter.impl.SimpleControllerHandlerAdapter,\
com.yw.springmvc.framework.adapter.impl.RequestMappingHandlerAdapter
测试
- 定义控制器:
/**
* 注意:
* SpringMvc中的处理器在该类中到底指的是谁?
* 是Controller类呢?还是其他的?
* 真正的处理器是Controller中的某个使用RequestMapping注解标记的方法
* 也就是Controller对象+Method对象==> HandlerMethod对象(真正的处理器)
*/
@Controller
@RequestMapping("user")
public class UserController {
@RequestMapping("query")
@ResponseBody
public Map<String, Object> query(Integer id, String name) {
Map<String, Object> map = new HashMap<>(2);
map.put("id", id);
map.put("name", name);
return map;
}
@RequestMapping("save")
@ResponseBody
public String save() {
return "OK";
}
}
代码实现github地址
- https://github.com/shouwangyw/ssm/tree/main/springmvc-framework-custom