tables-urls-views-forms处理工作流程-openstack E版

2024-03-16 10:48

本文主要是介绍tables-urls-views-forms处理工作流程-openstack E版,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

感谢朋友支持本博客,欢迎共同探讨交流,由于能力和时间有限,错误之处在所难免,欢迎指正!

如有转载,请保留源作者博客信息。

Better Me的博客:blog.csdn.net/tantexian

如需交流,欢迎大家博客留言。


tables->urls->views->forms处理工作流程-openstack E版

1、/opt/horizon-2012.1/horizon/dashboards/syspanel/balancers/ views.py
class EditAttachmentsView(tables.DataTableView):
table_class = AttachmentsTable
template_name = 'nova/instances_and_volumes/volumes/attach.html'

def get_object(self): #点击Edit Attachments之后第5步执行 
if not hasattr(self, "_object"): #点击deachments提交按钮后第7步执行 , 接着执行tables里面。
volume_id = self.kwargs['volume_id']
try:
self._object = api.volume_get(self.request, volume_id)
except:
self._object = None
exceptions.handle(self.request,
_('Unable to retrieve volume information.'))
return self._object

def get_data(self): #点击Edit Attachments第4步执行 
try: #点击deachments提交按钮后第6步执行 
volumes = self.get_object()  #此处在调用froms.py中的表单处理之后为tables获取data
attachments = [att for att in volumes.attachments if att] # 跟进到4中的父类get_data实现
except:
attachments = []
exceptions.handle(self.request,
_('Unable to retrieve volume information.'))
return attachments

def get_context_data(self, **kwargs): #点击Edit Attachments第6步执行, 还要继续调用get_object 
context = super(EditAttachmentsView, self).get_context_data(**kwargs)
context['form'] = self.form
context['volume'] = self.get_object()
return context

def handle_form(self): #点击Edit Attachments第2步执行 ,接着第3步执行forms (此处跟踪跳转到2、froms.py中流程解析)
instances = api.nova.server_list(self.request) #点击Attachments提交按钮后第2步执行 ,接着接着第3步执行forms
initial = {'volume_id': self.kwargs["volume_id"], #点击deachments提交按钮后第2步执行 ,接着接着第3步执行forms
'instances': instances} #点击deachments提交按钮后第5步执行 
return AttachForm.maybe_handle(self.request, initial=initial) #在此函数中初始化了instances和volume_id的initial字典,
#以便于在forms中 instance_list = kwargs.get('initial', {}).get('instances', [])取用     

def get(self, request, *args, **kwargs): #点击Edit Attachments第1步执行
self.form, handled = self.handle_form() #点击deachments提交按钮后第4步执行 
if handled:                                                 #每次在点击编辑按钮时候,发来一个url被get捕获,
return handled                                      #然后根据是提交表单还是link进行相应的处理, 接着就调用
handled = self.construct_tables()            #handle_form(self)函数进行处理
if handled:
return handled
context = self.get_context_data(**kwargs)
context['form'] = self.form
if request.is_ajax():
context['hide'] = True
self.template_name = ('nova/instances_and_volumes/volumes'
'/_attach.html')
return self.render_to_response(context)

def post(self, request, *args, **kwargs):
form, handled = self.handle_form() #点击Attachments提交按钮后第1执行 
if handled: #点击deachments提交按钮后第1执行 
return handled
return super(EditAttachmentsView, self).post(request, *args, **kwargs


2、/opt/horizon-2012.1/horizon/dashboards/syspanel/balancers/forms.py
class AttachForm(forms.SelfHandlingForm):
instance = forms.ChoiceField(label="Attach to Instance",
help_text=_("Select an instance to "
"attach to."))
device = forms.CharField(label="Device Name", initial="/dev/vdc",
widget=forms.TextInput(
attrs={'readonly':'readonly'}))
os_type = forms.ChoiceField(label=_("Operating System"),
help_text=_("The OS type of instance"),
choices=[('linux', 'Linux'),
('windows', 'Windows')],
widget=forms.Select(attrs={'class':
'switchable'}))
mount_path =forms.CharField(label="Mount Path",
initial="/data")
def __init__(self, *args, **kwargs): #上一步中views.py的handle_form取得的initial数据,在此处可以pop出来使用
super(AttachForm, self).__init__(*args, **kwargs)
# populate volume_id
volume_id = kwargs.get('initial', {}).get('volume_id', [])#
self.fields['volume_id'] = forms.CharField(widget=forms.HiddenInput(),
initial=volume_id)

# Populate instance choices
instance_list = kwargs.get('initial', {}).get('instances', [])
instances = []
for instance in instance_list:
if instance.status in ACTIVE_STATES:
instances.append((instance.id, '%s (%s)' % (instance.name,
instance.id)))
if instances:
instances.insert(0, ("", _("Select an instance")))
else:
instances = (("", _("No instances available")),)
self.fields['instance'].choices = instances #选择instance的下拉框

def handle(self, request, data):
try:
api.volume_attach(request,   #点击提交按钮时候执行此处函数调用
data['volume_id'],
data['instance'],
data['device'],
data['mount_path'],
data['os_type'])
vol_name = api.volume_get(request, data['volume_id']).display_name

message = (_('Attaching volume %(vol)s to instance '
'%(inst)s at %(dev)s' 'and mount at %(path)s') %
{"vol": vol_name, "inst": data['instance'],
"dev": data['device'],
"path":data['mount_path']})
LOG.info(message)
messages.info(request, message)
except novaclient_exceptions.ClientException, e:
LOG.exception("ClientException in AttachVolume")
messages.error(request,
_('Error attaching volume: %s') % e.message)
return shortcuts.redirect(
"horizon:nova:instances_and_volumes:index") #执行成功返回





3、/opt/horizon-2012.1/horizon/dashboards/syspanel/balancers/tables.py
class AttachmentsTable(tables.DataTable):
instance = tables.Column("server_id", verbose_name=_("Instance"))
device = tables.Column("device")

def get_object_id(self, obj): #点击deachments提交按钮后tables第2步执行 
return obj['id'] #点击deachments提交按钮后tables第5步执行 

def get_object_display(self, obj): #点击deachments提交按钮后tables第3步执行 
vals = {"dev": obj['device'],
"instance": obj['server_id']}
return "Attachment %(dev)s on %(instance)s" % vals

def get_object_by_id(self, obj_id): #点击deachments提交按钮后tables第1步执行 
for obj in self.data: #点击deachments提交按钮后tables第4步执行 
if self.get_object_id(obj) == obj_id:
return obj
raise ValueError('No match found for the id "%s".' % obj_id)

class Meta:
name = "attachments"
table_actions = (DetachVolume,)
row_actions = (DetachVolume,)



4、/opt/horizon-2012.1/horizon/tables/views.py
class DataTableView(MultiTableView):
""" A class-based generic view to handle basic DataTable processing.

Three steps are required to use this view: set the ``table_class``
attribute with the desired :class:`~horizon.tables.DataTable` class;
define a ``get_data`` method which returns a set of data for the
table; and specify a template for the ``template_name`` attribute.

Optionally, you can override the ``has_more_data`` method to trigger
pagination handling for APIs that support it.
"""
    #使用DataTableView必须满足三个条件:1、设定table_class属性
                                                                     #2、定义get_data方法返回数据给tabels
                                                                     #3、指定template_name属性
#本例中        table_class = AttachmentsTable (在AttachmentsTables中定义)
                     template_name = 'nova/instances_and_volumes/volumes/attach.html'


table_class = None
context_object_name = 'table'

def _get_data_dict(self):#解析data
if not self._data:
self._data = {self.table_class._meta.name: self.get_data()} #此处跟踪到3中的AttachmentsTable
return self._data

def get_data(self):
raise NotImplementedError('You must define a "get_data" method on %s.'
% self.__class__.__name__)

def get_tables(self):
tableName = self.request.GET.get("table",None)
if tableName=="volumes":
self.template_name = 'horizon/common/_volumes.html'
self.table_class = instances_and_volumes.volumes.tables.VolumesTable
elif tableName=="instances":
self.template_name = 'horizon/common/_instances.html'
self.table_class = instances_and_volumes.instances.tables.InstancesTable
elif tableName =="images":
self.template_name = 'horizon/common/_images.html'
self.table_class = images_and_snapshots.images.tables.ImagesTable
elif tableName == "snapshots":
self.template_name = 'horizon/common/_snapshots.html'
self.table_class = images_and_snapshots.snapshots.tables.SnapshotsTable
elif tableName == "volume_snapshots":
self.template_name = 'horizon/common/_volume_snapshots.html'
self.table_class = images_and_snapshots.volume_snapshots.tables.VolumeSnapshotsTable
elif tableName == "keypairs":
self.template_name = 'horizon/common/_keypairs.html'
self.table_class = access_and_security.keypairs.tables.KeypairsTable
elif tableName == "security_groups":
self.template_name = 'horizon/common/_security_groups.html'
self.table_class = access_and_security.security_groups.tables.SecurityGroupsTable
elif tableName == "floating_ips":
self.template_name = 'horizon/common/_floating_ips.html'
self.table_class = access_and_security.floating_ips.tables.FloatingIPsTable
elif tableName == "devices":
self.table_class = elastic_load_balancing.devices.tables.DevicesTable
self.template_name = 'horizon/common/_devices.html'
elif tableName == "serverfarms":
self.table_class = elastic_load_balancing.serverfarms.tables.ServerfarmsTable
self.template_name = 'horizon/common/_serverfarms.html'

if not self._tables:
self._tables = {self.table_class._meta.name: self.get_table()}
return self._tables

def get_table(self):
if not self.table_class:
raise AttributeError('You must specify a DataTable class for the '
'"table_class" attribute on %s.'
% self.__class__.__name__)
if not hasattr(self, "table"):
self.table = self.table_class(self.request, **self.kwargs)
return self.table

def get_context_data(self, **kwargs):
context = super(DataTableView, self).get_context_data(**kwargs)
context[self.context_object_name] = self.table
return context


5、/opt/horizon-2012.1/horizon/base.py
class DataTable(object):
""" A class which defines a table with all data and associated actions.

.. attribute:: name

String. Read-only access to the name specified in the
table's Meta options.

.. attribute:: multi_select

Boolean. Read-only access to whether or not this table
should display a column for multi-select checkboxes.

.. attribute:: data

Read-only access to the data this table represents.

.. attribute:: filtered_data

Read-only access to the data this table represents, filtered by
the :meth:`~horizon.tables.FilterAction.filter` method of the table's
:class:`~horizon.tables.FilterAction` class (if one is provided)
using the current request's query parameters.
"""
__metaclass__ = DataTableMetaclass

def __init__(self, request, data=None, **kwargs):
self._meta.request = request
self._meta.data = data
self.kwargs = kwargs

# Create a new set
columns = []
for key, _column in self._columns.items():
column = copy.copy(_column)
column.table = self
columns.append((key, column))
self.columns = SortedDict(columns)
self._populate_data_cache()

# Associate these actions with this table
for action in self.base_actions.values():
action.table = self

def __unicode__(self):
return unicode(self._meta.verbose_name)

def __repr__(self):
return '<%s: %s>' % (self.__class__.__name__, self.name)

@property
def name(self):
return self._meta.name

@property
def data(self):
return self._meta.data

@data.setter
def data(self, data):
self._meta.data = data

@property
def multi_select(self):
return self._meta.multi_select

@property
def filtered_data(self):
if not hasattr(self, '_filtered_data'):
self._filtered_data = self.data
if self._meta.filter and self._meta._filter_action:
action = self._meta._filter_action
filter_string = self.get_filter_string()
request_method = self._meta.request.method
if filter_string and request_method == action.method:
self._filtered_data = action.filter(self,
self.data,
filter_string)
return self._filtered_data

def get_filter_string(self):
filter_action = self._meta._filter_action
param_name = filter_action.get_param_name()
filter_string = self._meta.request.POST.get(param_name, '')
return filter_string

def _populate_data_cache(self):
self._data_cache = {}
# Set up hash tables to store data points for each column
for column in self.get_columns():
self._data_cache[column] = {}

def _filter_action(self, action, request, datum=None):
try:
# Catch user errors in permission functions here
return action._allowed(request, datum)
except Exception:
LOG.exception("Error while checking action permissions.")
return None

def render(self):
""" Renders the table using the template from the table options. """
table_template = template.loader.get_template(self._meta.template)
param_dict=self._meta.request.GET
rowsinfo=self.get_rows();
after_range_num=4
befor_range_num=3
perpage= int(param_dict.get("perpage",10))
perpage_list=[10,20,30]
paginator = Paginator(rowsinfo,perpage)
try:
page=int(param_dict.get("page",1))
if page<1:
page=1
elif page>paginator.num_pages:
page=paginator.num_pages    
except ValueError:
page=1
try:
paginatorRows=paginator.page(page)
except(EmptyPage,InvalidPage,PageNotAnInteger):
paginatorRows=paginator.page(1)
if page >= after_range_num:
page_range = paginator.page_range[page-after_range_num:page+befor_range_num]
else:
page_range = paginator.page_range[0:int(page)+befor_range_num]
extra_context = {self._meta.context_var_name: self,"rows":paginatorRows,"page_range":page_range,"perpage":perpage,"paginator_num_list":perpage_list}
context = template.RequestContext(self._meta.request,extra_context)
return table_template.render(context)

def get_absolute_url(self):
""" Returns the canonical URL for this table.

This is used for the POST action attribute on the form element
wrapping the table. In many cases it is also useful for redirecting
after a successful action on the table.

For convenience it defaults to the value of
``request.get_full_path()`` with any query string stripped off,
e.g. the path at which the table was requested.
"""
full_path=self._meta.request.get_full_path()
if("paginator" in full_path):
return full_path.partition('paginator')[0]
return full_path.partition('?')[0]

def get_empty_message(self):
""" Returns the message to be displayed when there is no data. """
return _("No items to display.")

def get_object_by_id(self, lookup):
"""
Returns the data object from the table's dataset which matches
the ``lookup`` parameter specified. An error will be raised if
the match is not a single data object.

Uses :meth:`~horizon.tables.DataTable.get_object_id` internally.
"""
matches = [datum for datum in self.data if
self.get_object_id(datum) == lookup]
if len(matches) > 1:
raise ValueError("Multiple matches were returned for that id: %s."
% matches)
if not matches:
raise exceptions.Http302(self.get_absolute_url(),
_('No match returned for the id "%s".')
% lookup)
return matches[0]

def get_table_actions(self):
""" Returns a list of the action instances for this table. """
bound_actions = [self.base_actions[action.name] for
action in self._meta.table_actions]
return [action for action in bound_actions if
self._filter_action(action, self._meta.request)]

def get_row_actions(self, datum):
""" Returns a list of the action instances for a specific row. """
bound_actions = []
for action in self._meta.row_actions:
# Copy to allow modifying properties per row
bound_action = copy.copy(self.base_actions[action.name])
bound_action.attrs = copy.copy(bound_action.attrs)
bound_action.datum = datum
# Remove disallowed actions.
if not self._filter_action(bound_action,
self._meta.request,
datum):
continue
# Hook for modifying actions based on data. No-op by default.
bound_action.update(self._meta.request, datum)
# Pre-create the URL for this link with appropriate parameters
if issubclass(bound_action.__class__, LinkAction):
bound_action.bound_url = bound_action.get_link_url(datum)
bound_actions.append(bound_action)
return bound_actions

def render_table_actions(self):
""" Renders the actions specified in ``Meta.table_actions``. """
template_path = self._meta.table_actions_template
table_actions_template = template.loader.get_template(template_path)
bound_actions = self.get_table_actions()
extra_context = {"table_actions": bound_actions}
if self._meta.filter:
extra_context["filter"] = self._meta._filter_action
context = template.RequestContext(self._meta.request, extra_context)
return table_actions_template.render(context)

def render_row_actions(self, datum):
"""
Renders the actions specified in ``Meta.row_actions`` using the
current row data. """
template_path = self._meta.row_actions_template
row_actions_template = template.loader.get_template(template_path)
bound_actions = self.get_row_actions(datum)
extra_context = {"row_actions": bound_actions,
"row_id": self.get_object_id(datum)}
context = template.RequestContext(self._meta.request, extra_context)
return row_actions_template.render(context)

@staticmethod
def parse_action(action_string):
"""
Parses the ``action`` parameter (a string) sent back with the
POST data. By default this parses a string formatted as
``{{ table_name }}__{{ action_name }}__{{ row_id }}`` and returns
each of the pieces. The ``row_id`` is optional.
"""
if action_string:
bits = action_string.split(STRING_SEPARATOR)
bits.reverse()
table = bits.pop()
action = bits.pop()
try:
object_id = bits.pop()
except IndexError:
object_id = None
return table, action, object_id

def take_action(self, action_name, obj_id=None, obj_ids=None):
"""
Locates the appropriate action and routes the object
data to it. The action should return an HTTP redirect
if successful, or a value which evaluates to ``False``
if unsuccessful.
"""
# See if we have a list of ids
obj_ids = obj_ids or self._meta.request.POST.getlist('object_ids')
action = self.base_actions.get(action_name, None)
if not action or action.method != self._meta.request.method:
# We either didn't get an action or we're being hacked. Goodbye.
return None

# Meanhile, back in Gotham...
if not action.requires_input or obj_id or obj_ids:
if obj_id:
obj_id = self.sanitize_id(obj_id)
if obj_ids:
obj_ids = [self.sanitize_id(i) for i in obj_ids]
# Single handling is easy
if not action.handles_multiple:
response = action.single(self, self._meta.request, obj_id)
# Otherwise figure out what to pass along
else:
# Preference given to a specific id, since that implies
# the user selected an action for just one row.
if obj_id:
obj_ids = [obj_id]
response = action.multiple(self, self._meta.request, obj_ids)
return response
elif action and action.requires_input and not (obj_id or obj_ids):
messages.info(self._meta.request,
_("Please select a row before taking that action."))
return None

@classmethod
def check_handler(cls, request):
""" Determine whether the request should be handled by this table. """
if request.method == "POST" and "action" in request.POST:
table, action, obj_id = cls.parse_action(request.POST["action"])
elif "table" in request.GET and "action" in request.GET:
table = request.GET["table"]
action = request.GET["action"]
obj_id = request.GET.get("obj_id", None)
else:
table = action = obj_id = None
return table, action, obj_id

def maybe_preempt(self):
"""
Determine whether the request should be handled by a preemptive action
on this table or by an AJAX row update before loading any data.
"""
request = self._meta.request
table_name, action_name, obj_id = self.check_handler(request)

if table_name == self.name:
# Handle AJAX row updating.
new_row = self._meta.row_class(self)
if new_row.ajax and new_row.ajax_action_name == action_name:
try:
datum = new_row.get_data(request, obj_id)
new_row.load_cells(datum)
error = False
except:
datum = None
error = exceptions.handle(request, ignore=True)
if request.is_ajax():
if not error:
return HttpResponse(new_row.render())
else:
return HttpResponse(status=error.status_code)

preemptive_actions = [action for action in
self.base_actions.values() if action.preempt]
if action_name:
for action in preemptive_actions:
if action.name == action_name:
handled = self.take_action(action_name, obj_id)
if handled:
return handled
return None

def maybe_handle(self):
"""
Determine whether the request should be handled by any action on this
table after data has been loaded.
"""
request = self._meta.request
table_name, action_name, obj_id = self.check_handler(request)
if table_name == self.name and action_name:
return self.take_action(action_name, obj_id)
return None

def sanitize_id(self, obj_id):
""" Override to modify an incoming obj_id to match existing
API data types or modify the format.
"""
return obj_id

def get_object_id(self, datum):
""" Returns the identifier for the object this row will represent.

By default this returns an ``id`` attribute on the given object,
but this can be overridden to return other values.

.. warning::

Make sure that the value returned is a unique value for the id
otherwise rendering issues can occur.
"""
return datum.id

def get_object_display(self, datum):
""" Returns a display name that identifies this object.

By default, this returns a ``name`` attribute from the given object,
but this can be overriden to return other values.
"""
return datum.name

def has_more_data(self):
"""
Returns a boolean value indicating whether there is more data
available to this table from the source (generally an API).

The method is largely meant for internal use, but if you want to
override it to provide custom behavior you can do so at your own risk.
"""
return self._meta.has_more_data

def get_marker(self):
"""
Returns the identifier for the last object in the current data set
for APIs that use marker/limit-based paging.
"""
return http.urlquote_plus(self.get_object_id(self.data[-1]))

def calculate_row_status(self, statuses):
"""
Returns a boolean value determining the overall row status
based on the dictionary of column name to status mappings passed in.

By default, it uses the following logic:

#. If any statuses are ``False``, return ``False``.
#. If no statuses are ``False`` but any or ``None``, return ``None``.
#. If all statuses are ``True``, return ``True``.

This provides the greatest protection against false positives without
weighting any particular columns.

The ``statuses`` parameter is passed in as a dictionary mapping
column names to their statuses in order to allow this function to
be overridden in such a way as to weight one column's status over
another should that behavior be desired.
"""
values = statuses.values()
if any([status is False for status in values]):
return False
elif any([status is None for status in values]):
return None
else:
return True

def get_row_status_class(self, status):
"""
Returns a css class name determined by the status value. This class
name is used to indicate the status of the rows in the table if
any ``status_columns`` have been specified.
"""
if status is True:
return "status_up"
elif status is False:
return "status_down"
else:
return "status_unknown"

def get_columns(self):
""" Returns this table's columns including auto-generated ones."""
return self.columns.values()

def get_rows(self):
""" Return the row data for this table broken out by columns. """
rows = []
try:
for datum in self.filtered_data:
rows.append(self._meta.row_class(self, datum))
except:
# Exceptions can be swallowed at the template level here,
# re-raising as a TemplateSyntaxError makes them visible.
LOG.exception("Error while rendering table rows.")
exc_info = sys.exc_info()
raise template.TemplateSyntaxError, exc_info[1], exc_info[2]
return rows

这篇关于tables-urls-views-forms处理工作流程-openstack E版的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/815233

相关文章

Python使用getopt处理命令行参数示例解析(最佳实践)

《Python使用getopt处理命令行参数示例解析(最佳实践)》getopt模块是Python标准库中一个简单但强大的命令行参数处理工具,它特别适合那些需要快速实现基本命令行参数解析的场景,或者需要... 目录为什么需要处理命令行参数?getopt模块基础实际应用示例与其他参数处理方式的比较常见问http

Java Response返回值的最佳处理方案

《JavaResponse返回值的最佳处理方案》在开发Web应用程序时,我们经常需要通过HTTP请求从服务器获取响应数据,这些数据可以是JSON、XML、甚至是文件,本篇文章将详细解析Java中处理... 目录摘要概述核心问题:关键技术点:源码解析示例 1:使用HttpURLConnection获取Resp

Java中Switch Case多个条件处理方法举例

《Java中SwitchCase多个条件处理方法举例》Java中switch语句用于根据变量值执行不同代码块,适用于多个条件的处理,:本文主要介绍Java中SwitchCase多个条件处理的相... 目录前言基本语法处理多个条件示例1:合并相同代码的多个case示例2:通过字符串合并多个case进阶用法使用

Java实现优雅日期处理的方案详解

《Java实现优雅日期处理的方案详解》在我们的日常工作中,需要经常处理各种格式,各种类似的的日期或者时间,下面我们就来看看如何使用java处理这样的日期问题吧,感兴趣的小伙伴可以跟随小编一起学习一下... 目录前言一、日期的坑1.1 日期格式化陷阱1.2 时区转换二、优雅方案的进阶之路2.1 线程安全重构2

将Java项目提交到云服务器的流程步骤

《将Java项目提交到云服务器的流程步骤》所谓将项目提交到云服务器即将你的项目打成一个jar包然后提交到云服务器即可,因此我们需要准备服务器环境为:Linux+JDK+MariDB(MySQL)+Gi... 目录1. 安装 jdk1.1 查看 jdk 版本1.2 下载 jdk2. 安装 mariadb(my

Python处理函数调用超时的四种方法

《Python处理函数调用超时的四种方法》在实际开发过程中,我们可能会遇到一些场景,需要对函数的执行时间进行限制,例如,当一个函数执行时间过长时,可能会导致程序卡顿、资源占用过高,因此,在某些情况下,... 目录前言func-timeout1. 安装 func-timeout2. 基本用法自定义进程subp

Java字符串处理全解析(String、StringBuilder与StringBuffer)

《Java字符串处理全解析(String、StringBuilder与StringBuffer)》:本文主要介绍Java字符串处理全解析(String、StringBuilder与StringBu... 目录Java字符串处理全解析:String、StringBuilder与StringBuffer一、St

浅析Java中如何优雅地处理null值

《浅析Java中如何优雅地处理null值》这篇文章主要为大家详细介绍了如何结合Lambda表达式和Optional,让Java更优雅地处理null值,感兴趣的小伙伴可以跟随小编一起学习一下... 目录场景 1:不为 null 则执行场景 2:不为 null 则返回,为 null 则返回特定值或抛出异常场景

深入理解Apache Kafka(分布式流处理平台)

《深入理解ApacheKafka(分布式流处理平台)》ApacheKafka作为现代分布式系统中的核心中间件,为构建高吞吐量、低延迟的数据管道提供了强大支持,本文将深入探讨Kafka的核心概念、架构... 目录引言一、Apache Kafka概述1.1 什么是Kafka?1.2 Kafka的核心概念二、Ka

Go 语言中的select语句详解及工作原理

《Go语言中的select语句详解及工作原理》在Go语言中,select语句是用于处理多个通道(channel)操作的一种控制结构,它类似于switch语句,本文给大家介绍Go语言中的select语... 目录Go 语言中的 select 是做什么的基本功能语法工作原理示例示例 1:监听多个通道示例 2:带