Struts—自定义一个简单的mystruct

传统mvc开发总结：

1. 跳转代码写死，不灵活

2. 每次都去写servlet，web.xml中配置servlet！

(配置目的：请求, Servlet处理类)

一个简单的struct案例，描述如下

登陆、注册

登陆成功首页

　　　登入失败登入页

注册成功登陆页

整理如下

项目列表如下

代码实现

前台页面登入页：

<form action="${pageContext.request.contextPath }/login.action" name="frmLogin"  method="post">

   	   用户名： <input type="text" name="name"> <br/>

   	 　　密码： <input type="text" name="pwd"> <br/>

   	   <input type="submit" value="登陆"> <br/>

   	</form>

注册页：

<form action="${pageContext.request.contextPath }/register.action" name="frmRegister"  method="post">

   	   用户名： <input type="text" name="name"> <br/>

   	  　　密码： <input type="text" name="pwd"> <br/>

   	   <input type="submit" value="注册"> <br/>

</form>

首页

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

  <head>

    <title>index</title>

  </head>

  <body>

    欢迎你的到来,${sessionScope.userInfo.name }

  </body>

</html>

后台处理代码

1、假设有一个用户类

package com.gqx.entity;

public class User {

	private String name;

	private String pwd;

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getPwd() {

		return pwd;

	}

	public void setPwd(String pwd) {

		this.pwd = pwd;

	}

}

2、还有一个UserDao类，处理用户的登入问题与注册问题，然后则是还有一个业务逻辑层service

package com.gqx.dao;

import com.gqx.entity.User;

public class UserDao {

	// 模拟登陆

	public User login(User user){

		if ("gqxing".equals(user.getName()) && "888".equals(user.getPwd()) ){

			// 登陆成功

			return user;

		}

		// 登陆失败

		return null;

	}

	// 模拟注册

	public void register(User user) {

		System.out.println("注册成功：用户，" + user.getName());

	}

}

service

package com.gqx.service;

import com.gqx.dao.UserDao;

import com.gqx.entity.User;

public class UserService {

	private UserDao dao=new UserDao();

	// 模拟登陆

	public User login(User user){

			return dao.login(user);

	}

	// 模拟注册

	public void register(User user) {

		dao.register(user);

	}

}

3、mystruct.xml文件，对整个页面跳转的逻辑的配置，每一action对应的result表示要跳转的页面的信息和处理他的相关类

<?xml version="1.0" encoding="UTF-8"?>

<mystruct>

	<package>

		<!-- 配置请求路径，与处理action类的关系 -->

		<!--

			1. 请求路径与处理Action的关系

			     /login = LoginAction                          login

			      success = /index.jsp                     登陆成功(重定向)

			      loginFaild  = /login.jsp                 登陆失败

		 -->

		<action name="login" class="com.gqx.framework.action.LoginAction" method="login" >

			<result name="loginSuccess" type="redirect">/index.jsp</result>

			<result name="loginFailed">/login.jsp</result>	<!-- 默认是转发 -->

		</action>

		<action name="register" class="com.gqx.framework.action.RegisterAction" method="register">

			<result name="registerSuccess">/login.jsp</result>

		</action>

	</package>

</mystruct>

4、写两个类分别用来处理登入和注册响应这两个事件（注册事件和登入事件）。注意这不和servlet相同，这里返回的是一种状态（对应着前面的struct配置的xml文件中要跳转的页面）。

LoginAction类

package com.gqx.framework.action;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import com.gqx.entity.User;

import com.gqx.service.UserService;

/**

 * Action表示动作类

 * 1. 一个servlet对应一个action

 * 2. action中负责处理具体的请求

 */

public class LoginAction {

	/**

	 * 处理登陆请求

	 */

	public Object login(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		Object uri = null;

		// 1. 获取请求数据，封装

		String name = request.getParameter("name");

		String pwd = request.getParameter("pwd");

		User user = new User();

		user.setName(name);

		user.setPwd(pwd);

		// 2. 调用Service

		UserService userService = new UserService();

		User userInfo = userService.login(user);

		// 3. 跳转

		if (userInfo == null) {

			// 登陆失败

			uri="loginFailed";	//login.jsp

		} else {

			// 登陆成功

			request.getSession().setAttribute("userInfo", userInfo);

			// 首页

			uri ="loginSuccess";		//index.jsp

		}

		return uri;

	}

}

RegisterAction类

package com.gqx.framework.action;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import com.gqx.entity.User;

import com.gqx.service.UserService;

public class RegisterAction {

	/*

	 * 处理注册事件

	 */

	public Object register(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		// 1. 获取请求数据，封装

		String name = request.getParameter("name");

		String pwd = request.getParameter("pwd");

		User user = new User();

		user.setName(name);

		user.setPwd(pwd);

		// 2. 调用Service

		UserService userService = new UserService();

		userService.register(user);

		return "registerSuccess"; //login.jsp

	}

}

5、为了能更好的解析mystruct.xml文件，这里写了几个javabean去封装这个xml文件的信息

首先是对result（<result name="loginSuccess" type="redirect">/index.jsp</result>）的信息封装类

package com.gqx.framework.bean;

/**

 * 封装结果视图

 * <result name="loginSuccess" type="redirect">/index.jsp</result>

 * @author Administrator

 *

 */

public class Result {

	private String name; //封装结果的标记

	private String type;	//封装跳转类型，默认为“redirect”—重定向

	private String page;	//封装跳转的页面

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public String getType() {

		return type;

	}

	public void setType(String type) {

		this.type = type;

	}

	public String getPage() {

		return page;

	}

	public void setPage(String page) {

		this.page = page;

	}

}

然后是action节点的封装

package com.gqx.framework.bean;

import java.util.Map;

/**

 * 封装action节点

 * <action name="login" class="com.gqx.framework.action.LoginAction" method="login" >

			<result name="loginSuccess" type="redirect">/index.jsp</result>

			<result name="loginFailed">/login.jsp</result>	<!-- 默认是转发 -->

 *		</action>

 */

public class ActionMapping {

		private String name;	//封装路径名称

		private String className;	//封装action的类全名

		private String method;	//封装处理方法

		private Map<String, Result> result;	//封装视图集合

		public String getName() {

			return name;

		}

		public void setName(String name) {

			this.name = name;

		}

		public String getClassName() {

			return className;

		}

		public void setClassName(String className) {

			this.className = className;

		}

		public String getMethod() {

			return method;

		}

		public void setMethod(String method) {

			this.method = method;

		}

		public Map<String, Result> getResult() {

			return result;

		}

		public void setResult(Map<String, Result> result) {

			this.result = result;

		}

}

最后一个则是对整个action的管理，即管理着mystruct的类，在这里去解析xml文件（这里用到了dom4j的jar包）同时将解析的信息封装到action中去，在这里的构造方法中传入了init()函数（该函数用于封装action信息），然后通过本类去操控需求

package com.gqx.framework.bean;

import java.io.InputStream;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import javax.management.RuntimeErrorException;

import org.dom4j.Document;

import org.dom4j.DocumentException;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

/**

 * 加载配置文件，封装整个mystruct.xml

 * @author Administrator

 *

 */

public class ActionMappingManager {

	//保存action的集合（根据action的name去拿result）

	Map<String	, ActionMapping> allAction;

	//由于init方法无法被外界被调用（private修饰），这里要写一个无参的构造方法去调用

	public ActionMappingManager() {

		// TODO Auto-generated constructor stub

		allAction=new HashMap<String, ActionMapping>();

		//初始化

		this.init();

	}

	/**

	 * 根据请求路径名称，返回action映射对象

	 * 即有action的name返回一个由actionMapping包装的如下结构

	 * <action name="login" class="com.gqx.framework.action.LoginAction" method="login" >

			<result name="loginSuccess" type="redirect">/index.jsp</result>

			<result name="loginFailed">/login.jsp</result>	<!-- 默认是转发 -->

		</action>

	 */

	/**

	 *

	 * @param actionName	当前返回路径

	 * @return	返回配置文件中代表action节点的actionMapping对象

	 */

	public ActionMapping getActionMapping(String actionName) {

		// TODO Auto-generated method stub

		if (actionName == null) {

			throw new RuntimeException("传入参数不能为空！");

		}

		ActionMapping actionMapping=allAction.get(actionName);

		if (actionMapping==null) {

			throw new RuntimeException("路径在mystruct中找不到！请检查。");

		}

		return actionMapping;

	}

	//初始化allAction集合

	private void init() {

		// TODO Auto-generated method stub

		/****************dom4j读取配置文件**********/

		try {

			//1、得到解析器

			SAXReader reader=new SAXReader();

			//得到src/下的文件流

			InputStream insStream=this.getClass().getResourceAsStream("/mystruct.xml");

			//2、加载文件

			Document doc=reader.read(insStream);

			//3、得到根文件

			Element rootElement=doc.getRootElement();

			//4、得到package节点

			Element elem_package=rootElement.element("package");

			//5/5得到package节点下的所有action节点

			List<Element> listAction=elem_package.elements("action");

			//6、遍历action且封装

			for (Element element : listAction) {

				//6、1封装一个ActionMapping对象

				ActionMapping actionMapping=new ActionMapping();

				/**

				 * <action name="login" class="com.gqx.framework.action.LoginAction" method="login" >

						<result name="loginSuccess" type="redirect">/index.jsp</result>

						<result name="loginFailed">/login.jsp</result>	<!-- 默认是转发 -->

					</action>

				 */

				//封装action

				actionMapping.setName(element.attributeValue("name"));

				actionMapping.setClassName(element.attributeValue("class"));

				actionMapping.setMethod(element.attributeValue("method"));

				//封装action下的result

				Map<String, Result> results=new HashMap<String, Result>();

				//得到当前action下所有的result子节点

				Iterator<Element> iterator=element.elementIterator("result");

				while (iterator.hasNext()) {

					//当前迭代的每一result

					Element element2 = (Element) iterator.next();

					Result result =new Result();

					//封装

					result.setName(element2.attributeValue("name"));

					result.setType(element2.attributeValue("type"));

					result.setPage(element2.getTextTrim());

					//添加到results中

					results.put(result.getName(), result);

				}

				actionMapping.setResult(results);

				//6、2actionMapping添加到Map集合中

				allAction.put(actionMapping.getName(), actionMapping);

			}

		} catch (Exception e) {

			// TODO Auto-generated catch block

			throw new RuntimeException("xml读取失败，初始化错误！");

		}

	}

}

6、最后则是写全局的控制器ActionServlet，由它来管理ActionMappingManager中要跳转的页面信息，如外界通过访问http://localhost:8080/mystruct/login.jsp发来http://localhost:8080/mystruct/login.action请求，首先将其解析成login，根据这个login名字在mystruct中找到对应的class类（class="com.gqx.framework.action.LoginAction"）和方法（method="login"），同时根据方法名称和参数得到类中的方法，通过反射得到调动其方法，便可得到一个返回的uri（表是状态，如：loginSuccess），然后由配置文件（管理类ActionMappingManager）依据uri来控制要跳转的相应页面。

package com.gqx.framework;

import java.io.IOException;

import java.lang.reflect.Method;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import com.gqx.framework.bean.ActionMapping;

import com.gqx.framework.bean.ActionMappingManager;

import com.gqx.framework.bean.Result;

public class ActionServlet extends HttpServlet {

	/**

	 * 核心控制器，此项目只有一个servlet

	 * 拦截所有的以action结尾的请求

	 */

	private static final long serialVersionUID = 1L;

	ActionMappingManager actionMappingManager;

	@Override

	public void init() throws ServletException {

		// TODO Auto-generated method stub

		//第一次访问时启动时候执行，希望启动的时候执行，在xml文件中配置load-on-startup在启动的是执行

		//配置文件的读取，在ActionMappingManage的构造方法中调用了init方法。

		actionMappingManager=new ActionMappingManager();

	}

	public void doGet(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		try {

			//1、获取请求的uri，得到请求的路径名称【login】

			String uri=request.getRequestURI();

			//得到login，根据login去mystruct.xml配置文件去第2步

			String actionName=uri.substring(uri.lastIndexOf("/")+1,uri.indexOf(".action"));

			//	2、根据路径名称，读取配置文件，得到类的全名

			ActionMapping actionMapping=actionMappingManager.getActionMapping(actionName);

			String className=actionMapping.getClassName();

			//当前请求的处理方法【method="login】

			String method=actionMapping.getMethod();

			//3、通过反射创建对象，调用方法，获取方法返回的标记

			Class<?> clazz=Class.forName(className);

				//实例化,创建对象

			Object object=clazz.newInstance();

			/**

			 *   这里的参数只能是HttpServletRequest.class，不能是request.class。

			 *   因为request是一个实现类，而这里必须是以接口.class为参数

			 */

			Method m=clazz.getDeclaredMethod(method, HttpServletRequest.class,HttpServletResponse.class);

			//调用方法返回的标记

			String returnValue=(String) m.invoke(object,request,response);

			//4、拿到标记，读取配置文件，对应的标记页面

			Result result=actionMapping.getResult().get(returnValue);

			//跳转类型

			String type=result.getType();

			//页面

			String page=result.getPage();

			//5、跳转

			if ("redirect".equals(type)) {

				response.sendRedirect(request.getContextPath()+page);

			}else {

				request.getRequestDispatcher(page).forward(request, response);

			}

		} catch (Exception e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public void doPost(HttpServletRequest request, HttpServletResponse response)

			throws ServletException, IOException {

		this.doGet(request, response);

	}

}

最后则是配置这个Actionservlet在服务器的web.xml文件了

<!-- 核心控制器 -->

  <servlet>

    <description>This is the description of my J2EE component</description>

    <display-name>This is the display name of my J2EE component</display-name>

    <servlet-name>ActionServlet</servlet-name>

    <servlet-class>com.gqx.framework.ActionServlet</servlet-class>

    <!-- 启动的时候执行servlet的初始化方法 -->

    <load-on-startup>1</load-on-startup>

  </servlet>

  <servlet-mapping>

    <servlet-name>ActionServlet</servlet-name>

    <!-- 拦截所有的action -->

    <url-pattern>*.action</url-pattern>

  </servlet-mapping>

最后我们登入的时候就会看到这个效果了：

Struts—自定义一个简单的mystruct

Struts—自定义一个简单的mystruct的相关教程结束。

相关推荐

利用pytorch自定义CNN网络（四）：损失函数和优化器

POJ 2243 简单搜索 (DFS BFS A*)

SpringBoot自定义注解+AOP+redis实现防接口幂等性重复提交，从概念到实战

包含引用类型字段的自定义结构体，能作为map的key吗

dedecms：织梦文章如何添加“自定义属性”标签（sql命令行工具）

VS中创建自定义一个VC工程为基础的开发向导的总结

Django自定义storage上传文件到Minio

pages.json 文件：自定义导航栏