socket编程

什么是socket

  • 定义

socket通常也称作套接字，用于描述IP地址和端口，是一个通信链的句柄，应用程序通常通过套接字向网络发出请求或者应答网络请求。

socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，对于文件用【打开】【读写】【关闭】模式来操作。socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）

  • socket和file的区别：

    • file模块是针对某个指定文件进行【打开】【读写】【关闭】
    • socket模块是针对 服务器端 和 客户端Socket 进行【打开】【读写】【关闭】

  • python相关

Python 提供了两个基本的 socket 模块。py2位大写，py3全部小写
第一个是 Socket，它提供了标准的 BSD Sockets API。
第二个是 SocketServer， 它提供了服务器中心类，可以简化网络服务器的开发

socket编程实现

  • 流程图：



  • 说明：

    • 服务端

      1.服务端需要导入socket模块，并创建套接字(实例化为一个对象)

      import socket
      
s = socket.socket()

      2.绑定套接字s到本地IP和端口

      ip_port = ('127.0.0.1',8080)
      
s.bind(ip_port)

      3.监听连接

      s.listen(0)

PS：0表示缓冲区可挂起的连接数量 0表示不限制，1表示 可挂起一个，那么意思就是连接一个、挂起一个，第三个再连接的话，就无法连接，会超时

      4.接收客户端建立连接的请求

      conn,addr = s.accept()
      
PS：conn为一个客户端和服务器建立的连接，addr为客户端ip

      5.接收客户端的消息，并做相应处理

      recv_data = conn.recv(1024)
      
send_data = recv_data.upper()  ＃将客户端发送的内容转换为大写，注意。python3里面客户端发送的都是二进制数据，python2里可以发送字符串

      6.给客户端回消息

      conn.send(send_data)

      7.关闭连接

      conn.close()

    • 客户端
      1.创建套接字

      import socket

s = socket.socket()

      2.连接服务端

      ip_port = ('127.0.0.1',8080)
      
s.connect(ip_port)

      3.给服务端发送消息

      send_data = input('请输入: ')
      
s.send(send_data.encode())  ＃注意py3发送的数据需要转换为二进制，不能直接发送字符串

      4.接收服务端消息，并打印

      recv_data = s.recv(1024)
      
print(recv_data.decode())  ＃服务端回应的是二进制，所以需要转换为字符串

      5.关闭连接

      s.close()

以上就是一个简单的客户端和服务端socket连接，并发送消息，读消息，回消息的过程，初学者可能一下子就懵了，请看下面的类比，

  • 类比

    通过上面的服务端和客户端的一个简单的交互，可以将其比作打电话，小明是服务端，小红是客户端

    • 小明

      1. 小明为了接收电话，他首先得买个手机，此步骤类同创建socket套接字
      2. 小明有了手机，需要办一张电话卡，此步骤类同绑定套接字搭配监听的ip和端口
      3. 小明有了手机和电话卡，则手机开机，处于待机状态 此步骤类同监听客户端连接
      4. 当小红打电话进来之后，需要接电话，此类同于接收客户端建立连接的请求

    • 小红

      1. 小红在和小明打电话前得有个通信工具等等，所以需要找到一部手机，类同创建一个套接字
      2. 小红需要知道小明的电话号码，并拨打电话，此步骤就等于客户端连接服务端

    • 小红和小明交互

    小红：你好 此时小红是发消息，小明此时处于收消息的状态
    小明：你好 小明收到小红发的你好消息，做出回应，此时小明开始给小红发消息，小红处于收消息状态
    最后小红收到了小明的消息，小明此时已经挂断电话，最后此次通信已断

    

    注意此次通信只是一个简单的交互过程，交互完成之后，则先完成方会主动关系连接。如果要持续通信，请继续往下看

  • 实现服务端保持连接，不受客户端断开而断开，并实现客户端和服务端持续交互过程

服务端

import socket

ip_port = ('127.0.0.1',8080)

s = socket.socket()

s.bind(ip_port)

s.listen(0)

while True:    ＃此次while循环用于客户端断开连接之后，重新循环建立新连接

    conn,addr = s.accept()

    while True:    ＃此while循环用于客户端和服务器持续交互

       recv_data = conn.recv(1024)

       if not recv_data: break   ＃判断消息是否为空，当消息为空时，跳出循环，如果不判断的话，客户端那边如果主动断开连接，将会导致服务端处于一个不停的收消息的死循环中，因为连接已断开，处于非阻塞状态

       send_data = recv_data.upper()  ＃将客户消息转换为大写

       conn.send(send_data)

    conn.close()

客户端：

import socket

s = socket.socket()

ip_port = ('127.0.0.1',8080)

s.connect(ip_port)

while True:

    send_data = input('请输入: ')

    if send_data == 'exit':break

    elif send_data == '':continue

    s.send(send_data.encode())

    recv_data = s.recv(1024)

    print(recv_data.decode())

s.close()

运行服务端和客户端，效果如下：

请输入: hello

HELLO

请输入: Jeck

JECK

请输入: 123

123

请输入:

请输入: exit

Process finished with exit code 0

socket模块功能

  • socket 类型

    socket.socket(socket.AF_INET,socket.SOCK_STREAM,0)

    • 参数一：地址簇
      　　 socket.AF_INET IPv4（默认）
      　　 socket.AF_INET6 IPv6
      　　 socket.AF_UNIX 只能够用于单一的Unix系统进程间通信

    • 参数二：类型
      　　socket.SOCK_STREAM　　流式socket , for TCP （默认）
      　　socket.SOCK_DGRAM　　 数据报式socket , for UDP
      　　socket.SOCK_RAW 原始套接字，普通的套接字无法处理ICMP、IGMP等网络报文，而SOCK_RAW可以；其次，SOCK_RAW也可以处理特殊的IPv4报文；此外，利用原始套接字，可以通过IP_HDRINCL套接字选项由用户构造IP头。
      　　socket.SOCK_RDM 是一种可靠的UDP形式，即保证交付数据报但不保证顺序。SOCK_RAM用来提供对原始协议的低级访问，在需要执行某些特殊操作时使用，如发送ICMP报文。SOCK_RAM通常仅限于高级用户或管理员运行的程序使用。
      　　socket.SOCK_SEQPACKET 可靠的连续数据包服务

    • 参数三：协议

　 　0　　（默认）与特定的地址家族相关的协议,如果是 0 ，则系统就会根据地址格式和套接类别,自动选择一个合适的协议

  • socket方法

    • sk.bind(address)

    将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

    • sk.listen(backlog)
      　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5,这个值不能无限大，因为要在内核中维护连接队列

    • sk.setblocking(bool)

    是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

    • sk.accept()

    接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。
    接收TCP 客户的连接（阻塞式）等待连接的到来

    • sk.connect(address)

    连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

    • sk.connect_ex(address)

    同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

    • sk.close()

    关闭套接字

    • sk.recv(bufsize[,flag])

    接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略

    • sk.recvfrom(bufsize[.flag])

    与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

    • sk.send(string[,flag])

    将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

    • sk.sendall(string[,flag])

    将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。内部通过递归调用send，将所有内容发送出去。

    • sk.sendto(string[,flag],address)

    将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

    • sk.settimeout(timeout)

    设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

    • sk.getpeername()

    返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

    • sk.getsockname()

    返回套接字自己的地址。通常是一个元组(ipaddr,port)

    • sk.fileno()

　　套接字的文件描述符

  • 案例：模拟ssh

    • 服务端：
import socket

import  subprocess

ip_port = ('127.0.0.1',8080)

s = socket.socket()

s.bind(ip_port)

s.listen(0)

while True:

    conn,addr = s.accept()

    while True:

        try:

            recv_data = conn.recv(1024)

            if not recv_data: break

            p = subprocess.Popen(str(recv_data,encoding='utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)    ＃执行shell命令，并将标准输出和错误输出放到缓冲区

            res = p.stdout.read()

            if not res:

                send_data = p.stderr.read()

            else:

                send_data = res

            data_size = len(send_data)

            conn.send(send_data)

        except Exception:

            break

    conn.close()
* 客户端


import socket

ip_port = ('127.0.0.1',8080)

s = socket.socket()

s.connect(ip_port)

while True:

    send_data = input('>>:  ')

    if send_data == 'exit':exit()

    elif not send_data:continue

    s.send(bytes(send_data,encoding='utf-8'))

    recv_data = s.recv(1024)

    print(recv_data.decode())

s.close()

执行结果：

>>:  df -h

Filesystem      Size  Used Avail Use% Mounted on

/dev/disk1      112G   51G   62G  45% /

>>:  netstat -lnt

Active Internet connections

Proto Recv-Q Send-Q  Local Address          Foreign Address        (state)

tcp4       0      0  172.16.23.42.57334     23.83.227.252.8023     ESTABLISHED

tcp4       0      0  127.0.0.1.1080         127.0.0.1.57333        ESTABLISHED

tcp4       0      0  127.0.0.1.57333        127.0.0.1.1080         ESTABLISHED

tcp4       0      0  127.0.0.1.8080         127.0.0.1.57332        ESTABLISHED

tcp4       0      0  127.0.0.1.57332        127.0.0.1.8080         ESTABLISHED

tcp4       0      0  172.16.23.42.57328     223.252.199.7.80       CLOSE_WAIT

tcp4       0      0  172.16.23.42.57269     163.177.72.143.993     ESTABLISHED

tcp4       0      0  10.255.0.10.57047      203.130.45.175.9000    ESTABLISHED

tcp4      27      0  172.16.23.42.57045     163.177.90.125.993     CLOSE_WAIT

tcp4       0      0  172.16.23.42.56988     114.215.186.163.443    ESTABLISHED

tcp4      27      0  172.16.23.42.56632     163.177.72.143.993     CLOSE_WAIT

tcp4       0      0  10.255.0.10.56374      10.2

>>:  route -n

0.7.12.22          ESTABLISHED

tcp4      27      0  172.16.23.42.56229     163.177.90.125.993     CLOSE_WAIT

tcp4       0      0  10.255.0.10.54889      203.130.45.175.9000    ESTABLISHED

tcp4       0      0  10.255.0.10.54605      203.130.45.173.6929    ESTABLISHED

tcp4       0      0  10.255.0.10.53228      10.20.7.12.22          ESTABLISHED

tcp4       0      0  10.255.0.10.53122      203.130.45.175.9000    ESTABLISHED

tcp4       0      0  172.16.23.42.52902     42.62.89.250.1194      ESTABLISHED

tcp4       0      0  127.0.0.1.1337         127.0.0.1.52901        ESTABLISHED

tcp4       0      0  127.0.0.1.52901        127.0.0.1.1337         ESTABLISHED

tcp4       0      0  172.16.23.42.52899     17.172.232.10.5223     ESTABLISHED

tcp4       0      0  172.16.23.42.52855     17.252.236.157.5223    ESTABLISHED

tcp4       0      0  172.16.23.42.52790     223.252.199.6.6003     ESTABLISHED

tcp4       0      0  172.16.23.42.50124     223.167.82.210.80      ESTABLISHED

tcp4       0      0  172.16.23.42.50026     1

从结果中发现，执行df -h 返回正常结果，执行netstat -lnt返回了一半的结果，继续执行命令，仍然返回的是netstat －lnt的结果，这就发生了粘包现象

  • 粘包解决

    所谓粘包现象就是服务端把数据发过来之后，客户端接收时会按一定大小来接收，决定此操作的是s.recv(1024)，1024是每次接收的包大小，第一次没有接收完的话，第二次会继续接收原来的数据包，这就是粘包现象，解决办法就是，服务端在发送数据时，现告诉客户端本次数据的大小，然后再发送数据，客户端收到数据大小之后，循环接收数据，知道接收完成再终止此次循环，这样就可以拿到所有的数据，解决了粘包现象

    • 服务端改造：
#!/usr/bin/env python

# -*- coding: UTF-8 -*-

#pyversion:python3.5

#owner:fuzj

import socket

import  subprocess

ip_port = ('127.0.0.1',8080)

s = socket.socket()

s.bind(ip_port)

s.listen(0)

while True:

    conn,addr = s.accept()

    while True:

        try:

            recv_data = conn.recv(1024)

            if not recv_data: break

            p = subprocess.Popen(str(recv_data,encoding='utf-8'),shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)

            res = p.stdout.read()

            if not res:

                send_data = p.stderr.read()

            else:

                send_data = res

            data_size = len(send_data)   ＃计算数据大小

            conn.send(bytes(str(data_size),encoding='utf-8'))  ＃发送数据大小

            res = conn.recv(1024)  ＃接收客户端状态

            conn.send(send_data)   ＃发送数据

        except Exception:

            break

    conn.close()
* 客户端改造：


import socket

ip_port = ('127.0.0.1',8080)

s = socket.socket()

s.connect(ip_port)

while True:

    send_data = input('>>:  ')

    if send_data == 'exit':exit()

    elif not send_data:continue

    s.send(bytes(send_data,encoding='utf-8'))

    recv_size = 0

    data = b''

    data_size = str(s.recv(1024),encoding='utf-8')  ＃接收数据大小

    s.send(bytes('ok',encoding='utf-8'))  ＃发送此时的状态

    while recv_size < int(data_size):    ＃循环接收数据，直到接收完所有数据

        recv_data = s.recv(1024)

        data += recv_data

        recv_size += len(recv_data)

    print(str(data,encoding='utf-8'))

s.close()

运行结果：发现已经解决上述问题

>>:  df -h

Filesystem      Size  Used Avail Use% Mounted on

/dev/disk1      112G   51G   62G  45% /

>>:  netstat -lnt

Active Internet connections

Proto Recv-Q Send-Q  Local Address          Foreign Address        (state)

tcp4       0      0  172.16.23.42.57476     223.252.199.7.80       CLOSE_WAIT

tcp4       0      0  127.0.0.1.8080         127.0.0.1.57475        ESTABLISHED

tcp4       0      0  127.0.0.1.57475        127.0.0.1.8080         ESTABLISHED

tcp4       0      0  172.16.23.42.57474     223.252.199.7.80       LAST_ACK

tcp4       0      0  172.16.23.42.57465     23.83.227.252.8023     ESTABLISHED

tcp4       0      0  127.0.0.1.1080         127.0.0.1.57464        ESTABLISHED

tcp4       0      0  127.0.0.1.57464        127.0.0.1.1080         ESTABLISHED

tcp4       0      0  172.16.23.42.57461     23.83.227.252.8023     ESTABLISHED

tcp4       0      0  127.0.0.1.1080         127.0.0.1.57460        ESTABLISHED

tcp4       0      0  127.0.0.1.57460        127.0.0.1.1080         ESTABLISHED

tcp4       0      0  172.16.23.42.57455     163.177.72.143.993     CLOSE_WAIT

tcp4       0      0  10.255.0.10.57047      203.130.45.175.9000    ESTABLISHED

tcp4      27      0  172.16.23.42.57045     163.177.90.125.993     CLOSE_WAIT

tcp4       0      0  172.16.23.42.56988     114.215.186.163.443    ESTABLISHED

tcp4      27      0  172.16.23.42.56632     163.177.72.143.993     CLOSE_WAIT

tcp4       0      0  10.255.0.10.56374      10.20.7.12.22          ESTABLISHED

tcp4      27      0  172.16.23.42.56229     163.177.90.125.993     CLOSE_WAIT

tcp4       0      0  10.255.0.10.54889      203.130.45.175.9000    ESTABLISHED

tcp4       0      0  10.255.0.10.54605      203.130.45.173.6929    ESTABLISHED

tcp4       0      0  10.255.0.10.53228      10.20.7.12.22          ESTABLISHED

tcp4       0      0  10.255.0.10.53122      203.130.45.175.9000    ESTABLISHED

tcp4       0      0  172.16.23.42.52902     42.62.89.250.1194      ESTABLISHED

tcp4       0      0  127.0.0.1.1337         127.0.0.1.52901        ESTABLISHED

tcp4       0      0  127.0.0.1.52901        127.0.0.1.1337         ESTABLISHED

tcp4       0      0  172.16.23.42.52899     17.172.232.10.5223     ESTABLISHED

tcp4       0      0  172.16.23.42.52855     17.252.236.157.5223    ESTABLISHED

tcp4       0      0  172.16.23.42.52790     223.252.199.6.6003     ESTABLISHED

tcp4       0      0  172.16.23.42.50124     223.167.82.210.80      ESTABLISHED

tcp4       0      0  172.16.23.42.50026     123.151.10.187.14000   ESTABLISHED

tcp4       0      0  172.16.23.42.49612     163.177.90.125.993     ESTABLISHED

tcp4       0      0  127.0.0.1.49871        127.0.0.1.49375        ESTABLISHED

tcp4       0      0  127.0.0.1.49375        127.0.0.1.49871        ESTABLISHED

tcp4       0      0  127.0.0.1.49871        127.0.0.1.49370        ESTABLISHED

tcp4       0      0  127.0.0.1.49370        127.0.0.1.49871        ESTABLISHED

tcp4       0      0  192.168.123.164.49282  112.90.83.61.443       ESTABLISHED

socketserver 实现支持多客户端

上述ssh模拟客户端只能支持一定数量的客户端，受s.listen(0)参数限制。下面可以实现支持多客户端操作

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求



  • ThreadingTCPServer

    ThreadingTCPServer实现的Soket服务器内部会为每个client创建一个 “线程”，该线程用来和客户端进行交互

  • 实现步骤：

    • 1.创建一个类，并继承SocketServer.BaseRequestHandler 的类
    • 2.在新类中需要创建一个handle的方法
    • 3.启动ThreadingTCPServer

代码如下：

import socketserver

import subprocess

class MyServer(socketserver.BaseRequestHandler):  ＃继承

    def handle(self):   ＃handle方法。注意此时send和recv时调用的self.request方法

        self.request.sendall(bytes('Welcome',encoding='utf-8'))

        while True:

            try:

                recv_data = self.request.recv(1024)

                if not recv_data: break

                p = subprocess.Popen(str(recv_data, encoding='utf-8'), shell=True, stdout=subprocess.PIPE,stderr=subprocess.PIPE)

                res = p.stdout.read()

                if not res:

                    send_data = p.stderr.read()

                else:

                    send_data = res

                if not send_data:

                    send_data = 'no output'.encode()

                data_size = len(send_data)

                self.request.send(bytes(str(data_size), encoding='utf-8'))

                self.request.recv(1024)

                self.request.send(send_data)

            except Exception:

                break

if __name__ == '__main__':

    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)    ＃启动server

    server.serve_forever()

PS:SocketServer.BaseRequestHandler类源码：其定义了三个方法:setup(),handle()he finish()
执行顺序为：setup(0-->handle()-->finish()
```

class BaseRequestHandler:

def __init__(self, request, client_address, server):

    self.request = request

    self.client_address = client_address

    self.server = server

    self.setup()

    try:

        self.handle()

    finally:

        self.finish()

def setup(self):

    pass

def handle(self):

    pass

def finish(self):

    pass

SocketServer.BaseRequestHandler

```

  • ThreadingTCPServer源码剖析



  • 内部调用流程

    • 启动服务端程序
    • 执行 TCPServer.__init__ 方法，创建服务端Socket对象并绑定 IP 和 端口
    • 执行 BaseServer.__init__ 方法，将自定义的继承自SocketServer.BaseRequestHandler 的类 MyRequestHandle赋值给 self.RequestHandlerClass
    • 执行 BaseServer.server_forever 方法，While 循环一直监听是否有客户端请求到达 ...
    • 当客户端连接到达服务器
    • 执行 ThreadingMixIn.process_request 方法，创建一个 “线程” 用来处理请求
    • 执行 ThreadingMixIn.process_request_thread 方法
    • 执行 BaseServer.finish_request 方法，执行 self.RequestHandlerClass() 即：执行 自定义 MyRequestHandler 的构造方法（自动调用基类BaseRequestHandler的构造方法，在该构造方法中又会调用 MyRequestHandler的handle方法）

socket编程基础的更多相关文章

  1. socket编程基础-字节序/IP/PORT转换/域名

    socket编程基础 网络IP操作函数 字符串的IP和32位的IP转换 #include <sys/socket.h> #inlcude <netinet/in.h> #inc ...

  2. c#socket编程基础

    Microsoft.Net Framework为应用程序访问Internet提供了分层的.可扩展的以及受管辖的网络服务,其名字空间System.Net和System.Net.Sockets包含丰富的类 ...

  3. Java从零开始学四十五（Socket编程基础)

    一.网络编程中两个主要的问题 一个是如何准确的定位网络上一台或多台主机,另一个就是找到主机后如何可靠高效的进行数据传输. 在TCP/IP协议中IP层主要负责网络主机的定位,数据传输的路由,由IP地址可 ...

  4. java socket编程基础（转）

    一,网络编程中两个主要的问题 一个是如何准确的定位网络上一台或多台主机,另一个就是找到主机后如何可靠高效的进行数据传输. 在TCP/IP协议中IP层主要负责网络主机的定位,数据传输的路由,由IP地址可 ...

  5. Python学习笔记——基础篇【第七周】———FTP作业（面向对象编程进阶 & Socket编程基础）

    FTP作业 本节内容: 面向对象高级语法部分 Socket开发基础 作业:开发一个支持多用户在线的FTP程序 面向对象高级语法部分 参考:http://www.cnblogs.com/wupeiqi/ ...

  6. 【转】Java Socket编程基础及深入讲解

    原文:https://www.cnblogs.com/yiwangzhibujian/p/7107785.html#q2.3.3 Socket是Java网络编程的基础,了解还是有好处的, 这篇文章主要 ...

  7. 【Socket】Java Socket编程基础及深入讲解

    Socket是Java网络编程的基础,了解还是有好处的, 这篇文章主要讲解Socket的基础编程.Socket用在哪呢,主要用在进程间,网络间通信.本篇比较长,特别做了个目录: 一.Socket通信基 ...

  8. 你得学会并且学得会的Socket编程基础知识

    这一篇文章,我将图文并茂地介绍Socket编程的基础知识,我相信,如果你按照步骤做完实验,一定可以对Socket编程有更好地理解. 本文源代码,可以通过这里下载 http://files.cnblog ...

  9. Java Socket编程基础篇

    原文地址:Java Socket编程----通信是这样炼成的 Java最初是作为网络编程语言出现的,其对网络提供了高度的支持,使得客户端和服务器的沟通变成了现实,而在网络编程中,使用最多的就是Sock ...

  10. 【socket编程基础模板】

    网络编程的基础是基于socket编程.socket(TCP)编程基于固定编程模板 server端: socket(声明socket类型) bind(命令socket,绑定地址和端口) listen(创 ...

随机推荐

  1. django中html过滤器filter

    http://blog.csdn.net/iloveyin/article/details/49560559 safe让Html标签以及一些特殊符号(如<)生效,下面以例子说明: # value ...

  2. SQL SERVER中关于OR会导致索引扫描或全表扫描的浅析

    在SQL SERVER的查询语句中使用OR是否会导致不走索引查找(Index Seek)或索引失效(堆表走全表扫描 (Table Scan).聚集索引表走聚集索引扫描(Clustered Index ...

  3. SQL SERVER 2000 迁移后SQL SERVER代理服务启动错误分析

    公司有一个老系统,这个系统所用的数据库是SQL SERVER 2000,它所在的Dell服务器已经运行超过10年了,早已经过了保修服务期,最近几乎每周会出现一次故障,加之5月份另外一台服务器坏了两个硬 ...

  4. WINDOWS登录系统之前（欢迎界面）运行指定程序脚本服务

    方法一:创建可在系统登录之前运行的服务 PS:需要用到两个程序—Srvany和Instsrv,点击 http://pan.baidu.com/share/link?shareid=4111024491 ...

  5. JVM之运行时常量池（Runtime Constant Pool）

    基本特性: 方法区的一部分,在方法去中分配,加载泪或者接口后就创建运行时常量区. class文件每一个类或接口的常量池表(constant_pool table)的运行时表现形式, 包括编译期的数值字 ...

  6. SQL Server 2008 R2——使用FOR XML PATH实现多条信息按指定格式在一行显示

    =================================版权声明================================= 版权声明:原创文章 谢绝转载  请通过右侧公告中的“联系邮 ...

  7. WPF 自定义Expander

    自定义Exander,收缩侧边栏 样式如下 <Grid> <Grid.Resources> <ControlTemplate x:Key="ExpanderCo ...

  8. Linux & Systemd 挂载问题解决

    1. 方法一: Create the following file as root: /etc/polkit-/rules.d/-nopasswd_global.rules /* Allow memb ...

  9. Window下python2.7+Apache+mod_wsgi+Django服务器配置

    前言:试着使用python搭建一个网页,分别在windows下和linux下,本篇文章主要讲解Window下python+Apache+mod_wsgi+Django服务器配置过程中遇见的问题和解决方 ...

  10. Web报表工具JS开发之日期校验

    在报表开发过程中,我们常常需要对查询界面进行日期校验.例如有两个参数:开始日期和结束日期,我们要校验的是:开始日期与结束日期不能为空,结束日期必须在开始日期之后以及结束日期必须在开始日期后的某个时间段 ...