工具类积累（二）—— 一个Servlet处理多个URL请求

　　今天帮同学看传智写聊天室源码时，在了解了该聊天室大致的结构之后，总结出了一个很不错的工具类！更准确的说是一段写得很优秀的源码！也解答了我长时间以来的疑惑！源代码如下：

package cn.itcast.utils;
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;

public class BaseServlet extends HttpServlet {
    /*
     * 它会根据请求中的method参数，来决定调用本类的哪个方法
     */
    protected void service(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        res.setContentType("text/html;charset=utf-8");
        // 例如：http://localhost:8080/demo1/xxx?method=login
        String methodName = req.getParameter("method");// 它是一个方法名称
        // 当没用指定要调用的方法时，那么默认请求的是execute()方法。
        if(methodName == null || methodName.isEmpty()) {
            methodName = "execute";
        }
        Class c = this.getClass();
        try {
            // 通过方法名称获取方法的反射对象
            Method m = c.getMethod(methodName, HttpServletRequest.class,
                    HttpServletResponse.class);
            // 反射方法目标方法，也就是说，如果methodName为add，那么就调用add方法。
            String result = (String) m.invoke(this, req, res);
            // 通过返回值完成请求转发
            if(result != null && !result.isEmpty()) {
                req.getRequestDispatcher(result).forward(req, res);
            }
        } catch (Exception e) {
            throw new ServletException(e);
        }
    }
}

package cn.itcast.action;
import java.io.IOException;
import java.util.Date;
import java.util.Map;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.commons.beanutils.BeanUtils;
import cn.itcast.service.UserService;
import cn.itcast.utils.BaseServlet;
import cn.itcast.vo.User;
public class UserServlet extends BaseServlet {
    /**
     * 检查session是否过期
     * @throws IOException 
     */
    public String check(HttpServletRequest req,HttpServletResponse resp) throws IOException{
        // 从session中获得用户的信息
        User existUser = (User) req.getSession().getAttribute("existUser");
        // 判断session中的用户是否过期
        if(existUser == null){
            // 登录的信息已经过期了!
            resp.getWriter().println("1");
        }else{
            // 登录的信息没有过期
            resp.getWriter().println("2");
        }
        return null;
    }
    
    /**
     *  退出聊天室
     * @throws IOException 
     */
    public String exit(HttpServletRequest request,HttpServletResponse response) throws IOException{
        // 获得session对象
        HttpSession session = request.getSession();
        // 将session销毁.
        session.invalidate();
        // 页面转向.
        response.sendRedirect(request.getContextPath()+"/index.jsp");
        return null;
    }
    
    /**
     * 发送聊天内容
     * @throws IOException 
     */
    public String sendMessage(HttpServletRequest req,HttpServletResponse resp) throws IOException{
        // 1.接收数据 。
        System.out.println("sendMessage invoke....");
        String from = req.getParameter("from"); // 发言人
        String face = req.getParameter("face"); // 表情
        String to = req.getParameter("to"); // 接收者
        String color = req.getParameter("color"); // 字体颜色
        String content = req.getParameter("content"); // 发言内容
        // 发言时间 正常情况下使用SimpleDateFormat
        String sendTime = new Date().toLocaleString(); // 发言时间
        // 获得ServletContext对象.
        ServletContext application = getServletContext();
        //  从ServletContext中获取消息
        String sourceMessage = (String) application.getAttribute("message");
        // 拼接发言的内容:xx 对 yy 说 xxx
        sourceMessage += "<font color='blue'><strong>" + from
                + "</strong></font><font color='#CC0000'>" + face
                + "</font>对<font color='green'>[" + to + "]</font>说："
                + "<font color='" + color + "'>" + content + "</font>（"
                + sendTime + "）<br>";
        // 将消息存入到application的范围
        application.setAttribute("message", sourceMessage);
        return getMessage(req, resp);
    }
    
    /**
     * 获取消息的方法
     * @throws IOException 
     */
    public String getMessage(HttpServletRequest req,HttpServletResponse resp) throws IOException{
        String message = (String) getServletContext().getAttribute("message");
        if(message != null){
            resp.getWriter().println(message);
        }
        return null;
    }
    /**
     * 踢人的功能
     * @throws IOException 
     */
    public String kick(HttpServletRequest req,HttpServletResponse resp) throws IOException{
        // 1.接收参数
        int id = Integer.parseInt(req.getParameter("id"));
        // 2.踢人:从userMap中将用户对应的session销毁.
        // 获得userMap集合(在线列表)
        Map<User, HttpSession> userMap = (Map<User, HttpSession>) getServletContext()
                .getAttribute("userMap");
        // 获得这个用户对应的session.如何知道是哪个用户呢? id已经传递过来.去数据库中查询.
        // 重写user的equals 和 hashCode 方法 那么只要用户的id相同就认为是同一个用户.
        User user = new User();
        user.setId(id);
        // 从map集合中获得用户的对应的session 
        HttpSession session = userMap.get(user);
        // 销毁session
        session.invalidate();
        // 重定向到页面
        resp.sendRedirect(req.getContextPath()+"/main.jsp");
        return null;
    }
    
    /**
     * 登录的功能
     */
    public String login(HttpServletRequest req,HttpServletResponse resp){
        // 接收数据
        Map<String, String[]> map = req.getParameterMap();
        User user = new User();
        // 封装数据
        try {
            BeanUtils.populate(user, map);
            // 调用Service层处理数据 
            UserService us = new UserService();
            User existUser = us.login(user);
            if (existUser == null) {
                // 用户登录失败
                req.setAttribute("msg", "用户名或密码错误!");
                return "/index.jsp";
            } else {
                // 用户登录成功
                // 第一个BUG的解决:第二个用户登录后将之前的session销毁!
                req.getSession().invalidate();
                
                // 第二个BUG的解决:判断用户是否已经在Map集合中,存在：已经在列表中.销毁其session.
                // 获得到ServletCOntext中存的Map集合.
                Map<User, HttpSession> userMap = (Map<User, HttpSession>) getServletContext()
                        .getAttribute("userMap");
                // 判断用户是否已经在map集合中'
                if(userMap.containsKey(existUser)){
                    // 说用map中有这个用户.
                    HttpSession session = userMap.get(existUser);
                    // 将这个session销毁.
                    session.invalidate();
                }
                // 使用监听器:HttpSessionBandingListener作用在JavaBean上的监听器.
                req.getSession().setAttribute("existUser", existUser);
                ServletContext application = getServletContext();
                String sourceMessage = "";
                if (null != application.getAttribute("message")) {
                    sourceMessage = application.getAttribute("message")
                            .toString();
                }
                sourceMessage += "系统公告：<font color='gray'>"
                        + existUser.getUsername() + "走进了聊天室！</font><br>";
                application.setAttribute("message", sourceMessage);

                resp.sendRedirect(req.getContextPath() + "/main.jsp");
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
        return null;
    }
}

　　这两个类结构写的蛮清楚的！一旦有请求过来，比如说：http:8080//localhost/项目名/User/method=login!当到达UserServlet时就会执行service方法。接下来所做的工作就是得到该类的类加载器，并根据方法名（为null时默认调用execute方法）调用对应的方法！这样就实现了UserServlet类处理多个Action请求的目的！说到这里，衷心觉得这段代码写得蛮好的！

　　想到这里，我突然想到了Struts2！它的模式似乎也是这样！在一个类中处理多个请求！看了上面一段代码！突然就形成了一个想法，或者说猜测吧！（没看源码，也没得到验证）现在我就基于上面的代码思路来简单的分析一些Struts的实现机制！

　　首先，当前台一个请求到达的时候，就会经过Struts的核心过滤器--->

　　过滤器就可以得到request和response对象-->

　　根据request得到请求URL（假设是http:8080//localhost/项目名/namespace/methodName）-->

　　解析该URL字符串，并且得到namespace和methodName-->

　　根据配置文件struts.xml解析得到对应的类和方法名-->

　　通过反射来调用对应的方法-->

　　最后，根据返回的结果，将jsp显示！

　　当然，上面的分析的确是太简陋，太简单了，实际项目中肯定是复杂得多了（过滤器、拦截器、监听器等等）！上面的分析肯定是基于最简单的情景而分析的。相信在思路上还是讲得通的。因为Struts框架的底层肯定还是Servlet！

　　好了，今天的博客就写到这里了！不得不感叹，优秀的代码还是要读一些的！因为思路总是相通的！优秀的代码之所有优秀，那是因为优秀的代码集众家之所长！是人类智慧的结晶！

　　思路分享给大家，希望有所启迪！