分类后端技术下的文章

2024-09-06

在本系列的第四部分，我们将介绍如何使用Spring Boot和CAS构建一个简单的单点登录系统。我们将重点介绍如何配置CAS服务器和客户端，以及如何处理用户登录和注销。

配置CAS服务器

在cas-overlay目录中，编辑deployerConfigContext.xml文件，确保数据库连接和用户查询是正确的。
配置认证管理器（AuthenticationManager），以支持数据库认证。
如果需要，配置其他CAS设置，如主题、登录页面等。

配置Spring Boot客户端

在Spring Boot应用中添加CAS客户端依赖。
在application.properties或application.yml中配置CAS服务器URL、登录成功、登录失败等。
创建一个CAS认证过滤器，并将其注册到Spring Security过滤器链中。
配置Spring Security以使用CAS登录。

代码示例




// 在Spring Boot应用的Security配置中添加CAS支持
@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        .authorizeRequests()
            .anyRequest().authenticated()
            .and()
        .casAuthenticationEntryPoint()
            .loginUrl("http://cas.example.org/cas/login")
            .serviceProperties(s -> s.service("http://app.example.org/login/cas"))
            .and()
        .addFilterAt(casAuthenticationFilter(), CasAuthenticationFilter.class);
}
 
// 创建CASAuthenticationFilter Bean
@Bean
public CasAuthenticationFilter casAuthenticationFilter() throws Exception {
    CasAuthenticationFilter filter = new CasAuthenticationFilter();
    filter.setAuthenticationManager(authenticationManager());
    // 其他配置...
    return filter;
}
 
// 配置Logout
@Override
protected void configure(HttpSecurity http) throws Exception {
    http
        // ...
        .logout()
            .logoutUrl("http://cas.example.org/cas/logout")
            .logoutSuccessUrl("http://app.example.org/logout-success")
            .and()
        // ...
}

以上代码仅为示例，实际配置时需要根据CAS服务器的实际部署和Spring Boot应用的具体情况进行调整。

注意：本示例假设CAS服务器和客户端在同一域下，如果不在同一域，还需要处理跨域请求。

通过本系列的教程，开发者可以快速了解如何在Spring Boot应用中集成CAS，并实现单点登录功能。这为开发者在实际项目中应用单点登录提供了基本框架和指导。

Springboot 集成 mongodb

2024-09-06

所有,数据库

要在Spring Boot中集成MongoDB，你需要做以下几步：

添加Maven依赖到你的pom.xml文件中。
配置application.properties或application.yml文件以连接到MongoDB。
创建一个实体类。
创建一个MongoDB仓库接口。
使用Spring Data MongoDB提供的注解和方法。

以下是具体步骤的示例代码：

1. 添加Maven依赖

在pom.xml中添加以下依赖：




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

2. 配置MongoDB

在application.properties中添加以下配置：




spring.data.mongodb.uri=mongodb://username:password@localhost:27017/your_database

或者，如果你使用application.yml：




spring:
  data:
    mongodb:
      uri: mongodb://username:password@localhost:27017/your_database

3. 创建一个实体类




import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
 
@Document
public class YourEntity {
    @Id
    private String id;
    // 其他字段和方法
}

4. 创建MongoDB仓库接口




import org.springframework.data.mongodb.repository.MongoRepository;
 
public interface YourEntityRepository extends MongoRepository<YourEntity, String> {
    // 自定义查询方法
}

5. 使用仓库

在你的服务类中注入YourEntityRepository：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class YourService {
 
    @Autowired
    private YourEntityRepository repository;
 
    public YourEntity findById(String id) {
        return repository.findById(id).orElse(null);
    }
 
    // 其他业务逻辑
}

以上就是Spring Boot集成MongoDB的基本步骤和示例代码。记得替换实体类名、字段和方法，以及数据库URI的用户名、密码和数据库名。

Redis 的 Bitmap详解和命令演示

2024-09-06

所有,redis

Bitmap是Redis中的一种数据类型，它是一个以位为单位的数组，数组中的每个元素只能是0或1。Bitmaps是特殊的字符串，Redis为它提供了一些专用的命令，使其可以用来进行位级的操作。

Redis的Bitmap通常被用来：

用于存储布尔值，对于用户是否登录，是否点赞等状态可以使用Bitmap。
用于统计用户访问信息，例如统计用户的访问次数、用户的访问时间等。
用于实现布隆过滤器，可以用来检查一个元素是否可能在一个集合中，也可以用来判断一个元素是否一定不在一个集合中。

以下是一些常用的Bitmap命令：

SETBIT：设置或者清空key所储存的字符串值的偏移量上的位。




127.0.0.1:6379> SETBIT mykey 10 1
(integer) 0

GETBIT：对key所储存的字符串值，获取指定偏移量上的位的值。




127.0.0.1:6379> GETBIT mykey 10
(integer) 1

BITCOUNT：计算给定整数范围内，位值为1的数量。




127.0.0.1:6379> BITCOUNT mykey 0 -1
(integer) 1

BITOP：对一个或多个保存二进制位的字符串key进行位元操作，并将结果保存到destkey中。




127.0.0.1:6379> SET mykey1 1
OK
127.0.0.1:6379> SET mykey2 2
OK
127.0.0.1:6379> BITOP AND destkey mykey1 mykey2
"\x02"

BITFIELD：用于处理32位有符号整数的字段，可以对这些整数进行读写操作。




127.0.0.1:6379> BITFIELD mykey SET u4 10 SET i4 5
1) (integer) 0
2) (integer) 0

BITPOS：用于找到位数组中值为0或1的第一个位置。




127.0.0.1:6379> SETBIT mykey 10 1
(integer) 0
127.0.0.1:6379> BITPOS mykey 1
(integer) 10

以上命令均为示例，具体使用时需要根据实际情况进行调整。

Oracle-数据库性能变慢问题分析

2024-09-06

所有,数据库




-- 查询最消耗资源的SQL
SELECT * FROM (
    SELECT
        sql_id,
        executions,
        parse_calls,
        disk_reads,
        buffer_gets,
        elapsed_time,
        cpu_time,
        user_io_wait_time
    FROM
        v$sqlarea
    ORDER BY
        buffer_gets DESC
    FETCH FIRST 10 ROWS ONLY
)
WHERE ROWNUM <= 10;
 
-- 查询最近运行时间最长的SQL
SELECT * FROM (
    SELECT
        sql_id,
        executions,
        parse_calls,
        disk_reads,
        buffer_gets,
        elapsed_time,
        cpu_time,
        user_io_wait_time
    FROM
        v$sqlarea
    ORDER BY
        elapsed_time DESC
    FETCH FIRST 10 ROWS ONLY
)
WHERE ROWNUM <= 10;
 
-- 查询最近使用CPU时间最长的SQL
SELECT * FROM (
    SELECT
        sql_id,
        executions,
        parse_calls,
        disk_reads,
        buffer_gets,
        elapsed_time,
        cpu_time,
        user_io_wait_time
    FROM
        v$sqlarea
    ORDER BY
        cpu_time DESC
    FETCH FIRST 10 ROWS ONLY
)
WHERE ROWNUM <= 10;
 
-- 查询最近等待IO的SQL
SELECT * FROM (
    SELECT
        sql_id,
        executions,
        parse_calls,
        disk_reads,
        buffer_gets,
        elapsed_time,
        cpu_time,
        user_io_wait_time
    FROM
        v$sqlarea
    ORDER BY
        user_io_wait_time DESC
    FETCH FIRST 10 ROWS ONLY
)
WHERE ROWNUM <= 10;

这段代码提供了四个查询示例，分别用于查找最消耗资源的SQL、最耗时的SQL、最消耗CPU的SQL和最需要等待IO的SQL。这些查询可以帮助数据库管理员和开发人员识别和优化数据库性能问题。

Golang crypto.chacha20 包详解

2024-09-06

所有,golang

crypto/chacha20 包在 Go 语言的标准库中不存在。这是因为 Go 语言的加密库 crypto 已经提供了对 ChaCha20 流密码的支持，通过 crypto/cipher 包中的 NewCipher 函数和 NewCipher 函数创建 ChaCha20 密码本实例。

以下是一个使用 crypto/cipher 包中的 NewCipher 函数和 NewCipher 函数创建 ChaCha20 密码本并进行加密解密的示例：




package main
 
import (
    "crypto/cipher"
    "crypto/rand"
    "io"
    "log"
 
    "golang.org/x/crypto/chacha20"
)
 
func main() {
    key := make([]byte, chacha20.KeySize)
    if _, err := io.ReadFull(rand.Reader, key); err != nil {
        log.Fatal(err)
    }
 
    cipher, err := chacha20.NewCipher(key, nil)
    if err != nil {
        log.Fatal(err)
    }
 
    // 使用密码本进行加密解密操作
    // ...
}

在上述代码中，我们首先使用 crypto/rand 包生成一个符合 chacha20.KeySize 大小的密钥。然后，我们使用 chacha20.NewCipher 函数创建一个 cipher.Stream 类型的密码本。最后，我们使用这个密码本进行加密解密操作。

注意：在实际的应用场景中，密钥应该是随机的，并且在使用后应当进行适当的处理，以防止泄露。此外，在创建密码本时，我们使用 nil 作为 nonce（在 ChaCha20 中 nonce 是必需的），在实际使用中，我们需要确保每个消息的 nonce 是唯一的，否则会导致安全问题。

springcloud gateway实时监听nacos微服务上下线

2024-09-06

Spring Cloud Gateway 实现实时监听 Nacos 微服务上下线，可以通过 Nacos 的 OpenAPI 和 Spring Cloud Gateway 的自定义路由过滤器来实现。

以下是实现的步骤和示例代码：

创建一个自定义的路由过滤器，用于监听 Nacos 服务的变更。
使用 Nacos 的 Open API 获取服务列表。
对比本地缓存的服务列表，如果有变更，更新 Spring Cloud Gateway 的路由。

示例代码：




@Component
public class NacosWatcherFilter implements WebFilter, Ordered {
 
    private final RouteLocator routeLocator;
    private final GatewayProperties gatewayProperties;
    private final NacosDiscoveryProperties nacosProperties;
    private final NamingService namingService;
 
    private final Map<String, List<ServiceInstance>> instanceMap = new ConcurrentHashMap<>();
 
    public NacosWatcherFilter(RouteLocator routeLocator, GatewayProperties gatewayProperties,
                              NacosDiscoveryProperties nacosProperties, NamingService namingService) {
        this.routeLocator = routeLocator;
        this.gatewayProperties = gatewayProperties;
        this.nacosProperties = nacosProperties;
        this.namingService = namingService;
 
        // 初始化时注册监听器
        init();
    }
 
    private void init() {
        nacosProperties.getMetadata().forEach((serviceId, metadata) -> {
            try {
                // 监听每个服务
                namingService.subscribe(serviceId, instances -> {
                    updateLocalRouteCache(serviceId, instances);
                });
                // 获取初始实例列表
                List<Instance> instances = namingService.getAllInstances(serviceId);
                updateLocalRouteCache(serviceId, instances);
            } catch (Exception e) {
                // 处理异常
                e.printStackTrace();
            }
        });
    }
 
    private void updateLocalRouteCache(String serviceId, List<Instance> instances) {
        List<ServiceInstance> serviceInstances = instances.stream()
                .map(instance -> new NacosServiceInstance(instance, serviceId, nacosProperties.getGroup()))
                .collect(Collectors.toList());
        instanceMap.put(serviceId, serviceInstances);
 
        // 更新 Spring Cloud Gateway 路由
        routeLocator.getR

2024-09-06

在RuoYi前后端分离版本中集成MyBatis Plus，可以按照以下步骤进行：

引入MyBatis Plus依赖
在pom.xml中添加MyBatis Plus的依赖：




<!-- MyBatis Plus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.x.x</version>
</dependency>

配置MyBatis Plus
在application.yml或application.properties中配置MyBatis Plus：




# MyBatis Plus 配置
mybatis-plus:
  mapper-locations: classpath:/mapper/**/*.xml  # mapper映射文件
  type-aliases-package: com.yourpackage.**.entity  # 实体类别名包
  global-config:
    db-config:
      id-type: auto  # 主键策略

创建Mapper接口和Mapper XML文件
在对应的模块下创建Mapper接口和XML文件，例如：




// UserMapper.java
@Mapper
public interface UserMapper extends BaseMapper<User> {
    // 其他自定义方法
}




<!-- UserMapper.xml -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yourpackage.module.mapper.UserMapper">
  <!-- 自定义SQL映射 -->
</mapper>

使用MyBatis Plus提供的方法
在Service层使用MyBatis Plus提供的BaseMapper方法，例如：




@Service
public class UserService {
 
    @Autowired
    private UserMapper userMapper;
 
    public List<User> getUsers() {
        return userMapper.selectList(null); // 获取所有用户
    }
}

自定义MyBatis Plus的增强器
若要自定义MyBatis Plus的增强器，可以实现MybatisPlusInterceptor接口：




@Component
public class MybatisPlusInterceptor implements MybatisPlusInterceptor {
 
    @Override
    public void addInnerInterceptor(InnerInterceptor innerInterceptor) {
        // 添加自定义的拦截器逻辑
    }
 
    @Override
    public void addInnerInterceptor(List<InnerInterceptor> innerInterceptors) {
        // 添加自定义的拦截器逻辑
    }
}

以上步骤提供了一个简化的集成MyBatis Plus的方法，并展示了如何在RuoYi框架中使用MyBatis Plus。在实际应用中，还需要考虑安全性、性能优化等问题。

2024-09-06

报错信息 "Failure to find org.springframework" 表明 Maven 在尝试构建 Spring Boot 项目时无法找到相应的依赖。

解决方法：

检查 pom.xml 文件中的 <dependencies> 部分，确保 org.springframework.boot 的依赖以及相关子依赖都已经正确声明。
确保你的 Maven 仓库配置是正确的，并且可以访问外部 Maven 仓库。
如果你是在中国大陆地区，可能因为网络问题无法访问 Maven 中央仓库，可以尝试配置阿里云的 Maven 镜像。
运行 mvn clean install 命令来清理并重新安装依赖。
如果问题依然存在，可以尝试手动下载相应的 JAR 文件，并将其放置到本地 Maven 仓库中。
确保你的 IntelliJ IDEA 中的 Maven 配置是正确的，可以正确地下载依赖。
如果你刚刚添加了依赖，可能 IDE 没有自动刷新，可以尝试重启 IntelliJ IDEA 或通过 IDE 的 "Reimport All Maven Projects" 功能来解决。

2024-09-06




import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
 
public class HelloWorldServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body><h1>Hello World</h1></body></html>");
    }
}

这段代码继承自HttpServlet类，并覆盖了doGet方法。当客户端发送一个HTTP GET请求到这个Servlet时，Servlet会响应一个简单的HTML页面，显示"Hello World"。这个例子展示了Servlet的基本工作原理，对于学习Java Web开发的初学者来说，是一个很好的起点。

深入解析 Redisson分布式锁看门狗机制

2024-09-06

所有,redis




import redis.clients.jedis.Jedis;
 
// 使用Redisson的分布式可重入锁
// 注意：需要先添加Redisson的依赖
 
// 初始化Redisson客户端
RedissonClient redisson = Redisson.create();
 
// 获取锁对象实例
RLock lock = redisson.getLock("myLock");
 
try {
    // 尝试加锁，最多等待100秒，锁定后最多持有锁10秒
    boolean isLocked = lock.tryLock(100, 10, TimeUnit.SECONDS);
    if (isLocked) {
        // 业务逻辑处理
        System.out.println("Lock acquired");
        // 处理完毕后，释放锁
    } else {
        // 如果未能获取锁，则进行其他业务逻辑或者重试
        System.out.println("Lock not acquired");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    // 确保释放锁，即使在获取锁时发生异常
    if (lock.isHeldByCurrentThread()) {
        lock.unlock();
        System.out.println("Lock released");
    }
}
 
// 关闭Redisson客户端
redisson.shutdown();

这段代码展示了如何使用Redisson客户端获取一个分布式锁，并处理可能发生的异常。在获取锁之前，它指定了最多等待获取锁的时间和锁的最大持有时间，同时在最后确保释放锁。这是一个分布式环境中管理锁的标准做法。