SpringBoot集成Shiro+Jwt+Redis

news2024/11/5 21:28:11

1. 概述

首先需要知道为什么使用 Shiro+Jwt+Redis 进行登录认证和权限控制。

1. 为什么用Shiro？
主要用的是 shiro 的登录认证和权限控制功能。
Shiro 参见本栏目文章 🍃《Shiro实战》

2. 为什么用Jwt？
Shiro 默认的 Session 机制来帮助实现权限管理，用于维护用户的状态信息。而 JWT 是 token认证 的一种具体实现方式，相对于传统的 session认证方式，有如下优点：

  • 跨域支持：cookie 是无法跨域的，而 token 由于没有用到 cookie（前提是将 token 放到请求头中），所以跨域后不会存在信息丢失问题。
  • 无状态：token 机制在服务端不需要存储 session 信息，因为 token 自身包含了所有登录用户的信息，所以可以减轻服务端压力，节约服务器资源，并且可以很容易地分布式横向扩展应用。
  • 更适用CDN：可以通过内容分发网络请求服务端的所有资料。
  • 更适用于移动端：当客户端是非浏览器平台时，cookie 是不被支持的，此时采用 token 认证方式会简单很多。
  • 无需考虑CSRF：由于不再依赖 cookie，所以采用 token 认证方式不会发生 CSRF，所以也就无需考虑 CSRF 防御。

JWT 参见本栏目文章 🍃《JWT详解》

3. 为什么用Redis？

  1. JWT 本身不能续期，结合 Redis，可以实现续期、主动登出。
  2. Redis可以缓存用户信息，减少数据库压力。
  3. 可以实现分布式环境下的会话共享。

2. Springboot整合Shiro+Jwt+Redis

在这里插入图片描述

2.1 JWT配置

2.1.1 依赖

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.19.0</version>
</dependency>

2.1.2 配置JWT

shiro:
  jwt:
    # 加密秘钥
    secret: kGgySFGcfQML4ZOvvlE7856YvSCsbjBf
    # token有效时长，1天，单位毫秒
    expire: 86400000
    header:
      # 加密算法
      alg: HS256
      # token类型
      typ: JWT

2.1.2 JWT工具类

@Component
public class JwtUtil {

    @Value("${shiro.jwt.secret}")
    private String secret;
    @Value("${shiro.jwt.expire}")
    private Long expire;
    @Value("${shiro.jwt.header.alg}")
    private String headerAlg;
    @Value("${shiro.jwt.header.typ}")
    private String headerTyp;

    /**
     * 生成token
     */
    public String getToken(String account, long currentTimeMillis) {
        // 设置秘钥
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(account).append(secret);

        // 设置jwt头header
        Map<String, Object> headerClaims = new HashMap<>();
        headerClaims.put("alg", headerAlg); // 签名算法
        headerClaims.put("typ", headerTyp); // token 类型
        // 设置jwt的header，负载paload以及加密算法
        String token = JWT
                .create()
                .withHeader(headerClaims)
                .withClaim("account" ,account)
                .withClaim("expire", currentTimeMillis + expire)
                .sign(Algorithm.HMAC256(stringBuilder.toString()));
        return token;
    }

    /**
     * 无需秘钥就能获取其中的信息
     * 解析token.
     * {
     * "account": "account",
     * "timeStamp": "134143214"
     * }
     */
    public Map<String, String> parseToken(String token) {
        HashMap<String, String> map = new HashMap<String, String>();
        // 解码 JWT
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        Claim expire = decodedJwt.getClaim("expire");
        map.put("account", account.asString());
        map.put("expire", expire.asLong().toString());
        return map;
    }

    /**
     * 解析token获取账号.
     */
    public String getAccount(String token) {
        HashMap<String, String> map = new HashMap<String, String>();
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        return account.asString();
    }

    /**
     * 校验token是否正确
     * @param token Token
     * @return boolean 是否正确
     */
    public boolean verify(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim account = decodedJwt.getClaim("account");
        Claim expire = decodedJwt.getClaim("expire");
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(account.asString()).append(secret);
        // 验证JWT的签名和有效性
        Algorithm algorithm = Algorithm.HMAC256(stringBuilder.toString());
        JWTVerifier verifier = JWT.require(algorithm).build();
        try {
            verifier.verify(token);
            return true; // 验证通过
        } catch (JWTVerificationException e) {
            return false; // 验证失败
        }
    }


    /**
     * 校验token是否过期
     * @param token Token
     * @return boolean 是否正确
     */
    public boolean isExpired(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim expire = decodedJwt.getClaim("expire");
        // 验证过期时间
        Long expireTime = expire.asLong();
        if (System.currentTimeMillis() > expireTime) {
            return true;
        }
        return false;
    }


    /**
     * 获取token过期时间
     * @param token Token
     * @return boolean 是否正确
     */
    public long getExpiredTime(String token) {
        DecodedJWT decodedJwt = JWT.decode(token);
        Claim expire = decodedJwt.getClaim("expire");
        return expire.asLong();
    }

}

2.2 Redis配置

2.2.1 依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.2.2 配置 Redis 地址

spring:
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0
    timeout: 5000
    lettuce:
      pool:
        max-idle: 16
        max-active: 32
        min-idle: 8

2.2.3 Redis序列化

/**
 * redis序列化
 */
@Configuration
public class RedisConfig {
    @Bean(name = "redisTemplate")
    public RedisTemplate<String, Object> getRedisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        // 设置序列化
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // 配置redisTemplate
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(lettuceConnectionFactory);
        RedisSerializer<?> stringSerializer = new StringRedisSerializer();
        // key序列化
        redisTemplate.setKeySerializer(stringSerializer);
        // value序列化
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        // Hash key序列化
        redisTemplate.setHashKeySerializer(stringSerializer);
        // Hash value序列化
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

2.2.4 Redis工具类

封装 RedisTemplate

/**
 * RedisUtil 工具类
 */
@Component
public class RedisUtil {
    // 使用jwt的过期时间毫秒
    private final long defaultTimeout = 1*24*60*60*1000;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 是否存在指定的key
     *
     * @param key
     * @return
     */
    public boolean hasKey(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 删除指定的key
     *
     * @param key
     * @return
     */
    public boolean delete(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    //- - - - - - - - - - - - - - - - - - - - -  String类型 - - - - - - - - - - - - - - - - - - - -
    /**
     * 根据key获取值
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 将值放入缓存
     *
     * @param key   键
     * @param value 值
     * @return true成功 false 失败
     */
    public void set(String key, String value) {
        set(key, value, defaultTimeout);
    }

    /**
     * 将值放入缓存并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) -1为无期限
     * @return true成功 false 失败
     */
    public void set(String key, String value, long time) {
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value, defaultTimeout, TimeUnit.SECONDS);
        }
    }

    //- - - - - - - - - - - - - - - - - - - - -  object类型 - - - - - - - - - - - - - - - - - - - -
    /**
     * 根据key读取数据
     */
    public Object getObject(final String key) {
        if (StringUtils.isBlank(key)) {
            return null;
        }
        try {
            return redisTemplate.opsForValue().get(key);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 写入数据
     */
    public boolean setObject(final String key, Object value) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        try {
            setObject(key, value , defaultTimeout);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public boolean setObject(final String key, Object value, long time) {
        if (StringUtils.isBlank(key)) {
            return false;
        }
        if (time > 0) {
            redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
        } else {
            redisTemplate.opsForValue().set(key, value, defaultTimeout, TimeUnit.SECONDS);
        }
        return true;
    }
}

2.2.5 Redis常量

public class RedisConstant {

    private RedisConstant() {}

    public static final String PREFIX_ACCESS_TOKEN = "access_token";

    public static final String PREFIX_SHIRO_JWT = "shiro:jwt:";
}

2.3 Shiro配置

🍃《Shiro实战》已经介绍 Shiro 基本用法，如果需要整合 JWT 进行 token 认证，主要涉及三块改动：

  1. 关闭 Shiro 原有的 Session 功能，依赖于 Token 来进行认证。涉及 ShiroConfig 类改造。
  2. 配置 Shiro 的 过滤器链 来指定哪些 URL 需要进行 JWT 认证。涉及 ShiroConfig 类改造。
  3. 自定义 Realm 类中认证方法 doGetAuthenticationInfo 进行逻辑改造。涉及 CustomRealm 类改造。

2.3.1 ShiroConfig

@Configuration
public class ShiroConfig {
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        // 散列算法：这里使用 SHA-256 算法;
        HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher("SHA-256");
        // 散列的次数，比如散列两次，相当于 SHA-256(SHA-256(""));
        credentialsMatcher.setHashIterations(1024);
        // storedCredentialsHexEncoded 默认是 true，此时用的是密码加密用的是 Hex 编码；false 时用 Base64 编码
        credentialsMatcher.setStoredCredentialsHexEncoded(true);
        return credentialsMatcher;
    }

    @Bean
    public CustomRealm customRealm() {
        CustomRealm customRealm = new CustomRealm();
        // 将 HashService 注入到自定义的 Realm 中，告诉 realm，使用 hashedCredentialsMatcher 加密算法类来验证密文
        customRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return customRealm;
    }

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        // 设置自定义 Realm
        securityManager.setRealm(customRealm());
        // 禁用 Shiro 的 Session 存储，这样可以确保 shiro 不会创建或使用 Session，而是依赖于无状态的 Token 来进行认证。
        DefaultSubjectDAO subjectDAO = new DefaultSubjectDAO();
        DefaultSessionStorageEvaluator defaultSessionStorageEvaluator = new DefaultSessionStorageEvaluator();
        defaultSessionStorageEvaluator.setSessionStorageEnabled(false);
        subjectDAO.setSessionStorageEvaluator(defaultSessionStorageEvaluator);
        securityManager.setSubjectDAO(subjectDAO);
        return securityManager;
    }

    @Bean(name = "shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        // 注入 securityManager
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 添加自定义 Filter，并且取名为 jwt
        Map<String, Filter> filterMap = new HashMap<>();
        filterMap.put("jwt", new JwtFilter());
        shiroFilterFactoryBean.setFilters(filterMap);

        /*//登录
        shiroFilterFactoryBean.setLoginUrl("/login");
        //首页
        shiroFilterFactoryBean.setSuccessUrl("/index");
        //错误页面，认证不通过跳转
        shiroFilterFactoryBean.setUnauthorizedUrl("/notRole");
        shiroFilterFactoryBean.setUnauthorizedUrl("/error");*/

        // 设置 Shiro 的过滤器链来指定哪些 URL 需要进行 JWT 认证。
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        // authc：所有url都必须认证通过才可以访问; anon：所有url都都可以匿名访问
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/api/**", "anon");
        // /** 必须放在所有权限设置的最后，表示对所有资源起作用，本例使用自定义 jwt
        filterChainDefinitionMap.put("/**", "jwt");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }


    /**
     * *
     *  开启 Shiro 的注解（如@RequiresRoles、@RequiresPermissions），需借助 SpringAOP 扫描使用 Shiro 注解的类，并在必要时进行安全逻辑验证
     * *
     *  配置以下两个 bean （DefaultAdvisorAutoProxyCreator（可选）和 AuthorizationAttributeSourceAdvisor）即可实现此功能
     * * @return
     */
    // 配置 DefaultAdvisorAutoProxyCreator，执行权限注解 @RequiresPermissions 会调用两次 doGetAuthorizationInfo() 方法。故不注入该配置。
    /*@Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }

    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator() {
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }*/

    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
        return authorizationAttributeSourceAdvisor;
    }
}

其中，
在这里插入图片描述

该配置将 禁用 Shiro 的 Session 存储，这样可以确保 shiro 不会创建或使用 Session，而是依赖于 无状态的 Token 来进行认证。

在这里插入图片描述

  • filterMap.put("jwt", new JwtFilter()) 添加自定义 Filter，并且取名为 jwt。
  • filterChainDefinitionMap.put("/**", "jwt") 配置 Shiro 的过滤器链来指定哪些 URL 需要进行 JWT 认证。

2.3.2 自定义过滤器JwtFilter

自定义的 JWT 过滤器类。

/**
 *  jwt过滤器，作为shiro的过滤器，对请求进行拦截并处理
 */
@Slf4j
@Component
public class JwtFilter extends BasicHttpAuthenticationFilter {
    private String errorMsg;

    /**
     * 过滤器拦截请求的入口方法
     */
    @Override
    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
        // 判断请求头是否带上“Token”
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        String token = httpServletRequest.getHeader("Authorization");
        // 游客访问电商平台首页可以不用携带 token
        if (StringUtils.isEmpty(token)) {
            return true;
        }
        try {
            // 交给自定义 Realm 处理
            // getSubject(request, response).login(new JwtToken(token));  //getSubject(request, response) 等同于 SecurityUtils.getSubject()
            SecurityUtils.getSubject().login(new JwtToken(token));
            return true;
        } catch (Exception e) {
            errorMsg = e.getMessage();
            e.printStackTrace();
            return false;
        }
    }

    /**
     * isAccessAllowed()方法返回false，即认证不通过时进入onAccessDenied方法
     */
    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setStatus(400);
        httpServletResponse.setContentType("application/json;charset=utf-8");
        PrintWriter out = httpServletResponse.getWriter();
        out.println(JSONUtil.toJsonStr(Result.error(errorMsg)));
        out.flush();
        out.close();
        return false;
    }

    /**
     * 对跨域访问提供支持
     *
     * @param request
     * @param response
     * @return
     * @throws Exception
     */
    @Override
    protected boolean preHandle(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setHeader("Access-control-Allow-Origin", httpServletRequest.getHeader("Origin"));
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS,PUT,DELETE");
        httpServletResponse.setHeader("Access-Control-Allow-Headers", httpServletRequest.getHeader("Access-Control-Request-Headers"));
        // 跨域发送一个option请求
        if (httpServletRequest.getMethod().equals(RequestMethod.OPTIONS.name())) {
            httpServletResponse.setStatus(HttpStatus.OK.value());
            return false;
        }
        return super.preHandle(request, response);
    }

}
  • isAccessAllowed：过滤器拦截请求的入口方法。后续会交由自定义 Realm 处理。
  • onAccessDenied：认证不通过时，需要做什么处理。
  • preHandle：对跨域访问提供支持

2.3.3 自定义AuthenticationToken

JWTFilter 传递给 Realm 的 token 必须是 AuthenticationToken 的实现类，通过这个类将 string 的 token 转型成 AuthenticationToken，主要目的是在 Realm 的认证和授权的时候，能够获取到 token。

/*
 * 将 String 的 token 转型成 AuthenticationToken，供 Realm 认证和授权使用
 */
public class JwtToken implements AuthenticationToken {
    private String token;

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

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

✨注：需要重写 getPrincipal 和 getCredentials 方法。

2.3.4 自定义Realm

自定义 Realm 类中认证方法 doGetAuthenticationInfo 进行逻辑改造。

Shiro+Jwt+Redis

shiro整合redis jwt

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于Python的乡村居民信息管理系统【附源码】

基于Python的乡村居民信息管理系统【附源码】

基于Python的乡村居民信息管理系统 效果如下&#xff1a; 系统主页面 系统登录页面 管理员主页面 居民管理页面 政务学习页面 土地信息管理页面 个人信息管理页面 居民登陆页面 村委人员主页面 研究背景 随着信息技术的飞速发展和乡村振兴战略的深入实施&#xff0c;传统的乡…
阅读更多...
HTML 基础标签——表单标签＜form＞

HTML 基础标签——表单标签＜form＞

文章目录 1. `<form>` 标签：定义表单容器2. `<input>` 标签：多用途输入控件3. `<textarea>` 标签：多行文本输入框4. `<select>` 标签：下拉选择框5. `<option>` 标签：下拉菜单选项6. `<button>` 标签：按钮元素7. `<label>` 标签…
阅读更多...
Debian的基本使用

Debian的基本使用

前言 本人撰写的相关文档中&#xff0c;部分技术已经不再提供支持了&#xff08;不得不感慨&#xff0c;菜鸡的个人进步追不上技术更新啊&#xff09;&#xff0c;比如Centos、EasyExcel&#xff0c;虽然说目前仅使用还没有什么问题&#xff0c;但是还是要了解一下备用方案。 …
阅读更多...
比亚迪能不能打败特斯拉？

比亚迪能不能打败特斯拉？

文/孔文清 比亚迪在第三季度的财报发布后&#xff0c;首次在营收上超越了特斯拉&#xff0c;这是电动汽车行业的重要时刻&#xff0c;也反映了中国产业在全球市场中的崛起。 比亚迪在其2024年第三季度财报中首次实现了2011.2亿元的营业收入&#xff0c;相比特斯拉的1793亿元&a…
阅读更多...
什么情况下，不推荐建立索引？

什么情况下，不推荐建立索引？

一般有以下几种情况不推荐建立索引&#xff1a; 1&#xff09;对于数据量很小的表 当表的数据量很小&#xff08;如几百条记录&#xff09;时&#xff0c;建立索引并不会显著提高查询性能&#xff0c;反而可能增加管理的复杂性&#xff1b; 2&#xff09;频繁更新的表 对于…
阅读更多...
深度学习基础知识-残差网络ResNet

深度学习基础知识-残差网络ResNet

目录 一、ResNet 的核心思想&#xff1a;残差学习&#xff08;Residual Learning&#xff09; 二、ResNet 的基本原理 三、ResNet 网络结构 1. 残差块&#xff08;Residual Block&#xff09; ResNet 的跳跃连接类型 2. 网络结构图示 四、ResNet 的特点和优势 五、ResNe…
阅读更多...
做反向代购没货源，也能靠“东方玄学”风生水起？

做反向代购没货源，也能靠“东方玄学”风生水起？

在全球化日益加深的今天&#xff0c;文化的交流与碰撞愈发频繁。近年来&#xff0c;一股神秘的东方力量——风水玄学&#xff0c;在海外社交媒体上悄然走红&#xff0c;成为众多外国友人追捧的新风尚。从TikTok到Instagram&#xff0c;无数华人博主通过分享风水知识、解读玄学饰…
阅读更多...
新闻稿件管理：SpringBoot框架实战指南

新闻稿件管理：SpringBoot框架实战指南

3系统分析 3.1可行性分析 通过对本新闻稿件管理系统实行的目的初步调查和分析&#xff0c;提出可行性方案并对其一一进行论证。我们在这里主要从技术可行性、经济可行性、操作可行性等方面进行分析。 3.1.1技术可行性 本新闻稿件管理系统采用SSM框架&#xff0c;JAVA作为开发语…
阅读更多...
web实操2——idea创建普通web项目

web实操2——idea创建普通web项目

创建项目 就是普通的java项目&#xff0c;项目右键add framework support&#xff08;添加框架支持&#xff09;,然后点击Web Application&#xff08;web应用程序&#xff09;&#xff0c;然后点击OK。即可。 文件下就会多一个web文件夹&#xff0c;里面是WEB-INF文件夹&…
阅读更多...
冰雪奇缘！中科院一区算法+双向深度学习+注意力机制！SAO-BiTCN-BiGRU-Attention雪消融算法优化回归预测

冰雪奇缘！中科院一区算法+双向深度学习+注意力机制！SAO-BiTCN-BiGRU-Attention雪消融算法优化回归预测

冰雪奇缘&#xff01;中科院一区算法双向深度学习注意力机制&#xff01;SAO-BiTCN-BiGRU-Attention雪消融算法优化回归预测&#xff08;Matlab&#xff09; 目录 冰雪奇缘&#xff01;中科院一区算法双向深度学习注意力机制&#xff01;SAO-BiTCN-BiGRU-Attention雪消融算法优…
阅读更多...
LabVIEW适合开发的软件

LabVIEW适合开发的软件

LabVIEW作为一种图形化编程环境&#xff0c;主要用于测试、测量和控制系统的开发。以下是LabVIEW在不同应用场景中的适用性和优势。 一、测试与测量系统 LabVIEW在测试与测量系统中的应用广泛&#xff0c;是工程测试领域的主流工具之一。利用其强大的数据采集与处理功能&…
阅读更多...
ssm校园线上订餐系统的设计与实现+vue

ssm校园线上订餐系统的设计与实现+vue

系统包含&#xff1a;源码论文 所用技术&#xff1a;SpringBootVueSSMMybatisMysql 免费提供给大家参考或者学习&#xff0c;获取源码看文章最下面 需要定制看文章最下面 目 录 摘 要 I 目 录 III 第1章 绪论 1 1.1 研究背景 1 1.2目的和意义 1 1.3 论文研究内容 1 …
阅读更多...
stm32使用串口的轮询模式，实现数据的收发

stm32使用串口的轮询模式，实现数据的收发

------内容以b站博主keysking为原型&#xff0c;整理而来&#xff0c;用作个人学习记录。 首先在STM32CubeMX中配置 前期工作省略&#xff0c;只讲重点设置。 这里我配置的是USART2的模式。 会发现&#xff0c;PA2和PA3分别是TX与RX&#xff0c;在连接串口时需要TX对RX&…
阅读更多...
Webserver(2.8)守护进程

Webserver(2.8)守护进程

目录 守护进程案例 守护进程案例 每隔2s获取系统时间&#xff0c;将这个时间写入到磁盘文件中 #include<stdio.h> #include<sys/stat.h> #include<sys/types.h> #include<unistd.h> #include<fcntl.h> #include<sys/time.h> #include<…
阅读更多...
Vue3父传子

Vue3父传子

1. App.vue - 父组件 咱们先来看左边的 App.vue&#xff0c;它扮演的是“父亲”角色——你可以想象它是一位热心的老爸&#xff0c;手里拿着一条消息&#xff0c;正准备把这条消息送到“儿子”那里。 <script setup> // 这个 setup 就像一个神奇的开关&#xff0c;一开…
阅读更多...
IO 多路复用技术：原理、类型及 Go 实现

IO 多路复用技术：原理、类型及 Go 实现

文章目录 1. 引言IO 多路复用的应用场景与重要性高并发下的 IO 处理挑战 2. IO 多路复用概述什么是 IO 多路复用IO 多路复用的优点与适用场景 3. IO 多路复用的三种主要实现3.1 select3.2 poll3.3 epoll三者对比 4. 深入理解 epoll4.1 epoll 的三大操作4.2 epoll 的核心数据结构…
阅读更多...
HarmonyOS-消息推送

HarmonyOS-消息推送

一. 服务简述 Push Kit&#xff08;推送服务&#xff09;是华为提供的消息推送平台&#xff0c;建立了从云端到终端的消息推送通道。所有HarmonyOS 应用可通过集成 Push Kit&#xff0c;实现向应用实时推送消息&#xff0c;使消息易见&#xff0c;构筑良好的用户关系&#xff0…
阅读更多...
ubuntu安装与配置Nginx（1）

ubuntu安装与配置Nginx（1）

在 Ubuntu 上安装和配置 Nginx 是相对简单的。以下是一个逐步指南&#xff1a; 1. 更新系统包 首先&#xff0c;确保你的系统是最新的。打开终端并运行&#xff1a; sudo apt update sudo apt upgrade2. 安装 Nginx 使用以下命令安装 Nginx&#xff1a; sudo apt install …
阅读更多...
FastAdmin动态创建一个富文本编辑器（summernote）

FastAdmin动态创建一个富文本编辑器（summernote）

话多说直接看效果&#xff1a; <!-- 动态创建的一个富文本&#xff0c;请注意本人是为了方便所以把js放在了这里&#xff0c;使用者可以结合自身需求修改 --><div class"form-group"><!-- 这里博主使用临时路径&#xff0c;需要自行修改 --><…
阅读更多...
网络层5——IPV6

网络层5——IPV6

目录 一、IPv6 vs IPv4 1、对IPv6主要变化 2、IPv4 vs IPv6 二、IPv6基本首部 1、版本——4位 2、通信量类——8位 3、流标号——20位 4、有效载荷长度——16位 5、下一个首部——8位 6、跳数限制——8位 7、源 、 目的地址——128位 8、扩展首部 三、IPv6地址 1…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023