P2P

最新推荐文章于 2023-11-11 15:26:26 发布
最新推荐文章于 2023-11-11 15:26:26 发布
阅读量159 收藏
点赞数
分类专栏： netty4
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq5132834/article/details/89853743
版权

客户端

/**
 * 
 */
package com.netty.client;

import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollBar;
import javax.swing.JTextArea;
import javax.swing.JTextField;

import com.alibaba.fastjson.JSON;
import com.netty.server.MessageDataUtils;
import com.netty.server.MessageData;

/**
 * @author HUANGLIAO322
 * 
 */
public class ClientP2P implements ActionListener {
	
	 //是否停止  
    public static int STOP=0;  
	
    public JFrame frame;  
      
    public JTextArea info; 			//聊天信息  
    
    public JTextField fromText ; 	//发送方
    public JTextField toText ; 		//接受方
    
    public JTextField fromField;	
    public JTextField toField;
    
    public JTextField msgText; 	//发送消息  
      
    public JButton sendButton;  //发送按钮
    
    public Socket socket;		//
    
    public OutputStream outputStream;
    public PrintWriter printWriter;
    

	InputStream is  ;
	DataInputStream dataInputStream;
	
    
    public ClientP2P(Socket socket){
    	
    	this.socket = socket;
		try {
			outputStream = socket.getOutputStream();
			is = socket.getInputStream();
			dataInputStream = new DataInputStream(is);
		} catch (IOException e1) {
			e1.printStackTrace();
		}
    	
    	frame=new JFrame("P2P聊天");  
		frame.setSize(500, 400);
		
		info=new JTextArea(10,30);
        info.setLineWrap(true);		//激活自动换行功能   
        info.setWrapStyleWord(true);
        info.setEditable(false);
		
        JScrollBar scroll=new JScrollBar();
        scroll.add(info); 
        
        JPanel infopanel=new JPanel();  
        infopanel.add(info,BorderLayout.WEST);
        fromField = new JTextField(10);
        fromField.setText("from");
        fromField.setEditable(false);
        fromText = new JTextField(30);
        toField = new JTextField(10);
        toField.setText("to");
        toField.setEditable(false);
        toText =  new JTextField(30);
        
        JPanel panelCenter = new JPanel();
        panelCenter.add(fromField,BorderLayout.NORTH);
        panelCenter.add(fromText, BorderLayout.NORTH);
        panelCenter.add(toField,BorderLayout.NORTH);
        panelCenter.add(toText,BorderLayout.NORTH);
        
        JPanel panel=new JPanel();
        
        msgText=new JTextField(30);

        sendButton=new JButton("发送");
        panel.add(msgText);
        panel.add(sendButton);
        frame.add(infopanel,BorderLayout.NORTH);
        frame.add(panelCenter, BorderLayout.CENTER);
        frame.add(panel,BorderLayout.SOUTH);
        frame.setVisible(true);
        
        sendButton.addActionListener(this);  
        
        new Thread(){
			@Override
			public void run() {

				while(true){
					System.out.println("11111");
					if(STOP==1){
						break;
					}
					try {
						System.out.println("22222");
						
						byte[] buffer = new byte[1024];
						int len = -1;
						int position = 0;
						while((len = dataInputStream.read(buffer))!=-1){
							position = position + len;
							if(position>=3){
								byte flag = buffer[0];
								byte module = buffer[1];
								byte size = buffer[2];
								String rs = new String(buffer);
								System.out.println("rs:"+rs);
								System.out.println(position);
								System.out.println(size);
								if(position-1==size+3){
									String result = new String(buffer,3,position);
									System.out.println("result:"+result);
									MessageData msgres = JSON.parseObject(result, MessageData.class);
									info.append(msgres.getFrom() + ":"+ msgres.getData());
				                    info.append("\n");
									break;
								}
							}
						}
						System.out.println("3333");
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
        }.start();
          
        frame.addWindowListener(new WindowAdapter(){
            public   void   windowClosing(WindowEvent e){
            	STOP = 1;
                System.exit(0);
            }
         });
    }
    
    
	public static void main(String[] args) throws Exception {
		
		String serverIP="127.0.0.1";  
        int port=8090;
		Socket socket = new Socket(serverIP,port);
		
		new ClientP2P(socket);
		
	}
	
	public void send(String msg){

		try {
			MessageData data = new MessageData();
			data.setFrom(this.fromText.getText());
			data.setTo(this.toText.getText());
			data.setData(msg);
			System.out.println("发送："+JSON.toJSONString(data));
			this.outputStream.write(MessageDataUtils.encodeProtocol(JSON.toJSONString(data)));
			this.outputStream.flush();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	

	@Override
	public void actionPerformed(ActionEvent e) {
		  
        if(e.getSource()==this.sendButton)  
        {  
            try{  
                String msg=this.msgText.getText();  
                if(msg.length()>0)  
                {
//                    this.info.append("我说："+msg);
                	this.info.append(this.fromText.getText() + ":"+ msg);
                    this.info.append("\n");
                    this.send(msg);
                    this.msgText.setText("");  
                }
            }  
            catch(Exception ee){}  
        }  
	}

}

 

 

服务器

/**
 * 
 */
package com.netty.server;

/**
 * @author HUANGLIAO322
 */
public class MessageData {
	
	private String from;
	
	private String to;
	
	//0失败回执，1成功回执，2登录，3消息
	private int cmd;
	
	private String data;
	
	public String getFrom() {
		return from;
	}
	public void setFrom(String from) {
		this.from = from;
	}
	public String getTo() {
		return to;
	}
	public void setTo(String to) {
		this.to = to;
	}
	public int getCmd() {
		return cmd;
	}
	public void setCmd(int cmd) {
		this.cmd = cmd;
	}
	public String getData() {
		return data;
	}
	public void setData(String data) {
		this.data = data;
	}

}

/**
 * 
 */
package com.netty.server;

/**
 * @author HUANGLIAO322
 *
 */
public class MessageDataUtils  {
	
	private static final byte FLAG = 'S';
	private static final byte MODULE = '1';
	public static final int HEADER_LEN = 3;
	
	/***
	 * 编码协议
	 * @param data
	 * @return
	 */
	public static byte[] encodeProtocol(String data) {
		
		byte[] bs = data.getBytes();
		byte lenght = (byte)data.getBytes().length;
		byte[] buffer = new byte[HEADER_LEN + lenght];
		buffer[0] = FLAG;
		buffer[1] = MODULE;
		buffer[2] = lenght;
		for(int i=3,j=0; i<buffer.length;i++,j++){
			buffer[i] = bs[j];
		}
		return buffer;
		
	}
	

	/***
	 * 解码协议
	 * @param buf
	 * @return
	 */
	public static String decodeProtocol(byte[] buffer) {
		
		byte[] buf = buffer;
		if(buf.length>=HEADER_LEN){
			if(buf[0]==FLAG){
				if(buf[1]==MODULE){
					int lenght = buf[2];
					if(buf.length==HEADER_LEN+lenght){
						byte[] msg = new byte[lenght];
						for(int i=0;i<lenght;i++){
							msg[i] = buf[3+i];
						}
						return new String(msg);
					}
				}
			}
		}
		return null;
		
	}

}

/**
 * 
 */
package com.netty.server;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

import com.alibaba.fastjson.JSON;

/**
 * @author HUANGLIAO322
 *
 */
/**
 * 解码请求消息
 */
public class RequestDecoder extends ByteToMessageDecoder{
	
	@Override
	protected void decode(ChannelHandlerContext ctx, ByteBuf buffer, List<Object> out) throws Exception {
 
		System.out.println("ZukServerRequestDecoder.decode.解码请求消息");
		
		while(true){

			byte[] dst = new byte[buffer.readableBytes()];
			buffer.readBytes(dst);
			
			if(dst.length >= MessageDataUtils.HEADER_LEN){
				String message = MessageDataUtils.decodeProtocol(dst);
				if(message!=null){
//					System.out.println("message:"+message);
					MessageData msg = JSON.parseObject(message, MessageData.class);
					out.add(msg);
				}
			}
			else{
				break;
			}
		}
		
		//数据不完整，等待完整的数据包
		return ;
	
	}

}

/**
 * 
 */
package com.netty.server;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author HUANGLIAO322
 *
 */
public class Server {


	public static void main(String[] args) throws Exception {
		
		ServerBootstrap server = new ServerBootstrap();
		
		EventLoopGroup parentGroup = new NioEventLoopGroup();
		EventLoopGroup childGroup = new NioEventLoopGroup();
		server.group(parentGroup, childGroup);
		
		server.channel(NioServerSocketChannel.class);
		
		server.childHandler(new ChannelInitializer<SocketChannel>() {
			@Override
			public void initChannel(SocketChannel ch) throws Exception {
				//接受消息解码
				ch.pipeline().addLast(new RequestDecoder());
				//消息处理
				ch.pipeline().addLast(new ZukServerHandler());
				//返回消息编码
				ch.pipeline().addLast(new ZukServerResponseEncoder());
				
			}
		});
	
		server.option(ChannelOption.SO_BACKLOG, 2048);// 链接缓冲池队列大小
		server.bind(8090).sync();
		
	}

	
}

/**
 * 
 */
package com.netty.server;

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;

/**
 * @author HUANGLIAO322
 *
 */
public class ZukServerHandler  extends SimpleChannelInboundHandler<MessageData> {
	 
	private Logger logger = LoggerFactory.getLogger(ZukServerHandler.class);
	
	public static Map<String,String> map = new ConcurrentHashMap<String, String>();
	public static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
	
	public static Map<String, Channel> mapChannels = new ConcurrentHashMap<String, Channel>();
	
	@Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {  // (2)
		
		Channel incoming = ctx.channel();
		// Broadcast a message to multiple Channels
		// channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 加入\n");
		String address = incoming.remoteAddress().toString();
		System.out.println("handlerAdded:"+address);
		map.put(address, "");
		channels.add(incoming);
    }
	
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {  // (3)
		// Channel incoming = ctx.channel();
		
		// Broadcast a message to multiple Channels
		// channels.writeAndFlush("[SERVER] - " + incoming.remoteAddress() + " 离开\n");

		// A closed Channel is automatically removed from ChannelGroup,
		// so there is no need to do "channels.remove(ctx.channel());"
    }
	
	@Override
	protected void channelRead0(ChannelHandlerContext ctx, MessageData msg)
			throws Exception {
		
		System.out.println("msg--:"+JSON.toJSONString(msg));
		
		final Channel channel = ctx.channel();
//		channel.writeAndFlush(msg);
//		IoSession session = ChannelUtils.getSessionBy(channel);
		
		String from = msg.getFrom();
		String to = msg.getTo();
		
		if(mapChannels.get(from)==null){
			System.out.println("from "+from + " is not on line.");
			mapChannels.put(from, channel);
		}
		if(mapChannels.get(to)==null){
			Channel fromChannel = mapChannels.get(from);
			MessageData res = new MessageData();
			res.setFrom("server");
			res.setTo(from);
			res.setData(to+" is not online");
			fromChannel.writeAndFlush(res);
		}
		else{
			
			//向接收端发送消息
			mapChannels.get(to).writeAndFlush(msg);
			
			//带消息回执
			Channel fromChannel = mapChannels.get(from);
			MessageData res = new MessageData();
			res.setFrom("server");
			res.setTo(from);
			res.setData(to+" yes");
			fromChannel.writeAndFlush(res);
		}
//		
//		for (Map.Entry<String, Channel>  entry: mapChannels.entrySet()) {
//			System.out.println("user:" + entry.getKey());
//			entry.getValue().writeAndFlush("hello.world.");
//		}
		
	}
	
	
	 
	@Override
	public void channelInactive(ChannelHandlerContext ctx) throws Exception {
		System.out.println("channelInactive断开连接");
//		Session session = new SessionImpl(ctx.channel());
//		Object object = session.getAttachment();
//		if(object != null){
//			Player player = (Player)object;
//			SessionManager.removeSession(player.getPlayerId());
//		}
	}
 

}

/**
 * 
 */
package com.netty.server;

import javax.jws.WebParam.Mode;

import com.alibaba.fastjson.JSON;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * @author HUANGLIAO322
 *
 */
/**
 * 
 * +---------------------------------------------------------------------------
 * | 包头(int)4 | 模块(int)4  | 命令(int)4  |  结果码 (int)4   | 数据长度(int)4  | ......
 * +---------------------------------------------------------------------------
 * 
 * 编码返回
 */
public class ZukServerResponseEncoder extends MessageToByteEncoder<MessageData>{
 
	@Override
	protected void encode(ChannelHandlerContext ctx, MessageData response, ByteBuf buffer)
			throws Exception {
		
		System.out.println("返回"+JSON.toJSONString(response));
		byte[] bs = MessageDataUtils.encodeProtocol(JSON.toJSONString(response));
		buffer.writeBytes(bs);
		
		
//		System.out.println("返回请求:" + "module:" +response.getModule() +" cmd:" + response.getCmd() + " code:" + response.getCode());
//		
//		//包头
//		buffer.writeInt(123456789);
//		//module
//		buffer.writeInt(response.getModule());
//		//cmd
//		buffer.writeInt(response.getCmd());
//		//结果码
//		buffer.writeInt(200);
//		//长度
//		int lenth = response.getData()==null? 0 : response.getData().length;
//		if(lenth <= 0){
//			buffer.writeInt(lenth);
//		}else{
//			buffer.writeInt(lenth);
//			buffer.writeBytes(response.getData());
//		}
//	
		
	} 
	

}

 

qq513283439
关注
专栏目录
P2P金融借贷项目--源码+MySQL数据库_
10-19
P2P（Peer-to-Peer）金融借贷项目是一种基于互联网技术的新型金融服务模式，它将借款人与贷款人直接连接起来，省去了传统金融机构作为中介的角色，降低了交易成本，提高了资金利用效率。在这个项目中，源码是实现P2P...
QQ(P2P)聊天系统的原理与实现
05-07
本文旨在用Delphi面向对象的方法实现P2P(Peer To Peer)(类QQ)会话系统。本文可作为学习P2P通信与面向对象程序设计的用例。 一、 通信组件：采用TIdUDPServer(属于Indy Servers组件板)。 二、 通信原理:：利用P2P之UDP穿透Cone(锥型)NAPT原理。 三、 系统特点： 1、所有会话命令均封装成对象。 2、每个命令对象都有Send(发送)与Exec(执行)方法。Send方法用于把对象(自己)发到对方，Exec方法完成对象的功能。 3、主要命令：Login(用户登录(C->S))、CloseSession(关闭会话(S->C)) 、 Binding(回复用户绑定信息(客户端经NAT后的IP&Port;)(S->C))、OnlineList(回复当前在线用户列表(S->C))、Upline(用户上线(C->C))、Logout(用户登出(C->S))、 Leaveline(用户离线(C->C))、 Chat(会话(交谈、闲聊)(C->C))、Upload(上载(数据)文件(C->C))
耗时两周的P2PQQ终于完成了!!!
IT老兵
08-30 1139
头几天,一时兴起,想在linux下做一个基于p2p的通讯软件,于是利用了假期最后的两周,经过努力奋斗,终于取得阶段性的结束,虽然还有一些细节需要修改,但是整体的代码已经写完了.改好好休息了,这一段,几乎没有正经睡过觉. 
p2p
qq_45872049的博客
12-10 788
1.概念原理 现在基本上很多网络应用的软件都涉及p2p技术(QQ,PPS,对战平台…),p2p技术旨在于摒弃以前只能从服务器获得资源的观念,每台电脑都是一个peer,都可以从其他peer上获取自己想要的资源,而同时自己也在向他人共享自己的资源.这里有一个很大的优势就是可以极大程度节省服务器的带宽. 打个比喻,优酷和pps,一个是基于服务器->客户端的模式,一个是p2p技术,优酷要想为用户提供...
P2P聊天工具原来QQ是这个原理
07-30
P2P聊天工具原来QQ是这个原理
Windows平台上实现P2P服务（二）
weixin_33979203的博客
07-17 669
2019独角兽企业重金招聘Python工程师标准>>> ...
6.9 P2P应用
tang7mj的博客
11-11 558
P2P网络的基本概念：理解P2P网络的定义、工作原理以及它与传统客户端-服务器模型的区别。文件分发机制：了解P2P网络中文件如何被分发，特别是比特洪流（BitTorrent）等第三代P2P技术的原理。资源定位方法：掌握在P2P网络中定位资源的方法，特别是分布式散列表（DHT）的概念和应用，如Chord算法。P2P网络的优势与挑战：理解P2P网络的优势（如分布式处理、负载均衡）和面临的挑战（如资源定位的效率、网络安全、版权问题等）。
P2P应用
weixin_42374938的博客
07-13 1479
P2P可分为以下几个架构模式 一、纯P2P架构 1、特点 （1）没有总是在线的服务器 （2）任意端系统之间直接通信 （3）对等方之间可以间断连接并可以改变IP地址 2、例子 （1）文件分发 （2）流媒体 （3）VoIP 二、集中式目录架构 在这种模式中有个中央目录服务器为P2P提供目录服务。这种集中式目录架构最早来自于”Napster“公司的设计。 在集中式目录架构中： （1）当对等方启动时，它通知目录服务器以下信息： 1）IP地址 2）可供共享的对象名称 （2）当一个用户要在集中式的目录里面找寻某个资源时
P2P.zip_p2p VC
09-20
【标题】"P2P.zip_p2p VC" 涉及的核心知识点是P2P（Peer-to-Peer）网络技术和VC++编程，主要聚焦在P2P网络中的打洞技术在网络编程中的应用。 P2P网络是一种分布式共享模型，其中每个节点既是服务的提供者也是消费者...
P2P版M3U8解析源码1.2.1版.zip_P2P解析m3u8源码_m3u8 p2p解析_p2p加速m3u8接口_p2p视频解
07-15
《P2P版M3U8解析源码1.2.1版》是一个针对M3U8视频流的P2P加速解决方案，旨在优化视频播放体验，提高数据传输效率。M3U8是一种用于存储多媒体播放列表的文件格式，常用于HTTP流媒体服务。在本项目中，P2P技术被巧妙地...
p2p-ws:通过WebSocket进行p2p
05-20
在“p2p-ws”这个项目中，我们看到的是使用WebSocket技术来实现P2P（点对点）通信的一种方法。P2P网络是互联网上的一种分布式通信模型，其中每个节点（或称为对等方）都可以作为服务的提供者和消费者。在P2P网络中，...
p2p.rar_P2P_P2P 文件传输_P2P文件传输_易语言p2p传输
07-14
P2P（Peer-to-Peer）技术是一种网络通信模型，它打破了传统的客户端-服务器（Client-Server，C/S）架构，让网络中的每个参与者都可以同时作为客户端和服务器，互相分享资源和服务。这种技术最初应用于文件共享，如...
Windows平台上实现P2P服务（三）
weixin_34049032的博客
07-22 128
2019独角兽企业重金招聘Python工程师标准>>> ...
现有P2P协议分类与简介
Kendiv's Box
10-18 6732
出处: http://blog.chinaunix.net/u1/37861/showart.php?id=1296282  （一）　常用p2p协议　　一、Napster：世界上第一个大型的P2P应用网络；中央集中式，倒闭了。　　Napster，这是当时很火的一种共享服务，主要用于查找mp3，它有一个服务器用于存储mp3文件的链接位置并提供检索，而真正的mp3文件则存放在千千万万的个人电脑
springboot基于vue 线上买菜系统源码+sql
最新发布
10-03
springboot基于vue 线上买菜系统源码+sql
P2P网络技术与应用
"P2P Networking and Applications.pdf" 该资源是一部关于P2P(Peer-to-Peer)网络及其应用的专业图书，由Morgan Kaufmann Publishers（现为Elsevier的印记）出版。图书的ISBN编号为978-0-12-374214-8。该书可能包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值