复习

"""
视图家族
1、视图类:APIView、GenericAPIView
APIView:作为drf的基础view;as_view()禁用csrf;dispatch()二次封装request、三大认证、解析、渲染、响应、异常等模块;一堆类属性,可以用来做全局或局部插拔配置
GenericAPIView:继承APIView;三个方法三个属性(obj,queryset,serializer) 2、视图工具集:mixin五大工具类(六个方法)
list:群查
retrieve:单查
create:单增
destroy:单删
update:单整体改
partial_update:单局部改
前提:工具类都是由GenericAPIView的子类来继承 3、工具视图:Generic各种子类
ListAPIView(ListModelMixin, GenericAPIView):继承该类的视图类,只需要提供几个类属性,就可以完成群查,不需要书写get方法
ListCreateAPIView(ListModelMixin, CreateModelMixin, GenericAPIView) 4、视图集:ViewSet、GenericViewSet
ViewSetMixin:重写as_view(),可以将请求方法与视图类中的自定义函数名完成映射
as_view({'get': 'list', 'post': 'my_post'}) GenericViewSet:可以自定义请求映射的Model操作视图集 ViewSet:可以自定义请求映射的任意操作视图集(一般与Model操作不是那么密切相关)
登陆的post并非新增、短信的验证码(get或post)都和model无关
"""

前期准备

创建django项目,应用名api;

创建数据库,django:1.settings中修改连接mysql配置,2.__init__文件中import pymysql pymysql.install_as_MySQLdb(),测试连接;

settings.py中注册app 'rest_framework' ; 修改LANGUAGE_CODE = 'zh-hans' ,TIME_ZONE = 'Asia/Shanghai' ,USE_TZ = False,配置media路径MEDIA_URL = '/media/' ,MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

路由分发项目路由re_path(r'^api/', include('api.urls')), re_path(r'^media/(?P.*)', serve, {'document_root': settings.MEDIA_ROOT}),

路由分发应用api下的创建url.py

根目录下创建utils, 两个文件夹exception.py写自定义异常和response.py写自定义响应

根目录下创建script,写脚本测试文件,

根目录下创建media

三大认证简介

# 基于用户权限访问控制的认证 - RBAC - Role-Based Access Control
# 自己了解:基于auth的认证规则 # Django框架采用的是RBAC认证规则,RBAC认证规则通常会分为 三表规则、五表规则,Django采用的是六表规则 # 三表:用户表、角色表、权限表
# 五表:用户表、角色表、权限表、用户角色关系表、角色权限关系表
# 六表:用户表、角色表、权限表、用户角色关系表、角色权限关系表、用户权限关系表

APIView中的dispatch方法self.initial(request, *args, **kwargs)

AbstracUser源码分析

自定义user表继承AbstracUser
1.from django.contrib.auth.models import AbstractUser
class User(AbstractUser):
pass
2.settings文件夹中配置
AUTH_USER_MODEL = 'api.User' 点击AbstracUser进入看源码,定位文件
在资源文件models.py中,有基础的三表:Group类,Permission类,User(AbstractUser)
1.先查看Group类:group角色拥有权限 class Group(models.Model):
# permissions权限,在这里就是角色group拥有的权限
permissions = models.ManyToManyField( #多对多
Permission, #类名
verbose_name=_('permissions'),
blank=True,
) 2.查看User类
class User(AbstractUser):
.....
点击AbstractUser
class AbstractUser(AbstractBaseUser, PermissionsMixin):
.....
点击AbstractBaseUser,。。。
点击PermissionsMixin,最终在这找到了groups,user_permissions
class PermissionsMixin(models.Model):
"""
Add the fields and methods necessary to support the Group and Permission
models using the ModelBackend.
"""
is_superuser = models.BooleanField(
_('superuser status'),
default=False,
help_text=_(
'Designates that this user has all permissions without '
'explicitly assigning them.'
),
)
groups = models.ManyToManyField(
Group, #类名
verbose_name=_('groups'),
blank=True,
help_text=_( #文本提示
'The groups this user belongs to. A user will get all permissions '
'granted to each of their groups.'
),
related_name="user_set", #反向查询的字段
related_query_name="user",
)
#用户权限关系表
user_permissions = models.ManyToManyField(
Permission,
verbose_name=_('user permissions'),
blank=True,
help_text=_('Specific permissions for this user.'),
related_name="user_set", #反向查询字段
related_query_name="user",
) class Meta:
abstract = True
#(用户表与角色表的多对多的关键字段在User表中,用户表与权限表的多对多的关键字段在User表中)
# 用户表:正向查询角色表字段groups,正向查询用户权限表字段user_permissions
#(角色表与权限表的多对多字段在Group表中)
# 角色表:反向查询用户表字段user_set,正向查询角色权限表字段permissions
# 权限表:反向查询用户表字段user_set,反向查询角色表字段group_set

自定义User下的权限六表

models.py

from django.db import models

# Create your models here.

from django.contrib.auth.models import AbstractUser

class User(AbstractUser):
mobile = models.CharField(max_length=11, unique=True) class Meta:
db_table = 'api_user'
verbose_name = '用户表'
verbose_name_plural = verbose_name def __str__(self):
return self.username

到settings.py中注册

# 配置自定义user表
AUTH_USER_MODEL = 'api.User'

注意点:

# 重点:如果自定义User表后,再另一个项目中采用原生User表,完成数据库迁移时,可能失败
# 1)卸载Django重新装
# 2)将django.contrib下面的admin、auth下的数据库迁移记录文件清空 补充:全局配置
class APIView(View): # The following policies may be set at either globally, or per-view.
renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES
parser_classes = api_settings.DEFAULT_PARSER_CLASSES
authentication_classes = api_settings.DEFAULT_AUTHENTICATION_CLASSES
throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES
permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES
content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS
metadata_class = api_settings.DEFAULT_METADATA_CLASS
versioning_class = api_settings.DEFAULT_VERSIONING_CLASS 以上以这个为例renderer_classes=[..]这是自定义类中的局部配置,全局配置就是
点击api_settings,APISettings实例化的对象
api_settings = APISettings(None, DEFAULTS, IMPORT_STRINGS)
DEFAULTS点击:发现是系统的默认配置,
IMPORT_STRINGS是自己的settings.py的文件路径
点击APISettings:
def __init__(self, user_settings=None, defaults=None, import_strings=None):产生的实例化

执行数据迁移的俩条命令

python manage.py mekamigrations

python manage.py migrate

auth_permission这张表codename就是权限的名字,content_type_id就是属于哪张表的权限 , django_content_type这张表的里的app_label就是应用名,model字段就是对应的一张表

创建超级用户

Tools中执行命令createsuperuser

数据库中的auth_group添加数据,api_user_groups绑定两者关系

在测试文件t_models.py中进行测试

t_model.py

# django脚本话启动
import os, django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dg_proj.settings")
django.setup() from api import models user = models.User.objects.first()
# print(user.username)
# print(user.groups.first().name)
# print(user.user_permissions.first().name) from django.contrib.auth.models import Group
group = Group.objects.first()
# print(group.name)
# print(group.user_set.first().username)
# print(group.permissions.first().name) from django.contrib.auth.models import Permission
p_16 = Permission.objects.filter(pk=16).first()
# print(p_16.user_set.first().username)
# p_17 = Permission.objects.filter(pk=17).first()
# print(p_17.group_set.first().name)

数据库各表录入数据

源码分析


1)url.py路由re_path(r'^test/$', views.TestAPIView.as_view()), view.py视图class TestAPIView(APIView):pass 路由访问TestAPIView的as_view()方法,TestAPIView没有,父类APIView获取,as_view()返回csrf_exempt(view)禁用csrf,而view是view = super(APIView, cls).as_view(**initkwargs)调用父类的View的方法,走View中的view,然后到dispatch的时候走回自己的APIView的dispatch方法,三大认证模块 self.initial(request, *args, **kwargs)入口,在此之前request = self.initialize_request(request, *args, **kwargs)已经封装了
APIView的dispatch(self, request, *args, **kwargs)
2)dispath方法内 self.initial(request, *args, **kwargs) 进入三大认证
# 认证组件:校验用户 - 游客、合法用户、非法用户
# 游客:代表校验通过,直接进入下一步校验(权限校验)
# 合法用户:代表校验通过,将用户存储在request.user中,再进入下一步校验(权限校验)
# 非法用户:代表校验失败,抛出异常,返回403权限异常结果
self.perform_authentication(request)(认证通过才会走下面的认证) # 权限组件:校验用户权限 - 必须登录、所有用户、登录读写游客只读、自定义用户角色
# 认证通过:可以进入下一步校验(频率认证)
# 认证失败:抛出异常,返回403权限异常结果
self.check_permissions(request) # 频率组件:限制视图接口被访问的频率次数 - 限制的条件(IP、id、唯一键)、频率周期时间(s、m、h)、频率的次数(3/s)
# 没有达到限次:正常访问接口
# 达到限次:限制时间内不能访问,限制时间达到后,可以重新访问
self.check_throttles(request) 3) 点击认证组件self.perform_authentication(request),返回的request.user,request是drf封装的request对象,request.user觉得是登录用户,但是认证的时候没有用户,所以是属性或者是封装成属性方法,然后再资源drf的request.py文件中的Request类中的user(self)方法(self是request的对象,所以是直接拿到前端发来的数据),还要一个user(self,value)这个是设置值,所以user(self)才是获取值
if not hasattr(self, '_user'):# 判断是否有用户
with wrap_attributeerrors():
#没有用户认证出用户
self._authenticate()
#有用户直接返回用户 ,如果是游客的话request.user = AnonymousUser,所以也是有值的
return self._user 点击self._authenticate()
Request类的 方法属性 user 的get方法 => self._authenticate() 完成认证
# 做认证
def _authenticate(self):
# 遍历拿到一个个认证器,进行认证
# self.authenticators配置的一堆认证类产生的认证类对象组成的 list
for authenticator in self.authenticators:
try:
# 认证器(对象)调用认证方法authenticate(认证类对象self, request请求对象)
# 返回值:登陆的用户与认证的信息组成的 tuple
# 该方法被try包裹,代表该方法会抛异常,抛异常就代表认证失败
user_auth_tuple = authenticator.authenticate(self)
except exceptions.APIException:
self._not_authenticated()
raise # 返回值的处理
if user_auth_tuple is not None:
self._authenticator = authenticator
# 如何有返回值,就将 登陆用户 与 登陆认证 分别保存到 request.user、request.auth
self.user, self.auth = user_auth_tuple
return
# 如果返回值user_auth_tuple为空,代表认证通过,但是没有 登陆用户 与 登陆认证信息,代表游客
self._not_authenticated() 点击self.authenticators查看不了,回到APIView中的dispatch方法二次封装request的地方
request = self.initialize_request(request, *args, **kwargs) ,点击进入,
return Request(
request,
parsers=self.get_parsers(),
#认证产生
authenticators=self.get_authenticators(),
negotiator=self.get_content_negotiator(),
parser_context=parser_context
)
点击 authenticators=self.get_authenticators() 返回return [auth() for auth in self.authentication_classes]
authentication_classes可以是局部设置,也可以settings中全局设置 全局设置settings.py
# drf配置
REST_FRAMEWORK = {
# 认证类配置
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.SessionAuthentication',
'rest_framework.authentication.BasicAuthentication',
],
}
找到资源文件authentication文件中的SessionAuthentication类重写的
def authenticate(self, request): # Get the session-based user from the underlying HttpRequest object
#原生django的request中获取user
user = getattr(request._request, 'user', None)
#拿用户,用户如果为空或非活跃状态就返回空,代表游客,不需要csrf校验
# Unauthenticated, CSRF validation not required
if not user or not user.is_active:
return None #解析出用户,重新启用csrf认证,如果csrf认证失败,就会出现异常,就是非法用户
self.enforce_csrf(request) # CSRF passed with authenticated user
#csrf认证通过,代表合法用户
return (user, None) 找到资源文件authentication文件中的BasicAuthentication类重写的
class BasicAuthentication(BaseAuthentication):
"""
HTTP Basic authentication against username/password.
"""
www_authenticate_realm = 'api' def authenticate(self, request):
"""
Returns a `User` if a correct username and password have been supplied
using HTTP Basic authentication. Otherwise returns `None`.
"""
#获取认证信息auth是元组
auth = get_authorization_header(request).split() if not auth or auth[0].lower() != b'basic': #二进制
return None #代表游客 if len(auth) == 1: #长度等于一,代表认证信息错误,抛异常
msg = _('Invalid basic header. No credentials provided.')
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:#长度大于二,代表认证信息错误,抛异常
msg = _('Invalid basic header. Credentials string should not contain spaces.')
raise exceptions.AuthenticationFailed(msg) try:
#做处理
auth_parts = base64.b64decode(auth[1]).decode(HTTP_HEADER_ENCODING).partition(':')
except (TypeError, UnicodeDecodeError, binascii.Error):
#错误的话就抛异常
msg = _('Invalid basic header. Credentials not correctly base64 encoded.')
raise exceptions.AuthenticationFailed(msg)
#将用户和密码解析出来
userid, password = auth_parts[0], auth_parts[2]
#将userid, password, request丢进去
return self.authenticate_credentials(userid, password, request) #return self.authenticate_credentials(userid, password, request)
#将userid, password, request=None传入
def authenticate_credentials(self, userid, password, request=None):
"""
Authenticate the userid and password against username and password
with optional request for context.
"""
credentials = {
get_user_model().USERNAME_FIELD: userid,
'password': password
}
#获取user
user = authenticate(request=request, **credentials)
#如果用户为空抛异常
if user is None:
raise exceptions.AuthenticationFailed(_('Invalid username/password.'))
#用户为非活跃
if not user.is_active:
raise exceptions.AuthenticationFailed(_('User inactive or deleted.'))
#返回合法user
return (user, None)

自定义认证类

"""
1) 创建继承BaseAuthentication的认证类
2) 实现authenticate方法
3) 实现体根据认证规则 确定游客、非法用户、合法用户
4) 进行全局或局部配置 认证规则
i.没有认证信息返回None(游客)
ii.有认证信息认证失败抛异常(非法用户)
iii.有认证信息认证成功返回用户与认证信息元组(合法用户)
"""
api / urls.py

from django.urls import re_path
from . import views
urlpatterns = [ re_path(r'^test/$', views.TestAPIView.as_view()),
]
api / views.py
from django.shortcuts import render

# Create your views here.
from rest_framework.views import APIView
from utils.response import APIResponse class TestAPIView(APIView):
def get(self, request, *args, **kwargs):
print(request.user)
return APIResponse(0, 'test get ok ')
settings.py
# drf配置
REST_FRAMEWORK = {
# 全局配置异常模块
'EXCEPTION_HANDLER': 'utils.exception.exception_handler',
# 认证类配置
'DEFAULT_AUTHENTICATION_CLASSES': [
# 'rest_framework.authentication.SessionAuthentication',
# 'rest_framework.authentication.BasicAuthentication',
'api.authentications.MyAuthentication',
], }
utils/authentications.py
# 自定义认证类

# 1)继承BaseAuthentication类
# 2)重新authenticate(self, request)方法,自定义认证规则
# 3)认证规则基于的条件:
# 没有认证信息返回None(游客)
# 有认证信息认证失败抛异常(非法用户)
# 有认证信息认证成功返回用户与认证信息元组(合法用户)
# 4)完全视图类的全局(settings文件中)或局部(确切的视图类)配置
from rest_framework.authentication import BaseAuthentication
from rest_framework.exceptions import AuthenticationFailed
from . import models
class MyAuthentication(BaseAuthentication):
"""
同前台请求头拿认证信息auth(获取认证的字段要与前台约定)
没有auth是游客,返回None
有auth进行校验
失败是非法用户,抛出异常
成功是合法用户,返回 (用户, 认证信息)
"""
def authenticate(self, request):
# 前台在请求头携带认证信息,
# 且默认规范用 Authorization 字段携带认证信息,
# 后台固定在请求对象的META字段中 HTTP_AUTHORIZATION 获取
auth = request.META.get('HTTP_AUTHORIZATION', None) # 处理游客
if auth is None:
return None # 设置一下认证字段小规则(两段式):"auth 认证字符串"
auth_list = auth.split() # 校验合法还是非法用户
if not (len(auth_list) == 2 and auth_list[0].lower() == 'auth'):
raise AuthenticationFailed('认证信息有误,非法用户') # 合法的用户还需要从auth_list[1]中解析出来
# 注:假设一种情况,信息为abc.123.xyz,就可以解析出admin用户;实际开发,该逻辑一定是校验用户的正常逻辑
if auth_list[1] != 'abc.123.xyz': # 校验失败
raise AuthenticationFailed('用户校验失败,非法用户') user = models.User.objects.filter(username='admin').first() if not user:
raise AuthenticationFailed('用户数据有误,非法用户')
return (user, None)
# 家庭作业
# 1) 可以采用脚本基于auth组件创建三个普通用户:models.User.objects.create_user()
# 注:直接写出注册接口更好
# 2) 自定义session表:id,u_id,token,为每个用户配置一个固定人认证字符串,可以直接操作数据库
# 注:在注册接口中实现更好
# 3) 自定义认证类,不同的token可以校验出不同的登陆用户

权限类源码

APIView中的dispatch方法,然后就是self.initial(request, *args, **kwargs),点击self.check_permissions(request)
4) 权限组件
self.check_permissions(request)
认证细则:
def check_permissions(self, request):
# 遍历权限对象列表得到一个个权限对象(权限器),进行权限认证
for permission in self.get_permissions():
# 权限类一定有一个has_permission权限方法,用来做权限认证的
# 参数:权限对象self、请求对象request、视图类对象
# 返回值:有权限返回True,无权限返回False
if not permission.has_permission(request, self):
self.permission_denied(
request, message=getattr(permission, 'message', None)

系统权限类


# 因为默认全局配置的权限类是AllowAny
# settings.py
REST_FRAMEWORK = {
# 权限类配置
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.AllowAny',
'rest_framework.permissions.IsAuthenticated',
'rest_framework.permissions.IsAdminUser',
'rest_framework.permissions.IsAuthenticatedOrReadOnly',
],
} 查找permissions.py中的以下四个类
AllowAny,IsAuthenticated,IsAdminUser,IsAuthenticatedOrReadOnly
分析他们各自的功能,在settings文件中配置全局,或视图类中可局部permission_classes = [MyPermission]
"""
1)AllowAny:
认证规则全部返还True:return True
游客与登陆用户都有所有权限 2) IsAuthenticated:
认证规则必须有登陆的合法用户:return bool(request.user and request.user.is_authenticated)
游客没有任何权限,登陆用户才有权限 3) IsAdminUser:
认证规则必须是后台管理用户:return bool(request.user and request.user.is_staff)
游客没有任何权限,登陆用户才有权限 4) IsAuthenticatedOrReadOnly
认证规则必须是只读请求或是合法用户:
return bool(
request.method in SAFE_METHODS or
request.user and
request.user.is_authenticated
)
游客只读,合法用户无限制
"""

自定义权限类(在utils文件下创建permissions.py)

"""
1) 创建继承BasePermission的权限类
2) 实现has_permission方法
3) 实现体根据权限规则 确定有无权限
4) 进行全局或局部配置 认证规则
i.满足设置的用户条件,代表有权限,返回True
ii.不满足设置的用户条件,代表有权限,返回False
"""
# utils/permissions.py
from rest_framework.permissions import BasePermission
from django.contrib.auth.models import Group
class MyPermission(BasePermission):
def has_permission(self, request, view):
# 只读接口判断
r1 = request.method in ('GET', 'HEAD', 'OPTIONS')
# group为有权限的分组
group = Group.objects.filter(name='管理员').first()
# groups为当前用户所属的所有分组
groups = request.user.groups.all()
r2 = group and groups
r3 = group in groups
# 读接口大家都有权限,写接口必须为指定分组下的登陆用户
return r1 or (r2 and r3)
api/urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^test/$', views.TestAPIView.as_view()),
url(r'^test1/$', views.TestAuthenticatedAPIView.as_view()),
url(r'^test2/$', views.TestAuthenticatedOrReadOnlyAPIView.as_view()),
url(r'^test3/$', views.TestAdminOrReadOnlyAPIView.as_view()),
]
settings.py
# drf配置
REST_FRAMEWORK = {
# 认证类配置
'DEFAULT_AUTHENTICATION_CLASSES': [
'api.authentications.MyAuthentication',
], }
api/ views.py
from rest_framework.views import APIView
from utils.response import APIResponse # 只有登录后才能访问
from rest_framework.permissions import IsAuthenticated
class TestAuthenticatedAPIView(APIView):
permission_classes = [IsAuthenticated] def get(self, request, *args, **kwargs):
return APIResponse(0, 'test 登录才能访问的接口 ok') # 游客只读,登录无限制
from rest_framework.permissions import IsAuthenticatedOrReadOnly
class TestAuthenticatedOrReadOnlyAPIView(APIView):
permission_classes = [IsAuthenticatedOrReadOnly] def get(self, request, *args, **kwargs):
return APIResponse(0, '读 OK') def post(self, request, *args, **kwargs):
return APIResponse(0, '写 OK') # 游客只读,登录用户只读,只有登录用户属于 管理员 分组,才可以增删改
from .permissions import MyPermission
class TestAdminOrReadOnlyAPIView(APIView):
permission_classes = [MyPermission] def get(self, request, *args, **kwargs):
return APIResponse(0, '自定义读 OK') def post(self, request, *args, **kwargs):
return APIResponse(0, '自定义写 OK')

drf 权限认证的更多相关文章

  1. python 全栈开发,Day97(Token 认证的来龙去脉,DRF认证,DRF权限,DRF节流)

    昨日内容回顾 1. 五个葫芦娃和三行代码 APIView(views.View) 1. 封装了Django的request - request.query_params --> 取URL中的参数 ...

  2. DRF之权限认证,过滤分页,异常处理

    1. 认证Authentication 在配置文件中配置全局默认的认证方案 REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': ( 'rest_f ...

  3. DRF(4) - 认证、权限组件

    一.引入 通过前面三节课的学习,我们已经详细了解了DRF提供的几个重要的工具,DRF充分利用了面向对象编程的思想,对Django的View类进行了继承,并封装了其as_view方法和dispatch方 ...

  4. DRF之权限认证频率组件

    概要 retrieve方法源码剖析 认证组件的使用方式及源码剖析 权限组件的使用方式及源码剖析 频率组件的使用方式及源码剖析 知识点复习回顾 Python逻辑运算 知识点复习回顾一:Python逻辑运 ...

  5. DRF的认证,频率,权限

    1,DRF的认证 初识认证:浏览器是无状态的,一次导致每次发的请求都是新的请求,所以每次请求,服务器都会进行校验,这样就很繁琐,这趟我们就需要给每一个用户登录后一个新的标识,浏览器每次都会带着这个唯一 ...

  6. 8) drf 三大认证 认证 权限 频率

    一.三大认证功能分析 1)APIView的 dispath(self, request, *args, **kwargs) 2)dispath方法内 self.initial(request, *ar ...

  7. drf三大认证:认证组件-权限组件-权限六表-自定义认证组件的使用

    三大认证工作原理简介 认证.权限.频率 源码分析: from rest_framework.views import APIView 源码分析入口: 内部的三大认证方法封装: 三大组件的原理分析: 权 ...

  8. DRF 版本 认证

    DRF的版本 版本控制是做什么用的, 我们为什么要用 首先我们要知道我们的版本是干嘛用的呢大家都知道我们开发项目是有多个版本的 当我们项目越来越更新~版本就越来越多我们不可能新的版本出了~以前旧的版本 ...

  9. DRF 权限的流程

    DRF 权限的流程 django rest framework,入口是 dispatch,然后依次 --->>封装请求--->>处理版本--->>>认证--- ...

随机推荐

  1. 4K手机能拯救索尼手机吗?

    智能手机屏幕分辨率究竟达到多少才是极限,一直是业内争论不休的问题.从低分辨率一路走来,直到iPhone 4搭载视网膜屏,业内才有了一个较为统一的认知:屏幕起码要在合适距离下看不到文字.图像虚影,才称得 ...

  2. kettle_errot_karafLifecycleListenter

    使用kettle 6.1 通过命令行批量执行作业的过程中,发现偶尔有作业执行时间会变慢几分钟,查看日志发现改作业开始就报了一个错 报错之后才会继续下面的作业,虽然不影响最终作业执行结果,但也延误了一些 ...

  3. swap和shm的区别

    在使用docker的过程中,发现其有很多内存相关的命令,对其中的swap(交换内存)和shm(共享内存)尤其费解.于是查阅了一些资料,弄明白了二者的基本区别. swap 是一个文件,是使用硬盘空间的一 ...

  4. Design Patterns in Android

    对日常在 Android 中实用设计模式进行一下梳理和总结,文中参考了一些网站和大佬的博客,如 MichaelX(xiong_it) .菜鸟教程.四月葡萄.IAM四十二等,在这里注明下~另外强烈推荐图 ...

  5. sed 分组替换

    将文件以help开头的句子前加# [root@localhost]# cat a.txthelp b helphelp1helphelp2help c help[root@localhost]# se ...

  6. 初学Qt——vs2012开发环境下的窗体跳转

    最近接了份外快,要求使用vs+qt开发一个简单的数据管理系统.qt开发使用的语言是c++,然而c++只是大一第二学期有教过而已,基本也差不多忘光了,废话不多说,讲下今天遇到的问题吧 如标题所说,窗体跳 ...

  7. Spring Security基于Oauth2的SSO单点登录怎样做?一个注解搞定

    一.说明 单点登录顾名思义就是在多个应用系统中,只需要登录一次,就可以访问其他相互信任的应用系统,免除多次登录的烦恼.本文主要介绍 同域 和 跨域 两种不同场景单点登录的实现原理,并使用 Spring ...

  8. sql -- update表子查询、多条件判断case when

    表结构: 需求 思路: 求出平均数 select avg(user_total) as avg from user_level 更新他的等级 update user_level set user_ra ...

  9. 计算机思维的逻辑基础是什么? & 计算思维

    l  计算机思维的逻辑基础: 计算机思维是指人们操作计算机时,计算机行使特定功能的运作方式. 逻辑基础则是指支撑事物运作的基本法则. 因而,计算机思维的逻辑基础可以理解为,计算机在行使特定功能时,其运 ...

  10. YiGo表单建立

    做一个请假单表单(下图是最后的成品图) 表单的类型 实体表单 1.可存储 2.可编辑 虚拟表单 视图(不可存储数据,只有显示功能) 不可编辑 字典 报表 备注 :一张表单是实体还是虚拟取决于其数据对象 ...