精华内容
下载资源
问答
  • 关于java博网即时通讯软件的设计与实现 Server方面: 1 运行监控,打开Server,执行对其它用户的监控。 2 关闭监控,关闭Server,不在对其它用户进行监控。 3 阅览用户信息,阅览已登录用户信息。 4 ...
  • JavaQQ程序是通过多线程实现了一个服务器同时与多个客户机通信的程序。 Server类实现当程序开始运行时,会把相应的端口port设置为服务器。并让其处于待连接状态。每当有客户机连接上来时,就实例化一个线程类...
  • 基于Java实现即时通信系统
  • 基于JAVA即时通信软件

    千次阅读 2018-12-24 11:16:00
    设计任务书1.1 设计任务本文设计的是一个简单的即时通信软件,利用 Java Socket 进行点到点通信,其工作机制模仿即时通信软件的基本功能,已实现的功能有:客户端登录客户端退出群组成员之间传输文字或图片信息该...

    一.设计任务书

    1.1 设计任务

    本文设计的是一个简单的即时通信软件,利用 Java Socket 进行点到点通信,其工作机制模仿即时通信软件的基本功能,已实现的功能有:

    客户端登录

    客户端退出

    群组成员之间传输文字或图片信息

    该软件分为客户端与服务器端,客户端负责与服务器建立连接,且执行收发消息的操作,服务器端负责等待客户端连接并保存用户的昵称与客户端 Socket 的输出流的对应关系。

    1.2 技术指标

    本程序使用的是 TCP 协议实现的即时通信软件,程序是基于 Java 语言开发的,主要用到的技术有:

    Socket 编程

    自定义协议

    如果使用普通的方法来标记一条消息的结束,如换行符,那么程序就不易扩展,只能发送纯文本消息,所以需要自己定义一种消息的格式,并且我们还需要提供发送消息与解析消息的方法。

    服务器端创建一个 ServerSocket,循环等待客户端的连接,每当有客户端连接,就获取到客户端的 Socket 对象,并将该对象交付给一个服务器端线程处理,服务器端线程会不断从 Socket 的输入流中解析出消息类型、长度及消息内容,然后根据类型执行不同的操作。

    客户端与服务器建立连接,同时开启一个客户端线程接收服务器端发送的消息,客户端登录是向服务器发送一条登录命令,客户端向服务器发送一条消息首先需要包装成定义的消息格式,然后再发送给服务器。

    不管是发送消息还是发送命令其实本质都是一条消息,向服务器发送的消息都必须按照定义的格式来。

    1.3 论证结果

    经论证,这个任务是可行的。TCP 协议的实现细节 Java Socket 已经帮我们做好了,我们需要做的是定义一个协议工具类,实现发送消息与接收消息的方法,然后客户端与服务器端都利用这两个方法来进行消息的发送与解析。

    二.实现原理

    2.1 基于 TCP 协议的即时通信

    TCP 协议是一种端到端协议,当一台计算机要与远程的另一台计算机连接时,TCP 协议会让他们建立一个用于发送和接收数据的虚拟链路。TCP 要负责收集数据信息包,并将其按照适当的次序放好传送,接收端收到后再正确的还原,TCP协议使用了重发机制,当一个通信实体发送一个消息到另一个通信实体后,需要接收到另一个通信实体的确认消息,如果没有收到确认消息,则会重发消息。所以 TCP 协议保证了数据包在传输中不发生错误。通信示意图如图 1 所示。

    6607861-e3cbea655dbbf052.png

    在通信实体 1 与通信实体 2 建立虚拟链路前,必须有一方主动来接收其他通信实体的连接请求,作出“主动”的通信实体称为服务器,发出连接请求的通信实体称为客户机。

    2.2 自定义协议的定义

    2.2.1 通信原理

    客户端与服务器端相互通信,首先要建立 Socket 连接,连接建立好后双方都会拿到一个 Socket 对象,通过 Socket 对象拿到输入、输出流可以实现写、读的功能。服务器端接收到客户端的连接,将客户端的 Socket 对象交付给一个线程,该线程负责维护该客户端,在线程体中需要使用死循环不断的获取客户端发给服务器的消息。

    2.2.2 存在的问题

    那么问题来了:怎么标志客户端发送的消息的结尾?如果不对结尾标志,服务器端将不知道客户端本次客户端发送的消息到哪里。

    参考文档和完整的文档和源码下载地址:

    https://www.write-bug.com/article/1371.html

    展开全文
  • 基于Java即时通信软件 客户端 基于Java即时通信软件 客户端
  • 即时通信系统(Java实现),完整版,可供大家参考学习
  • java实现即时通讯代码

    2019-03-25 09:48:26
    本程序使用的是 TCP 协议实现的即时通信软件,程序是基于 Java 语言开发的,主要用到的技术有: Socket 编程 自定义协议 如果使用普通的方法来标记一条消息的结束,如换行符,那么程序就不易扩展,只能发送纯文本...
  • 基于java即时通信软件毕业设计.doc
  • 基于java即时通信软件 服务器端 基于java即时通信软件 服务器端
  • 基于Java实现的即时通信系统,很适合刚学Java的人群做简单的Java开发小项目
  • 即时通信系统(基于Java实现),功能全面,代码规整
  • UDP 即时通信软件源码

    2019-02-26 12:43:49
    基于UDP的即时通信源码,简单进行了丢包处理,可作为学习资料
  • 基于Java即时通讯软件的设计与实现 一、项目设计 1. 模块设计 该即时通讯系统是有两部分组成, 服务器端可以通过启动来监听客户端信息的传递与执行各种对客户端的监控,客户端则是通过人性化与美观的界面来使...


    前言

    今天学长向大家分享一个 java 设计项目:

    基于Java的即时通讯软件的设计与实现


    一、项目设计

    1. 模块设计

    在这里插入图片描述
    该即时通讯系统是有两部分组成,

    服务器端可以通过启动来监听客户端信息的传递与执行各种对客户端的监控,客户端则是通过人性化与美观的界面来使用户可以易上手和舒适的体验快速与简便的通讯。

    应用从这两部分分别进行了详细的功能设计,服务器端功能主要为启动对于客户端的监听与关闭监听,还有对于已注册用户的实时监控与管理,客户端功能主要为使用者该软件账号的申请与进入操作界面,还有自己资料的修改以及对于其他账号好友的添加与管理等等。

    2. 实现效果

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    二、部分源码

    部分代码示例:

    package cn.itbaizhan.client;
    
    import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.FlowLayout;
    import java.awt.Font;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    import java.io.BufferedReader;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.PrintStream;
    import java.io.RandomAccessFile;
    
    import javax.swing.ImageIcon;
    import javax.swing.JButton;
    import javax.swing.JDialog;
    import javax.swing.JFrame;
    import javax.swing.JLabel;
    import javax.swing.JOptionPane;
    import javax.swing.JPanel;
    
    import cn.itbaizhan.common.*;
    
    public class ChangeHead extends JDialog {
    	 BufferedReader in;//����������
    	 PrintStream out;//���������
    	 UserBean myInfo;
    	 JLabel jLtop=new JLabel(new ImageIcon("src/file/changeHeadtop.jpg"));//530*25
    	 JButton jB1=new JButton(new ImageIcon("src/file/changeHead1.jpg"));//75*20�Զ���ͷ��
    	 JPanel jP=new JPanel();//��ʾϵͳͷ��ģ��
    	 //JScrollPane js=new JScrollPane(jP);
    	 JButton jB2=new JButton(new ImageIcon("src/file/changeHead2.jpg"));//65*20ϵͳͷ��
    	 JButton jB3=new JButton(new ImageIcon("src/file/changeHead3.jpg"));//90*20��Աͷ��
    	 JButton jB4=new JButton(new ImageIcon("src/file/changeHead4.jpg"));//70*20��Աͷ��
    	 JLabel jLtop2=new JLabel(new ImageIcon("src/file/changeHeadtop2.jpg"));//140*20
    	 JLabel jLshow=new JLabel("�Ƽ�ͷ��");
    	 JLabel jLprepare=new JLabel("Ԥ��");
    	 JButton jBsure=new JButton(new ImageIcon("src/file/changeHeadSure.jpg"));//65*20
    	 JLabel por=new JLabel(new ImageIcon("src/file/personelView1.jpg"));
    	 String imagePath="src/head/10-1.gif";//�û�ѡ���ͼ���·��
    	 PersonelView father;
    	public ChangeHead(JFrame owner, String title, boolean b,
    			UserBean myInfo, BufferedReader in, PrintStream out,PersonelView father) {
    		// TODO Auto-generated constructor stub
    		super(owner,title,b);
    		this.in=in;
    		this.out=out;
    		this.myInfo=myInfo;
    		this.father=father;
    		this.setSize(530, 403);
    		this.setLocationRelativeTo(null);
    		this.setLayout(null);
    		init();
    		this.add(jLtop);
    		this.add(jB1);
    		this.add(jB2);
    		this.add(jB3);
    		this.add(jB4);
    		this.add(jLtop2);
    		this.add(jP);
    		this.add(jLshow);
    		this.add(jLprepare);
    		this.add(por);
    		this.add(jBsure);
    		this.setVisible(true);
    	}
    	 public void init()
    	 {
    		 jLtop.setBounds(0, 0, 530, 25);
    		 jB1.setBounds(0, 25, 75, 20);
    		 jB2.setBounds(75, 25, 65, 20);
    		 jP.setBounds(0, 70, 400, 500);
    		 jP.setBackground(Color.WHITE);
    		 jP.setLayout(new FlowLayout());
    		 makeIcon();
    		 jB3.setBounds(140, 25, 90, 20);
    		 jB4.setBounds(230, 25, 70, 20);
    		 jLtop2.setBounds(300, 25, 100, 20);
    		 jLshow.setFont(new Font("����",Font.PLAIN,14));
    		 jLshow.setForeground(Color.BLACK);
    		 jLshow.setBounds(10,45, 400, 25);
    		 jLshow.setBackground(Color.WHITE);
    		 
    		 jLprepare.setFont(new Font("����",Font.PLAIN,16));
    		 jLprepare.setForeground(Color.BLACK);
    		 jLprepare.setBounds(410,30, 100, 25);
    		 jLprepare.setBackground(Color.WHITE);
    		
    		 por.setIcon(new ImageIcon(myInfo.getPortrait()));
    		 por.setBounds(420, 60, 60, 60);
    		 jBsure.setBounds(420, 335, 65, 20);
    		 jBsure.addActionListener(new ActionListener(){
    
    			@Override
    			public void actionPerformed(ActionEvent arg0) {
    				// TODO Auto-generated method stub
    				String image=por.getIcon().toString();
    				out.println("UpdateMyportrait");
    				out.flush();
    				out.println(myInfo.getUserNum());
    				out.flush();
    				out.println(image);
    				out.flush();
    				try {
    					String judge=in.readLine();
    					if(judge.equals("updateMyportraitOver"))
    					{
    						ChangeHead.this.setVisible(false);
    						//JOptionPane.showMessageDialog(father, "����ͷ��ɹ���");
    						System.out.println("����ͷ��ɹ���");
    					}
    					else if(judge.equals("updateMyportraitFail"))
    					{
    						ChangeHead.this.setVisible(false);
    						JOptionPane.showMessageDialog(father, "����ͷ��ɹ���");
    						System.out.println("ϵͳ��æ�����Ժ����ԣ�");
    					}
    				} catch (IOException e1) {
    					// TODO Auto-generated catch block
    					e1.printStackTrace();
    				}
    				
    			}
    			 
    		 });
    	
    	 }
    	 private void makeIcon()
    	 {
    		 String path="src/head/";
    		 try {
    			RandomAccessFile file=new RandomAccessFile(path+"face.txt","r");
    			long fileLongth=file.length();
    			System.out.println(fileLongth);
    			long filePointer=0;
    			JLabel[] jLimage=new JLabel[84];
    			int i=0;
    			while(filePointer<fileLongth)
    			{
    				jLimage[i]=new JLabel(new ImageIcon(new String(path+file.readLine())));
    				jLimage[i].addMouseListener(new MouseAdapter(){
    					public void mousePressed(MouseEvent e)
    					{
    						String iconInfo=e.toString();
    						int begin=iconInfo.indexOf("src/head");
    						int last=iconInfo.lastIndexOf("-1.gif");
    						imagePath=iconInfo.substring(begin, last+6);
    						por.setIcon(new ImageIcon(imagePath));
    						System.out.println(imagePath);
    					}
    				});
    				jP.add(jLimage[i]);
    				i++;
    				filePointer=file.getFilePointer();
    			}
    			
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	 }
    }
    
    

    项目源码

    https://blog.csdn.net/mabile123444/article/details/119712695

    展开全文
  • 基于NetBeans的开发环境,添加项目后可以直接...本项目是在李刚《疯狂JAVA讲义》的LanTalk项目的基础上进行了界面优化,并实现了与QQ相同的一些功能,如登录界面,右下角任务栏托盘图标显示,在线与隐身状态可选等等。
  • java实现即时通信的完整步骤分享

    千次阅读 2021-02-12 09:30:24
    前言移动社交是我们日常生活中很常见的软件,最近在做即时通信,我用的是环信,和大家分享一下~~环信的API都是基于JSON的,所以在构造HTTP请求的时候,要指定请求头:注意==》环信API必须携带token才可以访问。...

    前言

    移动社交是我们日常生活中很常见的软件,最近在做即时通信,我用的是环信,和大家分享一下~~

    环信的API都是基于JSON的,所以在构造HTTP请求的时候,要指定请求头:

    e27382a1cf0ca8e9464af9e55fb96563.png

    bb7ce353325ebf17e002facb2abdc195.png

    注意==》环信API必须携带token才可以访问。

    创建一个认证类

    public class Authentic {

    private static Token token = new Token();

    private TalkHttpService service;

    public Authentic(TalkHttpService service) {

    this.service = service;

    }

    public Authentic(TalkHttpService service, Token token) {

    this.service = service;

    if (token != null) {

    Authentic.token = token;

    }

    }

    public Token getToken() {

    this.flush();

    return token;

    }

    public void task() {

    this.flush();

    }

    /**

    * @describe 申请认证 POST PUT 这两种请求携带参数

    * @author 何章怀晓 hezhanghuaixiao

    * @date 2020/9/8 17:02

    * @other

    */

    public void applyAuthentication(HttpEntityEnclosingRequestBase request) {

    this.flush();

    request.addHeader("Authorization", "Bearer " + token.toString());

    }

    /**

    * @describe 申请认证 GET DELETE 这两种请求不携带参数

    * @author 何章怀晓 hezhanghuaixiao

    * @date 2020/9/8 17:02

    * @other

    */

    public void applyAuthentication(HttpRequestBase request) {

    this.flush();

    request.addHeader("Authorization", "Bearer " + token.toString());

    }

    private void flush() {

    synchronized (Authentic.class) {

    try {

    //如果超时

    if (token.isExpire()) {

    //判断APPID和秘钥信息

    if (_Global.APP_CLIENT_ID != null && _Global.APP_CLIENT_SECRET != null) {

    Map param = new HashMap();

    param.put("grant_type", "client_credentials");

    param.put("client_id", _Global.APP_CLIENT_ID);

    param.put("client_secret", _Global.APP_CLIENT_SECRET);

    //请求获取token

    TalkNode res = service

    .request(_Global.URR_TOKEN, _Global.HTTP_METHOD_POST, param, null, null);

    //成功获取token

    if (res != null && res.getAccess_token() != null && res.getExpires_in() != null

    && res.getExpires_in() > 0) {

    //赋值

    token = new Token(res.getAccess_token(),

    res.getExpires_in() * 1000 + System.currentTimeMillis());

    }

    }

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    }

    }

    public static class Token {

    private String token;

    private Long expire;

    public Token() {

    }

    public Token(String token, long expire) {

    this.token = token;

    this.expire = expire;

    }

    public String getToken() {

    return token;

    }

    public void setToken(String token) {

    this.token = token;

    }

    public Long getExpire() {

    return expire;

    }

    public void setExpire(Long expire) {

    this.expire = expire;

    }

    public boolean isExpire() {

    return expire == null || System.currentTimeMillis() > expire;

    }

    @Override

    public String toString() {

    return token;

    }

    }

    }

    创建请求接口

    public interface TalkHttpService {

    /**

    @describe

    @param

    * @param url 请求地址

    * @param method请求方法

    * @param param参数

    * @param auth加密认证

    * @param field字段转换

    @return com.hedashi.protal.model.TalkNode

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:21

    @other

    */

    TalkNode request(String url, int method, Object param,

    Authentic auth, String[][] field) throws Exception;

    /**

    @describe

    @param

    * @param url 请求地址

    * @param file文件名称

    * @param auth加密认证

    * @param equal字段转换

    @return com.hedashi.protal.model.TalkNode

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:21

    @other

    */

    TalkNode upload(String url, File file, Authentic auth,

    String[][] equal) throws Exception;

    /**

    @describe

    @param

    * @param url 请求地址

    * @param file文件名称

    * @param auth加密认证

    * @param header请求头

    @return void

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:21

    @other

    */

    void downLoad(String url, File file, Authentic auth,

    Map header) throws Exception;

    }

    创建全局变量对不同模块操作

    /*

    @describe 全局变量

    @params

    @return

    @author 何章怀晓

    @date 2020/7/30 9:30

    @other

    */

    public class _Global {

    public static String APP_KEY = "";

    public static String APP_CLIENT_ID = "";

    public static String APP_CLIENT_SECRET = "";

    //每页数量

    public static int APP_PAGE_SIZE = 10;

    public static final int HTTP_METHOD_GET = 1;

    public static final int HTTP_METHOD_POST = 2;

    public static final int HTTP_METHOD_PUT = 3;

    public static final int HTTP_METHOD_DELETE = 4;

    public static final String URL_HOST = "http://a1.easemob.com/"+APP_KEY.replace("#","/")+"/";

    public static final String URR_TOKEN = URL_HOST+"token";

    public static final String URL_CHAT = URL_HOST+"chatmessages";

    public static final String URL_GROUP = URL_HOST+"chatgroups";

    public static final String URL_FILE = URL_HOST+"chatfiles";

    public static final String URL_ROOM = URL_HOST+"chatrooms";

    public static final String URL_MESSAGES = URL_HOST+"messages";

    public static final String URL_USER = URL_HOST+"users";

    }

    请求管理类

    package com.hedashi.protal.service.impl;

    import com.hedashi.protal.model.TalkNode;

    import com.hedashi.protal.model.Authentic;

    import com.hedashi.protal.service.TalkHttpService;

    import com.hedashi.protal.util.JsonTool;

    import com.hedashi.protal.util._Global;

    import java.io.File;

    import java.io.FileOutputStream;

    import java.io.InputStream;

    import java.net.URI;

    import java.util.Map;

    import java.util.Map.Entry;

    import org.apache.http.HttpEntity;

    import org.apache.http.HttpResponse;

    import org.apache.http.HttpStatus;

    import org.apache.http.client.methods.HttpDelete;

    import org.apache.http.client.methods.HttpGet;

    import org.apache.http.client.methods.HttpPost;

    import org.apache.http.client.methods.HttpPut;

    import org.apache.http.entity.StringEntity;

    import org.apache.http.entity.mime.MultipartEntity;

    import org.apache.http.entity.mime.content.ContentBody;

    import org.apache.http.entity.mime.content.FileBody;

    import org.apache.http.impl.client.CloseableHttpClient;

    import org.apache.http.impl.client.HttpClients;

    import org.apache.http.util.EntityUtils;

    import org.springframework.stereotype.Service;

    @Service

    public class TalkHttpServiceImplApache implements TalkHttpService {

    /**

    @describe

    @param

    * @param url 请求路径

    * @param method 方式

    * @param param 参数

    * @param auth 认证

    * @param field 将相应结果封装到本地

    @return com.hedashi.protal.model.TalkNode

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:39

    @other

    */

    @Override

    public TalkNode request(String url, int method, Object param,

    Authentic auth, String[][] field) throws Exception {

    //获得可关闭的连接

    CloseableHttpClient client = this.getClient();

    try {

    HttpResponse response = null;

    //区分请求方式

    switch (method) {

    case _Global.HTTP_METHOD_GET:

    //构建请求

    HttpGet get = new HttpGet(url);

    if (auth != null) {

    //如果未认证 请求认证

    auth.applyAuthentication(get);

    }

    //固定请求头信息为JSON

    get.addHeader("Content-Type", "application/json");

    response = client.execute(get);

    break;

    case _Global.HTTP_METHOD_POST:

    HttpPost post = new HttpPost(url);

    if (auth != null) {

    auth.applyAuthentication(post);

    }

    //POST携带参数

    if (param != null) {

    //参数编码放入请求体

    post.setEntity(new StringEntity(JsonTool.write(param),

    "UTF-8"));

    }

    post.addHeader("Content-Type", "application/json");

    response = client.execute(post);

    break;

    case _Global.HTTP_METHOD_PUT:

    HttpPut put = new HttpPut(url);

    if (put != null) {

    auth.applyAuthentication(put);

    }

    if (param != null) {

    put.setEntity(new StringEntity(JsonTool.write(param),

    "UTF-8"));

    }

    put.addHeader("Content-Type", "application/json");

    response = client.execute(put);

    break;

    case _Global.HTTP_METHOD_DELETE:

    HttpDelete delete = new HttpDelete(url);

    if (auth != null) {

    auth.applyAuthentication(delete);

    }

    delete.addHeader("Content-Type", "application/json");

    response = client.execute(delete);

    break;

    default:

    throw new Exception("非法请求方式");

    }

    int code = response.getStatusLine().getStatusCode();

    //判断返回code 如果为200

    if (code == HttpStatus.SC_OK) {

    //获取响应体

    HttpEntity entity = response.getEntity();

    if (entity != null) {

    //解析

    String json = EntityUtils.toString(entity, "UTF-8");

    if (field != null && field.length > 0) {

    for (String[] temp : field) {

    json = json.replace(temp[0], temp[1]);

    }

    }

    //解析为实体类

    TalkNode talkNode = (TalkNode) JsonTool.read(json, TalkNode.class);

    talkNode.setStatusCode(code);

    return talkNode;

    }

    } else {

    //非200将code返回

    return new TalkNode(code);

    }

    } catch (Exception e) {

    throw e;

    } finally {

    client.close();

    }

    return null;

    }

    @Override

    public TalkNode upload(String url, File file, Authentic auth,

    String[][] equal) throws Exception {

    CloseableHttpClient client = this.getClient();

    try {

    HttpPost post = new HttpPost();

    post.setURI(new URI(url));

    if (auth != null) {

    auth.applyAuthentication(post);

    }

    post.addHeader("restrict-access", "true");

    ContentBody body = new FileBody(file);

    MultipartEntity part = new MultipartEntity();

    part.addPart("file", body);

    post.setEntity(part);

    HttpResponse response = client.execute(post);

    int code = response.getStatusLine().getStatusCode();

    if (code == HttpStatus.SC_OK) {

    HttpEntity entity = response.getEntity();

    if (entity != null) {

    String json = EntityUtils.toString(entity, "UTF-8");

    if (equal != null && equal.length > 0) {

    for (String[] temp : equal) {

    json = json.replace(temp[0], temp[1]);

    }

    }

    TalkNode talkNode = (TalkNode) JsonTool.read(json, TalkNode.class);

    talkNode.setStatusCode(code);

    return talkNode;

    }

    }

    } catch (Exception e) {

    throw e;

    } finally {

    client.close();

    }

    return null;

    }

    @Override

    public void downLoad(String url, File file, Authentic auth,

    Map header) throws Exception {

    CloseableHttpClient client = this.getClient();

    try {

    HttpGet get = new HttpGet();

    get.setURI(new URI(url));

    if (auth != null) {

    auth.applyAuthentication(get);

    }

    for (Entry en : header.entrySet()) {

    get.addHeader(en.getKey(), en.getValue());

    }

    HttpResponse response = client.execute(get);

    if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {

    HttpEntity entity = response.getEntity();

    if (entity != null) {

    InputStream in = entity.getContent();

    FileOutputStream fos = new FileOutputStream(file);

    byte[] data = new byte[10 * 1024];

    int len = 0;

    while ((len = in.read(data)) != -1) {

    fos.write(data, 0, len);

    }

    fos.flush();

    fos.close();

    in.close();

    }

    }

    } catch (Exception e) {

    throw e;

    } finally {

    client.close();

    }

    }

    private CloseableHttpClient getClient() {

    return HttpClients.createDefault();

    }

    }

    创建业务请求和响应格式类

    package com.hedashi.protal.model;

    import java.util.List;

    import java.util.Map;

    /**

    @describe 根据不同的业务封装不同的返回结果,该格式在发送请求的时候就被指定

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:42

    @other

    */

    public class TalkNode {

    public static final String[][] DATA_ENTITIES = new String[][]{{"entities", "entities_share"},

    {"share-secret", "share_secret"}};

    public static final String[][] DATA_ARRAY = new String[][]{{"data", "data_array"}};

    public static final String[][] DATA_LIST = new String[][]{{"data", "data_list"}};

    public static final String[][] DATA_MAP = new String[][]{{"data", "data_map"}};

    public static final String[][] DATA_CHAT_LIST = new String[][]{{"entities", "data_chat_list"}};

    public static final String[][] DATA_ROOM = new String[][]{{"data", "data_room"}};

    public static final String[][] DATA_ROOM_LIST = new String[][]{{"data", "data_room_list"},

    {"public", "public_room"}};

    public static final String[][] DATA_ROOM_REDO = new String[][]{{"data", "data_room_rodo"}};

    public static final String[][] DATA_ROOM_REDO_LIST = new String[][]{

    {"data", "data_room_redo_list"}};

    public static final String[][] DATA_GROUP = new String[][]{{"data", "data_group"}};

    public static final String[][] DATA_GROUP_UPDATE = new String[][]{{"data", "data_group_update"}};

    public static final String[][] DATA_GROUP_OWNER = new String[][]{{"data", "data_group_owner"}};

    public static final String[][] DATA_GROUP_LIST = new String[][]{{"data", "data_group_list"}};

    public static final String[][] DATA_GROUP_LIST_MEMBER = new String[][]{

    {"data", "data_group_list_member"}};

    public static final String[][] DATA_GROUP_LIST_NEW = new String[][]{

    {"data", "data_group_list_new"}, {"public", "public_group"}};

    public static final String[][] DATA_GROUP_FRIEND = new String[][]{{"data", "data_group_friend"}};

    public static final String[][] DATA_GROUP_FRIEND_LIST = new String[][]{

    {"data", "data_group_friend_list"}};

    private String access_token;

    private String action;

    private String application;

    private String applicationName;

    private Long count;

    private String cursor;

    private Integer duration;

    private Long expires_in;

    private String organization;

    private String path;

    private Integer statusCode;

    private Long timestamp;

    private String uri;

    private Map params;

    private TalkUser user;

    private List entities;

    private String[] data_array;

    private Map data_map;

    private List> data_list;

    private List data_chat_list;

    private TalkRoom data_room;

    private List data_room_list;

    private TalkRoomRedo data_room_rodo;

    private List data_room_redo_list;

    private TalkGroup data_group;

    private TalkGroupMember data_group_update;

    private TalkGroupMember data_group_owner;

    private List data_group_list;

    private List data_group_list_member;

    private List data_group_list_new;

    private TalkGroupFriend data_group_friend;

    private List data_group_friend_list;

    public TalkNode() {

    }

    public TalkNode(Integer statusCode) {

    this.statusCode = statusCode;

    }

    public String getAccess_token() {

    return access_token;

    }

    public void setAccess_token(String access_token) {

    this.access_token = access_token;

    }

    public String getAction() {

    return action;

    }

    public void setAction(String action) {

    this.action = action;

    }

    public String getApplication() {

    return application;

    }

    public void setApplication(String application) {

    this.application = application;

    }

    public String getApplicationName() {

    return applicationName;

    }

    public void setApplicationName(String applicationName) {

    this.applicationName = applicationName;

    }

    public Long getCount() {

    return count;

    }

    public void setCount(Long count) {

    this.count = count;

    }

    public String getCursor() {

    return cursor;

    }

    public void setCursor(String cursor) {

    this.cursor = cursor;

    }

    public Integer getDuration() {

    return duration;

    }

    public void setDuration(Integer duration) {

    this.duration = duration;

    }

    public Long getExpires_in() {

    return expires_in;

    }

    public void setExpires_in(Long expires_in) {

    this.expires_in = expires_in;

    }

    public String getOrganization() {

    return organization;

    }

    public void setOrganization(String organization) {

    this.organization = organization;

    }

    public String getPath() {

    return path;

    }

    public void setPath(String path) {

    this.path = path;

    }

    public Integer getStatusCode() {

    return statusCode;

    }

    public void setStatusCode(Integer statusCode) {

    this.statusCode = statusCode;

    }

    public Long getTimestamp() {

    return timestamp;

    }

    public void setTimestamp(Long timestamp) {

    this.timestamp = timestamp;

    }

    public String getUri() {

    return uri;

    }

    public void setUri(String uri) {

    this.uri = uri;

    }

    public Map getParams() {

    return params;

    }

    public void setParams(Map params) {

    this.params = params;

    }

    public TalkUser getUser() {

    return user;

    }

    public void setUser(TalkUser user) {

    this.user = user;

    }

    public List getEntities() {

    return entities;

    }

    public void setEntities(List entities) {

    this.entities = entities;

    }

    public String[] getData_array() {

    return data_array;

    }

    public void setData_array(String[] data_array) {

    this.data_array = data_array;

    }

    public Map getData_map() {

    return data_map;

    }

    public void setData_map(Map data_map) {

    this.data_map = data_map;

    }

    public List> getData_list() {

    return data_list;

    }

    public void setData_list(List> data_list) {

    this.data_list = data_list;

    }

    public List getData_chat_list() {

    return data_chat_list;

    }

    public void setData_chat_list(List data_chat_list) {

    this.data_chat_list = data_chat_list;

    }

    public TalkRoom getData_room() {

    return data_room;

    }

    public void setData_room(TalkRoom data_room) {

    this.data_room = data_room;

    }

    public List getData_room_list() {

    return data_room_list;

    }

    public void setData_room_list(List data_room_list) {

    this.data_room_list = data_room_list;

    }

    public TalkRoomRedo getData_room_rodo() {

    return data_room_rodo;

    }

    public void setData_room_rodo(TalkRoomRedo data_room_rodo) {

    this.data_room_rodo = data_room_rodo;

    }

    public List getData_room_redo_list() {

    return data_room_redo_list;

    }

    public void setData_room_redo_list(List data_room_redo_list) {

    this.data_room_redo_list = data_room_redo_list;

    }

    public TalkGroup getData_group() {

    return data_group;

    }

    public void setData_group(TalkGroup data_group) {

    this.data_group = data_group;

    }

    public TalkGroupMember getData_group_update() {

    return data_group_update;

    }

    public void setData_group_update(TalkGroupMember data_group_update) {

    this.data_group_update = data_group_update;

    }

    public TalkGroupMember getData_group_owner() {

    return data_group_owner;

    }

    public void setData_group_owner(TalkGroupMember data_group_owner) {

    this.data_group_owner = data_group_owner;

    }

    public List getData_group_list() {

    return data_group_list;

    }

    public void setData_group_list(List data_group_list) {

    this.data_group_list = data_group_list;

    }

    public List getData_group_list_member() {

    return data_group_list_member;

    }

    public void setData_group_list_member(

    List data_group_list_member) {

    this.data_group_list_member = data_group_list_member;

    }

    public List getData_group_list_new() {

    return data_group_list_new;

    }

    public void setData_group_list_new(List data_group_list_new) {

    this.data_group_list_new = data_group_list_new;

    }

    public TalkGroupFriend getData_group_friend() {

    return data_group_friend;

    }

    public void setData_group_friend(TalkGroupFriend data_group_friend) {

    this.data_group_friend = data_group_friend;

    }

    public List getData_group_friend_list() {

    return data_group_friend_list;

    }

    public void setData_group_friend_list(

    List data_group_friend_list) {

    this.data_group_friend_list = data_group_friend_list;

    }

    }

    工具类

    public class HuanXinUtil {

    private static TalkDataService service = null;

    /**

    @describe 初始化

    @param

    * @param

    @return void

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:26

    @other

    */

    private static void init(){

    if(service == null){

    // 初始服务端Token

    Authentic.Token token = new Authentic(new TalkHttpServiceImplApache()).getToken();

    //token和过期时间

    Authentic.Token TEST_TOKEN = new Authentic.Token(token.getToken(),token.getExpire());

    //新建一个链接服务

    service = new TalkDataServiceImpl(new TalkHttpServiceImplApache());

    // 修改数据业务Token

    service.setToken(TEST_TOKEN);

    }

    }

    /**

    @describe 添加管理员

    @param

    * @param groupId 群组id

    * @param userid 管理员id

    @return boolean

    @author 何章怀晓 hezhanghuaixiao

    @date 2020/9/8 17:54

    @other

    */

    public static boolean addGroupManager(String groupId,String userid) {

    try {

    init();

    TalkNode talkNode = service.addGroupManager(groupId,userid);

    if(talkNode.getStatusCode()==200){

    return true;

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return false;

    }

    }

    service调用

    @Override

    public TalkNode addGroupManager(String id, String userId) throws Exception {

    Map param = new HashMap();

    param.put("newadmin", userId);

    return service.request(_Global.URL_GROUP + "/" + id + "/admin",

    _Global.HTTP_METHOD_POST, param, auth, TalkNode.DATA_GROUP);

    }

    /**

    * @param [groupId, managerId]

    * @return com.hedashi.common.api.CommonResult

    * @describe 后台添加群组管理员

    * @author 何章怀晓 hezhanghuaixiao

    * @date 2020/9/8 14:28

    * @other

    */

    @Override

    public CommonResult addGroupManager(String groupId, String managerId) {

    boolean b = HuanXinUtil.addGroupManager(groupId, managerId);

    if(b){

    System.out.println("环信添加管理员成功==========================");

    //本地添加管理员

    addGroupAdmin(groupId,managerId);

    return CommonResult.success("SUCCESS");

    }

    return CommonResult.failed("FAILED");

    }

    @ApiOperation(value = "群组添加管理员")

    @RequestMapping(value = "/addGroupManager", method = RequestMethod.POST)

    @ResponseBody

    public CommonResult addGroupManager(

    @RequestParam @ApiParam(value = "群组环信ID", required = true) String groupId,

    @RequestParam @ApiParam(value = "管理员环信id", required = true) String managerId

    ) {

    return heUGroupService.addGroupManager(groupId,managerId);

    }

    swagger调用

    7c9fcd41c37c7343d4867d1c3bb92186.png

    token 信息

    {“application”:“53e3eeb5-6926-46dd-bc61-4e214342ef7e”,“access_token”:“YWMtXDS-uPG6EeqItFktBQxljAAAAAAAAAAAAAAAAAAAAAFT4-61aSZG3bxhTiFDQu9-AgMAAAF0bSppWwBPGgBXDkgrlvguBLEe966D_LnbgNyNz2OOsTgP4okhQGoOdA”,“expires_in”:5184000}

    swagger返回结果

    34ac25d3ab8d6ddb0a296b9b14424cad.png

    控制台

    2123acad6f76171139f885eca299a336.png

    数据库:

    6c151885adcf320ef833cdceb9ed6170.png

    总结

    到此这篇关于java实现即时通信的文章就介绍到这了,更多相关java实现即时通信内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • 基于加密安全的java即时通信系统设计 :包含源代码、课程设计报告,以及说明。 。
  • Java即时通信软件源代码

    热门讨论 2009-09-18 11:21:39
    基于JavaSE开发的即时通信软件,附可执行打包文件。采用C/S设计模式,服务端使用数据库文件,无需设计数据库方便实用。源代码来源于网络,修改了源代码中错误若干,修复BUG若干,增加了两个类修改了界面。现仍有一处...
  • JAVA韩顺平即时通信系统代码
  • 本文设计的是一个简单的即时通信软件,利用 Java Socket 进行点到点通信,其工作机制模仿即时通信软件的基本功能,已实现的功能有: 客户端登录 客户端退出 群组成员之间传输文字或图片信息 该软件分为客户端与...

    一.设计任务书

    1.1 设计任务

    本文设计的是一个简单的即时通信软件,利用 Java Socket 进行点到点通信,其工作机制模仿即时通信软件的基本功能,已实现的功能有:

    • 客户端登录
    • 客户端退出
    • 群组成员之间传输文字或图片信息

    该软件分为客户端与服务器端,客户端负责与服务器建立连接,且执行收发消息的操作,服务器端负责等待客户端连接并保存用户的昵称与客户端 Socket 的输出流的对应关系。

    1.2 技术指标

    本程序使用的是 TCP 协议实现的即时通信软件,程序是基于 Java 语言开发的,主要用到的技术有:

    • Socket 编程
    • 自定义协议

    如果使用普通的方法来标记一条消息的结束,如换行符,那么程序就不易扩展,只能发送纯文本消息,所以需要自己定义一种消息的格式,并且我们还需要提供发送消息与解析消息的方法。

    服务器端创建一个 ServerSocket,循环等待客户端的连接,每当有客户端连接,就获取到客户端的 Socket 对象,并将该对象交付给一个服务器端线程处理,服务器端线程会不断从 Socket 的输入流中解析出消息类型、长度及消息内容,然后根据类型执行不同的操作。

    客户端与服务器建立连接,同时开启一个客户端线程接收服务器端发送的消息,客户端登录是向服务器发送一条登录命令,客户端向服务器发送一条消息首先需要包装成定义的消息格式,然后再发送给服务器。

    不管是发送消息还是发送命令其实本质都是一条消息,向服务器发送的消息都必须按照定义的格式来。

    1.3 论证结果

    经论证,这个任务是可行的。TCP 协议的实现细节 Java Socket 已经帮我们做好了,我们需要做的是定义一个协议工具类,实现发送消息与接收消息的方法,然后客户端与服务器端都利用这两个方法来进行消息的发送与解析。

    二.实现原理

    2.1 基于 TCP 协议的即时通信

    TCP 协议是一种端到端协议,当一台计算机要与远程的另一台计算机连接时,TCP 协议会让他们建立一个用于发送和接收数据的虚拟链路。TCP 要负责收集数据信息包,并将其按照适当的次序放好传送,接收端收到后再正确的还原,TCP协议使用了重发机制,当一个通信实体发送一个消息到另一个通信实体后,需要接收到另一个通信实体的确认消息,如果没有收到确认消息,则会重发消息。所以 TCP 协议保证了数据包在传输中不发生错误。通信示意图如图 1 所示。

    在通信实体 1 与通信实体 2 建立虚拟链路前,必须有一方主动来接收其他通信实体的连接请求,作出“主动”的通信实体称为服务器,发出连接请求的通信实体称为客户机。

    2.2 自定义协议的定义

    2.2.1 通信原理

    客户端与服务器端相互通信,首先要建立 Socket 连接,连接建立好后双方都会拿到一个 Socket 对象,通过 Socket 对象拿到输入、输出流可以实现写、读的功能。服务器端接收到客户端的连接,将客户端的 Socket 对象交付给一个线程,该线程负责维护该客户端,在线程体中需要使用死循环不断的获取客户端发给服务器的消息。

    2.2.2 存在的问题

    那么问题来了:怎么标志客户端发送的消息的结尾?如果不对结尾标志,服务器端将不知道客户端本次客户端发送的消息到哪里。

     


    参考文档和完整的文档和源码下载地址:

    https://www.write-bug.com/article/1371.html

    展开全文
  • Java即时通信工具

    2019-05-25 02:37:59
    NULL 博文链接:https://guidao.iteye.com/blog/480508
  • 基于JAVA即时通信

    2013-04-13 15:18:11
    基于JAVA即时通信,对于初学者了解网络编程挺有帮助的,初学者可以看一下
  • 基于Java即时通信软件源代码,使用Netbeans6.7.1开发环境,基于数据库文件,无需配置数据库。此系统是在网络源代码基础上改进而来,修复了两处错误,和一处Bug增加了两个类,修改美化了界面。尚有一处Bug发现未...
  • java web即时通信

    2016-06-04 13:31:52
    实现简单的网上即时通信,相当于是淘宝,京东客服功能的简单版
  • 导读:即时通讯软件即所谓的聊天工具,其主要用途是用于文字信息的传递与文件传输。使用eclipse作为即时通讯软件的开发工具,使用Socket建立通讯渠道,多线程实现多台计算机同时进行信息的...
  • Java版msn即时通信软件

    2011-02-27 16:56:12
    Java即时通信软件,类似于msn,有详细的使用说明和源码。
  • Java是当前比较流行的开发语言之一,它有着自己的易用特点与性能优势,比如跨平台、安全性、多线程、网络Socket编程、数据流概念等方面,因此通过对开源即时通讯LinuxQQ的研究和分析,基于Java语言和J2EE规范设计了...
  • 基于加密安全的java即时通信系统设计 包含源代码、课程设计报告,以及说明。 实现功能: 1即时通信。 2对通信内容进行加密,解密。 3实现对公钥、私钥的保管、导出等。
  • 基于 Java 实现即时... 即时通信改变人们的生活方式 2. 即时通讯优势 ( 即时性直观性廉价性 ) 研究目的及意义 ? 提供更方便的信息交流方式 ? 用户可以直接在浏览器中登录不需要安装客户 端软件 ? 具有安全性可靠性实

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,718
精华内容 13,887
关键字:

java平台的即时通信软件

java 订阅