本篇文章给大家谈谈javasocket客户端程序，以及websocket服务端java对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
1、求一个简单JAVA, socket 客户端 .2、基于JAVA socket的服务器客户端编程3、[java]利用socket class作成客户端程序4、求一个JAVA socket客户端程序，急！！！5、JAVA 问题，用socket编写一个客户端程序
求一个简单JAVA, socket 客户端 .
给你一个简单的示例代码吧。服务器，客户端的都有。
客户端：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Date;
public class TCPClent {
public static void main(String[] args) throws UnknownHostException,
IOException {
Socket socket = new Socket(“www.easyaq.com”, 5000);
OutputStream outputStream = socket.getOutputStream();
outputStream.write((“connect to the server at time ” + new Date()
.toString()).getBytes());
outputStream.flush();
System.out.println(socket);
InputStream is = socket.getInputStream();
byte[] bytes = new byte[1024];
int n = is.read(bytes);
System.out.println(new String(bytes, 0, n));
is.close();
socket.close();
}
}
服务器：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;
public class TCPServer {
static int i = 1;
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(5000);
while (true) {
final Socket socket = serverSocket.accept();
new Thread() {
Socket mySocket = socket;
@Override
public void run() {
try {
System.out.println(mySocket);
InputStream is = mySocket.getInputStream();
byte[] bytes = new byte[1024];
int n = is.read(bytes);
System.out.println(new String(bytes, 0, n));
OutputStream os = mySocket.getOutputStream();
os.write((i++ + “:server reply at time ” + new Date()
.toString()).getBytes());
mySocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}
}
}
基于JAVA socket的服务器客户端编程
要完成这个工作，需要完成三个部分的工作，以下依次说明：
一、建立服务器类
Java中有一个专门用来建立Socket服务器的类，名叫ServerSocket,可以用服务器需要使用的端口号作为参数来创建服务器对象。
ServerSocket server = new ServerSocket(9998)
这条语句创建了一个服务器对象，这个服务器使用9998号端口即在端口9998上注册服务，这里稍微要注意的是端口的分配必须是唯一的。因为端口是为了唯一标识每台计算机唯一服务的，另外端口号是从0~65535之间的，前1024个端口已经被Tcp/Ip 作为保留端口，因此你所分配的端口只能是1024个之后的。当一个客户端程序建立一个Socket连接，所连接的端口号为9998时，服务器对象server便响应这个连接，并且server.accept()方法会创建一个Socket对象。服务器端便可以利用这个Socket对象与客户进行通讯。
Socket incoming = server.accept() ; // 监听窗口,等待连接
进而得到输入流和输出流,并进行封装
BufferedReader in = new BufferedReader(new
InputStreamReader(incoming.getInputStream()));
/*
当读取文件时，先把内容读到缓存中，当调用in.readLine()时，再从缓存中以字符的方式读取数据（以下简称“缓存字节读取方式”）。
*/
PrintWriter ut = new PrintWriter(incoming.getOutputStream(),true);
随后，就可以使用in.readLine()方法得到客户端的输入，也可以使用out.println()方法向客户端发送数据。从而可以根据程序的需要对客户端的不同请求进行回应。
在所有通讯结束以后应该关闭这两个数据流，关闭的顺序是先关闭输出流，再关闭输入流，即使用
out.close();
in.close();
二、建立客户端代码
相比服务器端，客户端要简单一些，客户端只需用服务器所在机器的ip以及服务器的端口作为参数创建一个Socket对象。得到这个对象后，就可以用”建立服务器”部分介绍的方法实现数据的输入和输出。
Socket socket = new Socket(“168.160.12.42”,9998);
或：
Socket socket = new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
客户机必须知道有关服务器的IP地址，对于着一点Java也提供了一个相关的类InetAddress 该对象的实例必须通过它的静态方法来提供，它的静态方法主要提供了得到本机IP 和通过名字或IP直接得到InetAddress的方法。
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
以上的程序代码建立了一个Socket对象，这个对象连接到ip地址为168.160.12.42的主机上、端口为9998的服务器对象。并且建立了输入流和输出流，分别对应服务器的输出和客户端的写入。
三、实例分析
服务方:
import java.io.*;
import java.net.*;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678); //在端口5678上注册服务
Socket client=server.accept(); // 监听窗口,等待连接
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
BufferedReader serverInput=new BufferedReader(new InputStreamReader(System.in));
PrintWriter ut=new PrintWriter(client.getOutputStream());
while(true){
String str=in.readLine(); //// 读取从client传来的数据信息
str = serverInput.readLine(); // 读取用户键盘输入的字符串
System.out.println(str); //服务器控制台输出数据信息
out.println(“has receive….”); //服务器向客户端发送信息:has receive….
out.flush();
if(str.equals(“end”))
break;
}
client.close();
}
}
这个程序的主要目的在于服务器不断接收客户机所写入的信息只到，客户机发送”End”字符串就退出程序，并且服务器也会做出”Receive”为回应，告知客户机已接收到消息。
客户机代码:
import java.net.*;
import java.io.*;
public class Client{
static Socket server;
public static void main(String[] args)throws Exception{
server=new Socket(InetAddress.getLocalHost(),5678); // 向主机名为InetAddress.getLocalHost()的服务器申请连接
BufferedReader in=new BufferedReader(new InputStreamReader(server.getInputStream())); //客户端建立输入流并进行封装
PrintWriter ut=new PrintWriter(server.getOutputStream());
BufferedReader wt=new BufferedReader(new InputStreamReader(System.in)); //客户端从键盘输入信息
while(true){
String str=wt.readLine(); //客户端读取（获得）键盘的字符串
String str1=in.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 java.net.*;
public class MyServer {
public static void main(String[] args) throws IOException{
ServerSocket server=new ServerSocket(5678);
while(true){
Socket client=server.accept();
BufferedReader in=new BufferedReader(new InputStreamReader(client.getInputStream()));
PrintWriter ut=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 java.net.*;
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 ut=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(5678);
while(true){
//transfer location change Single User or Multi User
MultiUser mu=new MultiUser(server.accept());
mu.start();
}
}
}
我的类直接从Thread类继承了下来.并且通过构造函数传递引用和客户Socket建立了联系，这样每个线程就有了。一个通讯管道.同样我们可以填写run方法，把之前的操作交给线程来完成，这样多客户并行的Socket就建立起来了。
[java]利用socket class作成客户端程序
嘿嘿 为了一百分啊 都有注解哦
逻辑和操作分开 比较好看哈
import java.io.*;
import java.net.*;
import java.util.Random;
public class SelectNumberClient{
private String address = “127.0.0.1”;//地址
private int port = 3939;//端口
private Socket socket;//套接字
private DataOutputStream dos;//输出流
private DataInputStream dis;//输入流
private Random random;
private int shuzi;//猜测的数字
//初始化:与服务器连接获取套接字
private boolean init(){
try{
socket = new Socket(address,port);
dos = new DataOutputStream(socket.getOutputStream());
dis = new DataInputStream(socket.getInputStream());
}catch(IOException ioe){
System.out.println(“连接错误,请重试:错误信息:”+ioe.getMessage());
return false;
}
random = new Random();
return true;
}
//发送并接受数据
private int sentAndGet(int i){
try{
dos.writeInt(i);
return dis.readInt();
}catch(IOException ioe){
ioe.printStackTrace();
return -3;
}
}
//得到两数之间的随机数
private int getRanInt(int i,int j){
return random.nextInt(j-i+1)+i;
}
//逻辑处理
private boolean luoji(){
int i=1,j=1000,temp,temp2;
while(true){
shuzi = getRanInt(i,j);
temp = sentAndGet(shuzi);
if(temp==0)break;
if(temp==-1)j=shuzi-1;
if(temp==-2)i=shuzi+1;
if(temp==-3){
System.out.println(“IOErrer”);
return false;
}
}
return true;
}
//关闭
private void close(){
try{
if(socket!=null)socket.close();
if(dis!=null)dis.close();
if(dos!=null)dos.close();
}catch(Exception e){
e.printStackTrace();
System.out.println(“连接错误,请重试,”);
}
}
//业务处理
public void star(){
if(init()){
if(luoji()){
System.out.println(“服务器上的数字是”+shuzi+”\n”);
}else{
System.out.println(“连接错误,请重试”);
}
close();
}
}
public static void main(String[] args){
new SelectNumberClient().star();
}
}
求一个JAVA socket客户端程序，急！！！
客户端输入“time”请求当前时间，输入“info”请求服务器信息，输入“bye”退出，输入其他和服务器对话。
服务器端：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Calendar;
public class Server {
// 定义数据成员
public static final int port = 8000;
ServerSocket server = null;
Socket socket = null;
BufferedReader in = null;
PrintStream out = null;
BufferedReader userin = null;
public Server() {
try {
server = new ServerSocket(port); // 创建一个倾听Socket
} catch (Exception e) {
System.out.println(“异常:” + e);
}
}
void acceptSocket() {
try {
socket = server.accept(); // 等待客户机连接请求
System.out.println(“serversocket: ” + socket);
} catch (Exception e) {
System.out.println(“异常:” + e);
}
}
void creatInOut() {
try {
// 通过Socket获取连接上的输入流
in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
// 通过Socket获取连接上的输出流
out = new PrintStream(socket.getOutputStream());
} catch (Exception e) {
System.out.println(“异常:” + e);
}
}
void talk() {
String str; // 存放接收到的字符串
try {
// 创建标准输入流，从键盘接收数据
userin = new BufferedReader(new InputStreamReader(System.in));
while (true) {
System.out.println(“等待客户端的消息…”);
str = in.readLine(); // 读取客户端发送的数据
System.out.println(“客户端saying:” + str);
if (str.equals(“bye”))
break;
System.out.print(“给客户端发送:”);
if (str.equals(“time”))// 请求时间
str = “当前时间：” + Calendar.getInstance().getTime();
else if (str.equals(“info”)) {// 请求信息
str = “服务器IP:” + socket.getInetAddress().getHostAddress()
+ ” 服务器端口:” + server.getLocalPort();
} else
str = userin.readLine(); // 从键盘接收数据
out.println(str); // 发送数据给客户端
out.flush();
System.out.println(str);
if (str.equals(“bye”))
break;
}
out.close();
in.close();
socket.close();
server.close();
} catch (Exception e) {
System.out.println(“异常:” + e);
}
}
public static void main(String args[]) {
Server server = new Server();
server.acceptSocket();
server.creatInOut();
server.talk();
}
}
客户端：
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.Socket;
public class Client {
public static void main(String[] args) {
String str;
try {
InetAddress addr = InetAddress.getByName(“127.0.0.1”);
Socket socket = new Socket(addr, 8000);// 发出连接请求
System.out.println(“clientsocket=” + socket);
BufferedReader in = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
// 连接建立，通过Socket获取连接上的输入流
PrintStream out = new PrintStream(socket.getOutputStream());
// 连接建立，通过Socket获取连接上的输出流
BufferedReader userin = new BufferedReader(new InputStreamReader(
System.in));
// 创建标准输入流，从键盘接收数据
while (true) {
System.out.print(“发送字符串:”);
str = userin.readLine(); // 从标准输入中读取一行
out.println(str); // 发送给服务器
if (str.equals(“bye”))
break;
System.out.println(“等待服务器端消息…”);
str = in.readLine(); // 读取服务器端的发送的数据
System.out.println(“服务器saying:” + str);
if (str.equals(“bye”))
break;
}
out.close();
in.close();
socket.close();
} catch (Exception e) {
System.out.println(“异常:” + e);
}
}
}
JAVA 问题，用socket编写一个客户端程序
给你一个我写的示例，用的是基于TCP的Socket技术，你锻炼一下，改一改，不会改再找我！
客户端：
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class TcpClient {
public static void main(String[] args) throws Exception
{
//创建客户端Socket服务，并且制定主机和duank
Socket s = new Socket(“192.168.1.104”,10002);//连接固定的主机和端口
//为了发送数据，获取Socket中的输入输出流
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;
//读取服务器发过来的数据
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
while((line = br.readLine())!=null)
{
out.write(line.getBytes());
if(“886”.equals(line))
break;
int len = in.read(buf);
String content = new String(buf,0,len);
System.out.println(“Server:”+content);
}
s.close();
}
}
服务器：
/*
* 需求分析：
* 使用TCP协议，写服务器端。做到服务器能收到客户端的信息，也能向客户端发送信息
* */
package JavaNetProgramming;
import java.net.ServerSocket;
import java.net.Socket;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
public class TcpServer {
public static void main(String[] args) throws Exception
{
//建立服务器的Socket服务，并且监听一个端口
ServerSocket ss = new ServerSocket(10002);
Socket s = ss.accept();
InputStream is = s.getInputStream();
//从服务器端向客户端发送数据
OutputStream out = s.getOutputStream();
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String line = null;
while(true)
{
//通过accept()方法获得客户端传过来的Socket对象
//System.out.println(“getByNanme():”+s.getInetAddress());
System.out.print(“getHostAddress():”+s.getInetAddress().getHostAddress());
//获取客户端发过来的数据，就要使用客户端对象的读取流来读取数据
byte[] buf = new byte[1024];
int len = is.read(buf);//把流中数据读到字节数组中
String content = new String(buf,0,len);
System.out.println(” “+content);
if(“886”.equals(content))
break;
while((line = br.readLine())!=null)
{
out.write(line.getBytes());
break;
}
}
s.close(); //循环内有判断语句,这句话才不出错
ss.close();
}
}
javasocket客户端程序的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于websocket服务端java、javasocket客户端程序的信息别忘了在本站进行查找喔。
微信扫一扫 
支付宝扫一扫 
