深入理解Spring Security

news2024/11/18 2:39:10

第1章：Spring Security简介

大家好，我是小黑，在谈到网站安全的时候，Spring Security是个避不开的话题。它就像是个守门员，决定谁能进入我们的网站，又能在网站的哪些角落里走动。简单来说，Spring Security负责两大块：认证（Authentication）和授权（Authorization）。认证是确认咱们的身份，授权则是决定咱们能做什么、不能做什么。

想象一下，小黑正在尝试进入一个只有VIP成员才能访问的网站区域。Spring Security首先会检查小黑是不是网站的注册用户，这就是认证。一旦确认小黑确实是谁他说的那个人，接下来就要看看小黑有没有VIP的权限，这就是授权的过程了。

这套机制听起来是不是很像生活中的例子？比如，咱们进入一家公司，需要先通过门卫的身份验证，然后才能根据自己的身份证进入相应的办公区域。Spring Security就是在软件里，为应用程序提供这样一道保护屏障。

Spring Security的强大之处还在于它的灵活性和扩展性。不论是对于简单的个人博客，还是复杂的企业系统，它都能提供强有力的安全保障。而且，Spring Security支持多种认证方式，比如表单登录、LDAP、OAuth2等，几乎可以满足所有的安全需求。

第2章：认证与授权基础

谈到Spring Security，咱们不能不提它的两大核心：认证和授权。这两者听起来很简单，但要做好，细节是关键。

认证，就是确认请求者的身份。在Spring Security中，这个过程通常是通过AuthenticationManager来完成的。它会使用一系列的AuthenticationProvider，每个Provider都尝试认证用户提交的信息。如果认证成功，用户的详情就会被保存在SecurityContextHolder中，方便后续操作使用。

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;

// 创建一个用户的认证令牌
Authentication request = new UsernamePasswordAuthenticationToken("小黑的用户名", "小黑的密码");
// 通过AuthenticationManager验证用户的认证信息
Authentication result = authenticationManager.authenticate(request);
// 认证成功后，将用户信息保存到SecurityContextHolder
SecurityContextHolder.getContext().setAuthentication(result);

授权，则是决定认证通过的用户能做什么。在Spring Security中，这通常是通过定义一系列的权限规则来实现的。比如，咱们可以定义某个API接口只允许拥有ADMIN角色的用户访问。

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/admin/**").hasRole("ADMIN") // 只有ADMIN角色的用户才能访问/admin/**路径
            .anyRequest().authenticated(); // 其他所有请求都需要认证
    }
}

通过这两段代码，咱们可以看到Spring Security在认证和授权上的基本使用。但真正的魅力在于它的灵活性和扩展性，无论是简单的身份验证，还是复杂的权限控制，Spring Security都能轻松应对。

第3章：配置Spring Security

配置Spring Security可能听起来有点儿头疼，但别担心，小黑来带咱们一步步搞定它。要让Spring Security为咱们的应用站岗放哨，首先得让它知道咱们的规则。这就像是告诉守门员，哪些人可以进来，哪些人需要验证，哪些区域是禁止进入的。

引入Spring Security

在开始配置之前，确保咱们的项目中已经加入了Spring Security的依赖。如果是用Spring Boot，那简直不能更简单，只需要在pom.xml文件中加入下面这段：

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

这行代码就像是给咱们的项目装上了一个安全套件，Spring Boot会自动配置很多东西，但咱们还需要根据自己的需求做一些调整。

基本的HTTP安全配置

Spring Security的魅力之一就在于它的灵活性，咱们可以轻松定义哪些路径需要认证，哪些不需要。来看看下面这段基础配置：

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests() // 开始定义哪些URL需要被保护、哪些不需要
            .antMatchers("/", "/home").permitAll() // 定义不需要认证就可以访问的路径
            .anyRequest().authenticated() // 任何请求,登录后可以访问
            .and()
            .formLogin() // 定义当需要用户登录时候，转到的登录页面
            .loginPage("/login") // 设置登录页面
            .permitAll() // 登录页面用户任意访问
            .and()
            .logout() // 默认注销行为为logout，可以通过logoutUrl()定制
            .permitAll(); // 注销行为任意访问
    }
}

这段代码其实就是在说：“听着，Spring Security，首页和home页面谁都可以随便进，但如果想要访问其他页面，用户得登录。哦，对了，登录页面设置在/login这里，别忘了所有人都可以访问登录和注销页面。”

自定义用户认证

默认情况下，Spring Security会提供一个用户进行认证，但这通常不符合实际需求。咱们通常需要从数据库或其他地方读取用户信息。这时，就需要自定义UserDetailsService了：

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Service;

import java.util.Collections;

@Service
public class MyUserDetailsService implements UserDetailsService {

    @Override
    public User loadUserByUsername(String username) throws UsernameNotFoundException {
        // 假设这里调用数据库，根据用户名找到用户
        // 为了示例简单，直接创建一个用户
        return new User("小黑", "{noop}password", Collections.singletonList(new SimpleGrantedAuthority("ROLE_USER")));
    }
}

这段代码就是自定义的用户服务，它告诉Spring Security使用咱们提供的方式来加载用户信息。注意这里的{noop}前缀，它是告诉Spring Security这个密码没有加密，这样做只是为了示例简单，在实际项目中强烈建议使用密码加密。

第4章：深入理解Spring Security认证流程

理解Spring Security的认证流程就像是拆解一个精密的时钟，看看里面的齿轮是如何协同工作的。这个过程可能有点复杂，但别担心，小黑在这里帮咱们一步步拆解，让这个复杂的机制变得简单易懂。

认证流程概览

在深入代码之前，咱们先来了解一下Spring Security认证流程的大致轮廓。用户提交用户名和密码后，这个信息首先会被一个叫做AuthenticationFilter的东西拦截。这个过滤器的任务就是收集认证信息并将其传递给AuthenticationManager，后者则是真正的认证大脑，负责检查这个用户是否真的是他声称的那个人。

如果认证成功，AuthenticationManager就会返回一个充满用户详情和权限信息的Authentication对象，标志着用户成功登录。但如果失败，则会抛出异常，告知用户认证失败的原因。

代码实现认证流程

接下来，让咱们看看这个过程在代码层面是如何实现的。假设咱们想要自定义一个认证过滤器来处理JSON格式的登录请求：

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import javax.servlet.FilterChain;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.util.Collections;

public class CustomAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {
        try {
            // 从请求中读取用户名和密码
            BufferedReader reader = request.getReader();
            StringBuilder sb = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
            LoginRequest loginRequest = new ObjectMapper().readValue(sb.toString(), LoginRequest.class);
            UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(
                    loginRequest.getUsername(), loginRequest.getPassword(), Collections.emptyList());
            // 允许子类设置详细属性
            setDetails(request, authRequest);
            // 运行AuthenticationManager认证用户
            return this.getAuthenticationManager().authenticate(authRequest);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    // 需要定义一个LoginRequest类来匹配JSON中的字段
    static class LoginRequest {
        private String username;
        private String password;
        // getter和setter省略
    }
}

这段代码定义了一个自定义的认证过滤器CustomAuthenticationFilter，它继承自UsernamePasswordAuthenticationFilter，主要改写了attemptAuthentication方法，使其能够处理JSON格式的登录请求。这个方法首先从HTTP请求中解析出用户名和密码，然后创建一个UsernamePasswordAuthenticationToken对象，并通过AuthenticationManager进行认证。

认证成功与失败的处理

认证成功后，通常需要将一些信息返回给用户，比如JWT令牌或者其他的认证信息。同样，如果认证失败，咱们也需要合理处理，比如返回一个错误消息。

在CustomAuthenticationFilter中，咱们可以重写successfulAuthentication和unsuccessfulAuthentication方法来自定义这些行为：

@Override
protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) {
    // 认证成功后的逻辑，比如生成JWT令牌，返回给客户端
}

@Override
protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException {
    // 认证失败的逻辑，比如返回一个错误消息
    response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
    response.getWriter().write("认证失败，原因：" + failed.getMessage());
}

通过这些自定义的逻辑，咱们可以控制认证成功或失败后的行为，提高用户体验。

理解和实现Spring Security的认证流程是保护咱们应用安全的关键步骤。通过自定义认证过滤器和成功失败处理逻辑，咱们可以根据应用的特定需求灵活地实现认证机制。希望通过本章的讲解，咱们对Spring Security的认证流程有了更深入的理解。

第5章：探索Spring Security授权过程

授权流程概览

授权，简单来说，就是确定一个已认证的用户是否有权限进行某个操作。在Spring Security中，这通常涉及到两个关键概念：角色（Roles）和权限（Authorities）。角色通常代表了用户的身份，比如"管理员"或"普通用户"，而权限则更细粒度，表示用户能执行的具体操作，比如"读取数据"或"修改数据"。

当请求到达应用时，Spring Security会检查与请求相关的安全配置，确定执行该请求需要哪些权限。然后，它会检查当前用户是否具有这些权限，如果满足条件，则允许操作；如果不满足，则拒绝访问。

代码实现授权配置

让咱们看看如何在Spring Security中配置这些规则。假设小黑想要创建一个简单的Web应用，其中包含三个部分：首页（所有人可见）、用户信息页（仅登录用户可见）和管理员页面（仅管理员可见）。

import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
            .antMatchers("/").permitAll() // 首页所有人都可以访问
            .antMatchers("/user/**").hasRole("USER") // 用户信息页仅限角色为USER的用户访问
            .antMatchers("/admin/**").hasAuthority("ROLE_ADMIN") // 管理员页面仅限拥有ADMIN权限的用户访问
            .anyRequest().authenticated(); // 除了上述路径外，其他所有请求都需要认证
    }
}

在这段代码中，小黑通过authorizeRequests()方法和一系列的antMatchers()方法调用，定义了不同URL模式所需的权限。这样，Spring Security就能根据配置，控制对不同部分的访问。

深入理解权限检查

当一个请求到达时，Spring Security会评估与该请求相关的所有配置规则，决定是否允许访问。这个过程不仅涉及到了用户的角色和权限，还可能包括其他的安全约束，比如请求的来源IP地址。

为了更深入地理解这个过程，咱们可以看一个更复杂的例子，比如基于方法的安全性：

import org.springframework.security.access.prepost.PreAuthorize;

public class UserService {

    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long userId) {
        // 删除用户的代码逻辑
    }
}

在这个例子中，deleteUser方法被@PreAuthorize注解修饰，这意味着只有拥有ADMIN角色的用户才能调用此方法。Spring Security会在方法调用之前检查当前用户是否符合给定的条件。

第6章：深入JWT与Spring Security整合

在今天的网络里，保护咱们的应用安全变得越来越重要。好在，有了像JSON Web Token（JWT）这样的技术，能帮助咱们在客户端和服务器之间安全地传递信息。这一章节，小黑要带咱们深入了解JWT是什么，以及如何在Spring Security中使用JWT来实现无状态的认证机制。

JWT简介

JWT是一个开放标准（RFC 7519），它定义了一种紧凑且自包含的方式，用于在各方之间安全地传输信息。一个JWT实际上就是一个被编码的JSON对象，包含了一系列声明。这些声明可以被用来传递用户身份信息，或者任何其他数据。

JWT通常由三部分组成：头部（Header）、载荷（Payload）和签名（Signature）。头部包含了令牌的类型和所使用的算法；载荷包含了一系列声明；签名则用于验证消息的真实性和完整性。

在Spring Security中使用JWT

要在Spring Security中使用JWT，咱们需要进行几个步骤的配置。首先，咱们要添加一个过滤器来解析每个请求中的JWT，然后创建一个自定义的认证令牌，并将其传递给Spring Security的认证管理器。

让咱们通过代码来具体看看这个过程：

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.filter.GenericFilterBean;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

public class JwtTokenFilter extends GenericFilterBean {

    private JwtTokenProvider jwtTokenProvider;

    // 构造函数
    public JwtTokenFilter(JwtTokenProvider jwtTokenProvider) {
        this.jwtTokenProvider = jwtTokenProvider;
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        String token = jwtTokenProvider.resolveToken((HttpServletRequest) request);
        if (token != null && jwtTokenProvider.validateToken(token)) {
            Authentication auth = jwtTokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(auth);
        }
        chain.doFilter(request, response);
    }
}

在这段代码里，小黑创建了一个JwtTokenFilter，它继承自GenericFilterBean。这个过滤器的任务是解析请求中的JWT，验证它，然后创建一个UsernamePasswordAuthenticationToken，最后将其设置到SecurityContextHolder中。这样，Spring Security就能使用这个令牌来完成认证过程。

JWT的验证和生成

为了生成和验证JWT，咱们需要一个JwtTokenProvider类。这个类会处理JWT的生成、验证以及从请求中解析JWT的逻辑。

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

public class JwtTokenProvider {

    private String secretKey = "秘钥"; // 实际应用中应该更复杂，且存储在安全的地方

    // 生成JWT
    public String createToken(String username, List<String> roles) {
        Claims claims = Jwts.claims().setSubject(username);
        claims.put("roles", roles);

        Date now = new Date();
        Date validity = new Date(now.getTime() + 3600000); // 设置过期时间为1小时

        return Jwts.builder()
                .setClaims(claims)
                .setIssuedAt(now)
                .setExpiration(validity)
                .signWith(SignatureAlgorithm.HS256, secretKey)
                .compact();
    }

    // 从请求中获取JWT
    public String resolveToken(HttpServletRequest request) {
        String bearerToken = request.getHeader("Authorization");
        if (bearerToken != null && bearerToken.startsWith("Bearer ")) {
            return bearerToken.substring(7);
        }
        return null;
    }

    // 验证JWT的有效性
    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            throw new CustomException("Expired or invalid JWT token", HttpStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

在这个类中，createToken方法用于生成JWT，resolveToken从HTTP请求中解析出JWT，而validateToken则负责验证JWT的有效性。通过这些方法，小黑能够在Spring Security中灵活地使用JWT进行认证。

第7章：OAuth 2.0与Spring Security的完美搭档

在现代应用程序中，OAuth 2.0 已成为实现授权和认证的金标准。这一章节，小黑将带咱们一探究竟，看看OAuth 2.0是如何在Spring Security中发挥作用的，以及如何通过一个实际的例子来实现它。

OAuth 2.0概述

OAuth 2.0是一个授权框架，允许应用程序获取有限的访问权限。它主要用于授权第三方应用访问用户数据，而无需将用户的登录信息暴露给第三方应用。OAuth 2.0定义了四种授权模式：授权码模式、简化模式、密码模式和客户端凭据模式。在Spring Security中，最常用的是授权码模式，特别是在需要对第三方应用进行安全授权时。

Spring Security中的OAuth 2.0

在Spring Security中整合OAuth 2.0，意味着咱们可以让用户通过第三方服务（如Google、Facebook等）来认证，而无需在自己的系统中处理登录逻辑。这不仅提高了安全性，还为用户提供了便利。

让咱们看看如何通过Spring Boot和Spring Security来实现OAuth 2.0认证：

  1. 依赖配置

首先，确保咱们的pom.xml中包含了Spring Security和OAuth2客户端的依赖。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
</dependencies>
  1. 配置OAuth 2.0

接下来，在application.yml（或application.properties）中配置OAuth 2.0客户端。

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            clientId: 你的Google客户端ID
            clientSecret: 你的Google客户端秘钥
            redirectUri: "{baseUrl}/login/oauth2/code/{registrationId}"
            scope: profile, email

这段配置定义了一个Google OAuth 2.0客户端，包括客户端ID、秘钥以及重定向URI。这些信息需要从Google Cloud Console获取。

  1. 安全配置

在Spring Security配置类中，咱们需要配置哪些路径需要安全保护，哪些不需要。同时，还要配置OAuth 2.0登录。

@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests(authorizeRequests ->
                authorizeRequests
                    .antMatchers("/", "/home").permitAll() // 允许所有人访问首页和/home路径
                    .anyRequest().authenticated() // 其他所有路径都需要认证
            )
            .oauth2Login(); // 启用OAuth 2.0登录
    }
}

通过这段配置，小黑告诉Spring Security哪些请求是公开的，哪些需要通过OAuth 2.0登录后才能访问。

使用OAuth 2.0进行认证

一旦配置完成，咱们的应用就能够处理通过Google等提供的OAuth 2.0服务进行认证的请求了。用户在访问受保护的资源时会被重定向到第三方服务（如Google）的登录页面，完成认证后，会重定向回咱们的应用，并携带一个授权码。Spring Security会处理这个授权码，与OAuth 2.0服务交换获取访问令牌，最终允许用户访问请求的资源。

更多推荐

详解SpringCloud之远程方法调用神器Fegin

掌握Java Future模式及其灵活应用

小黑的超超超级视頻会园站

使用Apache Commons Chain实现命令模式

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

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

相关文章

语音合成(TTS) GPT-SoVITS认知

语音合成(TTS) GPT-SoVITS认知

写在前面 小伙伴推荐&#xff0c;简单了解相对之前试过的其他的TTS项目&#xff0c;GPT-SoVITS的优点简单易用&#xff0c;文档完整&#xff0c;默认的模型效果就很好理解不足小伙伴帮忙指正 不必太纠结于当下&#xff0c;也不必太忧虑未来&#xff0c;当你经历过一些事情的时候…
阅读更多...
智能驾驶控制规划理论学习02-基于搜索的路径规划算法

智能驾驶控制规划理论学习02-基于搜索的路径规划算法

目录 一、路径搜索问题 二、图论基础 三、图搜索方法 1、广度优先搜索&#xff08;BFS&#xff09; bfs与dfs的区别 bfs的搜索过程 bfs的算法实现 2、迪杰斯特拉算法&#xff08;Dijkstra&#xff09; 核心思想 优先级队列 Dijkstra搜索过程 Dijkstra优缺点…
阅读更多...
MySQL(基础篇)——函数、约束

MySQL(基础篇)——函数、约束

一.函数 1.定义 函数是指一段可以直接被另一段程序调用的程序或代码。 2.字符串函数 常见如下&#xff1a; -- 字符串拼接 SELECT CONCAT(hello,MySql) AS CONCAT -- 将字符串全部转为小写 SELECT LOWER(HEllo MYSql) AS LOWER -- 将字符串全部转为大写 SELECT UPPER(Hello…
阅读更多...
前端mock数据 —— 使用Apifox mock页面所需数据

前端mock数据 —— 使用Apifox mock页面所需数据

前端mock数据 —— 使用Apifox 一、使用教程二、本地请求Apifox所mock的接口 一、使用教程 在首页进行新建项目&#xff1a; 新建项目名称&#xff1a; 新建接口&#xff1a; 创建json&#xff1a; 请求方法&#xff1a; GET。URL&#xff1a; api/basis。响应类型&#xff1…
阅读更多...
用Flutter开发App：助力您的移动业务腾飞

用Flutter开发App：助力您的移动业务腾飞

一、Flutter简介 Flutter是Google推出的用于构建多平台应用程序的开源UI框架。它使用Dart语言编写&#xff0c;可以编译为原生机器代码&#xff0c;从而提供卓越的性能和流畅的用户体验。 二、Flutter的优势 一套代码&#xff0c;多平台部署&#xff1a;Flutter可以使用一套代…
阅读更多...
183896-00-6，Biotin-C3-PEG3-C3-NH2，可以选择性降解靶蛋白

183896-00-6，Biotin-C3-PEG3-C3-NH2，可以选择性降解靶蛋白

您好&#xff0c;欢迎来到新研之家 文章关键词&#xff1a;183896-00-6&#xff0c;Biotin-C3-PEG3-C3-NH2&#xff0c;Biotin-C3-PEG3-C3-amine&#xff0c;生物素-C3-PEG3-C3-胺 一、基本信息 【产品简介】&#xff1a;Biotin-PEG3-C3-NH2是一种PROTAC linker&#xff0c;…
阅读更多...
Redis在中国火爆，为何MongoDB更受欢迎国外？

Redis在中国火爆，为何MongoDB更受欢迎国外？

一、概念 Redis Redis&#xff08;Remote Dictionary Server&#xff09;是一个使用ANSI C编写的开源、支持网络、基于内存、分布式、可选持久性的键值对存储数据库。Redis是由Salvatore Sanfilippo于2009年启动开发的&#xff0c;首个版本于同年5月发布。 MongoDB MongoDB…
阅读更多...
Apache Bench（ab ）压力测试

Apache Bench（ab ）压力测试

目录 参数说明示例1&#xff1a;压力测试示例2&#xff1a;测试post接口post数据文件该如何编写&#xff1f; apr_pollset_poll: The timeout specified has expired (70007)apr_socket_recv: Connection reset by peer (104)参考 参数说明 官方文档参考这里。 ab -c 100 -n …
阅读更多...
JVM——JVM与Java体系结构

JVM——JVM与Java体系结构

文章目录 1、Java及JVM简介1.1、Java是跨平台的语言1.2、JVM是跨语言的平台 2、Java发展里程碑3、Open JDK和Oracle JDK4、虚拟机与JVM4.1、虚拟机4.2、JVM 5、JVM整体结构6、Java代码执行流程7、JVM的架构模型7.1、基于栈式架构的特点7.2、基于寄存器架构的特点 8、JVM的生命周…
阅读更多...
使用pytorch实现一个线性回归训练函数

使用pytorch实现一个线性回归训练函数

使用sklearn.dataset 的make_regression创建用于线性回归的数据集 def create_dataset():x, y, coef make_regression(n_samples100, noise10, coefTrue, bias14.5, n_features1, random_state0)return torch.tensor(x), torch.tensor(y), coef 加载数据集&#xff0c;并拆分…
阅读更多...
蓝桥杯_定时器的基本原理与应用

蓝桥杯_定时器的基本原理与应用

一 什么是定时器 定时器/计数器是一种能够对内部时钟信号或外部输入信号进行计数&#xff0c;当计数值达到设定要求时&#xff0c;向cpu提出中断处理请求&#xff0c;从而实现&#xff0c;定时或者计数功能的外设。 二 51单片机的定时/计数器 单片机外部晶振12MHZ&#xff0c;…
阅读更多...
leetcode 重复的子字符串

leetcode 重复的子字符串

前要推理 以abababab为例&#xff0c;这里最主要的就是根据相等前后缀进行推导 s [ 0123 ] 如 t【 0123 】 f 【01 23 】 后两个分别是前后缀&#xff0c;第一个是总的字符串&#xff0c;然后可以推导 //首先还是算出…
阅读更多...
【JavaEE】网络原理: HTTP协议相关内容

【JavaEE】网络原理: HTTP协议相关内容

目录 HTTP 是什么 理解HTTP 协议的工作过程 HTTP 协议格式 抓包工具的使用 抓包工具的原理 抓包结果 HTTP请求 HTTP响应 协议格式总结 HTTP 请求 (Request) 认识 URL 关于 URL encode 认识 "方法" (method) get方法 post方法 其他方法 认识请求 &q…
阅读更多...
Linux小项目：在线词典开发

Linux小项目：在线词典开发

在线词典介绍 流程图如下&#xff1a; 项目的功能介绍 在线英英词典项目功能描述用户注册和登录验证服务器端将用户信息和历史记录保存在数据中。客户端输入用户和密码&#xff0c;服务器端在数据库中查找、匹配&#xff0c;返回结果单词在线翻译根据客户端输入输入的单词在字…
阅读更多...
李宏毅机器学习入门笔记——第四节

李宏毅机器学习入门笔记——第四节

自注意力机制&#xff08;常见的神经网络结构&#xff09; 上节课我们已经讲述过 CNN 卷积神经网络 和 spatial transformer 网络。这次讲述一个其他的常用神经网络自注意力机制神经网络。 对于输入的变量长度不一的时候&#xff0c;采用frame的形式&#xff0c;进行裁剪设计。…
阅读更多...
Astra Pro点云代码

Astra Pro点云代码

github上找到的python读取点云的代码 import timeimport cv2 as cv import numpy as np import open3d from openni import _openni2 from openni import openni2SAVE_POINTCLOUDS True # 是否保存点云数据def get_rgbd(color_capture, depth_stream, depth_scale1000, dept…
阅读更多...
猫头虎分享已解决Bug || 依赖问题：DependencyNotFoundException: Module ‘xyz‘ was not found

猫头虎分享已解决Bug || 依赖问题：DependencyNotFoundException: Module ‘xyz‘ was not found

博主猫头虎的技术世界 &#x1f31f; 欢迎来到猫头虎的博客 — 探索技术的无限可能&#xff01; 专栏链接&#xff1a; &#x1f517; 精选专栏&#xff1a; 《面试题大全》 — 面试准备的宝典&#xff01;《IDEA开发秘籍》 — 提升你的IDEA技能&#xff01;《100天精通鸿蒙》 …
阅读更多...
VirtualBox虚拟机安装 Linux 系统

VirtualBox虚拟机安装 Linux 系统

要想学习各种计算机技术&#xff0c;自然离不开Linux系统。并且目前大多数生产系统都是安装在Linux系统上。常用的Linux系统有 Redhat&#xff0c;Centos&#xff0c;OracleLinux 三种。 三者的区别简单说明如下&#xff1a; Red Hat Enterprise Linux (RHEL): RHEL 是由美国…
阅读更多...
QEMU之内存虚拟化

QEMU之内存虚拟化

内存虚拟化方案 最直观的方案&#xff0c;将QEMU进程的虚拟地址空间的一部分作为虚拟机的物理地址。但该方案有一个问题&#xff1a; 在物理机上&#xff0c;CPU对内存的访问在保护模式下是通过分段分页实现的&#xff0c;在该模式下&#xff0c;CPU访问时使用的是虚拟地址&am…
阅读更多...
算法--时空复杂度分析以及各个数据量对应的可使用的算法（C++；1s内）

算法--时空复杂度分析以及各个数据量对应的可使用的算法（C++；1s内）

这里写目录标题 由数据范围反推算法时间复杂度以及算法内容一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 一级目录二级目录二级目录二级目录 由数据范围反推算法时间复杂度以及算法内容 一级目录 二级目录 二级目录…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023