商业源码 请问javaweb开发中的servlet到底怎么用的？它就是一个java类吗，用继承它的类可以实现请求转发？
首先要明白，JSP和Servlet都是位于服务器端，平时我们做开发，自己的机器充当了客户机和服务器的双重角色。在典型的MVC开发模式中，JSP充当了视图层，Servlet充当控制层，JavaBeen充当模型层。
每一个JSP页面一般都会对应一个Sevlet，（在webxml中可以看到有关配置），JSP页面如果是以post方式发出请求给Servlet，就会调用Servlet中的doPost（）方法，如果是以get方式发出请求，就会调用其doGet()方法，一般这两个方法只具体实现一个，可以在另一个方法调用有具体实现的那个方法。至于JSP页面是以get方式发出请求，还是以post方式发出请求，最简单的方式是看地址栏又没有像？name=xxxx&id=xxxx的键值对字符串，如果jsp网页中包含form表单，还可以看其method属性是get还是post，不过一般表单都是用post方式提交给后台Servlet。当请求传给Servlet时，同时也会把相关数据传过去，这样才可以在后台获取这些数据。一般使用requestgetParameter()方法
由于Servlet是控制层，顾名思义，它当然可以控制请求的转发操作。使用requestgetRequestDispatcher("xxx,jsp")forward(request,response)
就先说这些吧，要具体说挺多的。我也有段时间没弄这些了，可能有些单词没写对，不过不影响阅读，还有什么不明白的，继续问。
代理服务器的应用非常广泛。比如，在企业网内部，它可以用来控制员工在工作时浏览的Internet内容，阻止员工访问某些类型的内容或某些指定的网站。代理服务器实际上扮演着浏览器和Web服务器之间的中间人的角色，能够对浏览器请求进行各种各样的处理，能够过滤广告和Cookie，能够预先提取Web页面，使得浏览器访问页面的速度更快，等等。
一、基础知识
不管以哪种方式应用代理服务器，其监控HTTP传输的过程总是如下：
步骤一：内部的浏览器发送请求给代理服务器。请求的第一行包含了目标URL。
步骤二：代理服务器读取该URL，并把请求转发给合适的目标服务器。
步骤三：代理服务器接收来自Internet目标机器的应答，把应答转发给合适的内部浏览器。
例如，假设有一个企业的雇员试图访问wwwcnibmcom网站。如果没有代理服务器，雇员的浏览器打开的Socket通向运行这个网站的Web服务器，从Web服务器返回的数据也直接传递给雇员的浏览器。如果浏览器被配置成使用代理服务器，则请求首先到达代理服务器；随后，代理服务器从请求的第一行提取目标URL，打开一个通向wwwcnibmcom的Socket。当wwwcnibmcom返回应答时，代理服务器把应答转发给雇员的浏览器。
当然，代理服务器并非只适用于企业环境。作为一个开发者，拥有一个自己的代理服务器是一件很不错的事情。例如，我们可以用代理服务器来分析浏览器和Web服务器的交互过程。测试和解决Web应用中存在的问题时，这种功能是很有用的。我们甚至还可以同时使用多个代理服务器（大多数代理服务器允许多个服务器链接在一起使用）。例如，我们可以有一个企业的代理服务器，再加上一个用java编写的代理服务器，用来调试应用程序。但应该注意的是，代理服务器链上的每一个服务器都会对性能产生一定的影响。
二、设计规划
正如其名字所示，代理服务器只不过是一种特殊的服务器。和大多数服务器一样，如果要处理多个请求，代理服务器应该使用线程。下面是一个代理服务器的基本规划：
等待来自客户（Web浏览器）的请求。
启动一个新的线程，以处理客户连接请求。
读取浏览器请求的第一行（该行内容包含了请求的目标URL）。
分析请求的第一行内容，得到目标服务器的名字和端口。
打开一个通向目标服务器（或下一个代理服务器，如合适的话）的Socket。
把请求的第一行发送到输出Socket。
把请求的剩余部分发送到输出Socket。
把目标Web服务器返回的数据发送给发出请求的浏览器。
当然，如果考虑细节的话，情况会更复杂一些。实际上，这里主要有两个问题要考虑：第一，从Socket按行读取数据最适合进一步处理，但这会产生性能瓶颈；第二，两个Socket之间的连接必需高效。有几种方法可以实现这两个目标，但每一种方法都有各自的代价。例如，如果要在数据进入的时候进行过滤，这些数据最好按行读取；然而，大多数时候，当数据到达代理服务器时，立即把它转发出去更适合高效这一要求。另外，数据的发送和接收也可以使用多个独立的线程，但大量地创建和拆除线程也会带来性能问题。因此，对于每一个请求，我们将用一个线程处理数据的接收和发送，同时在数据到达代理服务器时，尽可能快速地把它转发出去。
三、实例
在用java编写这个代理服务器的过程中，注意可重用性是很重要的。因为这样的话，当我们想要在另一个工程中以不同的方式处理浏览器请求时，可以方便地重用该代理服务器。当然，我们必须注意灵活性和效率之间的平衡。
图一显示了本文代理服务器实例（HttpProxyjava）的输出界面，当浏览器访问http://www-900ibmcom/cn/时，代理服务器向默认日志设备（即标准输出设备屏幕）输出浏览器请求的URL。图二显示了SubHttpProxy的输出。SubHttpProxy是HttpProxy的一个简单扩展。
图一
图二
为了构造代理服务器，我从Thread基类派生出了HttpProxy类（文章正文中出现的代码是该类的一些片断，完整的代码请从本文最后下载）。HttpProxy类包含了一些用来定制代理服务器行为的属性，参见Listing 1和表一。
Listing 1
/
一个基础的代理服务器类
/
import javanet;
import javaio;
public class HttpProxy extends Thread {
static public int CONNECT_RETRIES=5;
static public int CONNECT_PAUSE=5;
static public int TIME-OUT=50;
static public int BUFSIZ=1024;
static public boolean logging = false;
static public OutputStream log=null;
// 传入数据用的Socket
protected Socket socket;
// 上级代理服务器，可选
static private String parent=null;
static private int parentPort=-1;
static public void setParentProxy(String name, int pport) {
parent=name;
parentPort=pport;
}
// 在给定Socket上创建一个代理线程。
public HttpProxy(Socket s) { socket=s; start(); }
public void writeLog(int c, boolean browser) throws IOException {
logwrite(c);
}
public void writeLog(byte[] bytes,int offset,
int len, boolean browser) throws IOException {
for (int i=0;i<len;i++) writeLog((int)bytes[offset+i],browser);
}
// 默认情况下，日志信息输出到
// 标准输出设备，
// 派生类可以覆盖它
public String processHostName(String url, String host, int port, Socket sock) {
javatextDateFormat cal=javatextDateFormatgetDateTimeInstance();
Systemoutprintln(calformat(new javautilDate()) + " - " +
url + " " + sockgetInetAddress()+"<BR>");
return host;
}
表一
变量/方法 说明
CONNECT_RETRIES 在放弃之前尝试连接远程主机的次数。
CONNECT_PAUSE 在两次连接尝试之间的暂停时间。
TIME-OUT 等待Socket输入的等待时间。
BUFSIZ Socket输入的缓冲大小。
logging 是否要求代理服务器在日志中记录所有已传输的数据（true表示“是”）。
log 一个OutputStream对象，默认日志例程将向该OutputStream对象输出日志信息。
setParentProxy 用来把一个代理服务器链接到另一个代理服务器（需要指定另一个服务器的名称和端口）。
当代理服务器连接到Web服务器之后，我用一个简单的循环在两个Socket之间传递数据。这里可能出现一个问题，即如果没有可操作的数据，调用read方法可能导致程序阻塞，从而挂起程序。为防止出现这个问题，我用setSoTimeout方法设置了Socket的超时时间（参见Listing 2）。这样，如果某个Socket不可用，另一个仍旧有机会进行处理，我不必创建一个新的线程。
Listing 2
// 执行操作的线程
public void run() {
String line;
String host;
int port=80;
Socket outbound=null;
try {
socketsetSoTimeout(TIMEOUT);
InputStream is=socketgetInputStream();
OutputStream os=null;
try {
// 获取请求行的内容
line="";
host="";
int state=0;
boolean space;
while (true) {
int c=isread();
if (c==-1) break;
if (logging) writeLog(c,true);
space=CharacterisWhitespace((char)c);
switch (state) {
case 0:
if (space) continue;
state=1;
case 1:
if (space) {
state=2;
continue;
}
line=line+(char)c;
break;
case 2:
if (space) continue; // 跳过多个空白字符
state=3;
case 3:
if (space) {
state=4;
// 只分析主机名称部分
String host0=host;
int n;
n=hostindexOf("//");
if (n!=-1) host=hostsubstring(n+2);
n=hostindexOf('/');
if (n!=-1) host=hostsubstring(0,n);
// 分析可能存在的端口号
n=hostindexOf(":");
if (n!=-1) {
port=IntegerparseInt(hostsubstring(n+1));
host=hostsubstring(0,n);
}
host=processHostName(host0,host,port,socket);
if (parent!=null) {
host=parent;
port=parentPort;
}
int retry=CONNECT_RETRIES;
while (retry--!=0) {
try {
outbound=new Socket(host,port);
break;
} catch (Exception e) { }
// 等待
Threadsleep(CONNECT_PAUSE);
}
if (outbound==null) break;
outboundsetSoTimeout(TIMEOUT);
os=outboundgetOutputStream();
oswrite(linegetBytes());
oswrite(' ');
oswrite(host0getBytes());
oswrite(' ');
pipe(is,outboundgetInputStream(),os,socketgetOutputStream());
break;
}
host=host+(char)c;
break;
}
}
}
catch (IOException e) { }
} catch (Exception e) { }
finally {
try { socketclose();} catch (Exception e1) {}
try { outboundclose();} catch (Exception e2) {}
}
}
和所有线程对象一样，HttpProxy类的主要工作在run方法内完成（见Listing 2）。run方法实现了一个简单的状态机，从Web浏览器每次一个读取字符，持续这个过程直至有足够的信息找出目标Web服务器。然后，run打开一个通向该Web服务器的Socket（如果有多个代理服务器被链接在一起，则run方法打开一个通向链里面下一个代理服务器的Socket）。打开Socket之后，run先把部分的请求写入Socket，然后调用pipe方法。pipe方法直接在两个Socket之间以最快的速度执行读写操作。
如果数据规模很大，另外创建一个线程可能具有更高的效率；然而，当数据规模较小时，创建新线程所需要的开销会抵消它带来的好处。
Listing 3显示了一个很简单的main方法，可以用来测试HttpProxy类。大部分的工作由一个静态的startProxy方法完成（见Listing 4）。这个方法用到了一种特殊的技术，允许一个静态成员创建HttpProxy类（或HttpProxy类的子类）的实例。它的基本思想是：把一个Class对象传递给startProxy类；然后，startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法确定该Class对象的哪一个构造函数接受一个Socket参数；最后，startProxy方法调用newInstance方法创建该Class对象。
Listing 3
// 测试用的简单main方法
static public void main(String args[]) {
Systemoutprintln("在端口808启动代理服务器\n");
HttpProxylog=Systemout;
HttpProxylogging=false;
HttpProxystartProxy(808,HttpProxyclass);
}
}
Listing 4
static public void startProxy(int port,Class clobj) {
ServerSocket ssock;
Socket sock;
try {
ssock=new ServerSocket(port);
while (true) {
Class [] sarg = new Class[1];
Object [] arg= new Object[1];
sarg[0]=Socketclass;
try {
javalangreflectConstructor cons = clobjgetDeclaredConstructor(sarg);
arg[0]=ssockaccept();
consnewInstance(arg); // 创建HttpProxy或其派生类的实例
} catch (Exception e) {
Socket esock = (Socket)arg[0];
try { esockclose(); } catch (Exception ec) {}
}
}
} catch (IOException e) {
}
}
利用这种技术，我们可以在不创建startProxy方法定制版本的情况下，扩展HttpProxy类。要得到给定类的Class对象，只需在正常的名字后面加上class（如果有某个对象的一个实例，则代之以调用getClass方法）。由于我们把Class对象传递给了startProxy方法，所以创建HttpProxy的派生类时，就不必再特意去修改startProxy。（下载代码中包含了一个派生得到的简单代理服务器）。
结束语
利用派生类定制或调整代理服务器的行为有两种途径：修改主机的名字，或者捕获所有通过代理服务器的数据。processHostName方法允许代理服务器分析和修改主机名字。如果启用了日志记录，代理服务器为每一个通过服务器的字符调用writeLog方法。如何处理这些信息完全由我们自己决定——可以把它写入日志文件，可以把它输出到控制台，或进行任何其他满足我们要求的处理。writeLog输出中的一个Boolean标记指示出数据是来自浏览器还是Web主机。
和许多工具一样，代理服务器本身并不存在好或者坏的问题，关键在于如何使用它们。代理服务器可能被用于侵犯隐私，但也可以阻隔偷窥者和保护网络。即使代理服务器和浏览器不在同一台机器上，我也乐意把代理服务器看成是一种扩展浏览器功能的途径。例如，在把数据发送给浏览器之前，可以用代理服务器压缩数据；未来的代理服务器甚至还可能把页面从一种语言翻译成另一种语言……可能性永无止境。
通过反射！
下面是一个服务器与客户端信息交互的例子：
反射API介绍
4Java Socket编程 TCP 协议编程
1) TCP工作模型: 先找
堂(主机/IP), 到食堂以后找窗口
(Socket/套接字 端口号), 服务员等待连接,客户向服务员发起连接
连接以后, 一个窗口可以为每个客户安排一个服务员(线程)提供服务,
每个服务过程可以双向交流通讯(流), 通讯完成后要关闭连接
5 TCP 服务端编程(食堂)(javaio,javanet,javalang)
1) 创建ServerSocket实例绑定一个服务端口(Socket/套接字 端口号)
2) 开始ServerSocket实例 的监听, 等待客户端的连接
3) 如果有客户连接进来, 就获得了客户的套接字(Socket)实例
客户的套接字(Socket)实例中包括与客户端建立的连接流
4) 为这个客户(Socket) 创建一个服务线程, 提供服务(run方法)
5) 继续等待下一个连接, 返回到2)
6) 服务线程 完成通讯服务过程
7) 端口号: 0~65535, 1K以下留给系统使用
6 TCP 客户端编程
1) 创建Socket 实例, 连接到服务器端, 成功创建s就表示连接到了
服务器
Socket s = new Socket("host", port)
2) 客户端 Socket 与服务器端 Socket 对应, 都包含输入, 输出流
客户端的sgetInputStream() 连接于服务器sgetOutputStream()
客户端的sgetOutputStream()连接于服务器sgetInputStream()
3) 使用线程处理 网络流
7 Java 反射
1) 反射是Java自我管理(类, 对象)的机制
2) 可以通过反射机制发现对象的类型 发现类型的方法/属性/构造器
3) Java 反射 可以创建对象 并 访问任意对象方法和属性等
4) Class 加载
类加载到内存: java 将磁盘类文件加载到内存中,为一个对象(实例)
这个对象是Class的实例, 也就是 这些对象都是Class实例
5)Class 实例代表Java中类型, 基本类型的类型: intclass, longclass
类类型 Class 实例获得如下:
Class cls = Stringclass;
Class cls = ClassforName("javalangString");
Class cls = "abc"getClass();
以上方法获得cls 是同一个对象, 就是String 类内存加载的结果
package javase2day06ftp;import javaioBufferedOutputStream;import javaioFile;import javaioFileOutputStream;import javaioIOException;import javaioInputStream;import javaioOutputStream;import javanetSocket;import javautilScanner;/ ftp 客户端 可以使用命令 ls pwd get /public class FtpClient { public static void main(String[] args) throws IOException{ FtpClient client = new FtpClient(); clientopen(); } public void open() throws IOException{ Socket s = new Socket("localhost", 9000); InputStream in = sgetInputStream(); OutputStream out = sgetOutputStream(); //处理客户端对服务器的请求 new RequestProcess(out)start(); //处理服务器的反馈信息 new ResponseProcess(in)start(); }//处理客户端对服务器的请求 class RequestProcess extends Thread{ OutputStream out; public RequestProcess(OutputStream out) { thisout = out; } public void run() { try{ Scanner sc = new Scanner(Systemin); while(true){ String s = scnextLine(); IOUtilsprintln(out, s); if(sequals("bye")){ Systemexit(0); } } }catch(IOException e){ eprintStackTrace(); } } } class ResponseProcess extends Thread{ InputStream in; public ResponseProcess(InputStream in) { thisin = in; } public void run() { try{ while(true){ String header = IOUtilsreadLine(in); if(headerstartsWith("text,")){ show(header,in); }else if(headerstartsWith("file,")){ save(header, in); } } }catch(IOException e){ eprintStackTrace(); } } } public void show(String header, InputStream in) throws IOException { int n = IntegerparseInt(headersplit(",")[1]); for(int i=0; i<n; i++){ String s = IOUtilsreadLine(in); Systemoutprintln(s); } } public void save(String header, InputStream in) throws IOException{ File dir = new File("ftp"); if(!direxists()){ dirmkdir(); } //header: file,10,filename String[] data = headersplit(","); long length = LongparseLong(data[1]); String filename = data[2]; File file = new File(dir, filename); BufferedOutputStream out = new BufferedOutputStream( new FileOutputStream(file)); for(long i=0; i<length; i++){ int b = inread(); outwrite(b); } outclose(); } }-----------------------------------package javase2day06ftp;import javaioFile;import javaioFileInputStream;import javaioIOException;import javaioInputStream;import javaioOutputStream;import javanetServerSocket;import javanetSocket;/ 模拟FTP服务器, 支持命令pwd,ls,get file 协议: type,length,value TLV格式 文本: text,5\nline1\nline2\nline3\nline4\nline5\n 文件: file,4,filename\n 41 42 43 44 text,5\nline1\nline2\nline3\nline4\nline5\nfile,4,filename\n 41 42 43 44 /public class FtpServer { public static void main(String[] args) throws IOException{ FtpServer server = new FtpServer(); serverstart(); } public void start() throws IOException{ ServerSocket ss = new ServerSocket(9000); while(true){ Socket s = ssaccept(); new Agent(s)start(); } } class Agent extends Thread{ Socket s; public Agent(Socket s) { thiss = s; } public void run() { try{ InputStream in = sgetInputStream(); OutputStream out = sgetOutputStream(); //向客户端发送, 先发协议头,再发送文本行 outwrite("text,1\n"getBytes());//协议头 //发送消息内容, 一行文本消息 outwrite("欢迎使用FTP演示服务器!\n"getBytes()); outflush(); while(true){ //读取客户端发送到命令 String cmd = IOUtilsreadLine(in)trim(); if("pwd"equals(cmd)){//显示当前目录 pwd(out); }else if("ls"equals(cmd)){ ls(out); }else if(cmdstartsWith("get ")){ get(cmd, out); }else if("bye"equalsIgnoreCase(cmd)){ IOUtilsprintln(out, "text,1"); IOUtilsprintln(out, "Bye, Bye!"); sclose(); }else{ outwrite("text,1\n"getBytes());//协议头 outwrite("只支持pwd,ls,get,bye!\n"getBytes()); outflush(); } } }catch(IOException e){ eprintStackTrace(); } } } public void pwd(OutputStream out) throws IOException{ File dir = new File(""); IOUtilsprintln(out, "text,1"); IOUtilsprintln(out, dirgetCanonicalPath()); } public void ls(OutputStream out) throws IOException{ File dir = new File(""); File[] files = dirlistFiles(); IOUtilsprintln(out, "text,"+fileslength); for (File f : files) { if(fisDirectory()){ IOUtilsprintln(out, "["+fgetName()+"]"); }else{ IOUtilsprintln(out, fgetName()); } } } public void get(String cmd, OutputStream out) throws IOException{ //cmd="get filename" String name = cmdsplit("\\s+")[1]; File file = new File(name); if(! fileexists()){ IOUtilsprintln(out, "text,1"); IOUtilsprintln(out, "没有文件呀!"+name); return; } //文件协议头: IOUtilsprintln(out, "file,"+filelength()+","+name); FileInputStream in = new FileInputStream(file); IOUtilscp(in, out); outflush(); inclose(); IOUtilsprintln(out, "text,1"); IOUtilsprintln(out, "发送成功:"+name); }}
http和tcp是不同层的东西，不能比较
http是应用层协议
tcp是传输层协议
一般来说http就是用tcp进行传输的
所以说，如果只是传文件而不涉及web应用的话，用socket就好了，没必要用http
你要请求web页面的时候才用HttpConnection，比如访问html, servlet, jsp等等
服务器端源码：
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
聊天具体是这么聊，聊天室、群聊、一对一。java其实websocket足矣，ws服务器部署起来，客户端程序连接ws服务器服务，用服务器转发作为消息传输机制，当然你要大文件传输和视频通话就用socket转发连接，p2p通信，这里的p2pjava因为都是服务器部署，不需要做外网打洞穿透，因为web服务器他是本地环境，明白不。你用windows应用程序就需要外网穿透打洞，你不可能视频数据也让服务器转发吧，聊天人数越来越多，服务器承受不了，它需要服务器指派点对点单向传输，不去途径服务器。
0条评论