注释

src/main/java/com/wsk/controller/ErrorController.java

@@ -0,0 +1,25 @@
+package com.wsk.controller;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+/**
+ * ErrorController类，用于处理特定的错误相关请求并返回对应的视图。
+ * 该类属于Spring MVC框架中的控制器组件，用于Web请求的处理逻辑。
+ * 由wsk1103在2017/5/23创建。
+ */
+@Controller
+// @Controller注解标记此类为Spring MVC的控制器类，会被Spring框架扫描并管理，用于处理Web请求
+public class ErrorController {
+
+    /**
+     * 处理"/error"请求路径的方法。
+     * 当客户端发起对"/error"的请求时，此方法会被调用。
+     * @return 返回名为"error"的视图名称，Spring会根据视图解析配置去查找对应的视图资源（如HTML页面等）来展示给客户端
+     */
+    @RequestMapping(value = "/error")
+    // @RequestMapping注解将error方法与"/error"这个请求路径进行映射关联，意味着该方法会处理对应的请求
+    public String error() {
+        return "error";
+    }
+}

src/main/java/com/wsk/controller/ForgetController.java

@@ -18,51 +18,86 @@ import java.util.Map;
 
 /**
  * Created by wsk1103 on 2017/5/9.
+ * ForgetController类，主要用于处理用户忘记密码相关的业务逻辑，
+ * 例如验证验证码、更新密码等操作，是Spring MVC框架中的一个控制器类。
  */
 @RestController
+// @RestController注解，结合了@Controller和@ResponseBody的功能，
+// 意味着该类中的方法返回值会直接作为响应体返回给客户端（通常用于返回JSON等数据格式），而不是跳转视图。
 public class ForgetController {
 
     @Resource
+    // @Resource注解用于依赖注入，这里会将Spring容器中管理的UserPasswordService类型的Bean注入到当前类中，
+    // 以便后续调用该服务层提供的与用户密码相关的业务方法。
     private UserPasswordService userPasswordService;
     @Resource
+    // 同理，注入UserInformationService类型的Bean，用于调用和用户信息相关的业务方法。
     private UserInformationService userInformationService;
 
+    /**
+     * 处理验证手机号验证码相关的请求方法。
+     * 支持POST和GET请求方式，用于验证传入的验证码和token是否有效，并根据验证结果返回相应信息。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息，如请求参数、会话等。
+     * @param model    Spring MVC中的Model对象，可用于向视图传递数据（此处该类是@RestController，一般不用于视图传递，但保留参数形式）。
+     * @param code     从请求中获取的验证码参数。
+     * @param token    从请求中获取的token参数，用于验证请求的合法性等。
+     * @return 返回一个Map，其中包含验证结果（"result"键对应的整数值，1表示验证通过，0表示验证失败）。
+     */
     @RequestMapping(value = "checkCode.do", method = {RequestMethod.POST, RequestMethod.GET})
     public Map checkPhone(HttpServletRequest request, Model model,
                           @RequestParam String code, @RequestParam String token) {
         Map<String, Integer> map = new HashMap<>();
+        // 从请求中获取名为"name"的参数值
         String name = request.getParameter("name");
+        // 判断name是否不为空（利用StringUtils工具类的方法来判断），如果不为空，则将其存入会话中。
         if (!StringUtils.getInstance().isNullOrEmpty(name)) {
             request.getSession().setAttribute("name", name);
         }
+        // 从会话中获取名为"token"的属性值，用于后续验证。
         String checkCodeToken = (String) request.getSession().getAttribute("token");
-        if (StringUtils.getInstance().isNullOrEmpty(checkCodeToken) || !checkCodeToken.equals(token)) {
+        // 如果获取到的会话中的token为空或者与传入的token不一致，则验证失败，将结果设置为0并返回。
+        if (StringUtils.getInstance().isNullOrEmpty(checkCodeToken) ||!checkCodeToken.equals(token)) {
             map.put("result", 0);
             return map;
         }
-        //验证码错误
+        // 调用checkCodePhone方法验证验证码是否正确，如果不正确，验证失败，将结果设置为0并返回。
         if (!checkCodePhone(code, request)) {
             map.put("result", 0);
             return map;
         }
+        // 验证通过，将结果设置为1并返回。
         map.put("result", 1);
         return map;
     }
 
-    //更新密码
+    /**
+     * 用于更新用户密码的方法。
+     * 根据传入的新密码和token等信息，进行密码更新操作，并返回相应的操作结果响应（通过BaseResponse封装）。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息以及操作会话等。
+     * @param model    Spring MVC中的Model对象（此处一般不用于视图传递，但保留参数形式）。
+     * @param password 从请求中获取的新密码参数。
+     * @param token    从请求中获取的token参数，用于防止重复提交等验证。
+     * @return 返回BaseResponse对象，表示密码更新操作的结果，成功返回success，失败返回fail。
+     */
     @RequestMapping("updatePassword.do")
     public BaseResponse updatePassword(HttpServletRequest request, Model model,
                                        @RequestParam String password, @RequestParam String token) {
-        //防止重复提交
+        // 从会话中获取名为"token"的属性值，用于验证是否重复提交（和传入的token对比）。
         String updatePasswordToken = (String) request.getSession().getAttribute("token");
-        if (StringUtils.getInstance().isNullOrEmpty(updatePasswordToken) || !updatePasswordToken.equals(token)) {
+        // 如果获取到的会话中的token为空或者与传入的token不一致，则认为是重复提交或非法请求，直接返回失败响应。
+        if (StringUtils.getInstance().isNullOrEmpty(updatePasswordToken) ||!updatePasswordToken.equals(token)) {
             return BaseResponse.fail();
         }
+        // 从会话中获取存储的真实手机号（假设之前已存入会话中）。
         String realPhone = (String) request.getSession().getAttribute("phone");
         UserPassword userPassword = new UserPassword();
+        // 使用StringUtils工具类的方法对传入的密码进行MD5加密处理，得到加密后的新密码。
         String newPassword = StringUtils.getInstance().getMD5(password);
         int uid;
         try {
+            // 通过用户信息服务，根据手机号查询对应的用户ID，如果查询到的ID为0，表示未找到对应用户，返回失败响应。
             uid = userInformationService.selectIdByPhone(realPhone);
             if (uid == 0) {
                 return BaseResponse.fail();
@@ -71,29 +106,41 @@ public class ForgetController {
             e.printStackTrace();
             return BaseResponse.fail();
         }
+        // 通过用户密码服务，根据用户ID查询对应的用户密码记录，并获取其ID。
         int id = userPasswordService.selectByUid(uid).getId();
         userPassword.setId(id);
         userPassword.setUid(uid);
+        // 设置密码修改时间为当前时间。
         userPassword.setModified(new Date());
         userPassword.setPassword(newPassword);
         int result;
         try {
+            // 调用用户密码服务的方法，根据主键有选择地更新用户密码记录（只更新传入的非空字段对应的属性）。
             result = userPasswordService.updateByPrimaryKeySelective(userPassword);
         } catch (Exception e) {
             return BaseResponse.fail();
         }
-        //更新失败
-        if (result != 1) {
+        // 如果更新操作影响的行数不等于1（即更新失败），返回失败响应。
+        if (result!= 1) {
             return BaseResponse.fail();
         }
+        // 更新成功后，根据用户ID查询用户信息，并将其存入会话中，方便后续使用。
         UserInformation userInformation = userInformationService.selectByPrimaryKey(uid);
         request.getSession().setAttribute("userInformation", userInformation);
         return BaseResponse.success();
     }
 
-    //check the phone`s code
+    /**
+     * 私有方法，用于检查传入的手机号验证码是否正确。
+     * 这里目前写死了正确的验证码为"12251103"，实际应用中应该从数据库等正确的数据源获取进行对比验证。
+     *
+     * @param codePhone 传入的要验证的手机号验证码。
+     * @param request   HttpServletRequest对象（此处未用到，可根据实际情况调整是否需要该参数）。
+     * @return 返回布尔值，true表示验证码正确，false表示验证码错误。
+     */
+    // check the phone`s code
     private boolean checkCodePhone(String codePhone, HttpServletRequest request) {
         String trueCodePhone = "12251103";
         return codePhone.equals(trueCodePhone);
     }
-}
+}

src/main/java/com/wsk/controller/GoodsController.java

@@ -0,0 +1,326 @@
+package com.wsk.controller;
+
+import com.wsk.bean.ShopContextBean;
+import com.wsk.bean.ShopInformationBean;
+import com.wsk.bean.UserWantBean;
+import com.wsk.pojo.*;
+import com.wsk.service.*;
+import com.wsk.token.TokenProccessor;
+import com.wsk.tool.StringUtils;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by wsk1103 on 2017/5/14.
+ * GoodsController类，主要用于处理商品相关的各种业务操作，例如发布商品、查询商品、查看商品详情等功能，是Spring MVC框架中的一个控制器类。
+ */
+@Controller
+// @Controller注解表明这个类是Spring MVC的控制器类，会被Spring框架扫描并用于处理Web请求，可将请求映射到对应的方法上。
+public class GoodsController {
+
+    @Resource
+    // @Resource注解用于依赖注入，将Spring容器中管理的ShopInformationService类型的Bean注入到当前类中，方便后续调用其提供的与店铺信息相关的业务方法。
+    private ShopInformationService shopInformationService;
+    @Resource
+    private ShopContextService shopContextService;
+    @Resource
+    private UserInformationService userInformationService;
+    @Resource
+    private SpecificeService specificeService;
+    @Resource
+    private ClassificationService classificationService;
+    @Resource
+    private AllKindsService allKindsService;
+    @Resource
+    private UserWantService userWantService;
+
+    /**
+     * 处理进入发布商品页面的请求方法。
+     * 该方法支持GET请求方式，会先判断用户是否登录，如果未登录则重定向到登录页面；如果已登录，进一步判断用户是否经过认证，未认证则提示先认证信息并重定向到个人信息页面；若已认证则准备相关数据并跳转到发布商品页面。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息以及操作会话等。
+     * @param model    Spring MVC中的Model对象，可用于向视图传递数据，比如将用户信息、页面相关参数等传递给视图。
+     * @return 返回一个视图名称，根据不同情况可能是重定向到其他页面或者跳转到"page/publish_product"页面。
+     */
+    @RequestMapping(value = "/publish_product.do", method = RequestMethod.GET)
+    public String publish(HttpServletRequest request, Model model) {
+        // 从会话中获取用户信息，判断用户是否已登录。
+        UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+        if (StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+            // 如果用户信息为空，表示用户没有登录，重定向到登录页面。
+            return "redirect:/login.do";
+        } else {
+            // 如果用户已登录，将用户信息添加到Model中，以便视图可以获取并展示相关信息。
+            model.addAttribute("userInformation", userInformation);
+        }
+        // 如果登录了，判断该用户有没有经过认证，通过获取用户的真实姓名、学号、宿舍等信息是否为空来判断。
+        try {
+            String realName = userInformation.getRealname();
+            String sno = userInformation.getSno();
+            String dormitory = userInformation.getDormitory();
+            if (StringUtils.getInstance().isNullOrEmpty(realName) || StringUtils.getInstance().isNullOrEmpty(sno) || StringUtils.getInstance().isNullOrEmpty(dormitory)) {
+                // 如果这些关键信息有空值，说明用户未认证，添加提示信息到Model中，并重定向到个人信息页面让用户去认证。
+                model.addAttribute("message", "请先认证真实信息");
+                return "redirect:personal_info.do";
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "redirect:/login.do";
+        }
+        // 使用TokenProccessor生成一个token，用于可能的表单防重复提交等安全验证场景（此处假设）。
+        String goodsToken = TokenProccessor.getInstance().makeToken();
+        request.getSession().setAttribute("goodsToken", goodsToken);
+        // 向Model中添加一个新的ShopInformation对象，可能用于页面上的表单绑定等操作（具体取决于页面需求）。
+        model.addAttribute("shopInformation", new ShopInformation());
+        model.addAttribute("action", 1);
+        model.addAttribute("token", goodsToken);
+        // 最终跳转到发布商品的页面（具体页面路径配置可能在视图解析器中定义）。
+        return "page/publish_product";
+    }
+
+    /**
+     * 处理模糊查询商品的请求方法。
+     * 根据传入的商品名称进行模糊查询，获取符合条件的商品信息列表，然后将相关信息进行处理和封装后添加到Model中，并返回展示商品列表的视图页面。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关信息以及操作会话等，比如获取用户信息。
+     * @param model    Spring MVC中的Model对象，用于向视图传递查询到的商品信息列表等数据。
+     * @param name     从请求中获取的要模糊查询的商品名称参数。
+     * @return 返回一个视图名称，若查询过程出现异常则重定向到商城页面（"mall_page.do"），正常则返回"page/mall_page"视图展示查询结果。
+     */
+    @RequestMapping(value = "/findShopByName.do")
+    public String findByName(HttpServletRequest request, Model model,
+                             @RequestParam String name) {
+        try {
+            // 调用ShopInformationService的方法，根据商品名称进行模糊查询，获取符合条件的ShopInformation列表。
+            List<ShopInformation> shopInformations = shopInformationService.selectByName(name);
+            UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+            if (StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+                userInformation = new UserInformation();
+                // 如果用户未登录（用户信息为空），创建一个空的UserInformation对象添加到Model中，可能用于页面展示等情况。
+                model.addAttribute("userInformation", userInformation);
+            } else {
+                // 如果用户已登录，将用户信息添加到Model中。
+                model.addAttribute("userInformation", userInformation);
+            }
+            List<ShopInformationBean> shopInformationBeans = new ArrayList<>();
+            String sortName;
+            // 遍历查询到的每个ShopInformation对象，进行相关信息的提取和封装到ShopInformationBean对象中。
+            for (ShopInformation shopInformation : shopInformations) {
+                int sort = shopInformation.getSort();
+                sortName = getSort(sort);
+                ShopInformationBean shopInformationBean = new ShopInformationBean();
+                shopInformationBean.setId(shopInformation.getId());
+                shopInformationBean.setName(shopInformation.getName());
+                shopInformationBean.setLevel(shopInformation.getLevel());
+                shopInformationBean.setRemark(shopInformation.getRemark());
+                shopInformationBean.setPrice(shopInformation.getPrice().doubleValue());
+                shopInformationBean.setQuantity(shopInformation.getQuantity());
+                shopInformationBean.setTransaction(shopInformation.getTransaction());
+                shopInformationBean.setSort(sortName);
+                shopInformationBean.setUid(shopInformation.getUid());
+                shopInformationBean.setImage(shopInformation.getImage());
+                shopInformationBeans.add(shopInformationBean);
+            }
+            // 将封装好的商品信息列表添加到Model中，以便视图展示。
+            model.addAttribute("shopInformationBean", shopInformationBeans);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "redirect:mall_page.do";
+        }
+        return "page/mall_page";
+    }
+
+    /**
+     * 处理进入查看商品详情页面的请求方法。
+     * 根据传入的商品ID，获取商品详细信息以及相关的评论等上下文信息，进行处理和准备相关数据后，跳转到展示商品详情的页面。
+     *
+     * @param id       从请求中获取的要查看详情的商品ID参数。
+     * @param request  HttpServletRequest对象，用于获取请求相关信息以及操作会话等，比如获取用户信息、设置会话属性等。
+     * @param model    Spring MVC中的Model对象，用于向视图传递商品详情、用户信息、评论信息等数据。
+     * @return 返回一个视图名称，若获取商品信息等过程出现异常则重定向到根路径（"/"），正常则返回"page/product_info"视图展示商品详情。
+     */
+    @RequestMapping(value = "/selectById.do")
+    public String selectById(@RequestParam int id,
+                             HttpServletRequest request, Model model) {
+        UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+        if (StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+            userInformation = new UserInformation();
+            model.addAttribute("userInformation", userInformation);
+        }
+        try {
+            // 调用ShopInformationService的方法，根据商品ID获取商品的详细信息，并添加到Model中。
+            ShopInformation shopInformation = shopInformationService.selectByPrimaryKey(id);
+            model.addAttribute("shopInformation", shopInformation);
+            // 调用ShopContextService的方法，根据商品ID获取该商品的相关评论等上下文信息列表。
+            List<ShopContext> shopContexts = shopContextService.selectById(id);
+            List<ShopContextBean> shopContextBeans = new ArrayList<>();
+            // 遍历每个评论上下文信息，进行相关信息的提取和封装到ShopContextBean对象中。
+            for (ShopContext s : shopContexts) {
+                ShopContextBean shopContextBean = new ShopContextBean();
+                UserInformation u = userInformationService.selectByPrimaryKey(s.getUid());
+                shopContextBean.setContext(s.getContext());
+                shopContextBean.setId(s.getId());
+                shopContextBean.setModified(s.getModified());
+                shopContextBean.setUid(u.getId());
+                shopContextBean.setUsername(u.getUsername());
+                shopContextBeans.add(shopContextBean);
+            }
+            String sort = getSort(shopInformation.getSort());
+            String goodsToken = TokenProccessor.getInstance().makeToken();
+            request.getSession().setAttribute("goodsToken", goodsToken);
+            model.addAttribute("token", goodsToken);
+            model.addAttribute("sort", sort);
+            model.addAttribute("userInformation", userInformation);
+            model.addAttribute("shopContextBeans", shopContextBeans);
+            return "page/product_info";
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "redirect:/";
+        }
+    }
+
+    /**
+     * 处理进入求购商城页面的请求方法。
+     * 获取所有的求购商品信息列表，进行相关信息的处理和封装后添加到Model中，最后跳转到展示求购商城的页面。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关信息以及操作会话等，比如获取用户信息。
+     * @param model    Spring MVC中的Model对象，用于向视图传递求购商品信息列表等数据。
+     * @return 返回一个视图名称，即"page/require_mall"，用于展示求购商城页面。
+     */
+    @RequestMapping(value = "/require_mall.do")
+    public String requireMall(HttpServletRequest request, Model model) {
+        UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+        if (StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+            userInformation = new UserInformation();
+            model.addAttribute("userInformation", userInformation);
+        } else {
+            model.addAttribute("userInformation", userInformation);
+        }
+        // 调用UserWantService的方法，获取所有的求购商品信息列表。
+        List<UserWant> userWants = userWantService.selectAll();
+        List<UserWantBean> list = new ArrayList<>();
+        // 遍历每个求购商品信息，进行相关信息的提取和封装到UserWantBean对象中。
+        for (UserWant userWant : userWants) {
+            UserWantBean u = new UserWantBean();
+            u.setSort(getSort(userWant.getSort()));
+            u.setRemark(userWant.getRemark());
+            u.setQuantity(userWant.getQuantity());
+            u.setPrice(userWant.getPrice().doubleValue());
+            u.setUid(userWant.getUid());
+            u.setId(userWant.getId());
+            u.setModified(userWant.getModified());
+            u.setName(userWant.getName());
+            list.add(u);
+        }
+        model.addAttribute("list", list);
+        return "page/require_mall";
+    }
+
+    /**
+     * 根据商品ID查找商品详细信息的方法，该方法会直接返回商品信息对象，并且使用了@ResponseBody注解，意味着返回结果会直接作为响应体（通常是JSON格式等）返回给客户端，常用于提供数据接口。
+     *
+     * @param id 从请求中获取的要查找详情的商品ID参数。
+     * @return 返回ShopInformation对象，即对应商品的详细信息，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/findShopById.do")
+    @ResponseBody
+    public ShopInformation findShopById(@RequestParam int id) {
+        return shopInformationService.selectByPrimaryKey(id);
+    }
+
+    /**
+     * 根据分类选择商品的方法，同样使用了@ResponseBody注解，会将查询到的符合分类条件的商品信息列表作为响应体返回给客户端，用于提供根据分类获取商品数据的接口。
+     *
+     * @param sort 从请求中获取的分类ID参数，用于筛选对应分类的商品。
+     * @return 返回List<ShopInformation>，即符合分类条件的商品信息列表，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/selectBySort.do")
+    @ResponseBody
+    public List<ShopInformation> selectBySort(@RequestParam int sort) {
+        return shopInformationService.selectBySort(sort);
+    }
+
+    /**
+     * 分页查询商品的方法，使用了@ResponseBody注解，根据传入的页码数进行分页查询，获取对应页的商品信息列表并作为响应体返回给客户端，用于提供分页获取商品数据的接口。
+     *
+     * @param counts 从请求中获取的页码数参数，用于确定要查询的商品数据页。
+     * @return 返回List<ShopInformation>，即对应页码的商品信息列表，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/selectByCounts.do")
+    @ResponseBody
+    public List<ShopInformation> selectByCounts(@RequestParam int counts) {
+        Map<String, Integer> map = new HashMap<>();
+        map.put("start", (counts - 1) * 12);
+        map.put("end", 12);
+        return shopInformationService.selectTen(map);
+    }
+
+    //    //通过id查看商品详情
+    //    @RequestMapping(value = "/showShop")
+    //    public String showShop(@RequestParam int id, HttpServletRequest request, Model model) {
+    //        ShopInformation shopInformation =
+    //    }
+
+    /**
+     * 根据分类ID获取最详细的分类信息（第三层分类）的私有方法，用于内部辅助获取商品分类相关的详细信息，方便其他方法构建完整的分类名称等操作。
+     *
+     * @param sort 要获取的分类ID参数。
+     * @return 返回Specific对象，即对应分类ID的最详细分类信息。
+     */
+    private Specific selectSpecificBySort(int sort) {
+        return specificeService.selectByPrimaryKey(sort);
+    }
+
+    /**
+     * 根据二级分类ID获取第二层分类信息的私有方法，同样用于辅助获取商品分类相关信息，与其他分类获取方法配合使用，构建完整的分类路径等。
+     *
+     * @param cid 要获取的二级分类ID参数。
+     * @return 返回Classification对象，即对应二级分类ID的第二层分类信息。
+     */
+    private Classification selectClassificationByCid(int cid) {
+        return classificationService.selectByPrimaryKey(cid);
+    }
+
+    /**
+     * 根据一级分类ID获取第一层分类信息的私有方法，也是用于辅助构建商品分类完整路径，方便获取和展示更详细准确的商品分类情况。
+     *
+     * @param aid 要获取的一级分类ID参数。
+     * @return 返回AllKinds对象，即对应一级分类ID的第一层分类信息。
+     */
+    private AllKinds selectAllKindsByAid(int aid) {
+        return allKindsService.selectByPrimaryKey(aid);
+    }
+
+    /**
+     * 根据商品分类ID构建完整分类名称的私有方法，通过依次获取一、二、三级分类信息，将各级分类名称拼接起来，形成一个完整的分类名称字符串，用于在页面展示商品分类情况等用途。
+     *
+     * @param sort 要构建分类名称的商品分类ID参数。
+     * @return 返回一个表示完整分类名称的字符串，格式为"一级分类名-二级分类名-三级分类名"。
+     */
+    private String getSort(int sort) {
+        StringBuilder sb = new StringBuilder();
+        Specific specific = selectSpecificBySort(sort);
+        int cid = specific.getCid();
+        Classification classification = selectClassificationByCid(cid);
+        int aid = classification.getAid();
+        AllKinds allKinds = selectAllKindsByAid(aid);
+        String allName = allKinds.getName();
+        sb.append(allName);
+        sb.append("-");
+        sb.append(classification.getName());
+        sb.append("-");
+        sb.append(specific.getName());
+        return sb.toString();
+    }
+}

src/main/java/com/wsk/controller/HomeController.java

@@ -0,0 +1,336 @@
+package com.wsk.controller;
+
+import com.wsk.bean.ShopInformationBean;
+import com.wsk.pojo.*;
+import com.wsk.service.*;
+import com.wsk.tool.StringUtils;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by wsk1103 on 2017/5/11.
+ * HomeController类，作为Spring MVC框架中的控制器类，主要处理与网站首页、商城页面展示以及商品分类、商品数量获取等相关的业务逻辑，将请求映射到对应的方法进行处理，并根据情况返回相应的视图或数据响应。
+ */
+@Controller
+// @Controller注解表明该类是Spring MVC的控制器，会被Spring框架扫描并用于处理Web请求，可将请求映射到对应的方法上。
+public class HomeController {
+
+    @Resource
+    // @Resource注解用于依赖注入，将Spring容器中管理的ShopInformationService类型的Bean注入到当前类中，方便后续调用其提供的与店铺信息相关的业务方法。
+    private ShopInformationService shopInformationService;
+    @Resource
+    private SpecificeService specificeService;
+    @Resource
+    private ClassificationService classificationService;
+    @Resource
+    private AllKindsService allKindsService;
+    @Resource
+    private ShopContextService shopContextService;
+
+    /**
+     * 处理网站首页（根路径"/"以及"/home.do"）的请求方法。
+     * 该方法会先判断用户是否登录（通过会话中是否存在"userInformation"属性判断），若登录则将用户信息添加到Model中；然后获取一定数量的商品信息进行处理和封装后添加到Model中，最后返回展示首页的视图。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息以及操作会话等，比如获取用户信息。
+     * @param model    Spring MVC中的Model对象，可用于向视图传递数据，如用户信息、商品信息列表等。
+     * @return 返回一个视图名称，若在获取商品信息等过程出现异常则重定向到登录页面（"page/login_page"），正常则返回"index"视图展示首页内容。
+     */
+    @RequestMapping(value = {"/", "/home.do"})
+    public String home(HttpServletRequest request, Model model) {
+        UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+        // 如果用户登录了，会话中会有"userInformation"属性，这里判断其是否为空来确定用户是否登录。
+        if (!StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+            // 如果用户已登录，将用户信息添加到Model中，以便视图可以获取并展示相关信息。
+            model.addAttribute("userInformation", userInformation);
+        } else {
+            userInformation = new UserInformation();
+            model.addAttribute("userInformation", userInformation);
+        }
+        // 一般形式进入首页，尝试获取部分商品信息进行展示。
+        try {
+            // 调用selectTen方法获取指定数量的商品信息列表，此处获取第1页，每页显示5条商品信息（参数含义可查看selectTen方法注释）。
+            List<ShopInformation> shopInformations = selectTen(1, 5);
+            List<ShopInformationBean> list = new ArrayList<>();
+            // 获取商品的总数量，用于可能的页面展示等用途（比如分页相关功能）。
+            int counts = getShopCounts();
+            model.addAttribute("shopInformationCounts", counts);
+            String stringBuffer;
+            // 遍历获取到的每个商品信息，进行相关信息的提取和封装到ShopInformationBean对象中，并添加到列表中。
+            for (ShopInformation shopInformation : shopInformations) {
+                stringBuffer = getSortName(shopInformation.getSort());
+                ShopInformationBean shopInformationBean = new ShopInformationBean();
+                shopInformationBean.setId(shopInformation.getId());
+                shopInformationBean.setName(shopInformation.getName());
+                shopInformationBean.setLevel(shopInformation.getLevel());
+                shopInformationBean.setPrice(shopInformation.getPrice().doubleValue());
+                shopInformationBean.setRemark(shopInformation.getRemark());
+                shopInformationBean.setSort(stringBuffer);
+                shopInformationBean.setQuantity(shopInformation.getQuantity());
+                shopInformationBean.setUid(shopInformation.getUid());
+                shopInformationBean.setTransaction(shopInformation.getTransaction());
+                shopInformationBean.setImage(shopInformation.getImage());
+                list.add(shopInformationBean);
+            }
+            model.addAttribute("shopInformationBean", list);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "page/login_page";
+        }
+        return "index";
+    }
+
+    /**
+     * 处理进入商城页面的请求方法。
+     * 同样先判断用户是否登录并处理用户信息添加到Model中，然后获取一定数量的商品信息进行处理和封装后添加到Model，最后返回展示商城页面的视图。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关信息以及操作会话等，比如获取用户信息。
+     * @param model    Spring MVC中的Model对象，用于向视图传递用户信息、商品信息列表等数据。
+     * @return 返回一个视图名称，若在获取商品信息等过程出现异常则重定向到登录页面（"page/login_page"），正常则返回"page/mall_page"视图展示商城页面内容。
+     */
+    @RequestMapping(value = "/mall_page.do")
+    public String mallPage(HttpServletRequest request, Model model) {
+        UserInformation userInformation = (UserInformation) request.getSession().getAttribute("userInformation");
+        if (StringUtils.getInstance().isNullOrEmpty(userInformation)) {
+            userInformation = new UserInformation();
+            model.addAttribute("userInformation", userInformation);
+        } else {
+            model.addAttribute("userInformation", userInformation);
+        }
+        try {
+            // 调用selectTen方法获取指定数量的商品信息列表，此处获取第1页，每页显示12条商品信息（参数含义可查看selectTen方法注释）。
+            List<ShopInformation> shopInformations = selectTen(1, 12);
+            List<ShopInformationBean> list = new ArrayList<>();
+            // 获取商品的总数量，用于可能的页面展示等用途（比如分页相关功能）。
+            int counts = getShopCounts();
+            model.addAttribute("shopInformationCounts", counts);
+            String sortName;
+            // 遍历获取到的每个商品信息，进行相关信息的提取和封装到ShopInformationBean对象中，并添加到列表中。
+            for (ShopInformation shopInformation : shopInformations) {
+                int sort = shopInformation.getSort();
+                sortName = getSortName(sort);
+                ShopInformationBean shopInformationBean = new ShopInformationBean();
+                shopInformationBean.setId(shopInformation.getId());
+                shopInformationBean.setName(shopInformation.getName());
+                shopInformationBean.setLevel(shopInformation.getLevel());
+                shopInformationBean.setRemark(shopInformation.getRemark());
+                shopInformationBean.setPrice(shopInformation.getPrice().doubleValue());
+                shopInformationBean.setSort(sortName);
+                shopInformationBean.setQuantity(shopInformation.getQuantity());
+                shopInformationBean.setTransaction(shopInformation.getTransaction());
+                shopInformationBean.setUid(shopInformation.getUid());
+                shopInformationBean.setImage(shopInformation.getImage());
+                list.add(shopInformationBean);
+            }
+            model.addAttribute("shopInformationBean", list);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return "page/login_page";
+        }
+        return "page/mall_page";
+    }
+
+    /**
+     * 根据商品分类的第三层ID获取完整分类名称的私有方法。
+     * 通过依次获取一、二、三级分类信息，将各级分类名称拼接起来，形成一个完整的分类名称字符串，用于在页面展示商品分类情况等用途。
+     *
+     * @param sort 要构建分类名称的商品分类第三层ID参数。
+     * @return 返回一个表示完整分类名称的字符串，格式为"一级分类名-二级分类名-三级分类名"。
+     */
+    private String getSortName(int sort) {
+        StringBuilder stringBuffer = new StringBuilder();
+        Specific specific = selectSpecificBySort(sort);
+        int cid = specific.getCid();
+        Classification classification = selectClassificationByCid(cid);
+        int aid = classification.getAid();
+        AllKinds allKinds = selectAllKindsByAid(aid);
+        stringBuffer.append(allKinds.getName());
+        stringBuffer.append("-");
+        stringBuffer.append(classification.getName());
+        stringBuffer.append("-");
+        stringBuffer.append(specific.getName());
+//        System.out.println(sort);
+        return stringBuffer.toString();
+    }
+
+    /**
+     * 获取所有第一层分类信息的方法，使用了@ResponseBody注解，意味着返回结果会直接作为响应体（通常是JSON格式等）返回给客户端，常用于提供数据接口，此处用于获取全部的第一层分类数据。
+     *
+     * @return 返回List<AllKinds>，即所有第一层分类信息的列表，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/getAllKinds.do")
+    @ResponseBody
+    public List<AllKinds> getAllKind() {
+        return getAllKinds();
+    }
+
+    /**
+     * 根据第一层分类的ID获取其下第二层分类信息的方法，同样使用了@ResponseBody注解，用于提供根据第一层分类ID获取对应第二层分类数据的接口，返回符合条件的第二层分类信息列表。
+     *
+     * @param id 从请求中获取的第一层分类的ID参数，用于筛选对应第一层分类下的第二层分类。
+     * @return 返回List<Classification>，即对应第一层分类ID下的第二层分类信息列表，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/getClassification.do", method = RequestMethod.POST)
+    @ResponseBody
+    public List<Classification> getClassificationByAid(@RequestParam int id) {
+        return selectAllClassification(id);
+    }
+
+    /**
+     * 根据第二层分类的ID获取其对应的第三层分类信息的方法，使用了@ResponseBody注解，用于提供根据第二层分类ID获取对应第三层分类数据的接口，返回符合条件的第三层分类信息列表。
+     *
+     * @param id 从请求中获取的第二层分类的ID参数，用于筛选对应第二层分类下的第三层分类。
+     * @return 返回List<Specific>，即对应第二层分类ID下的第三层分类信息列表，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/getSpecific.do")
+    @ResponseBody
+    public List<Specific> getSpecificByCid(@RequestParam int id) {
+        return selectAllSpecific(id);
+    }
+
+    /**
+     * 获取商品总数量的方法，使用了@ResponseBody注解，会将获取到的商品总数量封装到Map中作为响应体返回给客户端，用于提供获取商品总数的数据接口。
+     *
+     * @return 返回Map<String, Integer>，其中包含"counts"键对应的商品总数量值，作为响应体返回给客户端。
+     */
+    @RequestMapping(value = "/getShopsCounts.do")
+    @ResponseBody
+    public Map getShopsCounts() {
+        Map<String, Integer> map = new HashMap<>();
+        int counts = 0;
+        try {
+            counts = shopInformationService.getCounts();
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("counts", counts);
+            return map;
+        }
+        map.put("counts", counts);
+        return map;
+    }
+
+    /**
+     * 根据起始位置获取商品信息列表的方法，使用了@ResponseBody注解，用于分页获取商品数据，根据传入的起始位置参数，获取对应页的商品信息列表并作为响应体返回给客户端，提供分页获取商品数据的接口。
+     *
+     * @param start 从请求中获取的起始位置参数，用于确定要获取的商品数据起始位置（结合每页显示数量来确定具体页的数据）。
+     * @return 返回List，即对应起始位置的商品信息列表，作为响应体返回给客户端，此处实际返回的是ShopInformation类型的列表。
+     */
+    @RequestMapping(value = "/getShops.do")
+    @ResponseBody
+    public List getShops(@RequestParam int start) {
+        List<ShopInformation> list = new ArrayList<>();
+        try {
+            int end = 12;
+            list = selectTen(start, end);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return list;
+        }
+        return list;
+    }
+
+    /**
+     * 分页获取商品信息的私有方法，根据传入的起始页和每页显示数量参数，构建查询参数Map，调用ShopInformationService的方法获取对应页的商品信息列表，用于内部辅助实现分页查询商品的功能。
+     *
+     * @param start 要获取的商品信息起始页参数，从1开始计数。
+     * @param end   每页显示的商品数量参数。
+     * @return 返回List<ShopInformation>，即对应页的商品信息列表。
+     */
+    private List<ShopInformation> selectTen(int start, int end) {
+        Map map = new HashMap();
+        map.put("start", (start - 1) * end);
+        map.put("end", end);
+        List<ShopInformation> list = shopInformationService.selectTen(map);
+        return list;
+    }
+
+    /**
+     * 根据分类ID获取最详细的分类信息（第三层分类）的私有方法，用于内部辅助获取商品分类相关的详细信息，方便其他方法构建完整的分类名称等操作。
+     *
+     * @param sort 要获取的分类ID参数。
+     * @return 返回Specific对象，即对应分类ID的最详细分类信息。
+     */
+    private Specific selectSpecificBySort(int sort) {
+        return specificeService.selectByPrimaryKey(sort);
+    }
+
+    /**
+     * 根据二级分类ID获取第二层分类信息的私有方法，同样用于辅助获取商品分类相关信息，与其他分类获取方法配合使用，构建完整的分类路径等。
+     *
+     * @param cid 要获取的二级分类ID参数。
+     * @return 返回Classification对象，即对应二级分类ID的第二层分类信息。
+     */
+    private Classification selectClassificationByCid(int cid) {
+        return classificationService.selectByPrimaryKey(cid);
+    }
+
+    /**
+     * 根据一级分类ID获取第一层分类信息的私有方法，也是用于辅助构建商品分类完整路径，方便获取和展示更详细准确的商品分类情况。
+     *
+     * @param aid 要获取的一级分类ID参数。
+     * @return 返回AllKinds对象，即对应一级分类ID的第一层分类信息。
+     */
+    private AllKinds selectAllKindsByAid(int aid) {
+        return allKindsService.selectByPrimaryKey(aid);
+    }
+
+    /**
+     * 获取所有第一层分类信息的私有方法，用于内部调用获取全部的第一层分类数据，配合其他方法来提供完整的分类相关数据获取功能。
+     *
+     * @return 返回List<AllKinds>，即所有第一层分类信息的列表。
+     */
+    private List<AllKinds> getAllKinds() {
+        return allKindsService.selectAll();
+    }
+
+    /**
+     * 根据第一层分类的ID获取其下第二层分类信息的私有方法，用于内部辅助实现根据第一层分类ID获取对应第二层分类数据的功能，配合其他分类获取方法来构建完整的分类层级数据。
+     *
+     * @param aid 要获取的第一层分类的ID参数，用于筛选对应第一层分类下的第二层分类。
+     * @return 返回List<Classification>，即对应第一层分类ID下的第二层分类信息列表。
+     */
+    private List<Classification> selectAllClassification(int aid) {
+        return classificationService.selectByAid(aid);
+    }
+
+    /**
+     * 根据第二层分类的ID获取其对应的第三层分类信息的私有方法，用于内部辅助实现根据第二层分类ID获取对应第三层分类数据的功能，配合其他分类获取方法来构建完整的分类层级数据。
+     *
+     * @param cid 要获取的第二层分类的ID参数，用于筛选对应第二层分类下的第三层分类。
+     * @return 返回List<Specific>，即对应第二层分类ID下的第三层分类信息列表。
+     */
+    private List<Specific> selectAllSpecific(int cid) {
+        return specificeService.selectByCid(cid);
+    }
+
+    /**
+     * 获取商品总数量的私有方法，调用ShopInformationService的相关方法获取商品的总数量，用于内部辅助实现获取商品总数的功能，比如在其他方法中判断分页等情况。
+     *
+     * @return 返回商品的总数量，即一个整数表示商品总数。
+     */
+    private int getShopCounts() {
+        return shopInformationService.getCounts();
+    }
+
+    /**
+     * 获取商品留言总页数的私有方法，调用ShopContextService的相关方法，根据传入的商品ID获取该商品留言的总页数，用于内部辅助实现商品留言分页相关功能（虽然代码中未完整展示使用场景，但可推测用于此用途）。
+     *
+     * @param sid 商品的ID参数，用于确定获取哪个商品的留言总页数。
+     * @return 返回商品留言的总页数，即一个整数表示留言总页数。
+     */
+    private int getShopContextCounts(int sid) {
+        return shopContextService.getCounts(sid);
+    }
+
+    /**
+     * 根据商品ID和起始位置获取商品留言信息列表的私有方法，调用ShopContextService

src/main/java/com/wsk/controller/RegisterController.java

@@ -0,0 +1,127 @@
+package com.wsk.controller;
+
+import com.wsk.pojo.UserInformation;
+import com.wsk.pojo.UserPassword;
+import com.wsk.response.BaseResponse;
+import com.wsk.service.UserInformationService;
+import com.wsk.service.UserPasswordService;
+import com.wsk.tool.StringUtils;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import javax.annotation.Resource;
+import javax.servlet.http.HttpServletRequest;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Created by wsk1103 on 2017/5/9.
+ * 注册中心
+ * 该类作为Spring MVC中的控制器，主要负责处理用户注册相关的业务逻辑，通过接收前端传来的注册信息，与服务层交互进行数据持久化等操作，最终返回注册结果响应给前端。
+ */
+@Controller
+// @Controller注解表明这个类是Spring MVC的控制器类，会被Spring框架扫描并用于处理Web请求，将请求映射到对应的方法上。
+public class RegisterController {
+
+    @Resource
+    // @Resource注解用于依赖注入，将Spring容器中管理的UserPasswordService类型的Bean注入到当前类中，方便后续调用其提供的与用户密码相关的业务方法。
+    private UserPasswordService userPasswordService;
+
+    @Resource
+    // 同样，注入UserInformationService类型的Bean，用于调用和用户信息相关的业务方法，比如插入、查询、删除用户信息等操作。
+    private UserInformationService userInformationService;
+
+    /**
+     * 处理用户注册的请求方法，该方法接收前端传来的密码和token参数，用于创建新用户信息并插入到数据库中，包括用户基本信息和密码信息，同时进行一系列的验证，如防止重复提交、手机号是否已存在等，最后根据操作结果返回相应的注册结果响应给前端。
+     * 使用了@ResponseBody注解，表示方法的返回值会直接作为响应体（通常是JSON等格式）返回给客户端，而不是跳转视图。
+     *
+     * @param request  HttpServletRequest对象，用于获取请求相关的信息，例如从会话（session）中获取之前存储的手机号、token等数据，还能用于后续向会话中存储用户信息等操作。
+     * @param password 从请求中获取的用户密码参数，后续会进行加密等处理后存入数据库。
+     * @param token    从请求中获取的token参数，用于防止重复提交等安全验证，会和会话中存储的token进行比对。
+     * @return 返回BaseResponse对象，该对象封装了注册操作的结果状态，成功则返回success，失败则返回fail，前端可根据此响应来提示用户相应的注册情况。
+     */
+    @RequestMapping("/insertUser.do")
+    @ResponseBody
+    public BaseResponse insertUser(HttpServletRequest request,
+                                   @RequestParam String password, @RequestParam String token) {
+
+        // 从会话（session）中获取之前存储的手机号码，该手机号码可能是在注册流程的前序步骤中由用户输入并存储到会话里的（虽然代码中未展示具体存储过程，但可推测是这样的流程）。
+        String realPhone = (String) request.getSession().getAttribute("phone");
+
+        // 从会话中获取名为"token"的属性值，该token作为唯一标识，用于验证本次请求是否是重复提交等情况（例如在表单提交场景中防止用户多次点击提交按钮造成重复注册）。
+        String insertUserToken = (String) request.getSession().getAttribute("token");
+
+        // 防止重复提交验证，如果获取到的会话中的token为空或者与传入的token不一致，则认为是重复提交或非法请求，直接返回注册失败的响应。
+        if (StringUtils.getInstance().isNullOrEmpty(insertUserToken) ||!insertUserToken.equals(token)) {
+            return BaseResponse.fail();
+        }
+
+        // 调用UserInformationService的方法，根据手机号查询对应的用户ID，判断该手机号码是否已经存在于数据库中，如果查询到的ID不为0，表示该手机号已被注册，直接返回注册失败的响应。
+        int uid = userInformationService.selectIdByPhone(realPhone);
+        if (uid!= 0) {
+            return BaseResponse.fail();
+        }
+
+        // 创建一个新的UserInformation对象，用于封装要插入数据库的用户基本信息，后续会将该对象通过服务层方法插入到数据库中。
+        UserInformation userInformation = new UserInformation();
+
+        // 将从会话中获取到的手机号码设置到用户信息对象中，作为用户的手机号属性值。
+        userInformation.setPhone(realPhone);
+
+        // 设置用户信息的创建时间为当前时间，通过创建一个Date对象获取当前时间并赋值给createtime属性。
+        userInformation.setCreatetime(new Date());
+
+        // 从会话中获取用户名（同样，这里的用户名可能是之前在注册流程中用户输入并存储到会话里的，代码未完整展示该部分），并设置到用户信息对象的username属性中。
+        String username = (String) request.getSession().getAttribute("name");
+        userInformation.setUsername(username);
+
+        // 设置用户信息的修改时间为当前时间，这里可能是考虑到新用户注册也算一次信息修改操作，所以初始创建时修改时间和创建时间都设置为当前时间。
+        userInformation.setModified(new Date());
+
+        // 调用UserInformationService的insertSelective方法，将封装好的用户信息对象插入到数据库中，该方法可能只会插入对象中不为空的属性对应的字段值（具体取决于服务层实现），并获取插入操作影响的行数，存储到result变量中。
+        int result;
+        result = userInformationService.insertSelective(userInformation);
+
+        // 如果用户基本信息插入数据库成功（即影响行数为1，表示成功插入了一条记录），则继续进行密码相关信息的插入操作。
+        if (result == 1) {
+            // 再次通过手机号查询用户ID，确保获取到刚插入用户信息对应的正确ID，以便后续关联用户密码信息。
+            uid = userInformationService.selectIdByPhone(realPhone);
+
+            // 使用StringUtils工具类的方法对传入的密码进行MD5加密处理，得到加密后的密码字符串，用于安全地存储到数据库中。
+            String newPassword = StringUtils.getInstance().getMD5(password);
+
+            // 创建一个新的UserPassword对象，用于封装用户密码相关信息，后续将其插入到数据库中与对应的用户关联起来。
+            UserPassword userPassword = new UserPassword();
+
+            // 设置密码的修改时间为当前时间，与用户信息的修改时间逻辑类似，记录密码信息的最后修改时间。
+            userPassword.setModified(new Date());
+
+            // 将前面获取到的用户ID设置到用户密码对象的uid属性中，建立用户信息和密码信息的关联关系。
+            userPassword.setUid(uid);
+
+            // 将加密后的密码设置到用户密码对象的password属性中，准备插入到数据库。
+            userPassword.setPassword(newPassword);
+
+            // 调用UserPasswordService的insertSelective方法，将用户密码信息插入到数据库中，并获取插入操作影响的行数，存储到result变量中。
+            result = userPasswordService.insertSelective(userPassword);
+
+            // 如果密码信息插入失败（即影响行数不为1，表示插入操作出现问题），则需要删除之前插入的用户基本信息（保持数据的一致性，避免产生孤立的用户信息记录），然后返回注册失败的响应。
+            if (result!= 1) {
+                userInformationService.deleteByPrimaryKey(uid);
+                return BaseResponse.fail();
+            } else {
+                // 如果密码信息插入成功，说明整个注册流程成功完成，通过用户ID查询完整的用户信息对象（可能包含更多详细信息，比如后续添加的其他用户属性等），并将该用户信息存储到会话中，方便后续用户登录后的操作中可以直接获取用户信息。
+                userInformation = userInformationService.selectByPrimaryKey(uid);
+                request.getSession().setAttribute("userInformation", userInformation);
+                return BaseResponse.success();
+            }
+        }
+
+        // 如果用户基本信息插入数据库失败（前面result不为1的情况），直接返回注册失败的响应。
+        return BaseResponse.fail();
+    }
+}

src/main/java/com/wsk/controller/webSocket/WebSocketConfig.java

@@ -0,0 +1,29 @@
+package com.wsk.controller.webSocket;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
+import org.springframework.web.socket.config.annotation.EnableWebSocket;
+import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
+import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
+
+/**
+ * Created by wsk1103 on 2017/5/22.
+ */
+@Configuration
+@EnableWebMvc
+@EnableWebSocket
+public class WebSocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {
+    @Override
+    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
+        //WebIM WebSocket通道
+        registry.addHandler(chatWebSocketHandler(),"/webSocketIMServer");
+        registry.addHandler(chatWebSocketHandler(),"/sockjs/webSocketIMServer");
+        registry.addHandler(chatWebSocketHandler(), "/sockjs/webSocketIMServer").withSockJS();
+    }
+    @Bean
+    public ChatWebSocketHandler chatWebSocketHandler() {
+        return new ChatWebSocketHandler();
+    }
+}