clientserverjava

Ⅰ 在java Socket编程中（client给server发送一个字符串，再由server返回一个字符串给client）

SERVER端：
--------------------------------------------------------
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class Server extends Thread {

private Socket clientSocket;

public Server(Socket clientSocket) {
this.clientSocket = clientSocket;
}

public void run() {

DataInputStream dis = null;
DataOutputStream dos = null;

try {

dis = new DataInputStream(clientSocket.getInputStream());
dos = new DataOutputStream(clientSocket.getOutputStream());

while (true) {
String temp = dis.readUTF();
if ("over".equals(temp)) {
break;
}
dos.writeUTF("from server:" + temp);
}

} catch (Exception e) {
//e.printStackTrace();
} finally {
try {
if (dis != null) {
dis.close();
}
if (dis != null) {
dos.close();
}

if (clientSocket != null) {
clientSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
System.out.println("Server Thread is shutdown.");
}
}
}

public static void main(String[] args) throws Exception {

ServerSocket ss = new ServerSocket(8008);
while (true) {
Socket clientSocket = ss.accept();
// 针对每个客户端, 启一个Server线程专门处理此客户端的请求。
Server server = new Server(clientSocket);
server.start();
}

}

}

CLIENT端：
----------------------------------------
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.Socket;

public class Client {

public static void main(String[] args) throws Exception {

// 输入流1, 从键盘进入Client。
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);

Socket clientSocket = new Socket("127.0.0.1", 8008);

// 输入流2, 从服务器端进入Client的流对象。
DataInputStream dis = new DataInputStream(clientSocket.getInputStream());

// 输出流, 从Client出去, 到服务器端。
DataOutputStream dos = new DataOutputStream(clientSocket.getOutputStream());

while (true) {

// 从键盘输入读取
String msg = br.readLine();

// 将读取信息发送给服务器端
dos.writeUTF(msg);

//输入over退出
if ("over".equals(msg)) {
break;
}

//读取从服务器返回的信息
String temp = dis.readUTF();
System.out.println(temp);
}

br.close();
dis.close();
dos.close();
clientSocket.close();

}

}
--------------------------------------------------------

Ⅱ Java中每当server给client发一条消息，client的JTextArea如何同步该消息

因为JTextArea中声明是这样的：
JTextArea mytxtarea = new JTextArea();
所以当client收到server端发过来的消息之后，在方法中调用：
mytxtarea.setText(server_message);

这样信息就会显示在JTextArea中。

Ⅲ 如何使用java远程传输文件，client只提供ip\文件路径等参数，server端无需部署服务！

其实有几种方式的，
1 ftp传输应用情况，加入在linux系统端有一些文件需要下载到用户电脑client端，而linux系统又不是web服务器，那么可以通过java程序FTP方式登录到linux，读取文件转换为流输出到用户IE端， java访问Linux服务器读取文件 所需jar包：j2ssh-core-0.2.2.jar
2 socket方式，可以应用于比如server-client 聊天窗，传输文字；
3 http协议，这种就是最常用的了，比如打开IE下载，上传东西，java是通过jsp servlet来实现的，然后部署放在tomcat web 服务器上，在其他局域网环境下的电脑登录IE即可访问到。没有特殊jar，只用java servlet的jar即可。例子如附件，可能上传不成功哈，网络网络会有很多哈

Ⅳ java开发中svr的client是什么意思

client是客户端，在java中c/s结构，c是client客户端，s是server服务器端：

1. C/S又称Client/Server或客户/服务器模式。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如ORACLE、SYBASE、InfORMix或 SQL Server。客户端需要安装专用的客户端软件。

2. 传统的C/S体系结构虽然采用的是开放模式，但这只是系统开发一级的开放性，在特定的应用中无论是Client端还是Server端都还需要特定的软件支持。由于没能提供用户真正期望的开放环境，C/S结构的软件需要针对不同的操作系统系统开发不同版本的软件， 加之产品的更新换代十分快，已经很难适应百台电脑以上局域网用户同时使用。而且代价高， 效率低。

3. Client/Server结构是20世纪80年代末提出的。这种结构的系统把较复杂的计算和管理任务交给网络上的高档机器——服务器，而把一些频繁与用户打交道的任务交给前端较简单的计算机—客户机。通过这种方式，将任务合理分配到客户端和服务器端，既充分利用了两端硬件环境的优势，又实现了网络上信息资源的共享。由于这种结构比较适于局域网运行环境，因此逐渐得到了广泛的应用。

4. 在Client/Server结构的系统中，应用程序分为客户端和服务器端两大部分。客户端部分为每个用户所专有，而服务器端部分则由多个用户共享其信息与功能。客户端部分通常负责执行前台功能，如管理用户接口、数据处理和报告请求等；而服务器端部分执行后台服务，如管理共享外设、控制对共享数据库的操作等。这种体系结构由多台计算机构成，它们有机地结合在一起，协同完成整个系统的应用，从而达到系统中软、硬件资源最大限度的利用。

5. 任何一个应用系统，不管是简单的单机系统还是复杂的网络系统，都由3个部分组成：显示逻辑部分(表示层)、事务处理逻辑部分(功能层)和数据处理逻辑部分(数据层)。显示逻辑部分的功能是与用户进行交互；事务处理逻辑部分的功能是进行具体的运算和数据的处理；数据处理逻辑部分的功能是对数据库中的数据进行查询、修改和更新等。在两层模式的Client/Server结构中，显示逻辑部分和事务处理逻辑部分均被放在客户端，数据处理逻辑部分和数据库被放在服务器端。这样就使得客户端变得很“胖”，成为胖客户机，而服务器端的任务相对较轻，成为瘦服务器。

6. 这种传统的Client/Server结构比较适合于在小规模、用户数较少(≤100)、单一数据库且有安全性和快速性保障的局域网环境下运行，所以得到了广泛的应用。但随着应用系统的大型化，以及用户对系统性能要求的不断提高，两层模式(2-Tier)的Client/Server结构越来越满足不了用户需求。这主要体现在程序开发量大、系统维护困难、客户机负担过重、成本增加及系统的安全性难以保障等方面。

Ⅳ 用java编写Client和Server程序，实现Client和Server的数据通信。

服务端代码：

importjava.io.IOException;
importjava.io.InputStream;
importjava.net.InetAddress;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.net.UnknownHostException;

publicclassServer{

	publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
		
		ServerSocketserver=newServerSocket(2408,5,InetAddress.getByName("localhost"));
		
		while(true){
		
			//等待客户端的连接
			SocketclientSocket=server.accept();
			
			//为每个连接的客户端分配一个线程，与客户端通信
			newThread(newClientThread(clientSocket)).start();
		}
	}
}

{

	privateSocketclientSocket;
	
	publicClientThread(Socketsocket){
		this.clientSocket=socket;
	}
	
	@Override
	publicvoidrun(){
		
		try{
			
			InputStreaminput=clientSocket.getInputStream();
			
			byte[]buffer=newbyte[1024];
			
			booleanexit=false;
			
			while(!exit){
				
				intlen=input.read(buffer);
				Stringmessage=newString(buffer,0,len);
				
				if("bye".equals(message)){
					exit=true;
				}
				
				System.out.println(clientSocket.getRemoteSocketAddress()+":"+message);
			}
			
			clientSocket.close();
			
		}catch(IOExceptione){
			e.printStackTrace();
		}
	}
}

客户端代码：

importjava.io.IOException;
importjava.io.OutputStream;
importjava.net.InetAddress;
importjava.net.Socket;
importjava.net.UnknownHostException;
importjava.util.Scanner;

publicclassClient{

	publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
		
		Scannerscanner=newScanner(System.in);
		
		Socketsocket=newSocket(InetAddress.getByName("localhost"),2408);
		
		OutputStreamoutput=socket.getOutputStream();
		
		booleanexit=false;
		
		while(!exit){
		
			Stringmessage=scanner.nextLine();
			
			if("bye".equals(message)){
				exit=true;
			}
			
			byte[]data=message.getBytes();
			
			output.write(data);
			output.flush();
		}
		
		socket.close();
	}
}

Ⅵ 用Java中的Server-Client来相互发送消息，把消息包装成对象来发送。

importjava.io.InputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.OutputStream;
importjava.net.ServerSocket;
importjava.net.Socket;
//服务端
publicclassTCPServerDemo{

	publicstaticvoidmain(String[]args)throwsException{
		ServerSocketss=newServerSocket(5000);
		Sockets=ss.accept();
		InputStreamin=s.getInputStream();
		OutputStreamout=s.getOutputStream();
		ObjectOutputStreamoos=newObjectOutputStream(out);
		ObjectInputStreamois=newObjectInputStream(in);
		SocketMessagemessage=newSocketMessage();
		message.setMessageId(1);
		message.setContent("服务器消息1");
		oos.writeObject(message);
		oos.flush();
		SocketMessagetemp=(SocketMessage)ois.readObject();
		System.out.println("收到客户端消息="+temp);
	}

}
importjava.io.InputStream;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.OutputStream;
importjava.net.Socket;
//客户端
publicclassTCPClientDemo{

	publicstaticvoidmain(String[]args)throwsException{
		Sockets=newSocket("localhost",5000);
		InputStreamin=s.getInputStream();
		OutputStreamout=s.getOutputStream();
		ObjectOutputStreamoos=newObjectOutputStream(out);
		ObjectInputStreamois=newObjectInputStream(in);
		SocketMessagemessage=newSocketMessage();
		message.setMessageId(2);
		message.setContent("客户端消息2");
		oos.writeObject(message);
		oos.flush();
		SocketMessagetemp=(SocketMessage)ois.readObject();
		System.out.println("收到服务端消息="+temp);
		
	}

}
importjava.io.Serializable;
//消息对象
{

	=1L;

	privateStringcontent;
	privatelongmessageId;

	publicStringgetContent(){
		returncontent;
	}

	publicvoidsetContent(Stringcontent){
		this.content=content;
	}

	publiclonggetMessageId(){
		returnmessageId;
	}

	publicvoidsetMessageId(longmessageId){
		this.messageId=messageId;
	}

	
	@Override
	publicStringtoString(){
		returngetClass().getSimpleName()+"[id="+getMessageId()+",content="+getContent()+"]";
	}
}

Ⅶ 用java 写出一个Server 和Client 能实现Client发送的消息显示在服务端上，Server发送的信息显示在客户端上

你好！
我写的很简单，你可以在此基础上完善，好了，废话不多说，直入正题。
首先，建立一个项目名为TestChat，然后建两个包，分别为server和client。
server包下建立一个类为Server，一个类为ServerListen。
client包建立一个类Client，一个类为ClentListen。
由于我时间仓促，你自行参考哈。

***********************************************************************

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/*
* Server.java
*
* Created on 2011-5-8, 16:37:13
*/

package server;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
*
* @author Study
*/
public class Server extends javax.swing.JFrame {

/** Creates new form Server */
public Server() {
initComponents();
try {
ss = new ServerSocket(8888);
s = ss.accept();
in = new ObjectInputStream(getS().getInputStream());
out = new ObjectOutputStream(getS().getOutputStream());
this.startListen();
} catch (IOException ex) {
Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
}
}

/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();
messageShow = new javax.swing.JTextArea();
messageInput = new javax.swing.JTextField();
sendBtn = new javax.swing.JButton();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
setTitle("服务器");

messageShow.setColumns(20);
messageShow.setEditable(false);
messageShow.setRows(5);
jScrollPane1.setViewportView(messageShow);

sendBtn.setText("发送");
sendBtn.addMouseListener(new java.awt.event.MouseAdapter() {
public void mousePressed(java.awt.event.MouseEvent evt) {
sendBtnMousePressed(evt);
}
});

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 400, Short.MAX_VALUE)
.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 400, Short.MAX_VALUE)
.addComponent(messageInput, javax.swing.GroupLayout.DEFAULT_SIZE, 400, Short.MAX_VALUE)
.addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
.addContainerGap(333, Short.MAX_VALUE)
.addComponent(sendBtn)
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 300, Short.MAX_VALUE)
.addGroup(layout.createSequentialGroup()
.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 201, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(messageInput, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(sendBtn)
.addContainerGap(19, Short.MAX_VALUE))
);

pack();
}// </editor-fold>

private void sendBtnMousePressed(java.awt.event.MouseEvent evt) {
this.sendMessage();
this.messageInput.setText("");
}

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Server().setVisible(true);
}
});
}

// Variables declaration - do not modify
protected javax.swing.JScrollPane jScrollPane1;
protected javax.swing.JTextField messageInput;
protected javax.swing.JTextArea messageShow;
protected javax.swing.JButton sendBtn;
// End of variables declaration

private ServerSocket ss;
private Socket s;
private ObjectOutputStream out;
private ObjectInputStream in;

private void startListen() {
ServerListen listen = new ServerListen(this);
Thread t = new Thread(listen);
t.start();
}

/**
* @return the s
*/
public Socket getS() {
return s;
}

/**
* @return the out
*/
public ObjectOutputStream getOut() {
return out;
}

/**
* @return the in
*/
public ObjectInputStream getIn() {
return in;
}

/**
* @return the messageShow
*/
public javax.swing.JTextArea getMessageShow() {
return messageShow;
}

private void sendMessage() {
try {
out.writeObject("服务器说");
out.flush();
out.writeObject(this.messageInput.getText().trim());
out.flush();
} catch (IOException ex) {
Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex);
}
}

}

Ⅷ 用java socket实现client与server通信，客户端向服务端发送字符串, 服务端再返回,把返回的变成大写。

import java.io.*;
import java.util.*;
import java.net.*;
public class Client { //客户端
public static void main(String args[])throws Exception
{
String clientMessage;//来自用户输入的的信息
String serverMessage; //服务器端的信息
Socket ClientSocket=new Socket("127.0.0.0",5557);//参数是本机地址和端口,客户端套接字，发起TCP连接
BufferedReader fromUser=new BufferedReader(new InputStreamReader(System.in));//字符读取流，获取从键盘输入的字符
BufferedReader fromServer=new BufferedReader(new InputStreamReader(ClientSocket.getInputStream()));//获取从服务器端的流，建立套接字输入流
DataOutputStream toServer=new DataOutputStream(ClientSocket.getOutputStream());//建立套接字输出流
clientMessage=fromUser.readLine();//读取从用户的输入
toServer.writeBytes(clientMessage);//写到服务器端
serverMessage=fromServer.readLine();//从服务器端读取
ClientSocket.close();//关闭套接字连接
}

}
import java.io.*;
import java.net.*; //服务器端
public class Server {
public static void main(String args[])throws Exception
{
String ClientMessage;
String ServerMessage;
ServerSocket serversocket=new ServerSocket(5557);//端口要和客户端对应
System.out.println("正在监听5555端口");//
while(true)
{
Socket collection=serversocket.accept();//调用accept()函数，建立TCP连接
DataInputStream fromClient=new DataInputStream(collection.getInputStream());
DataOutputStream toClient=new DataOutputStream(collection.getOutputStream());
ClientMessage=fromClient.readUTF();//接收来自客户端的信息
ServerMessage=ClientMessage.toUpperCase();//转换为大写
toClient.writeBytes(ServerMessage);//写到服务器端
System.out.println("成功建立TCP连接");
}
}

}

Ⅸ 那个Java通信能在说的详细点吗server是如何和Client_A和B同时通信呢谢谢。

将client_A和B都存在map集合里面，用名字作为键，之后只要在A请求的时候，将要通讯的B的名字传过去，从集合里面找B的socket，就对它发送A的发送内容，就可以了，

如果要server同时对A和B通讯，直接遍历集合就可以了
细节你再去优化

Ⅹ JVM client模式和Server模式的区别

这里向大家描述一下JVMclient模式和Server模式两者的区别和联系，JVM如果不显式指定是-Server模式还是-client模式，JVM能够根据下列原则进行自动判断（适用于Java5版本或者Java以上版本）。

JVM client模式和Server模式

JVM Server模式与client模式启动，最主要的差别在于：-Server模式启动时，速度较慢，但是一旦运行起来后，性能将会有很大的提升。JVM如果不显式指定是-Server模式还是-client模式，JVM能够根据下列原则进行自动判断（适用于Java5版本或者Java以上版本）。

前段时间有个同事给我发了个java跟c++性能比较的文章，其中有个对比图引起了我的兴趣，意外的是，我感兴趣的不是java和c++的对比，而是java -Server模式和java -client模式的对比。从来没想到两者间的性能有如此巨大的差别。而在后来自己的亲身测试中发现确实如此。

下面是我看到的那个对比图：

JVM工作在Server模式可以大大提高性能，但应用的启动会比client模式慢大概10%。当该参数不指定时，虚拟机启动检测主机是否为服务器，如果是，则以Server模式启动，否则以client模式启动，J2SE5.0检测的根据是至少2个CPU和最低2GB内存。

当JVM用于启动GUI界面的交互应用时适合于使用client模式，当JVM用于运行服务器后台程序时建议用Server模式。
JVM在client模式默认-Xms是1M，-Xmx是64M；JVM在Server模式默认-Xms是128M，-Xmx是1024M。我们可以通过运行:java -version来查看jvm默认工作在什么模式。