久爱编程网

使用HTTPS访问Wordpress站点的问题解决

Wed, 19 Nov 2025 20:49:34 +0800

安装Wordpress后使用HTTPS访问，可能会出现页面错乱问题，在浏览器控制台显示类似如下错误提示：

Blocked loading mixed active content “http://9icode.com/wp-includes/css/dashicons.min.css?ver=6.3.1”
Blocked loading mixed active content “http://9icode.com/wp-includes/css/admin-bar.min.css?ver=6.3.1”
Blocked loading mixed active content “http://9icode.com/wp-includes/css/dist/block-library/style.min.css?ver=6.3.1”
Blocked loading mixed active content “http://9icode.com/wp-content/themes/bloghash/assets/css/swiper-bundle.min.css?ver=6.3.1”
Blocked loading mixed active content “http://9icode.com/wp-content/themes/bloghash/assets/css/all.min.css?ver=5.15.4”
Blocked loading mixed active content “http://9icode.com/wp-content/themes/bloghash/assets/css/style.min.css?ver=1.0.25”
Blocked loading mixed active content “http://9icode.com/wp-content/uploads/bloghash/dynamic-styles.css?ver=1761397781”
Blocked loading mixed active content “http://9icode.com/wp-includes/js/jquery/jquery.min.js?ver=3.7.0”
Loading failed for the <script> with source “http://en.9icode.com/wp-includes/js/jquery/jquery.min.js?ver=3.7.0”
Blocked loading mixed active content “http://en.9icode.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=3.4.1”

原因是部分CSS和JS文件在HTTPS访问时，仍然是HTTP地址，由于浏览器的CSP策略，HTTPS不能HTTP资源，解决方案是在wp-config.php开头添加如下行：

define('FORCE_SSL_ADMIN', true);
$_SERVER['HTTPS'] = 'on';

对于其它第三方插件的HTTPS问题可以安装“SSL Insecure Content Fixer”，设置“Fix insecure content”为“Capture”、“Ignore external sites”为“Only fix content pointing to this WordPress site”、“HTTPS detection”为“HTTP_X_FORWARDED_PROTO (e.g. load balancer, reverse proxy, NginX)”。

如何安装pnpm

Mon, 10 Nov 2025 17:42:05 +0800

1、安装NodeJS，NodeJS自带npm包管理器，且依赖Python；

2、在命令提示符、VSCode或PowerShell等终端中执行：

npm install -g pnpm

3、若运行“pnpm install”提示无权限是因为PowerShell的执行策略限制，执行如下命令修改：

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned

4、参考：https://learn.microsoft.com/zh-cn/powershell/module/microsoft.powershell.core/about/about_execution_policies?view=powershell-7.5

5、若执行pnpm install时提示找不到test命令，则打开package.json添加test命令：

{
  ...
  "scripts": {
    "i": "pnpm install",
    "dev": "pnpm vite --mode base",
    "test": ""
  },
  ...
}

使用了husky的Vue3项目在执行命令“pnpm install”时提示“husky - install command is DEPRECATED”问题解决

Mon, 10 Nov 2025 17:34:48 +0800

在使用了husky的Vue3项目中，执行命令“pnpm install”时，若报如下错误：

husky - install command is DEPRECATED

是因为package.json中husky的安装命令已过时，改为最新安装命令即可：

"prepare": "pnpm dlx husky-init && husky install"

若使用npm或yarn，可改为如下安装命令：

"prepare": "npx husky-init && husky install"

若在提交Git时提示找不到.husky/commit-msg等类似错误，但该文件确实存在则可能是权限问题，使用Git Bash打开.husky所在目录，并赋予commit-msg写入权限：

# 检查文件权限
ls -la .husky/commit-msg

# 如果没有执行权限，添加执行权限
chmod +x .husky/commit-msg

# 或者递归设置整个 .husky 目录的权限
chmod -R +x .husky/

OpenIddict从零开始（三）——基于ASP.NET Core创建自定义服务端

Mon, 27 Oct 2025 15:19:13 +0800

1、使用现有或新建一个"ASP.NET Core Empty"等相关类型的项目，在Nuget Package Manager中引用OpenIddict.AspNetCore、OpenIddict.EntityFrameworkCore两个Nuget包，或在*.csproj项目文件中新增如下行：

  <ItemGroup>
    <PackageReference Include="OpenIddict.AspNetCore" Version="7.1.0" />
    <PackageReference Include="OpenIddict.EntityFrameworkCore" Version="7.1.0" />
  </ItemGroup>

OpenIddict.AspNetCore是OpenIddict的核心类库，OpenIddict.EntityFrameworkCore是OpenIddict的EF Core支持类库。

2、自定义一个OpenIddict注册相关类：

/// <summary>
/// 
/// </summary>
public class Shared
{
    /// <summary>
    /// 
    /// </summary>
    public static string UnsupportedDatabaseTypeError { get; set; } = "";
}

/// <summary>
/// OIDC Options
/// </summary>
public class OIDCOptions
{
    /// <summary>
    /// Database Type
    /// </summary>
    public string DatabaseType { get; set; } = "";
    /// <summary>
    /// Connection String
    /// </summary>
    public string ConnectionString { get; set; } = "";
    /// <summary>
    /// Token EndpointUris
    /// </summary>
    public string TokenEndpointUris { get; set; } = "connect/token";
    /// <summary>
    /// Authorizatio nEndpointUris
    /// </summary>
    public string AuthorizationEndpointUris { get; set; } = "connect/authorize";
    /// <summary>
    /// UserInfo EndpointUris
    /// </summary>
    public string UserInfoEndpointUris { get; set; } = "connect/userinfo";
    /// <summary>
    /// EndSession EndpointUri
    /// </summary>
    public string EndSessionEndpointUri { get; set; } = "connect/logout";
    /// <summary>
    /// Action to Configure DbContextOptions
    /// </summary>
    public Action<DbContextOptionsBuilder>? ActionDbContextOptions { get; set; }
}

/// <summary>
/// 
/// </summary>
public class OpenIddictDbContext : IdentityDbContext
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="options"></param>
    public OpenIddictDbContext(DbContextOptions<OpenIddictDbContext> options)
        : base(options)
    {
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="builder"></param>
    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
    }
}

/// <summary>
/// Interface IRegisterable 
/// </summary>
public interface IOIDCRegisterable
{
    /// <summary>
    /// Register OIDC
    /// </summary>
    /// <param name="services">Service Collection</param>
    void Register(IServiceCollection services);
}

/// <summary>
/// OpenIddict Register
/// </summary>
public class OpenIddictRegister: Singleton<OpenIddictRegister>, IOIDCRegisterable
{
    /// <summary>
    /// Register OpenIddict
    /// </summary>
    /// <param name="services"></param>
    /// <exception cref="InvalidOperationException"></exception>
    public void Register(IServiceCollection services)
    {
        OIDCOptions oidcOptions;
        IStringLocalizer<Shared> SL;
        using (var serviceProvider = services.BuildServiceProvider())
        {
            oidcOptions = serviceProvider.GetRequiredService<IOptions<OIDCOptions>>().Value;
            SL = serviceProvider.GetRequiredService<IStringLocalizer<Shared>>();
        }
        services.AddDbContext<OpenIddictDbContext>(options =>
        {
            if (null != oidcOptions.ActionDbContextOptions)
            {
                oidcOptions.ActionDbContextOptions(options);
            }
            else
            {
                switch (oidcOptions.DatabaseType)
                {
                    case "SqlServer":
                        // Configure Entity Framework Core to use Microsoft SQL Server.
                        options.UseSqlServer(oidcOptions.ConnectionString);
                        break;
                    case "MySQL":
                        // Configure Entity Framework Core to use MySQL.
                        options.UseMySQL(oidcOptions.ConnectionString);
                        break;
                    case "Sqlite":
                        // Configure Entity Framework Core to use SQLite.
                        options.UseSqlite(oidcOptions.ConnectionString);
                        break;
                    default:
                        throw new InvalidOperationException(SL[nameof(Shared.UnsupportedDatabaseTypeError), oidcOptions.DatabaseType]);
                }
            }

            // Register the entity sets needed by OpenIddict.
            // Note: use the generic overload if you need to replace the default OpenIddict entities.
            options.UseOpenIddict();
        });

        services.AddOpenIddict()
            // Register the OpenIddict core components.
            .AddCore(options =>
            {
                // Configure OpenIddict to use the Entity Framework Core stores and models.
                // Note: call ReplaceDefaultEntities() to replace the default entities.
                options.UseEntityFrameworkCore()
                        .UseDbContext<OpenIddictDbContext>();
            })
            // Register the OpenIddict server components.
            .AddServer(options =>
            {
                // Enable the token endpoint.
                options.SetTokenEndpointUris(oidcOptions.TokenEndpointUris);
                options.SetAuthorizationEndpointUris(oidcOptions.AuthorizationEndpointUris);
                options.SetUserInfoEndpointUris(oidcOptions.UserInfoEndpointUris);
                options.SetEndSessionEndpointUris(oidcOptions.EndSessionEndpointUri);

                // Register the signing and encryption credentials.
                options.AddDevelopmentEncryptionCertificate()
                        .AddDevelopmentSigningCertificate();

                // Enable the client credentials flow.
                options.AllowClientCredentialsFlow();
                options.AllowAuthorizationCodeFlow();
                options.AllowRefreshTokenFlow();

                // Register the ASP.NET Core host and configure the ASP.NET Core options.
                options.UseAspNetCore()
                        .EnableTokenEndpointPassthrough()
                        .EnableAuthorizationEndpointPassthrough()
                        .EnableUserInfoEndpointPassthrough()
                        .EnableEndSessionEndpointPassthrough()
                        .DisableTransportSecurityRequirement();
            })
            // Register the OpenIddict validation components.
            .AddValidation(options =>
            {
                // Import the configuration from the local OpenIddict server instance.
                options.UseLocalServer();

                // Register the ASP.NET Core host.
                options.UseAspNetCore();
            });
           
        services.AddDefaultIdentity<IdentityUser>(options =>
        {
            options.SignIn.RequireConfirmedAccount = true;
            options.SignIn.RequireConfirmedEmail = true;

            options.User.RequireUniqueEmail = true;

            options.Password.RequiredUniqueChars = 6;
            options.Password.RequiredLength = 8;
        })
            .AddEntityFrameworkStores<OpenIddictDbContext>();

        services.AddScoped<IOIDCExecutable, OpenIddictExecutor>();
    }
}

/// <summary>
/// 
/// </summary>
public static class OpenIddictRegisterHelper
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="services"></param>
    /// <param name="optionsBuidlerAction"></param>
    public static void AddOIDC(this IServiceCollection services, Action<OIDCOptions> optionsAction)
    {
        services.Configure(optionsAction);
        OpenIddictRegister.Instance.Register(services);
    }
}

/// <summary>
/// Interface IOIDCExecutable 
/// </summary>
public interface IOIDCExecutable
{
    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    Task<IActionResult> Authorize(Controller baseController);

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    Task<IActionResult> GetUserInfo(Controller baseController);

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    Task<IActionResult> Logout(Controller baseController);

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    Task<IActionResult> GetToken(Controller baseController);
}

/// <summary>
/// OpenIddict Executor
/// </summary>
public class OpenIddictExecutor : IOIDCExecutable
{
    /// <summary>
    /// 
    /// </summary>
    private readonly IOpenIddictApplicationManager _applicationManager;
    /// <summary>
    /// 
    /// </summary>
    private readonly UserManager<IdentityUser> _userManager;
    /// <summary>
    /// 
    /// </summary>
    private readonly SignInManager<IdentityUser> _signInManager;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="applicationManager"></param>
    /// <param name="userManager"></param>
    /// <param name="signInManager"></param>
    public OpenIddictExecutor(IOpenIddictApplicationManager applicationManager,
        UserManager<IdentityUser> userManager,
        SignInManager<IdentityUser> signInManager)
    {
        _applicationManager = applicationManager;
        _userManager = userManager;
        _signInManager = signInManager;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    /// <exception cref="NotImplementedException"></exception>
    public async Task<IActionResult> Authorize(Controller baseController)
    {
        var request = baseController.HttpContext.GetOpenIddictServerRequest();
        if (!request?.IsAuthorizationCodeGrantType() ?? false)
        {
            throw new NotImplementedException("The specified grant is not implemented.");
        }

        var authResult = await baseController.HttpContext.AuthenticateAsync(IdentityConstants.ApplicationScheme);
        if (!authResult.Succeeded)
        {
            return baseController.Challenge(
                authenticationSchemes: IdentityConstants.ApplicationScheme,
                properties: new AuthenticationProperties
                {
                    RedirectUri = baseController.Request.PathBase + baseController.Request.Path + QueryString.Create(
                        baseController.Request.HasFormContentType ? baseController.Request.Form.ToList() : baseController.Request.Query.ToList())
                });
        }

        var principal = new ClaimsPrincipal(authResult.Principal);

        principal.SetScopes(request?.GetScopes());
        principal.SetClaim(Claims.Subject, principal.FindFirstValue(ClaimTypes.NameIdentifier));

        return baseController.SignIn(principal, OpenIddictServerAspNetCoreDefaults.AuthenticationScheme);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    public async Task<IActionResult> GetUserInfo(Controller baseController)
    {
        var user = await _userManager.FindByIdAsync(baseController.User?.GetClaim(Claims.Subject) ?? "");
        if (user is null)
        {
            return baseController.Challenge(
                authenticationSchemes: OpenIddictServerAspNetCoreDefaults.AuthenticationScheme,
                properties: new AuthenticationProperties(new Dictionary<string, string?>
                {
                    [OpenIddictServerAspNetCoreConstants.Properties.Error] = Errors.InvalidToken,
                    [OpenIddictServerAspNetCoreConstants.Properties.ErrorDescription] =
                        "The specified access token is bound to an account that no longer exists."
                }));
        }

        var claims = new Dictionary<string, object>(StringComparer.Ordinal)
        {
            // Note: the "sub" claim is a mandatory claim and must be included in the JSON response.
            [Claims.Subject] = await _userManager.GetUserIdAsync(user)
        };

        if (baseController.User?.HasScope(Scopes.Email) ?? false)
        {
            claims[Claims.Email] = await _userManager.GetEmailAsync(user) ?? "";
            claims[Claims.EmailVerified] = await _userManager.IsEmailConfirmedAsync(user);
        }

        if (baseController.User?.HasScope(Scopes.Phone) ?? false)
        {
            claims[Claims.PhoneNumber] = await _userManager.GetPhoneNumberAsync(user) ?? "";
            claims[Claims.PhoneNumberVerified] = await _userManager.IsPhoneNumberConfirmedAsync(user);
        }

        if (baseController.User?.HasScope(Scopes.Roles) ?? false)
        {
            claims[Claims.Role] = await _userManager.GetRolesAsync(user);
        }

        // Note: the complete list of standard claims supported by the OpenID Connect specification
        // can be found here: http://openid.net/specs/openid-connect-core-1_0.html#StandardClaims

        return baseController.Ok(claims);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    public async Task<IActionResult> Logout(Controller baseController)
    {
        // Ask ASP.NET Core Identity to delete the local and external cookies created
        // when the user agent is redirected from the external identity provider
        // after a successful authentication flow (e.g Google or Facebook).
        await _signInManager.SignOutAsync();

        // Returning a SignOutResult will ask OpenIddict to redirect the user agent
        // to the post_logout_redirect_uri specified by the client application or to
        // the RedirectUri specified in the authentication properties if none was set.
        return baseController.SignOut(
            authenticationSchemes: OpenIddictServerAspNetCoreDefaults.AuthenticationScheme,
            properties: new AuthenticationProperties
            {
                RedirectUri = "/"
            });
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="baseController"></param>
    /// <returns></returns>
    /// <exception cref="InvalidOperationException"></exception>
    /// <exception cref="NotImplementedException"></exception>
    public async Task<IActionResult> GetToken(Controller baseController)
    {
        var request = baseController.HttpContext.GetOpenIddictServerRequest() ??
            throw new InvalidOperationException("The OpenID Connect request cannot be retrieved.");

        if (request.IsClientCredentialsGrantType())
        {
            // Note: the client credentials are automatically validated by OpenIddict:
            // if client_id or client_secret are invalid, this action won't be invoked.

            var application = await _applicationManager.FindByClientIdAsync(request.ClientId ?? "") ??
                throw new InvalidOperationException("The application cannot be found.");

            // Create a new ClaimsIdentity containing the claims that
            // will be used to create an id_token, a token or a code.
            var identity = new ClaimsIdentity(TokenValidationParameters.DefaultAuthenticationType, Claims.Name, Claims.Role);

            // Use the client_id as the subject identifier.
            identity.SetClaim(Claims.Subject, await _applicationManager.GetClientIdAsync(application));
            identity.SetClaim(Claims.Name, await _applicationManager.GetDisplayNameAsync(application));

            identity.SetDestinations(static claim => claim.Type switch
            {
                // Allow the "name" claim to be stored in both the access and identity tokens
                // when the "profile" scope was granted (by calling principal.SetScopes(...)).
                Claims.Name when claim.Subject?.HasScope(Scopes.Profile) ?? false
                    => [Destinations.AccessToken, Destinations.IdentityToken],

                // Otherwise, only store the claim in the access tokens.
                _ => [Destinations.AccessToken]
            });

            return baseController.SignIn(new ClaimsPrincipal(identity), OpenIddictServerAspNetCoreDefaults.AuthenticationScheme);
        }
        else if (request.IsAuthorizationCodeGrantType() || request.IsRefreshTokenGrantType())
        {
            // Retrieve the claims principal stored in the authorization code/refresh token.
            var result = await baseController.HttpContext.AuthenticateAsync(OpenIddictServerAspNetCoreDefaults.AuthenticationScheme);

            // Retrieve the user profile corresponding to the authorization code/refresh token.
            var user = await _userManager.FindByIdAsync(result.Principal?.GetClaim(Claims.Subject) ?? "");
            if (user is null)
            {
                return baseController.Forbid(
                    authenticationSchemes: OpenIddictServerAspNetCoreDefaults.AuthenticationScheme,
                    properties: new AuthenticationProperties(new Dictionary<string, string?>
                    {
                        [OpenIddictServerAspNetCoreConstants.Properties.Error] = Errors.InvalidGrant,
                        [OpenIddictServerAspNetCoreConstants.Properties.ErrorDescription] = "The token is no longer valid."
                    }));
            }

            // Ensure the user is still allowed to sign in.
            if (!await _signInManager.CanSignInAsync(user))
            {
                return baseController.Forbid(
                    authenticationSchemes: OpenIddictServerAspNetCoreDefaults.AuthenticationScheme,
                    properties: new AuthenticationProperties(new Dictionary<string, string?>
                    {
                        [OpenIddictServerAspNetCoreConstants.Properties.Error] = Errors.InvalidGrant,
                        [OpenIddictServerAspNetCoreConstants.Properties.ErrorDescription] = "The user is no longer allowed to sign in."
                    }));
            }

            var identity = new ClaimsIdentity(result.Principal?.Claims,
                authenticationType: TokenValidationParameters.DefaultAuthenticationType,
                nameType: Claims.Name,
                roleType: Claims.Role);

            // Override the user claims present in the principal in case they
            // changed since the authorization code/refresh token was issued.
            identity.SetClaim(Claims.Subject, await _userManager.GetUserIdAsync(user))
            .SetClaim(Claims.Email, await _userManager.GetEmailAsync(user))
            .SetClaim(Claims.Name, await _userManager.GetUserNameAsync(user))
                    .SetClaim(Claims.PreferredUsername, await _userManager.GetUserNameAsync(user))
                    .SetClaims(Claims.Role, [.. (await _userManager.GetRolesAsync(user))]);

            identity.SetDestinations(GetDestinations);

            // Returning a SignInResult will ask OpenIddict to issue the appropriate access/identity tokens.
            return baseController.SignIn(new ClaimsPrincipal(identity), OpenIddictServerAspNetCoreDefaults.AuthenticationScheme);
        }

        throw new NotImplementedException("The specified grant is not implemented.");
    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="claim"></param>
    /// <returns></returns>
    private static IEnumerable<string> GetDestinations(Claim claim)
    {
        // Note: by default, claims are NOT automatically included in the access and identity tokens.
        // To allow OpenIddict to serialize them, you must attach them a destination, that specifies
        // whether they should be included in access tokens, in identity tokens or in both.

        switch (claim.Type)
        {
            case Claims.Name or Claims.PreferredUsername:
                yield return Destinations.AccessToken;

                if (claim.Subject?.HasScope(Scopes.Profile) ?? false)
                    yield return Destinations.IdentityToken;

                yield break;

            case Claims.Email:
                yield return Destinations.AccessToken;

                if (claim.Subject?.HasScope(Scopes.Email) ?? false)
                    yield return Destinations.IdentityToken;

                yield break;

            case Claims.Role:
                yield return Destinations.AccessToken;

                if (claim.Subject?.HasScope(Scopes.Roles) ?? false)
                    yield return Destinations.IdentityToken;

                yield break;

            // Never include the security stamp in the access and identity tokens, as it's a secret value.
            case "AspNet.Identity.SecurityStamp": yield break;

            default:
                yield return Destinations.AccessToken;
                yield break;
        }
    }
}

IOIDCRegisterable是注册OpenIddict的契约接口、IOIDCExecutable是OpenIddict各种授权流程具体实现的契约接口，使用本机服务端验证AccessToken。

3、在Program.cs如下设置：

using Microsoft.AspNetCore.Localization;
using RockstackAdmin.Infra.Common.Resources;
using RockstackAdmin.Infra.OIDC.OpenIddict;
using System.Globalization;

var builder = WebApplication.CreateBuilder(args);
var services = builder.Services;
var configuration = builder.Configuration;

services.AddLocalization();
services.AddRazorPages();
services.AddControllersWithViews(options =>
{

})
.AddViewLocalization()
.AddDataAnnotationsLocalization(options =>
{
    options.DataAnnotationLocalizerProvider = (type, factory) => factory.Create(typeof(Shared));
});

const string defaultCulture = "en";
var supportedCultures = new[]
{
    new CultureInfo(defaultCulture),
    new CultureInfo("ko"),
    new CultureInfo("zh-CN"),
};
services.Configure<RequestLocalizationOptions>(options =>
{
    options.DefaultRequestCulture = new RequestCulture(defaultCulture);
    options.SupportedCultures = supportedCultures;
    options.SupportedUICultures = supportedCultures;
    options.ApplyCurrentCultureToResponseHeaders = true;
});

services.AddOIDC(options =>
{
    options.DatabaseType = configuration.GetValueByPath("OIDC.DatabaseType");
    options.ConnectionString = configuration.GetValueByPath("OIDC.ConnectionString");
    options.AuthorizationEndpointUris = configuration.GetValueByPath("OIDC.AuthorizationEndpointUris");
    options.EndSessionEndpointUri = configuration.GetValueByPath("OIDC.EndSessionEndpointUri");
    options.TokenEndpointUris = configuration.GetValueByPath("OIDC.TokenEndpointUris");
    options.UserInfoEndpointUris = configuration.GetValueByPath("OIDC.UserInfoEndpointUris");
});

var app = builder.Build();

app.UseRequestLocalization();

app.UseDeveloperExceptionPage();

app.UseForwardedHeaders();

app.UseRouting();
app.UseCors();

app.UseAuthentication();
app.UseAuthorization();

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

app.Run();

4、appsettings.json配置：

{
  "OIDC": {
    "DatabaseType": "Sqlite",
    "ConnectionString": "Data Source=oidc.sqlite;Password=;Mode=ReadWriteCreate;Cache=Shared;Pooling=True;Default Timeout=5;",
    "TokenEndpointUris": "connect/token",
    "AuthorizationEndpointUris": "connect/authorize",
    "UserInfoEndpointUris": "connect/userinfo",
    "EndSessionEndpointUri": "connect/logout"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

5、控制器：

/// <summary>
/// 
/// </summary>
public class OIDCController : Controller
{
    /// <summary>
    /// 
    /// </summary>
    private readonly IOIDCExecutable _oidcExecutable;

    /// <summary>
    /// 
    /// </summary>
    /// <param name="oidcExecutable"></param>
    public OIDCController(IOIDCExecutable oidcExecutable)
    {
        _oidcExecutable = oidcExecutable;
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    [HttpGet("~/connect/authorize"), HttpPost("~/connect/authorize")]
    public async Task<IActionResult> Authorize()
    {
        return await _oidcExecutable.Authorize(this);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    [Authorize(AuthenticationSchemes = OpenIddictServerAspNetCoreDefaults.AuthenticationScheme)]
    [HttpPost("~/connect/userinfo"), Consumes("application/json"), Produces("application/json")]
    public async Task<IActionResult> GetUserInfo()
    {
        return await _oidcExecutable.GetUserInfo(this);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    [Authorize(AuthenticationSchemes = OpenIddictServerAspNetCoreDefaults.AuthenticationScheme)]
    [HttpPost("~/connect/logout"), Consumes("application/json"), Produces("application/json")]
    public async Task<IActionResult> Logout()
    {
        return await _oidcExecutable.Logout(this);
    }

    /// <summary>
    /// 
    /// </summary>
    /// <returns></returns>
    [HttpPost("~/connect/token"), Consumes("application/json"), Produces("application/json")]
    public async Task<IActionResult> GetToken()
    {
        return await _oidcExecutable.GetToken(this);
    }
}

~/connect/authorize：Authorization Code授权流程的入口页；

~/connect/userinfo：获取当前用户信息接口页；

~/connect/logout：注销登录接口页；

~/connect/token：获得AccessToken的接口页。

OpenIddict从零开始（二）——授权流程

Mon, 27 Oct 2025 14:51:49 +0800

OpenIddict内置5种授权流程：

授权码流程（Authorization Code Flow）
支持PKCE，最推荐。
隐式流程（Implicit Flow）
出于历史遗留原因该流程仅在OpenIddict服务端库中支持，但在OpenIddict客户端库不支持。该流程已过时。
混合流程（Hybrid Flow）
介于授权码流程和隐式流程之间的一种混合流程。
资源所有者密码凭证授权流程（Resource Owner Password Credentials Grant Flow）
因安全原因该流程应在其它流程都不适用时才考虑采用。
客户端凭证授权流程（Client Credentials Grant Flow）
设备授权流程（Device Grant Flow）

授权流程	是否交互	应用场景
Authorization Code Flow (PKCE)	是	SPA单页面应用、Web应用
Implicit Flow	是	SPA单页面应用
Hybrid Flow	是	SPA单页面应用、Web应用
Resource Owner Password Credentials Grant Flow	否	第一方原生应用或高度信任的内部系统
Client Credentials Grant Flow	否	服务端内部、服务端之间、定时任务、后台作业、不需要特定用户上下文的接口调用
Device Grant Flow	是	不带浏览器的IoT设备等

OpenIddict从零开始（一）——概述

Mon, 27 Oct 2025 14:16:40 +0800

OpenIddict是一个免费、开源、多功能、可自定义、基于.NET的OAuth 2.0和OIDC（Open ID Connect）库，可以帮助实现.NET应用的OIDC服务端、客户端和令牌验证。支持.NET Framework 4.6.2+, .NET Core 2.3+ 和.NET 8+，需与Identity配合使用。Identity 负责“这个用户是谁”以及“他/她在我的应用里有什么身份”，OpenIddict 负责“这个客户端应用是否有权限代表某个用户访问特定资源”并颁发一个被广泛认可的通行证（如JWT Token）。主要用途包括：单点登录、第三方应用授权等。

OIDC客户端模块可以用来和任何标准OIDC服务器交互；
OIDC服务端模块可以用来实现自己的标准OIDC服务器；
OIDC令牌验证模块可以用来和OIDC服务器通信以实现用户认证。

在.NET Framework 4.6.2上，不支持以下方法，都将抛出PlatformNotSupportedException异常：

AddSigningCertificate、AddSigningKey()；
无可用开发证书时AddDevelopmentEncryptionCertificate()；
无可用开发证书时AddDevelopmentSigningCertificate()。

OpenIddict官网：https://openiddict.com

OAuth 2.0规范: https://datatracker.ietf.org/doc/html/rfc6749

OpenID Connect规范：https://openid.net/specs/openid-connect-core-1_0.html

开放接口无版本化有哪些策略？

Mon, 27 Oct 2025 13:53:12 +0800

开放接口无版本化适用于对长期稳定性和可演进性要求极高的系统。

1. 资源表示扩展（Resource Representation Extension）

核心思想：API的根端点（或一个发现端点）返回所有可用资源的链接，客户端通过跟随这些链接来操作。版本升级时，通过添加新字段、新链接或弃用旧字段来实现，而不改变核心URL。

示例：

请求 GET /users/123

v1 返回：

{
  "id": 123,
  "name": "Alice",
  "email": "alice@example.com"}

v2 返回：

{
  "id": 123,
  "name": "Alice",
  "email": "alice@example.com",
  // 新增字段
  "avatar_url": "https://...",
  // 添加超媒体控制，这是关键
  "_links": {
    "self": { "href": "/users/123" },
    "posts": { "href": "/users/123/posts" }
  }}

优点：

URL永久稳定，符合REST的最高理想。
通过添加而非修改来演进API，向后兼容性好。

缺点：

实现复杂：需要精心设计字段和超媒体控制（HATEOAS）。
客户端必须忽略未知字段：要求客户端遵循“稳健性原则”。
沟通成本高：需要明确告知客户端哪些字段已弃用，以及何时会移除。

2. 容忍性读取，严格性写入

读取操作：服务器总是返回最完整的资源表示，客户端应忽略不认识的字段。
写入操作：客户端总是发送它知道的所有字段，服务器应忽略不认识的字段。

示例：

# 客户端（老版本）只知道name和email
PUT /users/123 HTTP/1.1
{
  "name": "Alice",
  "email": "alice@example.com"
  # 不知道新的avatar_url字段
}

# 服务器（新版本）保存已知字段，忽略未知字段

3. 功能开关（Feature Toggle）

通过功能开关控制新老逻辑，而不是通过版本号。

GET /users/123 HTTP/1.1X-Feature-Flags: new_avatar_system,enhanced_search

优点： 细粒度控制，可以逐步发布新功能。
缺点： 客户端复杂度增加，需要管理功能开关状态。

4. 智能版本推理

服务器通过分析请求特征自动推断合适的版本。

GET /users/123 HTTP/1.1
User-Agent: CompanyApp/3.2.1
X-Device-Type: mobile
# 服务器根据UserAgent、设备类型、访问模式等自动选择v2 AP

优点: 对客户端透明，无需显式版本声明。
缺点: 可能产生错误推断，调试困难。
适用场景: 拥有固定客户端生态的系统。

5. 行为检测版本选择

通过分析请求内容和模式来动态选择API版本。

POST /users HTTP/1.1
Content-Type: application/json

{
  "name": "Alice",
  "email": "alice@example.com",
  "preferences": {
    "newsletter": true,
    "two_factor_auth": true  # 新版本才有的字段  
    }
}
# 服务器检测到新版本特有的字段，自动使用v2逻辑处理

优点: 智能适配，减少版本冲突。
缺点: 处理逻辑复杂，性能开销大。
适用场景: 渐进式迁移过程中的临时方案。

开放接口版本号可以放在哪些位置？

Mon, 27 Oct 2025 13:19:56 +0800

开放接口版本号的设计位置会影响到API的易用性、可维护性以及是否符合RESTful规范。可以作为版本号一部分的有：1.0.0.0格式自定义版本号、时间戳、Git提交Hash等。总的来说，接口版本号主要有以下几种常见位置，各有优劣：

1. URL路径（URI Path）

这是最常见、最直观的方式，将版本号直接放在API的URL中。

格式：

https://api.example.com/v1/users
https://api.example.com/v2/users

示例：

GitHub API: https://api.github.com/v3/user
Twitter API: https://api.twitter.com/1.1/statuses/home_timeline.json

优点：

极其直观：用户一眼就能看出使用的是哪个版本。
易于访问和测试：直接在浏览器地址栏输入即可测试。
部署简单：可以通过路径将不同版本的请求路由到不同的服务器或服务上（例如，/v1/ 路由到服务A，/v2/ 路由到服务B）。

缺点：

不符合纯REST理念：从资源的角度看，版本号不属于资源本身的一部分，URL应该始终指向同一个“逻辑”资源。
URL污染：版本号使得URL变得稍长。

结论： 这是最推荐、最通用的做法，尤其是在需要频繁迭代、版本间差异较大的公开API中。

2. 查询参数（Query String）

将版本号作为一个参数附加在URL的查询部分。

格式：

https://api.example.com/users?version=1
https://api.example.com/users?v=2

示例：

不常见于主流API，但一些内部服务或早期API可能会使用。

优点：

不改变基础URL：资源的主路径保持不变。
实现简单：后端可以通过解析参数来区分版本。

缺点：

不够明显：版本信息容易被忽略。
缓存复杂性：某些缓存代理可能会忽略查询字符串，导致缓存键不一致。
语义
较弱：通常认为查询参数用于过滤、排序，而非定义API的根本契约。

3. 自定义请求头（Custom Header）

使用HTTP请求头来传递版本信息。

格式：

GET /users HTTP/1.1
Host: api.example.com
Accept-Version: v1

或者使用更标准的 Accept 头变体：

GET /users HTTP/1.1
Host: api.example.com
Accept: application/vnd.example.v1+json

示例：

Accept: application/vnd.github.v3+json (GitHub也支持这种方式，作为URL路径的补充)

优点：

保持URL干净：URL完全不包含版本信息，纯粹指向资源。
非常符合REST规范：利用HTTP内容协商机制，语义清晰。
灵活性强：可以同时支持多个版本，由服务器根据头信息决定返回哪个表示。

缺点：

使用不便：无法直接在浏览器地址栏中测试，必须借助工具（如Postman, curl）。
可发现性差：开发者需要查阅文档才知道要加什么头。
缓存配置：需要确保缓存机制将版本头作为缓存键的一部分。

结论： 适用于对RESTful原则要求极高、或客户端环境可控（如内部微服务、单页应用）的场景。

Host: api.example.com
Accept: application/vnd.example.v1+json

示例：

Accept: application/vnd.github.v3+json (GitHub也支持这种方式，作为URL路径的补充)

优点：

保持URL干净：URL完全不包含版本信息，纯粹指向资源。
非常符合REST规范：利用HTTP内容协商机制，语义清晰。
灵活性强：可以同时支持多个版本，由服务器根据头信息决定返回哪个表示。

缺点：

使用不便：无法直接在浏览器地址栏中测试，必须借助工具（如Postman, curl）。
可发现性差：开发者需要查阅文档才知道要加什么头。
缓存配置：需要确保缓存机制将版本头作为缓存键的一部分。

结论： 适用于对RESTful原则要求极高、或客户端环境可控（如内部微服务、单页应用）的场景。

4. 媒体类型（Media Type / Content Negotiation）

这是“自定义请求头”的一种更正式、更标准化的形式，利用HTTP的 Accept 头进行内容协商。

格式：

GET /users HTTP/1.1
Host: api.example.com
Accept: application/vnd.myapi.v2+json

在这里，vnd.myapi.v2+json 是一个自定义的媒体类型，表示“我请求版本2的JSON格式数据”。

优点：

是REST的最佳实践：完全利用HTTP协议自身机制。
功能强大：不仅可以协商版本，还可以协商数据格式（JSON/XML等）。
向前兼容性好：可以定义默认版本，当客户端不指定 Accept 头时使用。

缺点：

使用最不方便：对开发者不友好，测试和调试复杂。
可发现性最差。

结论： 通常是大型、成熟API平台（如GitHub）的进阶选择，或者是内部架构非常规范的微服务系统的选择

5. 域名（Host/Subdomain）

将版本号放在子域名或独立的域名上。

格式：

https://v1.api.example.com/users
https://api.example.com/v2/users/ (这个属于路径，注意区分)

示例：

https://developer.github.com/v3/ (文档域名，非API域名)

优点：

完全隔离：不同版本的API可以部署在完全独立的基础设施上，互不影响。
技术栈无关：v1可以用Java，v2可以用Go，互不干扰。

缺点：

部署和运维成本高：需要管理多个域名和服务器环境。
SSL证书：可能需要为每个子域名配置SSL证书。
跨域问题：如果主站在不同域名，可能会遇到CORS问题。

结论： 适用于需要极端隔离的大型、重大版本升级，一般不用于常规的迭代。

6. 扩展方案与特殊思路

6.1 配置文件/契约驱动（Configuration Driven）

版本信息不通过请求传递，而是通过外部的配置文件或API契约来定义。

核心思想：客户端和服务器通过共享一个API契约（如OpenAPI/Swagger规范）来绑定版本。在部署或集成时，客户端库会根据指定的契约版本生成对应的代码。

示例：

项目中有 openapi-v1.yaml 和 openapi-v2.yaml 两个文件。
客户端SDK通过 npm install my-api-client@v1 来引入对应版本的客户端，这个客户端内部所有方法都已固定为v1的端点。

优点：

类型安全：客户端在编译时即可发现错误。
强约束：版本在集成阶段就已确定，避免了运行时的不一致。
适用于SDK：对于提供官方SDK的API来说非常合适。

缺点：

灵活性差：难以在运行时动态切换版本。
不适用于直接HTTP调用：主要用于有SDK封装的场景。
部署复杂：需要维护和发布多套客户端库。

结论：在 微服务内部通信 或 提供强类型SDK的公有云服务 中比较常见。

6.2 组合策略（Hybrid Approaches）

在实际生产中，很多公司会采用组合策略来兼顾灵活性和兼容性。

默认路径 + 头重写

默认：使用URL路径（如 /v1/）。
重写：通过一个特殊的请求头（如 X-Api-Version: 2）来覆盖URL中指定的版本。
用途：方便内部测试和调试，无需修改URL。

路径为主，头部为辅

像GitHub API，主要使用路径 /v3/，但同时完全支持通过 Accept: application/vnd.github.v3+json 头来指定版本。
用途：提供最大限度的开发者友好性和灵活性。

7. HTTP 重定向版本协商

客户端访问一个无版本的入口端点，服务器通过HTTP重定向到对应版本。

示例：

# 初始请求（无版本）
GET /api/users/123 HTTP/1.1
Host: example.com

# 服务器响应
HTTP/1.1 302 Found
Location: https://api.example.com/v2/users/123

优点： 客户端无需关心版本。
缺点： 额外的重定向开销，对性能敏感的场景不适用。
适用场景： 内部服务发现，或者希望强制客户端使用最新版本的场景。

.NET如何使用SqlSugar加密读写SQLite

Thu, 20 Feb 2025 18:43:14 +0800

1、引用SqlSugarCore和QLitePCLRaw.bundle_e_sqlcipher；

2、SQLite连接字符串：

Data Source=test.sqlite;Password=pwd;

3、调用SqlSugar连接SQLite：

var sqliteDb = new SqlSugarScope(new ConnectionConfig()
{
    ConnectionString = "Data Source=test.sqlite;Password=pwd;",
    DbType = DbType.Sqlite,
    IsAutoCloseConnection = true
},
    client =>
    {
        client.Aop.OnError = (ex) =>
        {
        
        };
        client.Aop.OnLogExecuting = (sql, pars) =>
        {
            var sqlRaw = UtilMethods.GetSqlString(DbType.Sqlite, sql, pars);
        };
    });

4、关于SQLite数据管理软件：推荐DB Browser for SQLite，使用DB Browser for SQLCipher打开加密SQLite；

5、关于加密：

（1）直接使用DB Browser for SQLite给SQLite数据库文件加密后，SqlSugar不能打开；

（2）如上代码会自动创建一个已加密的空白SQLite数据库文件，可以使用DB Browser for SQLCipher打开该文件。

.NET如何使用SqlSugar读写Access

Thu, 20 Feb 2025 18:37:02 +0800

1、引用SqlSugarCore和SqlSugar.AccessCore；

2、Access连接字符串：

2007版本之前

Provider=Microsoft.Jet.OleDb.4.0;Data Source=test.mdb;Persist Security Info=False;Password=;

2007版本及之后

Provider=Microsoft.ACE.OleDB.15.0;Data Source=test.accdb;Persist Security Info=False;Password=;

其中的Access驱动版本号因Access版本不同而不同，同时需安装对应的Access驱动（32位或64位）。若安装了32位驱动，则应用程序也需要生成x86版本；64位则需要生成x64版本。

3、调用SqlSugar连接Access：

var accessDb = new SqlSugarScope(new ConnectionConfig()
{
    ConnectionString = "Provider=Microsoft.Jet.OleDb.4.0;Data Source=test.mdb;Persist Security Info=False;Password=;",
    DbType = DbType.Access,
    IsAutoCloseConnection = true
},
    client =>
    {
        client.Aop.OnError = (ex) =>
        {
        
        };
        client.Aop.OnLogExecuting = (sql, pars) =>
        {
            var sqlRaw = UtilMethods.GetSqlString(DbType.Access, sql, pars);
        };
    });