这是刚开始学习java网络编程的时候做的一个东东，，局域网聊天器，可以在局域网内，和小伙伴聊天，共同画图（游戏原型）。先上图吧
一，首先讲解下基本知识，建立网络连接，你首先得有服务器和客户端，
1，服务器：ServerSocket s=new ServerSocket(n)；这样就建立好一个端口号n的服务器，如果把你的电脑比作公寓，端口号类似于你的房间号。服务器创建好后，你得等待客户端连接，Socket so=s.accept();这样就能获取到连接进来的客户端（如果当前么有人连进来，他就会阻塞在当前，不会执行下面的代码），然后你就得获取他的输入输出流，用来传送和接收数据，InputStream is=so.GetinpputStream();Outputstream ou=so.getOutPutstream();
2，客户端：Socket s=new Socket("ip",端口号);ip就是你连接的那台服务器的电脑的ip地址，端口号就是你创建服务器的那个端口号，也就是说你得先找到公寓地址，然后再去找房间，这样就连接好了，同样的获取输入输出流，用来传送接收数据。
二，以上就是基本知识点，现在开始实例代码
首先看界面代码
public class fu extends JFrame{
public Test t=new Test();
private static JTextArea jt3;
public JTextField jt2;
static Graphics gr;
public void UI(){
this.setTitle("服务器");
this.setSize(400,400);
this.setLocation(400,200);
this.setLayout(new FlowLayout(FlowLayout.LEFT));
this.setDefaultCloseOperation(3);
JButton jb1=new JButton("start");//启动服务器按钮
this.add(jb1);
JTextField jt1=new JTextField();//输入消息框
jt1.setPreferredSize(new Dimension(40,30));
this.add(jt1);
JButton jb2=new JButton("send");//发送按钮
this.add(jb2);
jt2=new JTextField();
jt2.setPreferredSize(new Dimension(180,30));
this.add(jt2);
jt3=new JTextArea();
jt3.setPreferredSize(new Dimension(400,150));
this.add(jt3);
JPanel jp=new JPanel();
jp.setPreferredSize(new Dimension(400,150));
this.add(jp);
this.setVisible(true);
gr= jp.getGraphics();
Test t=new Test();
fhj fh=new fhj(this,t);
jp.addMouseListener(fh);
fujian f=new fujian(jt1,jt2,t);
jb1.addActionListener(f);
jb2.addActionListener(f);
}
public static void setjt3(String s){
jt3.setText(s);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
fu f=new fu();
f.UI();
}
}
按下start触发事件fujian中的“start”
package First;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JTextField;
public class fujian implements ActionListener {
public JTextField jt1,jt2;
public Test tt;
public fujian( JTextField jt1,JTextField jt2,Test tt ){
this.jt1=jt1;
this.jt2=jt2;
this.tt=tt;
}
int co=0;
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand().equals("start")){
if(co==0){
fuxian u=new fuxian(jt1,tt);
u.start();
co=1;
}else{
System.out.println("端口已经成功创建无需再创建");
}
}
if(e.getActionCommand().equals("send")){
for(int i=0;i<tt.l.size();i++){
try {
tt.l.get(i).qunfa(jt2.getText());
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
}
}
启动一个线程fuxian u=new fuxian(jt1,tt); u.start()；来启动服务器
package First;
import javax.swing.JTextField;
public class fuxian extends Thread{
public JTextField jt;
public Test tt;
public fuxian(JTextField jt,Test tt){
this.jt=jt;
this.tt=tt;
}
public void run(){
int x=Integer.parseInt(jt.getText());
tt.set(x);
}
}
启动服务器的具体方法是Test类中的set()方法
package First;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import org.omg.CORBA_2_3.portable.OutputStream;
public class Test {
public ArrayList<Tx> l=new ArrayList<Tx>();
public void set(int x) {
//建立绑定在指定端口傻瓜的服务器
ServerSocket se;
try {
se = new ServerSocket(x);
System.out.println("服务器创建成功"+x);
Socket c;
//让服务器进入等待状态：
while(true){
c=se.accept();
Tx t=new Tx(c,this);
l.add(t);
System.out.println("目前队列的长度是"+l.size());
t.start();
}
}catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String[] args) {
}
}
其中public ArrayList<Tx> l=new ArrayList<Tx>();是一个Tx类型的队列，用来存储Tx对象
c=se.accept();
Tx t=new Tx(c,this);
l.add(t);
一旦有客户连接就启动Tx线程，并且将Tx对象存储，现在来看下Tx的具体类容
package First;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.ArrayList;
public class Tx extends Thread {
public DataInputStream Di;
public DataOutputStream Do;
public BufferedReader bf;
public int j=0;
public Socket c;
public String name="",r;
public java.io.OutputStream out;
public Test t1;
public InputStream in;
public Tx(Socket c,Test t1) throws Exception {
this.c=c;
this.t1=t1;
in=c.getInputStream();
Di=new DataInputStream(in);
out=c.getOutputStream();
Do=new DataOutputStream(out);
}
public void qunfa(String s) throws Exception{
s +="\r\n";
byte[] data=s.getBytes();
String t=new String(data);
System.out.println(t);
Do.writeByte(1);
Do.write(data);
}
public void jieshou() throws Exception{
//out=c.getOutputStream();
int k=Di.readByte();
if(k==0){
int x1=Di.readInt();
int y1=Di.readInt();
int x2=Di.readInt();
int y2=Di.readInt();
System.out.println("接受成功");
fu.gr.drawLine(x1, y1, x2, y2);
for(int i=0;i<t1.l.size();i++){
t1.l.get(i).Do.writeByte(0);
t1.l.get(i).Do.writeInt(x1);
t1.l.get(i).Do.writeInt(y1);
t1.l.get(i).Do.writeInt(x2);
t1.l.get(i).Do.writeInt(y2);
//t1.l.get(i).Do.flush();
System.out.println("传送成功");
}
}else if(k==1){
System.out.println("正在接受文字");
bf=new BufferedReader(new InputStreamReader(in));
r=bf.readLine();
System.out.println(r);
System.out.println("阅读完毕");
fu.setjt3(r);
String g="user"+r;
g+="\r\n";
byte[] e=g.getBytes();
for(int i=0;i<t1.l.size();i++){
t1.l.get(i).Do.writeByte(1);
t1.l.get(i).Do.write(e);
//t1.l.get(i).out.flush();
System.out.println("执行了-----------"+i);
System.out.println(r+"文字接受成功");
}
}else{
System.out.println("eeeeeeeeeeeeeeeeeeeee"+k);
}
}
public void X() throws Exception{
while(true){
System.out.println("主机接收");
jieshou();
}
}
public void run(){
try {
X();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
由
public void run(){
try {
X();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
看出是线程开启 X();x()里面是个死循环 一直执行jieshou()方法
接收分为两种一种是接收图象，一种接收文字（自己定义的协议）
客户端连接之后开启线程接收，为什么要存储起来呢
这样就能对每一个客户端进行管理了，你可以向某一个客户端发送，或者全部发送（里面的qunfa方法）
上面是服务器接收，现在看服务器发送，这是fujian里面的方法，按下send之后，获取输入框上的东东，调用qunfa发送，其中有一个循环，就是把所有连接进来的客户端Tx对像取出来调用发送方法qunffa（）
if(e.getActionCommand().equals("send")){
for(int i=0;i<tt.l.size();i++){
try {
tt.l.get(i).qunfa(jt2.getText());
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
然后就是可以看下如何传送图像
package First;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class fhj extends MouseAdapter{
public Test tt;
public fu f;
public int x1,x2,y1,y2;
public fhj(fu f,Test tt){
this.f=f;
this.tt=tt;
}
public void mousePressed(MouseEvent e){
x1=e.getX();
y1=e.getY();
}
public void mouseReleased(MouseEvent e){
x2=e.getX();
y2=e.getY();
f.gr.drawLine(x1,y1,x2,y2);
for(int i=0;i<tt.l.size();i++){
try {
// tt.l.get(i).Do.writeByte(1);
// String s="画线成功";
// s=s+"\r\n";
// byte[] b=s.getBytes();
//tt.l.get(i).Do.write(b);
tt.l.get(i).Do.writeByte(0);
tt.l.get(i).Do.writeInt(x1);
tt.l.get(i).Do.writeInt(y1);
tt.l.get(i).Do.writeInt(x2);
tt.l.get(i).Do.writeInt(y2);
System.out.println("发送成功-------------"+tt.l.size());
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}}
}
}
上面是对画板的监听，首先传入tt.l.get(i).Do.writeByte(0);0，（自己定义的格式，接收方如果首先接收到0，就执行接收图片的方法），然后就是传入线条的四个坐标，（关于鼠标监听，前面的博客java基础画图板有说过），这样服务器这边就写完了
/******************************************下面开始客户端的接收与发送*********************************/
客户端和服务器的接收和发送差不多，所以不再啰嗦
界面
package First;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Graphics;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextArea;
public class ku extends JFrame{
static String s;
static Graphics g;
static JTextArea jt1;
static JTextArea jt2;
public void UI(){
this.setTitle("客户端");
this.setSize(400,400);
this.setLocation(400,200);
this.setLayout(new FlowLayout(FlowLayout.CENTER));
this.setDefaultCloseOperation(3);
JButton jb1=new JButton("登录");
JButton jb2=new JButton("发送");
jt1=new JTextArea();
jt1.setPreferredSize(new Dimension(380,100));
jt2=new JTextArea();
jt2.setPreferredSize(new Dimension(380,100));
JPanel jp=new JPanel();
this.add(jp);
jp.setPreferredSize(new Dimension(380,100));
this.add(jt1);
this.add(jt2);
this.add(jb1);
this.add(jb2);
this.setVisible(true);
g=jp.getGraphics();
kejian ke=new kejian();
kbj kb=new kbj(this,ke);
jp.addMouseListener(kb);
jb1.addActionListener(ke);
jb2.addActionListener(ke);
}
public static void getjt2(){
s=jt2.getText();
}
public static void setjt2(){
jt2.setText("");
}
public static void setjt1(){
jt1.setText(s);
}
public static void setjt1(String st){
jt1.setText(st);
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ku t=new ku();
t.UI();
}
}
然后是连接和接收的方法，
package First;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class kehu extends Thread{
public int j=2;
public int i=0;
public BufferedReader bu;
public String ip;
public int pot;
public StringBuffer b=new StringBuffer() ;
public InputStream in;
static OutputStream out;
static DataInputStream Di;
static DataOutputStream Do;
//public kehu(String ip,int pot){this.ip=ip;this.pot=pot;}
public void login() throws Exception{
Socket s=new Socket( "172.16.27.47", 9090);
in=s.getInputStream();
out=s.getOutputStream();
Di=new DataInputStream(in);
Do=new DataOutputStream(out);
while(true){
System.out.println("等待循环");
js();
}
}
public void js() throws Exception{
System.out.print("客户端正在接受");
int k=Di.readByte();
if(k==0){
int x1=Di.readInt();
int y1=Di.readInt();
int x2=Di.readInt();
int y2=Di.readInt();
ku.g.drawLine(x1, y1, x2, y2);
}else if(k==1){
bu=new BufferedReader(new InputStreamReader(in));
String str=bu.readLine();
ku.setjt1(str);
System.out.println("设置窗体"+str);
}
}
public void run(){
try {
login();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
//new kehu().login("192.168.1.149", 9090);
}
}
这是放送的方法
package First;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;
public class kejian implements ActionListener{
public kehu k;
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
if(e.getActionCommand().equals("登录")){
try {
k=new kehu();
k.start();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
if(e.getActionCommand().equals("发送")){
ku.getjt2();
ku.setjt2();
String st=ku.s;
st+="\r\n";
System.out.println(st+"-------客户端发送成功-----------");
byte[] by=st.getBytes();
try {
k.Do.writeByte(1);
k.out.write(by);
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
}
}
画板发送的方法
package First;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.DataInputStream;
import java.io.DataOutputStream;
public class kbj extends MouseAdapter{
public int i=0;
public kejian ke;
public ku kk;
public int x1,x2,y1,y2;
public kbj(ku k,kejian ke2){
this.ke=ke2;
this.kk=k;
}
public void mousePressed(MouseEvent e){
x1=e.getX();
y1=e.getY();
}
public void mouseReleased(MouseEvent e){
x2=e.getX();
y2=e.getY();
try {
ke.k.Do.writeByte(0);
ke.k.Do.writeInt(x1);
ke.k.Do.writeInt(y1);
ke.k.Do.writeInt(x2);
ke.k.Do.writeInt(y2);
System.out.println("发送成功");
ke.k.Do.flush();
} catch (Exception e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
kk.g.drawLine(x1, y1, x2, y2);
}
}
源码已经上传，不懂之处可以留言，可以联系505860922
感谢分享
相关推荐
在这个名为“Java我的聊天器代码和界面”的项目中，开发者显然利用了Java的核心特性，如Socket通信和多线程技术，来构建一个功能完备的聊天器。下面我们将详细探讨这些关键知识点。 1. **Java Socket通信**： Java...
【Java JSP聊天器】是一种基于Java服务器页面技术（JSP）实现的在线聊天应用程序。在Web开发领域，JSP是用于创建动态网页的一种技术，它允许开发者将HTML、CSS和Java代码混合编写，以便在服务器端处理数据并生成响应...
【Java聊天器】是一款基于Java编程语言开发的即时通讯软件，它可以实现群聊和私聊功能，为用户提供方便快捷的沟通途径。虽然程序可能存在一些已知或未知的Bug，但其开源特性使得用户和开发者可以对其进行修改和优化...
【Java Swing聊天器详解】 Java Swing是Java标准库中的一个组件集，用于构建桌面应用程序，提供了丰富的用户界面元素。在本项目中，“基于Java swing的聊天器”是一个使用Swing来实现的简单模拟QQ聊天器，它允许...
Java简单聊天器模拟是一个基于网络通信的项目，主要利用了Socket编程来实现客户端与服务器端的交互。在本文中，我们将深入探讨这个项目的核心概念、技术实现和应用场景。 首先，我们要理解Socket的基本概念。Socket...
【Java实现QQ聊天器】 Java是一种广泛使用的编程语言，尤其在开发跨平台应用程序时，它的“一次编写，到处运行”的特性使得它成为理想的选择。在这个项目中，“用Java写的qq聊天器”是一个基于Java实现的在线聊天...
【Java网络聊天器】是一种基于Java编程语言实现的网络通信应用程序，主要用于实现用户之间的实时文本聊天功能。在计算机网络课程设计中，这类项目是学习网络编程、多线程和socket编程的重要实践。通过分析和研究这个...
首先，Java聊天工具的基础是Socket编程，这是网络应用程序之间通信的接口。Java的`java.net.Socket`和`ServerSocket`类提供了客户端和服务器之间的连接。在聊天应用中，服务器会监听特定端口，等待客户端的连接请求...
在Java编程领域，开发一个小型聊天器涉及到许多关键知识点，这些知识点构成了聊天应用程序的基础。以下是对这个"java聊天器源代码"的详细解读： 1. **Socket编程**：Java聊天器的核心是基于Socket进行网络通信。...
通过以上步骤，我们可以构建一个基础的Java Socket版的QQ聊天软件。然而，实际的QQ客户端包含了更多复杂的功能，如表情、图片发送、实时位置分享等，这需要更多的工作来实现，如处理不同类型的二进制数据、状态同步...
【JAVA 聊天器 多人聊天室】 在信息技术高速发展的今天，网络通信已经成为日常生活中不可或缺的一部分。JAVA 聊天器是一个基于JAVA技术实现的多人聊天室应用，它允许用户通过网络进行实时交流。这个项目涵盖了网络...
【Java局域网聊天器】是一款基于Java技术开发的局域网内通信工具，它集成了公聊、私聊以及文件传输功能，充分利用了Java的IO流、多线程（Thread）以及套接字（Socket）等核心概念，使得用户在局域网环境下可以便捷地...
在这个简易QQ聊天工具中，开发者可能使用了Java的基础语法，如类、对象、接口、异常处理、输入输出流等，来实现程序的基本结构和功能。 2. **Swing或JavaFX图形用户界面**：Java提供了Swing和JavaFX库用于构建桌面...
【Java聊天器C/S架构详解】 在IT领域，开发一个聊天应用程序是常见的实践项目，而本文将深入探讨如何使用Java语言、Eclipse IDE以及C/S（客户端/服务器）架构来构建一个聊天GUI（图形用户界面）应用。我们将讨论...
1. **Servlet**：Servlet是Java EE中的核心组件之一，用于扩展服务器的功能。在本项目中，Servlet充当了HTTP协议的处理器，接收并响应来自客户端（通常是浏览器）的请求，处理业务逻辑，并向客户端返回响应。 2. **...
8. **网络编程协议**：尽管Java聊天器可能采用自定义的简单协议，但了解TCP/IP协议基础是必要的，因为它是互联网通信的基础。TCP确保了数据的可靠传输，而IP负责将数据包路由到正确的目的地。 9. **异常处理**：在...
1. **网络编程**：Java聊天程序的基础是网络通信，这通常涉及到Socket编程。Socket是TCP/IP协议族的一部分，用于建立两个节点间的通信连接。在Java中，`java.net.Socket` 和 `java.net.ServerSocket` 类提供了创建和...
Java聊天器的实现离不开网络编程基础，如TCP/IP协议的理解，socket编程，以及数据的序列化与反序列化。TCP保证了数据的可靠传输，而序列化则确保了对象在网络中的安全传输。 8. **多线程** 由于服务器需要同时...
本项目名为“Java简单聊天程序”，旨在提供一个基础的、易于理解的示例，帮助初学者掌握Java网络编程的基本概念和技术。在这个简单的聊天程序中，我们将探讨以下几个关键知识点： 1. **Socket编程**：Java的Socket...