Java初学第一篇

常用jdk版本
1.8(8)、17、23
下载地址
https://repo.huaweicloud.com/java/jdk/
https://repo.huaweicloud.com/openjdk/
https://d.injdk.cn/download/

基本数据类型是CPU可以直接进行运算的类型。Java定义了以下几种基本数据类型:

整数类型:byte,short,int,long
浮点数类型:float,double
字符类型:char
布尔类型:boolean

Java基本数据类型的字节大小

在 Java 中,每种基本数据类型占用的字节数是固定的,具体如下:
byte:1 字节
short:2 字节
int:4 字节
long:8 字节
float:4 字节
double:8 字节
char:2 字节(用于存储 Unicode 字符)

数据类型占用字节数

byte:1 字节(8 位)。适合表示 -128 到 127 范围内的整数。
short:2 字节(16 位)。适合表示 -32,768 到 32,767 范围内的整数。
int:4 字节(32 位)。适合表示 -2^31 到 2^31-1 范围内的整数。
long:8 字节(64 位)。适合表示 -2^63 到 2^63-1 范围内的整数。
float:4 字节(32 位)。用于表示单精度浮点数。
double:8 字节(64 位)。用于表示双精度浮点数。
char:2 字节(16 位)。用于表示单个字符(Unicode 编码)。

整型

对于整型类型,Java只定义了带符号的整型,因此,最高位的bit表示符号位(0表示正数,1表示负数)。各种整型能表示的最大范围如下:
byte:-128 ~ 127
short: -32768 ~ 32767
int: -2147483648 ~ 2147483647
long: -9223372036854775808 ~ 9223372036854775807
我们来看定义整型的例子:

// 定义整型
public class Main {
    public static void main(String[] args) {
        int i = 2147483647;
        int i2 = -2147483648;
        int i3 = 2_000_000_000; // 加下划线更容易识别 
        // 等价 int i3 = 2000000000;
        int i4 = 0xff0000; // 十六进制表示的16711680
        int i5 = 0b1000000000; // 二进制表示的512

        long n1 = 9000000000000000000L; // long型的结尾需要加L
        long n2 = 900; // 没有加L,此处900为int,但int类型可以赋值给long
        int i6 = 900L; // 错误:不能把long型赋值给int
    }
}

特别注意:同一个数的不同进制的表示是完全相同的,例如15=0xf=0b1111
注意 在 Java 7(JDK1.7)开始,引入了这个语法特性,允许在数字字面量中使用下划线作为“分隔符”,目的是提高大数字的可读性,比如像:

int oneBillion = 1_000_000_000;
long creditCardNumber = 1234_5678_9012_3456L;
int hexBytes = 0xFF_EC_DE_5E;

语法规则虽然你可以加下划线,但要遵守一些规则:

✅ 合法的 ❌ 非法的
1_000_000 _1000000(不能开头)
1000000_ _不能在结尾
1_000_000L 0x_FF_EC(不能在前缀 0x 和数字之间)
3.14_15 3._1415(不能在小数点前后直接用)
1_2_3_4 1__2(不能连续多个下划线)

浮点型

浮点类型的数就是小数,因为小数用科学计数法表示的时候,小数点是可以“浮动”的,如1234.5可以表示成12.345x102,也可以表示成1.2345x103,所以称为浮点数。
下面是定义浮点数的例子:

float f1 = 3.14f;
float f2 = 3.14e38f; // 科学计数法表示的3.14x10^38
float f3 = 1.0; // 错误:不带f结尾的是double类型,不能赋值给float
double d = 1.79e308;
double d2 = -1.79e308;
double d3 = 4.9e-324; // 科学计数法表示的4.9x10^-324

对于float类型,需要加上f后缀。
float 类型可表示的最大值是:3.4028235e+38
double 类型可表示的最大值是:1.7976931348623157e+308

布尔类型

布尔类型boolean只有true和false两个值,布尔类型总是关系运算的计算结果:

boolean b1 = true;
boolean b2 = false;
boolean isGreater = 5 > 3; // 计算结果为true
int age = 12;
boolean isAdult = age >= 18; // 计算结果为false

Java语言对布尔类型的存储并没有做规定,因为理论上存储布尔类型只需要1 bit,但是通常JVM内部会把boolean表示为4字节整数。

字符类型

字符类型char表示一个字符。Java的char类型除了可表示标准的ASCII外,还可以表示一个Unicode字符:

// 字符类型
public class Main {
    public static void main(String[] args) {
        char a = 'A';
        char zh = '中';
        System.out.println(a);
        System.out.println(zh);
    }
}

注意char类型使用单引号',且仅有一个字符,要和双引号"的字符串类型区分开。

引用类型

除了上述基本类型的变量,剩下的都是引用类型。例如,引用类型最常用的就是String字符串:

String s = "hello";

常量

定义变量的时候,如果加上final修饰符,这个变量就变成了常量:

final double PI = 3.14; // PI是一个常量
double r = 5.0;
double area = PI * r * r;
PI = 300; // compile error!

常量在定义时进行初始化后就不可再次赋值,再次赋值会导致编译错误。
常量的作用是用有意义的变量名来避免魔术数字(Magic number),例如,不要在代码中到处写3.14,而是定义一个常量。如果将来需要提高计算精度,我们只需要在常量的定义处修改,例如,改成3.1416,而不必在所有地方替换3.14。
为了和变量区分开来,根据习惯,常量名通常全部大写。

var关键字

有些时候,类型的名字太长,写起来比较麻烦。例如:

StringBuilder sb = new StringBuilder();

这个时候,如果想省略变量类型,可以使用var关键字:

var sb = new StringBuilder();

编译器会根据赋值语句自动推断出变量sb的类型是StringBuilder。对编译器来说,语句:

var sb = new StringBuilder();

实际上会自动变成:

StringBuilder sb = new StringBuilder();

因此,使用var定义变量,仅仅是少写了变量类型而已。

Dify 社区版Docker部署-(私有化部署知识库1)

克隆代码

git clone https://github.com/langgenius/dify.git

启动Dify

进入 Dify 源代码的 Docker 目录

cd dify/docker
复制环境配置文件
cp .env.example .env
启动 Docker 容器

根据你系统上的 Docker Compose 版本,选择合适的命令来启动容器。你可以通过 $ docker compose version 命令检查版本,详细说明请参考 Docker 官方文档:

如果版本是 Docker Compose V2,使用以下命令:

docker compose up -d

如果版本是 Docker Compose V1,使用以下命令:

docker-compose up -d

更新 Dify

进入 dify 源代码的 docker 目录,按顺序执行以下命令:

cd dify/docker
docker compose down
git pull origin main
docker compose pull
docker compose up -d

同步环境变量配置 (重要!)
如果 .env.example 文件有更新,请务必同步修改你本地的 .env 文件。

检查 .env 文件中的所有配置项,确保它们与你的实际运行环境相匹配。你可能需要将 .env.example 中的新变量添加到 .env 文件中,并更新已更改的任何值。

修改默认端口

EXPOSE_NGINX_PORT=80
EXPOSE_NGINX_SSL_PORT=443

Rust初学-安装篇

mac下安装

首先通过homebrew安装rustup管理工具:

brew install rustup

安装完后发现并不能够找到rustup指令,通过brew list进行查询,发现实际上安装的为rustup-init,于是再在命令行执行:

rustup-init

顺着流程安装完成之后,重启终端便可以安装好rust环境以及相关的工具链。

可以查看对应rustc以及cargo的版本:

rustc --version
rustc 1.53.0 (53cb7b09b 2021-06-17)
cargo --version
cargo 1.53.0 (4369396ce 2021-04-27)

简单的创建一个rust语言版的Hello World进行测试:

fn main() {
    println!("Hello World!");
}

将其保存为hello.rs。

在命令行使用rustc将其编译为可执行文件:

rustc hello.rs

之后直接执行可执行文件,便可以在终端看到对应的输出了!

./hello
Hello World!

打开本地文档

rustup doc

更新

 rustup update

卸载

rustup self uninstall

关于时序数据库influxdb的基本说明与使用整理

InfluxDB 是一种时序数据库,时序数据库通常被用在监控场景,比如运维和 IOT(物联网)领域。这类数据库旨在存储时序数据并实时处理它们。
可以写一个程序将服务器上 CPU 的使用情况每隔 10 秒钟向 InfluxDB 中写入一条数据。接着,我们写一个查询语句,查询过去 30 秒 CPU 的平均使用情况,然后让这个查询语句也每隔 10 秒钟执行一次。最终,我们配置一条报警规则,如果查询语句的执行结果>xxx,就立刻触发报警。
上述就是一个指标监控的场景,在 IOT 领域中,也有大量的指标需要我们监控。比如, 机械设备的轴承震动频率,农田的湿度温度等等。

为什么不用关系型数据库

  1. 写入性能
    关系型数据库也是支持时间戳的,也能够基于时间戳进行查询。但是,从我们的使用场景出发,需要注意数据库的写入性能。通常,关系型数据库会采用 B+树数据结构,在数据写入时,有可能会触发叶裂变,从而产生了对磁盘的随机读写,降低写入速度。
    数据价值

  2. 时间不可倒流,数据只写不改
    我们之前说,时序数据库一般用于指标监控场景。这个场景的数据有一个非常明显的特点就是冷热差别明显。通常,指标监控只会使用近期一段时间的数据,比如我只查询某个设备最近 10 分钟的记录,10 分钟前的数据我就不再用了。那么这 10 分钟前的数据,对我们来说就是冷数据,应该被压缩放到磁盘里去来节省空间。而热数据因为经常要用,数据库就应该让它留在内存里,等待查询。而市面上的时序数据库大都有类似的设计。

  3. 时间不可倒流,数据只写不改
    时序数据是描述一个实体在不同时间所处的不同状态。
    就像是我们打开任务管理器,查看 CPU 的使用情况。我发现 CPU 占用率太高了,于是杀死了一个进程,但 10 秒前的数据不会因为我关闭进程再发生改变了。这是时序数据的一大特点。与之相应,时序数据库基本上是插入操作较多,而且还没有什么更新需求。

一些概念

Bucket桶
是influxDb中基本存储单元 用于组织和存储时间序列数据 他是数据的逻辑容器,用于区分和隔离不同类型或来源的数据
oraganization 组织
用于隔离和管理用户 应用程序或者项目 每个用户可以属于一个或者多个组织 Bucket 也属于一个组织
Measurement 测量值
是influxDb中的数据表的概念 他类似关系型数据库中的数据表 用于存储时间序列数据 每个Measurement 包含一组字段和标签
Field 字段
field 是 Measurement 中的一种数据类型 用于存储实际的数值数据 例如温度 湿度 等是字段的例子
Tag标签
Tag 是 Measurement 中的一种索引类型 用于标识和过滤数据 标签通常用于存储维度信息 例如设备ID 地理位置 等是字段的例子
Point数据点
Point 是influxDb中时间序列数据的基本单位 它包含了时间戳 字段 标签 每个数据点都关联到一个Measurement
API密钥和访问令牌
为了进行安全的访问和操作
2.x 引入了Api 密钥和访问令牌 API密钥用于身份验证 而访问令牌用于授权对数据的访问
Flux查询语言
Flux是2.x 中的查询语言 用于执行强大的数据处理和分析操作 它支持灵活的 查询 过滤 聚合和转换操作
仪表盘和可视化
2.x 提供了仪表盘 和可视化工具 允许用户创建 定制 和共享图表 和仪表盘 以直观的展示时间序列数据

概念是oraganization,所有的数据都是属于org的。数据的存储都是在bucket里面。可以理解为数据库,2.x版本中没有database这个概念了。measurement可以理解成为一张表,但是实际上不是一个表。数据中point表示一条数据,每条数据都有一个_time表示时间戳,series表示point的集合,field是固定字段_field,key和value都是值,没有索引,tag是自定义字段名和值,索引的结合

复盘Casbin权限框架

Casbin的工作原理

在 Casbin 中, 访问控制模型被抽象为基于 PERM (Policy, Effect, Request, Matcher) [策略,效果,请求,匹配器]的一个文件。

Policy:定义权限的规则
Effect:定义组合了多个Policy之后的结果
Request:访问请求
Matcher:判断Request是否满足Policy

首先会定义一堆Policy,让后通过Matcher来判断Request和Policy是否匹配,然后通过Effect来判断匹配结果是Allow还是Deny。

Policy
Policy 主要表示访问控制关于角色、资源、行为的具体映射关系。

Casbin的核心概念

Model

Model是Casbin的具体访问模型,其主要以文件的形式出现,该文件常常以.conf最为后缀。

Model CONF 至少应包含四个部分:
[request_definition],
[policy_definition],
[policy_effect],
[matchers]。
如果 model 使用 RBAC, 还需要添加[role_definition]部分。
Model CONF 文件可以包含注释。注释以 # 开头, # 会注释该行剩余部分。

比如:

# 请求定义 
# 用于request的定义,它明确了e.Enforce(...)函数中参数的定义,sub, obj, act 表示经典三元组: 访问实体 (Subject),访问资源 (Object) 和访问方法 (Action)。
[request_definition]
r = sub, obj, act

# 策略定义
# 用于policy的定义,每条规则通常以形如p的policy type开头,比如p,joker,data1,read就是一条joker具有data1读权限的规则。
[policy_definition]
p = sub, obj, act

# 角色定义
# 是RBAC角色继承关系的定义。g 是一个 RBAC系统,_, _表示角色继承关系的前项和后项,即前项继承后项角色的权限。
[role_definition]
g = _, _

# policy_effect:是对policy生效范围的定义,它对request的决策结果进行统一的决策,比如e = some(where (p.eft == allow))就表示如果存在任意一个决策结果为allow的匹配规则,则最终决策结果为allow。p.eft 表示策略规则的决策结果,可以为allow 或者deny,当不指定规则的决策结果时,取默认值allow 。
[policy_effect]
e = some(where (p.eft == allow))

# 匹配器定义
# 定义了策略匹配者。匹配者是一组表达式,它定义了如何根据请求来匹配策略规则
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act

在Casbin中,访问控制模型被抽象为基于PERM元模型(策略 = Policy ,效果 = Effect,请求 = Request,匹配器 = Matcher)的CONF文件。

为项目切换或升级授权机制就像修改配置一样简单。 您可以通过组合可用模型来定制自己的访问控制模型。

例如,您可以在一个模型内部将RBAC角色和ABAC属性结合在一起,并共享一套策略规则。

策略 一般存储到数据库 因为会有很多!!!!

定义Policy

定义Matcher

Request 与 Policy 进行匹配,获得一个Effect

拿到 Effect 的结果到 Effect 的表达式 返回一个布尔值

Request == 请求

定义请求参数。 基本请求是一个元组对象,至少需要一个主体(被访问实体),对象(被访问资源)和动作(访问方法)。

例如,请求定义可能看起来像这样:

r={sub,obj,act}
# r={被访问主体,被访问资源,动作或方法}

此定义指定了访问控制匹配函数所需的参数名称和顺序。

Policy == 策略

定义访问策略的模型。 它指定了策略规则文档中字段的名称和顺序。

例如:

p={sub, obj, act} 或 p={sub, obj, act, eft}

注意:如果未定义eft(策略结果),则不会读取策略文件中的结果字段,匹配策略结果将默认允许。

Matcher == 匹配

定义请求和策略的匹配规则。

例如:

m = r.sub == p.sub && r.act == p.act && r.obj == p.obj 

这个简单而常见的匹配规则意味着,如果请求的参数(被访问主体,被访问资源,动作或方法)等于策略中找到的那些,那么返回策略结果(p.eft)。 策略的结果将保存在p.eft中。

Effect == 效果

对匹配器的匹配结果进行逻辑组合判断。

例如:

e = some(where(p.eft == allow))

这个语句意味着,如果匹配策略结果p.eft有(一些)允许的结果,那么最终结果为真。

让我们看另一个例子:

e = some(where (p.eft == allow)) && !some(where (p.eft == deny))

这个例子组合的逻辑意义是:如果有一个策略匹配到允许的结果,并且没有策略匹配到拒绝的结果,结果为真。 换句话说,当匹配策略都是允许时,结果为真。 如果有任何拒绝,两者都为假(更简单地说,当允许和拒绝同时存在时,拒绝优先)。

ACL

Casbin中最基本和最简单的模型是ACL。
ACL的模型CONF如下:

# 请求
[request_definition]
r = sub, obj, act

# 策略
[policy_definition]
p = sub, obj, act

# 效果
[policy_effect]
e = some(where (p.eft == allow))

# 匹配
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

ACL模型的一个示例策略为:

p, 张三, data1, read
p, 李四, data2, write

这意味着:

张三 可以读取data1
李四 可以写入data2
我们还支持通过在末尾添加 '\' 来进行多行模式:

# 匹配
[matchers]
m = r.sub == p.sub && r.obj == p.obj \
&& r.act == p.act

此外,如果您正在使用ABAC,您可以尝试如下例子中的'in'操作符,该例子是Casbin golang版本的(jCasbin和Node-Casbin还不支持):

# 匹配
[matchers]
m = r.obj == p.obj && r.act == p.act || r.obj in ('data2', 'data3')

但是你必须确保数组的长度超过 1,否则会引发难以恢复的错误(panic)。

参考教程

国高办公系统
https://www.bilibili.com/video/BV1qz4y167XP/
https://blog.csdn.net/weixin_51991615/article/details/123746169
https://darjun.github.io/2020/06/12/godailylib/casbin/
https://casbin.org/zh/docs/how-it-works
https://casbin.org/zh/editor
https://github.com/casbin/gorm-adapter
https://casbin.org/zh/docs/adapters/#%E6%94%AF%E6%8C%81%E7%9A%84%E9%80%82%E9%85%8D%E5%99%A8
https://juejin.cn/post/7133456877605617678
https://medium.com/@mehul25/casbin-rbac-with-domains-92680bd28d2e
https://medium.com/@mehul25/casbin-groups-and-roles-6c279aa918b

1 2 3 4 5 11