精华内容
下载资源
问答
  • 2021-10-12 16:31:06

    登录校验功能是每个项目都必须的功能,常见的登陆校验方式有JWT和session.

    JWT的优点是无状态,缺点很多,明文传输,无法提前终止,字段过长。所以我们采用JWT加session的方式。JWT中只存放随机生成的token,再通过token去redis中找用户信息。当然也可以直接传token,就是安全性比放JWT中差一点。

    第一步,登录完成随机生成token,把用户信息放入redis中

        public String saveUserToken(Integer userId, Integer platform, String ip,
                                    Boolean autoLogin, Boolean checkUrl) {
            UserToken userToken = new UserToken();
            String token = UUIDUtils.getUUID();
            userToken.setToken(token);
            userToken.setUserId(userId);
            userToken.setLoginTime(LocalDateTime.now());
            userToken.setIp(ip);
            userToken.setPlatform(platform);
            userToken.setAutoLogin(autoLogin);
            userToken.setCheckUrl(checkUrl);
            //保存token与用户对应关系,便于后面自动登录
            save(userToken);
            User user = userService.getById(userId);
            //获取用户中不常变动的信息放入redis,节省内存
            UserCacheBean userBean = Convert.convert(UserCacheBean.class, user);
            userBean.setCheckUrl(checkUrl);
            userBean.setToken(token);
            //保存用户信息到redis
            saveUserInSession(userBean);
            //生成JWT
            JwtBean jwtBean = new JwtBean();
            jwtBean.setToken(token);
            token = JWTUtil.createToken(BeanUtil.beanToMap(jwtBean), systemConfig.getJwtPassword().getBytes());
            return token;
        }

    第二步,网关校验

    首先,新建一个过滤器来过滤所有请求

    @Component
    public class SecurityFilter implements GlobalFilter, Ordered {

    接着,我们要排除不需要校验的url,比如登录就不需要校验,通常我们会把不需要校验的路径放入public路径下,比如/basic/public/login,就这样配置/basic/public/**,然后使用AntPathMatcher来校验

        private AntPathMatcher pathMatcher = new AntPathMatcher();
    
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            String url = exchange.getRequest().getURI().getPath();
            //对于排除的url放行
            String excludePath = systemConfig.getExcludePath();
            if (StringUtils.isNotEmpty(excludePath)) {
                String[] excludePaths = excludePath.split(",");
                for (String pattern : excludePaths) {
                    if (pathMatcher.match(pattern, url)) {
                        return chain.filter(exchange);
                    }
                }
            }

    然后从头字段中取出jwt

            //从头字段或者请求参数中取出token
            String token = exchange.getRequest().getHeaders().getFirst(ConstantKey.TOKEN_HEADER);
            if (StringUtils.isEmpty(token)) {
                token = exchange.getRequest().getQueryParams().getFirst(ConstantKey.TOKEN_HEADER);
            }

    接下来校验JWT的有效性

            ServerHttpResponse resp = exchange.getResponse();
            if (StringUtils.isEmpty(token)) {
                return printMsg(Result.UNAUTHORIZED, resp, "请登录");
            }
            //校验jwt签名有效性
            if (!JWTUtil.verify(token, systemConfig.getJwtPassword().getBytes())) {
                return printMsg(Result.UNAUTHORIZED, resp, "token签名错误");
            }

    如果JWT没问题则从中取出token,然后去redis中找用户信息

            //解析jwt取出标识redis的token
            final JWT jwt = JWTUtil.parseToken(token);
            JwtBean jwtBean = JsonUtils.parse(jwt.getPayload().toString(), JwtBean.class);
            token = jwtBean.getToken();
            //从session中取user
            UserCacheBean simpleUser = redisSessionService.getUser(token);
            if (simpleUser == null) {
                //自动登录
                Result<UserCacheBean> result = basicPublicService.autoLogin(token);
                if (result.getData() == null) {
                    return printMsg(Result.UNAUTHORIZED, resp, "token已过期");
                }
                simpleUser = result.getData();
            }

    如果正常找到用户信息,则把用户信息放入token,这样微服务就能直接使用了

            String authUserVo = JsonUtils.serialize(simpleUser);
            ServerHttpRequest newHttpRequest = FilterRequestResponseUtil.getNewHttpRequest(exchange.getRequest()
                    , FilterRequestResponseUtil.getNewHttpHeadersConsumer(ConstantKey.TOKEN_HEADER, authUserVo));
            return chain.filter(exchange.mutate()
                    .request(newHttpRequest).build());

    这是操作gateway输入输出的工具类

    public final class FilterRequestResponseUtil {
    
        public static ServerHttpRequest getNewHttpRequest(ServerHttpRequest httpRequest
                , Consumer<HttpHeaders> httpHeadersConsumer, Flux<DataBuffer> dataBufferFlux) {
            ServerHttpRequest newHttpRequest = httpRequest.mutate()
                    .headers(httpHeadersConsumer)
                    .build();
            return new ServerHttpRequestDecorator(newHttpRequest) {
                @Override
                public Flux<DataBuffer> getBody() {
                    return dataBufferFlux;
                }
            };
        }
    
        public static ServerHttpRequest getNewHttpRequest(ServerHttpRequest httpRequest
                , Consumer<HttpHeaders> httpHeadersConsumer) {
            return httpRequest.mutate()
                    .headers(httpHeadersConsumer)
                    .build();
        }
    
        public static Consumer<HttpHeaders> getNewHttpHeadersConsumer(String headerName, String headerVal) {
            Consumer<HttpHeaders> consumer = headers -> {
                headers.set(headerName, headerVal);
            };
            return consumer;
        }
    
        /**
         * 认证错误输出
         *
         * @param resp    响应对象
         * @param message 错误信息
         * @return
         */
        public static Mono<Void> printMsg(int status, ServerHttpResponse resp, String message) {
            resp.setStatusCode(HttpStatus.OK);
            resp.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
            Result result = new Result();
            result.setStatus(status);
            result.setMessage(message);
            String returnStr = JsonUtils.serialize(result);
            DataBuffer buffer = resp.bufferFactory().wrap(returnStr.getBytes(StandardCharsets.UTF_8));
            return resp.writeWith(Flux.just(buffer));
        }
    }

    第三步,微服务校验

    微服务的校验就比较简单了,由于微服务是处于内网的,可以明文传输,拿到用户信息放入ThreadLocal直接用就行了

    public class SecurityInterceptor implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
            String token = request.getHeader(ConstantKey.TOKEN_HEADER);
            if (StringUtils.isEmpty(token)) {
                token = request.getParameter(ConstantKey.TOKEN_HEADER);
            }
            if (StringUtils.isEmpty(token)) {
                AjaxUtils.printMsg(Result.UNAUTHORIZED, response, "请登录");
                return false;
            }
            //从头字段中取user
            UserCacheBean simpleUser = JsonUtils.parse(token, UserCacheBean.class);
            if (simpleUser == null || simpleUser.getId() == null) {
                AjaxUtils.printMsg(Result.UNAUTHORIZED, response, "无效的token");
                return false;
            }
            UserThreadLocal.set(simpleUser);
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            UserThreadLocal.remove();
        }
    }

    更多相关内容
  • 在做找房微服务的时候,一般只有登录的用户能够预约房源操作,或者修改资料等密码操作,管理员也需要登录的情况下才能对房源进行管理上架、添加等操作。 假如我们没一个方法都分别对其权限鉴定,用户判断是否登录,...
  • 主要为大家详细介绍了Java struts2 validate用户登录校验功能实现的具体步骤,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了SpringBoot框架集成token实现登录校验功能,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 本文给大家介绍使用Bootstrap新制作的一个登录框,带验证码,带校验,非常不错,具有参考借鉴价值,感兴趣的朋友可以参考下
  • 登录校验的实现

    千次阅读 2018-11-07 21:53:44
    在前端领域,一个避不开的话题就是登录验证的实现,本文将通过3种方式来实现登录验证: 一 php+js实现登录验证 开发时,前后端分离提供的接口如下: ## 用户登录的接口 type : post url : api/doLogin.php data : ...

    在前端领域,一个避不开的话题就是登录验证的实现,本文将通过3种方式来实现登录验证:

    一 php+js实现登录验证

    开发时,前后端分离提供的接口如下:

    ## 用户登录的接口
    type : post
    url : api/doLogin.php
    data : 
        password  
        email
    响应体: ok  或则 fail
    
    
    ## 判断登录成功的接口
    type : get 
    url : api/checkLogin.php
    data : 不传
    响应体: ok  或则 fail
    
    

    实现登录校验的整体思路:
    在这里插入图片描述

    现在书写接口定义:

    1.1 判断用户登录的接口

    <?php
    
        //判断是否登录,如果没有登录,那么打回登录页面
        //开启session
        session_start();
        //获取
        // $userInfo = $_SESSION['userInfo'];
    
        if(isset($_SESSION['userInfo'])) {
            echo "ok";
        }else {
            echo "fail";
        }
    
    ?>
    

    1.2 用户登录的接口

    <?php
    	//封装的操作数据库的方法
        include_once "./tools/executeSql.php";
    
        //获取传递过来数据
        $password = $_POST['password'];
        $email = $_POST['email'];
    
        // echo $password;
        // echo $email;
        
        //查库进行判断
        $sql = " select *from users where email = '$email' and password = '$password'  ";
        $data = excute_select($sql); //返回的数据是一个二维数组
    
        // var_dump($data);
        // return;
        //判断
        if(count($data)) {
    
            //将用户的信息存入cookie里面不安全,存入到seesion里面
            //开启session
            session_start();
            $_SESSION['userInfo'] = $data[0]; //$data[0]包含了用户的所有信息
    
            echo "ok";
        }else {
            echo "fail";
        }
    ?>
    

    1.3 前端页面实现登录校验的代码:

    <script>
        //程序一加载就执行这个语句,判断用户有没有登录
        var xhr = new XMLHttpRequest();
        //设置请求行
        xhr.open('get','api/checkLogin.php');
        //发送请求
        xhr.send();
        //监听响应
        xhr.onload = function(){
          // console.log(xhr.responseText);
          if(xhr.responseText.trim() != "ok") {
      
              //打回登录页
              location = "login.html";
          }
        }    
    </script>
    

    在前台的所有需要登录校验的页面里,加上这样一段代码,判断用户是否已经登录了,这里需要注意的是:这段代码应该放在那里?

    因为,页面一加载就需要判断是否登录过,所以需要这样放置代码:

    <!DOCTYPE html>
    <html lang="zh-CN">
    	<!--放置用户是否登录的代码-->
        <script>
           //判断用户是否登录 
         </script>
    <head>
    

    因为页面的解析是从上到下的,只有在页面一开始就判断用户是否登录,这样才有效.然后将这段代码放置到所有需要校验的页面里就可以了

    二 nodeJS实现登录校验

    nodeJS里面的登录校验是利用nodeJS的门禁系统(权限管理),在nodejs中我们可以拦截到所有的用户http请求,此时我们就可以加以判断,看是否登录过了.

    在这里插入图片描述
    这里的nodeJS运用了express框架来书写:

    //1. 引入express组件
    const express = require('express');
    const path = require('path');
    const app = express();
    //1.2 引入操作seesion的组件
    const session = require('express-session')
    
    
    
    //2.1 使用express的静态资源
    app.use(express.static(path.join(__dirname,"static")));
    //2.2 使用session的组件 // 集成session中间件  req.session.xxx = yyy   req.session.xxx
    app.use(session({
        secret: 'keyboard cat',
        resave: false,
        saveUninitialized: true
    }));
    
    //2.2 引入模板引擎
    app.engine('html', require('express-art-template'));
    
    
    //3.0 门禁系统(权限设置)
    // 第一个参数 /* 表示除了静态资源的请求之外所有的请求
    // 第二个参数 next 表示放过
    app.all('/*',(req,res,next) => {
        
        if(req.url.includes('account')) { //账号有关,放过
            next();
        }else { //需要登录校验的页面
            //判断是否登录
            if(req.session.loginName != null) {
                next();
            }else {
                //打回登录页面
                res.send('<script>location.href = "/account/login.html";</script>');    
            }
        }  
    })
    
    
    //3.1 集成处理请求的组件处理账号模块
    const accountRouter = require(path.join(__dirname,'./routers/accountRouter.js'));
    //使用路由模块,处理账号模块
    app.use('/account',accountRouter);
    
    //3.2 集成处理请求的组件处理学生模块
    const studentRouter = require(path.join(__dirname,'./routers/studentRouter.js'));
    //使用路由模块,处理学生模块
    app.use('/student',studentRouter);
    
    
    
    //4. 开启服务
    app.listen(5000,"127.0.0.1",err => {
        if(err) {
            console.log(err);
        }else {
            console.log('web start!!!');
        }
    })
    

    通过上面的代码就可以实现权限控制:

    //3.0 门禁系统(权限设置)
    // 第一个参数 /* 表示除了静态资源的请求之外所有的请求
    // 第二个参数 next 表示放过
    app.all('/*',(req,res,next) => {
        
        if(req.url.includes('account')) { //账号有关,放过
            next();
        }else { //需要登录校验的页面
            //判断是否登录
            if(req.session.loginName != null) {
                next();
            }else {
                //打回登录页面
                res.send('<script>location.href = "/account/login.html";</script>');    
            }
        }  
    })
    

    三 vue实现登录验证

    vue的登录校验与前面两种很相识,可以说是将前面两种糅合在一起.vue里面也有门禁控制的模块就是vue router的导航守卫.

    //2. 设置路由规则
    const router = new VueRouter({
        // (缩写) 相当于 routes: routes
        routes: [
            { path: "/", redirect: "/goodlist" }, //重定向
            { name: "GOODLIST", path: "/goodlist", component: goodlist }, //设置goodlist路由规则
            { path: "/goodInfo/:goodsId", component: goodInfo }, //设置goodinfo路由规则
            { path: "/shopcart", component: shopcart }, //设置shopcart路由规则
            { name: "login", path: "/login", component: login}, //设置登录页的路由规则
    
            /************需要登录验证的部分 *******************/
            { name: "order", path: "/order", component: order, meta: { checkoutLogin: true } }  //设置order路由规则,这里是params传值      
        ]
    });
    
    
    //3.利用导航守卫做登录验证
    router.beforeEach((to, from, next) => {
    
        //from是来的页面,to是去的也页面,next是权限控制
        if(to.path != "/login") {
            //如果不是登录请求页面,那么记录来的路径方便以后使用
            localStorage.setItem('wantVisitPath',to.fullPath)
        }
    
    
        if(to.meta.checkoutLogin) { //需要登录校验的部分
            //发请求校验
            const url = `site/account/islogin`
            axios.get(url).then(res=>{
                if(res.data.code == "logined") { //登录过
                    next()
                }else {
                    //没登录打回到登录页
                    // router.push({ path : "/login" })
                    router.push({ name: "login" })
                }
            })
        }else { //不需要登录校验的部分
            next() 
        }  
    })
    

    具体的导航守卫可以参见导航守卫的使用

    展开全文
  • 4如何实现图库式登录校验码 unigui演示
  • 主要介绍了spring boot整合scurity做简单的登录校验的实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 相关博文: 《JSP/Servlet实现简单的登录校验》 《SpringMVC使用拦截器(Interceptor)实现用户登录校验》 《SpringBoot拦截器的配置并实现用户登录校验》 2、使用拦截器实现用户登录校验 下面通过一个示例来使用...

    在系统中,经常需要在处理用户请求之前和之后执行一些行为,例如检测用户的权限,或者将请求的信息记录到日志中。当然不仅仅这些,所以需要一种机制,拦截用户的请求,在请求的前后添加处理逻辑。

    SpringBoot 提供了 Interceptor 拦截器机制,用于请求的预处理和后处理。在 SpringBoot 中定义一个拦截器有两种方法:第一种是实现 HandlerInterceptor 接口,或者继承实现了 HandlerInterceptor 接口的类(例如:HandlerInterceptorAdapter);第二种方法时实现 Spring 的 WebRequestInterceptor 接口,或者继承实现了 WebRequestInterceptor 接口的类。这些拦截器都是在Handler的执行周期内进行拦截操作的。

    1、HandlerInterceptor接口

    首先来看看 HandlerInterceptor 接口的源码:

    package org.springframework.web.servlet;
     
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import org.springframework.lang.Nullable;
     
    public interface HandlerInterceptor {
        default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            return true;
        }
     
        default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        }
     
        default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        }
    }

    如果要实现 HandlerInterceptor 接口,就要实现其三个方法,分别是:preHandle、postHandle、afterCompletion。

    (1)preHandle 方法在执行 Handler 方法之前执行。该方法返回值为 Boolean 类型,如果返回false,表示拦截请求,不在向下执行。而如果返回 true,表示放行,程序继续向下进行(如果后面没有其他 Interceptor,就会直接执行 Controller 方法)。所以,此方法可以对请求进行判断,决定程序是否继续执行,或者进行一些前置初始化操作及对请求做预处理。

    (2)postHandle 方法在执行 Handler 之后,返回 ModelAndView 之前执行。由于该方法会在前端控制器(DispatcherServlet)进行返回视图渲染之前被调用,所以此方法多被用于统一处理返回的视图,例如将公用的模型数据(例如导航栏菜单)添加到视图,或者根据其他情况制定公用的视图。

    (3)afterCompletion 方法在执行完Handler之后执行。由于是在 Controller 方法执行完毕后执行该方法,所以该方法适合进行统一的异常或者日志处理操作。

    相关博文:

    《JSP/Servlet实现简单的登录校验》

    《SpringMVC使用拦截器(Interceptor)实现用户登录校验》

    《SpringBoot拦截器的配置并实现用户登录校验》

    2、使用拦截器实现用户登录校验

    下面通过一个示例来使用拦截器完成登录控制,具体为拦截用户的请求,判断用户是否已经登录,如果用户没有登录,则跳转到 login 页面,如果用户已经登录,则放行。执行结果如下图:

    登录失败,提示失败信息:

     登录成功,进入首页:

     (1)创建项目 

    创建 SpringBoot 项目,项目结构如下图:

     (2)添加依赖

    使用Maven添加依赖文件,在 pom.xml 文件中,添加需要的依赖:

    <!-- Spring Boot 的 Web 依赖-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- Thymeleaf 的依赖-->
    <dependency>
    	<groupId>org.springframework.boot</groupId>
    	<artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>

    (3)创建拦截器

    创建 com.pjb.interceptor 包,创建登录拦截器(LoginInterceptor.java),并实现HandlerInterceptor接口,实现其三个方法。这里主要以preHandle方法为主。

    package com.pjb.interceptor;
    
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * 登录拦截器
     * @author pan_junbiao
     **/
    public class LoginInterceptor implements HandlerInterceptor
    {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception
        {
            String uri = request.getRequestURI();
    
            //判断当前请求地址是否登录地址
            if(uri.contains("login") || uri.contains("toLoginPage"))
            {
                //登录请求,直接放行
                return true;
            }
            else
            {
                //判断用户是否登录
                if(request.getSession().getAttribute("userName")!=null)
                {
                    //说明已经登录,放行
                    return true;
                }
                else
                {
                    //没有登录,重定向到登录界面
                    response.sendRedirect(request.getContextPath() + "/toLoginPage");
                }
            }
    
            //默认拦截
            return false;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,Exception ex) throws Exception {
        }
    }

    (4)创建配置类

    创建 com.pjb.config 包,并创建 WebMvcConfig 类,实现 WebMvcConfigurer 接口;重写  addViewControllers 方法和 addInterceptors 方法;使用 @Configuration 注解,标注该类为配置类。

    了解WebMvcConfigurer配置接口的详解:

    《SpringBoot中的WebMvcConfigurer配置接口的详解》

    package com.pjb.config;
    
    import com.pjb.interceptor.LoginInterceptor;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
    import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    
    /**
     * Web MVC 配置类
     * @author pan_junbiao
     **/
    @Configuration
    public class WebMvcConfig implements WebMvcConfigurer
    {
        /**
         * 控制器配置
         */
        @Override
        public void addViewControllers(ViewControllerRegistry registry)
        {
            registry.addViewController("/toIndexPage").setViewName("/index");
            registry.addViewController("/").setViewName("/index");
        }
    
        /**
         * 拦截器配置
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry)
        {
            //注册Interceptor拦截器
            InterceptorRegistration registration = registry.addInterceptor(new LoginInterceptor());
            registration.addPathPatterns("/**"); //所有路径都被拦截
            registration.excludePathPatterns( //添加不拦截路径
                    "/toLoginPage", //登录页面
                    "/login",       //登录请求
                    "/**/*.html",   //html静态资源
                    "/**/*.js",     //js静态资源
                    "/**/*.css"     //css静态资源
            );
        }
    }

    (5)创建控制器

    创建 com.pjb.controller 包,创建登录控制器(LoginController.java),编写登录与登出方法。

    package com.pjb.controller;
    
    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 javax.servlet.http.HttpServletRequest;
    
    /**
     * 登录控制器
     * @author pan_junbiao
     **/
    @Controller
    public class LoginController
    {
        /**
         * 登录页面
         */
        @RequestMapping("/toLoginPage")
        public String toLoginPage()
        {
            //跳转至登录页面
            return "login.html";
        }
    
        /**
         * 登录
         */
        @RequestMapping(value = "/login", method = RequestMethod.POST)
        public String login(Model model, HttpServletRequest request, String userName, String password)
        {
            //验证登录信息
            if (userName.equals("pan_junbiao的博客") && password.equals("123456"))
            {
                //验证成功,记录Session信息
                request.getSession().setAttribute("userName", userName);
    
                //重定向到首页
                return "redirect:toIndexPage";
            }
            else
            {
                model.addAttribute("errorMsg", "账号或密码错误!");
            }
    
            //跳转至登录页面
            return toLoginPage();
        }
    
        /**
         * 登出
         */
        @RequestMapping(value = "/logout")
        public String logout(HttpServletRequest request)
        {
            //销毁session对象
            request.getSession().invalidate();
    
            //重定向到登录页面
            return "redirect:toLoginPage";
        }
    }

     (6)创建视图

    创建用户登录页面(Login.html)。

    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>用户登录</title>
        <meta name="author" content="pan_junbiao的博客">
        <style>
            .txtBox{
                padding: 3px;
                width: 250px;
                font-size: 16px;
            }
        </style>
    </head>
    <body>
    <div align="center">请输入登录信息
        <form name="myForm" method="post" action="/login" onsubmit="SubmitLogin()">
            <table>
                <tr>
                    <td>用户姓名:</td>
                    <td><input type="text" name="userName" value="pan_junbiao的博客" class="txtBox" /></td>
                </tr>
                <tr>
                    <td>登录密码:</td>
                    <td><input type="password" name="password" value="123456" class="txtBox"/></td>
                </tr>
                <!-- 以下是提交、取消按钮 -->
                <tr>
                    <td>
                        <input type="submit" value="登录" />
                    </td>
                    <td>
                        <input type="reset" value="取消" />
                    </td>
                </tr>
            </table>
            <p style="color:red" th:text="${errorMsg}"></p>
        </form>
    </div>
    </body>
    <script>
        //提交登录
        function SubmitLogin() {
            //判断用户名是否为空
            if (!myForm.userName.value) {
                alert("请输入用户姓名!");
                myForm.userName.focus();
                return false;
            }
    
            //判断密码是否为空
            if (!myForm.password.value) {
                alert("请输入登录密码!");
                myForm.password.focus();
                return false;
            }
            return true;
        }
    </script>
    </html>

    创建首页(index.html)。

    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>首页</title>
        <meta name="author" content="pan_junbiao的博客">
    </head>
    <body>
        <h1>首页</h1>
        <p>当前Session中保存的登录人名称:<span th:text="${session.userName}"/></p>
        <p>您好,欢迎访问 pan_junbiao的博客!</p>
        <p>博客地址:https://blog.csdn.net/pan_junbiao</p>
        <a href="logout" onclick="return confirm('确定注销吗?');">注销</a>
    </body>
    </html>

    展开全文
  • 主要介绍了koa2 用户注册、登录校验与加盐加密的实现方法,本文给大家介绍的非常详细,具有一定的参考借鉴价值 ,需要的朋友可以参考下
  • JDBC 登录校验

    2017-11-01 17:00:20
    JDBC 连接数据库登录校验,实现登陆功能;JDBC 连接数据库登录校验,实现登陆功能
  • * 此注解是为了校验所有登录身份的 * 默认是需要登录 * 可作用于类和方法上 * </p> * <p> * @Retention 元注解 * 1、RetentionPolicy.SOURCE:注解只保留在源文件,当Java文件编.

    这个需要配合过滤器或者oauth等使用,我这里使用的是拦截器
    目前要登录拦截的话,如果同时注解在类上和方法上,以方法上的注解为准,具体代码如:拦截器代码

    /**
     * 方槐
     * <p>
     *     此注解是为了校验所有登录身份的
     *     默认是需要登录
     *     可作用于类和方法上
     * </p>
     * <p>
     *     @Retention 元注解
     *     1、RetentionPolicy.SOURCE:注解只保留在源文件,当Java文件编译成class文件的时候,注解被遗弃;
     *     2、RetentionPolicy.CLASS:注解被保留到class文件,但jvm加载class文件时候被遗弃,这是默认的生命周期;
     *     3、RetentionPolicy.RUNTIME:注解不仅被保存到class文件中,jvm加载class文件之后,仍然存在;
     *
     *      @Target Annotation所修饰的对象范围
     *      METHOD 可用于方法上
     *      TYPE   可用于类或者接口上
     *      ANNOTATION_TYPE 可用于注解类型上(被@interface修饰的类型)
     *      CONSTRUCTOR 可用于构造方法上
     *      FIELD  可用于域上
     *      LOCAL_VARIABLE 可用于局部变量上
     *      PACKAGE 用于记录java文件的package信息
     *      PARAMETER 可用于参数上
     *
     *      @Inherited 阐述了某个被标注的类型是被继承的。
     *      如果一个使用了@Inherited修饰的annotation类型被用于一个class,则这个annotation将被用于该class的子类。
     * </p>
     * @author fangh
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(value = {ElementType.TYPE,ElementType.METHOD})
    @Documented
    @Inherited
    public @interface AuthLogin {
    
        /**
         *是否需要登录
         * 默认:需要登录
         */
        boolean needLogin() default true ;
    }
    

    具体使用如下图
    在这里插入图片描述
    拦截器代码
    登录拦截验证代码

    到这就完成了,有喜欢的小伙伴们可以点个赞,也可以关注下,里面还有其他干货可以看看。

    展开全文
  • vue router 给路由添加一个自定义的meta对象,然后通过判断自定义的meta对象内的自定义属性,设置不同的校验。 再通过vue router导航守卫router.beforeEach(),再进入前进行检验拦截。 router 路由配置 { path: '/'...
  • 关闭ONVIF登录校验,任何一台硬盘录像机连接此摄像机时也不需要输入此摄像机的用户名和密码直接就可以看到这个摄像机的画面在实际的应用中,监控摄像机开启ONVIF登录校验和关闭ONVIF登录校验好处与坏处,目前,大华...
  • 前端经典——webApp登录校验及封装
  • 准备数据 CREATE TABLE `user` ( `name` varchar(255) NOT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8; CREATE TABLE `role` ( `name` varchar(255) NOT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8;...
  • delphi unigui如何实现图库式登录校验码源码.zip
  • ASP.NET Core5.0 WebApi和BlazorWebAssembly 博客后台管理系统(jwt登录校验)MySQL数据库
  • Login登录校验

    千次阅读 2018-11-03 11:47:42
    首次登录: @RequestMapping("/login") public JsonResult login(HttpServletRequest request, HttpServletResponse response, @RequestParam Map&lt;String, String&gt; map) {  if (!(map ==...
  • 【JavaWeb项目】实现简易的疫苗预约系统 登录校验 Cookie Session 前端 Servlet JDBC
  • Ajax实现注册登录校验

    千次阅读 2021-05-08 11:44:53
    Ajax实现注册登录校验 1.在做项目的时候,或多或少都会用到ajax来实现注册登录的校验,例如,当你注册时,你输入一个用户名,就会提示你,用户名可用,或者,用户名已被注册 ,等等 ,就像下图这种。 接下来我们就...
  • 用户登录校验接口

    2020-02-10 21:27:44
    后台实现校验用户接口 我们在learn-auth-service中定义用户的校验接口,通过cookie获取token,然后校验通过返回用户信息。 请求方式:GET 请求路径:/verify 请求参数:无,不过我们需要从cookie中...
  • delphi unigui如何实现图库式登录校验
  • 一个登录校验的小demo演示,可以借鉴里面的内容进行修改
  • 登录拦截器:在这里介绍的登录拦截器主要有两个功能作用,禁止未登录登录信息失效状态下对系统进行操作,同时实现用户登录信息的过期机制。 我们通常会将用户信息保存在session或cookie中,而对于session来讲设置...
  • ASP.NET Core 中简单Session登录校验

    千次阅读 2018-11-27 15:13:45
    ASP.NET Core 中简单Session登录校验:从Session的配置添加、到请求过滤、再到页面操作。推荐相关阅读:ASP.NET 会话状态概述 ASP.NET Cookie 概述 ASP.NET 状态管理建议 ASP.NET Core 中的会话和应用状态 目录 ...
  • spring-security 自定义登录校验

    千次阅读 2018-12-22 17:03:01
    1.为何要做自定义登录页面以及校验在项目中配置了spring-security的模块的项目中,spring boot会默认帮我们生成的一个简洁的登录页面,它会在我们访问任何请求的时候弹出来 用户名是默认的:user,密码是需要我们...
  • 相关博文: 《JSP/Servlet实现简单的登录校验》 《SpringMVC使用拦截器(Interceptor)实现用户登录校验》 《SpringBoot拦截器的配置并实现用户登录校验》 2、使用拦截器实现用户登录校验 下面通过一个示例来使用...
  • CXF-拦截器-权限控制-登录校验

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,738
精华内容 66,295
关键字:

登录校验

友情链接: tt.o.rar