.net core web项目teachers表的CRUD和基于JWT的登录登出以及给接口添加权限控制

已于 2024-03-14 20:26:16 修改
阅读量782 收藏 19
点赞数 9
文章标签： .netcore
于 2024-03-14 20:19:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myid6/article/details/136720675
版权

（1）导入Pomelo.EntityFrameworkCore.Mysql

（2）导入Swashbuckle.AspNetCore

（3）导入Microsoft.AspNetCore.Authentication.JwtBearer

一.前期配置

1.Startup.cs

using CRUD4.Models;
using CRUD4.Services;
using Microsoft.AspNetCore.Authentication.JwtBearer;
using Microsoft.EntityFrameworkCore;
using Microsoft.IdentityModel.Tokens;
using Microsoft.OpenApi.Models;
using System.Security.Claims;
using System.Security.Cryptography;

namespace CRUD4
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();
            // Add your services here
            string connectionString = Configuration.GetConnectionString("DefaultConnection");
            services.AddScoped<ITeacherRepository, TeacherRepository>();
            services.AddScoped<ITeacherService, TeacherService>();
            services.AddScoped<RsaSecurityKey>();
            services.AddHttpContextAccessor();
            services.AddScoped<ITokenBlacklistService, TokenBlacklistService>();
            services.AddLogging();


            //swager
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Your API", Version = "v1" });
            });

            //database
            services.AddDbContext<MyContext>(options =>
                options.UseMySql
                (connectionString, ServerVersion.AutoDetect(connectionString))
                );

            // 生成 RSA 密钥对
            RSA rsa = RSA.Create(2048);
            var privateKey = rsa;
            var publicKey = rsa.ExportRSAPublicKey();

            // 将密钥保存到服务中，以便后续使用
            services.AddSingleton(privateKey);
            services.AddSingleton(publicKey);

            // 配置 JWT 认证
            services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
                .AddJwtBearer(options =>
                {
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuer = false,
                        ValidateAudience = false,
                        ValidateLifetime = true,
                        ValidateIssuerSigningKey = true,
                        IssuerSigningKey = new RsaSecurityKey(privateKey)
                    };
                    options.Events = new JwtBearerEvents
                    {
                        OnTokenValidated = async context =>
                        {
                            var blacklistService = context.HttpContext.RequestServices.GetRequiredService<ITokenBlacklistService>();
                            var token = context.Request.Headers["Authorization"].ToString();
                            if (token != null && await blacklistService.IsBlacklisted(token.Substring(7)))
                            {
                                context.Fail("This token is blacklisted");
                            }
                        }
                    };
                });
            //添加自定义接口访问权限   在接口上加[Authorize(Policy = "admin")]
            services.AddAuthorization(options =>
            {
                options.AddPolicy("admin", policy =>
                {
                    policy.RequireAuthenticatedUser(); // 用户必须经过身份验证
                    policy.RequireClaim(ClaimTypes.Name, "T2024002"); // 用户必须具有指定的声明（即指定的信息为""里的信息）
                });
            });


        }


        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();

                app.UseSwagger();
                // Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.),
                // specifying the Swagger JSON endpoint.
                app.UseSwaggerUI(c =>
                {
                    c.SwaggerEndpoint("/swagger/v1/swagger.json", "Your API V1");
                });
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseStaticFiles();

            app.UseRouting();
            //添加身份验证中间件
            app.UseAuthentication();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllerRoute(
                    name: "default",
                    pattern: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

2.Program.cs

namespace CRUD4;
public class Program
{
    public static void Main(string[] args)
    {
        CreateHostBuilder(args).Build().Run();
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup<Startup>();
            });
}

3.appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=demo1;User=root;Password=123456;"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

4.统一返回类R

namespace CRUD4.Commons
{
    public class R<T>
    {
        public int Code { get; set; } // 编码：1成功，0和其它数字为失败

        public string Msg { get; set; } // 错误信息

        public T Data { get; set; } // 数据

        public Dictionary<string, object> Map { get; set; } = new Dictionary<string, object>(); // 动态数据

        public static R<T> Success(T data)
        {
            return new R<T> { Data = data, Code = 1 };
        }

        public static R<T> Error(string msg)
        {
            return new R<T> { Msg = msg, Code = 0 };
        }

        public R<T> Add(string key, object value)
        {
            this.Map[key] = value;
            return this;
        }
    }
}

二.模型文件夹

1.数据库配置

using Microsoft.EntityFrameworkCore;

namespace CRUD4.Models
{
    public class MyContext : DbContext
    {
        public DbSet<Teacher> Teachers { get; set; }

        public DbSet<Course> Courses { get; set; }

        public MyContext(DbContextOptions<MyContext> options)
        :base(options)
        {
        }
    }
}

2.Teacher类

namespace CRUD4.Models
{
    public class Teacher
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Code { get; set; }
        public string Password { get; set; }
    }
}

3.TeacherLocalModel类

用于教师登录操作，使用Code教师编号和Password登录

namespace CRUD4.Models
{
    public class TeacherLoginModel
    {
        public string Code{  get; set; }
        public string Password { get; set; }
    }
}

4.ITeacherRepository

namespace CRUD4.Models
{
    public interface ITeacherRepository
    {
        void AddTeacher(Teacher teacher);
        void RemoveTeacherByCode(string code);
        void UpdateTeacher(Teacher teacher);
        Teacher GetTeacherById(int id);
        IEnumerable<Teacher> GetTeacherByName(string name);
        Teacher GetTeacherByCode(string code);
        IEnumerable<Teacher> GetAllTeachers();

        Teacher Login(TeacherLoginModel teacherLoginModel);
    }
}

5.TeacherRepository


namespace CRUD4.Models
{
    public class TeacherRepository : ITeacherRepository
    {

        private readonly MyContext _context;
        public TeacherRepository(MyContext context) {
        _context = context;
        }
        public void AddTeacher(Teacher teacher)
        {
            _context.Teachers.Add(teacher);
            _context.SaveChanges();
        }
        public void RemoveTeacherByCode(string code)
        {
            var teacher=_context.Teachers.FirstOrDefault(t=>t.Code == code);
            _context.Teachers.Remove(teacher);
            _context.SaveChanges(true);
        }

        public void UpdateTeacher(Teacher teacher)
        {
            var teacher1=_context.Teachers.FirstOrDefault(t=>t.Id == teacher.Id );
            _context.Teachers.Entry(teacher1).CurrentValues.SetValues(teacher);
            _context.SaveChanges();
        }
        public IEnumerable<Teacher> GetAllTeachers()
        {
            return _context.Teachers.ToList();
        }

        public Teacher GetTeacherByCode(string code)
        {
            return _context.Teachers.FirstOrDefault(t => t.Code == code);
        }

        public Teacher GetTeacherById(int id)
        {
            return _context.Teachers.FirstOrDefault(t => t.Id == id);
        }

        public IEnumerable<Teacher> GetTeacherByName(string name)
        {
            return _context.Teachers.Where(t => t.Name.Contains(name)).ToList();
        }

        public Teacher Login(TeacherLoginModel teacherLoginModel)
        {
            return _context.Teachers.FirstOrDefault(t => t.Code == teacherLoginModel.Code && t.Password == teacherLoginModel.Password);
        }
    }
}

6.ITokenBlacklistService

用于退出功能把token拉进黑名单

namespace CRUD4.Models
{
    public interface ITokenBlacklistService
    {
        Task<bool> IsBlacklisted(string token);
        Task AddTokenToBlacklist(string token);
    }
}

7.TokenBlacklistService

namespace CRUD4.Models
{
    public class TokenBlacklistService : ITokenBlacklistService
    {
        // 这里假设黑名单存储在内存中的集合中，您可以根据实际需求将其替换为数据库或其他持久化存储方式
        private readonly HashSet<string> _blacklistedTokens;

        public TokenBlacklistService()
        {
            _blacklistedTokens = new HashSet<string>();
        }

        public Task<bool> IsBlacklisted(string token)
        {
            // 模拟异步操作
            return Task.FromResult(_blacklistedTokens.Contains(token));
        }

        public Task AddTokenToBlacklist(string token)
        {

            // 去掉 "Bearer " 前缀
            var tokenValue = token.Substring("Bearer ".Length);
            // 模拟异步操作
            _blacklistedTokens.Add(tokenValue);
            return Task.CompletedTask;
        }
    }
}

三.Service层

1.ITeacherService

using CRUD4.Commons;
using CRUD4.Models;

namespace CRUD4.Services
{
    public interface ITeacherService
    {
        R<string> AddTeacher(Teacher teacher);
        R<string> DeleteTeacher(string code);
        R<string> UpdateTeacher(Teacher teacher);
        R<Teacher> GetTeacherById(int id);
        R<IEnumerable<Teacher>> GetTeacherByName(string name);
        R<Teacher> GetTeacherByCode(string code);
        R<IEnumerable<Teacher>> GetAllTeachers();
        R<string> Login(TeacherLoginModel teacherLoginModel);
        R<string> Logout();
    }
}

2.TeacherService

using CRUD4.Commons;
using CRUD4.Models;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;

namespace CRUD4.Services
{
    public class TeacherService : ITeacherService
    {
        private readonly ITeacherRepository _repository;
        private readonly RsaSecurityKey _securityKey;
        private readonly IDictionary<string, string> _tokens;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly ITokenBlacklistService _tokenBlacklistService;
        private readonly ILogger<TeacherService> _logger;
        public TeacherService(ITeacherRepository repository,RsaSecurityKey securityKey,
            IHttpContextAccessor httpContextAccessor,
            ILogger<TeacherService> logger,
            ITokenBlacklistService tokenBlacklistService)
        {
            _repository = repository;
            _securityKey = securityKey;
            _tokens = new Dictionary<string, string>();
            _httpContextAccessor = httpContextAccessor;
            _logger = logger;
            _tokenBlacklistService = tokenBlacklistService;
        }
        public R<string> AddTeacher(Teacher teacher)
        {
            var teacher1=_repository.GetTeacherByCode(teacher.Code);
            if(teacher1 == null)
            {
                _repository.AddTeacher(teacher);
                return R<string>.Success("新增成功");
            }
            return R<string>.Error("新增失败");
        }

        public R<string> DeleteTeacher(string code)
        {
            var teacher=_repository.GetTeacherByCode(code);
            if(teacher != null)
            {
                _repository.RemoveTeacherByCode(code);
                return R<string>.Success("删除成功");
            }
            return R<string>.Error("删除失败，没有此编号的老师");
        }
        public R<string> UpdateTeacher(Teacher teacher)
        {
            var teacher1 = _repository.GetTeacherById(teacher.Id);
            if(teacher1 != null)
            {
                _repository.UpdateTeacher(teacher);
                return R<string>.Success("修改成功");
            }
            return R<string>.Error("修改失败，没有此编号的老师");
        }

        public R<IEnumerable<Teacher>> GetAllTeachers()
        {
            return R<IEnumerable<Teacher>>.Success(_repository.GetAllTeachers());
        }

        public R<Teacher> GetTeacherByCode(string code)
        {
            var teacher = _repository.GetTeacherByCode(code);
            if (teacher != null)
            {
                return R<Teacher>.Success(teacher);
            }
            return R<Teacher>.Error("没有这个编号的老师");
        }

        public R<Teacher> GetTeacherById(int id)
        {
            var teacher = _repository.GetTeacherById(id);
            if (teacher != null)
            {
                return R<Teacher>.Success(teacher);
            }
            return R<Teacher>.Error("没有这个id的老师");
        }

        public R<IEnumerable<Teacher>> GetTeacherByName(string name)
        {
            var teacher = _repository.GetTeacherByName(name);
            if (teacher != null)
            {
                return R<IEnumerable<Teacher>>.Success(teacher);
            }
            return R<IEnumerable<Teacher>>.Error("没有这个名字的老师");
        }

        public R<string> Login(TeacherLoginModel teacherLoginModel)
        {
            var teacher=_repository.Login(teacherLoginModel);
            if(teacher != null)
            {
                var token = GenerateToken(teacher.Code);
                // 登录成功后将 Teacher 对象存储在 HttpContext.Items 中
                //_contextAccessor.HttpContext.Items["LoggedInTeacher"] = teacher;
                return R<string>.Success(token);
            }
            return R<string>.Error("登录失败");
        }
        /*
        public R<string> Logout()
        {

            if (_contextAccessor.HttpContext.Items.ContainsKey("LoggedInTeacher"))
            {
                var teacher = (Teacher)_contextAccessor.HttpContext.Items["LoggedInTeacher"];
                ClearToken(teacher.Code);
                return R<string>.Success("退出成功");
            }
            else
            {
                return R<string>.Error("退出失败，必须先登录才能退出");
            }
        }
        */

        public  R<string> Logout()
        {

            if (_httpContextAccessor == null || _tokenBlacklistService == null)
            {
                _logger.LogError("HttpContextAccessor or TokenBlacklistService is null.");
                return R<string>.Error("服务未正确配置");
            }
            var token = _httpContextAccessor.HttpContext.Request.Headers["Authorization"].FirstOrDefault();
            if(token == null|| !token.StartsWith("Bearer "))
            {
                return R<string>.Error("退出失败");
            }

            // 去掉 "Bearer " 前缀
            var tokenValue = token.Substring("Bearer ".Length);

            // 调用添加到黑名单的方法
            _tokenBlacklistService.AddTokenToBlacklist(tokenValue);

            return R<string>.Success("退出成功");
        }
        public string GenerateToken(string tcode)
        {
            var signingCredentials = new SigningCredentials(_securityKey, SecurityAlgorithms.RsaSha256);
            var claims = new[ ]
            {
                new Claim(ClaimTypes.Name,tcode)
        };
            var jwt=new JwtSecurityToken(
                claims:claims, 
                signingCredentials:signingCredentials,
                expires:DateTime.UtcNow.AddMinutes(30));
            var token =new JwtSecurityTokenHandler().WriteToken(jwt);
            return token;
        }

        public void ClearToken(string tcode)
        {
            if (_tokens.ContainsKey(tcode))
            {
                _tokens.Remove(tcode);            
            }
        }
    }
}

四.控制器层

1.TeacherController

using CRUD4.Models;
using CRUD4.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace CRUD4.Controllers
{
    [ApiController]
    [Route("api/teacher")]
    public class TeacherController : Controller
    {
        private readonly ITeacherService _service;

        public TeacherController(ITeacherService service)
        {
            _service = service;
        }

        //Post: api/teacher/add
        [HttpPost("add")]
        public IActionResult AddTeacher(Teacher teacher)
        {
            return Ok(_service.AddTeacher(teacher));
        }

        //Delete: api/teacher/delete/T2024003
        [HttpDelete("delete/{code}")]
        public IActionResult DeleTeacher(string code)
        {
            return Ok(_service.DeleteTeacher(code));
        }

        //Post: api/teacher/update
        [HttpPost("update")]
        public IActionResult UpdateTeacher(Teacher teacher)
        {
            return Ok(_service.UpdateTeacher(teacher));
        }

        //Get: api/teacher/1
        [HttpGet("{id}")]
        public IActionResult GetTeacherById(int id)
        {
            return Ok(_service.GetTeacherById(id));
        }

        //Get: api/teacher/getByCode/T2024001
        [HttpGet("getByCode/{code}")]
        public IActionResult GetTeacherByCode(string code)
        {
            return Ok(_service.GetTeacherByCode(code));
        }

        //Get: api/teacher/getByName/李老师
        [HttpGet("getByName/{name}")]
        public IActionResult GetTeacherByName(string name)
        {
            return Ok(_service.GetTeacherByName(name));
        }

        //Get: api/teacher
        [HttpGet]
        [Authorize(Policy ="admin")]
        public IActionResult GetAllTeachers()
        {
            return Ok(_service.GetAllTeachers());
        }

        //Post: api/teacher/login
        [HttpPost("login")]
        public IActionResult Login(TeacherLoginModel teacherLoginModel)
        {
            return Ok(_service.Login(teacherLoginModel));
        }

        //Post: api/teacher/logout
        [HttpPost("logout")]
        [Authorize]
        public IActionResult Logout()
        {
            return Ok(_service.Logout());
        }

        [HttpGet("index")]
        public IActionResult Index()
        {
            return View();
        }
    }
}


 

myid6
关注
  • 9
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
JWT认证及登录功能实现，退出登录
pink_Pig___的博客
07-12 1940
JWT认证及登录功能的实现
angular6-webapi：使用angular 6和.net core2 webapi登录，认证，CRUD操作
02-01
使用angular 6和.net core2 webapi登录，令牌认证，CRUD操作 仓库代码库 该存储库由以下项目组成： ＃ 项目名 项目细节 地点 1个 WebApi Asp.Net Core2 WebApi作为后端 后端文件夹 2 客户 角度6作为前端 客户...
NET Core中JWT+OAuth2.0实现SSO，附完整源码（.NET6）
xwnxwn的专栏
10-15 1582
https://www.cnblogs.com/wei325/p/16316004.html
Jwt退出登陆
最新发布
qq_40369277的博客
09-24 1372
我们之前可以使用退出登录接口直接退出，用户Session中的验证信息也会被销毁，但是现在是无状态的，用户来管理Token令牌，服务端只认Token是否合法，那这个时候该怎么让用户正确退出登录呢？这里我们以黑名单机制为例，让用户退出登录之后，无法再次使用之前的JWT进行操作，首先我们需要给JWT额外添加一个用于判断的唯一标识符，这里就用UUID好了。首先我们从最简单的方案开始，我们可以直接让客户端删除自己的JWT令牌，这样不就相当于退出登录了吗，这样甚至不需要请求服务器，直接就退了。
mysql的用户管理（crud用户）和权限授予（赋予crud权限）
健康平安的活着的专栏
03-20 1266
一 用户管理 1.1 用户与密码操作 1.创建名称为 zhang3 的用户，密码设为 123123 create user zhang3 identified by '123123'； 2.查看用户权限 select host,user,authentication_string,select_priv,insert_priv,drop_priv from mysql.user; 3.修改当前用户密码 set password =password('123456') 所..
.net core基于Oauth2+jwt两种方式实现身份认证(附单点登录)
xwnxwn的专栏
10-15 1981
securityKey明文,Java加密使用的是Base64返回的实体
Jwt登录退出
10000guo的博客
06-09 1349
【代码】Jwt登录退出。
.NET6WebAPI使用Sqlserver+JWT增删改查
06-26
在本项目中，".NET6WebAPI使用Sqlserver+JWT增删改查"是一个基于最新.NET框架.NET6构建的Web应用程序示例，主要用于演示如何利用ASP.NET Core Web API与SQL Server数据库进行数据操作，以及结合JWT（JSON Web Tokens...
WebApiJwt：具有身份和MySQL的Asp.NET Core 2.0 WebApi JWT身份验证
02-04
【标题】：“WebApiJwt：基于身份验证和MySQL的Asp.NET Core 2.0 WebApi JWT实现” 在本文中，我们将深入探讨如何在Asp.NET Core 2.0的WebApi项目中集成JWT（JSON Web Tokens）进行身份验证，并与MySQL数据库配合...
WebApiMongoDB：将MongoDB与ASP.NET Web API和ASP.NET Core结合使用以执行CRUD操作并构建NotebookApp
02-02
示例：将MongoDB .NET驱动程序与.NET Core WebAPI一起使用 演练博客文章 这是第一篇博客文章，介绍了与示例应用程序关联的后端：NotebookApp。 这是使用.NET Core 2使用MongoDB .NET驱动程序版本2来构建Web API层...
JWT项目中用法
08-08
JWT原理：对登录和注册方法放行，用户名和密码验证正确后，服务端保存到redis缓存并设置有效期，返回给客户端userid和sessionid， 客户端自行保存（Cookie或者 h5的localStorage）。 其他接口统一拦截（header里的参数authorization 值为 userid_sessionid）， 服务端到redis根据key:userid 取出根据 sessionid 与接收的客户端 sessionid验证是否一致。
ng-netcore-card-manager:具有Asp.Net Core Web API和Angular的简单CRUD卡管理器
04-11
**标题详解：** "ng-netcore-card-manager" 是一个项目名称，表明这是一个使用Angular和Asp.Net Core构建的Web应用程序，专门用于卡片管理。"ng-" 指的是Angular，"netcore" 指的是Asp.Net Core，而 "card-manager" ...
MongoDB基础篇-04-用户权限操作(即用户的CRUD)
Alan0517
12-04 1226
在删除用户时需要切换到创建用户时所指定的数据库才可以删除。注意：需要使用具有 userAdminAnyDatabase角色管理员用户才可以删除其他用户。上面的案列意思是，创建一个用户名为wql，密码为wql的用户，他的权限读写，对应的数据库是ccc’上面的权限，对于新人来说，建议，自己玩一遍，会更理解。上面举例的意思是，修改wql01用户权限，之前是abc库的读写，现在改成abc的读权限。不管是新增管理员用户，还是新增普通用户，都一样，只不过权限不一样而已。查看当前需要修改的用户的权限。
jwt退出登录的解决方案
热门推荐
C4Z的博客
11-05 3万+
jwt退出登录 前言 JWT 的原理是，服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样。 { "姓名": "张三", "角色": "管理员", "到期时间": "2018年7月1日0点0分" } 以后，用户与服务端通信的时候，都要发回这个 JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名。 服务器就...
.net Core Jwt登录验证刷新Token
qq_26900081的博客
07-18 7536
使用 jwt做登录验证的时候，token的过期时间的固定的， 也就是只要经过了一定的时间肯定会过期。有可能用户用着系统就突然提示登录失效了。这里通过在行为结果过滤器Result Filter中刷新Token。例如设置token失效时间为20分钟， 那么只要用户在20分钟之内没有访问后台接口，token将失效。 代码只是个范例，不严谨。小伙伴们自己修改吧！别报空引用哦~~~ public c...
.net core 3.1 使用jwt完成登录验证
qq_26900081的博客
01-14 1万+
nuget安装：Microsoft.AspNetCore.Authentication.JwtBearer 3.1.0 版本 一、添加配置文件 "Authentication": { "JwtBearer": { "IsEnabled": "true", "SecurityKey": "Demo_C421AAEE0D114E9C1", "Iss...
Asp.net core [单点登录sso] JWT与用户身份验证的具体实现
csdn2990的博客
09-27 4812
什么是 JWT – JSON WEB TOKEN JWT官网 下面我们来具体实现 先为服务创建一个jwt 1.先给项目安装相应的包 如图: 提醒一下，这玩意要和你.net core框架版本一致。我用的3.1稳定版 接下来我们来在服务端使用JWT创建Token代码如下: [AllowAnonymous]//允许所有人访问 [HttpPost("login")] public IActionResult login([FromBody] LoginDto loginDto)
asp.net core JWT 验证用户是否有效
赫的BLOG
09-26 1698
asp.net core Json web Token 验证用户是否有效，有多种方法 第一种是在MVC控制器中用特性限制。 第二种是使用控制器安全标识变量控制 if (User.Identity.IsAuthenticated) 使用上面这段代码来限制
.NET Core中文文档：ASP.NET Core、WebAPI、MVC与Blazor教程
教程涵盖了添加控制器、视图、模型，以及使用EF Core进行数据访问和并发冲突处理。 ### Blazor Blazor是ASP.NET Core的一个组成部分，它允许使用C#和Razor语法来构建客户端Web应用。Blazor提供了与Web API和实时...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值