最近闲来无事，折腾一下很久之前已经火完了的Stable Diffusion。这篇博客主要说明如何快速在有英伟达显卡的电脑上部署一份Stable Diffusion以及如何引入自己希望的模型。


本人部署用环境：
- CPU：AMD 5600X
- GPU：RTX3060
- RAM：32GB
# 1.确定相关网址
- SD-WebUI Github : SD经典UI仓库 https://github.com/AUTOMATIC1111/stable-diffusion-webui 
- HuggingFace: 用于下载各类所需模型,模型类型非常多 https://huggingface.co/
- civitai: 用于下载各类所需模型，更加直观一点，https://civitai.com/models/119012/bluepencil-xl


# 2. Clone仓库
打开你的Terminal，Clone SD WebUi仓库，在此之前请保证你的电脑有Git环境、cuda环境和python环境，关于如何安装Git请自行百度/知乎
```
git clone git@github.com:AUTOMATIC1111/stable-diffusion-webui.git
```

# 3.下载models
在HuggingFace或c站都可以任意选择一个model进行下载，我这里使用的是https://civitai.com/models/119012/bluepencil-xl 这个模型
![QQ截图20240108162956.png](https://s2.loli.net/2024/01/09/pM7yLniWgXel5b9.png)
下载完成后，将下载好的model文件放在.\stable-diffusion-webui\models目录下即可

# 4 启动SD
点击运行.\stable-diffusion-webui下的webui-user.bat文件，会弹出一个终端执行框，等待其自动配置完成即可

如果出现错误，请检查你的cuda环境和Python环境是否正常
![QQ截图20240109010854.png](https://s2.loli.net/2024/01/09/NhAgnoE6SlO8f4K.png)
# 5 成品
![QQ截图20240109010758.png](https://s2.loli.net/2024/01/09/NqYBh4aR5ofjLMX.png)

参考prompt：

anime, cute girl, wizard hat, kimono, thigh-highs, happy, dynamic pose, "HAPPY NEW YEAR!", 2024, pop font, landscape, sunrise, winter, red tone color, bloom effect, ambient occlusion, Bokeh, depth of field

speed：1360477511

快速部署一份自己的Stable Diffusion

# 问题描述

在Golang服务端使用Casbin作为权限管理的场景下，会增加多个Casbin实例来保证请求高并发和稳定性，但是与此同时会出现多个实例接口返回的数据不一致的问题，这种问题会严重影响业务使用。




# 问题原因

在Casbin的设计中，为了保证高并发下的可观性能，Casbin内置一个内存缓存，每当执行读数据的动作时，会先获取内存缓存中的数据，而不是数据库的数据。

因此在多实例场景下，当一个实例的Casbin数据发生变更时，其它实例的Casbin缓存并没有及时同步刷新，这就导致了当请求被分发到对应的实例上时，获取到的依然还是旧的错误数据。

# 问题解决

Casbin官方提供了一种可行的解决方法——Watcher机制，可以阅读对应文档[CasbinWathcer](https://casbin.org/zh/docs/watchers/)

文档中说明了casbin支持使用Redis、Kafka、zookeeper等中间件实现多实例之间的数据同步

我采用了成本较低的Redis作为Watcher，下面是我的代码参考：

- Watcher回调函数：
```golang
// 这是一个包装方法，方便传入Enforcer实例来实现回调中对casbin的操作
func ConsumeCallback(e *casbin.Enforcer) func(msg string) {
	return func(msg string) {
		zap.L().Info("enforcer update msg:" + msg)
                // 在接收到任意的权限变更后，刷新Enforce实例，达到刷新缓存的目的
		e.LoadPolicy()
	}
}
```
需要注意的是我们这里给到的回调函数必须是func(msg string)的形式，因为Casbin Watcher规定了回调到的方法只会给到一个Msg信息，剩下的需要我们自己处理。

具体的MSG信息官方文档并没有给出，不过我在实际测试过程中有总结到一个大的结构体对象可以供有需要的进行参考
```golang
// 回调中给到的msg的结构大概就是下面struct中定义的样子
type MSG struct {
	Method      string
	ID          string
	Sec         string
	Ptype       string
	Params      interface{}
	NewRules    interface{}
	OldRules    interface{}
	NewRule     interface{}
	OldRule     interface{}
	FieldValues interface{}
}

func (m *MSG) MarshalBinary() ([]byte, error) {
	return json.Marshal(m)
}

// UnmarshalBinary decodes the struct into a User
func (m *MSG) UnmarshalBinary(data []byte) error {
	if err := json.Unmarshal(data, m); err != nil {
		return err
	}
	return nil
}
```

- Casbin注册回调函数

```golang
func (c *CasbinOptions) Init(db *gorm.DB) (*casbin.Enforcer, error) {
	w, _ := rediswatcher.NewWatcher(viper.GetString("redis.addr"), rediswatcher.WatcherOptions{
		Options: redis.Options{
			Network:  "tcp",
			Password: "redis.password",
			DB:       "redis.iotDB",
			PoolSize: "redis.poolSize",
		},
		Channel: "/casbin",
		// 忽略容器自身发起的订阅消息推送，防止出现死循环
		IgnoreSelf: true,
	})

	adapter, err := gormadapter.NewAdapterByDB(db)
	if err != nil {
		zap.L().Error("casbin adapter init error:" + err.Error())
		return nil, err
	}
	e, err := casbin.NewEnforcer(c.Path, adapter)
	if err != nil {
		zap.L().Error("casbin enforcer init error:" + err.Error())
		return nil, err
	}
        // 设置RedisWatcher
	_ = e.SetWatcher(w)
        // 设置回调函数
	_ = w.SetUpdateCallback(ConsumeCallback(e))
	err = e.LoadPolicy()
	if err != nil {
		zap.L().Error("casbin policy init error:" + err.Error())
		return nil, err
	}
	_ = e.SavePolicy()
	return e, nil

}
```

完成后重新运行验证效果即可

Casbin多容器实例场景下数据不一致的问题解决

# 一、引言

## 代码整洁的重要性

代码整洁是软件开发中至关重要的一个方面。当我们编写整洁的代码时，可以提高代码的可读性、可维护性和可扩展性。整洁的代码易于理解，减少了他人阅读和维护代码时的困惑和错误。同时，整洁的代码也有助于减少bug的产生，提高软件的质量。




## 代码整洁的好处

1. 可读性：整洁的代码易于阅读和理解，减少了他人阅读代码时的困惑和错误。清晰的代码结构和命名规范使得代码逻辑更加明确，提高了团队协作效率。（简单来说就是要让一起协同工作的人能读懂你的代码，而不是一坨答辩）

2. 可维护性：整洁的代码易于维护。清晰的代码结构和模块化设计使得修改和扩展代码更加容易。通过遵循一致的编码风格和注释规范，他人能够更快速地理解代码的意图和实现细节。（

3. 可测试性：整洁的代码易于进行单元测试和集成测试。清晰的函数和类设计使得测试代码更加简洁和可靠。通过良好的错误处理和异常处理机制，能够更好地捕获和处理错误，提高代码的健壮性。

4. 可扩展性：整洁的代码易于扩展和重构。良好的代码结构和设计原则使得添加新功能或修改旧功能时能够保持代码的灵活性和可扩展性。通过避免代码的重复和冗余，减少了后续维护的工作量。


# 二、代码命名

在编写代码时，良好的命名是十分重要的，它能够提高代码的可读性和可理解性。以下是关于命名的几个要点：

1. 使用有意义的变量名：变量名应该能够准确地描述变量的用途和含义。例如，如果我们需要表示一个人的年龄，可以使用age作为变量名，而不是使用无意义的字母或数字。

2. 避免使用含糊不清的缩写：尽量避免使用难以理解的缩写，因为缩写可能会使代码的可读性降低。例如，如果我们需要表示一个订单的创建时间，可以使用creationTime作为变量名，而不是使用缩写形式如ct。

3. 统一的命名风格：在整个代码库中保持统一的命名风格是很重要的。例如，可以选择使用驼峰命名法或下划线命名法，并在项目中保持一致。例如，如果我们使用驼峰命名法，可以将一个变量命名为firstName，而不是first_name或FIRSTNAME。（一般对于Java、Golang而言我们更喜欢使用驼峰命名，而对于c/c++、python或脚本语言更喜欢使用下划线命名）

4. 避免误导性的命名：命名应该准确地反映变量或函数的用途，避免使用与其实际功能不符的名称。例如，如果我们有一个函数用于计算圆的面积，可以将其命名为calculateCircleArea，而不是calculateRectangleArea。

5. 避免使用中文拼音：很多初学者，特别是一些没有接触编程或从某些培训班体系出来的程序员会非常喜欢使用中文拼音来命名变量，这是非常不好的习惯，比如下面的代码：
    ```java
    String diYiXueQi  = "第一学期"
    ```
    如上面的变量，很容易引起误解，读者在阅读代码时，很难第一反应了解到这个diYiXueQi到底代表什么，而使用英文可以很顺畅地表达我们的想法。

# 三、函数

在编写代码时，函数是组织和封装逻辑的基本单元。函数设计的好不好直接决定了项目的鲁棒性和耦合度。
下面我通过python来举例什么是好的函数：

1. 函数的简洁性和清晰性：函数应该保持简洁和清晰，只关注单一的任务或功能。避免函数过于复杂和冗长，可以通过拆分函数、提取子函数等方式来简化函数的逻辑。

```python
# 不好的示例：复杂且冗长的函数
def process_data(data):
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
    # 复杂的数据处理逻辑...
    # ...
    # ...
    # ...
```

```python
# 好的示例：简洁清晰的函数
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)
```

2. 函数的单一责任原则：每个函数应该只负责一个明确的任务或功能，并且只做这一个任务。这样可以提高函数的可重用性和可测试性，同时也使得代码更易于理解和维护。

```python
# 不好的示例：一个函数负责多个任务
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)
```

```python
# 好的示例：每个函数只负责一个任务
def preprocess_data(data):
    # 数据预处理逻辑...

def transform_data(data):
    # 数据转换逻辑...

def analyze_data(data):
    # 数据分析逻辑...

def save_data(data):
    # 数据保存逻辑...
```

3. 函数的命名和参数选择：函数的命名应该能够准确地描述函数的功能和作用。选择有意义的函数名和参数名，可以让代码更易于理解和使用。

```python
# 不好的示例：函数名和参数名不具备描述性
def calc(a, b):
    # 计算逻辑...

# 不好的示例：使用缩写和无意义的参数名
def process_data(d):
    # 数据处理逻辑...
```

```python
# 好的示例：具有描述性的函数名和参数名
def calculate_sum(num1, num2):
    # 计算两个数的和...

def process_data(data):
    # 数据处理逻辑...
```

4. 避免过长的函数：函数应该尽量避免过长，超过一屏幕的长度。长函数难以理解和维护，可以通过拆分函数或提取子函数来减少函数的长度。

```python
# 不好的示例：过长的函数
def process_data(data):
    # 长长的处理逻辑...
    # ...
    # ...
    # ...
    # 长长的处理逻辑...
    # ...
    # ...
    # ...
    # 长长的处理逻辑...
    # ...
    # ...
    # ...
```

```python
# 好的示例：拆分和提取子函数
def process_data(data):
    preprocess_data(data)
    transform_data(data)
    analyze_data(data)
    save_data(data)

def preprocess_data(data):
    # 数据预处理逻辑...

def transform_data(data):
    # 数据转换逻辑...

def analyze_data(data):
    # 数据分析逻辑...

def save_data(data):
    # 数据保存逻辑...
```

5. 函数的注释和文档：为函数提供清晰的注释和文档，可以帮助其他开发人员理解函数的用途、输入和输出。注释应该简洁明了，解释函数的功能和关键步骤，而文档可以提供更详细的说明和示例。

```python
def calculate_sum(num1, num2):
    """
    计算两个数的和

    Args:
        num1 (int): 第一个数
        num2 (int): 第二个数

    Returns:
        int: 两个数的和
    """
    return num1 + num2
```

# 四、注释

注释是用来解释代码意图、提供额外信息并帮助理解代码的文字说明，注释的存在不仅仅是帮助别人理解你的代码，也是帮助未来的自己在维护时能够想起代码是干什么的（对于某些自己写的远古项目，如果你没有注释，那么那份代码可能只有上帝知道是干什么的）：

1. 注释的作用和使用场景：注释的主要作用是解释代码的意图、提供上下文信息以及帮助其他开发人员理解代码。注释的使用场景包括：

   - 解释代码的目的和功能。
   - 提供算法或逻辑的解释。
   - 强调特殊的注意事项或约束条件。
   - 提供对代码的修改或优化的说明。
   - 文档函数、类或模块的用途和使用方法。

   注释应该在需要解释的地方使用，并且应该与代码保持同步，以确保注释的准确性和有效性。

2. 注释应该解释代码的意图而非实现细节：注释应该关注代码的意图和目的，而不是详细描述代码的实现细节。代码本身应该尽可能自解释，而注释则应该解释代码为什么要这样做，以及代码的目的和预期结果。

   ```python
   # 不好的示例：注释过多的实现细节
   def calculate_sum(num1, num2):
       # 将num1和num2相加
       result = num1 + num2
       return result
   ```

   ```python
   # 好的示例：注释解释代码的意图
   def calculate_sum(num1, num2):
       # 计算两个数的和
       result = num1 + num2
       return result
   ```

3. 避免无用或误导性的注释：注释应该是有用的，不应该存在无意义或误导性的注释。避免在代码中添加显而易见的注释，注释应该提供额外的信息，帮助理解代码。

   ```python
   # 不好的示例：无用的注释
   result = num1 + num2  # 计算结果
   ```

   ```python
   # 好的示例：提供额外信息的注释
   # 将num1和num2相加得到结果
   result = num1 + num2
   ```

4. 注释的更新和维护：注释是与代码同步的重要部分，应该随着代码的修改和演进进行更新和维护。当代码发生变化时，相应的注释也需要相应地更新，以保持注释与代码的一致性。

   注释应该被视为代码的一部分，同样受到代码审查和维护的过程。确保注释的准确性和完整性，以便其他开发人员能够依赖和理解注释提供的信息。
# 五、格式化

代码的格式化对于代码的可读性和可维护性非常重要，如果你的代码没有合理的格式化，那么非常容易让你的代码看起来像一大坨💩。
通过合理地使用缩进、空格、折行和空行，我们可以使代码更易读、易于理解和维护。保持一致的格式化风格，并遵守通用的格式化准则，有助于提高代码的可读性和一致性：

1. 代码的缩进和对齐：使用一致的缩进风格来展示代码的结构和层次关系。常见的缩进方式是使用四个空格或者一个制表符（Tab）。对于每个代码块，都应该有相同的缩进级别，以便于阅读和理解代码的逻辑。

   ```python
   # 不好的示例：缩进不一致
   if condition:
   print("Condition is true!")
      print("Indented inside if block")

   # 好的示例：一致的缩进
   if condition:
       print("Condition is true!")
       print("Indented inside if block")
   ```

2. 空格的使用：在代码中适当地使用空格可以提高代码的可读性。以下是一些常见的空格使用场景：

   - 在运算符两侧和逗号后面添加空格，以增加可读性。

   ```python
   # 不好的示例：缺少空格
   result=a+b

   # 好的示例：添加空格
   result = a + b
   ```

   - 在函数的参数列表和元素列表中，逗号后面添加一个空格。

   ```python
   # 不好的示例：缺少空格
   my_function(arg1,arg2,arg3)

   # 好的示例：添加空格
   my_function(arg1, arg2, arg3)
   ```

   - 在注释中，运算符和关键字后面添加一个空格。

   ```python
   # 不好的示例：缺少空格
   #计算两个数的和
   result = num1+num2

   # 好的示例：添加空格
   # 计算两个数的和
   result = num1 + num2
   ```

3. 行的长度和折行规则：为了保持代码的可读性，应该遵守适当的行长度限制。通常，建议将每行代码限制在80个字符以内。如果一行代码超过了限制，可以使用括号、反斜杠或换行符进行折行。

   ```python
   # 不好的示例：过长的行
   long_line = "This is a very long line of code that exceeds the recommended line length and makes it hard to read and understand."

   # 好的示例：使用括号进行折行
   long_line = ("This is a very long line of code that exceeds the recommended line length "
                "and makes it hard to read and understand.")

   # 好的示例：使用反斜杠进行折行
   long_line = "This is a very long line of code that exceeds the recommended line length " \
               "and makes it hard to read and understand."

   # 好的示例：使用换行符进行折行
   long_line = "This is a very long line of code that exceeds the recommended line length\n" \
               "and makes it hard to read and understand."
   ```

4. 空行的使用：适当地使用空行可以增加代码的可读性，将代码分成逻辑块和功能块。以下是一些常见的空行使用场景：

-    在函数和类之间使用空行，以及在函数内部的逻辑块之间使用空行，以增加代码的可读性。

   ```python
   def function1():
       # 代码逻辑...

   def function2():
       # 代码逻辑...

   class MyClass:
       # 类定义...

   function1()

   function2()
   ```

   - 在函数和类的定义之前使用空行，以增加代码的可读性。

   ```python
   import module1

   import module2


   def my_function():
       # 代码逻辑...


   class MyClass:
       # 类定义...
   ```

   - 在代码的不同部分之间使用空行，以增加代码的可读性和分组。

   ```python
   import module1

   import module2


   def function1():
       # 代码逻辑...


   def function2():
       # 代码逻辑...
   ```

如何写好一份规范的代码？

ChatGPT好使是有目共睹的，~~特别对于我这种懒狗~~，但是相对的ChatGPT受限于某些神秘力量，导致在使用它的时候比较麻烦，而OpenAI官方为了解决这些问题给出了可以快速集成到个人应用中的APPKEY，因此出现了一些可以一站式解决的傻瓜式ChatGPT部署方案。



我这里采用[ChatBot-WebUI](https://github.com/mckaywrigley/chatbot-ui)这个开源库来快速部署
## 前期准备
你需要一个APP_KEY,可以从[这里获取](https://platform.openai.com/account/api-keys)，当前前提是你拥有一个可以正常使用的ChatGPT账号。
如果你不懂得什么叫~~接码平台~~，也不懂得什么叫~~互联网虚拟混砖逾越技术~~，可以找你认识的，有chatGPT账号的朋友Py一个Key
## 开始
1. Fork chatbot-ui仓库到自己仓库
3. 访问https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fmckaywrigley%2Fchatbot-ui  使用Vercel快速部署chatbot-ui（其实官方都给弄好了，剩下的自己搞就完了）按它的一路点点点就行
4. 完成以后是这样的：

![image.png](https://umb.ink/static/img/74890d1bce066a510858b8d100a13c63.image.png)
6. 这时可以尝试访问它给到你的DOMAINS里的链接，同样的如果你有自己的域名，可以添加DNS记录来快速访问它（不要忘记去CF上给自己的域名加记录）：

![image.png](https://umb.ink/static/img/425f285f9ac5bb8ebd3672817ba2f64d.image.png)
7. 部署完成以后访问，你会看到如下页面：

![image.png](https://umb.ink/static/img/928f69dc7721358cc71fd277c4aa0053.image.png)
8. 将你的APPKEY粘贴到左下角的OpenAI API 密钥中：

![image.png](https://umb.ink/static/img/088825c261db0c56ac1754cd470e5473.image.png)

9. 开始你的ChatGPT对话就可以了
10. PS如果希望持久化APPKEY，让别人一打开就可以用的话，你需要向仓库里添加一份.env.local配置文件，参考官方的README

![image.png](https://umb.ink/static/img/d29b3aa6b51e57f2cf8fea7d4295d099.image.png)
添加之后重新让Vercel构建一下，再部署，就可以啦

快速搭建部署自己的ChatGPT

最近维护几个老旧的服务（shi山），并且源代码已经莫得了，只有生产环境的几个jar包，但是要对里面的一些配置进行一些更改，因此尝试做了一下简单的jar解包 


# 环境
MacOS && Linux均可
# 解包
使用指令
```bash
tar -zxvf <jar-name>.jar -C <Dir>
```
参数说明：
jar-name: 需要解包的目标jar
Dir：解包到对应的文件夹下，如果想要解包到当前目录下，则不需要加-C，像这样
```bash
tar -zxvf <jar-name>.jar
```
# 逆向.class文件
解包后的目录大概是这样的：

![截屏2022-11-04 20.05.36.png](https://umb.ink/static/img/680d4066f6d6bdaf22d3aa87f9df8911.%E6%88%AA%E5%B1%8F2022-11-04%2020.05.36.png)
.class文件都在BOOT-INF下

![截屏2022-11-04 20.06.44.png](https://umb.ink/static/img/3a6b5f9c59212e28703e0958800cc83b.%E6%88%AA%E5%B1%8F2022-11-04%2020.06.44.png)
lib文件夹是程序依赖的lib库
classes文件夹就是包括了所有的.class文件
.class文件是Java的二进制支持文件，所以我们需要进行逆向还原出Java源文件
办法很简单，直接使用IDEA打开该目录，IDEA内置.class文件自动逆向还原，只可惜权限是read only
像这样：
![image.png](https://umb.ink/static/img/94784c17a724fcfe723abaee20842ea4.image.png)


![image.png](https://umb.ink/static/img/6d3ee6785f4a25247c214ec53f6a7f99.image.png)
这样的话就可以查看到逆向后的.class文件源码了（甚至是kt代码）
# 替换
如果需要修改的文件或者配置，直接cv逆向后的文件代码（虽然它是read only，但是可以复制），复制到任意一个Java文件中，然后用java -c 进行编译打包为.class文件，然后把原来BOOT-INF下的对应.class文件直接进行替换即可
# 重新打包
替换完成后需要重新把这些文件打包回jar包，使用下面的指令（在解包目录下）：
```shell
 jar -cvf0m <jar-name>.jar   ./META-INF/MANIFEST.MF  .  
```
指定打包后的jar-name，然后运行指令，就会在当前目录下生成重新打包后的jar文件
到此我们的jar逆向解包、更新文件、重新打包就完成了