首页 文章 精选 留言 我的

django form表单插件，中间件，缓存，信号

2017-11-07 757
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
一、form插件
django form表单类的字段和插件，字段用于表单验证获取数据，插件用来生成html代码
Field
     required = True ,               是否允许为空
     widget = None ,                 HTML插件
     label = None ,                  用于生成Label标签或显示内容
     initial = None ,                初始值
     help_text = '',                帮助信息(在标签旁边显示)
     error_messages = None ,         错误信息 { 'required' :  '不能为空' ,  'invalid' :  '格式错误' }
     show_hidden_initial = False ,   是否在当前插件后面再加一个隐藏的且具有默认值的插件（可用于检验两次输入是否一直）
     validators = [],               自定义验证规则
     localize = False ,              是否支持本地化
     disabled = False ,              是否可以编辑
     label_suffix = None             Label内容后缀
     
 
CharField(Field)
     max_length = None ,             最大长度
     min_length = None ,             最小长度
     strip = True                    是否移除用户输入空白
 
IntegerField(Field)
     max_value = None ,              最大值
     min_value = None ,              最小值
     
DecimalField(IntegerField)
     max_value = None ,              最大值
     min_value = None ,              最小值
     max_digits = None ,             总长度
     decimal_places = None ,         小数位长度
     
RegexField(CharField)
     regex,                      自定制正则表达式
     max_length = None ,            最大长度
     min_length = None ,            最小长度
     error_message = None ,         忽略，错误信息使用 error_messages = { 'invalid' :  '...' }
 
EmailField(CharField)
FileField(Field)
     allow_empty_file = False      是否允许空文件
 
ChoiceField(Field)
     ...
     choices = [],                选项，如：choices  =  [( 0 , '上海' ),( 1 , '北京' ),]
     required = True ,             是否必填
     widget = None ,               插件，默认select插件
     label = None ,                Label内容
     initial = None ,              初始值
     help_text = '',              帮助提示
     
FilePathField(ChoiceField)     文件选项，目录下文件显示在页面中
     path,                      文件夹路径
     match = None ,                正则匹配
     recursive = False ,           递归下面的文件夹
     allow_files = True ,          允许文件
     allow_folders = False ,       允许文件夹
     required = True ,
     widget = None ,
     label = None ,
     initial = None ,
     help_text = ''
 
GenericIPAddressField
     protocol = 'both' ,           both,ipv4,ipv6支持的IP格式
     unpack_ipv4 = False           解析ipv4地址，如果是::ffff: 192.0 . 2.1 时候，可解析为 192.0 . 2.1 ， PS：protocol必须为both才能启用
1
二、form验证规则
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
新建模块forms.py
from  django.forms  import  Form
from  django.forms  import  fields
from  django.forms  import  widgets
from  app01  import  models
import  re
from  django.core.exceptions  import  ValidationError
from  django.core.validators  import  RegexValidator
 
class  UserInfoForm(Form):
     name  =  fields.CharField(
         required = True ,
         min_length = 6 ,
         max_length = 12
     )
     email  =  fields.EmailField(
         required = True ,
     )
     方法一: RegexValidator对象
     phone  =  fields.CharField(
         validators = [RegexValidator(r '^[0-9]+$' ,  '请输入数字' ), RegexValidator(r '^159[0-9]+$' ,  '数字必须以159开头' )]
      )
      
     方式二：函数
     def  mobile_validate(value):
     mobile_re  =  re. compile (r '^(13[0-9]|15[0123456789]|17[678]|18[0-9]|14[57])[0-9]{8}$' )
     if  not  mobile_re.match(value):
         raise  ValidationError( '手机号码格式错误' )
         
     phone  =  fields.CharField(
          validators =  [mobile_validate,]
      )
      
     方法三：当前类的方法中，方法名称要求: clean_phone方法
     phone  =  fields.CharField()
     
     def  clean_phone( self ):
         # 去取用户提交的值：可能是错误的，可能是正确
         value  =  self .cleaned_data[ 'phone' ]
         mobile_re  =  re. compile (r '^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$' )
         if  not  mobile_re.match(value):
             raise  ValidationError( '手机号码格式错误' )
 
         if  models.UserInfo.objects. filter (phone = value).count():
             raise  ValidationError( '手机号码已经存在' )
 
         return  value
         
  注册确认密码认证clean函数
  class  RegisterForm(Form):
     name  =  fields.CharField(
         widget = widgets.TextInput(attrs = { 'class' :  'c1' })
     )
 
     email  =  fields.EmailField(
         widget = widgets.EmailInput(attrs = { 'class' :  'c1' })
     )
 
     phone  =  fields.CharField(
         widget = widgets.Textarea(attrs = { 'class' :  'c1' })
     )
 
     pwd  =  fields.CharField(
         widget = widgets.PasswordInput(attrs = { 'class' :  'c1' })
     )
 
     pwd_confirm  =  fields.CharField(
         widget = widgets.PasswordInput(attrs = { 'class' :  'c1' })
     )
 
     dp_id  =  fields.ChoiceField(
         choices = []
     )
 
     roles_id  =  fields.ChoiceField(
         choices = []
     )
 
     def  __init__( self ,  * args,  * * kwargs):
         super (RegisterForm,  self ).__init__( * args,  * * kwargs)
         self .fields[ 'dp_id' ].choices  =  models.Depart.objects.values_list( 'id' ,  'title' )
         self .fields[ 'roles_id' ].choices  =  models.Role.objects.values_list( 'id' ,  'name' )
 
     def  clean( self ):
         pwd  =  self .cleaned_data[ 'pwd' ]
         pwd_confirm  =  self .cleaned_data[ 'pwd_confirm' ]
         if  pwd  = =  pwd_confirm:
             return  self .cleaned_data
         else :
             from  django.core.exceptions  import  ValidationError
             self .add_error( 'pwd_confirm' , ValidationError( '密码输入不一致' ))
             return  self .cleaned_data
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
三、中间件
项目目录下新建目录md
md目录新建middleware.py文件
from  django.shortcuts  import  HttpResponse,redirect
 
class  MiddlewareMixin:
     def  __init__( self , get_response = None ):
         self .get_response  =  get_response
         super (MiddlewareMixin, self ).__init__()
 
     def  __call__( self , request):
         response  =  None
         if  hasattr ( self ,  'process_request' ):
             response  =  self .process_request(request)
         if  not  response:
             response  =  self .get_response(request)
         if  hasattr ( self ,  'process_response' ):
             response  =  self .process_response(request, response)
         return  response
 
class  M1(MiddlewareMixin):
     def  process_request( self , request):
         print ( 'm1.process_request' )
 
     def  process_view( self , request, callback, callback_args, callback_kwargs):
         print ( 'm1.process_view' , callback)
 
     def  process_exception( self ,request,exception):
         print ( 'm1.process_exception' )
 
     def  process_response( self ,request,response):
         print ( 'm1.process_response' )
         return  response
 
class  M2(MiddlewareMixin):
     def  process_request( self , request):
         print ( 'm2.process_request' )
 
     def  process_view( self ,request,callback, callback_args, callback_kwargs):
         print ( 'm2.process_view' , callback)
 
     def   process_response( self ,request, response):
         print ( 'm2.process_response' )
         return  response
 
     def  process_exception( self ,request,exception):
         print ( 'm2.process_exception' )
         
         
  settings.py文件中间件添加
MIDDLEWARE  =  [
     'django.middleware.security.SecurityMiddleware' ,
     'django.contrib.sessions.middleware.SessionMiddleware' ,
     'django.middleware.common.CommonMiddleware' ,
     'django.middleware.csrf.CsrfViewMiddleware' ,
     'django.contrib.auth.middleware.AuthenticationMiddleware' ,
     'django.contrib.messages.middleware.MessageMiddleware' ,
     'django.middleware.clickjacking.XFrameOptionsMiddleware' ,
     'md.middleware.M1' ,     #添加项
     'md.middleware.M2' ,     #添加项
]
 
 
中间件是一个类
中间件中一共有四个方法：
process_request
process_view
process_exception
process_response
 
 
已经添加中间件M1和M2
中间件执行时机: 请求到来，请求返回时
-  应用：
     -  请求日志
     -  用户登录认证

wKioL1m_hbXh99ymAABUHI-DJ4M285.jpg-wh_50

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
四、缓存
由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会
更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，
5 分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿
到，并返回
 
Django中提供了 6 种缓存方式：
1.  开发调试
2.  内存
3.  文件
4.  数据库
5.  Memcache缓存（python - memcached模块）
6.  Memcache缓存（pylibmc模块)
 
a.开发调试
# 此为开始调试用，实际内部不做任何操作
# 配置：
CACHES  =  {            
     'default' : {               
          'BACKEND' :  'django.core.cache.backends.dummy.DummyCache' ,      # 引擎
          'TIMEOUT' :  300 ,  # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
          'OPTIONS' :{
              'MAX_ENTRIES' :  300 ,  # 最大缓存个数（默认300）
              'CULL_FREQUENCY' :  3 ,     # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
              },
          'KEY_PREFIX' : '',  # 缓存key的前缀（默认空）  
          'VERSION' :  1 ,      # 缓存key的版本（默认1）
          'KEY_FUNCTION'  函数名     # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
        }
      }
      
      
  def  default_key_func(key, key_prefix, version):
      return  '%s:%s:%s'  %  (key_prefix, version, key)
      
  def  get_key_func(key_func):
      if  key_func  is  not  None :            
          if  callable (key_func):                
              return  key_func            
          else :                
              return  import_string(key_func)        
      return  default_key_func
      
      
  b. 内存缓存
   此缓存将内容保存至内存的变量中
   # 配置：
   CACHES  =  {           
        'default' : {                
            'BACKEND' :  'django.core.cache.backends.locmem.LocMemCache' ,                
            'LOCATION' :  'unique-snowflake' ,
             }
         }
    
c. 文件缓存
# 此缓存将内容保存至文件
     # 配置：
         CACHES  =  {            
             'default' : {                
                 'BACKEND' :  'django.core.cache.backends.filebased.FileBasedCache' ,  
                 'LOCATION' :  '/var/tmp/django_cache' ,
             }
         }
         
d. 数据库缓存
# 此缓存将内容保存至数据库
 
     # 配置：
         CACHES  =  {            
             'default' : {               
                  'BACKEND' :  'django.core.cache.backends.db.DatabaseCache' ,                
                  'LOCATION' :  'my_cache_table' ,  # 数据库表                           
              }
         }
         
e. Memcache缓存（python - memcached模块）
# 此缓存使用python-memcached模块连接memcache
     CACHES  =  {        
         'default' : {            
             'BACKEND' :  'django.core.cache.backends.memcached.MemcachedCache' ,           
              'LOCATION' :  '127.0.0.1:11211' ,
         }
     }
 
     CACHES  =  {       
          'default' : {            
              'BACKEND' :  'django.core.cache.backends.memcached.MemcachedCache' ,           
               'LOCATION' :  'unix:/tmp/memcached.sock' ,
         }
     }   
 
     CACHES  =  {       
          'default' : {            
              'BACKEND' :  'django.core.cache.backends.memcached.MemcachedCache' ,           
               'LOCATION' : [ 
               '172.19.26.240:11211' ,                
               '172.19.26.242:11211' ,
             ]
         }
     }
 
     
  f. Memcache缓存（pylibmc模块）
  # 此缓存使用pylibmc模块连接memcache    
     CACHES  =  {        
         'default' : {            
             'BACKEND' :  'django.core.cache.backends.memcached.PyLibMCCache' ,            
             'LOCATION' :  '127.0.0.1:11211' ,
         }
     }
 
     CACHES  =  {        
         'default' : {            
             'BACKEND' :  'django.core.cache.backends.memcached.PyLibMCCache' ,            
             'LOCATION' :  '/tmp/memcached.sock' ,
         }
     }   
 
     CACHES  =  {        
         'default' : {            
             'BACKEND' :  'django.core.cache.backends.memcached.PyLibMCCache' ,           
              'LOCATION' : [                
                  '172.19.26.240:11211' ,                
                  '172.19.26.242:11211' ,
             ]
         }
     }
     
     
缓存使用方法
1.  全站应用配置
使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获
取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则
UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存
 
MIDDLEWARE  =  [       
          'django.middleware.cache.UpdateCacheMiddleware' ,         # 其他中间件...
          'django.middleware.cache.FetchFromCacheMiddleware' ,
     ]
 
     #CACHE_MIDDLEWARE_ALIAS = ""
    # CACHE_MIDDLEWARE_SECONDS = ""
    # CACHE_MIDDLEWARE_KEY_PREFIX = ""
     
2. 单独视图函数
方式一：        
from  django.views.decorators.cache  import  cache_page
 
@cache_page ( 60  *  15 )        
def  my_view(request):
             ...
 
方式二：        
from  django.views.decorators.cache  import  cache_page
 
urlpatterns  =  [
     url(r '^foo/([0-9]{1,2})/$' , cache_page( 60  *  15 )(my_view)),
     ]
     
     
3. 局部视图使用
a. 引入TemplateTag
 
         { %  load cache  % }
 
b. 使用缓存
 
         { %  cache  5000  缓存key  % }
             缓存内容
         { %  endcache  % }
         
五、信号
1. 内置信号
Django中提供了“信号调度”，用于在框架执行操作时解耦。通俗来讲，就是一些动作发生的时候，
信号允许特定的发送者去提醒一些接受者
 
Model signals
     pre_init                     # django的modal执行其构造方法前，自动触发
     post_init                    # django的modal执行其构造方法后，自动触发
     pre_save                     # django的modal对象保存前，自动触发
     post_save                    # django的modal对象保存后，自动触发
     pre_delete                   # django的modal对象删除前，自动触发
     post_delete                  # django的modal对象删除后，自动触发
     m2m_changed                  # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
     class_prepared               # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
Management signals
     pre_migrate                  # 执行migrate命令前，自动触发
     post_migrate                 # 执行migrate命令后，自动触发
Request / response signals
     request_started              # 请求到来前，自动触发
     request_finished             # 请求结束后，自动触发
     got_request_exception        # 请求异常后，自动触发
Test signals
     setting_changed              # 使用test测试修改配置文件时，自动触发
     template_rendered            # 使用test测试渲染模板时，自动触发
Database Wrappers
     connection_created           # 创建数据库连接时，自动触发
     
对于Django内置的信号，仅需注册指定信号，当程序执行相应操作时，自动触发注册函数：
 
from  django.core.signals  import  request_finished    
from  django.core.signals  import  request_started    
from  django.core.signals  import  got_request_exception    
from  django.db.models.signals  import  class_prepared    
from  django.db.models.signals  import  pre_init, post_init    
from  django.db.models.signals  import  pre_save, post_save    
from  django.db.models.signals  import  pre_delete, post_delete    
from  django.db.models.signals  import  m2m_changed    
from  django.db.models.signals  import  pre_migrate, post_migrate    
from  django.test.signals  import  setting_changed    
from  django.test.signals  import  template_rendered    
from  django.db.backends.signals  import  connection_created    
 
def  callback(sender,  * * kwargs):        
     print ( "xxoo_callback" )        
     print (sender,kwargs)
 
xxoo.connect(callback)     # xxoo指上述导入的内容
 
 
例子:
from  django.core.signals  import  request_finished
from  django.dispatch  import  receiver
 
@receiver (request_finished)
def  my_callback(sender,  * * kwargs):    
     print ( "Request finished!" )
     
2. 自定义信号
a. 定义信号
import  django.dispatch
pizza_done  =  django.dispatch.Signal(providing_args = [ "toppings" ,  "size" ])
 
b. 注册信号
def  callback(sender,  * * kwargs):
     print ( "callback" )
     print (sender,kwargs)
  
pizza_done.connect(callback)
 
c. 触发信号
from  路径  import  pizza_done
  
pizza_done.send(sender = 'seven' ,toppings = 123 , size = 456 )
 
 
例子请求后打印一行数据: 配置在urls.py一层目录下面的__init__.py文件中
from  django.core.signals  import  request_finished
from  django.core.signals  import  request_started
from  django.core.signals  import  got_request_exception
 
from  django.db.models.signals  import  class_prepared
from  django.db.models.signals  import  pre_init, post_init
from  django.db.models.signals  import  pre_save, post_save
from  django.db.models.signals  import  pre_delete, post_delete
from  django.db.models.signals  import  m2m_changed
from  django.db.models.signals  import  pre_migrate, post_migrate
 
from  django.test.signals  import  setting_changed
from  django.test.signals  import  template_rendered
 
from  django.db.backends.signals  import  connection_created
 
 
def  test(sender,  * * kwargs):
     print ( "request_finished.222" )
     print (sender, kwargs)
 
request_started.connect(test)     #请求开始时打印
request_finished.connect(test)     #请求结束后打印





     本文转自小白的希望 51CTO博客，原文链接：http://blog.51cto.com/haoyonghui/1966329 ，如需转载请自行联系原作者






上一篇 下一篇
优秀的个人博客,低调大师

微信关注我们

原文链接：https://yq.aliyun.com/articles/500315

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

SharePoint 2010 服务应用程序(Service Application)架构（2）

在第(1)篇文章中，回顾了一下SharePoint 2007中的Shared Services Provider（SSP）架构。从这篇开始，将开始讲述SharePoint 2010中的服务应用程序架构。 在SharePoint 2010中，微软重新设计了共享服务提供程序架构，将其改进成了服务应用程序架构。相比共享服务提供程序架构，服务应用程序架构有更好的灵活性。如果一个SharePoint 2010服务实现了服务应用程序框架，那么管理员就可以根据需要，在服务器场中创建一个相应的服务应用程序，来提供此服务。当然，管理员也可以为一个SharePoint 2010服务，创建多个服务应用程序。每个服务应用程序可以有不同的设置，甚至可以有不同的数据库，用来存放服务应用程序单独的数据。这也就是一个服务应用程序也被称为服务的一个可配置服务器场实例（Configured Farm-Scoped Instantiation）的原因。 服务应用程序运行在服务器场中的应用服务器上，它们通常需要被运行在前端服务器上的组件，例如Web部件，来调用。前端服务器上的组件是透过一种叫做服务应用程序代理的中间组件，来调...
2017-11-08
463
上一篇

转REST框架介绍

学习 REST REST 是由 Roy Fielding 在他的论文 《Architectural Styles and the Design of Network-based Software Architectures》中提出的一个术语。 REST 是英文 Representational State Transfer 的缩写，有中文翻译为“具象状态传输”（参考： 《SIP/IMS网络中的Representational State Transfer (REST)和数据分布》）。 ————————————— 前面的内容比较枯燥，我说说我自己的理解。 但是 REST 到底是什么呢？论文我看不懂，不过找到一篇更简单易懂的东西： 《Building Web Services the REST Way》。 根据这篇文章，我整理了一下我自己对 REST 的理解： REST 首先只是一种架构样式，不是一种标准。这点和 Ajax 类似，两者都是利用现有的成熟技术。 在 REST 的定义中，一个 Web 应用总是 使用固定的 URI 向外部世界呈现（或者说暴露）一个资源。 URI 是英文 Unif...
2017-11-08
591
下一篇

相关文章

发表评论

资源下载

更多资源
腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

时间: 2025-12-28 大小: 1MB 下载: 4次
Spring

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

时间: 2025-12-17 大小: 5MB 下载: 1次
Rocky Linux

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

时间: 2026-01-03 大小: 1.42GB 下载: 2次
Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

时间: 2025-12-03 大小: 9.84MB 下载: 39次
手机查看

扫码在手机上查看文章

扫描二维码，手机阅读更方便

热门标签
HarmonyOS6 Redis Docker Nacos3 Service Mesh Kubernetes DeepSeek Jdk25 SpringCloud SpringBoot4 Rocky Gemini3 OpenAi

欢迎您来访！

登录后，您将获得更多功能！
热门文章
联系我们

有任何问题或合作意向欢迎联系我们

Email: 99873273@qq.com

QQ: 99873273

用户登录
用户注册