• J2EE基础-自定义MVC(中)

    目录

    前言

    一、让中央控制器动态加载存储子控制器

    二、 参数传递封装优化

    三、 对于方法执行结果转发重定向优化

    四、框架配置文本优化

    前言

    上次我们认识了自定义MVC原理(http://t.csdn.cn/S5TWs)，今天了解的内容是自定义mvc框架实现(基于上篇文章进行优化)

    一、让中央控制器动态加载存储子控制器

    通过建模我们可以知道，最终configModel对象会包含config.xml中所有子控制器信息，同时为了解决中央控制器能够动态加载保存子控制器的信息，那么我们只需要引入configModel对象即可

     config.xml:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <config>
    3. 	<action path="/book" type="com.oyang.servlet.BookAction">
    4. 		<forward name="failed" path="/demo2.jsp" redirect="false" />
    5. 		<forward name="success" path="/demo3.jsp" redirect="true" />
    6. 	</action>
    7.  
    8. 	<action path="/order" type="com.oyang.servlet.OrderAction">
    9. 		<forward name="failed" path="/demo2.jsp" redirect="false" />
    10. 		<forward name="success" path="/demo3.jsp" redirect="true" />
    11. 	</action>
    12. </config>

     优化DispatcherServlet： 

    1. package com.oyang.framework;
    2.  
    3. import java.io.IOException;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12.  
    13. import org.apache.commons.beanutils.BeanUtils;
    14. import org.apache.commons.beanutils.PropertyUtils;
    15. import com.oyang.servlet.BookAction;
    16. /**
    17.  * 中央控制器：
    18.  * 	主要职能，接收浏览器请求，找到对应的处理人
    19.  * @author yang 
    20.  *
    21.  */
    22. //@WebServlet("*.action")
    23. public  class DispatcherServlet extends HttpServlet{
    24. 	//private Map<String, Action> actions=new HashMap<String,Action>();
    25. 	/**
    26. 	 * 通过建模我们可以知道，最终configModel对象会包含config.xml中的所有子控制器信息，
    27. 	 * 同时为了解决中央控制器能够动态加载保存子控制器的信息，那么我们只需要引入configModel对象即可
    28. 	 */
    29. 	
    30. 	private ConfigModel configModel;
    31. 	//程序启动时 ，只会加载一次
    32. 	@Override
    33. 	public void init() throws ServletException {
    34. 		//actions.put("/book",new BookAction());
    35. 		//actions.put("/order",new BookAction());
    36. 		try {
    37. 			//配置地址
    38. 			//getInitParameter的作用是拿到web.xml中的Servlet信息配置的参数
    39. 			String configLocation = this.getInitParameter("configLocation");
    40. 			if(configLocation==null || "".equals(configLocation))
    41. 				configModel=ConfigModelFactory.bulid();
    42. 			else
    43. 				configModel=ConfigModelFactory.bulid(configLocation);
    44. 		} catch (Exception e) {
    45. 			e.printStackTrace();
    46. 		}
    47. 	}
    48.  
    49. 	@Override
    50. 	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    51. 		doPost(req, resp);
    52. 	}
    53. 		
    54. 	//只要是以.action结尾的每次请求都会被doPost截取
    55. 	@Override
    56. 	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    57. 		http://localhost:8080/mvc/book.action?methodName=list
    58. 		String uri = req.getRequestURI();
    59. 		// 要拿到/book，就是最后一个/到最后一个.为止
    60. 		uri= uri.substring(uri.lastIndexOf("/"),uri.lastIndexOf("."));
    61. 		
    62.  
    63. 		/**
    64. 		 * 思路：
    65. 		 * 以前我们从map集合中获取，那样的话就行不通了。那么该怎么办呢？此时我们就需要修改xml配置文件了。
    66. 		 * 通过配置文件拿到全路径名，再通过反射实例化
    67. 		 */
    68. 		
    69. 		//Action action = actions.get(uri);
    70. 		//取到.action之后	Action action = actions.get(uri);里面定义了对应的方法
    71. 		//相比于上一种从map集合获取子控制器，当前需要获取config.xml中的全路径名，然后反射实例化
    72. 		ActionModel actionModel = configModel.pop(uri);
    73. 		if(actionModel==null) {
    74. 			throw new RuntimeException("action config eroer 配置错误");
    75. 		}
    76. 		String type = actionModel.getType();//拿到type值 
    77. 		//拿到type值之后就能通过路径名反射实例化 ------type是Action子控制器的全路径名
    78. 		try {
    79. 			Action action = (Action) Class.forName(type).newInstance();
    80. 			//此时的action 是bookAction
    81. 			if(action instanceof ModelDriven) {
    82. 				ModelDriven md=(ModelDriven) action;
    83. 				//action指的是bookAction，而bookAction又实现了ModelDriven接口，然后把bookAction转换成ModelDriven接口
    84. 				Object model = md.getModel();//model指的是bookAction中的book实例
    85. 				//给model中的属性赋值，要接收前端jsp传递过来的参数
    86. 				//PropertyUtils.getProperty(bean, name);//从某一个对象里面取某一个值
    87. 				//将前端所有参数值封装进实体类
    88. 				BeanUtils.populate(model, req.getParameterMap());
    89. 				System.out.println(model);
    90. 			} 
    91. 			//正式调用方法之前，book中的属性要被赋值
    92. //			action.execute(req, resp);
    93. 			String retult = action.execute(req, resp);
    94. 			ForwardModel forwardModel = actionModel.pop(retult);
    95. 			if(forwardModel==null) {
    96. 				throw new RuntimeException("forward config error 配置错误");
    97. 			}
    98. //			/bookList.jsp/index.jsp
    99. 			String path = forwardModel.getPath();
    100. 			//拿到是否需要转发的配置
    101. 			boolean redirect = forwardModel.getRedirect();
    102. 			if(redirect) 
    103. 				resp.sendRedirect(req.getServletContext().getContextPath()+path);
    104. 			else
    105. 			req.getRequestDispatcher(path).forward(req, resp);
    106. 		} catch (Exception e) {
    107. 			// TODO Auto-generated catch block
    108. 			e.printStackTrace();
    109. 		} //Action的实例
    110. 	}
    111. 	//由原来的actions.get(uri)变成了从模型对象里取 
    112. }

     ConfigModel：

    1. package com.oyang.framework;
    2.  
    3. import java.util.HashMap;
    4. import java.util.Map;
    5.  
    6. /**
    7.  * 根标签对应的对象
    8.  * @author yang 
    9.  *
    10.  * @date 2022年6月15日上午9:04:05
    11.  */
    12. public class ConfigModel {
    13. 	private Map<String, ActionModel> aMap=new HashMap<String, ActionModel>();
    14. 	
    15. 	public void push(ActionModel actionModel) {
    16. 		 aMap.put(actionModel.getPath(), actionModel);
    17. 	}
    18. 	
    19. 	public ActionModel pop(String path) {
    20. 		return aMap.get(path);
    21. 	}
    22. 	
    23. }

    ConfigModelFactory ：

    1. package com.oyang.framework;
    2.  
    3. import java.io.InputStream;
    4. import java.util.List;
    5.  
    6. import org.dom4j.Document;
    7. import org.dom4j.DocumentException;
    8. import org.dom4j.Element;
    9. import org.dom4j.io.SAXReader;
    10.  
    11. /**
    12.  * 23种设计模式之工厂模式
    13.  * sessionFactory
    14.  * ConfigModelFactory 就是用来生产configmodel对象的
    15.  * 生产出来的Configmodel对象就包含了config.xml中的配置内容
    16.  * @author yang 
    17.  *
    18.  *此地生产configmodel有配置信息？
    19.  *1.解析config.xml中的配置信息
    20.  *2.将对应的配置信息分别加载进不同的模型对象中
    21.  * @date 2022年6月15日上午9:55:56
    22.  */
    23. public class ConfigModelFactory {
    24. 	public static ConfigModel  bulid(String path) throws Exception {
    25. 		InputStream in = ConfigModelFactory.class.getResourceAsStream(path);
    26. 		SAXReader sr=new SAXReader();
    27. 		Document doc = sr.read(in);
    28. 		List<Element> actionEles = doc.selectNodes("/config/action");
    29. 		ConfigModel con=new ConfigModel();
    30. 		for (Element actionM : actionEles) {
    31. 			ActionModel actionModel = new ActionModel();
    32. 			actionModel.setPath(actionM.attributeValue("path"));
    33. 			actionModel.setType(actionM.attributeValue("type"));
    34. 			//将forwardmodel赋值并且添加到actionmodel中
    35. 			List<Element> forwardEles = actionM.selectNodes("forward");
    36. 			for (Element element : forwardEles) {
    37. 				ForwardModel forwardModel = new ForwardModel();
    38. 				forwardModel.setName(element.attributeValue("name"));
    39. 				forwardModel.setPath(element.attributeValue("path"));
    40. //				redirect:只能是false|true,允许空,默认值为false
    41. 				forwardModel.setRedirect("true".equals(element.attributeValue("redirect")));
    42. 				actionModel.push(forwardModel);
    43. 			}
    44. 			con.push(actionModel);
    45. 		}
    46. 		return con;
    47. 	}
    48. 	
    49. 	
    50. 	public static ConfigModel  bulid() throws Exception {
    51. 		String defaultPath="/config.xml";
    52. 		return bulid(defaultPath);
    53. 	}
    54. }

    ForwardModel ：

    1. package com.oyang.framework;
    2.  
    3. /**
    4.  * 对应forward标签
    5.  * @author yang 
    6.  *
    7.  * @date 2022年6月15日上午9:05:38
    8.  */
    9. public class ForwardModel {
    10. 	private String name;
    11. 	private String path;
    12. 	private boolean redirect;
    13. 	public String getName() {
    14. 		return name;
    15. 	}
    16. 	public void setName(String name) {
    17. 		this.name = name;
    18. 	}
    19. 	public String getPath() {
    20. 		return path;
    21. 	}
    22. 	public void setPath(String path) {
    23. 		this.path = path;
    24. 	}
    25. 	public boolean getRedirect() {
    26. 		return redirect;
    27. 	}
    28. 	public void setRedirect(boolean b) {
    29. 		this.redirect = b;
    30. 	}
    31. 	
    32. 	
    33. 	
    34. }

    效果：

    二、 参数传递封装优化

    同常的Servlet：

    1. private void add(HttpServletRequest request, HttpServletResponse response) {
    2. 	String bid = request.getParameter("bid");
    3. 	String bname = request.getParameter("bname");
    4. 	String price = request.getParameter("price");
    5. 	Book b=new Book(Integer.valueOf(bid), bname, Float.valueOf(price));
    6. 	//BookDao.add(b);
    7. 	System.out.println(book);
    8. 		//上述问题：如果一张表有20乃至50行数据，那岂不是要写那么多行去接收？如果有10张20条数据以上的表，那一个增加方法就得写很多行，甚至还有可能写错。大大的限制了我们的开发速度和效率
    9. 		//为了避免上述问题，如果上述代码可以不写就好了，那就不会这么麻烦了。能否让它们默认就接收那么多值呢？那我们就去生产这样的一个框架
    10. 		System.out.println("在同一个Servlet中调用add新增方法");
    11. 	}

    上述问题：如果一张表有20乃至50行数据，那岂不是要写那么多行去接收？如果有10张20条数据以上的表，那一个增加方法就得写很多行，甚至还有可能写错。大大的限制了我们的开发速度和效率

    解决方案：
    为了避免上述问题，如果上述代码可以不写就好了，那就不会这么麻烦了。能否让它们默认就接收那么多值呢？那我们就去生产这样的一个框架

    建立一个模型驱动接口，该接口目的是为了接受前台JSP传递的参数，并且封装到实体类中

    ModelDriven<T> ：

    1. package com.oyang.framework;
    2.  
    3. /**
    4.  * 模型驱动接口：接收前台JSP传递的参数，并且封装到实体类中
    5.  * @author yang 
    6.  *
    7.  * @date 2022年6月28日上午9:02:29
    8.  */
    9. public interface ModelDriven<T> {
    10. 	//拿到将要封装的类实例		ModelDriven.getModel()//当你要调用这个方法的时候等价于-->new Book();
    11. 	//此时new 的book是没有值的，我们去封装一下值
    12. 	T getModel();
    13. }

    此时new 的book是没有值的，我们去封装一下值

     BooKAction实现模型驱动接口：

    1. package com.oyang.servlet;
    2.  
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletResponse;
    5.  
    6. import com.oyang.entity.Book;
    7. import com.oyang.framework.Action;
    8. import com.oyang.framework.ActionSupport;
    9. import com.oyang.framework.ModelDriven;
    10.  
    11. public class BookAction extends ActionSupport implements ModelDriven<Book>{
    12. 	private  Book book=new Book();
    13.  
    14. 	private void list(HttpServletRequest request, HttpServletResponse response) {
    15. 		System.out.println("在同一个Servlet中调用list查询方法");
    16. 	}
    17. 	
    18. 	private void load(HttpServletRequest request, HttpServletResponse response) {
    19. 		System.out.println("在同一个Servlet中调用load回显方法");
    20. 	}
    21.  
    22. 	private void edit(HttpServletRequest request, HttpServletResponse response) {
    23. 		System.out.println("在同一个Servlet中调用edit修改方法");
    24. 	}
    25.  
    26. 	private void del(HttpServletRequest request, HttpServletResponse response) {
    27. 		System.out.println("在同一个Servlet中调用del删除方法");
    28. 	}
    29.  
    30. 	private void add(HttpServletRequest request, HttpServletResponse response) {
    31. 		System.out.println("在同一个Servlet中调用add新增方法");
    32. 	}
    33.  
    34. 	@Override
    35. 	public Book getModel() {
    36. 		return book;
    37. 	}
    38.  
    39. }

     将DispatcherServlet进行近一步的优化:

    1. package com.oyang.framework;
    2.  
    3. import java.io.IOException;
    4. import java.util.HashMap;
    5. import java.util.Map;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12.  
    13. import org.apache.commons.beanutils.BeanUtils;
    14. import org.apache.commons.beanutils.PropertyUtils;
    15.  
    16. import com.oyang.servlet.BookAction;
    17.  
    18.  
    19. /**
    20.  * 中央控制器：
    21.  * 	主要职能，接收浏览器请求，找到对应的处理人
    22.  * @author yang 
    23.  *
    24.  */
    25. //@WebServlet("*.action")
    26. public  class DispatcherServlet extends HttpServlet{
    27. 	//private Map<String, Action> actions=new HashMap<String,Action>();
    28. 	/**
    29. 	 * 通过建模我们可以知道，最终configModel对象会包含config.xml中的所有子控制器信息，
    30. 	 * 同时为了解决中央控制器能够动态加载保存子控制器的信息，那么我们只需要引入configModel对象即可
    31. 	 */
    32. 	
    33. 	private ConfigModel configModel;
    34. 	//程序启动时 ，只会加载一次
    35. 	@Override
    36. 	public void init() throws ServletException {
    37. 		//actions.put("/book",new BookAction());
    38. 		//actions.put("/order",new BookAction());
    39. 		try {
    40. 			//配置地址
    41. 			//getInitParameter的作用是拿到web.xml中的Servlet信息配置的参数
    42. 			String configLocation = this.getInitParameter("configLocation");
    43. 			if(configLocation==null || "".equals(configLocation))
    44. 				configModel=ConfigModelFactory.bulid();
    45. 			else
    46. 				configModel=ConfigModelFactory.bulid(configLocation);
    47. 		} catch (Exception e) {
    48. 			e.printStackTrace();
    49. 		}
    50. 	}
    51.  
    52. 	@Override
    53. 	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    54. 		doPost(req, resp);
    55. 	}
    56. 		
    57. 	//只要是以.action结尾的每次请求都会被doPost截取
    58. 	@Override
    59. 	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    60. 		http://localhost:8080/mvc/book.action?methodName=list
    61. 		String uri = req.getRequestURI();
    62. 		// 要拿到/book，就是最后一个/到最后一个.为止
    63. 		uri= uri.substring(uri.lastIndexOf("/"),uri.lastIndexOf("."));
    64. 		
    65.  
    66. 		/**
    67. 		 * 思路：
    68. 		 * 以前我们从map集合中获取，那样的话就行不通了。那么该怎么办呢？此时我们就需要修改xml配置文件了。
    69. 		 * 通过配置文件拿到全路径名，再通过反射实例化
    70. 		 */
    71. 		
    72. 		//Action action = actions.get(uri);
    73. 		//取到.action之后	Action action = actions.get(uri);里面定义了对应的方法
    74. 		//相比于上一种从map集合获取子控制器，当前需要获取config.xml中的全路径名，然后反射实例化
    75. 		ActionModel actionModel = configModel.pop(uri);
    76. 		if(actionModel==null) {
    77. 			throw new RuntimeException("action config eroer 配置错误");
    78. 		}
    79. 		String type = actionModel.getType();//拿到type值 
    80. 		//拿到type值之后就能通过路径名反射实例化 ------type是Action子控制器的全路径名
    81. 		try {
    82. 			Action action = (Action) Class.forName(type).newInstance();
    83. 			//此时的action 是bookAction
    84. 			if(action instanceof ModelDriven) {
    85. 				ModelDriven md=(ModelDriven) action;
    86. 				//action指的是bookAction，而bookAction又实现了ModelDriven接口，然后把bookAction转换成ModelDriven接口
    87. 				Object model = md.getModel();//model指的是bookAction中的book实例
    88. 				//给model中的属性赋值，要接收前端jsp传递过来的参数
    89. 				//PropertyUtils.getProperty(bean, name);//从某一个对象里面取某一个值
    90. 				//将前端所有参数值封装进实体类
    91. 				BeanUtils.populate(model, req.getParameterMap());
    92. //				System.out.println(model);
    93. 			} 
    94. 			//正式调用方法之前，book中的属性要被赋值
    95. //			action.execute(req, resp);
    96. 			String retult = action.execute(req, resp);
    97. 			ForwardModel forwardModel = actionModel.pop(retult);
    98. 			if(forwardModel==null) {
    99. 				throw new RuntimeException("forward config error 配置错误");
    100. 			}
    101. //			/bookList.jsp/index.jsp
    102. 			String path = forwardModel.getPath();
    103. 			//拿到是否需要转发的配置
    104. 			boolean redirect = forwardModel.getRedirect();
    105. 			if(redirect) 
    106. 				resp.sendRedirect(req.getServletContext().getContextPath()+path);
    107. 			else
    108. 			req.getRequestDispatcher(path).forward(req, resp);
    109. 		} catch (Exception e) {
    110. 			// TODO Auto-generated catch block
    111. 			e.printStackTrace();
    112. 		} //Action的实例
    113. 	}
    114. 	//由原来的actions.get(uri)变成了从模型对象里取 
    115. }

     效果：

    我们可以看到原本Book没有值的当再一次点击的时候Book中又有值。 他大大减少了代码量，不管之后有多少属性，都可以接受属性值和封装

    三、 对于方法执行结果转发重定向优化

    对方法的执行结果进行优化，如果增加成功就用转发，失败就用重定向。 

    编辑.xml配置文件：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <config>
    3. 	<action path="/book" type="com.oyang.servlet.BookAction">
    4. 		<forward name="failed" path="/demo2.jsp" redirect="false" />
    5. 		<forward name="success" path="/demo3.jsp" redirect="true" />
    6. 	</action>
    7.  
    8. 	<action path="/order" type="com.oyang.servlet.OrderAction">
    9. 		<forward name="failed" path="/demo2.jsp" redirect="false" />
    10. 		<forward name="success" path="/demo3.jsp" redirect="true" />
    11. 	</action>
    12. </config>

    对子控制器进行优化 Action ：

    1. package com.oyang.framework;
    2.  
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletResponse;
    5.  
    6. /**
    7.  * 子控制器
    8.  * 	对应请求的处理人
    9.  * @author yang 
    10.  *
    11.  */
    12. public interface Action {
    13. 	 String execute(HttpServletRequest request, HttpServletResponse response);
    14. 	 
    15. }

     ActionSupport类：

    1. package com.oyang.framework;
    2.  
    3. import java.lang.reflect.Method;
    4.  
    5. import javax.servlet.http.HttpServletRequest;
    6. import javax.servlet.http.HttpServletResponse;
    7.  
    8. public class ActionSupport implements Action {
    9.  
    10. 	@Override
    11. 	public String execute(HttpServletRequest request, HttpServletResponse response) {
    12. 		String methodName = request.getParameter("methodName");
    13. 		// methodName可能是add/del/edit/list/load/...
    14. 		// 前台传递什么方法，就调用当前类的对应方法
    15. 		try {
    16. 			Method m = this.getClass()// 当前类.class
    17. 					.getDeclaredMethod(methodName, HttpServletRequest.class, HttpServletResponse.class);
    18. 			// 打开权限
    19. 			m.setAccessible(true);
    20. 			// 调用当前类实例的methodName 方法
    21. 		return	(String) m.invoke(this, request, response);
    22. 		} catch (Exception e) {
    23. 			// TODO Auto-generated catch block
    24. 			e.printStackTrace();
    25. 		}
    26. 		return null;
    27. 	}
    28. }

    DispatcherServlet：

    上述代码有，在此标记出来 

    BookAction：(更改返回值)

    1. package com.oyang.servlet;
    2.  
    3. import javax.servlet.http.HttpServletRequest;
    4. import javax.servlet.http.HttpServletResponse;
    5.  
    6. import com.oyang.entity.Book;
    7. import com.oyang.framework.Action;
    8. import com.oyang.framework.ActionSupport;
    9. import com.oyang.framework.ModelDriven;
    10.  
    11. public class BookAction extends ActionSupport implements ModelDriven<Book>{
    12. 	private  Book book=new Book();
    13.  
    14. 	private String list(HttpServletRequest request, HttpServletResponse response) {
    15. 		System.out.println("在同一个Servlet中调用list查询方法");
    16. 		return "success";
    17. 	}
    18. 	
    19. 	private void load(HttpServletRequest request, HttpServletResponse response) {
    20. 		System.out.println("在同一个Servlet中调用load回显方法");
    21. 	}
    22.  
    23. 	private void edit(HttpServletRequest request, HttpServletResponse response) {
    24. 		System.out.println("在同一个Servlet中调用edit修改方法");
    25. 	}
    26.  
    27. 	private void del(HttpServletRequest request, HttpServletResponse response) {
    28. 		System.out.println("在同一个Servlet中调用del删除方法");
    29. 	}
    30.  
    31. 	private String add(HttpServletRequest request, HttpServletResponse response) {
    32. //		String bid = request.getParameter("bid");
    33. //		String bname = request.getParameter("bname");
    34. //		String price = request.getParameter("price");
    35. //		Book b=new Book(Integer.valueOf(bid), bname, Float.valueOf(price));
    36. 		//BookDao.add(b);
    37. //		System.out.println(book);
    38. 		//上述问题：如果一张表有20乃至50行数据，那岂不是要写那么多行去接收？如果有10张20条数据以上的表，那一个增加方法就得写很多行，甚至还有可能写错。大大的限制了我们的开发速度和效率
    39. 		//为了避免上述问题，如果上述代码可以不写就好了，那就不会这么麻烦了。能否让它们默认就接收那么多值呢？那我们就去生产这样的一个框架
    40. 		System.out.println("在同一个Servlet中调用add新增方法");
    41. 		return "failed";
    42. 	}
    43.  
    44. 	@Override
    45. 	public Book getModel() {
    46. 		return book;
    47. 	}
    48. }

    新建两个jsp界面，用于演示跳转转发&重定向

     

    我们点击新增后的运行结果：

     

    四、框架配置文本优化

    以后我们使用的框架有很多，很有可能会重名，但是换了名字程序就跑不了了

    对此问题我们只需要更改web.xml文件的配置就行了

     

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
    3.   <display-name>Oyang_mvc</display-name>
    4.   <servlet>
    5.   	<servlet-name>mvc</servlet-name>
    6.   	<servlet-class>com.oyang.framework.DispatcherServlet</servlet-class>
    7. 	<init-param><!-- 可以把值传到 configLocation中-->
    8. 		<param-name>configLocation</param-name>
    9. 		<param-value>/oyang.xml</param-value>
    10. 	</init-param>
    11.   </servlet>
    12.   
    13.   <servlet-mapping>
    14.   	<servlet-name>mvc</servlet-name>
    15.   	<url-pattern>*.action</url-pattern>
    16.   </servlet-mapping>
    17. </web-app>

     试试运行结果：

    点击增加

     跳转到转发界面

     

     看一下控制台打印的值

     敬请期待下篇J2EE基础-自定义MVC(下)，下篇将会优化的更多

     OK，今日的学习就到此结束啦，如果对个位看官有帮助的话可以留下免费的赞哦(收藏或关注也行),如果文章中有什么问题或不足以及需要改正的地方可以私信博主，博主会做出改正的。个位看官，小陽在此跟大家说拜拜啦

  • 相关阅读:
    flutte: 可滚动列表
    [k8s] 常见yml配置和详细解释
    Android 3D Launcher锁定IMU界面
    Centos8安装CDH解决不兼容问题
    ApiSix网关环境搭建及简单使用（Windows）
    诊断DLL——Visual Studio安装与dll使用
    Leetcode 第 372 场周赛题解
    基于TCP的聊天系统
    渗透测试学习day3
    Java8新特性
  • 原文地址：https://blog.csdn.net/weixin_65211978/article/details/125499671