ການພັດທະນາ Blockchain ສໍາລັບອຸດສາຫະກໍາການນໍາໃຊ້ Go. ພາກທີ 1

ສໍາລັບສີ່ເດືອນໃນປັດຈຸບັນຂ້າພະເຈົ້າໄດ້ເຮັດວຽກກ່ຽວກັບໂຄງການທີ່ເອີ້ນວ່າ "ການພັດທະນາການປົກປ້ອງຂໍ້ມູນແລະເຄື່ອງມືການຄຸ້ມຄອງໃນຂະແຫນງການຂອງລັດຖະບານແລະອຸດສາຫະກໍາໂດຍອີງໃສ່ blockchain."
ຕອນນີ້ຂ້ອຍຢາກບອກເຈົ້າກ່ຽວກັບວິທີທີ່ຂ້ອຍເລີ່ມໂຄງການນີ້, ແລະຕອນນີ້ຂ້ອຍຈະອະທິບາຍລະຫັດໂຄງການຢ່າງລະອຽດ.

ນີ້ແມ່ນບົດຄວາມທໍາອິດໃນຊຸດຂອງບົດຄວາມ. ທີ່ນີ້ຂ້ອຍອະທິບາຍເຄື່ອງແມ່ຂ່າຍແລະໂປໂຕຄອນ. ໃນຄວາມເປັນຈິງ, ຜູ້ອ່ານສາມາດຂຽນສະບັບຂອງຕົນເອງຂອງອົງປະກອບ blockchain ເຫຼົ່ານີ້.

ແລະນີ້ແມ່ນພາກທີສອງ — ກ່ຽວ​ກັບ blockchain ແລະ​ໂຄງ​ສ້າງ​ຂໍ້​ມູນ​ການ​ເຮັດ​ທຸ​ລະ​ກໍາ​, ເຊັ່ນ​ດຽວ​ກັນ​ກັບ​ຊຸດ​ທີ່​ປະ​ຕິ​ບັດ​ການ​ພົວ​ພັນ​ກັບ​ຖານ​ຂໍ້​ມູນ​.

ໃນປີກາຍນີ້, ຢູ່ທີ່ Digital Breakthrough hackathon, ພວກເຂົາເຈົ້າໄດ້ມີຄວາມຄິດທີ່ຈະເຮັດໃຫ້ລະບົບທີ່ເປັນປະໂຫຍດສໍາລັບອຸດສາຫະກໍາແລະເສດຖະກິດດິຈິຕອນໂດຍນໍາໃຊ້ເຕັກໂນໂລຢີບັນຊີລາຍການທີ່ແຈກຢາຍ; ການຊ່ວຍເຫຼືອຍັງໄດ້ຖືກອອກໃຫ້ສໍາລັບການພັດທະນາໂດຍກອງທຶນການຊ່ວຍເຫຼືອດ້ານນະວັດກໍາ (ຂ້ອຍຄວນຂຽນແຍກຕ່າງຫາກ. ບົດ​ຄວາມ​ກ່ຽວ​ກັບ​ການ​ຊ່ວຍ​ເຫຼືອ​ລ້າ​, ສໍາ​ລັບ​ຜູ້​ທີ່​ພຽງ​ແຕ່​ເລີ່ມ​ຕົ້ນ​ທີ່​ຈະ​ເລີ່ມ​ຕົ້ນ​)​, ແລະ​ໃນ​ປັດ​ຈຸ​ບັນ​ໃນ​ຄໍາ​ສັ່ງ​.

ການພັດທະນາເກີດຂື້ນໃນພາສາ Go, ແລະຖານຂໍ້ມູນທີ່ບລັອກຖືກເກັບໄວ້ແມ່ນ LevelDB.
ພາກສ່ວນຕົ້ນຕໍແມ່ນໂປໂຕຄອນ, ເຄື່ອງແມ່ຂ່າຍ (ທີ່ດໍາເນີນການ TCP ແລະ WebSocket - ທໍາອິດສໍາລັບການ synchronizing blockchain, ທີສອງສໍາລັບການເຊື່ອມຕໍ່ລູກຄ້າ, ສົ່ງທຸລະກໍາແລະຄໍາສັ່ງຈາກ JavaScript, ສໍາລັບການຍົກຕົວຢ່າງ.

ດັ່ງທີ່ໄດ້ກ່າວມາແລ້ວ, blockchain ນີ້ແມ່ນຈໍາເປັນຕົ້ນຕໍເພື່ອອັດຕະໂນມັດແລະປົກປ້ອງການແລກປ່ຽນຜະລິດຕະພັນລະຫວ່າງຜູ້ສະຫນອງແລະລູກຄ້າ, ຫຼືທັງສອງຄົນໃນຄົນດຽວ. ຄົນເຫຼົ່ານີ້ບໍ່ຮີບຮ້ອນທີ່ຈະເຊື່ອໃຈກັນ. ແຕ່ວຽກງານບໍ່ພຽງແຕ່ສ້າງ "ປື້ມເຊັກ" ທີ່ມີເຄື່ອງຄິດເລກໃນຕົວ, ແຕ່ລະບົບທີ່ເຮັດໃຫ້ວຽກງານປົກກະຕິສ່ວນໃຫຍ່ເກີດຂື້ນໃນເວລາທີ່ເຮັດວຽກກັບວົງຈອນຊີວິດຂອງຜະລິດຕະພັນ. bytecode ທີ່ມີຄວາມຮັບຜິດຊອບຕໍ່ເລື່ອງນີ້, ຕາມປະເພນີຂອງ blockchains, ແມ່ນຖືກເກັບໄວ້ໃນວັດສະດຸປ້ອນແລະຜົນຜະລິດຂອງທຸລະກໍາ (ການເຮັດທຸລະກໍາຕົວເອງຖືກເກັບໄວ້ໃນບລັອກ, ຕັນໃນ LevelDB ແມ່ນຖືກເຂົ້າລະຫັດກ່ອນໃນຮູບແບບ GOB). ທໍາອິດ, ໃຫ້ເວົ້າກ່ຽວກັບໂປໂຕຄອນແລະເຄື່ອງແມ່ຂ່າຍ (aka node).

ໂປໂຕຄອນບໍ່ສັບສົນ, ຈຸດທັງຫມົດຂອງມັນແມ່ນການປ່ຽນໄປສູ່ໂຫມດການໂຫຼດຂໍ້ມູນບາງຢ່າງ, ໂດຍປົກກະຕິແມ່ນບລັອກຫຼືການເຮັດທຸລະກໍາ, ເພື່ອຕອບສະຫນອງກັບເສັ້ນຄໍາສັ່ງພິເສດ, ແລະມັນຍັງຕ້ອງການສໍາລັບການແລກປ່ຽນສິນຄ້າຄົງຄັງ, ເພື່ອໃຫ້ node ຮູ້ວ່າມັນແມ່ນໃຜ. ເຊື່ອມຕໍ່ແລະວິທີການທີ່ເຂົາເຈົ້າມີທຸລະກິດທີ່ຈະເຮັດ (ຂໍ້ທີ່ເຊື່ອມຕໍ່ສໍາລັບກອງປະຊຸມ synchronization ຍັງເອີ້ນວ່າ "ເພື່ອນບ້ານ" ເພາະວ່າ IP ຂອງເຂົາເຈົ້າເປັນທີ່ຮູ້ຈັກແລະຂໍ້ມູນຂອງລັດຂອງພວກເຂົາຖືກເກັບໄວ້ໃນຫນ່ວຍຄວາມຈໍາ).

ໂຟນເດີ (ໄດເລກະທໍລີທີ່ Linux ເອີ້ນພວກເຂົາ) ໃນຄວາມເຂົ້າໃຈຂອງໂປລແກລມ Go ຖືກເອີ້ນວ່າແພັກເກັດ, ດັ່ງນັ້ນໃນຕອນຕົ້ນຂອງແຕ່ລະໄຟລ໌ທີ່ມີລະຫັດ Go ຈາກໄດເລກະທໍລີນີ້ພວກເຂົາຂຽນ package folder_name_where_this_file. ຖ້າ​ບໍ່​ດັ່ງ​ນັ້ນ​, ທ່ານ​ຈະ​ບໍ່​ສາ​ມາດ​ໃຫ້​ອາ​ຫານ​ຊຸດ​ໃຫ້​ຄອມ​ພິວ​ເຕີ​ໄດ້​. ດີ, ນີ້ບໍ່ແມ່ນຄວາມລັບສໍາລັບຜູ້ທີ່ຮູ້ພາສານີ້. ເຫຼົ່ານີ້ແມ່ນຊຸດ:

• ການ​ສື່​ສານ​ເຄືອ​ຂ່າຍ (ເຊີບ​ເວີ​, ລູກ​ຄ້າ​, protocol​)
• ໂຄງ​ສ້າງ​ຂອງ​ຂໍ້​ມູນ​ທີ່​ເກັບ​ຮັກ​ສາ​ໄວ້​ແລະ​ການ​ຖ່າຍ​ໂອນ (block​, ທຸ​ລະ​ກໍາ​)
• ຖານຂໍ້ມູນ (blockchain)
• ຄວາມເຫັນດີເຫັນພ້ອມ
• ເຄື່ອງຈັກສະເໝືອນຊ້ອນກັນ (xvm)
• ຕົວຊ່ວຍ (crypto, ປະເພດ) ທັງໝົດສຳລັບຕອນນີ້.

ນີ້ແມ່ນການເຊື່ອມຕໍ່ກັບ github

ນີ້ແມ່ນສະບັບການສຶກສາ, ມັນຂາດປະຕິສໍາພັນລະຫວ່າງຂະບວນການແລະອົງປະກອບຂອງການທົດລອງຈໍານວນຫນຶ່ງ, ແຕ່ໂຄງສ້າງທີ່ສອດຄ້ອງກັນກັບການພັດທະນາທີ່ກໍາລັງດໍາເນີນ. ຖ້າທ່ານມີສິ່ງໃດທີ່ຈະແນະນໍາໃນຄໍາເຫັນ, ຂ້ອຍຈະຍິນດີທີ່ຈະພິຈາລະນາໃນການພັດທະນາຕໍ່ໄປ. ແລະໃນປັດຈຸບັນສໍາລັບຄໍາອະທິບາຍຂອງເຄື່ອງແມ່ຂ່າຍແລະ protocol.

ລອງເບິ່ງເຊີບເວີກ່ອນ.

routine ຍ່ອຍຂອງເຊີບເວີເຮັດຫນ້າທີ່ເປັນເຄື່ອງແມ່ຂ່າຍຂໍ້ມູນທີ່ດໍາເນີນການຢູ່ເທິງສຸດຂອງໂປໂຕຄອນ TCP ໂດຍໃຊ້ໂຄງສ້າງຂໍ້ມູນຈາກຊຸດໂປໂຕຄອນ.

ປົກກະຕິໃຊ້ແພັກເກດຕໍ່ໄປນີ້: ເຄື່ອງແມ່ຂ່າຍ, protocol, ປະເພດ. ໃນຊຸດຕົວມັນເອງ tcp_server.go ມີໂຄງສ້າງຂໍ້ມູນ ຮັບໃຊ້.

type Serve struct {
	Port string
	BufSize int
	ST *types.Settings
}

ມັນສາມາດຍອມຮັບຕົວກໍານົດການດັ່ງຕໍ່ໄປນີ້:

• ພອດເຄືອຂ່າຍໂດຍຜ່ານຂໍ້ມູນທີ່ຈະໄດ້ຮັບການແລກປ່ຽນ
• ໄຟລ໌ການຕັ້ງຄ່າເຊີບເວີໃນຮູບແບບ JSON
• ທຸງສຳລັບແລ່ນຢູ່ໃນໂໝດດີບັກ (ບລັອກເຊນສ່ວນຕົວ)

ຄວາມຄືບໜ້າ:

• ອ່ານການຕັ້ງຄ່າຈາກໄຟລ໌ JSON
• ທຸງຮູບແບບການດີບັກຖືກກວດສອບ: ຖ້າມັນຖືກຕັ້ງ, ຕົວກໍານົດເວລາ synchronization ເຄືອຂ່າຍບໍ່ໄດ້ເປີດຕົວແລະ blockchain ບໍ່ໄດ້ຖືກໂຫລດ.
• ການເລີ່ມຕົ້ນໂຄງສ້າງຂໍ້ມູນການຕັ້ງຄ່າແລະການເລີ່ມຕົ້ນເຄື່ອງແມ່ຂ່າຍ

Server

• ດໍາເນີນການເປີດຕົວຂອງເຄື່ອງແມ່ຂ່າຍ TCP ແລະການໂຕ້ຕອບເຄືອຂ່າຍໂດຍສອດຄ່ອງກັບໂປໂຕຄອນ.
• ມັນມີໂຄງສ້າງຂໍ້ມູນ Serve ປະກອບດ້ວຍໝາຍເລກພອດ, ຂະໜາດ buffer ແລະຕົວຊີ້ໄປຫາໂຄງສ້າງ types.Settings
• ວິທີການ Run ເລີ່ມຕົ້ນການໂຕ້ຕອບເຄືອຂ່າຍ (ຟັງການເຊື່ອມຕໍ່ຂາເຂົ້າຢູ່ໃນພອດທີ່ກໍານົດໄວ້, ເມື່ອໄດ້ຮັບການເຊື່ອມຕໍ່ໃຫມ່, ການປຸງແຕ່ງຂອງມັນຖືກໂອນໄປຫາວິທີການຈັດການສ່ວນຕົວໃນຫົວຂໍ້ໃຫມ່)
• В ຈັບໄດ້ ຂໍ້​ມູນ​ຈາກ​ການ​ເຊື່ອມ​ຕໍ່​ແມ່ນ​ໄດ້​ອ່ານ​ເຂົ້າ​ໄປ​ໃນ buffer​, ປ່ຽນ​ເປັນ​ຕົວ​ແທນ​ສະ​ຕ​ຣິງ​ແລະ​ສົ່ງ​ໄປ​ protocol.ທາງເລືອກ
• protocol.ທາງເລືອກ ກັບຄືນ ຜົນ ຫຼືເຮັດໃຫ້ເກີດຄວາມຜິດພາດ. ຜົນ ຫຼັງ​ຈາກ​ນັ້ນ​ໄດ້​ຍົກ​ຍ້າຍ​ໄປ​ protocol.Interpreteເຊິ່ງກັບຄືນມາ intrpr - ວັດ​ຖຸ​ປະ​ເພດ​ ແປຂໍ້ມູນ, ຫຼືເຮັດໃຫ້ເກີດຄວາມຜິດພາດໃນການປະມວນຜົນຜົນການຄັດເລືອກ
• ຫຼັງຈາກນັ້ນ, ສະຫຼັບໄດ້ຖືກປະຕິບັດ intrpr.Commands[0] ເຊິ່ງກວດສອບໜຶ່ງໃນ: ຜົນໄດ້ຮັບ, inv, ຄວາມຜິດພາດ ແລະ​ມີ​ພາກ​ສ່ວນ​ Default
• ໃນພາກ ຜົນ ສະວິດແມ່ນພົບໂດຍຄ່າ intrpr.Commands[1] ເຊິ່ງກວດສອບຄ່າ bufferlength и ສະບັບພາສາ (ໃນ​ແຕ່​ລະ​ກໍ​ລະ​ນີ​ການ​ທໍາ​ງານ​ທີ່​ສອດ​ຄ້ອງ​ກັນ​ແມ່ນ​ເອີ້ນ​ວ່າ​)

ຟັງຊັນ GetVersion и BufferLength ຢູ່ໃນໄຟລ໌ srvlib.go ຊຸດເຊີບເວີ

GetVersion(conn net.Conn, version string)

ມັນພຽງແຕ່ພິມໃສ່ console ແລະສົ່ງສະບັບທີ່ຜ່ານໃນພາລາມິເຕີໄປຫາລູກຄ້າ:

conn.Write([]byte("result:" + version))

.
ການທໍາງານຂອງ

BufferLength(conn net.Conn, intrpr *protocol.InterpreteData)

ໂຫລດບລັອກ, ທຸລະກໍາ, ຫຼືຂໍ້ມູນສະເພາະອື່ນໆດັ່ງຕໍ່ໄປນີ້:

• ພິມໃສ່ console ປະເພດຂອງຂໍ້ມູນທີ່ລະບຸໄວ້ໃນໂປໂຕຄອນທີ່ຕ້ອງໄດ້ຮັບການຍອມຮັບ:

  fmt.Println("DataType:", intrpr.Commands[2])

• ອ່ານຄ່າ intrpr.ຮ່າງກາຍ ກັບຕົວແປຕົວເລກ buf_len
• ສ້າງ buffer newbuf ຂະໜາດທີ່ລະບຸ:

  make([]byte, buf_len)

• ສົ່ງ​ການ​ຕອບ​ສະ​ຫນອງ ok:

  conn.Write([]byte("result:ok"))

• ຕື່ມຂໍ້ມູນໃສ່ buffer ຢ່າງສົມບູນຈາກກະແສການອ່ານ:

  io.ReadFull(conn, newbuf)

  .

• ພິມເນື້ອໃນຂອງ buffer ໃສ່ console ໄດ້

  fmt.Println(string(newbuf))

  ແລະຈໍານວນຂອງ bytes ອ່ານ

  fmt.Println("Bytes length:", n)

• ສົ່ງ​ການ​ຕອບ​ສະ​ຫນອງ ok:

  conn.Write([]byte("result:ok"))

ວິທີການຈາກແພັກເກັດເຊີບເວີຖືກຕັ້ງຄ່າໃຫ້ປະມວນຜົນຂໍ້ມູນທີ່ໄດ້ຮັບໂດຍໃຊ້ຟັງຊັນຈາກແພັກເກັດ protocol.

ອະນຸສັນຍາ

ອະນຸສັນຍາເຮັດໜ້າທີ່ເປັນຕົວແທນຂອງຂໍ້ມູນໃນການແລກປ່ຽນເຄືອຂ່າຍ.

Choice(str string) (string, error) ປະຕິບັດການປະມວນຜົນເບື້ອງຕົ້ນຂອງຂໍ້ມູນທີ່ໄດ້ຮັບໂດຍເຊີບເວີ, ໄດ້ຮັບການສະແດງສະຕຣິງຂອງຂໍ້ມູນເປັນການປ້ອນຂໍ້ມູນ ແລະສົ່ງຄືນສະຕຣິງທີ່ກຽມໄວ້ສໍາລັບ ນາຍພາສາ:

• ສາຍປ້ອນຂໍ້ມູນຖືກແບ່ງອອກເປັນຫົວ ແລະ ຮ່າງກາຍໂດຍໃຊ້ ReqParseN2(str)
• ຫົວຖືກແບ່ງອອກເປັນອົງປະກອບແລະຖືກຈັດໃສ່ເຂົ້າໄປໃນຕ່ອນຄໍາສັ່ງໂດຍໃຊ້ ReqParseHead(head)
• В ສະຫຼັບ(ຄໍາສັ່ງ[0]) ເລືອກຄໍາສັ່ງທີ່ໄດ້ຮັບ (cmd, ລະຫັດ, ທີ່ຢູ່ ຫຼືພາກສ່ວນຖືກກະຕຸ້ນ Default)
• 2 ຄໍາສັ່ງຖືກກວດສອບໃນ cmd switch(ຄໍາສັ່ງ[1]) — ຄວາມຍາວ и ການປ່ຽນແປງ.
• ຄວາມຍາວ ກວດ​ສອບ​ປະ​ເພດ​ຂໍ້​ມູນ​ໃນ​ ຄໍາສັ່ງ[2] ແລະບັນທຶກມັນຢູ່ໃນ ປະເພດຂໍ້ມູນ
• ກວດເບິ່ງວ່າ ຮ່າງກາຍ ປະກອບມີຄ່າສະຕຣິງ

  len(body) < 1

• ຕອບສະຕຣິງຕອບ:

  "result:bufferlength:" + datatype + "/" + body

• ການປ່ຽນແປງ ຕອບສະຕຣິງ

  return "result:version/auto"

ນາຍພາສາ

ປະກອບດ້ວຍໂຄງສ້າງ InterpreteData ແລະປະຕິບັດການປະມວນຜົນຂັ້ນສອງຂອງຂໍ້ມູນທີ່ສົ່ງຄືນມາຈາກ ທາງເລືອກ ຊ່ອຍແນ່ ແລະການສ້າງວັດຖຸ ແປຂໍ້ມູນ.

type InterpreteData struct {
	Head string
	Commands []string
	Body string
	IsErr bool
	ErrCode int 
	ErrMessage string
}

ການທໍາງານຂອງ

Interprete(str string) (*InterpreteData, error)

ຍອມຮັບສາຍ ຜົນ ແລະສ້າງ ແລະສົ່ງຄືນການອ້າງອີງເຖິງວັດຖຸ ແປຂໍ້ມູນ.

ຄວາມຄືບໜ້າ:

• ເຊັ່ນດຽວກັນ ທາງເລືອກ ຫົວແລະຮ່າງກາຍໄດ້ຖືກສະກັດອອກໂດຍໃຊ້ ReqParseN2(str)
• ຫົວຖືກແບ່ງອອກເປັນອົງປະກອບໂດຍໃຊ້ ReqParseHead(ຫົວ)
• ວັດຖຸແມ່ນເລີ່ມຕົ້ນ ແປຂໍ້ມູນ ແລະຕົວຊີ້ໄປຫາມັນຖືກສົ່ງຄືນ:

res := &InterpreteData{
	Head: head,
	Commands: commands,
	Body: body,
}
return res, nil

ວັດຖຸນີ້ຖືກນໍາໃຊ້ໃນ server.go ຊຸດຫຼັກ.

ລູກ​ຄ້າ

ຊຸດລູກຄ້າປະກອບດ້ວຍຫນ້າທີ່ TCPConnect и TCPRresponseData.

ການທໍາງານຂອງ

TCPConnect(s *types.Settings, data []byte, payload []byte)

ເຮັດວຽກແບບນີ້:

• ການ​ເຊື່ອມ​ຕໍ່​ແມ່ນ​ເຮັດ​ໃຫ້​ການ​ເຊື່ອມ​ຕໍ່​ທີ່​ລະ​ບຸ​ໄວ້​ໃນ​ວັດ​ຖຸ​ການ​ຕັ້ງ​ຄ່າ​ຜ່ານ​

  net.Dial("tcp", s.Host + ":" + s.Port)

• ຂໍ້ມູນທີ່ຜ່ານໃນພາລາມິເຕີຂໍ້ມູນຖືກສົ່ງ:

  conn.Write(data)

• ຄໍາຕອບແມ່ນອ່ານ

  resp, n, _ := TCPResponseData(conn, s.BufSize)

  ແລະພິມອອກໃນ console ໄດ້

  fmt.Println(string(resp[:n]))

• ຖ້າໂອນ payload ຫຼັງ​ຈາກ​ນັ້ນ​ຜ່ານ​ມັນ​

  conn.Write(payload)

  ແລະຍັງອ່ານຄໍາຕອບຂອງເຄື່ອງແມ່ຂ່າຍ, ພິມມັນໃສ່ console

ການທໍາງານຂອງ

 TCPResponseData(conn net.Conn, bufsiz int) ([]byte, int, error)

ສ້າງ buffer ຂອງຂະຫນາດທີ່ກໍານົດໄວ້, ອ່ານການຕອບສະຫນອງຂອງເຄື່ອງແມ່ຂ່າຍຢູ່ທີ່ນັ້ນແລະສົ່ງຄືນ buffer ນີ້ແລະຈໍານວນຂອງ bytes ອ່ານ, ເຊັ່ນດຽວກັນກັບວັດຖຸຄວາມຜິດພາດ.

ກິດຈະກຳຍ່ອຍຂອງລູກຄ້າ

ຮັບໃຊ້ການສົ່ງຄໍາສັ່ງໄປຫາເຄື່ອງແມ່ຂ່າຍຂອງ node, ເຊັ່ນດຽວກັນກັບການໄດ້ຮັບສະຖິຕິສັ້ນໆແລະການທົດສອບ.

ສາມາດຍອມຮັບພາລາມິເຕີຕໍ່ໄປນີ້: ໄຟລ໌ການຕັ້ງຄ່າໃນຮູບແບບ JSON, ຂໍ້ມູນທີ່ຈະຖືກສົ່ງໄປຫາເຄື່ອງແມ່ຂ່າຍເປັນສະຕຣິງ, ເສັ້ນທາງໄປຫາໄຟລ໌ທີ່ຈະຖືກສົ່ງໄປຫາ payload, node scheduler emulation flag, ປະເພດຂອງຂໍ້ມູນທີ່ໂອນເປັນຄ່າຕົວເລກ.

• ໄດ້​ຮັບ​ການ​ຕັ້ງ​ຄ່າ​

  st := types.ParseConfig(*config)

• ຖ້າທຸງ emu ຖືກຜ່ານ, ມັນເລີ່ມຕົ້ນ ຜູ້ລ້ຽງ
• ຖ້າທຸງ f ຊີ້ບອກເສັ້ນທາງໄປຫາໄຟລ໌ໄດ້ຖືກສະຫນອງ, ຫຼັງຈາກນັ້ນພວກເຮົາໂຫລດຂໍ້ມູນຂອງມັນເຂົ້າໄປໃນ fdb ແລະເນື້ອຫາຖືກສົ່ງໄປຫາເຄື່ອງແມ່ຂ່າຍ

  client.TCPConnect(st, []byte(CMD_BUFFER_LENGTH + ":" + strconv.Itoa(*t) + "/" + strconv.Itoa(fdblen)), fdb)

• ຖ້າໄຟລ໌ບໍ່ໄດ້ຖືກລະບຸ, ຫຼັງຈາກນັ້ນຂໍ້ມູນຈາກທຸງຈະຖືກສົ່ງງ່າຍໆ -d:

  client.TCPConnect(st, []byte(*data), nil)

ທັງໝົດນີ້ເປັນຕົວແທນທີ່ງ່າຍດາຍສະແດງໃຫ້ເຫັນເຖິງໂຄງສ້າງຂອງໂປໂຕຄອນ. ໃນລະຫວ່າງການພັດທະນາ, ຫນ້າທີ່ທີ່ຈໍາເປັນໄດ້ຖືກເພີ່ມເຂົ້າໃນໂຄງສ້າງຂອງມັນ.

ໃນສ່ວນທີສອງຂ້ອຍຈະເວົ້າກ່ຽວກັບໂຄງສ້າງຂໍ້ມູນສໍາລັບການບລັອກແລະການເຮັດທຸລະກໍາ, ໃນ 3 ກ່ຽວກັບເຄື່ອງແມ່ຂ່າຍຂອງ WebSocket ສໍາລັບການເຊື່ອມຕໍ່ຈາກ JavaScript, ໃນ 4 ຂ້ອຍຈະເບິ່ງຕາຕະລາງ synchronization, ຫຼັງຈາກນັ້ນເຄື່ອງ stack ທີ່ປຸງແຕ່ງ bytecode ຈາກວັດສະດຸປ້ອນແລະຜົນຜະລິດ, cryptography ແລະ. ສະນຸກເກີສໍາລັບຜົນໄດ້ຮັບ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com