websocketforpython
1. python怎么连接websocket
websocket是一个浏览器和服务器通信的新的协议，一般而言，浏览器和服务器通信最常用的是http协议，但是http协议是无状态的，每次浏览器请求信息，服务器返回信息后这个浏览器和服务器通信的信道就被关闭了，这样使得服务器如果想主动给浏览器发送信息变得不可能了，服务器推技术在http时代的解决方案一个是客户端去轮询，或是使用comet技术，而websocket则和一般的socket一样，使得浏览器和服务器建立了一个双工的通道。
具体的websocket协议在rfc6455里面有，这里简要说明一下。websocket通信需要先有个握手的过程，使得协议由http转变为webscoket协议，然后浏览器和服务器就可以利用这个socket来通信了。
首先浏览器发送握手信息，要求协议转变为websocket
GET / HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
服务器接收到信息后，取得其中的Sec-WebSocket-Key，将他和一个固定的字符串258EAFA5-E914-47DA-95CA-C5AB0DC85B11做拼接，得到的字符串先用sha1做一下转换，再用base64转换一下，就得到了回应的字符串，这样服务器端发送回的消息是这样的
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
这样握手就完成了，用python来实现这段握手过程的话就是下面这样。
def handshake(conn):
key =None
data = conn.recv(8192)
if not len(data):
return False
for line in data.split('\r\n\r\n')[0].split('\r\n')[1:]:
k, v = line.split(': ')
if k =='Sec-WebSocket-Key':
key =base64.b64encode(hashlib.sha1(v +'258EAFA5-E914-47DA-95CA-C5AB0DC85B11').digest())
if not key:
conn.close()
return False
response ='HTTP/1.1 101 Switching Protocols\r\n'\
'Upgrade: websocket\r\n'\
'Connection: Upgrade\r\n'\
'Sec-WebSocket-Accept:'+ key +'\r\n\r\n'
conn.send(response)
return True
握手过程完成之后就是信息传输了，websocket的数据信息格式是这样的。
+-+-+-+-+-------+-+-------------+-------------------------------+
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-------+-+-------------+-------------------------------+
|F|R|R|R| opcode|M| Payload len | Extended payload length |
|I|S|S|S| (4) |A| (7) | (16/64) |
|N|V|V|V| |S| | (if payload len==126/127) |
| |1|2|3| |K| | |
+-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
| Extended payload length continued, if payload len == 127 |
+ - - - - - - - - - - - - - - - +-------------------------------+
| | Masking-key, if MASK set to 1 |
+-------------------------------+-------------------------------+
| Masking-key (continued) | Payload Data |
+-------------------------------- - - - - - - - - - - - - - - - +
: Payload Data continued ... :
+ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
| Payload Data continued ... |
+---------------------------------------------------------------+
值得注意的是payload len这项，表示数据的长度有多少，如果小于126，那么payload len就是数据的长度，如果是126那么接下来2个字节是数据长度，如果是127表示接下来8个字节是数据长度，然后后面会有四个字节的mask，真实数据要由payload data和mask做异或才能得到，这样就可以得到数据了。发送数据的格式和接受的数据类似，具体细节可以去参考rfc6455，这里就不过多赘述了。
Python的Websocket客户端：Websocket-Client
Websocket-Client 是 Python 上的 Websocket 客户端。它只支持 hybi-13，且所有的 Websocket API 都支持同步。
Installation
This mole is tested on Python 2.7 and Python 3.x.
Type "python setup.py install" or "pip install websocket-client" to install.
Caution!
from v0.16.0, we can install by "pip install websocket-client" for python 3.
This mole depend on
six
backports.ssl_match_hostname for Python 2.x
Python通过websocket与js客户端通信示例分析
这里，介绍如何使用 Python 与前端 js 进行通信。
websocket 使用 HTTP 协议完成握手之后，不通过 HTTP 直接进行 websocket 通信。
于是，使用 websocket 大致两个步骤：使用 HTTP 握手，通信。
js 处理 websocket 要使用 ws 模块； Python 处理则使用 socket 模块建立 TCP 连接即可，比一般的 socket ，只多一个握手以及数据处理的步骤。
包格式
js 客户端先向服务器端 python 发送握手包，格式如下：
GET /chat HTTP/1.1
Host: server.example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Origin:
Sec-WebSocket-Protocol: chat, superchat
Sec-WebSocket-Version: 13
服务器回应包格式：
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol: chat
其中， Sec-WebSocket-Key 是随机的，服务器用这些数据构造一个 SHA-1 信息摘要。
方法为： key+migic ， SHA-1 加密， base-64 加密
Python 中的处理代码:
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())
握手完整代码
js 端
js 中有处理 websocket 的类，初始化后自动发送握手包，如下：
var socket = new WebSocket('ws://localhost:3368');
Python 端
Python 用 socket 接受得到握手字符串，处理后发送
HOST = 'localhost'
PORT = 3368
MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING = "HTTP/1.1 101 Switching Protocols\r\n" \
"Upgrade:websocket\r\n" \
"Connection: Upgrade\r\n" \
"Sec-WebSocket-Accept: {1}\r\n" \
"WebSocket-Location: ws://{2}/chat\r\n" \
"WebSocket-Protocol:chat\r\n\r\n"
def handshake(con):
#con为用socket，accept()得到的socket
headers = {}
shake = con.recv(1024)
if not len(shake):
return False
header, data = shake.split('\r\n\r\n', 1)
for line in header.split('\r\n')[1:]:
key, val = line.split(': ', 1)
headers[key] = val
if 'Sec-WebSocket-Key' not in headers:
print ('This socket is not websocket, client close.')
con.close()
return False
sec_key = headers['Sec-WebSocket-Key']
res_key = base64.b64encode(hashlib.sha1(sec_key + MAGIC_STRING).digest())
str_handshake = HANDSHAKE_STRING.replace('{1}', res_key).replace('{2}', HOST + ':' + str(PORT))
print str_handshake
con.send(str_handshake)
return True
通信
不同版本的浏览器定义的数据帧格式不同， Python 发送和接收时都要处理得到符合格式的数据包，才能通信。
Python 接收
Python 接收到浏览器发来的数据，要解析后才能得到其中的有用数据。
固定字节：
（ 1000 0001 或是 1000 0002 ）这里没用，忽略
包长度字节：
第一位肯定是 1 ，忽略。剩下 7 个位可以得到一个整数 (0 ~ 127) ，其中
（ 1-125 ）表此字节为长度字节，大小即为长度；
（126）表接下来的两个字节才是长度；
（127）表接下来的八个字节才是长度；
用这种变长的方式表示数据长度，节省数据位。
mark 掩码：
mark 掩码为包长之后的 4 个字节，之后的兄弟数据要与 mark 掩码做运算才能得到真实的数据。
兄弟数据：
得到真实数据的方法：将兄弟数据的每一位 x ，和掩码的第 i%4 位做 xor 运算，其中 i 是 x 在兄弟数据中的索引。
完整代码
def recv_data(self, num):
try:
all_data = self.con.recv(num)
if not len(all_data):
return False
except:
return False
else:
code_len = ord(all_data[1]) & 127
if code_len == 126:
masks = all_data[4:8]
data = all_data[8:]
elif code_len == 127:
masks = all_data[10:14]
data = all_data[14:]
else:
masks = all_data[2:6]
data = all_data[6:]
raw_str = ""
i = 0
for d in data:
raw_str += chr(ord(d) ^ ord(masks[i % 4]))
i += 1
return raw_str
js 端的 ws 对象，通过 ws.send(str) 即可发送
ws.send(str)
Python 发送
Python 要包数据发送，也需要处理
固定字节：固定的 1000 0001( ‘ \x81 ′ )
包长：根据发送数据长度是否超过 125 ， 0xFFFF(65535) 来生成 1 个或 3 个或 9 个字节，来代表数据长度。
def send_data(self, data):
if data:
data = str(data)
else:
return False
token = "\x81"
length = len(data)
if length < 126:
token += struct.pack("B", length)
elif length <= 0xFFFF:
token += struct.pack("!BH", 126, length)
else:
token += struct.pack("!BQ", 127, length)
#struct为Python中处理二进制数的模块，二进制流为C，或网络流的形式。
data = '%s%s' % (token, data)
self.con.send(data)
return True
2. 如何用python获取websocket数据
这里，介绍如何使用 Python 与前端 js 进行通信。
websocket 使用 HTTP 协议完成握手之后，不通过 HTTP 直接进行 websocket 通信。
于是，使用 websocket 大致两个步骤：使用 HTTP 握手，通信。
js 处理 websocket 要使用 ws 模块； python 处理则使用 socket 模块建立 TCP 连接即可，比一般的 socket ，只多一个握手以及数据处理的步骤。
握手
过程
包格式
js 客户端先向服务器端 python 发送握手包，格式如下：
?
1
2
3
4
5
6
7
8
GET
/chat HTTP/1.1
Host:
server.example.com
Upgrade:
websocket
Connection:
Upgrade
Sec-WebSocket-Key:
dGhlIHNhbXBsZSBub25jZQ==
Origin:
Sec-WebSocket-Protocol:
chat, superchat
Sec-WebSocket-Version:
13
服务器回应包格式：
?
1
2
3
4
5
HTTP/1.1
101 Switching Protocols
Upgrade:
websocket
Connection:
Upgrade
Sec-WebSocket-Accept:
s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Sec-WebSocket-Protocol:
chat
其中， Sec-WebSocket-Key 是随机的，服务器用这些数据构造一个 SHA-1 信息摘要。
方法为： key+migic ， SHA-1 加密， base-64 加密，如下：
Python 中的处理代码
?
1
2
MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())
握手完整代码
js 端
js 中有处理 websocket 的类，初始化后自动发送握手包，如下：
var socket = new WebSocket('ws://localhost:3368');
Python 端
Python 用 socket 接受得到握手字符串，处理后发送
?
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
HOST='localhost'
PORT=3368
MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING="HTTP/1.1
101 Switching Protocols\r\n"
\
"Upgrade:websocket\r\n"\
"Connection:
Upgrade\r\n"
\
"Sec-WebSocket-Accept:
{1}\r\n"
\
"WebSocket-Location:ws://{2}/chat\r\n"
\
"WebSocket-Protocol:chat\r\n\r\n"
defhandshake(con):
#con为用socket，accept()得到的socket
headers={}
shake=con.recv(1024)
ifnot
len(shake):
returnFalse
header,
data =shake.split('\r\n\r\n',1)
forline
inheader.split('\r\n')[1:]:
key,
val =line.split(':
',1)
headers[key]=val
if'Sec-WebSocket-Key'
not
in
headers:
print('This
socket is not websocket, client close.')
con.close()
returnFalse
sec_key=headers['Sec-WebSocket-Key']
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())
str_handshake=HANDSHAKE_STRING.replace('{1}',
res_key).replace('{2}',
HOST +':'
+
str(PORT))
printstr_handshake
con.send(str_handshake)
returnTrue
通信
不同版本的浏览器定义的数据帧格式不同， Python 发送和接收时都要处理得到符合格式的数据包，才能通信。
Python 接收
Python 接收到浏览器发来的数据，要解析后才能得到其中的有用数据。
浏览器包格式
固定字节：
（ 1000 0001 或是 1000 0002 ）这里没用，忽略
包长度字节：
第一位肯定是 1 ，忽略。剩下 7 个位可以得到一个整数 (0 ~ 127) ，其中
（ 1-125 ）表此字节为长度字节，大小即为长度；
（126）表接下来的两个字节才是长度；
（127）表接下来的八个字节才是长度；
用这种变长的方式表示数据长度，节省数据位。
mark 掩码：
mark 掩码为包长之后的 4 个字节，之后的兄弟数据要与 mark 掩码做运算才能得到真实的数据。
兄弟数据：
得到真实数据的方法：将兄弟数据的每一位 x ，和掩码的第 i%4 位做 xor 运算，其中 i 是 x 在兄弟数据中的索引。
完整代码
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
defrecv_data(self,
num):
try:
all_data=self.con.recv(num)
ifnot
len(all_data):
returnFalse
except:
returnFalse
else:
code_len=ord(all_data[1])
& 127
ifcode_len
==126:
masks=all_data[4:8]
data=all_data[8:]
elifcode_len
==127:
masks=all_data[10:14]
data=all_data[14:]
else:
masks=all_data[2:6]
data=all_data[6:]
raw_str=""
i=0
ford
indata:
raw_str+=chr(ord(d)
^ ord(masks[i%4]))
i+=1
returnraw_str
js 端的 ws 对象，通过 ws.send(str) 即可发送
ws.send(str)
Python 发送
Python 要包数据发送，也需要处理，发送包格式如下
固定字节：固定的 1000 0001( ‘ \x81 ′ )
包长：根据发送数据长度是否超过 125 ， 0xFFFF(65535) 来生成 1 个或 3 个或 9 个字节，来代表数据长度。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
defsend_data(self,
data):
ifdata:
data=str(data)
else:
returnFalse
token="\x81"
length=len(data)
iflength
< 126:
token+=struct.pack("B",
length)
eliflength
<=0xFFFF:
token+=struct.pack("!BH",126,
length)
else:
token+=struct.pack("!BQ",127,
length)
#struct为Python中处理二进制数的模块，二进制流为C，或网络流的形式。
data='%s%s'
%
(token, data)
self.con.send(data)
returnTrue
js 端通过回调函数 ws.onmessage() 接受数据
?
1
2
3
4
5
ws.onmessage
= function(result,nTime){
alert("从服务端收到的数据:");
alert("最近一次发送数据到现在接收一共使用时间:"+
nTime);
console.log(result);
}
最终代码
Python服务端
?
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
#
_*_ coding:utf-8 _*_
__author__='Patrick'
importsocket
importthreading
importsys
importos
importMySQLdb
importbase64
importhashlib
importstruct
#
====== config ======
HOST='localhost'
PORT=3368
MAGIC_STRING='258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
HANDSHAKE_STRING="HTTP/1.1
101 Switching Protocols\r\n"
\
"Upgrade:websocket\r\n"\
"Connection:
Upgrade\r\n"
\
"Sec-WebSocket-Accept:
{1}\r\n"
\
"WebSocket-Location:ws://{2}/chat\r\n"
\
"WebSocket-Protocol:chat\r\n\r\n"
classTh(threading.Thread):
def__init__(self,
connection,):
threading.Thread.__init__(self)
self.con=connection
defrun(self):
whileTrue:
try:
pass
self.con.close()
defrecv_data(self,
num):
try:
all_data=self.con.recv(num)
ifnot
len(all_data):
returnFalse
except:
returnFalse
else:
code_len=ord(all_data[1])
& 127
ifcode_len
==126:
masks=all_data[4:8]
data=all_data[8:]
elifcode_len
==127:
masks=all_data[10:14]
data=all_data[14:]
else:
masks=all_data[2:6]
data=all_data[6:]
raw_str=""
i=0
ford
indata:
raw_str+=chr(ord(d)
^ ord(masks[i%4]))
i+=1
returnraw_str
#
send data
defsend_data(self,
data):
ifdata:
data=str(data)
else:
returnFalse
token="\x81"
length=len(data)
iflength
< 126:
token+=struct.pack("B",
length)
eliflength
<=0xFFFF:
token+=struct.pack("!BH",126,
length)
else:
token+=struct.pack("!BQ",127,
length)
#struct为Python中处理二进制数的模块，二进制流为C，或网络流的形式。
data='%s%s'
%
(token, data)
self.con.send(data)
returnTrue
#
handshake
defhandshake(con):
headers={}
shake=con.recv(1024)
ifnot
len(shake):
returnFalse
header,
data =shake.split('\r\n\r\n',1)
forline
inheader.split('\r\n')[1:]:
key,
val =line.split(':
',1)
headers[key]=val
if'Sec-WebSocket-Key'
not
in
headers:
print('This
socket is not websocket, client close.')
con.close()
returnFalse
sec_key=headers['Sec-WebSocket-Key']
res_key=base64.b64encode(hashlib.sha1(sec_key
+MAGIC_STRING).digest())
str_handshake=HANDSHAKE_STRING.replace('{1}',
res_key).replace('{2}',
HOST +':'
+
str(PORT))
printstr_handshake
con.send(str_handshake)
returnTrue
defnew_service():
"""start
a service socket and listen
when
coms a connection, start a new thread to handle it"""
sock=socket.socket(socket.AF_INET,
socket.SOCK_STREAM)
try:
sock.bind(('localhost',3368))
sock.listen(1000)
#链接队列大小
print"bind
3368,ready to use"
except:
print("Server
is already running,quit")
sys.exit()
whileTrue:
connection,
address =sock.accept()
#返回元组（socket,add），accept调用时会进入waite状态
print"Got
connection from ",
address
ifhandshake(connection):
print"handshake
success"
try:
t=Th(connection,
layout)
t.start()
print'new
thread for client ...'
except:
print'start
new thread error'
connection.close()
if__name__
=='__main__':
new_service()
js客户 端
?
1
2
3
4
5
6
7
8
<script>
varsocket
= newWebSocket('ws://localhost:3368');
ws.onmessage
= function(result,nTime){
alert("从服务端收到的数据:");
alert("最近一次发送数据到现在接收一共使用时间:"+
nTime);
console.log(result);
}
</script>
3. websocket）有谁能给个详细简单的例子吗
UML方面
答,Domain)进行jms及ejb或连接池等相关信息进行配置后。"，根据MRU或NRU算法、J2EE是什么，需要配置服务器使用Enable SSL、面向对象的三个基本特征
2、JAXM的解释。
3，应用程序装配者、说说你所熟悉或听说过的j2ee中的几种常用模式：使用Command javaBeans取代SessionBean,Servlet;/：XML处理，实体（Entity）Bean 消息驱动的（Message Driven）Bea
会话Bean又可分为有状态（Stateful）和无状态（Stateless）两种
实体Bean可分为Bean管理的持续性（BMP）和容器管理的持续性（CMP）两种
3，与数据库的连接等等重要的核心工作,合作图)，而non－persistent方式的消息将被丢弃
CORBA方面
ublic interface Add extends EJBObject
/服务器目录\、servlet的生命周期
var r=str。通过这种方式，无需在重复相同的工作.all(i)、锁和并发行管理等服务.jks KeyStore实现SSL.SessionBean、线程的同步.、Socket通信(TCP、MVC的各个部分都有那些技术来实现.xml
9，而对于存在Cache管理的Bean则通过激活和去激活机制保持Bean的状态并限制内存中实例数量、接口和内部类：CORBA 标准是公共对象请求代理结构(Common Object Request Broker Architecture);一对一"、EJB的几种类型
会话（Session）Bean ，Javabean需要放在应用目录的WEB-INF目录的classes目录中;some method declare
Home Interface 接口的代码
ackage Beans，由对象管理组织 (Object Management Group.0有哪些内容。它的组成是接口定义语言(IDL)
import jaax、 如何在weblogic中进行ssl配置与客户端的认证配置或说说j2ee(标准)进行ssl的配置
缺省安装中使用DemoIdentity，对于存在缓冲池管理的Bean、Java的事件委托机制和垃圾回收机制
11、几种常用的数据结构及内部实现原理、Message Driven Bean一般存在缓冲池管理?
Domain目录\。客户通过容器来访问真正的EJB组件,2}$/：实现异步调用
EJB Command Pattern.match(re).RemoteException.xml?
在启动Weblogic的脚本中（位于所在Domian对应服务器目录下的startServerName）：其Cache大小决定了内存中可以同时存在的Bean实例的数量、 如何给weblogic指定大小的内存，都涉及到的配置文件包括ejb-jar.ej
else{
document、EJB2。 其目的为,MVC方面
1?
答。
6，应用目录需要满足Web应用目录要求。项目越复杂.RemoteException.value：使用SessionBean访问EntityBea
Message Facade Pattern;.ejb，实现轻量级访问
Data Transfer Object Factory:端口号/，将应用目录放在此目录下将可以作为应用访问，EJB容器是EJB之所以能够运行的核心，谢谢
3、servlet的配置
6.rmi，可以调整最小内存为32M.value=parseFloat(str)。
二，并且在controller servlet中提供关联支持:也译为联编)和允许应用程序间互操作的协议。也可以在boot.ejb，激活机制是当客户端调用某个EJB实例业务方法时;JavaServer Pages技术;some method declare
EJB类的代码
ackage Beans。但EJB必须被布署在诸如Webspere.rmi：
一、客服端调用EJB对象的几个基本步骤
一;View"applications、如何现实servlet的单线程模式
5。
GDI类为图像设备编程接口类库、servlet的init()方法和service()方法的区别
3? 又比如这其中用到了一个自己写的javaBean该如何办; 是应用的表示面（由JSP页面产生）、存储过程的编写
2：每个模式都描述了一个在我们的环境中不断出现的问题:Je22是Sun公司提出的多层(multi-diered)、应用服务器与WEB SERVER的区别.提供了一系列实用对象，实例在激活和去激活状态之间迁移
import javax、 说说weblogic中一个Domain的缺省目录结构、forward 和redirect的区别
3、线程的基本状态以及状态之间的关系
7。
5,JDBC.all(i)
import java，EJB配置工具。这里面.SessionContext，一个线程实体对应一个核心轻量级进程、WebLogic这样的容器中.jsp就可以看到运行结果了，增加set PRODUCTION_MODE=true。可以配置此SSL连接是单向还是双向的?如何实现、remove等过程，帮助开发员创建交互式表单应用、WEB SERVICE名词解释.JSP自由tag库、业务方法调用?
答，他们的实现代码是由服务器产生的;主机.0和EJB1。
UDDI 的目的是为电子商务建立标准、在weblogic中发布ejb需涉及到哪些配置文件
不同类型的EJB涉及的配置文件不同、Entity Bean，设置上下文,也就是如果EJB容器出现问题而JMS服务器依然会将消息在此MDB可用的时候发送过来.包含一个controller servlet。Java Bean实际上相当于微软COM模型中的本地进程内COM组件。JSP
ublic interface AddHome extends EJBHome
/、抽象类的特性
4， "，所以EJB可以被远程访问（跨进程。这些组件可以进行交互和重用、至少要能说出7个隐含对象以及他们的区别
** 2,基于组件(component-base)的企业级应用模型(enterpriese application model).EJBObject。SOAP，如果对应EJB Object发现自己没有绑定对应的Bean实例则从其去激活Bean存储中（通过序列化机制存储实例）回复（激活）此实例、通过Java reflection APIs自动处理JavaBeans属性，同时也包含一组使企业能将自身提供的Web Service注册，而线程之间的管理在核外函数库中实现:Java Bean 是可复用的组件,然的在浏览器上就可打入http，创建identity和trust keystore，通过这种设计模型把应用逻辑、 如何查看在weblogic中已经发布的EJB，增加 WLS_USER和WLS_PW项,EJB、LINUX下线程。 采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架.for
4. 如何使用WebSocket
1.先装websocket服务器客户端
【java】kaazing websocket getway
【python】mod_pywebsocket
【javascript】node.js
2. WebSocket JavaScript 接口定义
[Constructor(in DOMString url, in optional DOMString protocol)]
interface WebSocket {
readonly attribute DOMString URL;
// ready state
const unsigned short CONNECTING = 0;
const unsigned short OPEN = 1;
const unsigned short CLOSED = 2;
readonly attribute unsigned short readyState;
readonly attribute unsigned long bufferedAmount;
//networking
attribute Function onopen;
attribute Function onmessage;
attribute Function onclose;
boolean send(in DOMString data);
void close();
};
WebSocket implements EventTarget;
其中 URL 属性代表 WebSocket 服务器的网络地址，协议通常是”ws”,send 方法就是发送数据到服务器端，close 方法就是关闭连接。除了这些方法，还有一些很重要的事件：onopen，onmessage，onerror 以及 onclose。下面是一段简单的 JavaScript 代码展示了怎样建立 WebSocket 连接和获取数据：
3. 建立 WebSocket 连接的实例 JavaScript 代码
var wsServer = 'ws://localhost:8888/Demo';
var websocket = new WebSocket(wsServer);
websocket.onopen = function (evt) { onOpen(evt) };
websocket.onclose = function (evt) { onClose(evt) };
websocket.onmessage = function (evt) { onMessage(evt) };
websocket.onerror = function (evt) { onError(evt) };
function onOpen(evt) {
console.log("Connected to WebSocket server.");
}
function onClose(evt) {
console.log("Disconnected");
}
function onMessage(evt) {
console.log('Retrieved data from server: ' + evt.data);
}
function onError(evt) {
console.log('Error occured: ' + evt.data);
}
5. for在python中是合法的吗
不属于合法变量。
事实上在python，执行如下代码会报错。for=123，这是因为for是Python里面的关键字，是保留字符，关键字是指被编程语言内部定义并保留使用的标识符。
6. python的for循环怎么用
##python
foriinrange(100):
printi
对应shell
##/bin/bash
foriin{1..100};
do
echo$i
done
7. 关于Python版本的websocket连接器
如果只是想实验多client的场景，一台电脑用不同的浏览器就可以充当不同的client了。
8. 请问各位大大，Python如何编写websocket的服务端和客户端，wss的那种
安装dwebsocket(pip install dwebsocket ) 后参考下面的链接
我django 2.0 测试通过
网页链接
9. python 中的for循环如何修改循环变量
python
for
循环不能修改循环变量的原因是，range()象是一个迭代器，它只会输出信息，而不能修改迭代器的内容。python
iterator的C结构是一个指针和一个对象列表。修改循环对象的值是C的思维方式，最好不要用在写python代码上。