先开服务器，再开客户端。 import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 创建服务器
* 写出数据：输出流
* 读取数据：输入流
*/
public class Server {
public static void main(String[] args) throws IOException {
ServerSocket server =new ServerSocket();
Socket client =server.accept();
//写出数据
//输入流
DataInputStream dis = new DataInputStream(client.getInputStream());
String msg =dis.readUTF();
//输出流
DataOutputStream dos = new DataOutputStream(client.getOutputStream());
dos.writeUTF("服务器-->"+msg);
dos.flush();
}
} import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;
/**
* 创建客户端: 发送数据+接收数据
* 写出数据：输出流
* 读取数据：输入流
*/
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket client = new Socket("localhost",);
//把控制台输入封装成输入流
BufferedReader console = new BufferedReader(new InputStreamReader(System.in));
DataOutputStream dos = new DataOutputStream(client.getOutputStream());
DataInputStream dis = new DataInputStream(client.getInputStream());
while(true){
String info =console.readLine();//根据输入的换行符读取一行。
//输出流，输出去在读进来。
dos.writeUTF(info);
dos.flush();
//输入流
String msg =dis.readUTF();
System.out.println(msg);
}
}
} 聊天室：
. 客户端可以发送数据 +接收数据 独立的
. 每个客户端创建一个线程，彼此相互独立。 输入流 与输出流 在同一个线程内 应该 独立处理，彼此独立。 a客户端发送数据给服务器，服务器中转给b、c客户端。所以服务器要为每一个客户端建立一个线程。服务器为每一个客户端服务时，每个客户端都有输入流和输出流，客户端的输入流和输出流也是独立的所以也是线程。并且有私聊的功能。 import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException; /**
* 创建客户端: 发送数据+接收数据
* 写出数据：输出流
* 读取数据：输入流
*
输入流 与输出流 在同一个线程内 应该 独立处理，彼此独立 加入名称
*/
public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
System.out.println("请输入名称:");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String name = br.readLine();
if(name.equals("")){
return;
}
Socket client = new Socket("localhost",);
new Thread(new Send(client,name)).start(); //一条路径
new Thread(new Receive(client)).start(); //一条路径
}
} /**
* 接收线程
*/
public class Receive implements Runnable {
//输入流
private DataInputStream dis ;
//线程标识
private boolean isRunning = true;
public Receive() {
}
public Receive(Socket client){
try {
dis = new DataInputStream(client.getInputStream());
} catch (IOException e) {
e.printStackTrace();
isRunning =false;
CloseUtil.closeAll(dis);
}
}
/**
* 接收数据
*/
public String receive(){
String msg ="";
try {
msg=dis.readUTF();
} catch (IOException e) {
e.printStackTrace();
isRunning =false;
CloseUtil.closeAll(dis);
}
return msg;
}
@Override
public void run() {
//线程体
while(isRunning){
System.out.println(receive());
}
}
} /**
* 发送数据 线程
*/
public class Send implements Runnable{
//控制台输入流
private BufferedReader console;
//管道输出流
private DataOutputStream dos;
//控制线程
private boolean isRunning =true;
//名称
private String name;
public Send() {
console =new BufferedReader(new InputStreamReader(System.in));
}
public Send(Socket client,String name){
this();
try {
dos =new DataOutputStream(client.getOutputStream());
this.name =name;
send(this.name);
} catch (IOException e) {
//e.printStackTrace();
isRunning =false;
CloseUtil.closeAll(dos,console); }
}
//1、从控制台接收数据
private String getMsgFromConsole(){
try {
return console.readLine();
} catch (IOException e) {
//e.printStackTrace();
}
return "";
}
/**
* 1、从控制台接收数据
* 2、发送数据
*/
public void send(String msg){
try {
if(null!=msg&& !msg.equals("")){
dos.writeUTF(msg);
dos.flush(); //强制刷新
}
} catch (IOException e) {
//e.printStackTrace();
isRunning =false;
CloseUtil.closeAll(dos,console);
}
} @Override
public void run() {
//线程体
while(isRunning){
send(getMsgFromConsole());
}
} } /**
* 创建服务器
* 写出数据：输出流
* 读取数据：输入流
*/
public class Server {
private List<MyChannel> all = new ArrayList<MyChannel>(); public static void main(String[] args) throws IOException {
new Server().start(); } public void start() throws IOException{
ServerSocket server =new ServerSocket();
while(true){
Socket client =server.accept();
MyChannel channel = new MyChannel(client);
all.add(channel);//统一管理
new Thread(channel).start(); //一条道路
}
} /**
* 一个客户端 一条道路
* 1、输入流
* 2、输出流
* 3、接收数据
* 4、发送数据
*/
private class MyChannel implements Runnable{
private DataInputStream dis ;
private DataOutputStream dos ;
private boolean isRunning =true;
private String name;
public MyChannel(Socket client ) {
try {
dis = new DataInputStream(client.getInputStream());
dos = new DataOutputStream(client.getOutputStream());
this.name =dis.readUTF();
this.send("欢迎您进入聊天室");
sendOthers(this.name+"进入了聊天室",true);
} catch (IOException e) {
//e.printStackTrace();
CloseUtil.closeAll(dis,dos);
isRunning =false;
}
}
/**
* 读取数据
* @return
*/
private String receive(){
String msg ="";
try {
msg=dis.readUTF();
} catch (IOException e) {
//e.printStackTrace();
CloseUtil.closeAll(dis);
isRunning =false;
all.remove(this); //移除自身
}
return msg;
} /**
* 发送数据
*/
private void send(String msg){
if(null==msg ||msg.equals("")){
return ;
}
try {
dos.writeUTF(msg);
dos.flush();
} catch (IOException e) {
//e.printStackTrace();
CloseUtil.closeAll(dos);
isRunning =false;
all.remove(this); //移除自身
}
} /**
* 发送给其他客户端
*/
private void sendOthers(String msg,boolean sys){
//是否为私聊 约定
if(msg.startsWith("@")&& msg.indexOf(":")>- ){ //私聊
//获取name
String name =msg.substring(,msg.indexOf(":"));
String content = msg.substring(msg.indexOf(":")+);
for(MyChannel other:all){
if(other.name.equals(name)){
other.send(this.name+"对您悄悄地说:"+content);
}
}
}else{
//遍历容器
for(MyChannel other:all){
if(other ==this){
continue;
}
if(sys){ //系统信息
other.send("系统信息:"+msg);
}else{
//发送其他客户端
other.send(this.name+"对所有人说:"+msg);
}
}
}
} @Override
public void run() {
while(isRunning){
sendOthers(receive(),false);
}
}
} } /**
* 关闭流的方法
*/
public class CloseUtil {
public static void closeAll(Closeable... io){
for(Closeable temp:io){
try {
if (null != temp) {
temp.close();
}
} catch (Exception e) {
// TODO: handle exception
}
}
}
}