本站提倡有节制游戏，合理安排游戏时间，注意劳逸结合。 本站提倡有节制游戏，合理安排游戏时间，注意劳逸结合。 1.jfinal不兼容的浏览器有哪些
2.unity photon 能取代传统服务器吗
3.java中如何实现从客户端发送文件到服务器端？
jfinal不兼容的浏览器有哪些
官网介绍：JFinal 是基于 Java 语言的极速 WEB + ORM
框架，其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、网卡驱动源码学习易扩展、Restful。在拥有Java语言所有优势的同时再拥有ruby、python、php等动态语言的开发效率！为您节约更多时间，仙游游戏源码去陪恋人、家人和朋友
:)
Jfinal是JAVA框架， 不在浏览器上执行的， 是两个方向。
如果你说的是Jfinal做为后台，进行下载文件服务时，是否有浏览器兼容问题，在Jfinal3.0之后的版已经全面兼容了
3.3版的源码中可看到已经有处理：
/*** Copyright (c) -, James Zhan 詹波 (jfinal@.com).
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* .jfinal.render;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import javax.servlet.ServletContext;
import javax.servlet..jfinal.kit.LogKit;
import com.jfinal.kit.StrKit;
/
*** FileRender.
*/
public class FileRender extends Render {
protected static final String DEFAULT_CONTENT_TYPE = "application/octet-stream";
protected static String baseDownloadPath;
protected static ServletContext servletContext;
protected File file;
protected String downloadFileName = null;
public FileRender(File file) {
if (file == null) {
throw new IllegalArgumentException("file can not be null.");
}
this.file = file;
}
public FileRender(File file, String downloadFileName) {
this(file);
if (StrKit.isBlank(downloadFileName)) {
throw new IllegalArgumentException("downloadFileName can not be blank.");
}
this.downloadFileName = downloadFileName;
}
public FileRender(String fileName) {
if (StrKit.isBlank(fileName)) {
throw new IllegalArgumentException("fileName can not be blank.");
}
String fullFileName;
fileName = fileName.trim();
if (fileName.startsWith("/") || fileName.startsWith("\\")) {
if (baseDownloadPath.equals("/")) {
fullFileName = fileName;
} else {
fullFileName = baseDownloadPath + fileName;
}
} else {
fullFileName = baseDownloadPath + File.separator + fileName;
}
this.file = new File(fullFileName);
}
public FileRender(String fileName, String downloadFileName) {
this(fileName);
if (StrKit.isBlank(downloadFileName)) {
throw new IllegalArgumentException("downloadFileName can not be blank.");
}
this.downloadFileName = downloadFileName;
}
static void init(String baseDownloadPath, ServletContext servletContext) {
FileRender.baseDownloadPath = baseDownloadPath;
FileRender.servletContext = servletContext;
}
public void render() {
if (file == null || !file.isFile()) {
RenderManager.me().getRenderFactory().getErrorRender().setContext(request, response).render();
return ;
}
// ---------
response.setHeader("Accept-Ranges", "bytes");
String fn = downloadFileName == null ? file.getName() : downloadFileName;
response.setHeader("Content-disposition", "attachment; " + encodeFileName(request, fn));
String contentType = servletContext.getMimeType(file.getName());
response.setContentType(contentType != null ? contentType : DEFAULT_CONTENT_TYPE);
// ---------
if (StrKit.isBlank(request.getHeader("Range"))) {
normalRender();
} else {
rangeRender();
}
}
protected String encodeFileName(String fileName) {
try {
// return new String(fileName.getBytes("GBK"), "ISO-1");
return new String(fileName.getBytes(getEncoding()), "ISO-1");
} catch (UnsupportedEncodingException e) {
return fileName;
}
}
/
*** 依据浏览器判断编码规则
*/
public String encodeFileName(HttpServletRequest request, String fileName) {
String userAgent = request.getHeader("User-Agent");
try {
String encodedFileName = URLEncoder.encode(fileName, "UTF8");
// 如果没有UA，则默认使用IE的方式进行编码
if (userAgent == null) {
return "filename=\"" + encodedFileName + "\"";
}
userAgent = userAgent.toLowerCase();
// IE浏览器，只能采用URLEncoder编码
if (userAgent.indexOf("msie") != -1) {
return "filename=\"" + encodedFileName + "\"";
}
// Opera浏览器只能采用filename
*if (userAgent.indexOf("opera") != -1) {
return "filename*=UTF-8''" + encodedFileName;
}
// Safari浏览器，只能采用ISO编码的源码梳理文档中文输出,Chrome浏览器，只能采用MimeUtility编码或ISO编码的中文输出
if (userAgent.indexOf("safari") != -1 || userAgent.indexOf("applewebkit") != -1 || userAgent.indexOf("chrome") != -1) {
return "filename=\"" + new String(fileName.getBytes("UTF-8"), "ISO-1") + "\"";
}
// FireFox浏览器，可以使用MimeUtility或filename*或ISO编码的中文输出
if (userAgent.indexOf("mozilla") != -1) {
return "filename*=UTF-8''" + encodedFileName;
}
return "filename=\"" + encodedFileName + "\"";
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
}
protected void normalRender() {
response.setHeader("Content-Length", String.valueOf(file.length()));
InputStream inputStream = null;
OutputStream outputStream = null;
try {
inputStream = new BufferedInputStream(new FileInputStream(file));
outputStream = response.getOutputStream();
byte[] buffer = new byte[];
for (int len = -1; (len = inputStream.read(buffer)) != -1;) {
outputStream.write(buffer, 0, len);
}
outputStream.flush();
outputStream.close();
} catch (IOException e) {
String n = e.getClass().getSimpleName();
if (n.equals("ClientAbortException") || n.equals("EofException")) {
} else {
throw new RenderException(e);
}
} catch (Exception e) {
throw new RenderException(e);
} finally {
if (inputStream != null)
try { inputStream.close();} catch (IOException e) { LogKit.error(e.getMessage(), e);}
}
}
protected void rangeRender() {
Long[] range = { null, null};
processRange(range);
String contentLength = String.valueOf(range[1].longValue() - range[0].longValue() + 1);
response.setHeader("Content-Length", contentLength);
response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT); // status =
// Content-Range: bytes 0-/
StringBuilder contentRange = new StringBuilder("bytes ").append(String.valueOf(range[0])).append("-").append(String.valueOf(range[1])).append("/").append(String.valueOf(file.length()));
response.setHeader("Content-Range", contentRange.toString());
InputStream inputStream = null;
OutputStream outputStream = null;
try {
long start = range[0];
long end = range[1];
inputStream = new BufferedInputStream(new FileInputStream(file));
if (inputStream.skip(start) != start)
throw new RuntimeException("File skip error");
outputStream = response.getOutputStream();
byte[] buffer = new byte[];
long position = start;
for (int len; position <= end && (len = inputStream.read(buffer)) != -1;) {
if (position + len <= end) {
outputStream.write(buffer, 0, len);
position += len;
}
else {
for (int i=0; i<len && position <= end; i++) {
outputStream.write(buffer[i]);
position++;
}
}
}
outputStream.flush();
outputStream.close();
}
catch (IOException e) {
String n = e.getClass().getSimpleName();
if (n.equals("ClientAbortException") || n.equals("EofException")) {
} else {
throw new RenderException(e);
}
}
catch (Exception e) {
throw new RenderException(e);
}
finally {
if (inputStream != null)
try { inputStream.close();} catch (IOException e) { LogKit.error(e.getMessage(), e);}
}
}
/
*** Examples of byte-ranges-specifier values (assuming an entity-body of length ):
* The first bytes (byte offsets 0-, inclusive): bytes=0-
* The second bytes (byte offsets -, inclusive): bytes=-
* The final bytes (byte offsets -, inclusive): bytes=-
* Or bytes=-
*/
protected void processRange(Long[] range) {
String rangeStr = request.getHeader("Range");
int index = rangeStr.indexOf(',');
if (index != -1)
rangeStr = rangeStr.substring(0, index);
rangeStr = rangeStr.replace("bytes=", "");
String[] arr = rangeStr.split("-", 2);
if (arr.length < 2)
throw new RuntimeException("Range error");
long fileLength = file.length();
for (int i=0; i<range.length; i++) {
if (StrKit.notBlank(arr[i])) {
range[i] = Long.parseLong(arr[i].trim());
if (range[i] >= fileLength)
range[i] = fileLength - 1;
}
}
// Range format like: -
if (range[0] != null && range[1] == null) {
range[1] = fileLength - 1;
}
// Range format like: -
else if (range[0] == null && range[1] != null) {
range[0] = fileLength - range[1];
range[1] = fileLength - 1;
}
// check final range
if (range[0] == null || range[1] == null || range[0].longValue() > range[1].longValue())
throw new RuntimeException("Range error");
}
}
unity photon 能取代传统服务器吗
* 具体实现过程：
* 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[ * 5];
/**用来接收文件发送请求的字符串*/
String comm = null;
/**建立socekt通信，等待服务器进行连接*/
try {
ss = new ServerSocket();
s = ss.accept();
} catch (IOException e) {
e.printStackTrace();
}
/**读取一行客户端发送过来的约定信息*/
try {
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
comm = br.readLine();
} catch (IOException e) {
System.out.println("服务器与客户端断开连接");
}
/**开始解析客户端发送过来的请求命令*/
int index = comm.indexOf("/#");
/**判断协议是否为发送文件的协议*/
String xieyi = comm.substring(0, index);
if(!xieyi.equals("")){
System.out.println("服务器收到的协议码不正确");
return;
}
/**解析出文件的名字和大小*/
comm = comm.substring(index + 2);
index = comm.indexOf("/#");
String filename = comm.substring(0, index).trim();
String filesize = comm.substring(index + 2).trim();
/**创建空文件，用来进行接收文件*/
file = new File(filename);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("服务器端创建文件失败");
}
}else{
/**在此也可以询问是否覆盖*/
System.out.println("本路径已存在相同文件，进行覆盖");
}
/**以上就是客户端代码中写到的服务器的准备部分*/
/
*** 服务器接收文件的关键代码*/
try {
/**将文件包装到文件输出流对象中*/
fos = new FileOutputStream(file);
long file_size = Long.parseLong(filesize);
is = s.getInputStream();
/**size为每次接收数据包的长度*/
int size = 0;
/**count用来记录已接收到文件的长度*/
long count = 0;
/**使用while循环接收数据包*/
while(count < file_size){
/**从输入流中读取一个数据包*/
size = is.read(buffer);
/**将刚刚读取的数据包写到本地文件中去*/
fos.write(buffer, 0, size);
fos.flush();
/**将已接收到文件的长度+size*/
count += size;
System.out.println("服务器端接收到数据包，大小为" + size);
}
} catch (FileNotFoundException e) {
System.out.println("服务器写文件失败");
} catch (IOException e) {
System.out.println("服务器：客户端断开连接");
}finally{
/
*** 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ServerReceive
客户端源码：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/
***
* 文件名：ClientSend.java
* 实现功能：作为客户端向服务器发送一个文件
*
* 具体实现过程：
* 1、建立与服务器端的还原系统源码连接，IP：.0.0.1， port：
* 2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器
* 3、循环读取本地文件，将文件打包发送到数据输出流中
* 4、关闭文件，结束传输
*
* */
public class ClientSend {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
Socket s = null;
/**定义文件对象，即为要发送的文件
* 如果使用绝对路径，不要忘记使用'/'和'\'的区别
* 具体区别，请读者自行查询
* */
File sendfile = new File("API.CHM");
/**定义文件输入流，用来打开、读取即将要发送的文件*/
FileInputStream fis = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[ * 5];
/**定义输出流，使用socket的outputStream对数据包进行输出*/
OutputStream os = null;
/**检查要发送的文件是否存在*/
if(!sendfile.exists()){
System.out.println("客户端：要发送的文件不存在");
return;
}
/**与服务器建立连接*/
try {
s = new Socket(".0.0.1", );
}catch (IOException e) {
System.out.println("未连接到服务器");
}
/**用文件对象初始化fis对象
* 以便于可以提取出文件的大小
* */
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
/**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作
* 具体的准备工作，请查看服务器代码。
*
* 发送的内容包括：发送文件协议码（此处为）/#文件名（带后缀名）/#文件大小
* */
try {
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("/#" + sendfile.getName() + "/#" + fis.available());
ps.flush();
} catch (IOException e) {
System.out.println("服务器连接中断");
}
/
*** 此处睡眠2s，等待服务器把相关的工作准备好
* 也是为了保证网络的延迟
* 读者可自行选择添加此代码
* */
try {
Thread.sleep();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
/**之前的准备工作结束之后
* 下面就是文件传输的关键代码
* */
try {
/**获取socket的OutputStream，以便向其中写入数据包*/
os = s.getOutputStream();
/** size 用来记录每次读取文件的大小*/
int size = 0;
/**使用while循环读取文件，直到文件读取结束*/
while((size = fis.read(buffer)) != -1){
System.out.println("客户端发送数据包，大小为" + size);
/**向输出流中写入刚刚读到的数据包*/
os.write(buffer, 0, size);
/**刷新一下*/
os.flush();
}
} catch (FileNotFoundException e) {
System.out.println("客户端读取文件出错");
} catch (IOException e) {
System.out.println("客户端输出文件出错");
}finally{
/
*** 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fis != null)
fis.close();
} catch (IOException e) {
System.out.println("客户端文件关闭出错");
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ClientSend
java中如何实现从客户端发送文件到服务器端？
服务器端源码：
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/
***
* 文件名：ServerReceive.java
* 实现功能：作为服务器接收客户端发送的文件
*
* 具体实现过程：
* 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[ * 5];
/**用来接收文件发送请求的字符串*/
String comm = null;
/**建立socekt通信，等待服务器进行连接*/
try {
ss = new ServerSocket();
s = ss.accept();
} catch (IOException e) {
e.printStackTrace();
}
/**读取一行客户端发送过来的约定信息*/
try {
InputStreamReader isr = new InputStreamReader(s.getInputStream());
BufferedReader br = new BufferedReader(isr);
comm = br.readLine();
} catch (IOException e) {
System.out.println("服务器与客户端断开连接");
}
/**开始解析客户端发送过来的请求命令*/
int index = comm.indexOf("/#");
/**判断协议是否为发送文件的协议*/
String xieyi = comm.substring(0, index);
if(!xieyi.equals("")){
System.out.println("服务器收到的协议码不正确");
return;
}
/**解析出文件的名字和大小*/
comm = comm.substring(index + 2);
index = comm.indexOf("/#");
String filename = comm.substring(0, index).trim();
String filesize = comm.substring(index + 2).trim();
/**创建空文件，用来进行接收文件*/
file = new File(filename);
if(!file.exists()){
try {
file.createNewFile();
} catch (IOException e) {
System.out.println("服务器端创建文件失败");
}
}else{
/**在此也可以询问是否覆盖*/
System.out.println("本路径已存在相同文件，进行覆盖");
}
/**以上就是客户端代码中写到的服务器的准备部分*/
/
*** 服务器接收文件的关键代码*/
try {
/**将文件包装到文件输出流对象中*/
fos = new FileOutputStream(file);
long file_size = Long.parseLong(filesize);
is = s.getInputStream();
/**size为每次接收数据包的长度*/
int size = 0;
/**count用来记录已接收到文件的长度*/
long count = 0;
/**使用while循环接收数据包*/
while(count < file_size){
/**从输入流中读取一个数据包*/
size = is.read(buffer);
/**将刚刚读取的数据包写到本地文件中去*/
fos.write(buffer, 0, size);
fos.flush();
/**将已接收到文件的长度+size*/
count += size;
System.out.println("服务器端接收到数据包，大小为" + size);
}
} catch (FileNotFoundException e) {
System.out.println("服务器写文件失败");
} catch (IOException e) {
System.out.println("服务器：客户端断开连接");
}finally{
/
*** 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fos != null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ServerReceive
客户端源码：
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/
***
* 文件名：ClientSend.java
* 实现功能：作为客户端向服务器发送一个文件
*
* 具体实现过程：
* 1、建立与服务器端的连接，IP：.0.0.1， port：
* 2、将文件的名字和大小通过自定义的文件传输协议，发送到服务器
* 3、循环读取本地文件，将文件打包发送到数据输出流中
* 4、关闭文件，结束传输
*
* */
public class ClientSend {
public static void main(String[] args) {
/**与服务器建立连接的通信句柄*/
Socket s = null;
/**定义文件对象，即为要发送的文件
* 如果使用绝对路径，不要忘记使用'/'和'\'的区别
* 具体区别，请读者自行查询
* */
File sendfile = new File("API.CHM");
/**定义文件输入流，用来打开、读取即将要发送的文件*/
FileInputStream fis = null;
/**定义byte数组来作为数据包的存储数据包*/
byte[] buffer = new byte[ * 5];
/**定义输出流，使用socket的outputStream对数据包进行输出*/
OutputStream os = null;
/**检查要发送的文件是否存在*/
if(!sendfile.exists()){
System.out.println("客户端：要发送的文件不存在");
return;
}
/**与服务器建立连接*/
try {
s = new Socket(".0.0.1", );
}catch (IOException e) {
System.out.println("未连接到服务器");
}
/**用文件对象初始化fis对象
* 以便于可以提取出文件的大小
* */
try {
fis = new FileInputStream(sendfile);
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
/**首先先向服务器发送关于文件的信息，以便于服务器进行接收的相关准备工作
* 具体的准备工作，请查看服务器代码。
*
* 发送的内容包括：发送文件协议码（此处为）/#文件名（带后缀名）/#文件大小
* */
try {
PrintStream ps = new PrintStream(s.getOutputStream());
ps.println("/#" + sendfile.getName() + "/#" + fis.available());
ps.flush();
} catch (IOException e) {
System.out.println("服务器连接中断");
}
/
*** 此处睡眠2s，等待服务器把相关的工作准备好
* 也是为了保证网络的延迟
* 读者可自行选择添加此代码
* */
try {
Thread.sleep();
} catch (InterruptedException e1) {
e1.printStackTrace();
}
/**之前的准备工作结束之后
* 下面就是文件传输的关键代码
* */
try {
/**获取socket的OutputStream，以便向其中写入数据包*/
os = s.getOutputStream();
/** size 用来记录每次读取文件的大小*/
int size = 0;
/**使用while循环读取文件，直到文件读取结束*/
while((size = fis.read(buffer)) != -1){
System.out.println("客户端发送数据包，大小为" + size);
/**向输出流中写入刚刚读到的数据包*/
os.write(buffer, 0, size);
/**刷新一下*/
os.flush();
}
} catch (FileNotFoundException e) {
System.out.println("客户端读取文件出错");
} catch (IOException e) {
System.out.println("客户端输出文件出错");
}finally{
/
*** 将打开的文件关闭
* 如有需要，也可以在此关闭socket连接
* */
try {
if(fis != null)
fis.close();
} catch (IOException e) {
System.out.println("客户端文件关闭出错");
}//catch (IOException e)
}//finally
}//public static void main(String[] args)
}//public class ClientSend