商业源码 java中利用输入流与输出流实现服务器与客户端通信有哪些方法？
可以用TCP或UDP协议。两者不同之处在于，TCP要建立服务器客户端必须和服务器连接，才能和其他客户进行联系。
但UDF不需要，只要知道对方的IP和端口，就可以连接任何一台客户端。
想这样类似QQ的代码很多，晚上搜一下就有。这里给一个客户端和服务器。
-------------------
import javaawt;
import javaawtevent;
import javanet;
import javaio;
import javautilloggingLevel;
import javautilloggingLogger;
class myframe extends Frame implements ActionListener,WindowListener,Runnable,KeyListener
{
Thread mythread = new Thread(this);
Socket mysocket;
DataInputStream in;
DataOutputStream out;
Label label_ip = new Label("IP");
Label label_port = new Label("Port");
TextField text_ip = new TextField("127110",15);
TextField text_port = new TextField("8888",15);
Button button_connect = new Button("连接");
TextArea text_area_show = new TextArea();
TextField text_send = new TextField(45);
Button button_send = new Button("发送");
myframe()
{
Panel panel1 = new Panel();
Panel panel2 = new Panel();
panel1setLayout(new FlowLayout());
panel1add(label_ip);
panel1add(text_ip);
panel1add(label_port);
panel1add(text_port);
panel1add(button_connect);
panel2setLayout(new FlowLayout());
panel2add(text_send);
panel2add(button_send);
add(panel1,BorderLayoutNORTH);
add(text_area_show,BorderLayoutCENTER);
add(panel2,BorderLayoutSOUTH);
text_sendaddKeyListener(this);
button_connectaddActionListener(this);
button_sendaddActionListener(this);
addWindowListener(this);
thissetTitle("客户端");
setBounds(200,200,400,350);
setVisible(true);
}
public void actionPerformed(ActionEvent e)
{
if(egetSource() == button_connect)
{
try
{
String ip = null,port = null;
ip = text_ipgetText();
port = text_portgetText();
mysocket = new Socket(ip, IntegerparseInt(port));
in = new DataInputStream(mysocketgetInputStream());
out = new DataOutputStream(mysocketgetOutputStream());
}
catch (UnknownHostException ex)
{
LoggergetLogger(myframeclassgetName())log(LevelSEVERE, null, ex);
}
catch (IOException ex)
{
LoggergetLogger(myframeclassgetName())log(LevelSEVERE, null, ex);
}
mythreadstart();
}
if(egetSource() == button_send)
{
if(mysocketisConnected() == true)
{
String temp = null;
temp = text_sendgetText();
try
{
outwriteUTF(temp);
text_sendsetText(null);
}
catch (IOException ex)
{
LoggergetLogger(myframeclassgetName())log(LevelSEVERE, null, ex);
}
}
}
}
public void run()
{
while(true)
{
String temp = null;
try
{
temp = inreadUTF();
}
catch (IOException ex)
{
text_area_showappend("服务器退出\n");
return;
}
temp += "\n";
text_area_showappend(temp);
}
}
public void keyPressed(KeyEvent e)
{
if(egetKeyCode() == KeyEventVK_ENTER)
{
String temp = null;
temp = text_sendgetText();
try
{
outwriteUTF(temp);
}
catch (IOException ex)
{
LoggergetLogger(myframeclassgetName())log(LevelSEVERE, null, ex);
}
}
}
public void windowClosing(WindowEvent e)
{
Systemexit(0);
}
public void windowOpened(WindowEvent e) {}
public void windowClosed(WindowEvent e) {}
public void windowIconified(WindowEvent e) {}
public void windowDeiconified(WindowEvent e) {}
public void windowActivated(WindowEvent e) {}
public void windowDeactivated(WindowEvent e) {}
public void keyTyped(KeyEvent e) {}
public void keyReleased(KeyEvent e) {}
}
public class mywindow
{
public static void main(String argv[])
{
myframe f = new myframe();
}
}
--------------------------------
import javaawteventWindowAdapter;
import javaawteventWindowEvent;
import javaioDataInputStream;
import javaioDataOutputStream;
import javaioIOException;
import javanetServerSocket;
import javanetSocket;
import javautilLinkedList;
import javautilloggingLevel;
import javautilloggingLogger;
import javaxswingJTextArea;
class RecvMegSock extends Thread
{
LinkedList SocketList = null;
Socket ClientSock = null;
JTextArea jTextArea1;
RecvMegSock(LinkedList list,Socket s,JTextArea t)
{
SocketList = list;
jTextArea1 = t;
ClientSock = s;
start();
}
public void run()
{
while(true)
{
try
{
DataInputStream in = new DataInputStream(ClientSockgetInputStream());
String word = inreadUTF();
jTextArea1setText(jTextArea1getText() + word + "\n");
for(int i = 0;i < SocketListsize();i++)
{
Socket s = (Socket)SocketListget(i);
DataOutputStream out = new DataOutputStream(sgetOutputStream());
outwriteUTF(word);
}
}
catch (IOException ex)
{
for(int i = 0;i < SocketListsize();i++)
{
Socket s = (Socket)SocketListget(i);
if(s == ClientSock)
SocketListremove(s);
}
for(int i = 0;i < SocketListsize();i++)
{
Socket s = (Socket)SocketListget(i);
try
{
DataOutputStream out = new DataOutputStream(sgetOutputStream());
outwriteUTF(ClientSockgetInetAddress() + "已经退出!!\n");
}
catch (IOException ex1)
{
LoggergetLogger(RecvMegSockclassgetName())log(LevelSEVERE, null, ex1);
}
}
jTextArea1setText(jTextArea1getText() + ClientSockgetInetAddress() + "已经退出!!" + "\n");
return;
}
}
}
}
class AcceptSockThread extends Thread
{
ServerSocket ServerSock = null;
LinkedList SocketList = null;
JTextArea TextArea;
AcceptSockThread(ServerSocket s,LinkedList list,JTextArea t)
{
ServerSock = s;
SocketList = list;
TextArea = t;
start();
}
public void run()
{
while(true)
{
Socket ClientSock = null;
try
{
boolean same = false;
ClientSock = ServerSockaccept(); /
for(int i = 0;i < SocketListsize();i++)
{
Socket s = (Socket)SocketListget(i);
if(sgetInetAddress()equals(ClientSockgetInetAddress()) && sgetPort() == ClientSockgetPort())
{
DataOutputStream out = new DataOutputStream(sgetOutputStream());
outwriteUTF(ClientSockgetInetAddress() + "你已经连接了服务器！！\n");
same = true;
}
}
if(same == true)
continue;
/
new RecvMegSock(SocketList,ClientSock,TextArea);
SocketListadd(ClientSock);
for(int i = 0;i < SocketListsize();i++)
{
Socket s = (Socket)SocketListget(i);
DataOutputStream out = new DataOutputStream(sgetOutputStream());
outwriteUTF(ClientSockgetInetAddress() + "成功连接服务器\n");
}
TextAreasetText(TextAreagetText() + ClientSockgetInetAddress() + "连接到服务器\n");
}
catch (IOException ex)
{
LoggergetLogger(AcceptSockThreadclassgetName())log(LevelSEVERE, null, ex);
}
}
}
}
public class ServerDialog extends javaxswingJDialog
{
ServerSocket Server = null;
LinkedList SocketList = null;
public ServerDialog(javaawtFrame parent, boolean modal)
{
super(parent, modal);
initComponents();
try
{
Server = new ServerSocket(8888);
SocketList = new LinkedList();
new AcceptSockThread(Server,SocketList,jTextArea1);
}
catch (IOException ex)
{
LoggergetLogger(ServerDialogclassgetName())log(LevelSEVERE, null, ex);
}
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {
jScrollPane1 = new javaxswingJScrollPane();
jTextArea1 = new javaxswingJTextArea();
jTextField1 = new javaxswingJTextField();
jButton1 = new javaxswingJButton();
setDefaultCloseOperation(javaxswingWindowConstantsDISPOSE_ON_CLOSE);
getContentPane()setLayout(null);
jTextArea1setColumns(20);
jTextArea1setEditable(false);
jTextArea1setRows(5);
jScrollPane1setViewportView(jTextArea1);
getContentPane()add(jScrollPane1);
jScrollPane1setBounds(10, 10, 380, 250);
getContentPane()add(jTextField1);
jTextField1setBounds(10, 270, 290, 21);
jButton1setText("发送");
jButton1addActionListener(new javaawteventActionListener() {
public void actionPerformed(javaawteventActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
getContentPane()add(jButton1);
jButton1setBounds(310, 270, 80, 25);
pack();
}// </editor-fold>//GEN-END:initComponents
private void jButton1ActionPerformed(javaawteventActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
if(SocketListsize() == 0)
{
jTextArea1setText(jTextArea1getText() + "没有人连接!!" + "\n");
return;
}
for(int i = 0;i < SocketListsize();i++)
{
DataOutputStream out;
try
{
out = new DataOutputStream(((Socket) SocketListget(i))getOutputStream());
if(jTextField1getText() != null)
outwriteUTF(jTextField1getText());
}
catch (IOException ex)
{
LoggergetLogger(ServerDialogclassgetName())log(LevelSEVERE, null, ex);
}
}
jTextArea1setText(jTextArea1getText() + jTextField1getText() + "\n");
}//GEN-LAST:event_jButton1ActionPerformed
public static void main(String args[])
{
ServerDialog dlg = new ServerDialog(null,true);
dlgsetBounds(300, 200, 400, 325);
dlgaddWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
Systemexit(0);
}
});
dlgsetVisible(true);
}
// Variables declaration - do not modify//GEN-BEGIN:variables
private javaxswingJButton jButton1;
private javaxswingJScrollPane jScrollPane1;
private javaxswingJTextArea jTextArea1;
private javaxswingJTextField jTextField1;
// End of variables declaration//GEN-END:variables
}
服务器端源码：
import javaioBufferedReader;
import javaioFile;
import javaioFileNotFoundException;
import javaioFileOutputStream;
import javaioIOException;
import javaioInputStream;
import javaioInputStreamReader;
import javanetServerSocket;
import javanetSocket;
/
文件名：ServerReceivejava
实现功能：作为服务器接收客户端发送的文件
具体实现过程：
1、建立SocketServer，等待客户端的连接
2、当有客户端连接的时候，按照双方的约定，这时要读取一行数据
其中保存客户端要发送的文件名和文件大小信息
3、根据文件名在本地创建文件，并建立好流通信
4、循环接收数据包，将数据包写入文件
5、当接收数据的长度等于提前文件发过来的文件长度，即表示文件接收完毕，关闭文件
6、文件接收工作结束
public class ServerReceive {
public static void main(String[] args) {
/与服务器建立连接的通信句柄/
ServerSocket ss = null;
Socket s = null;
/定义用于在接收后在本地创建的文件对象和文件输出流对象/
File file = null;
FileOutputStream fos = null;
/定义输入流，使用socket的inputStream对数据包进行输入/
InputStream is = null;
/定义byte数组来作为数据包的存储数据包/
byte[] buffer = new byte[4096 5];
/用来接收文件发送请求的字符串/
String comm = null;
/建立socekt通信，等待服务器进行连接/
try {
ss = new ServerSocket(4004);
s = ssaccept();
} catch (IOException e) {
eprintStackTrace();
}
/读取一行客户端发送过来的约定信息/
try {
InputStreamReader isr = new InputStreamReader(sgetInputStream());
BufferedReader br = new BufferedReader(isr);
comm = brreadLine();
} catch (IOException e) {
Systemoutprintln("服务器与客户端断开连接");
}
/开始解析客户端发送过来的请求命令/
int index = commindexOf("/#");
/判断协议是否为发送文件的协议/
String xieyi = commsubstring(0, index);
if(!xieyiequals("111")){
Systemoutprintln("服务器收到的协议码不正确");
return;
}
/解析出文件的名字和大小/
comm = commsubstring(index + 2);
index = commindexOf("/#");
String filename = commsubstring(0, index)trim();
String filesize = commsubstring(index + 2)trim();
/创建空文件，用来进行接收文件/
file = new File(filename);
if(!fileexists()){
try {
filecreateNewFile();
} catch (IOException e) {
Systemoutprintln("服务器端创建文件失败");
}
}else{
/在此也可以询问是否覆盖/
Systemoutprintln("本路径已存在相同文件，进行覆盖");
}
/以上就是客户端代码中写到的服务器的准备部分/
/
服务器接收文件的关键代码/
try {
/将文件包装到文件输出流对象中/
fos = new FileOutputStream(file);
long file_size = LongparseLong(filesize);
is = sgetInputStream();
/size为每次接收数据包的长度/
int size = 0;
/count用来记录已接收到文件的长度/
long count = 0;
/使用while循环接收数据包/
while(count < file_size){
/从输入流中读取一个数据包/
size = isread(buffer);
/将刚刚读取的数据包写到本地文件中去/
foswrite(buffer, 0, size);
fosflush();
/将已接收到文件的长度+size/
count += size;
Systemoutprintln("服务器端接收到数据包，大小为" + size);
}
} catch (FileNotFoundException e) {
Systemoutprintln("服务器写文件失败");
} catch (IOException e) {
Systemoutprintln("服务器：客户端断开连接");
}finally{
/
将打开的文件关闭
如有需要，也可以在此关闭socket连接
/
try {
if(fos != null)
fosclose();
} catch (IOException e) {
eprintStackTrace();
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ServerReceive
客户端源码：
import javaioFile;
import javaioFileInputStream;
import javaioFileNotFoundException;
import javaioIOException;
import javaioOutputStream;
import javaioPrintStream;
import javanetSocket;
/
文件名：ClientSendjava
实现功能：作为客户端向服务器发送一个文件
具体实现过程：
1、建立与服务器端的连接，IP：127001， port：4004
2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器
3、循环读取本地文件，将文件打包发送到数据输出流中
4、关闭文件，结束传输
/
public class ClientSend {
public static void main(String[] args) {
/与服务器建立连接的通信句柄/
Socket s = null;
/定义文件对象，即为要发送的文件
如果使用绝对路径，不要忘记使用'/'和'\'的区别
具体区别，请读者自行查询
/
File sendfile = new File("APICHM");
/定义文件输入流，用来打开、读取即将要发送的文件/
FileInputStream fis = null;
/定义byte数组来作为数据包的存储数据包/
byte[] buffer = new byte[4096 5];
/定义输出流，使用socket的outputStream对数据包进行输出/
OutputStream os = null;
/检查要发送的文件是否存在/
if(!sendfileexists()){
Systemoutprintln("客户端：要发送的文件不存在");
return;
}
/与服务器建立连接/
try {
s = new Socket("127001", 4004);
}catch (IOException e) {
Systemoutprintln("未连接到服务器");
}
/用文件对象初始化fis对象
以便于可以提取出文件的大小
/
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1printStackTrace();
}
/首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作
具体的准备工作，请查看服务器代码。
发送的内容包括：发送文件协议码（此处为111）/#文件名（带后缀名）/#文件大小
/
try {
PrintStream ps = new PrintStream(sgetOutputStream());
psprintln("111/#" + sendfilegetName() + "/#" + fisavailable());
psflush();
} catch (IOException e) {
Systemoutprintln("服务器连接中断");
}
/
此处睡眠2s，等待服务器把相关的工作准备好
也是为了保证网络的延迟
读者可自行选择添加此代码
/
try {
Threadsleep(2000);
} catch (InterruptedException e1) {
e1printStackTrace();
}
/之前的准备工作结束之后
下面就是文件传输的关键代码
/
try {
/获取socket的OutputStream，以便向其中写入数据包/
os = sgetOutputStream();
/ size 用来记录每次读取文件的大小/
int size = 0;
/使用while循环读取文件，直到文件读取结束/
while((size = fisread(buffer)) != -1){
Systemoutprintln("客户端发送数据包，大小为" + size);
/向输出流中写入刚刚读到的数据包/
oswrite(buffer, 0, size);
/刷新一下/
osflush();
}
} catch (FileNotFoundException e) {
Systemoutprintln("客户端读取文件出错");
} catch (IOException e) {
Systemoutprintln("客户端输出文件出错");
}finally{
/
将打开的文件关闭
如有需要，也可以在此关闭socket连接
/
try {
if(fis != null)
fisclose();
} catch (IOException e) {
Systemoutprintln("客户端文件关闭出错");
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ClientSend
package Server;
import javaio;
import javanet;
import messageMessageType;
//该线程用于和客服端进行通信，是一个线程类
public class ServerClientComunicationThread extends Thread{
Socket s=null;
ObjectInputStream ois=null;
MessageType mt=null;
ObjectOutputStream oos=null;
public ServerClientComunicationThread(Socket s){
thiss=s;
}
public void run(){
//不停地从socket里面读取数据
while(true){
try {
ois=new ObjectInputStream(sgetInputStream());
mt=(MessageType)oisreadObject();
Systemoutprintln("服务器读取到的信息");
Systemoutprintln(mtgetContent()+" "+mtgetGetter()+" "+
mtgetMessagetype()+mtgetSendTime());
//将读取到的数据转发给对应的客服端
Systemoutprintln("从集合里面可以找到用户压迫将数据发送给"+ ManageOnlineUserhmget(mtgetGetter()));
oos=new ObjectOutputStream(( ManageOnlineUserhmget(mtgetGetter()))getOutputStream());
ooswriteObject(mt);
} catch (Exception e) {
eprintStackTrace();
}
}
}
}
面向对象：其实是现实世界模型的自然延伸。现实世界中任何实体都可以看作是对象。对象之间通过消息相互作用。另外，现实世界中任何实体都可归属于某类事物，任何对象都是某一类事物的实例。如果说传统的过程式编程语言是以过程为中心以算法为驱动的话，面向对象的编程语言则是以对象为中心以消息为驱动。用公式表示，过程式编程语言为：程序=算法+数据；面向对象编程语言为：程序=对象+消息。 所有面向对象编程语言都支持三个概念：封装、多态性和继承，Java也不例外。现实世界中的对象均有属性和行为，映射到计算机程序上，属性则表示对象的数据，行为表示对象的方法（其作用是处理数据或同外界交互）。所谓封装，就是用一个自主式框架把对象的数据和方法联在一起形成一个整体。可以说，对象是支持封装的手段，是封装的基本单位。Java语言的封装性较强，因为Java无全程变量，无主函数，在Java中绝大部分成员是对象，只有简单的数字类型、字符类型和布尔类型除外。而对于这些类型，Java也提供了相应的对象类型以便与其他对象交互操作。
可移植性：就是在这个系统上作的程序经过一次编译后可以移植到别的系统上解释执行，只要经过简单的粘贴和复制就行了，不影响程序的效果
安全性：在 iSeries 服务器上运行的大多数 Java(TM) 程序是应用程序，而不是 applet，所以“砂箱”安全性模型对它们不起限制作用。从安全性的观点看，Java 应用程序所受的安全性限制与 iSeries 服务器上的任何其它程序相同。要在 iSeries 服务器上运行 Java 程序，您必须对集成文件系统中的类文件具有权限。程序一旦启动，它就在该用户权限控制下运行。 您可以使用沿用权限来访问具有运行程序的用户的权限和程序拥有者权限的对象。沿用权限临时地将用户原先无权访问的对象的权限授予用户。
并发性：JAVA支持多线程技术，就是多个线程并行机制，多线程是Java的一个重要方法,特别有利于在程序中实现并发任务Java提供Thread线程类,实现了多线程的并发机制
j2se j2ee j2me
J2SE商业版本，标准版本 (Java2 Standard Edition) 定位在客户端，主要用于桌面应用软件的编程。
J2EE Java2平台企业版,企业级网站设计
J2ME在嵌入式系统上应用
类表示同一类事物的集合表示,就像是一个模板,它具有该同种对象的所有表现,它包含类的属性和方法,如举一个人的类,那么这个类有姓名 年龄 性别 等(属性),它会说话 会吃东西 等(方法),这就是一个简单的类,那么对象呢假设一个张三,一个李四，可能他们说话,吃东西方法类似,但是他们的姓名,年龄 性别等不一定是相同的,这就是一个类的具体的一个对象
Java的命名习惯：
1、包名中的字母一律小写。xxxyyyzzz
2、类名、接口名应当使用名词，每个单词的首字母大写。XxxYyyZzz
3、方法名，第一个单词小写，后面每个单词的首字母大写。xxxYyyZzz
4、变量名，第一个单词小写，后面第个单词的首字母大写。xxxYyyZzz
5、常量名中的每个字母一律大写。XXXYYYZZZ
所谓函数重载是指同一个函数名可以对应着多个函数的实现。例如，可以给函数名add()定义多个函数实现，该函数的功能是求和，即求两个操作数的和。其中，一个函数实现是求两个int型数之和，另一个实现是求两个浮点型数之和，再一个实现是求两个复数的和。每种实现对应着一个函数体，这些函数的名字相同，但是函数的参数的类型不同。这就是函数重载的概念。
0条评论