项目重构02 Scala中继承Java类，Spring依赖注入，返回视图等等

最新推荐文章于 2023-01-16 21:32:29 发布

梦境迷离

最新推荐文章于 2023-01-16 21:32:29 发布

阅读量1.1k

点赞数

分类专栏： Scala

本文链接：https://blog.csdn.net/qq_34446485/article/details/80334153

版权

Scala 专栏收录该内容

38 篇文章 0 订阅

订阅专栏

1、首先是Java基类控制器

package cn.edu.jxnu.base.controller;

import java.io.IOException;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;

import cn.edu.jxnu.base.common.DateEditor;

/**
 * 主控制类
 * 
 * @author 梦境迷离
 * @time 2018年4月10日 下午5:12:23.
 * @version V1.0
 */
public class BaseController {
	private Logger log = LoggerFactory.getLogger(getClass());
	@Autowired
	protected HttpServletRequest request;

	@Autowired
	protected HttpServletResponse response;

	// 由@InitBinder表示的方法，可以对WebDataBinder对象进行初始化。WebDataBinder是DataBinder的子类，用于完成由表单到JavaBean属性的绑定。
	// @InitBinder方法不能有返回值，它必须名为void。
	// @InitBinder方法的参数通常是WebDataBinder，@InitBinder可以对WebDataBinder进行初始化。
	/**
	 * 由InitBinder表示的方法，可以对WebDataBinder对象进行初始化。WebDataBinder是DataBinder的子类，
	 * 用于完成由表单到JavaBean属性的绑定。 InitBinder方法不能有返回值，它必须名为void。
	 * InitBinder方法的参数通常是WebDataBinder，@InitBinder可以对WebDataBinder进行初始化。
	 * 
	 * @time 2018年4月10日 下午5:12:31.</br>
	 * @version V1.0</br>
	 * @param webDataBinder</br>
	 */
	@InitBinder
	protected void initBinder(WebDataBinder webDataBinder) {
		/**
		 * 一个用于trim 的 String类型的属性编辑器 如默认删除两边的空格，charsToDelete属性：可以设置为其他字符
		 * emptyAsNull属性：将一个空字符串转化为null值的选项。
		 */
		webDataBinder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
		webDataBinder.registerCustomEditor(Date.class, new DateEditor(true));
	}

	/**
	 * 带参重定向
	 *
	 * @param path
	 * @return String
	 */
	protected String redirect(String path) {
		return "redirect:" + path;
	}

	/**
	 * 不带参重定向
	 *
	 * @param response
	 * @param path
	 * @return String
	 */
	protected String redirect(HttpServletResponse response, String path) {
		try {
			response.sendRedirect(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取分页请求 并排序
	 * 
	 * @return PageRequest
	 */
	protected PageRequest getPageRequest() {
		int page = 1;
		int size = 10;
		Sort sort = null;
		try {
			String sortName = request.getParameter("sortName");
			String sortOrder = request.getParameter("sortOrder");
			if (StringUtils.isNoneBlank(sortName) && StringUtils.isNoneBlank(sortOrder)) {
				if (sortOrder.equalsIgnoreCase("desc")) {
					sort = new Sort(Direction.DESC, sortName);
				} else {
					sort = new Sort(Direction.ASC, sortName);
				}
			}

			page = Integer.parseInt(request.getParameter("pageNumber")) - 1;
			size = Integer.parseInt(request.getParameter("pageSize"));
			log.info("页数：" + page);
			log.info("容量：" + size);
		} catch (Exception e) {
			e.printStackTrace();
		}
		PageRequest pageRequest = new PageRequest(page, size, sort);
		return pageRequest;
	}

	/**
	 * 获取分页请求 带排序
	 * 
	 * @param sort
	 *            排序条件
	 * @return PageRequest
	 */
	protected PageRequest getPageRequest(Sort sort) {
		int page = 0;
		int size = 10;
		try {
			String sortName = request.getParameter("sortName");
			String sortOrder = request.getParameter("sortOrder");
			if (StringUtils.isNoneBlank(sortName) && StringUtils.isNoneBlank(sortOrder)) {
				if (sortOrder.equalsIgnoreCase("desc")) {
					sort.and(new Sort(Direction.DESC, sortName));
				} else {
					sort.and(new Sort(Direction.ASC, sortName));
				}
			}
			page = Integer.parseInt(request.getParameter("pageNumber")) - 1;
			size = Integer.parseInt(request.getParameter("pageSize"));
		} catch (Exception e) {
			e.printStackTrace();
		}
		PageRequest pageRequest = new PageRequest(page, size, sort);
		return pageRequest;
	}

}

2、Java方式继承基类

package cn.edu.jxnu.base.controller.admin;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
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 cn.edu.jxnu.base.common.Constats;
import cn.edu.jxnu.base.common.JsonResult;
import cn.edu.jxnu.base.controller.BaseController;
import cn.edu.jxnu.base.entity.BorrowBook;
import cn.edu.jxnu.base.entity.User;
import cn.edu.jxnu.base.service.IBorrowBookService;
import cn.edu.jxnu.base.service.IUserService;
import cn.edu.jxnu.base.service.specification.SimpleSpecificationBuilder;
import cn.edu.jxnu.base.service.specification.SpecificationOperator.Operator;
import lombok.extern.slf4j.Slf4j;

/**
 * 主页控制层，公共控制层，不需要权限
 * 
 * @author 梦境迷离
 * @time 2018年4月10日 下午5:14:11.
 * @version V1.0
 */
@Controller
@Slf4j
public class AdminIndexController extends BaseController {

	@Autowired
	private IUserService userService;
	@Autowired
	private IBorrowBookService borrowBookService;

	/**
	 * 登陆
	 * 
	 * @time 2018年4月10日 下午5:14:23.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/", "/admin/index" })
	public String index() {
		log.info("登录界面");
		return "admin/index";
	}

	/**
	 * 首页查询
	 * 
	 * @time 2018年4月10日 下午5:14:38.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/welcome" })
	public String welcome() {

		return "admin/welcome";
	}

	/**
	 * 用户个人信息页面
	 * 
	 * @time 2018年4月10日 下午5:15:22.
	 * @version V1.0
	 * @param map
	 * @param response
	 * @return String
	 * @throws TimeoutException
	 */
	@RequestMapping(value = { "/admin/info" })
	public String info(ModelMap map, HttpServletResponse response, Integer id) throws TimeoutException {
		log.info("用户id:" + id);
		User u = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + id);
		if (u != null) {
			/**
			 * 没有过期
			 */
			map.put("user", u);
		} else {
			try {
				/**
				 * 已经过期
				 */
				throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
			} catch (Exception e) {
				map.put("message", e.getMessage());
			} finally {
				/**
				 * 重定向到登录页面
				 */
				redirect(response, "/admin/login");
			}
		}
		return "admin/info";
	}

	/**
	 * 用户已借阅书籍页面
	 * 
	 * @time 2018年4月10日 下午5:15:43.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/borrow" })
	public String borrow() {
		// 给页面传入必须的已借书籍
		return "admin/borrow";
	}

	/**
	 * 注册，不能拦截
	 * 
	 * @time 2018年4月10日 下午5:16:03.
	 * @version V1.0
	 * @param map
	 * @return String
	 */
	@RequestMapping(value = { "/assets/regist" })
	public String regist(ModelMap map) {
		/**
		 * 携带一个map,用于添加注册表单数据
		 */
		return "admin/regist/form";
	}

	/**
	 * 登录页面的注册专用
	 * 
	 * @time 2018年4月10日 下午5:16:27.
	 * @version V1.0
	 * @param user
	 * @param map
	 * @return JsonResult
	 */
	@RequestMapping(value = { "/assets/edit" }, method = RequestMethod.POST)
	@ResponseBody
	public JsonResult registAdd(User user, ModelMap map) {
		try {
			log.info("regist:" + user.toString());
			userService.saveOrUpdate(user);
		} catch (Exception e) {
			return JsonResult.failure(e.getMessage());
		}
		return JsonResult.success("注册成功,3秒后自动回到登录页面");
	}

	/**
	 * 验证用户名【学号】是否已经被注册,委托给用户控制层
	 * 
	 * @time 2018年4月10日 下午5:16:41.
	 * @version V1.0
	 * @param userCode
	 * @param request
	 * @param response
	 * @throws ServletException
	 * @throws IOException
	 */
	@RequestMapping(value = { "/assets/isAvailable" }, method = RequestMethod.GET)
	public void isAvailableUse(String userCode, HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		log.info("前台验证账户可用");
		request.getRequestDispatcher("/admin/user/isAvailable/" + userCode).forward(request, response);
	}

	/**
	 * 所有人均可修改的个人信息
	 * 
	 * @time 2018年4月10日 下午5:16:55.
	 * @version V1.0
	 * @param user
	 * @param map
	 * @return JsonResult
	 * @throws ServletException
	 * @throws IOException
	 */
	@ResponseBody
	@RequestMapping(value = { "/assets/update" }, method = RequestMethod.POST)
	public JsonResult allCanUpdate(User user, ModelMap map) throws ServletException, IOException {
		log.info("user:/assets/update:" + user.toString());
		try {
			User u = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + user.getId());
			if (u == null) {
				// 已经过期
				try {
					throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
				} catch (TimeoutException e) {
					map.put("message", e.getMessage());
				} finally {
					// 重定向到登录页面
					redirect(response, "/admin/logout");
				}
			}
			userService.saveOrUpdate(user);
			// 更新session
			SecurityUtils.getSubject().getSession().setAttribute(Constats.CURRENTUSER + user.getId(), user);
		} catch (Exception e) {
			return JsonResult.failure(e.getMessage());
		}

		return JsonResult.success();
	}

	/**
	 * 查询用户已借阅的图书 每个人均可操作，不需要授权。超期不可自主归还
	 * 
	 * @time 2018年4月10日 下午5:17:45.
	 * @version V1.0
	 * @param map
	 * @param uCode
	 *            操作人
	 * @return Page 类型 BorrowBook
	 */
	@RequestMapping(value = { "/assets/borrowList" })
	@ResponseBody
	public Page<BorrowBook> borrowList(ModelMap map, @RequestParam(value = "uCode") String uCode) {
		User u = userService.findByUserCode(uCode);
		SimpleSpecificationBuilder<BorrowBook> builder = new SimpleSpecificationBuilder<BorrowBook>();
		String bookName = request.getParameter("inputBookName");
		String bookAuthor = request.getParameter("inputAuthor");
		String bookPress = request.getParameter("inputPublication");
		if (StringUtils.isNotBlank(bookName)) {
			builder.add("bookName", Operator.likeAll.name(), bookName);
		}
		if (StringUtils.isNotBlank(bookAuthor)) {
			builder.add("bookAuthor", Operator.likeAll.name(), bookAuthor);

		}
		if (StringUtils.isNotBlank(bookPress)) {
			builder.add("bookPress", Operator.likeAll.name(), bookPress);
		}
		User user = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + u.getId());
		if (user.getId() != null) {
			builder.add("userId", Operator.eq.name(), user.getId());
		} else {
			// 已经过期
			try {
				throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
			} catch (TimeoutException e) {
				map.put("message", e.getMessage());
			} finally {
				// 重定向到登录页面
				redirect(response, "/admin/logout");
			}
		}
		// 得到已借阅的书籍
		Page<BorrowBook> page = borrowBookService.findAll(builder.generateSpecification(), getPageRequest());
		return page;
	}

}

3、Scala方式继承

package cn.edu.jxnu.base.controller.admin

import cn.edu.jxnu.base.controller.BaseController
import org.springframework.beans.factory.annotation.Autowired
import cn.edu.jxnu.base.service.IUserService
import cn.edu.jxnu.base.service.IBorrowBookService
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.ui.Model
import org.springframework.web.servlet.ModelAndView
import org.springframework.stereotype.Controller
import org.springframework.ui.ModelMap
import javax.servlet.http.HttpServletResponse
import lombok.extern.slf4j.Slf4j
import org.apache.shiro.SecurityUtils
import cn.edu.jxnu.base.common.Constats
import java.util.concurrent.TimeoutException
import cn.edu.jxnu.base.entity.User
import cn.edu.jxnu.base.common.JsonResult
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.ResponseBody
import org.springframework.web.bind.annotation.GetMapping
import javax.servlet.http.HttpServletRequest
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.data.domain.Page
import cn.edu.jxnu.base.entity.BorrowBook
import cn.edu.jxnu.base.service.specification.SimpleSpecificationBuilder
import org.apache.commons.lang3.StringUtils
import cn.edu.jxnu.base.service.specification.SpecificationOperator.Operator
import org.springframework.beans.factory.annotation.Required

/**
 * @author 梦境迷离.
 * @time 2018年5月15日
 * @version v2.0
 */
@Controller
class AdminIndexScala @Autowired() (val userService: IUserService, val borrowBookService: IBorrowBookService)
    extends BaseController {

    /**
     * 以下没有显示声明返回类型，所以默认返回最后的元素数据类型
     */
    //登陆
    @RequestMapping(value = { Array("/admin/", "/admin/index") })
    def index(model: Model) = {
        "admin/index"
    }

    //首页
    @RequestMapping(value = { Array("/admin/welcome") })
    def welcome() = {
        "admin/welcome"
    }

    //用户个人信息
    @RequestMapping(value = { Array("/admin/info") })
    def info(map: ModelMap, response: HttpServletResponse, @RequestParam(value    = "id", required = false) id: Int) = {

        println("用户id:" + id)
        val u = SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + id)
        if (u != null) {
            map.put("user", u)
        } else {
            try {
                throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
            } catch {
                case e: Exception => map.put("message", e.getMessage())
            } finally {
                redirect(response, "/admin/login")
            }
        }
        "admin/info"
    }

    //书籍借阅页面
    @RequestMapping(value = { Array("/admin/borrow") })
    def borrow() = {
        "admin/borrow"
    }

    //注册，不能拦截
    @RequestMapping(value = { Array("/assets/regist") })
    def regist(map: ModelMap) = {
        "admin/regist/form"
    }

    //登录页面的注册专用
    @ResponseBody
    @PostMapping(value = { Array("/assets/edit") })
    def registAdd(user: User, map: ModelMap): JsonResult = {
        try {

            println("regist:" + user.toString())
            userService.saveOrUpdate(user)
        } catch {
            case e: Exception => return JsonResult.failure(e.getMessage())
        }
        return JsonResult.success("注册成功,3秒后自动回到登录页面")
    }

    //验证用户名【学号】是否已经被注册,委托给用户控制层
    @GetMapping(value = { Array("/assets/isAvailable") })
    def isAvailableUse(userCode: String, request: HttpServletRequest, response: HttpServletResponse) = {
        println("前台验证账户可用")
        request.getRequestDispatcher("/admin/user/isAvailable/" + userCode).forward(request, response)
    }

    //所有人均可修改的个人信息
    @ResponseBody
    @PostMapping(value = { Array("/assets/update") })
    def allCanUpdate(user: User, map: ModelMap): JsonResult = {
        println("user:/assets/update:" + user.toString())
        try {
            val u = SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + user.getId())
            if (u == null) {
                // 已经过期
                try {
                    throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
                } catch {
                    case e: TimeoutException => map.put("message", e.getMessage())
                } finally {
                    // 重定向到登录页面
                    Thread.sleep(1000)
                    redirect(response, "/admin/logout")
                }
            }
            userService.saveOrUpdate(user)
            // 更新session
            SecurityUtils.getSubject().getSession().setAttribute(Constats.CURRENTUSER + user.getId(), user)
        } catch {
            case e: Exception => return JsonResult.failure(e.getMessage())
        }

        JsonResult.success("修改成功，下次登陆生效")
    }

    //查询用户已借阅的图书 每个人均可操作，不需要授权。超期不可自主归还
    @ResponseBody
    @RequestMapping(value = { Array("/assets/borrowList") })
    def borrowList(map: ModelMap, @RequestParam(value = "uCode") uCode: String): Page[BorrowBook] = {
        val u = userService.findByUserCode(uCode)
        val builder = new SimpleSpecificationBuilder[BorrowBook]()
        val bookName = request.getParameter("inputBookName")
        val bookAuthor = request.getParameter("inputAuthor")
        val bookPress = request.getParameter("inputPublication")
        if (StringUtils.isNotBlank(bookName)) {
            builder.add("bookName", Operator.likeAll.name(), bookName)
        }
        if (StringUtils.isNotBlank(bookAuthor)) {
            builder.add("bookAuthor", Operator.likeAll.name(), bookAuthor)

        }
        if (StringUtils.isNotBlank(bookPress)) {
            builder.add("bookPress", Operator.likeAll.name(), bookPress)
        }
        val user: User = SecurityUtils.getSubject().getSession()
            .getAttribute(Constats.CURRENTUSER + u.getId()).asInstanceOf[User]
        if (user.getId() != null) {
            builder.add("userId", Operator.eq.name(), user.getId())
        } else {
            try {
                throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
            } catch {
                case e: TimeoutException => map.put("message", e.getMessage())
            } finally {
                redirect(response, "/admin/logout")
            }
        }
        val page = borrowBookService.findAll(builder.generateSpecification(), getPageRequest())
        return page
    }
}

刚刚从Java转Scala需要注意的点还是很多的，总结目前遇到的

1、采用主构造注入SpringBean，bean定义val【常量】

2、继承与实现均使用extends【实际没有实现一说，接口可以使用with继承多个，叫混合更符合】

3、类等等允许有构造方法，甚至值类型也可以有一个参数的构造，构造参数一旦被使用，就自动升格为类的字段/属性

4、Scala默认public，private比Java更严格，不许嵌套类的父类访问嵌套类

5、def定义方法/过程，无返回值叫Unit是可以省略的，同时=也可以省略，叫过程

6、return与分号可以省略

7、集合默认是不可变集合

8、异常使用模式匹配 case

9、泛型使用 [] 而不是<>

10、Scala中一切操作均函数，甚至是 ++ +=这种，这++不是i++这种的，Scala是不存在++i 、i++、 --i、 i--

11、Scala没有基本类型，对数值可以进行方法调用，如+= 常见的 & %