java以太坊客户端实现
㈠ 用Java socket 实现客户端与服务器之间的数据的发送与接受。。。双向的
下面是一个简单的通讯实例，进行Server和Client之间的文件传输。。如果是简单的文本传输的话简化掉文本操作的内容即可。。
1.服务器端
package sterning;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerTest {
int port = 8821;
void start() {
Socket s = null;
try {
ServerSocket ss = new ServerSocket(port);
while (true) {
// 选择进行传输的文件
String filePath = "D:\\lib.rar";
File fi = new File(filePath);
System.out.println("文件长度:" + (int) fi.length());
// public Socket accept() throws
// IOException侦听并接受到此套接字的连接。此方法在进行连接之前一直阻塞。
s = ss.accept();
System.out.println("建立socket链接");
DataInputStream dis = new DataInputStream(new BufferedInputStream(s.getInputStream()));
dis.readByte();
DataInputStream fis = new DataInputStream(new BufferedInputStream(new FileInputStream(filePath)));
DataOutputStream ps = new DataOutputStream(s.getOutputStream());
//将文件名及长度传给客户端。这里要真正适用所有平台，例如中文名的处理，还需要加工，具体可以参见Think In Java 4th里有现成的代码。
ps.writeUTF(fi.getName());
ps.flush();
ps.writeLong((long) fi.length());
ps.flush();
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
while (true) {
int read = 0;
if (fis != null) {
read = fis.read(buf);
}
if (read == -1) {
break;
}
ps.write(buf, 0, read);
}
ps.flush();
// 注意关闭socket链接哦，不然客户端会等待server的数据过来，
// 直到socket超时，导致数据不完整。
fis.close();
s.close();
System.out.println("文件传输完成");
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String arg[]) {
new ServerTest().start();
}
}
2.socket的Util辅助类
package sterning;
import java.net.*;
import java.io.*;
public class ClientSocket {
private String ip;
private int port;
private Socket socket = null;
DataOutputStream out = null;
DataInputStream getMessageStream = null;
public ClientSocket(String ip, int port) {
this.ip = ip;
this.port = port;
}
/** *//**
* 创建socket连接
*
* @throws Exception
* exception
*/
public void CreateConnection() throws Exception {
try {
socket = new Socket(ip, port);
} catch (Exception e) {
e.printStackTrace();
if (socket != null)
socket.close();
throw e;
} finally {
}
}
public void sendMessage(String sendMessage) throws Exception {
try {
out = new DataOutputStream(socket.getOutputStream());
if (sendMessage.equals("Windows")) {
out.writeByte(0x1);
out.flush();
return;
}
if (sendMessage.equals("Unix")) {
out.writeByte(0x2);
out.flush();
return;
}
if (sendMessage.equals("Linux")) {
out.writeByte(0x3);
out.flush();
} else {
out.writeUTF(sendMessage);
out.flush();
}
} catch (Exception e) {
e.printStackTrace();
if (out != null)
out.close();
throw e;
} finally {
}
}
public DataInputStream getMessageStream() throws Exception {
try {
getMessageStream = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
return getMessageStream;
} catch (Exception e) {
e.printStackTrace();
if (getMessageStream != null)
getMessageStream.close();
throw e;
} finally {
}
}
public void shutDownConnection() {
try {
if (out != null)
out.close();
if (getMessageStream != null)
getMessageStream.close();
if (socket != null)
socket.close();
} catch (Exception e) {
}
}
}
3.客户端
package sterning;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
public class ClientTest {
private ClientSocket cs = null;
private String ip = "localhost";// 设置成服务器IP
private int port = 8821;
private String sendMessage = "Windwos";
public ClientTest() {
try {
if (createConnection()) {
sendMessage();
getMessage();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
private boolean createConnection() {
cs = new ClientSocket(ip, port);
try {
cs.CreateConnection();
System.out.print("连接服务器成功!" + "\n");
return true;
} catch (Exception e) {
System.out.print("连接服务器失败!" + "\n");
return false;
}
}
private void sendMessage() {
if (cs == null)
return;
try {
cs.sendMessage(sendMessage);
} catch (Exception e) {
System.out.print("发送消息失败!" + "\n");
}
}
private void getMessage() {
if (cs == null)
return;
DataInputStream inputStream = null;
try {
inputStream = cs.getMessageStream();
} catch (Exception e) {
System.out.print("接收消息缓存错误\n");
return;
}
try {
//本地保存路径，文件名会自动从服务器端继承而来。
String savePath = "E:\\";
int bufferSize = 8192;
byte[] buf = new byte[bufferSize];
int passedlen = 0;
long len=0;
savePath += inputStream.readUTF();
DataOutputStream fileOut = new DataOutputStream(new BufferedOutputStream(newBufferedOutputStream(new FileOutputStream(savePath))));
len = inputStream.readLong();
System.out.println("文件的长度为:" + len + "\n");
System.out.println("开始接收文件!" + "\n");
while (true) {
int read = 0;
if (inputStream != null) {
read = inputStream.read(buf);
}
passedlen += read;
if (read == -1) {
break;
}
//下面进度条本为图形界面的prograssBar做的，这里如果是打文件，可能会重复打印出一些相同的百分比
System.out.println("文件接收了" + (passedlen * 100/ len) + "%\n");
fileOut.write(buf, 0, read);
}
System.out.println("接收完成，文件存为" + savePath + "\n");
fileOut.close();
} catch (Exception e) {
System.out.println("接收消息错误" + "\n");
return;
}
}
public static void main(String arg[]) {
new ClientTest();
}
}
㈡ 怎么用java编写简单客户端程序
我这里有一个例子希望能够帮助你
public class Client{
private Socket socket;
try{
Socket socket=new Socket ("localhoast',8088);
ip=InetAddress.getLocalHost();
String localip=ip.getHostAddress();
System.out.println(localip);
String name=ip.getHostName();
System.out.println(name);
}
catch(Exception e){
}
public void start(){
try{
Run r2=new Run();
Thread t1=new Thread(r2);
t1.setDaemon(true);
t1.start();
Scanner sc=new Scanner(System.in);
OutputStream os=socket.getOutputStream();
OutputStreamWriter osw=new OutputStreamWriter(os);
PrintWriter writer=new PrintWriter(osw,true);
while(true){
writer.println(sc.nextLine());
}
}catch(Exception e){
}
}
public static void main(String args[]){
Client client=new Client();
client.start();
}
class Run implements Runnable{
public void run() {
while(true){
try {
InputStream is=socket.getInputStream();
InputStreamReader isr=new InputStreamReader(is);
BufferedReader br=new BufferedReader(isr);
while(true){
String str=br.readLine();
System.out.println("服务器说:"+str);
if("bye".equals(str)){
System.out.println("再见客户端");
System.out.println("聊天结束");
}
}
} catch (IOException e) {
e.printStackTrace();
} finally{
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}
㈢ java 网络编程： 如何实现客户端与客户端之间的之间通信
（1）服务器首先启动监听程序，对指定的端口进行监听，等待接收客户端的连接请求。
（2）客户端程序启动，请求连接服务器的指定端口。
（3）服务器收到客户端的连接请求后与客户端建立套接字连接。
（4）连接成功后，客户端与服务器分别打开两个流，其中客户端的输入流连接到服务器的输出流，服务器的输入流
连接到客户端的输出流，两边的流建立连接后就可以双向的通信了。
（5）当通信完毕后客户端与服务器端两边各自断开连接。
㈣ 编写java程序实现客户端和服务端的通信
服务器端：
public class Server{
public static void main(String[] args){
ServerSocket ss = new ServerSocket(端口号);
Socket s = ss.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
String str = br.readLine();
System.out.println(str);
br.close();
s.close();
ss.close();
}
}
客户端：
public class Client{
public static void main(String[] args){
Socket s = new Socket(ip,端口)
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
bw.write("hello");
bw.flush();
bw.close();
s.close();
}
}
先启动服务器端在启动客户端，两个端口要一致，如果是同一台电脑的ip可写为"127.0.0.1"
㈤ 用Java 的socket实现客户端的功能
//服务端程序：
importjava.io.*;
importjava.net.*;
publicclassTCPServer{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPServer().init();
}
@SuppressWarnings("static-access")
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
ServerSocketserver=newServerSocket(1000);
Socketclient=null;
while(true){
try{
client=server.accept();
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
Stringmessage="";
while((len=bis.read(b))!=-1){
message=newString(b,0,len);
System.out.print("客户端："+client.getInetAddress().getLocalHost().getHostAddress()+"发来消息："+message);
if("byte".equals(message.trim()))
client.close();
PrintWriterpw=newPrintWriter(client.getOutputStream(),true);
pw.println(message);
}
}catch(Exceptione){
System.err.println("客户端："+client.getInetAddress().getLocalHost().getHostAddress()+"已断开连接！");
}
}
}
}
//客户端程序：
importjava.io.*;
importjava.net.Socket;
{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPClient().init();
}
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
finalSocketclient=newSocket("127.0.0.1",1000);
BufferedReaderin=newBufferedReader(newInputStreamReader(System.in));
Stringsend="";
while(true){
send=in.readLine();
PrintWriterout=newPrintWriter(client.getOutputStream(),true);
if(!"byte".equals(send.trim()))
out.println(send);
else{
out.println(send);
System.exit(0);
}
newThread(newTCPClient(){
@SuppressWarnings("static-access")
publicvoidrun(){
try{
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
while((len=bis.read(b))!=-1){
System.out.println("服务器："+client.getInetAddress().getLocalHost().getHostAddress()+"发来消息："+newString(b,0,len).trim());
}
}catch(IOExceptione){
System.err.println("连接服务器失败!");
}
}
}).start();
}
}
publicvoidrun(){}
}
//服务器测试结果：
客户端：192.168.0.200发来消息：001 byte
客户端：192.168.0.200发来消息：byte
客户端：192.168.0.200 已断开连接！
客户端：192.168.0.200发来消息：adasd
客户端：192.168.0.200 已断开连接！
//客户端测试结果：
---001号客户端--
001byte
服务器：192.168.0.200发来消息：001byte
byte //001礼貌说跟服务器说byte
---002号客户端--
adasd //002客户端直接关闭程序
服务器：192.168.0.200发来消息：adasd
㈥ 用java代码实现客户端与服务端建立连接
套接字 Socket
import java.net.*;
Server:
ServerSocket server=new ServerSocket(port);//port是端口
Socket socket=server.accept();
//等待客户机的连接请求，若连接，则创建一套接字，并将返回。
Client:
Socket socket=new Socket("host",port);//host主机名（本机：127.0.0.1）
㈦ Java 编程 怎么做成客户端
打成jar包，写个bat文件，使用java -jar命令运行
㈧ 用Java编写创建一对客户端/服务器程序,利用数据报将一个文件从一台主机传送到另一
下面是我自己写的一个读取并显示txt文件的demo，希望对您有帮助。
publicclassClient{
publicstaticvoidmain(String[]args){
ClientFramef=newClientFrame();
}
}
importjava.awt.BorderLayout;
importjava.awt.Container;
importjava.awt.Dimension;
importjava.awt.GridLayout;
importjava.awt.Toolkit;
importjava.awt.event.ActionEvent;
importjava.awt.event.ActionListener;
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjava.util.Vector;
importjavax.swing.BorderFactory;
importjavax.swing.JButton;
importjavax.swing.JFrame;
importjavax.swing.JList;
importjavax.swing.JScrollPane;
importjavax.swing.JTextArea;
importjavax.swing.event.ListSelectionEvent;
importjavax.swing.event.ListSelectionListener;
,ListSelectionListener{
privateJListlist=null;
privateJButtonsbtn=null;
privateJButtoncbtn=null;
privateVectorv=null;
privateJTextAreatxt=null;
privateContainercontrol=null;
privateContainerbtn=null;
privateSocketclient=null;
privateDataInputStreamreader=null;
privateDataOutputStreamwriter=null;
publicClientFrame(){
this.list=newJList();
this.list.setBorder(BorderFactory.createTitledBorder("文件列表"));
this.list.addListSelectionListener(this);
this.sbtn=newJButton("显示");
this.sbtn.addActionListener(this);
this.cbtn=newJButton("清除");
this.cbtn.addActionListener(this);
this.control=newContainer();
this.control.setPreferredSize(newDimension(150,400));
this.control.setLayout(newBorderLayout());
this.control.add(newJScrollPane(this.list),BorderLayout.CENTER);
this.btn=newContainer();
this.btn.setLayout(newGridLayout(1,2));
btn.add(sbtn);
btn.add(cbtn);
this.control.add(this.btn,BorderLayout.SOUTH);
this.txt=newJTextArea();
this.txt.setEditable(false);
this.txt.setSize(350,400);
this.setTitle("客户端");
this.setSize(500,400);
this.setVisible(true);
DimensiondisplaySize=Toolkit.getDefaultToolkit().getScreenSize();
this.setLocation((displaySize.width-this.getWidth())/2,(displaySize.height-this.getHeight())/2);
this.setLayout(newBorderLayout());
this.add(this.control,BorderLayout.WEST);
this.add(newJScrollPane(this.txt),BorderLayout.CENTER);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
try{
//this.client=newSocket("192.168.32.34",6666);
this.client=newSocket("192.168.1.100",6666);
this.reader=newDataInputStream(client.getInputStream());
this.writer=newDataOutputStream(client.getOutputStream());
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
}
publicvoidactionPerformed(ActionEventevent){
if(event.getSource()==sbtn){
if(v==null){
v=newVector();
}
else{
v.clear();
}
try{
writer.writeUTF("getfilelist");
writer.flush();
Stringt=reader.readUTF();
while(t!=null&&!t.equals("")){
v.add(t);
t=reader.readUTF();
}
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
this.list.setListData(v);
}
if(event.getSource()==cbtn){
this.txt.setText("");
}
}
publicvoidvalueChanged(ListSelectionEvente){
inti=this.list.getSelectedIndex();
if(!this.list.getValueIsAdjusting()&&i!=-1){
try{
writer.writeUTF("getfilecontent_"+i);
writer.flush();
Stringtmp=reader.readUTF();
this.txt.setText(tmp);
}catch(IOExceptione1){
e1.printStackTrace();
}
}
}
}
importjava.io.DataInputStream;
importjava.io.DataOutputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.Reader;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.ArrayList;
importjava.util.Iterator;
publicclassServer{
staticArrayList<File>fileArray=newArrayList<File>();
publicstaticvoidmain(Stringargs[]){
ServerSocketserver=null;
Socketclient=null;
Stringcmd="";
try{
server=newServerSocket(6666);
client=server.accept();
DataInputStreamreader=newDataInputStream(client.getInputStream());
DataOutputStreamwriter=newDataOutputStream(client.getOutputStream());
while(true){
cmd=reader.readUTF();
System.out.println(cmd);
if(cmd.equals("getfilelist")){
fileArray.clear();
//fileArray=getFile(newFile("D:/tmp"));
fileArray=getFile(newFile("D:/学习/教程/学习笔记"));
Stringfn="";
for(intk=0;k<fileArray.size();k++){
fn=fileArray.get(k).getName();
writer.writeUTF(fn);
writer.flush();
}
writer.writeUTF("");
}
if(cmd.startsWith("getfilecontent_")){
inti=Integer.parseInt(cmd.split("_")[1]);
Filef=fileArray.get(i);
Readerin=newInputStreamReader(newFileInputStream(f));
inttempbyte;
Stringstr="";
while((tempbyte=in.read())!=-1){
str+=(char)tempbyte;
//System.out.println(str);
}
in.close();
writer.writeUTF(str);
}
}
}catch(IOExceptione){
e.printStackTrace();
}
}
privatestaticArrayList<File>getFile(Filef){
File[]ff=f.listFiles();
for(Filechild:ff){
if(child.isDirectory()){
getFile(child);
}else{
fileArray.add(child);
}
}
returnfileArray;
}
}
㈨ java 编写网络客户/服务器程序，实现如下功能： （1）设计服务器程序，运行时等待客户端连接； （2）客户
Server:
package s;
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(10001);
while (true) {
Socket socket = server.accept();
System.out.println("a socket in");
new UpderDeal(socket).start();
}
}
}
class UpderDeal extends Thread {
private Socket s = null;
public UpderDeal(Socket s) {
this.s = s;
}
public void run() {
byte[] b = new byte[1024];
String msg = null;
int len = 0;
try {
while (true) {
len = s.getInputStream().read(b);
msg = new String(b, 0, len);
msg = msg.toUpperCase();
s.getOutputStream().write(msg.getBytes());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Client:
package c;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
public static void main(String[] args) throws UnknownHostException,
IOException {
Socket socket = new Socket("localhost", 10001);
OutputStream out = socket.getOutputStream();
InputStream in = socket.getInputStream();
String msg = null;
Scanner sc = new Scanner(System.in);
new Recieve(in).start();
while (true) {
msg = sc.next();
if (msg.equals("exit")) {
break;
}
System.out.println("发出的信息：" + msg);
out.write(msg.getBytes());
}
}
}
class Recieve extends Thread {
private InputStream in = null;
public Recieve(InputStream in) {
this.in = in;
}
public void run() {
byte[] b = new byte[1024];
int len = 0;
while (true) {
try {
len = in.read(b);
System.out.println("收到的信息为：" + new String(b, 0, len));
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
希望可以帮到你，还有一种异步用SocketChannel的，我也怎么用过，可以网上参考一下。