Ⅰ java使用tcp协议传送数据库读取的数据
。。。。先自己看网络编程的资料:
最简单的思路:
服务器端:
侦听-》侦听到连接-》获得客户端的查询请求-》查询数据库-》发送数据给客户端
客户端：
连接服务器-》发送查询请求-》等待数据-》读取数据
Ⅱ java网络编程中，对于客户端和服务器的tcp连接，如果客户端异常断开连接，服务器端如何获知，有什么方法
这个得用java心跳处理机制。就是客户端每隔一段时间向服务器发送指定信息，如果服务器没有收到客服端发来的信息，这时服务器和客服端连接就已经断开。具体的心跳实现网络上很多。
Ⅲ Java 请教TCP网络编程里面的两个方法的使用！
package chatClient;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.JOptionPane;
import javax.swing.JFrame;
import javax.swing.JPasswordField;
import javax.swing.JTextArea;
import org.apache.log4j.Logger;
import DownLoad.*;
import config.*;
public class ChatClient extends JFrame {
private static Logger log=Logger.getLogger(ChatClient.class);
Socket s = null;
TextField tf = new TextField();
TextArea ta = new TextArea(null,11,50,TextArea.SCROLLBARS_VERTICAL_ONLY);
Panel p=new Panel(new GridLayout(2,6,2,3));
Label l3=new Label("下裁的文件名：");
TextField tf1 = new TextField();
Button b3=new Button("下载");
Label l4=new Label("上传的文件名：");
TextField tf2 = new TextField();
Button b4=new Button("上传");
Label l1=new Label("用户名：");
Label l2=new Label("密码：");
TextField name = new TextField();
JPasswordField pwd=new JPasswordField();
Button b1=new Button("连接");
Button b2=new Button("断开");
SimpleDateFormat st=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
DataOutputStream dos = null;
DataInputStream dis = null;
String cname;
boolean success=false;
boolean start=true;
public static void main(String[] args) {
new ChatClient().launchFrame();
log.debug("test");
log.info("info");
log.error("error");
}
public void launchFrame(){
setLocation(300,333);
p.add(l1);
p.add(name);
p.add(l2);
p.add(pwd);
p.add(b1);
p.add(b2);
p.add(l3);p.add(tf1);p.add(b3);p.add(l4);p.add(tf2);p.add(b4);
ta.setCaretPosition(ta.getText().length());
add(p,BorderLayout.NORTH);
add(tf,BorderLayout.SOUTH);
add(ta,BorderLayout.CENTER);
pack();
this.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e) {
if(!success){disconnect();}
System.exit(0);
}
});
tf.addActionListener(new TFListener());
b1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if(check()){
connect();
if(!success){
new Thread(new Receve()).start();
}
}else{
JOptionPane.showMessageDialog(null, "用户名或密码错误，请确认后重输！");
}
}
});
b2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
disconnect();
}
});
b3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if(tf1.getText().equals("")){
JOptionPane.showMessageDialog(null, "输入要下裁的文件名！");
}else{
new DownloadStartupC().start(tf1.getText());
}
}
});
b4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if(tf2.getText().equals("")){
JOptionPane.showMessageDialog(null, "请输入要上传的文件名和路径！");
}else{
new DownloadStartup().start(tf2.getText());
}
}
});
setVisible(true);
this.setResizable(false);
}
public boolean check(){
cname=name.getText();
String pwd1=pwd.getText();
String pwd2=FileUtil.getMemberData(cname);
if(pwd1.equals(pwd2)){
return true;
}else{
return false;
}
}
public void connect(){
start=true;
try {
s= new Socket (FileUtil.getServerInfoData("serverhost"),Integer.parseInt(FileUtil.getServerInfoData("serverport")));
dos = new DataOutputStream(s.getOutputStream());
dis = new DataInputStream(s.getInputStream());
dos.writeUTF(cname+"登录 "+st.format(new Date()));
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "服务器端异常，请稍后重试！");
success=true;
return;
}
success=false;
b1.setEnabled(false);
}
public void disconnect (){
try {
if(dos!=null){
dos.writeUTF(cname+"退出 "+st.format(new Date()));
dos.close();}
if(s!=null){
s.close();}
} catch (IOException e) {
e.printStackTrace();
}
success=true;
b1.setEnabled(true);
}
private class TFListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String str = tf.getText();
tf.setText("");
try {
dos.writeUTF(cname+":"+str);
dos.flush();
} catch (Exception e1) {
log.info(e.toString());
JOptionPane.showMessageDialog(null, "未连接，请连接后再发言！");
}
}
}
private class Receve implements Runnable{
public void run() {
try{
while(start){
String s= dis.readUTF();
//if(s.equals("服务器已关闭，请重新登录！")){
// start=false;
// b1.setEnabled(true);
// }
ta.setText(ta.getText()+s+'\n');
ta.setCaretPosition(ta.getText().length());
}
} catch(IOException e){
start=false;
b1.setEnabled(true);
// e.printStackTrace();
}
}
}
}
package ChatServer;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Frame;
import java.awt.GridLayout;
import java.awt.TextArea;
import java.awt.TextField;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.*;
import java.net.*;
import java.util.*;
import javax.swing.*;
import DownLoad.DownloadStartup;
import config.FileUtil;
public class ChatServer extends Frame {
ServerSocket ss = null;
Socket s = null;
boolean start = false;
DataInputStream dis = null;
List clients = new ArrayList();
TextArea ta = new TextArea(null,11,50,TextArea.SCROLLBARS_VERTICAL_ONLY);
JPanel p = new JPanel(new GridLayout(2, 2, 5, 5));
TextField tf = new TextField();
JButton b3 = new JButton("上传");
JButton b1 = new JButton("start");
JButton b2 = new JButton("stop");
class Client implements Runnable {
private Socket s = null;
private DataInputStream dis = null;
private DataOutputStream dos = null;
private boolean stat = false;
public Client(Socket s) {
this.s = s;
try {
dis = new DataInputStream(s.getInputStream());
dos = new DataOutputStream(s.getOutputStream());
stat = true;
} catch (IOException e) {
e.printStackTrace();
}
}
public void send(String str) {
try {
dos.writeUTF(str);
} catch (Exception e) {
clients.remove(this);
// e.printStackTrace();
}
}
public void run() {
Client c = null;
try {
while (stat) {
String str = dis.readUTF();
ta.setText(ta.getText()+str+"\n");
ta.setCaretPosition(ta.getText().length());
for (int i = 0; i < clients.size(); i++) {
c = (Client) clients.get(i);
c.send(str);
}
// System.out.println(clients.size());
}
} catch (Exception e) {
//System.out.println("closed!");
} finally {
try {
if (dos != null)
dos.close();
if (dis != null)
dis.close();
if (s != null)
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
new ChatServer().launchFrame();
}
public void launchFrame() {
setLocation(300, 333);
this.setSize(300, 300);
this.setTitle("服务器端");
p.add(b1);
p.add(b2);
p.add(tf);
p.add(b3);
ta.setCaretPosition(ta.getText().length());
add(p, BorderLayout.SOUTH);
add(ta, BorderLayout.CENTER);
pack();
this.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
Thread t=new Thread(new DisConnection());
t.start();
Client c = null;
for (int i = 0; i < clients.size(); i++) {
c = (Client) clients.get(i);
c.send("服务器已关闭，请稍后重新登录！");
}
System.exit(0);
}
});
b1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
setTitle("服务器启动");
Thread t=new Thread(new Connection());
t.start();
}
});
b2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
setTitle("服务器关闭");
Thread t=new Thread(new DisConnection());
t.start();
Client c = null;
for (int i = 0; i < clients.size(); i++) {
c = (Client) clients.get(i);
c.send("服务器已关闭，请稍后重新登录！");
}
}
});
b3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// System.out.println(tf.getText());
if(tf.getText().equals("")){
JOptionPane.showMessageDialog(null, "请输入要上传的文件名和路径！");
}else{
new DownloadStartup().start(tf.getText());}
}
});
setVisible(true);
}
private class Connection implements Runnable{
public void run() {
try {
ss = new ServerSocket(Integer.parseInt(FileUtil.getServerInfoData("serverport")));
} catch (Exception e) {
e.printStackTrace();
JOptionPane.showMessageDialog(null, "服务器启动不成功，重试！");
}
try {
start = true;
while (start) {
s = ss.accept();
Client c = new Client(s);
// System.out.println("A Client connected!");
new Thread(c).start();
clients.add(c);
}
} catch (Exception e) {
System.out.println("服务器关闭");
} finally {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
private class DisConnection implements Runnable{
public void run() {
try {
if(s!=null){
s.close();
}
if(ss!=null){
ss.close();
System.out.println("close");
}
} catch (IOException e) {
e.printStackTrace();
}
try {
FileOutputStream out=new FileOutputStream("Chathistory/history.txt");
out.write(ta.getText().getBytes());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
给你个例子 自己看吧
两个类 可以运行的 你运行起来看看
Ⅳ 怎样理解java中的网络编程
Java中的网路编程主要是Java的Socket编程，属于JavaEE中的高级的部分，以下内容是对java网路编程的一个小结，代码都是经过编译调试的
C/S程序应用：客户/服务器模式，如QQ客户端，客户端连到服务器上，一个C/S模式的应用必须有两套程序，一个是客户端的程序，一个是服务器程序。
B/S程序应用：浏览器/服务器模式，如当下的各种网站都是B/S模式，所有的程序代码都在服务器上，用户通过浏览器去访问。
C/S程序分为两种：
基于TCP协议：Socket（套接字）, 可靠的编程： A->B 如打电话先建立连接
基于UDP协议：不可靠，如短信功能。
如果编写一个TCP程序需要JAVA的两个包支持：
java.net.*: 主要提供网络支持；
|-ServerSocket类：服务器端程序
|-Socket类：客户端程序
java,io.*:传递信息流
客户端的两个功能：
1.建立Socket
2.接收输入的命令（输入流）->网络上传输的程序考的是字节流
以下是服务器端，客户端的两个事例程序，服务器端想客户端输出Hello word, 客户端接收并显示；
服务器程序：
importjava.io.*;
importjava.net.*;
publicclassTCPSever{
/**
*@paramargs
*@throwsIOException
*/
publicstaticvoidmain(String[]args)throwsIOException{
//TODOAuto-generatedmethodstub
//使用ServerSocket
ServerSocketserver=newServerSocket(8000);
//每个用户在程序中就是一个Socket
Socketclient=null;
//等待客户端连接
client=server.accept();
//像客户端打印信息
PrintWriterout=null;
//准被向客户端打印信息
out=newPrintWriter(client.getOutputStream());
out.println("HelloWorld");
out.close();
client.close();
server.close();
}
}
客户端程序：
packageClient;
importjava.io.*;
importjava.net.*;
publicclassTCPClient{
/**
*@paramargs
*@throwsIOException
*@throwsUnknownHostException
*/
publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
//TODOAuto-generatedmethodstub
//表示一个客户端的Socket
Socketclient=null;
//表示一个客户端的输入信息
BufferedReaderbuf=null;
client=newSocket("localhost",8000);
buf=newBufferedReader(newInputStreamReader(client.getInputStream()));
System.out.println(buf.readLine());
buf.close();
client.close();
}
}
在JDK中也准备了两个专门用于实现UDP的类
1.DatagramScoket
2.DatagramPacket
服务器端程序：
packageClient;
importjava.io.*;
importjava.net.*;
publicclassTCPClient{
/**
*@paramargs
*@throwsIOException
*@throwsUnknownHostException
*/
publicstaticvoidmain(String[]args)throwsUnknownHostException,IOException{
//TODOAuto-generatedmethodstub
//表示一个客户端的Socket
Socketclient=null;
//表示一个客户端的输入信息
BufferedReaderbuf=null;
client=newSocket("localhost",8000);
buf=newBufferedReader(newInputStreamReader(client.getInputStream()));
System.out.println(buf.readLine());
buf.close();
client.close();
}
}
客户端程序：
packageTest4;
importjava.io.*;
importjava.net.*;
publicclassUDPClient{
/**
*@paramargs
*@throwsIOException
*/
publicstaticvoidmain(String[]args)throwsIOException{
//TODOAuto-generatedmethodstub
DatagramSocketds=null;
DatagramPacketdp=null;
byte[]b=newbyte[1024];
ds=newDatagramSocket(8000);
dp=newDatagramPacket(b,b.length);
ds.receive(dp);
Stringstr=newString(dp.getData(),0,dp.getLength());
System.out.println(str);
}
}
Ⅳ Java网络编程需要导入()包中的类与接口
咨询记录 · 回答于2021-12-26
Ⅵ Java网络编程tcp，新手问题，
if(line.equals("over")){break;}//-------------------------------- 接收第一种结束标记。
改成
if(line.equals("over")){
so.shutdownInput();
break;}
Ⅶ java 网络编程： 如何实现客户端与客户端之间的之间通信
服务器告知双方对方的ip地址，并协调由哪一方主动连接。
如 协调结果是： 把c2的地址告诉c1，让c1主动连接c2，让c2打开端口等待连接。
要考虑认证问题，比如c2如何知道连接上来的是c1，而不是其他人，就需要有认证机制。
另外要考虑内网问题。由于从外部连接内网里面的IP地址是相当繁琐复杂的，所以需要特别的机制处理。
Ⅷ java的tcp网络编程问题
在服务器端
ow.write("welcome".getBytes());后添加
ow.flush();
Ⅸ 使用Java网络编程编写SIP消息的收发，TCP和UDP有什么区别
目前通用的编程语言有两种形式：汇编语言和高级语言。
汇编语言的实质和机器语言是相同的，都是直接对硬件操作，只不过指令采用了英文缩写的标识符，更容易识别和记忆。它同样需要编程者将每一步具体的操作用命令的形式写出来。汇编程序通常由三部分组成：指令、伪指令和宏指令。汇编程序的每一句指令只能对应实际操作过程中的一个很细微的动作，例如移动、自增，因此汇编源程序一般比较冗长、复杂、容易出错，而且使用汇编语言编程需要有更多的计算机专业知识，但汇编语言的优点也是显而易见的，用汇编语言所能完成的操作不是一般高级语言所能实现的，而且源程序经汇编生成的可执行文件不仅比较小，而且执行速度很快。
高级语言是目前绝大多数编程者的选择。和汇编语言相比，它不但将许多相关的机器指令合成为单条指令，并且去掉了与具体操作有关但与完成工作无关的细节，例如使用堆栈、寄存器等，这样就大大简化了程序中的指令。同时，由于省略了很多细节，编程者也就不需要有太多的专业知识。
高级语言主要是相对于汇编语言而言，它并不是特指某一种具体的语言，而是包括了很多编程语言，如目前流行的VB、VC、FoxPro、Delphi等，这些语言的语法、命令格式都各不相同。
高级语言所编制的程序不能直接被计算机识别，必须经过转换才能被执行，按转换方式可将它们分为两类:
解释类：执行方式类似于我们日常生活中的“同声翻译”，应用程序源代码一边由相应语言的解释器“翻译”成目标代码(机器语言)，一边执行，因此效率比较低，而且不能生成可独立执行的可执行文件，应用程序不能脱离其解释器，但这种方式比较灵活，可以动态地调整、修改应用程序。
编译类：编译是指在应用源程序执行之前，就将程序源代码“翻译”成目标代码(机器语言)，因此其目标程序可以脱离其语言环境独立执行，使用比较方便、效率较高。但应用程序一旦需要修改，必须先修改源代码，再重新编译生成新的目标文件(＊ .OBJ)才能执行，只有目标文件而没有源代码，修改很不方便。现在大多数的编程语言都是编译型的，例如Visual C＋＋、Visual Foxpro、Delphi等。