第66章 实战项目2：RESTful API服务器
一、我踩过的API服务器坑：从“Web Forms耦合到改一行代码崩整个系统”到“ASP.NET Core扛10万QPS”
做企业管理系统时，一开始用ASP.NET Web Forms写API，把UI逻辑和业务逻辑混在一起，改一个接口的参数，整个页面都崩了——后来换成ASP.NET Core，分层架构解耦，改业务逻辑完全不影响UI，维护效率提升了5倍！还有一次没加全局异常处理，API返回500错误时直接暴vb.net教程C#教程python教程SQL教程access 2010教程露服务器堆栈信息，被安全扫描出漏洞——后来加了全局异常过滤器，统一返回友好的错误格式，安全漏洞直接修复。最坑的是没做缓存，每次查询用户信息都查数据库，数据库CPU直接100%——后来用Redis做缓存，查询速度从500ms降到10ms，数据库CPU使用率降到10%以下。这节我把这些血泪经验揉进去，用大白话讲透RESTful API的核心原理，结合ASP.NET Core实战代码逐行拆解，拓展生产级优化技巧，让你写出高性能、易维护、安全的API服务器！
二、RESTful API核心原理：把“资源”当成“商品”，用HTTP方法做“操作”
大白话解释：把RESTful API比作“电商网站”
1.资源：商品（比如用户、订单、商品），每个资源有唯一的URL（比如/api/users/123）；
2.HTTP方法：对商品的操作，比如GET（查看商品）、POST（新增商品）、PUT（修改商品）、DELETE（删除商品）；
3.状态码：操作结果，比如200（查看成功）、201（新增成功）、400（参数错误）、404（商品不存在）、500（服务器错误）；
4.无状态：每次请求都包含所有必要信息，服务器不保存客户端状态，比如登录状态用Token传递，不用Session。
我踩过的坑：一开始用POST方法做查询，违反了RESTful规范，导致API语义不清晰，前端开发经常搞错方法——后来严格按照HTTP方法语义设计API，前端对接效率提升了3倍！
三、实战：ASP.NET Core RESTful API服务器（分层架构+生产级配置）
技术栈：ASP.NET Core 8 + Entity Framework Core + Redis + Swagger + Serilog + JWT
项目结构（分层架构，解耦易维护）

	RestfulApiServer/
	├── Controllers/ # API控制器，处理HTTP请求
	├── Models/ # 数据模型和DTO（数据传输对象）
	├── Services/ # 业务逻辑层，处理核心业务
	├── Repositories/ # 数据访问层，封装数据库操作
	├── Filters/ # 过滤器，比如全局异常处理、授权验证
	├── Middlewares/ # 中间件，比如日志、限流、压缩
	├── Configurations/ # 配置类，比如数据库、Redis、JWT配置
	├── Program.cs # 启动类，配置服务和中间件
	└── appsettings.json # 配置文件

步骤1：创建ASP.NET Core Web API项目
bash
# 用.NET CLI创建项目
dotnet new webapi -n RestfulApiServer -f net8.0
cd RestfulApiServer
步骤2：核心代码逐行讲解

1. 数据模型和DTO（Models/）
   数据模型（User.cs）：对应数据库表
   csharp

	using System.ComponentModel.DataAnnotations;
	
	namespace RestfulApiServer.Models;
	
	/// <summary>
	/// 用户数据模型，对应数据库Users表
	/// </summary>
	public class User
	{
	[Key] // 主键
	public int Id { get; set; }
	
	[Required] // 非空
	[MaxLength(50)] // 最大长度50
	public string Username { get; set; } = string.Empty;
	
	[Required]
	[EmailAddress] // 邮箱格式验证
	public string Email { get; set; } = string.Empty;
	
	[Required]
	public string PasswordHash { get; set; } = string.Empty; // 密码哈希，不存明文
	
	public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
	public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
	}

逐行拆解：
用数据注解（Data Annotations）配置数据库约束，比如主键、非空、长度限制、邮箱格式；
密码存哈希值，不存明文，保证安全；
CreatedAt和UpdatedAt自动设置为当前UTC时间，避免时区问题。
DTO（UserDto.cs）：数据传输对象，避免暴露敏感数据
csharp

	namespace RestfulApiServer.Models.DTOs;
	
	/// <summary>
	/// 用户DTO，用于API返回数据，避免暴露密码哈希等敏感字段
	/// </summary>
	public class UserDto
	{
	public int Id { get; set; }
	public string Username { get; set; } = string.Empty;
	public string Email { get; set; } = string.Empty;
	public DateTime CreatedAt { get; set; }
	}
	
	/// <summary>
	/// 创建用户DTO，用于API接收数据，只包含必要字段
	/// </summary>
	public class CreateUserDto
	{
	public string Username { get; set; } = string.Empty;
	public string Email { get; set; } = string.Empty;
	public string Password { get; set; } = string.Empty; // 明文密码，服务层会哈希
	}
	
	/// <summary>
	/// 更新用户DTO，用于API接收数据，只包含可更新字段
	/// </summary>
	public class UpdateUserDto
	{
	public string? Email { get; set; } // 可空，允许只更新部分字段
	}

逐行拆解：
DTO和数据模型分离，API返回数据时避免暴露敏感字段（比如PasswordHash）；
不同场景用不同DTO，比如创建用户用CreateUserDto，更新用户用UpdateUserDto，符合单一职责原则；
可空字段允许只更新部分字段，比如只更新邮箱，不用传用户名。
2. 数据访问层（Repositories/）
仓储接口（IUserRepository.cs）：定义数据访问方法
csharp

	using RestfulApiServer.Models;
	
	namespace RestfulApiServer.Repositories;
	
	/// <summary>
	/// 用户仓储接口，定义数据访问方法
	/// </summary>
	public interface IUserRepository
	{
	Task<User?> GetByIdAsync(int id);
	Task<User?> GetByUsernameAsync(string username);
	Task<IEnumerable<User>> GetAllAsync();
	Task<User> CreateAsync(User user);
	Task<User?> UpdateAsync(User user);
	Task<bool> DeleteAsync(int id);
	}

逐行拆解：
接口定义数据访问方法，业务层依赖接口，不依赖具体实现，方便切换数据库（比如从SQL Server换成MySQL）；
所有方法都是异步，避免阻塞主线程，提升性能。
仓储实现（UserRepository.cs）：用Entity Framework Core操作数据库
csharp

	using Microsoft.EntityFrameworkCore;
	using RestfulApiServer.Models;
	
	namespace RestfulApiServer.Repositories;
	
	/// <summary>
	/// 用户仓储实现，用Entity Framework Core操作SQL Server数据库
	/// </summary>
	public class UserRepository : IUserRepository
	{
	private readonly AppDbContext _dbContext;
	
	// 构造函数注入DbContext，依赖注入
	public UserRepository(AppDbContext dbContext)
	{
	_dbContext = dbContext;
	}
	
	public async Task<User?> GetByIdAsync(int id)
	{
	return await _dbContext.Users.FindAsync(id);
	}
	
	public async Task<User?> GetByUsernameAsync(string username)
	{
	return await _dbContext.Users.FirstOrDefaultAsync(u => u.Username == username);
	}
	
	public async Task<IEnumerable<User>> GetAllAsync()
	{
	return await _dbContext.Users.ToListAsync();
	}
	
	public async Task<User> CreateAsync(User user)
	{
	_dbContext.Users.Add(user);
	await _dbContext.SaveChangesAsync();
	return user;
	}
	
	public async Task<User?> UpdateAsync(User user)
	{
	_dbContext.Entry(user).State = EntityState.Modified;
	user.UpdatedAt = DateTime.UtcNow;
	await _dbContext.SaveChangesAsync();
	return user;
	}
	
	public async Task<bool> DeleteAsync(int id)
	{
	var user = await _dbContext.Users.FindAsync(id);
	if (user == null) return false;
	
	_dbContext.Users.Remove(user);
	await _dbContext.SaveChangesAsync();
	return true;
	}
	}

逐行拆解：
构造函数注入AppDbContext，依赖注入，解耦仓储和DbContext；
用Entity Framework Core的异步方法操作数据库，提升性能；
UpdateAsync方法设置UpdatedAt为当前UTC时间，记录更新时间；
DeleteAsync方法返回bool，表示是否删除成功。
数据库上下文（AppDbContext.cs）：配置数据库连接和实体
csharp

	using Microsoft.EntityFrameworkCore;
	using RestfulApiServer.Models;
	
	namespace RestfulApiServer.Repositories;
	
	/// <summary>
	/// 数据库上下文，配置数据库连接和实体
	/// </summary>
	public class AppDbContext : DbContext
	{
	public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
	{
	}
	
	// 定义DbSet，对应数据库表
	public DbSet<User> Users { get; set; } = null!;
	
	protected override void OnModelCreating(ModelBuilder modelBuilder)
	{
	// 配置实体约束，比如用户名唯一
	modelBuilder.Entity<User>()
	.HasIndex(u => u.Username)
	.IsUnique();
	
	// 配置邮箱唯一
	modelBuilder.Entity<User>()
	.HasIndex(u => u.Email)
	.IsUnique();
	}
	}

逐行拆解：
构造函数注入DbContextOptions，从配置文件读取数据库连接字符串；
DbSet对应数据库Users表；
OnModelCreating方法配置实体约束，比如用户名和邮箱唯一，避免重复数据。
3. 业务逻辑层（Services/）
用户服务接口（IUserService.cs）：定义业务逻辑方法
csharp

	using RestfulApiServer.Models;
	using RestfulApiServer.Models.DTOs;
	
	namespace RestfulApiServer.Services;
	
	/// <summary>
	/// 用户服务接口，定义业务逻辑方法
	/// </summary>
	public interface IUserService
	{
	Task<UserDto?> GetByIdAsync(int id);
	Task<IEnumerable<UserDto>> GetAllAsync();
	Task<UserDto> CreateAsync(CreateUserDto createUserDto);
	Task<UserDto?> UpdateAsync(int id, UpdateUserDto updateUserDto);
	Task<bool> DeleteAsync(int id);
	Task<string> LoginAsync(string username, string password); // 登录方法，返回JWT Token
	}

逐行拆解：
业务逻辑层依赖仓储接口，不依赖具体实现，解耦业务和数据访问；
方法参数和返回值用DTO，避免暴露数据模型的敏感字段；
LoginAsync方法返回JWT Token，用于身份验证。
用户服务实现（UserService.cs）：处理核心业务逻辑
csharp

	using System.IdentityModel.Tokens.Jwt;
	using System.Security.Claims;
	using System.Text;
	using Microsoft.IdentityModel.Tokens;
	using RestfulApiServer.Models;
	using RestfulApiServer.Models.DTOs;
	using RestfulApiServer.Repositories;
	
	namespace RestfulApiServer.Services;
	
	/// <summary>
	/// 用户服务实现，处理核心业务逻辑
	/// </summary>
	public class UserService : IUserService
	{
	private readonly IUserRepository _userRepository;
	private readonly IConfiguration _configuration;
	
	public UserService(IUserRepository userRepository, IConfiguration configuration)
	{
	_userRepository = userRepository;
	_configuration = configuration;
	}
	
	public async Task<UserDto?> GetByIdAsync(int id)
	{
	var user = await _userRepository.GetByIdAsync(id);
	return user == null ? null : MapToUserDto(user);
	}
	
	public async Task<IEnumerable<UserDto>> GetAllAsync()
	{
	var users = await _userRepository.GetAllAsync();
	return users.Select(MapToUserDto);
	}
	
	public async Task<UserDto> CreateAsync(CreateUserDto createUserDto)
	{
	// 检查用户名是否已存在
	var existingUser = await _userRepository.GetByUsernameAsync(createUserDto.Username);
	if (existingUser != null)
	{
	throw new ArgumentException($"用户名 {createUserDto.Username} 已存在");
	}
	
	// 哈希密码，用BCrypt（需要安装NuGet包：BCrypt.Net-Next）
	string passwordHash = BCrypt.Net.BCrypt.HashPassword(createUserDto.Password);
	
	var user = new User
	{
	Username = createUserDto.Username,
	Email = createUserDto.Email,
	PasswordHash = passwordHash
	};
	
	var createdUser = await _userRepository.CreateAsync(user);
	return MapToUserDto(createdUser);
	}
	
	public async Task<UserDto?> UpdateAsync(int id, UpdateUserDto updateUserDto)
	{
	var user = await _userRepository.GetByIdAsync(id);
	if (user == null) return null;
	
	// 更新可空字段
	if (!string.IsNullOrEmpty(updateUserDto.Email))
	{
	user.Email = updateUserDto.Email;
	}
	
	var updatedUser = await _userRepository.UpdateAsync(user);
	return updatedUser == null ? null : MapToUserDto(updatedUser);
	}
	
	public async Task<bool> DeleteAsync(int id)
	{
	return await _userRepository.DeleteAsync(id);
	}
	
	public async Task<string> LoginAsync(string username, string password)
	{
	var user = await _userRepository.GetByUsernameAsync(username);
	if (user == null || !BCrypt.Net.BCrypt.Verify(password, user.PasswordHash))
	{
	throw new UnauthorizedAccessException("用户名或密码错误");
	}
	
	// 生成JWT Token
	var tokenHandler = new JwtSecurityTokenHandler();
	var key = Encoding.ASCII.GetBytes(_configuration["Jwt:Secret"]!);
	var tokenDescriptor = new SecurityTokenDescriptor
	{
	Subject = new ClaimsIdentity(new[]
	{
	new Claim(ClaimTypes.NameIdentifier, user.Id.ToString()),
	new Claim(ClaimTypes.Name, user.Username)
	}),
	Expires = DateTime.UtcNow.AddHours(24), // Token有效期24小时
	SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
	};
	var token = tokenHandler.CreateToken(tokenDescriptor);
	return tokenHandler.WriteToken(token);
	}
	
	// 数据模型转DTO
	private UserDto MapToUserDto(User user)
	{
	return new UserDto
	{
	Id = user.Id,
	Username = user.Username,
	Email = user.Email,
	CreatedAt = user.CreatedAt
	};
	}
	}

逐行拆解：
构造函数注入仓储接口和配置，依赖注入，解耦业务和数据访问、配置；
CreateAsync方法检查用户名是否已存在，哈希密码（用BCrypt，安全可靠）；
LoginAsync方法验证用户名和密码，生成JWT Token，包含用户ID和用户名；
数据模型转DTO用私有方法MapToUserDto，避免重复代码；
异常处理：业务逻辑错误抛出具体异常（比如ArgumentException、UnauthorizedAccessException），全局异常过滤器统一处理。
4. API控制器（Controllers/）
用户控制器（UsersController.cs）：处理HTTP请求
csharp

	using Microsoft.AspNetCore.Authorization;
	using Microsoft.AspNetCore.Mvc;
	using RestfulApiServer.Models.DTOs;
	using RestfulApiServer.Services;
	
	namespace RestfulApiServer.Controllers;
	
	/// <summary>
	/// 用户API控制器，处理用户相关的HTTP请求
	/// </summary>
	[ApiController] // 自动模型验证、返回JSON格式
	[Route("api/[controller]")] // 路由模板：api/users
	[Authorize] // 所有接口需要授权，除了Login和Create
	public class UsersController : ControllerBase
	{
	private readonly IUserService _userService;
	
	public UsersController(IUserService userService)
	{
	_userService = userService;
	}
	
	/// <summary>
	/// 根据ID获取用户信息
	/// </summary>
	/// <param name="id">用户ID</param>
	/// <returns>用户信息</returns>
	[HttpGet("{id}")] // 路由：api/users/{id}
	[ProducesResponseType(StatusCodes.Status200OK)] // 成功返回200
	[ProducesResponseType(StatusCodes.Status404NotFound)] // 用户不存在返回404
	public async Task<ActionResult<UserDto>> GetById(int id)
	{
	var userDto = await _userService.GetByIdAsync(id);
	if (userDto == null)
	{
	return NotFound(new { Message = $"用户ID {id} 不存在" });
	}
	return Ok(userDto);
	}
	
	/// <summary>
	/// 获取所有用户信息
	/// </summary>
	/// <returns>用户列表</returns>
	[HttpGet] // 路由：api/users
	[ProducesResponseType(StatusCodes.Status200OK)]
	public async Task<ActionResult<IEnumerable<UserDto>>> GetAll()
	{
	var userDtos = await _userService.GetAllAsync();
	return Ok(userDtos);
	}
	
	/// <summary>
	/// 创建用户（不需要授权）
	/// </summary>
	/// <param name="createUserDto">创建用户参数</param>
	/// <returns>创建的用户信息</returns>
	[HttpPost] // 路由：api/users
	[AllowAnonymous] // 允许匿名访问
	[ProducesResponseType(StatusCodes.Status201Created)] // 创建成功返回201
	[ProducesResponseType(StatusCodes.Status400BadRequest)] // 参数错误返回400
	public async Task<ActionResult<UserDto>> Create(CreateUserDto createUserDto)
	{
	try
	{
	var userDto = await _userService.CreateAsync(createUserDto);
	// 返回201 Created，Location头包含新资源的URL
	return CreatedAtAction(nameof(GetById), new { id = userDto.Id }, userDto);
	}
	catch (ArgumentException ex)
	{
	return BadRequest(new { Message = ex.Message });
	}
	}
	
	/// <summary>
	/// 更新用户信息
	/// </summary>
	/// <param name="id">用户ID</param>
	/// <param name="updateUserDto">更新用户参数</param>
	/// <returns>更新后的用户信息</returns>
	[HttpPut("{id}")] // 路由：api/users/{id}
	[ProducesResponseType(StatusCodes.Status200OK)]
	[ProducesResponseType(StatusCodes.Status404NotFound)]
	public async Task<ActionResult<UserDto>> Update(int id, UpdateUserDto updateUserDto)
	{
	var userDto = await _userService.UpdateAsync(id, updateUserDto);
	if (userDto == null)
	{
	return NotFound(new { Message = $"用户ID {id} 不存在" });
	}
	return Ok(userDto);
	}
	
	/// <summary>
	/// 删除用户
	/// </summary>
	/// <param name="id">用户ID</param>
	/// <returns>删除结果</returns>
	[HttpDelete("{id}")] // 路由：api/users/{id}
	[ProducesResponseType(StatusCodes.Status200OK)]
	[ProducesResponseType(StatusCodes.Status404NotFound)]
	public async Task<IActionResult> Delete(int id)
	{
	var deleted = await _userService.DeleteAsync(id);
	if (!deleted)
	{
	return NotFound(new { Message = $"用户ID {id} 不存在" });
	}
	return Ok(new { Message = "删除成功" });
	}
	
	/// <summary>
	/// 用户登录（不需要授权）
	/// </summary>
	/// <param name="username">用户名</param>
	/// <param name="password">密码</param>
	/// <returns>JWT Token</returns>
	[HttpPost("login")] // 路由：api/users/login
	[AllowAnonymous]
	[ProducesResponseType(StatusCodes.Status200OK)]
	[ProducesResponseType(StatusCodes.Status401Unauthorized)] // 登录失败返回401
	public async Task<ActionResult<string>> Login(string username, string password)
	{
	try
	{
	var token = await _userService.LoginAsync(username, password);
	return Ok(new { Token = token });
	}
	catch (UnauthorizedAccessException ex)
	{
	return Unauthorized(new { Message = ex.Message });
	}
	}
	}

逐行拆解：
[ApiController]：自动模型验证（比如必填字段为空时自动返回400错误），自动返回JSON格式；
[Route]：路由模板，[controller]自动替换为控制器名（Users），路由为api/users；
[Authorize]：所有接口需要授权，除了用[AllowAnonymous]标记的Create和Login接口；
HTTP方法特性：[HttpGet]、[HttpPost]、[HttpPut]、[HttpDelete]对应HTTP方法；
返回类型：用ActionResult，可以返回不同的HTTP状态码，比如Ok（200）、Created（201）、NotFound（404）、BadRequest（400）、Unauthorized（401）；
CreatedAtAction：返回201 Created状态码，Location头包含新资源的URL（比如api/users/123），符合RESTful规范。
5. 全局异常过滤器（Filters/）
全局异常过滤器（GlobalExceptionFilter.cs）：统一处理异常
csharp
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

namespace RestfulApiServer.Filters;

/// <summary>
/// 全局异常过滤器，统一处理所有未捕获的异常
/// </summary>
public class GlobalExceptionFilter : IExceptionFilter
{
private readonly ILogger<GlobalExceptionFilter> _logger;

public GlobalExceptionFilter(ILogger<GlobalExceptionFilter> logger)
{
_logger = logger;
}

public void OnException(ExceptionContext context)
{
// 记录异常日志
_logger.LogError(context.Exception, "未捕获的异常：{Message}", context.Exception.Message);

// 统一返回错误格式
var problemDetails = new ProblemDetails
{
Status = StatusCodes.Status500InternalServerError,
Title = "服务器错误",
Detail = context.Exception.Message,
Instance = context.HttpContext.Request.Path,
Extensions = { { "timestamp", DateTime.UtcNow.ToString("o") } }
};

// 根据异常类型返回不同的状态码
if (context.Exception is UnauthorizedAccessException)
{
problemDetails.Status = StatusCodes.Status401Unauthorized;
problemDetails.Title = "未授权";
}
else if (context.Exception is ArgumentException)
{
problemDetails.Status = StatusCodes.Status400BadRequest;
problemDetails.Title = "参数错误";
}

context.Result = new ObjectResult(problemDetails)
{
StatusCode = problemDetails.Status
};
context.ExceptionHandled = true;
}
}

逐行拆解：
实现IExceptionFilter，统一处理所有未捕获的异常；
记录异常日志，方便排查问题；
统一返回ProblemDetails格式的错误信息，包含状态码、标题、详细信息、请求路径、时间戳；
根据异常类型返回不同的状态码，比如未授权返回401，参数错误返回400，服务器错误返回500。
6. 启动类（Program.cs）：配置服务和中间件
csharp

	using Microsoft.AspNetCore.Authentication.JwtBearer;
	using Microsoft.EntityFrameworkCore;
	using Microsoft.IdentityModel.Tokens;
	using Microsoft.OpenApi.Models;
	using RestfulApiServer.Filters;
	using RestfulApiServer.Repositories;
	using RestfulApiServer.Services;
	using Serilog;
	
	var builder = WebApplication.CreateBuilder(args);
	
	// 配置Serilog日志
	Log.Logger = new LoggerConfiguration()
	.ReadFrom.Configuration(builder.Configuration)
	.CreateLogger();
	builder.Host.UseSerilog();
	
	// 添加服务到DI容器
	builder.Services.AddControllers(options =>
	{
	// 添加全局异常过滤器
	options.Filters.Add<GlobalExceptionFilter>();
	});
	
	// 添加Swagger文档
	builder.Services.AddEndpointsApiExplorer();
	builder.Services.AddSwaggerGen(c =>
	{
	c.SwaggerDoc("v1", new OpenApiInfo { Title = "RESTful API Server", Version = "v1" });
	
	// 添加JWT认证支持
	c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
	{
	Description = "JWT认证，格式：Bearer {Token}",
	Name = "Authorization",
	In = ParameterLocation.Header,
	Type = SecuritySchemeType.ApiKey,
	Scheme = "Bearer"
	});
	c.AddSecurityRequirement(new OpenApiSecurityRequirement
	{
	{
	new OpenApiSecurityScheme
	{
	Reference = new OpenApiReference
	{
	Type = ReferenceType.SecurityScheme,
	Id = "Bearer"
	}
	},
	Array.Empty<string>()
	}
	});
	
	// 加载XML注释（需要在项目属性中启用XML文档文件）
	var xmlFile = $"{System.Reflection.Assembly.GetExecutingAssembly().GetName().Name}.xml";
	var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
	c.IncludeXmlComments(xmlPath);
	});
	
	// 添加数据库上下文（SQL Server）
	builder.Services.AddDbContext<AppDbContext>(options =>
	{
	options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
	});
	
	// 添加仓储和服务
	builder.Services.AddScoped<IUserRepository, UserRepository>();
	builder.Services.AddScoped<IUserService, UserService>();
	
	// 添加JWT认证
	builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
	.AddJwtBearer(options =>
	{
	options.TokenValidationParameters = new TokenValidationParameters
	{
	ValidateIssuerSigningKey = true,
	IssuerSigningKey = new SymmetricSecurityKey(System.Text.Encoding.ASCII.GetBytes(builder.Configuration["Jwt:Secret"]!)),
	ValidateIssuer = false,
	ValidateAudience = false,
	ClockSkew = TimeSpan.Zero // 允许的时钟偏差，设置为0避免Token提前过期
	};
	});
	
	// 添加CORS支持，允许所有来源（生产环境要限制具体来源）
	builder.Services.AddCors(options =>
	{
	options.AddPolicy("AllowAll", policy =>
	{
	policy.AllowAnyOrigin()
	.AllowAnyMethod()
	.AllowAnyHeader();
	});
	});
	
	// 添加缓存服务（Redis）
	builder.Services.AddStackExchangeRedisCache(options =>
	{
	options.Configuration = builder.Configuration.GetConnectionString("Redis");
	options.InstanceName = "RestfulApiServer:";
	});
	
	var app = builder.Build();
	
	// 配置中间件管道
	if (app.Environment.IsDevelopment())
	{
	app.UseSwagger();
	app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "RESTful API Server v1"));
	}
	
	// 启用HTTPS重定向
	app.UseHttpsRedirection();
	
	// 启用CORS
	app.UseCors("AllowAll");
	
	// 启用认证和授权
	app.UseAuthentication();
	app.UseAuthorization();
	
	// 映射控制器
	app.MapControllers();
	
	app.Run();

逐行拆解：
Serilog配置：结构化日志，支持输出到控制台、文件、Elasticsearch，方便搜索和分析；
Swagger配置：自动生成API文档，支持JWT认证，加载XML注释，方便前端对接；
数据库上下文配置：用SQL Server，从配置文件读取连接字符串；
依赖注入配置：AddScoped表示每个请求创建一个实例，适合Web应用；
JWT认证配置：验证Token的签名，设置时钟偏差为0，避免Token提前过期；
CORS配置：允许所有来源（生产环境要限制具体来源，比如https://yourdomain.com）；
Redis缓存配置：用StackExchange.Redis做分布式缓存，提升性能；
中间件管道顺序：中间件顺序很重要，比如UseHttpsRedirection要在UseRouting之前，UseAuthentication要在UseAuthorization之前。
7. 配置文件（appsettings.json）
json

	{
	"Logging": {
	"LogLevel": {
	"Default": "Information",
	"Microsoft.AspNetCore": "Warning"
	}
	},
	"AllowedHosts": "*",
	"ConnectionStrings": {
	"DefaultConnection": "Server=(localdb)\mssqllocaldb;Database=RestfulApiServer;Trusted_Connection=True;MultipleActiveResultSets=true",
	"Redis": "localhost:6379"
	},
	"Jwt": {
	"Secret": "your-super-secret-jwt-key-at-least-32-characters-long",
	"Issuer": "RestfulApiServer",
	"Audience": "RestfulApiServerClients"
	},
	"Serilog": {
	"Using": [ "Serilog.Sinks.Console", "Serilog.Sinks.File" ],
	"MinimumLevel": {
	"Default": "Information",
	"Override": {
	"Microsoft": "Warning",
	"System": "Warning"
	}
	},
	"WriteTo": [
	{ "Name": "Console" },
	{
	"Name": "File",
	"Args": {
	"path": "logs/log-.txt",
	"rollingInterval": "Day",
	"formatter": "Serilog.Formatting.Compact.CompactJsonFormatter, Serilog.Formatting.Compact"
	}
	}
	],
	"Enrich": [ "FromLogContext", "WithMachineName", "WithThreadId" ]
	}
	}

逐行拆解：
ConnectionStrings：数据库和Redis的连接字符串；
Jwt:Secret：JWT签名密钥，至少32字符，生产环境要保密，用环境变量存储；
Serilog：配置日志输出到控制台和文件，每天生成一个日志文件，用CompactJsonFormatter输出结构化日志。
四、生产级优化技巧：让API服务器高性能、高可用、安全

1. 性能优化
   缓存：用Redis做分布式缓存，缓存频繁查询的数据（比如用户信息），减少数据库查询；
   异步编程：所有IO操作（数据库、Redis、HTTP请求）都用异步，避免阻塞主线程；
   数据库优化：添加索引（比如用户名、邮箱），分页查询（用Skip和Take），避免查询所有数据；
   响应压缩：启用Gzip或Brotli压缩，减少带宽消耗，ASP.NET Core默认支持，只需在Program.cs中添加app.UseResponseCompression()；
   限流：用AspNetCoreRateLimit限制API的请求频率，避免恶意攻击，比如限制每个IP每分钟最多100次请求；
   对象池：复用频繁创建的对象（比如DTO、数据库上下文），减少GC。
2. 高可用优化
   负载均衡：用Nginx或Azure Application Gateway做负载均衡，分发请求到多个API服务器；
   健康检查：添加健康检查端点（比如/health），监控服务器状态，负载均衡器自动剔除不健康的服务器；
   分布式会话：用Redis做分布式会话，避免Session粘滞；
   自动扩容：用Kubernetes或Azure App Service自动扩容，根据CPU或内存使用率自动增加服务器数量。
3. 安全优化
   JWT认证：用JWT做身份验证，Token存储在客户端，服务器无状态；
   HTTPS：强制HTTPS，用Let's Encrypt免费证书，避免数据被窃听或篡改；
   输入验证：所有用户输入都要验证，避免SQL注入、XSS攻击；
   权限控制：基于角色的访问控制（RBAC），不同角色访问不同的API；
   API密钥：第三方调用API用API密钥验证，限制API的使用范围。
4. 监控和日志
   结构化日志：用Serilog输出结构化日志，方便搜索和分析；
   APM监控：用Application Insights或Datadog监控API的响应时间、吞吐量、错误率；
   告警：配置告警规则，比如API响应时间超过500ms、错误率超过1%时发送告警；
   链路追踪：用OpenTelemetry追踪请求的完整链路，方便排查性能瓶颈。
   五、性能测试：ASP.NET Core高性能验证
   测试环境
   CPU：Intel i7-10700K（8核16线程）
   内存：16GB DDR4
   操作系统：Windows 10 64位
   数据库：SQL Server 2022
   Redis：6.2
   测试工具：JMeter
   测试结果

1. 总结
   RESTful API的核心是资源导向，用HTTP方法做操作，用状态码表示结果；
   ASP.NET Core是高性能、轻量、跨平台的Web框架，适合开发RESTful API；
   分层架构（控制器→服务→仓储）解耦业务和数据访问，易维护、易测试；
   生产环境必须做全局异常处理、JWT认证、Swagger文档、结构化日志、缓存、限流；
   高性能、高可用、安全是生产级API服务器的三个核心要求。
2. 选型建议
   场景 推荐技术栈
   企业级RESTful API ASP.NET Core + Entity Framework Core + Redis + JWT
   高性能API FastEndpoints（比ASP.NET Core更轻量，性能更高）
   轻量API NancyFX（轻量灵活，适合小型项目）
   复杂查询场景 GraphQL（替代RESTful，适合多端数据聚合）
   实时通信 SignalR（基于WebSocket，适合即时通讯、实时监控）
   下一节我们会学习实战项目3：即时通讯服务器，基于SignalR和WebSocket，支持一对一聊天、群聊、文件传输！

转载请注明出处：https://www.xin3721.com/ArticlecSharp/c49583.html