springboot+shiro+jwt 兼容session和token

最近和别的软件集成项目，需要提供给别人接口来进行数据传输，发现给他token后并不能访问我的接口，拿postman试了下还真是不行。检查代码发现项目的shiro配置是通过session会话来校验信息的 ，我之前一直是前后端自己写，用浏览器来调试的程序所以没发现这个问题。
浏览器请求头的cookie带着JESSIONID是可以正常访问接口的
在这里插入图片描述

那要和别的项目集成，他那边又不是通过浏览器，咋办呢，我这边改造吧，兼容token和session不就行了，下面直接贴改造后的完整代码。

pom加依赖

		<dependency>
            <groupId>org.crazycake</groupId>
            <artifactId>shiro-redis</artifactId>
            <version>2.4.2.1-RELEASE</version>
        </dependency>
             <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.3.2</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.2.0</version>
        </dependency>

1.JwtToken重写token类型

package com.mes.common.token;

import com.mes.module.user.dto.SysUserDto;
import lombok.Data;
import org.apache.shiro.authc.HostAuthenticationToken;
import org.apache.shiro.authc.RememberMeAuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;


@Data
public class JwtToken implements HostAuthenticationToken, RememberMeAuthenticationToken {
    private String token;
    private char[] password;
    private boolean rememberMe = false;
    private String host;

    public JwtToken(String token){
        this.token = token;
    }


    @Override
    public String getHost() {
        return null;
    }

    @Override
    public boolean isRememberMe() {
        return false;
    }

    @Override
    public Object getPrincipal() {
        return token;
    }

    @Override
    public Object getCredentials() {
        return token;
    }
}

2.自定义过滤器 JwtFilter

package com.mes.common.shiro;

import com.alibaba.fastjson.JSON;
import com.auth0.jwt.interfaces.Claim;
import com.mes.common.token.JwtToken;
import com.mes.common.utils.JwtUtils;
import com.mes.common.utils.Result;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authc.AuthenticatingFilter;
import org.apache.shiro.web.util.WebUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.RequestMethod;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;

/**
 * @Description 自定义过滤器
 * @Date 2021/8/18
 **/
public class JwtFilter extends AuthenticatingFilter {

    private static final Logger log = LoggerFactory.getLogger(JwtFilter.class);
    @Override
    protected AuthenticationToken createToken(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String token = request.getHeader("token");
        if (token == null){
            return null;
        }
        return new JwtToken(token);
    }


    /**
     * 拦截校验  没有登录的情况下会走此方法
     * @param servletRequest
     * @param servletResponse
     * @return
     * @throws Exception
     */
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        String token = request.getHeader("token");

        response.setContentType("application/json;charset=utf-8");
        response.setHeader("Access-Control-Allow-Credentials", "true");
        response.setHeader("Access-control-Allow-Origin", request.getHeader("Origin"));
        response.setHeader("Access-Control-Allow-Methods", "GET,PUT,DELETE,UPDATE,OPTIONS");
        response.setHeader("Access-Control-Allow-Headers", request.getHeader("Access-Control-Request-Headers"));

        Subject subject = getSubject(servletRequest,servletResponse);

        if (!subject.isAuthenticated()){
            // 未登录
            PrintWriter writer = response.getWriter();
            writer.print(JSON.toJSONString(new Result<>().setCode(402).setMsg("请先登录")));
            return false;
        }

        if (StringUtils.isEmpty(token)){
            PrintWriter writer = response.getWriter();
            writer.print(JSON.toJSONString(new Result<>().setCode(402).setMsg("请先登录")));
            return false;
        }else {
            // 校验jwt
            try {
                Map<String, Claim> claimMap = JwtUtils.verifyToken(token);
            } catch (Exception e) {
                e.printStackTrace();
                PrintWriter writer = response.getWriter();
                writer.write(JSON.toJSONString(new Result<>().setCode(402).setMsg("登录失效，请重新登录")));
                return false;
            }
            return executeLogin(servletRequest, servletResponse);
        }
    }
    @Override
    protected boolean onLoginFailure(AuthenticationToken token, AuthenticationException e, ServletRequest request, ServletResponse response) {

        HttpServletResponse httpServletResponse = (HttpServletResponse) response;

        Throwable throwable = e.getCause() == null ? e : e.getCause();

        Result result = new Result().err().setMsg(e.getMessage());
        String json = JSON.toJSONString(result);

        try {
            httpServletResponse.getWriter().print(json);
        } catch (IOException ioException) {

        }
        return false;
    }

    /**
     * 跨域支持
     * @param servletRequest
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest servletRequest, ServletResponse response) throws Exception {
        HttpServletRequest httpRequest = WebUtils.toHttp(servletRequest);
        HttpServletResponse httpResponse = WebUtils.toHttp(response);
        if (httpRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
            httpResponse.setHeader("Access-control-Allow-Origin", httpRequest.getHeader("Origin"));
            httpResponse.setHeader("Access-Control-Allow-Methods", "GET,PUT,DELETE,UPDATE,OPTIONS");
            httpResponse.setHeader("Access-Control-Allow-Headers", httpRequest.getHeader("Access-Control-Request-Headers"));

            System.out.println(httpRequest.getHeader("Origin"));
            System.out.println(httpRequest.getMethod());
            System.out.println(httpRequest.getHeader("Access-Control-Request-Headers"));
            httpResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        HttpServletRequest request = (HttpServletRequest) servletRequest;
        String token = request.getHeader("token");
        if (token != null) {
            try {
//                Map<String, Claim> claimMap = JwtUtils.verifyToken(token);
//                String authToken = claimMap.get("token").asString();
                JwtToken jwtToken = new JwtToken(token);
                Subject subject = SecurityUtils.getSubject();
                subject.login(jwtToken);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                log.error("token失效，请重新登录");
               response.getWriter().print(JSON.toJSONString(new Result<>().setCode(402).setMsg("token失效，请重新登录")));
            }
        }
        return false;
    }

/*    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpRequest = WebUtils.toHttp(request);
        HttpServletResponse httpResponse = WebUtils.toHttp(response);
        if (httpRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpResponse.setHeader("Access-Control-Allow-Credentials", "true");
            httpResponse.setHeader("Access-control-Allow-Origin", httpRequest.getHeader("Origin"));
            httpResponse.setHeader("Access-Control-Allow-Methods", "GET,PUT,DELETE,UPDATE,OPTIONS");
            httpResponse.setHeader("Access-Control-Allow-Headers", httpRequest.getHeader("Access-Control-Request-Headers"));

            System.out.println(httpRequest.getHeader("Origin"));
            System.out.println(httpRequest.getMethod());
            System.out.println(httpRequest.getHeader("Access-Control-Request-Headers"));
            httpResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }*/

}

3.配置过滤器 ShiroFilterRegisterConfig

package com.mes.common.config;

import com.mes.common.shiro.JwtFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Description TODO
 * @Date 2021/8/19
 **/
@Configuration
public class ShiroFilterRegisterConfig {
    @Bean
    public FilterRegistrationBean shiroLoginFilteRegistration(JwtFilter filter) {
        FilterRegistrationBean registration = new FilterRegistrationBean(filter);
        registration.setEnabled(false);
        return registration;
    }
}

4. shiroConfig

package com.mes.common.config;

import com.baomidou.mybatisplus.extension.api.R;
import com.mes.common.constant.ExpTime;
import com.mes.common.realm.MyRealm;
import com.mes.common.shiro.JwtFilter;
import com.mes.common.shiro.MyCredentialsMatcher;
import org.apache.shiro.session.mgt.SessionManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**

  • @Description shiro配置
  • @Date 2021/8/18
    **/
    @Configuration
    public class ShiroConfig {
    @Autowired
    private MyRealm myRealm;
    @Autowired
    private MyCredentialsMatcher myCredentialsMatcher;
    @Value(“ s p r i n g . r e d i s . h o s t " ) p r i v a t e S t r i n g r e d i s H o s t ; @ V a l u e ( " {spring.redis.host}") private String redisHost; @Value(" spring.redis.host")privateStringredisHost;@Value("{spring.redis.port}”)
    private Integer redisPort;
    @Value(“${spring.redis.timeout}”)
    private Integer redisTimeout;

// @Bean
// public DefaultWebSessionManager sessionManager(@Value(“${globalSessionTimeout:3600}”) long globalSessionTimeout, RedisManager c){
// DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
// sessionManager.setSessionValidationSchedulerEnabled(true);
// sessionManager.setSessionIdUrlRewritingEnabled(false);
// sessionManager.setSessionValidationInterval(globalSessionTimeout * 1000);
// sessionManager.setGlobalSessionTimeout(globalSessionTimeout * 1000);
// sessionManager.setSessionDAO(redisSessionDAO©);
// return sessionManager;
// }
// @ConfigurationProperties(prefix=“spring.redis”)
// @Bean
// public RedisManager redisManager() {
// return new RedisManager();
// }
// @Bean
// public RedisSessionDAO redisSessionDAO(RedisManager redisManager) {
// RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
// redisSessionDAO.setRedisManager(redisManager);
// return redisSessionDAO;
// }

// @Bean
// public static DefaultAdvisorAutoProxyCreator getDefaultAdvisorAutoProxyCreator(){
//
// DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator=new DefaultAdvisorAutoProxyCreator();
// defaultAdvisorAutoProxyCreator.setUsePrefix(true);
//
// return defaultAdvisorAutoProxyCreator;
// }

@Bean
public DefaultWebSecurityManager getDefaultWebSecurityManager(SessionManager sessionManager, RedisCacheManager redisCacheManager){
    DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager();
    myRealm.setCredentialsMatcher(myCredentialsMatcher);
    defaultWebSecurityManager.setRealm(myRealm);

// defaultWebSecurityManager.setSessionManager(sessionManager);
defaultWebSecurityManager.setCacheManager(redisCacheManager);
return defaultWebSecurityManager;
}

@Bean
public ShiroFilterFactoryBean getShiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager,JwtFilter jwtFilter){
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);

// JwtFilter jwtFilter = new JwtFilter();
Map<String, Filter> filterMap = new HashMap<>();
filterMap.put(“jwt”,jwtFilter);
shiroFilterFactoryBean.setFilters(filterMap);
Map<String,String> map = new LinkedHashMap<>();
map.put(“/sys/user/login”,“anon”);
map.put(“/swagger-ui.html**”, “anon”);
map.put(“/v2/api-docs”, “anon”);
map.put(“/swagger-resources/“, “anon”);
map.put(”/webjars/”, “anon”);
map.put(“/img/“,“anon”);
map.put(”/fastdfs/”,“anon”);
map.put(“/**”,“jwt”); //取消就不会拦截
shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
// shiroFilterFactoryBean.setLoginUrl(“http://192.168.18.17:3000”);
return shiroFilterFactoryBean;
}

@Bean
public JwtFilter getJwtFilter(){
    return new JwtFilter();
}



/**
 * 配置shiro redisManager
 * 使用的是shiro-redis开源插件
 * @return
 */
@Bean
public RedisManager redisManager() {
    RedisManager redisManager = new RedisManager();
    redisManager.setHost(redisHost);
    redisManager.setPort(redisPort);
    redisManager.setExpire(Math.toIntExact(ExpTime.expTime));// 配置缓存过期时间
    redisManager.setTimeout(redisTimeout);
    return redisManager;
}
@Bean
public RedisSessionDAO redisSessionDAO(RedisManager redisManager) {

// RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
redisSessionDAO.setRedisManager(redisManager);
return redisSessionDAO;
}
/**
* shiro session的管理
*/
@Bean
public DefaultWebSessionManager redisSessionManager(RedisSessionDAO redisSessionDAO) {
DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
sessionManager.setSessionDAO(redisSessionDAO);
return sessionManager;
}
@Bean
public RedisCacheManager redisCacheManager(RedisManager redisManager) {
RedisCacheManager redisCacheManager = new RedisCacheManager();
redisCacheManager.setRedisManager(redisManager);
return redisCacheManager;
}

// @Bean
// public FilterRegistrationBean shiroLoginFilteRegistration(JwtFilter filter) {
// FilterRegistrationBean registration = new FilterRegistrationBean(filter);
// registration.setEnabled(false);
// return registration;
// }

}

在这里插入代码片

5.自定义认证逻辑 MyRealm

package com.mes.common.realm;

import com.auth0.jwt.interfaces.Claim;
import com.mes.common.token.JwtToken;
import com.mes.common.utils.JwtUtils;
import com.mes.module.user.dto.SysUserDto;
import com.mes.module.user.service.SysUserService;
import lombok.SneakyThrows;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**

  • @Description 授权

  • @Date 2021/8/18
    **/
    @Component
    public class MyRealm extends AuthorizingRealm {
    @Autowired
    private SysUserService sysUserService;

    @Override
    public boolean supports(AuthenticationToken token) {
    return token instanceof JwtToken;
    }

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
    String username = (String) principalCollection.iterator().next();
    SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
    return info;
    }

    @SneakyThrows
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    JwtToken jwtToken = (JwtToken) authenticationToken;
    String token = (String) jwtToken.getPrincipal();
    Map<String, Claim> claimMap = JwtUtils.verifyToken(token);
    String username = claimMap.get(“name”).asString();
    Map<String,Object> params = new HashMap<>();
    params.put(“username”, username);
    SysUserDto userDto = sysUserService.getOne(params);
    if (userDto == null){
    return null;
    }

// return new SimpleAuthenticationInfo(userDto,userDto.getPassword(),getName());
return new SimpleAuthenticationInfo(userDto,jwtToken,getName());
}
}

6.密码验证器

package com.mes.common.shiro;

import com.mes.common.token.JwtToken;
import com.mes.common.utils.CommonsUtils;
import com.mes.module.user.dto.SysUserDto;
import com.mes.module.user.service.SysUserService;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.credential.SimpleCredentialsMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @Description 密码验证器
 * @Date 2021/8/18
 **/
@Component
public class MyCredentialsMatcher extends SimpleCredentialsMatcher {
    @Autowired
    private SysUserService sysUserService;

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {

        JwtToken jwtToken = (JwtToken) token;
        if (jwtToken.getPassword() == null){
            return true;
        }
        String inPassword = new String(jwtToken.getPassword());
        SysUserDto dto = (SysUserDto) info.getPrincipals();
        String username = dto.getUsername();
        String dbPassword = String.valueOf(info.getCredentials());
        Map<String,Object> params = new HashMap<>();
        params.put("username",username);
        SysUserDto dbUser = sysUserService.getOne(params);
        String salt = dbUser.getSalt();
        if (CommonsUtils.encryptPassword(inPassword,salt).equals(dbPassword)){
            return true;
        }else {
            return false;
        }


    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/704623.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

flex布局，子项在主轴上超出父容器的问题

flex布局，子项在主轴上超出父容器的问题

flex布局&#xff0c;子项在主轴上超出父容器的问题 flex布局&#xff0c;子项在主轴上超出父容器的问题 大家有没有遇到&#xff0c;即使子项设置了flex:1 ,以为会分配主轴上的剩余空间。但是效果是子项在主轴上还是超出了父容器。 要解决这个问题&#xff0c;我们可以将f…
阅读更多...
《一头扎进》系列之Python+Selenium框架设计篇22- 价值好几K的框架，狼来了，狼来了....，狼没来，框架真的来了

《一头扎进》系列之Python+Selenium框架设计篇22- 价值好几K的框架，狼来了，狼来了....，狼没来，框架真的来了

宏哥微信粉丝群&#xff1a;https://bbs.csdn.net/topics/618423372 有兴趣的可以扫码加入 1. 简介 前边宏哥一边一边的喊框架&#xff0c;就如同一边一边的喊狼来了&#xff01;狼来了&#xff01;.....这回是狼没有来&#xff0c;框架真的来了。从本文开始宏哥将会一步一步介…
阅读更多...
项目经理如何做好需求管理规程？

项目经理如何做好需求管理规程？

软件资料清单列表部分文档清单&#xff1a;工作安排任务书&#xff0c;可行性分析报告&#xff0c;立项申请审批表&#xff0c;产品需求规格说明书&#xff0c;需求调研计划&#xff0c;用户需求调查单&#xff0c;用户需求说明书&#xff0c;概要设计说明书&#xff0c;技术解…
阅读更多...
使用Arrays.asList 报错Nullpointerexception 需要提前对参数进行判空

使用Arrays.asList 报错Nullpointerexception 需要提前对参数进行判空

//为什么这样的时候会报空指针异常**Arrays.asList 这里这个方法中的参数为空**String[] checkedResourceNos1 dto.getCheckedResourceNos();List<String> checkedResourceNos null; //需要在这里**判断是否为空**&#xff0c;**不为空才能**调**用Arrays.asList转化为…
阅读更多...
前端JS必用工具【js-tool-big-box】学习，下载大文件（纯下载功能版）

前端JS必用工具【js-tool-big-box】学习，下载大文件（纯下载功能版）

这一小节呢&#xff0c;我们说一下 js-tool-big-box 工具库&#xff0c;下载文件的用法。这一小节说的是纯下载版本。 意思就是我们在前端项目开发中&#xff0c;下载功能嘛&#xff0c;无论你发送fetch请求&#xff0c;还是axios请求&#xff0c;你总得发送一下请求&#xff0…
阅读更多...
Stable Audio Tools - 会打字就能搞音乐创作，AI音频生成工具，一键生成任意背景音乐 本地一键整合包

Stable Audio Tools - 会打字就能搞音乐创作，AI音频生成工具，一键生成任意背景音乐 本地一键整合包

Stable Audio Tools是Stability AI 推出的AI生成音乐平台&#xff0c;你只需要输入描述性文本提示以及所需的音频长度&#xff08;最长支持512秒即8分钟&#xff09;即可生成高质量的音乐和音效。 你可以通过文本提示就能直接生成摇滚、爵士、电子、嘻哈、重金属、民谣、流行、…
阅读更多...
垂直业务系统权限设计

垂直业务系统权限设计

遵循 RBAC 的原则&#xff0c;以更贴近日常工作的业务处理流程&#xff0c;设计一套与总公司分公司相吻合的组织、部门、岗位结构&#xff0c;配套可以继承的权限组和特定的岗位权限&#xff0c;实现系统授权的操作简化和权限的集成应用简化。 RBAC&#xff08;Role-Based Acce…
阅读更多...
如何从微软官方下载Edge浏览器的完整离线安装包

如何从微软官方下载Edge浏览器的完整离线安装包

文章目录 📖 介绍 📖🏡 演示环境 🏡📒 正文内容 📒🚀 官方直链下载🚬 手动选择下载🎈 获取方式 🎈⚓️ 相关链接 ⚓️📖 介绍 📖 在网上搜索Microsoft Edge浏览器的离线安装包时，很多用户都会发现大部分都是在线安装包，无法满足他们在无网络环境下进…
阅读更多...
Mocha Pro 2024 v11.0.1 Mac版摄像机反求跟踪插件更新：优化AE/PR/OFX/达芬奇工作流程

Mocha Pro 2024 v11.0.1 Mac版摄像机反求跟踪插件更新：优化AE/PR/OFX/达芬奇工作流程

更新Mac苹果版&#xff0c;原生支持Intel和Apple M芯片&#xff0c;安装很简单。Mocha Pro 是一款世界知名的软件和插件&#xff0c;用于平面运动跟踪、3D 跟踪、动态观察、对象移除、图像稳定和PowerMesh有机扭曲跟踪。得益于集成SynthEyes核心3D跟踪算法的强大功能&#xff0…
阅读更多...
白酒：茅台镇白酒的酒杯选择与品鉴技巧

白酒：茅台镇白酒的酒杯选择与品鉴技巧

品鉴一杯品质的白酒&#xff0c;需要选择合适的酒杯和掌握一定的品鉴技巧。在茅台镇&#xff0c;云仓酒庄豪迈白酒备受推广&#xff0c;其酒杯选择与品鉴技巧也备受关注。 首先&#xff0c;选择合适的酒杯非常重要。一般来说&#xff0c;品鉴白酒的酒杯应该具有一定的透明度&am…
阅读更多...
使用随机数字或计数器在运行时计算百分比

使用随机数字或计数器在运行时计算百分比

如果我们需要在运行时计算某些项目的百分比&#xff0c;可以使用 Python 中的随机数生成器或者计数器来模拟这个过程。这取决于我们想要模拟的具体情况和场景。今天我将通过文字方式详细记录我实操过程。 1、问题背景 在处理大量交易时&#xff0c;我们需要对一定比例的交易进…
阅读更多...
扩散模型ddpm原理

扩散模型ddpm原理

扩散模型ddpm原理 bilibili 视频讲解 笔记记录 总结&#xff1a;模型反向还原过程中&#xff0c;除模型推理得到噪声预测&#xff0c;还需要从标准正太分布中采样一份噪声&#xff0c;两者的线性组合得到前一时刻的降噪结果&#xff0c;这里可能会有较大的不确定性(对于生成式任…
阅读更多...
硬核：浏览器发展的四大方向，早把C/S挤到犄角旮旯了。

硬核：浏览器发展的四大方向，早把C/S挤到犄角旮旯了。

浏览器是互联网的基础设施&#xff0c;浏览器早不满足于作为上网入口&#xff0c;而是全面进化啦&#xff0c;比如各类应用开始web化&#xff0c;同时浏览器也被分装到桌面应用中去&#xff0c;本文就给大家分享一下浏览器发展的四大方向。 方向一&#xff1a; 传统桌面浏览器…
阅读更多...
shell文本三剑客之sed

shell文本三剑客之sed

一、sed编辑器 sed是一种流编辑器&#xff0c;流编辑器会在编辑器处理数据之前基于预先提供的一组规则来编辑数据流。sed编辑器可以根据命令来处理数据流中的数据&#xff0c;这些命令要么从命令行中输入&#xff0c;要么存储在一个命令文本文件中。 1、sed的执行过程 读取&…
阅读更多...
把Vue文件转至树莓派上遇到的问题和解决方案

把Vue文件转至树莓派上遇到的问题和解决方案

把整个文件夹复制进树莓派后&#xff0c;运行 npm run dev ,报错sh: 1: vite: Permission denied 解决方案&#xff1a;删除项目里的 node_modules 重新 npm install 再运行即可 rm -rf node_modules/ npm install 在安装过程中&#xff0c;遇到下图问题&#xff0c;vulnerabi…
阅读更多...
Docker：认识Docker Compose

Docker：认识Docker Compose

文章目录 什么是docker compose&#xff1f;为什么要使用docker compose&#xff1f;docker compose的功能使用步骤核心功能 docker compose使用场景Docker Compose命令清单Docker Compose 命令格式操作演示创建一个Compose目录创建一个docker-compose.yml文件创建首页目录&…
阅读更多...
【笔记】【Git】多个dev分支合并到master分支的文件冲突

【笔记】【Git】多个dev分支合并到master分支的文件冲突

问题描述 多个dev分支在同步开发，同时发起代码评审，但合入master的时候存在先后顺序，那么后面同文件的操作则会提示“合并有文件冲突”，导致代码无法入库，只能重新提交。 在个人分支中如何解决与master分支差异，从何顺利提交评审合入代码？ 参考方案 1、按照下面的流程…
阅读更多...
人工智能的社会应用：深刻变革的新浪潮

人工智能的社会应用：深刻变革的新浪潮

人工智能的社会应用&#xff08;语言文本方面&#xff09; 人工智能在社会应用中的广泛运用体现在多个领域&#xff0c;特别是在语音和文本处理方面。以下是这些技术的一些扩展&#xff1a; 1. 文本翻译&#xff1a; 谷歌翻译&#xff1a;利用深度学习模型&#xff0c;支持100多…
阅读更多...
「51媒体」媒体邀约-全国邀请媒体现场报道宣传

「51媒体」媒体邀约-全国邀请媒体现场报道宣传

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 「51媒体」媒体邀约是一家专注于提供媒体传播方案和执行的服务公司&#xff0c;旨在通过一站式服务帮助企业或个人进行有效的媒体邀约和活动宣传。 「51媒体」提供的不仅仅是简单的媒体邀…
阅读更多...
暗色系B端界面有什么好处、应用场景、缺点、该如何设计。

暗色系B端界面有什么好处、应用场景、缺点、该如何设计。

B端管理系统界面蓝色系和浅色系的非常多&#xff0c;暗色系一般不作为首选&#xff0c;这背后是什么原因呢&#xff0c;如果真的要设计暗色系界面&#xff0c;该如何办呢&#xff0c;本文就解决这些问题。 一、暗色系B端界面相对于浅色系有什么好处 1. 减少眩光和视觉疲劳&am…
阅读更多...
最新文章

Copyright @ 2022~2023