实验目的

利用Spring技术实现【实验二】中的校友信息网站。要求采用MVC框架，同时要求加入面向切面的编程。

构建一个用户记录的切面

实验内容

• 对于所有的登录操作，记录各各次登录的时间、用户，存入UserLog表格中。
• 对于所有的登出操作，记录各各次登录的时间、用户，存入UserLog表格中。
• 对于用户新的输入操作，记录其表单值，存入InsertLog表格中。

注意：只记录成功登陆和成功登出的信息（比如用户账号密码错误没有成功登入，不做记录；用户还没有登入便调用登出的接口，也不做记录）。

实验过程

• 搭建springboot+mybatis web开发框架，利用generator插件自动生成mapper和entity
• 实现/login，/logout接口，用于：
  1.验证是否成功登陆或成功登出，将此信息保存至response参数的status里，用于aop获取；
  （利用回调，实现了代理类和被代理类的简单通信）
  2.将用户信息保存在session中，以便记录用户登录状态。
• 实现loginAOP，logoutAOP，用于记录登录登出的信息。
• 实现insertAOP，用于记录用户Insert的信息。
• 实现登陆拦截器，用于拦截所有除登录的请求，如果用户未登录，则跳转到登录页面，同时将登录前访问的url保存至session中，以便登录成功后重新跳转到之前的页面。

搭建springboot+mybatis web开发框架

参考https://blog.csdn.net/weixin_42685022/article/details/82215893

实现/login，/logout接口

    @Autowired
    private AdminMapper adminMapper;

    @RequestMapping(value = "/login", method = RequestMethod.POST)
    public void login(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        HttpSession session = httpServletRequest.getSession();
        //如果已登录则自动退出登录
        if (session.getAttribute("userDetail") != null) {
            httpServletResponse.sendRedirect("/logout");
        }
        //验证用户是否成功登录
        else {
            String username = httpServletRequest.getParameter("username");
            String password = httpServletRequest.getParameter("password");
            AdminDetail adminDetail = adminMapper.getAdminDetail(username, password);
            if (adminDetail != null) {
                System.out.println(adminDetail.getId() + ":" + "login");
                adminDetail.setLogin(true);
                session = httpServletRequest.getSession();
                session.setAttribute("userDetail", adminDetail);
                //登录成功，将response中的status设置为200，以便aop获得此信息
                httpServletResponse.setStatus(200);
            } else {
                //登录成功，将response中的status设置为403，以便aop获得此信息
                httpServletResponse.setStatus(403);
            }
        }
    }

    @RequestMapping(value = "/logout", method = RequestMethod.GET)
    public void logout(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        HttpSession session = httpServletRequest.getSession();
        AdminDetail adminDetail = (AdminDetail) session.getAttribute("userDetail");
        //验证用户是否还未登录就登出
        if (adminDetail != null) {
            System.out.println(adminDetail.getId() + ":" + "logout");
            //登出成功，将response中的status设置为200，以便aop获得此信息
            httpServletResponse.setStatus(200);
        } else {
            //登录失败，将response中的status设置为403，以便aop获得此信息
            httpServletResponse.setStatus(403);
        }
    }

实现loginAOP，logoutAOP

 @Autowired
    private UserlogMapper userlogMapper;

    @Pointcut("execution(public * com.bao.schoolfellow.controller.Login.login(..))")
    public void LoginPoint() {
    }

    @Pointcut("execution(public * com.bao.schoolfellow.controller.Login.logout(..))")
    public void LogoutPoint() {
    }


    @Around("LoginPoint()")
    public Object doLoginAdvice(ProceedingJoinPoint proceedingJoinPoint) throws java.lang.Throwable {
        //先执行/login接口的方法
        proceedingJoinPoint.proceed();
        //通过反射机制获取/login方法response参数的status信息
        int status = (Integer) HttpServletResponse.class.getMethod("getStatus").invoke(proceedingJoinPoint.getArgs()[1]);

        //登录成功，记录信息并跳转到主页或登录前的页面
        if (status == 200) {
            //通过反射机制获取/login方法resquest参数的session信息
            HttpSession session = (HttpSession) HttpServletRequest.class.getMethod("getSession").invoke(proceedingJoinPoint.getArgs()[0]);
            //通过session获取用户信息，并记录登录信息至数据库
            Userlog userlog = new Userlog();
            userlog.setTime(new Date());
            userlog.setType("login");
            AdminDetail adminDetail = (AdminDetail) (session.getAttribute("userDetail"));
            userlog.setUserId(adminDetail.getId());
            userlogMapper.insertSelective(userlog);
            System.out.println("login success:" + "record");

            //获取用户登录前访问的url信息，如果有，则跳转；如果没有，跳转至主页
            String preURL=(String) session.getAttribute("preURL");
            if(preURL!=null){
                System.out.println("preURL"+preURL);
                HttpServletResponse.class.getMethod("sendRedirect", String.class).invoke(proceedingJoinPoint.getArgs()[1], session.getAttribute("preURL"));
            }
            else {
                HttpServletResponse.class.getMethod("sendRedirect", String.class).invoke(proceedingJoinPoint.getArgs()[1], "/index.html");
            }

        }
        //登录失败，跳转到错误页面
        else if (status == 403) {
            System.out.println("login fail:" + "not record!");
            HttpServletResponse.class.getMethod("sendRedirect", String.class).invoke(proceedingJoinPoint.getArgs()[1], "/login_error.html");
        }
        return null;
    }

    //logoutAOP原理同上
    @Around("LogoutPoint()")
    public Object doLogoutAdvice(ProceedingJoinPoint proceedingJoinPoint) throws java.lang.Throwable {
        proceedingJoinPoint.proceed();
        int status = (Integer) HttpServletResponse.class.getMethod("getStatus").invoke(proceedingJoinPoint.getArgs()[1]);
        if (status == 200) {
            HttpSession session = (HttpSession) HttpServletRequest.class.getMethod("getSession").invoke(proceedingJoinPoint.getArgs()[0]);
            Userlog userlog = new Userlog();
            userlog.setTime(new Date());
            userlog.setType("logout");
            AdminDetail adminDetail = (AdminDetail) (session.getAttribute("userDetail"));
            userlog.setUserId(adminDetail.getId());
            userlogMapper.insertSelective(userlog);
            session.removeAttribute("userDetail");
            System.out.println("logout success:" + "record");
        } else if (status == 403) {
            System.out.println("illegal operate:" + "not login but logout！");
        }
        HttpServletResponse.class.getMethod("sendRedirect", String.class).invoke(proceedingJoinPoint.getArgs()[1], "/login.html");
        return null;
    }

实现insertAOP

这里我想用Around通知同时实现两个切面：
1.对于所有的除GET方法的请求，操作成功后让returnAOP返回操作成功的状态码。
2.对于/insert接口，操作成功后记录用户本次操作的信息。

先贴下代码：
InsertController

    @Autowired
    private SchoolfellowMapper schoolfellowMapper;

    @RequestMapping(method = RequestMethod.POST)
    //注意：这里返回值不能写void，这样即使AOP返回了返回值，服务器也不会返回给客户端
    public Object add(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse, @RequestBody Schoolfellow schoolfellow) {
        System.out.println("insert!!!");
        schoolfellowMapper.insertSelective(schoolfellow);
        return null;
    }

AOP

    @Autowired
    private InsertlogMapper insertlogMapper;

    @Pointcut("execution(public * com.bao.schoolfellow.controller.Operate.*(..))")
    public void ReturnStatusPoint() {
    }

    @Pointcut("execution(public * com.bao.schoolfellow.controller.Operate.add(..))")
    public void InsertPoint() {
    }

    @Around("ReturnStatusPoint()")
    public Object returnStatus(ProceedingJoinPoint proceedingJoinPoint) throws java.lang.Throwable{
        System.out.println("changeReturnStart!");
        //先调用原方法
        Object object=proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        Method invokeMethod=null;
        //通过反射获取被调用的接口的方法信息
        for(Method method:proceedingJoinPoint.getTarget().getClass().getMethods()){
            if(method.getName().equals(proceedingJoinPoint.getSignature().getName())){
                invokeMethod=method;
                break;
            }
        }
        //获取此方法的注解信息
        for(Annotation annotation:invokeMethod.getDeclaredAnnotations()){
            //如果它不是GET的方法，则返回操作成功的状态status
            if(annotation.annotationType().equals(RequestMapping.class)){
                if(((RequestMapping)annotation).method()[0]!=RequestMethod.GET){
                    Map<String,String> status=new HashMap<>();
                    status.put("status",String.valueOf(HttpServletResponse.class.getMethod("getStatus").invoke(proceedingJoinPoint.getArgs()[1])));
                    System.out.println("changeReturnOver!");
                    return status;
                }
            }
        }
        //如果不是，返回原方法的返回值
        return object;
    }

    @Around("InsertPoint()")
    public Object saveInsert(ProceedingJoinPoint proceedingJoinPoint) throws java.lang.Throwable {
        System.out.println("saveInsertStart!!");
        //先调用原方法
        Object object=proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        //记录用户的操作信息至数据库
        HttpSession session = (HttpSession) HttpServletRequest.class.getMethod("getSession").invoke(proceedingJoinPoint.getArgs()[0]);
        AdminDetail adminDetail=(AdminDetail) session.getAttribute("userDetail");
        Insertlog insertlog=new Insertlog();
        insertlog.setContent(proceedingJoinPoint.getArgs()[2].toString());
        insertlog.setUserId(adminDetail.getId());
        insertlog.setTime(new Date());
        insertlogMapper.insertSelective(insertlog);
        System.out.println("saveInsertOver!!");
        return object;
    }

思考：这里使用两个Around调用了两次proceedingJoinPoint.proceed，会不会原方法也调用了两次呢？两次调用都修改了原方法的返回值，最终取谁的返回值呢？

如果搞清了AOP的原理——动态代理，这个问题就解决了：
这就是代理模式的神奇之处，可以嵌套代理，但是被代理类只被调用一次。
假设原方法的类为class，切面1的代理类proxy1，切面2的代理类为proxy2。事实上，SpringAOP使proxy2代理了class，proxy1代理了proxy2。调用的入口在proxy2，返回值的决定权也在proxy2，即最外层的代理类。（代理类的代理顺序可以进行配置）
打个比方：
spring aop就是一个同心圆，要执行的方法为圆心，proxy2相应的方法为圆AOP2，proxy1相应的方法为圆AOP1

image.png

理解并读懂了代码，会发现成功执行一次insert操作会输出如下结果：

image.png

实现登陆拦截器

拦截器和AOP一样采用了动态代理的方式，可以设置指定的url被拦截或不被拦截，配置方便，很好用。

@Component
public class LoginInterceptor implements HandlerInterceptor {
    public String getURL(HttpServletRequest httpServletRequest){
        StringBuffer url=new StringBuffer(httpServletRequest.getRequestURL());
        Map map=httpServletRequest.getParameterMap();
        if(!map.isEmpty()){
            url.append("?");
            for(Object key:map.keySet()){
                url.append(key+"="+map.get(key)+"&");
            }
            url.substring(0,url.length()-1);
        }
        return url.toString();
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取request的URL（包括request参数），保存至session中
        HttpSession session=request.getSession();
        AdminDetail adminDetail=(AdminDetail) session.getAttribute("userDetail");
        session.setAttribute("preURL",getURL(request));

        //验证用户是否登录，如果没有则跳转到登录页面
        if(adminDetail==null){
            response.sendRedirect("/login.html");
            return false;
        }
        else {
            return true;
        }
    }
}

构建一个用户记录的切面

实验内容

• 对于所有的Alumni表的查询操作，验证用户已经登录；如果用户没有登录，先导航到登录页面；
• 对于所有的Alumni表的更新（更新和删除）操作，在Read权限的基础上验证用户具有Update的权限。如果没有，该操作取消，并导航到错误页面。
• 对于所有的Alumni表的汇总和下载操作，验证用户具有Aggregate权限；如果没有，该操作取消，并导航到错误页面。

实验过程（在原项目的基础上）

• 实现登陆拦截器，用于拦截所有除登录的请求，如果用户未登录，则跳转到登录页面，同时将登录前访问的url保存至session中，以便登录成功后重新跳转到之前的页面。
• 实现PermissionMetadata组件，用于加载所有需要验证的URL的信息。
• 实现权限验证拦截器，用于拦截除登录登出以及获取当前用户信息外的所有请求，先查看此url是否在PermissionMetadata中，如果不在，则放行；如果在，根据sesssion中保存的用户的信息查看用户是否具有此权限，如果有，则放行。

实现PermissionMetadata组件

@Component
public class PermissionMetadata {
    @Autowired
    private AdminMapper adminMapper;

    private List<String> allPermissions;

    public List<String> getAllPermissions() {
        if(allPermissions==null){
            allPermissions=adminMapper.selectAllPermission();
        }
        return allPermissions;
    }
}

实现权限验证拦截器

@Component
public class PermissionInerceptor implements HandlerInterceptor {
    @Autowired
    private AdminMapper adminMapper;

    @Autowired
    private PermissionMetadata permissionMetadata;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        AdminDetail adminDetail=(AdminDetail) request.getSession().getAttribute("userDetail");

        //将当前访问的URL处理成method/URI的形式
        String requestURI=request.getRequestURI();
        String url=request.getMethod();
        int count=0;
        for(String subPath:requestURI.split("/")){
            if(count%2!=0){
                url+="/"+subPath;
            }
            count++;
        }
        System.out.println("url:"+url);

        //查看此权限是否在permissionMetada中，如果不在则放行
        boolean isExist=false;
        for(String permission:permissionMetadata.getAllPermissions()){
            if(url.equals(permission)){
                isExist=true;
            }
        }
        if(!isExist){
            System.out.println("Permission not exist so pass");
            return true;
        }

        //查看用户是否具有此权限，如果有则放行
        for(String permission:adminDetail.getPermissions()){
            if(permission.equals(url)){
                System.out.println("You have permission:"+url);
                return true;
            }
        }
        System.out.println("You have no permission:"+url);
        response.sendRedirect("/login_error.html");
        return false;

    }
}