一、DispatcherServlet解决的问题
**问题1：**如图所示，如果对于某一业务，增删改查如果都创建一个servlet，那么业务越多，对应的servlet就越多。以上述业务中增加和删除业务为例：
@WebServlet("/add.do")
public class AddServlet extends ViewBaseServlet {
private FruitDAO fruitDAO = new FruitDAOImpl();
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
request.setCharacterEncoding("UTF-8");
String fname = request.getParameter("fname");
Integer price = Integer.parseInt(request.getParameter("price")) ;
Integer fcount = Integer.parseInt(request.getParameter("fcount"));
String remark = request.getParameter("remark");
Fruit fruit = new Fruit(0,fname , price , fcount , remark ) ;
fruitDAO.addFruit(fruit);
response.sendRedirect("index");
}
}
@WebServlet("/del.do")
public class DelServlet extends ViewBaseServlet {
private FruitDAO fruitDAO = new FruitDAOImpl();
@Override
public void doGet(HttpServletRequest request , HttpServletResponse response)throws IOException, ServletException {
String fidStr = request.getParameter("fid");
if(StringUtil.isNotEmpty(fidStr)){
int fid = Integer.parseInt(fidStr);
fruitDAO.delFruit(fid);
//super.processTemplate("index",request,response);
response.sendRedirect("index");
}
}
}
解决方案：两个servlet重写了doGet方法，在doGet中进行相关操作，我们可以看到，两个servlet的url是不一样的，即@WebServlet(“/add.do”)和@WebServlet(“/del.do”)。那么可以根据路径参数不同，设置一个operate参数，这个参数由前台传入，
<input type="hidden" name="operate" value="add"/>
发送给服务器，服务器用来判断（条件判断）进入增删改查哪个方法。
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//设置编码
request.setCharacterEncoding("UTF-8");
String operate = request.getParameter("operate");
if(StringUtil.isEmpty(operate)){
operate = "index" ;
}
switch(operate){
case "index":
index(request,response);
break;
case "add":
add(request,response);
break;
case "del":
del(request,response);
break;
case "edit":
edit(request,response);
break;
case "update":
update(request,response);
break;
default:
throw new RuntimeException("operate值非法!");
}
}
**存在问题：**但是使用条件判断也存在问题，随着业务增加，条件判断会越来越多，这也不符合修改封闭原则。
解决方案：我们可以规定方法名称和operate参数相同，这样就可以用反射的方法来根据operate进入不同的方法了，即使增加业务，也不用修改代码。
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//设置编码
request.setCharacterEncoding("UTF-8");
String operate = request.getParameter("operate");
if(StringUtil.isEmpty(operate)){
operate = "index" ;
}
try {
Method method = this.getClass().getDeclaredMethod(operate, HttpServletRequest.class, HttpServletResponse.class);
if (method != null) {
method.invoke(this, request, response);
return;
}
} catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
e.printStackTrace();
}
throw new RuntimeException("Invalid operate.");
}
这样，即使增加新的访问方法，也不用修改这一块代码。
存在问题：但是这样还是存在问题的，如果系统还有一个user相关业务，那我们也要在user里面写一套相同逻辑的反射代码，来处理这一块。
解决方案：因此我们可以继续向上提取，设计了中央控制器类：DispatcherServlet。
二、DispatcherServlet主要功能
中央控制器需要完成功能
1)从url中提取servletPath : /fruit.do -> fruit
2)根据fruit找到对应的组件:FruitController ， 这个对应的依据我们存储在applicationContext.xml中
<bean id=“fruit” class="com.atguigu.fruit.controllers.FruitController/>
通过DOM技术我们去解析XML文件，在中央控制器中形成一个beanMap容器，用来存放所有的Controller组件
3)根据获取到的operate的值定位到我们FruitController中需要调用的方法
三、代码实现
package com.lucky.myssm.myspringmvc;
import com.lucky.myssm.io.BeanFactory;
import com.lucky.myssm.io.ClassPathXmlApplicationContext;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
@WebServlet("*.do")
public class DispatcherServlet extends ViewBaseServlet {
private BeanFactory beanFactory ;
// 生命周期 实例化 初始化 服务 销毁
public DispatcherServlet() {
}
@Override
public void init() throws ServletException {
super.init();
beanFactory = new ClassPathXmlApplicationContext();
}
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 设置编码
request.setCharacterEncoding("UTF-8");
// 假设url http://localhost:8080/pro10/hello.do
String servletPath = request.getServletPath();
// /hello.do
// 通过字符串截取获取 hello
int lastDot = servletPath.lastIndexOf(".do");
servletPath = servletPath.substring(1, lastDot);
// 获取到了hello
System.out.println(servletPath);
// 根据service path 获取controller对象
Object controller = beanFactory.getBean(servletPath);
// 找到hello对应的controller
// 调用controller里面对应operate的方法
request.setCharacterEncoding("UTF-8");
String operate = request.getParameter("operate");
if (Objects.isNull(operate) || "".equals(operate)) {
operate = "index";
}
try {
// 获取名称为operate， 参数为request和response的方法
Method[] methods = controller.getClass().getDeclaredMethods();
for (Method method : methods) {
if (operate.equals(method.getName())) {
// 获取请求参数
Parameter[] parameters = method.getParameters();
Object[] paramValues = new Object[parameters.length];
for (int i = 0; i < paramValues.length; i++) {
// 获取参数名称
Parameter param = parameters[i];
String paramName = param.getName();
if ("request".equals(paramName)) {
paramValues[i] = request;
} else if ("reponse".equals(paramName)) {
paramValues[i] = response;
} else if ("session".equals(paramName)) {
paramValues[i] = request.getSession();
}
else {
// 跟据name去request获取参数值
String paramValue = request.getParameter(paramName);
// 如果参数不是string，那么就需要强转
if (paramValue != null) {
if ("java.lang.Integer".equals(param.getType().getName())) {
paramValues[i] = Integer.parseInt(paramValue);
}
else {
paramValues[i] = paramValue; // 这个直接获取的是string
}
} else {
paramValues[i] = null;
}
}
}
method.setAccessible(true);
Object retVal = method.invoke(controller, paramValues);
// 视图处理
if (Objects.nonNull(retVal)) {
String retValStr = (String)retVal;
if (retValStr.startsWith("redirect:")) {
// 把redirect:后面拿过来
String redirectPath = retValStr.substring("redirect:".length());
response.sendRedirect(redirectPath);
} else {
super.processTemplate(retValStr, request, response);
}
}
// else {
// throw new RuntimeException("Invalid operate!");
// }
}
}
} catch (IllegalAccessException|InvocationTargetException e) {
e.printStackTrace();
}
}
}
获取Controler以及Controler中相关属性装配，才用application.xml配置，相当于简单实现一个IOC容器。
xml文件配置
<?xml version="1.0" encoding="utf-8"?>
<beans>
<!-- 这个bean标签的作用是 将来servletpath中涉及的名字对应的是fruit(前面的id，这就和dispatch对应起来了)，
那么就要FruitController这个类来处理 -->
<bean id="fruitDAO" class="com.lucky.fruit.dao.impl.FruitDAOImpl"/>
<bean id="fruitService" class="com.lucky.fruit.service.impl.FruitServiceImpl">
<property name="fruitDAO" ref="fruitDAO"/>
</bean>
<bean id="fruit" class="com.lucky.fruit.controllers.FruitController">
<property name="fruitService" ref="fruitService"/>
</bean>
</beans>
获取controller以及设置controller属性。
package com.lucky.myssm.io;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
public class ClassPathXmlApplicationContext implements BeanFactory {
private Map<String,Object> beanMap = new HashMap<>();
public ClassPathXmlApplicationContext(){
try {
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
//1.创建DocumentBuilderFactory
DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
//2.创建DocumentBuilder对象
DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder() ;
//3.创建Document对象
Document document = documentBuilder.parse(inputStream);
//4.获取所有的bean节点
NodeList beanNodeList = document.getElementsByTagName("bean");
for(int i = 0 ; i<beanNodeList.getLength() ; i++){
Node beanNode = beanNodeList.item(i);
if(beanNode.getNodeType() == Node.ELEMENT_NODE){
Element beanElement = (Element)beanNode ;
String beanId = beanElement.getAttribute("id");
String className = beanElement.getAttribute("class");
Class beanClass = Class.forName(className);
//创建bean实例
Object beanObj = beanClass.newInstance() ;
//将bean实例对象保存到map容器中
beanMap.put(beanId , beanObj) ;
//到目前为止，此处需要注意的是，bean和bean之间的依赖关系还没有设置
}
}
//5.组装bean之间的依赖关系
for(int i = 0 ; i<beanNodeList.getLength() ; i++){
Node beanNode = beanNodeList.item(i);
if(beanNode.getNodeType() == Node.ELEMENT_NODE) {
Element beanElement = (Element) beanNode;
String beanId = beanElement.getAttribute("id");
NodeList beanChildNodeList = beanElement.getChildNodes();
for (int j = 0; j < beanChildNodeList.getLength() ; j++) {
Node beanChildNode = beanChildNodeList.item(j);
if(beanChildNode.getNodeType()==Node.ELEMENT_NODE && "property".equals(beanChildNode.getNodeName())){
Element propertyElement = (Element) beanChildNode;
String propertyName = propertyElement.getAttribute("name");
String propertyRef = propertyElement.getAttribute("ref");
//1) 找到propertyRef对应的实例
Object refObj = beanMap.get(propertyRef);
//2) 将refObj设置到当前bean对应的实例的property属性上去
Object beanObj = beanMap.get(beanId);
Class beanClazz = beanObj.getClass();
Field propertyField = beanClazz.getDeclaredField(propertyName);
propertyField.setAccessible(true);
propertyField.set(beanObj,refObj);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public Object getBean(String id) {
return beanMap.get(id);
}
}
574
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
