socket编程实例java（通过Java中的Socket技术编写能够进行双向通信的客户端和服务器，为了能够同时进行消息的发送和接受，在服）
本文目录
- 通过Java中的Socket技术编写能够进行双向通信的客户端和服务器，为了能够同时进行消息的发送和接受，在服
- 怎么用java的socket进行文件传输谁能给个简单的例子，包括发送端和接收端
- Java Socket初步详解
- java对外提供多个socket接口
- java socket简单程序
- 用JAVA编写一个socket通信程序
- JAVA问题：用socket编写一个服务器端程序
- 利用Java编写一个程序利用Socket，实现网络的点对点文件传输并且能实现聊天，发个给我学习下，好吗
- Java进行并发多连接socket编程
通过Java中的Socket技术编写能够进行双向通信的客户端和服务器，为了能够同时进行消息的发送和接受，在服
SocketClient1.java内容如下：
package com.polyphylla.socket;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
public class SocketClient1 {
private Socket socket;
public SocketClient1() {
try {
socket = new Socket("127.0.0.1", 2222);
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @param args
*/
public static void main(String args) {
new SocketClient1().startClient();
}
public void startClient() {
new Thread(new ClientReader(socket)).start();
new Thread(new ClientWriter(socket)).start();
}
}
class ClientReader implements Runnable {
private Socket socket;
public ClientReader(Socket socket) {
this.socket = socket;
}
public void run() {
BufferedReader br = getReader();
String msg = null;
try {
while ((msg = br.readLine()) != null) {
System.out.println("client:" + msg);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br != null)
br.close();
if (socket != null)
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private BufferedReader getReader() {
try {
return new BufferedReader(new InputStreamReader(socket
.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
class ClientWriter implements Runnable {
private Socket socket;
public ClientWriter(Socket socket) {
this.socket = socket;
}
public void run() {
PrintWriter pw = getWriter();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
try {
while ((str = br.readLine()) != null) {
pw.println(str);
pw.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (pw != null)
pw.close();
try {
if (socket != null)
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private PrintWriter getWriter() {
try {
return new PrintWriter(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
SocketServer1.java内容如下：
package com.polyphylla.socket;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketServer1 {
private ServerSocket ss;
public SocketServer1() {
try {
ss = new ServerSocket(2222);
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String args) {
new SocketServer1().startServer();
}
public void startServer() {
try {
while (true) {
Socket s = ss.accept();
new Thread(new ServerReader(s)).start();
new Thread(new ServerWriter(s)).start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
class ServerReader implements Runnable {
private Socket socket;
public ServerReader(Socket socket) {
this.socket = socket;
}
public void run() {
BufferedReader br = getReader();
String msg = null;
try {
while((msg = br.readLine()) != null) {
System.out.println("server:" + msg);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(br != null)
br.close();
if(socket != null)
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private BufferedReader getReader() {
try {
return new BufferedReader(new InputStreamReader(socket.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
class ServerWriter implements Runnable {
private Socket socket;
public ServerWriter(Socket socket) {
this.socket = socket;
}
public void run() {
PrintWriter pw = getWriter();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
try {
while((str = br.readLine()) != null) {
pw.println(str);
pw.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (pw != null)
pw.close();
try {
if (socket != null)
socket.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
private PrintWriter getWriter() {
try {
return new PrintWriter(socket.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}
怎么用java的socket进行文件传输谁能给个简单的例子，包括发送端和接收端
java中的网络信息传输方式是基于TCP协议或者UD协议P的,socket是基于TCP协议的
例子1
（1）客户端程序：
import java.io.*;
import java.net.*;
public class Client
{ public static void main(String args)
{ String s=null;
Socket mysocket;
DataInputStream in=null;
DataOutputStream out=null;
try{
mysocket=new Socket("localhost",4331);
in=new DataInputStream(mysocket.getInputStream());
out=new DataOutputStream(mysocket.getOutputStream());
out.writeUTF("你好！");//通过 out向"线路"写入信息。
while(true)
{
s=in.readUTF();//通过使用in读取服务器放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF(":"+Math.random());
System.out.println("客户收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println("无法连接");
}
catch(InterruptedException e){}
}
}
（2）服务器端程序：
import java.io.*;import java.net.*;
public class Server
{ public static void main(String args)
{ ServerSocket server=null;
Socket you=null;String s=null;
DataOutputStream out=null;DataInputStream in=null;
try{ server=new ServerSocket(4331);}
catch(IOException e1){System.out.println("ERRO:"+e1);}
try{ you=server.accept();
in=new DataInputStream(you.getInputStream());
out=new DataOutputStream(you.getOutputStream());
while(true)
{
s=in.readUTF();// 通过使用in读取客户放入"线路"里的信息。堵塞状态，
//除非读取到信息。
out.writeUTF("你好:我是服务器");//通过 out向"线路"写入信息.
out.writeUTF("你说的数是:"+s);
System.out.println("服务器收到:"+s);
Thread.sleep(500);
}
}
catch(IOException e)
{ System.out.println(""+e);
}
catch(InterruptedException e){}
}
}
例子(2)
(1) 客户端
import java.net.*;import java.io.*;
import java.awt.*;import java.awt.event.*;
import java.applet.*;
public class Computer_client extends Applet implements Runnable,ActionListener
{ Button 计算;TextField 输入三边长度文本框,计算结果文本框;
Socket socket=null;
DataInputStream in=null; DataOutputStream out=null;
Thread thread;
public void init()
{ setLayout(new GridLayout(2,2));
Panel p1=new Panel(),p2=new Panel();
计算=new Button(" 计算");
输入三边长度文本框=new TextField(12);计算结果文本框=new TextField(12);
p1.add(new Label("输入三角形三边的长度,用逗号或空格分隔:"));
p1.add( 输入三边长度文本框);
p2.add(new Label("计算结果："));p2.add(计算结果文本框);p2.add(计算);
计算.addActionListener(this);
add(p1);add(p2);
}
public void start()
{ try
{ //和小程序所驻留的服务器建立套接字连接：
socket = new Socket(this.getCodeBase().getHost(), 4331);
in =new DataInputStream(socket.getInputStream());
out = new DataOutputStream(socket.getOutputStream());
}
catch (IOException e){}
if(thread == null)
{ thread = new Thread(this);
thread.start();
}
}
public void run()
{ String s=null;
while(true)
{ try{ s=in.readUTF();//堵塞状态，除非读取到信息。
计算结果文本框.setText(s);
}
catch(IOException e)
{ 计算结果文本框.setText("与服务器已断开");
break;
}
}
}
public void actionPerformed(ActionEvent e)
{ if(e.getSource()==计算)
{ String s=输入三边长度文本框.getText();
if(s!=null)
{ try { out.writeUTF(s);
}
catch(IOException e1){}
}
}
}
}
(2) 服务器端
import java.io.*;import java.net.*;
import java.util.*;import java.sql.*;
public class Computer_server
{ public static void main(String args)
{ ServerSocket server=null;Server_thread thread;
Socket you=null;
while(true)
{ try{ server=new ServerSocket(4331);
}
catch(IOException e1)
{ System.out.println("正在监听"); //ServerSocket对象不能重复创建。
}
try{ you=server.accept();
System.out.println("客户的地址:"+you.getInetAddress());
}
catch (IOException e)
{ System.out.println("正在等待客户");
}
if(you!=null)
{ new Server_thread(you).start(); //为每个客户启动一个专门的线程。
}
else
{ continue;
}
}
}
}
class Server_thread extends Thread
{ Socket socket;Connection Con=null;Statement Stmt=null;
DataOutputStream out=null;DataInputStream in=null;int n=0;
String s=null;
Server_thread(Socket t)
{ socket=t;
try { in=new DataInputStream(socket.getInputStream());
out=new DataOutputStream(socket.getOutputStream());
}
catch (IOException e)
{}
}
public void run()
{ while(true)
{ double a ;int i=0;
try{ s=in.readUTF();堵塞状态，除非读取到信息。
StringTokenizer fenxi=new StringTokenizer(s," ,");
while(fenxi.hasMoreTokens())
{ String temp=fenxi.nextToken();
try{ a=Double.valueOf(temp).doubleValue();i++;
}
catch(NumberFormatException e)
{ out.writeUTF("请输入数字字符");
}
}
double p=(a)/2.0;
out.writeUTF(" "+Math.sqrt(p*(p-a)));
sleep(2);
}
catch(InterruptedException e){}
catch (IOException e)
{ System.out.println("客户离开");
break;
}
}
}
}
这些例子都是Java2实用教程上的.
Java Socket初步详解
网络编程的基本模型就是客户机到服务器模型 简单的说就是两个进程之间相互通讯 然后其中一个必须提供一个固定的位置 而另一个则只需要知道这个固定的位置 并去建立两者之间的联系 然后完成数据的通讯就可以了 这里提供固定位置的通常称为服务器 而建立联系的通常叫做客户端 基于这个简单的模型 就可以进入网络编程啦
Java对这个模型的支持有很多种Api 而这里我只想介绍有关Socket的编程接口 对于Java而言已经简化了Socket的编程接口 首先我们来讨论有关提供固定位置的服务方是如何建立的 Java提供了ServerSocket来对其进行支持 事实上当你创建该类的一个实力对象并提供一个端口资源你就建立了一个固定位置可以让其他计算机来访问你 ServerSocket server=new ServerSocket( );这里稍微要注意的是端口的分配必须是唯一的 因为端口是为了唯一标识每台计算机唯一服务的 另外端口号是从 ~ 之间的 前 个端口已经被Tcp/Ip 作为保留端口 因此你所分配的端口只能是 个之后的 好了 我们有了固定位置 现在所需要的就是一根连接线了 该连接线由客户方首先提出要求 因此Java同样提供了一个Socket对象来对其进行支持 只要客户方创建一个Socket的实例对象进行支持就可以了 Socket client
=new Socket(InetAddress getLocalHost() );客户机必须知道有关服务器的IP地址 对于著一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供 它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法
上面的方法基本可以建立一条连线让两台计算机相互交流了 可是数据是如何传输的呢？事实上I/O操作总是和网络编程息息相关的 因为底层的网络是继续数据的 除非远程调用 处理问题的核心在执行上 否则数据的交互还是依赖于IO操作的 所以你也必须导入java io这个包 java的IO操作也不复杂 它提供了针对于字节流和Unicode的读者和写者 然后也提供了一个缓冲用于数据的读写
BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));
PrintWriter out=new PrintWriter(server getOutputStream());
上面两句就是建立缓冲并把原始的字节流转变为Unicode可以操作 而原始的字节流来源于Socket的两个方法 getInputStream()和getOutputStream()方 分别用来得到输入和输出 那么现在有了基本的模型和基本的操作工具 我们可以做一个简单的Socket例程了
服务方:
import java io *;
import *;
public class MyServer {
public static void main(String args) throws IOException{
ServerSocket server=new ServerSocket( );
Socket client=server accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
PrintWriter out=new PrintWriter(client getOutputStream());
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到 客户机发送 End 字符串就退出程序 并且服务器也会做出 Receive 为回应 告知客户机已接收到消息
客户机代码:
import *;
import java io *;
public class Client{
static Socket server;
public static void main(String args)throws Exception{
server=new Socket(InetAddress getLocalHost() );
BufferedReader in=new BufferedReader(new InputStreamReader(server getInputStream()));
PrintWriter out=new PrintWriter(server getOutputStream());
BufferedReader wt=new BufferedReader(new InputStreamReader(System in));
while(true){
String str=wt readLine();
out println(str);
out flush();
if(str equals( end )){
break;
}
System out println(in readLine());
}
server close();
}
}
客户机代码则是接受客户键盘输入 并把该信息输出 然后输出 End 用来做退出标识
这个程序只是简单的两台计算机之间的通讯 如果是多个客户同时访问一个服务器呢？你可以试着再运行一个客户端 结果是会抛出异常的 那么多个客户端如何实现呢?
其实 简单的分析一下 就可以看出客户和服务通讯的主要通道就是Socket本身 而服务器通过accept方法就是同意和客户建立通讯 这样当客户建立Socket的同时 服务器也会使用这一根连线来先后通讯 那么既然如此只要我们存在多条连线就可以了 那么我们的程序可以变为如下:
服务器:
import java io *;
import *;
public class MyServer {
public static void main(String args) throws IOException{
ServerSocket server=new ServerSocket( );
while(true){
Socket client=server accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
PrintWriter out=new PrintWriter(client getOutputStream());
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}
}
}
这里仅仅只是加了一个外层的While循环 这个循环的目的就是当一个客户进来就为它分配一个Socket直到这个客户完成一次和服务器的交互 这里也就是接受到客户的 End 消息 那么现在就实现了多客户之间的交互了 但是 问题又来了 这样做虽然解决了多客户 可是是排队执行的 也就是说当一个客户和服务器完成一次通讯之后下一个客户才可以进来和服务器交互 无法做到同时服务 那么要如何才能同时达到既能相互之间交流又能同时交流呢？很显然这是一个并行执行的问题了 所以线程是最好的解决方案
那么下面的问题是如何使用线程 首先要做的事情是创建线程并使得其可以和网络连线取得联系 然后由线程来执行刚才的操作 要创建线程要么直接继承Thread要么实现Runnable接口 要建立和Socket的联系只要传递引用就可以了 而要执行线程就必须重写run方法 而run方法所做的事情就是刚才单线程版本main所做的事情 因此我们的程序变成了这样:
import *;
import java io *;
public class MultiUser extends Thread{
private Socket client;
public MultiUser(Socket c){
this client=c;
}
public void run(){
try{
BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream()));
PrintWriter out=new PrintWriter(client getOutputStream());
//Mutil User but can t parallel
while(true){
String str=in readLine();
System out println(str);
out println( has receive );
out flush();
if(str equals( end ))
break;
}
client close();
}catch(IOException ex){
}finally{
}
}
public static void main(String args)throws IOException{
ServerSocket server=new ServerSocket( );
while(true){
//transfer location change Single User or Multi User
MultiUser mu=new MultiUser(server accept());
mu start();
}
}
}
lishixinzhi/Article/program/Java/hx/201311/27013java对外提供多个socket接口
Java可利用ServerSocket类对外部客户端提供多个socket接口。
基本的做法是先创建一个ServerSocket实例，并绑定一个指定的端口，然后在这个实例上调用accept()方法等待客户端的连接请求。一旦有连接请求到来，ServerSocket将返回一个Socket实例，可以用这个Socket实例进行数据的收发和处理。需要对外提供多个端口的情况下，只需在不同的ServerSocket实例上分别执行上述操作即可。
Java是一种面向对象的编程语言，由SunMicrosystems公司（现在为Oracle公司）在20世纪90年代开发。它被广泛应用于开发各种类型的软件、应用程序和大型系统。Java具有跨平台的特性，可在不同的操作系统上运行，其平台无关性使得开发者可以轻松地开发和构建高质量的可移植性应用程序。Java具有安全性高、可靠性强、代码简洁等优点，已经成为现代软件开发的重要工具之一。
java socket简单程序
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
public class ChatServer {
public static void main(String args) {
try {
System.out.println("服务已启动。。。客户端可连接。。");
Socket
socket = new ServerSocket(10000).accept();
BufferedReader
in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
PrintWriter
out = new PrintWriter(socket.getOutputStream());
while (true) {
String msg
= in.readLine();
System.out.println("服务端收到的信息:" + msg);
out.println("server
receive:" + msg);
out.flush();
if (msg.equals("bye")) {
break;
}
}
socket.close();
}
catch (IOException e) {
// TODO
Auto-generated catch block
e.printStackTrace();
}
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
public class ChatClient {
public static void main(String args) {
try {
System.out.println("请输入聊天内容，将会发送到服务器");
Socket
socket = new Socket("localhost",
10000);
BufferedReader
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter
out = new PrintWriter(socket.getOutputStream());
BufferedReader
reader = new BufferedReader(new InputStreamReader(System.in));
while (true) {
String msg
= reader.readLine();
out.println(msg);
out.flush();
if (msg.equals("bye")) {
break;
}
System.out.println(in.readLine());
}
socket.close();
}
catch (IOException e) {
// TODO
Auto-generated catch block
e.printStackTrace();
}
}
}
用JAVA编写一个socket通信程序
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String args) {
ServerSocket ss;
Socket s;
try {
ss = new ServerSocket(8888);
s = ss.accept();
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
System.out.println(br.readLine());
br.close();
isr.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
import java.io.PrintWriter;
import java.net.Socket;
public class Client {
public static void main(String args) {
try {
Socket s = new Socket("127.0.0.1", 8888);
PrintWriter pw = new PrintWriter(s.getOutputStream());
pw.write("hello server");
pw.flush();
pw.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
JAVA问题：用socket编写一个服务器端程序
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
publicclass Server
{
private ServerSocket ss;
private Socket socket;
private BufferedReader in;
private PrintWriter out;
public Server()
{
try
{
ss = new ServerSocket(10000);
while (true)
{
socket = ss.accept();
String RemoteIP = socket.getInetAddress().getHostAddress();
String RemotePort = ":" + socket.getLocalPort();
System.out.println("A clientcome in!IP:" + RemoteIP
+ RemotePort);
in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String line = in.readLine();
System.out.println("Cleint sendis :" + line);
out = new PrintWriter(socket.getOutputStream(), true);
out.println("YourMessage Received!");
out.close();
in.close();
socket.close();
}
}
catch (IOException e)
{
out.println("wrong");
}
}
publicstaticvoid main(String args)
{
new Server();
}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
publicclass Client {
Socket socket;
BufferedReader in;
PrintWriter out;
public Client()
{
try
{
System.out.println("Try toConnect to 127.0.0.1:10000");
socket = new Socket("127.0.0.1", 10000);
System.out.println("The ServerConnected!");
System.out.println("Pleaseenter some Character:");
BufferedReader line = new BufferedReader(new
InputStreamReader(System.in));
out = new PrintWriter(socket.getOutputStream(), true);
out.println(line.readLine());
in = new BufferedReader(new InputStreamReader(socket
.getInputStream()));
System.out.println(in.readLine());
out.close();
in.close();
socket.close();
}
catch (IOException e)
{
out.println("Wrong");
}
}
publicstaticvoid main(String args)
{
new Client();
}
}
你再改改代码就可以了.但我没时间帮你调了……
利用Java编写一个程序利用Socket，实现网络的点对点文件传输并且能实现聊天，发个给我学习下，好吗
这个时比较简单的。
package QQ;
import java.net.*;
import java.io.*;
import java.sql.*;
import java.util.*;
public class QQServer {
public static void main(String args) {
try {
HashMap《String , Socket》 hm = new
HashMap《String , Socket》() ;
// 服务器到8000端口监听(1)
ServerSocket ss = new ServerSocket
(8000);
while (true) {
System.out.println("服务器正在
8000端口监听.....");
Socket s = ss.accept();
MyService t = new MyService();
t.setSocket(s) ;
t.setHashMap(hm) ;
t.start();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
class MyService extends Thread {
private Socket s ;
private HashMap《String , Socket》 hm ;
public void setHashMap(HashMap《String , Socket》 hm){
this.hm = hm ;
}
public void setSocket(Socket s){
this.s = s ;
}
public void run() {
try {
// 接收客户端发送来的用户名和密码(2)
InputStream is = s.getInputStream();
InputStreamReader isr = new InputStreamReader
(is);
BufferedReader br = new BufferedReader(isr);
String uandp = br.readLine();
// 拆分用户名和密码(4)
String u = "";
String p = "";
try{
u = uandp.split("%");
p = uandp.split("%");
}catch(Exception e){}
// 到数据库中验证(5)
Class.forName
("com.microsoft.jdbc.sqlserver.SQLServerDriver");
Connection cn = DriverManager
.getConnection(
"jdbc:microsoft:sqlserver://127.0.0.1:1433;databasename=qq2",
"sa", "123");
PreparedStatement ps = cn
.prepareStatement("select
username from username where username=? and password=?");
ps.setString(1, u);
ps.setString(2, p);
ResultSet rs = ps.executeQuery();
// 发送确认信息到客户端(7)
OutputStream os = s.getOutputStream();
OutputStreamWriter osw = new
OutputStreamWriter(os);
PrintWriter pw = new PrintWriter(osw, true);
if (rs.next()) {
pw.println("ok");
//将自己的名字发送给HashMap中的其他人
(13)
for(Socket ts : hm.values()){
OutputStream tos =
ts.getOutputStream() ;
OutputStreamWriter tosw = new
OutputStreamWriter(tos) ;
PrintWriter tpw = new
PrintWriter(tosw , true) ;
tpw.println("user%"+u) ;
}
//将其他人的名字发送给自己(13)
for(String tu : hm.keySet()){
pw.println("user%"+tu) ;
}
//将用户名和对应的Socket存入HashMap
(13)
hm.put(u, s) ;
// 接收客户端发送来的信息(11)
while (true) {
String message = br.readLine
();
if(message.equals("exit")){
for(Socket ts :
hm.values()){
OutputStream
tos = ts.getOutputStream() ;
OutputStreamWriter tosw = new OutputStreamWriter(tos) ;
PrintWriter
tpw = new PrintWriter(tosw , true) ;
tpw.println
("exit%"+u);
}
hm.remove(u);
}
String to = message.split
("%");
String mess = message.split
("%");
Socket ts = hm.get(to);
OutputStream tos =
ts.getOutputStream();
OutputStreamWriter tosw = new
OutputStreamWriter(tos);
PrintWriter tpw = new
PrintWriter(tosw, true);
tpw.println("mess%"+mess
+"\n");
System.out.println(message);
}
} else {
pw.println("err");
}
} catch (Exception e) {}
}
}
Java进行并发多连接socket编程
Java多个客户端同时连接服务端 在现实生活中用得比较多 同时执行多项任务 第一想到的当然是多线程了 下面用多线程来实现并发多连接
import java net *;import java io *;
public class ThreadServer extends Thread{ private Socket client;
public ThreadServer(Socket c) { this client=c; }
public void run() { try { BufferedReader in=new BufferedReader(new InputStreamReader(client getInputStream())); PrintWriter out=new PrintWriter(client getOutputStream()); //Mutil User but can t parallel
while (true) { String str=in readLine(); System out println(str); out println( has receive ); out flush(); if (str equals( end )) break; } client close(); } catch (IOException ex) { } finally {
} } public static void main(String args)throws IOException { ServerSocket server=new ServerSocket( ); while (true) { //transfer location change Single User or Multi User
lishixinzhi/Article/program/Java/hx/201311/27248
本文相关文章：
2026年10月1日 17:20
java购物车实现流程（JAVA语言编写的网上订餐系统购物车功能如何实现）
2026年9月4日 15:00
网页制作的超文本标记语言（怎样使用超文本标记语言_用超文本标记语言可以编写homepage）
2026年8月6日 18:20
如何编写一个shell脚本代码（如何编写一个shell脚本）
2026年8月2日 15:20
2026年7月4日 03:50
更多文章：
2026年10月23日 05:30
2026年10月23日 04:30
jquery动态添加表格行（如何通过jquery动态给表格添加一行）
2026年10月23日 00:30
cmake命令行参数（CMake （三）cmake 在工程中的用法）
2026年10月23日 00:00
2026年10月22日 23:50
linux数据备份命令（Linux系统下常用的数据备份方法有哪些）
2026年10月22日 23:20
2026年10月22日 23:10
executequery返回值（ExecuteQuery（sql）的返回值）
2026年10月22日 23:00
2026年10月22日 22:50
舍曲林吃了一周越来越严重（我母亲77岁，服用舍曲林一周，开始半片，4天后改为1片，第三天开始失眠，第四天出现乏力、食欲下降，）
2026年10月22日 21:00
