## 简介

在 `Go` 中，`go mod` 会将依赖项下载并存储在本地的模块缓存中。默认情况下，这些依赖项会存储在 `$GOPATH/pkg/mod` 目录下。如果想要修改本地 `gomod` 下载的依赖存储路径，可以通过设置环境变量 GOMODCACHE 来实现。

在Windows中，我们为了保证系统正常运行，C盘一般不会存储太多东西，但如果你没有自定义设置 `go mod` 下载依赖的路径，则系统会将依赖自动保存在c盘，所以时间久了以后，容易将C盘占满。因此，将以手动修改`go mod` 下载依赖的路径。

想要自定义保存路径，简单来讲就是设置环境变量 `GOMODCACHE` 指向指定的文件夹路径，如果你了解环境变量的设置，可以忽略下列教程直接设置，如果你不会环境变量的设置，可以向下看。



## Windows
在 `Windows` 环境下，你可以通过设置系统环境变量来修改 go mod 下载的依赖存储路径。以下是详细步骤：

打开系统环境变量设置：

1. 右键点击“此电脑”或“我的电脑”，选择“属性”。
2. 在系统属性窗口中，选择“高级系统设置”。
3. 在“系统属性”对话框中，点击“环境变量”按钮。
4. 添加或修改 `GOMODCACHE` 环境变量：

在环境变量窗口中，可以根据情况添加或修改用户变量或系统变量中的 `GOMODCACHE`。

1. 点击“新建”按钮，创建一个新的环境变量。
2. 在“变量名”框中输入 `GOMODCACHE`。
3. 在“变量值”框中输入你希望存储依赖项的路径，例如：`D:\GoModulesCache`。
4. 点击“确定”保存变量。

如果已经存在 `GOMODCACHE` 变量，可以选择它并点击“编辑”，然后修改变量值为你希望的路径。

应用并重启命令行窗口：

确保点击所有对话框中的“确定”按钮，以保存你的更改。然后，关闭并重新打开你的命令行窗口（如 `Command Prompt (cmd)` 或 `PowerShell`），以使新的环境变量生效。

现在，当你在命令行中运行 `go mod` 命令时，依赖项会下载并存储到你指定的新路径中。

## Linux

1. 设置 `GOMODCACHE` 环境变量：

你可以在终端中通过以下命令设置 `GOMODCACHE` 环境变量，将依赖存储路径改为你希望的路径。

```sh
export GOMODCACHE=/your/custom/path
```
这会将依赖项存储到 `/your/custom/path` 目录下。

2. 在项目中使用新的依赖路径：

确保在你需要的终端会话或脚本中设置了 `GOMODCACHE` 环境变量，这样 `go mod` 在下载依赖项时会使用新的存储路径。


### 永久更改 `GOMODCACHE` 路径

如果你希望永久性地更改 `GOMODCACHE` 路径，可以将上述 `export` 命令添加到你的 `shell` 配置文件中，例如 `~/.bashrc`、`~/.zshrc` 等。添加完后，记得重新加载配置文件：

```sh
source ~/.bashrc   # 如果你使用的是 bash
source ~/.zshrc    # 如果你使用的是 zsh
```
完成上述步骤后，`go mod` 下载的依赖项会存储在你指定的新路径下。

修改gomod下载的依赖保存路径

## 简介

本文用于记录Java项目中使用Redis时，常见的一些操作，并封装为一个工具类。

工具类基于spring的redistemplate。



```java
package com.integration.api.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.TimeUnit;


/**
 * redis操作工具类
 */
@SuppressWarnings(value = {"unchecked", "rawtypes"})
@Component
public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 批量删除对应的value
     *
     * @param keys redis keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            remove(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern 正则
     */
    public void removePattern(final String pattern) {
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }

    /**
     * 删除对应的value
     *
     * @param key Redis Key
     */
    public void remove(final String key) {
        if (exists(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 判断缓存中是否有对应的value
     *
     * @param key Redis Key
     */
    public boolean exists(final String key) {
        return redisTemplate.hasKey(key);
    }

    public boolean existsPattern(final String pattern) {
        Set<String> keys = redisTemplate.keys(pattern);
        return !CollectionUtils.isEmpty(keys);
    }

    /**
     * 读取缓存
     *
     * @param key Redis Key
     */
    public Object get(final String key) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate
                .opsForValue();
        result = operations.get(key);
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key   Redis Key
     * @param value Redis Value
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value, 2, TimeUnit.DAYS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 写入缓存
     *
     * @param key   Redis Key
     * @param value Redis Value
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            ValueOperations<Serializable, Object> operations = redisTemplate
                    .opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @return boolean true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout) {
        return expire(key, timeout, TimeUnit.SECONDS);
    }

    /**
     * 设置有效时间
     *
     * @param key     Redis键
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return true=设置成功；false=设置失败
     */
    public boolean expire(final String key, final long timeout, final TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * 缓存List数据
     *
     * @param key      缓存的键值
     * @param dataList 待缓存的List数据
     * @return 缓存的对象
     */
    public <T> long setCacheList(final String key, final List<T> dataList) {
        Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
        return count == null ? 0 : count;
    }

    /**
     * 获得缓存的list对象
     *
     * @param key 缓存的键值
     * @return 缓存键值对应的数据
     */
    public <T> List<T> getCacheList(final String key) {
        return redisTemplate.opsForList().range(key, 0, -1);
    }

    /**
     * 缓存Set
     *
     * @param key     缓存键值
     * @param dataSet 缓存的数据
     * @return 缓存数据的对象
     */
    public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet) {
        BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
        Iterator<T> it = dataSet.iterator();
        while (it.hasNext()) {
            setOperation.add(it.next());
        }
        return setOperation;
    }

    /**
     * 获得缓存的set
     *
     * @param key Redis Key
     */
    public <T> Set<T> getCacheSet(final String key) {
        return redisTemplate.opsForSet().members(key);
    }

    /**
     * 缓存Map
     *
     * @param key     Redis Key
     * @param dataMap Map集合
     */
    public <T> void setCacheMap(final String key, final Map<String, T> dataMap) {
        if (dataMap != null) {
            redisTemplate.opsForHash().putAll(key, dataMap);
        }
    }

    /**
     * 获得缓存的Map
     *
     * @param key Redis Key
     */
    public <T> Map<String, T> getCacheMap(final String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 往Hash中存入数据
     *
     * @param key   Redis键
     * @param hKey  Hash键
     * @param value 值
     */
    public <T> void setCacheMapValue(final String key, final String hKey, final T value) {
        redisTemplate.opsForHash().put(key, hKey, value);
    }

    /**
     * 获取Hash中的数据
     *
     * @param key  Redis键
     * @param hKey Hash键
     * @return Hash中的对象
     */
    public <T> T getCacheMapValue(final String key, final String hKey) {
        HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
        return opsForHash.get(key, hKey);
    }

    /**
     * 获取多个Hash中的数据
     *
     * @param key   Redis键
     * @param hKeys Hash键集合
     * @return Hash对象集合
     */
    public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys) {
        return redisTemplate.opsForHash().multiGet(key, hKeys);
    }

    /**
     * 获得缓存的基本对象列表
     *
     * @param pattern 字符串前缀
     * @return 对象列表
     */
    public Collection<String> keys(final String pattern) {
        return redisTemplate.keys(pattern);
    }

}

```

Java常用的Redis工具类

一分钟教会你如何保存instagram上的图片

原博主：https://www.instagram.com/kimgapju/

![image](https://images.oldmoon.top/images/beauty/beauty1720670365.jpg)



![image](https://images.oldmoon.top/images/beauty/beauty1720670369.jpg)

![image](https://images.oldmoon.top/images/beauty/beauty1720670371.jpg)

20240711欣赏

下面是一段删除图片（文件）的代码，读取某个文件夹下所有的文件名，排序后，按照隔一张删除一个的策略进行批量删除：

```python
import os

# 设置文件夹路径
folder_path = '/path/to/your/folder'

# 获取所有文件名
file_names = os.listdir(folder_path)

# 按文件名排序
file_names.sort()

# 隔一张删除一个
for i in range(1, len(file_names), 2):
    file_path = os.path.join(folder_path, file_names[i])
    if os.path.isfile(file_path):
        os.remove(file_path)
        print(f'Deleted: {file_path}')

```