jfinalclub源码
㈠ 如何评价Jfinal，Jpress
首先，我是从qbasic开始编程，经历了qb到vb，vb到asp(不带.net)，asp到jsp，jsp到php，再回头学习j2ee。这个过程可能导致我的观点可能跟主流观点不同，希望各位理解。
j2ee并不等于spring struts hibernate，还有各种其他的选择，ssh不是唯一甚至不是最好的选择，这里按下不表。
先问一个问题，什么是jsp/servlet不能做，而ssh能做的？没有ssh之前，就没有web应用了么？
有人会觉得servlet傻，可是你看看struts的核心入口Dispatcher，不就是一个Servlet么。你觉得jdbc难用，hibernate的功能最后还是用jdbc实现的，而且不少批量处理的情况，还是原生sql好用，以至于hibernate不得不提供原生sql接口，mybatis正是从这里挖走不少用户。
在很多情况下，ssh做的，只不过是把java/jsp/servlet/jdbc本来就具有的功能，封装成不一样的API，把原先用Java编写的代码变成用XML编写，然后在用java写的解释器在jvm里面去运行这些XML。所以，我觉得ssh其实就是面向web开发这个领域创造出来的一组DSL(领域特定语言)。而这套语言以XML开始，现在转移到java的注解annotation，慢慢的又回归java语言本身。
不太全面的说，struts就是给不熟悉html/css/js的web程序员摆脱它们写业务逻辑用的，hibernate就是给不熟悉SQL的程序员摆脱SQL写数据库程序用的，spring就是给不熟悉java的接口、反射的程序员摆脱接口反射写AOP用的。而上面被代替的这些，恰恰是相关领域的原生DSL，这里面多少有一点讽刺的意味，对么？
如果struts的开发者没有在jsp混杂java片段的各种<%="'"+xx.yy()+"'"%>嵌套括号引号海里面摸爬滚打过来，你觉得他们会想到要做struts么？
如果hibernate的开发者没有在SQL的join链中绕晕过，他们会搞hibernate?
如果spring的开发者没有对java反射的异常数量吐过槽，会有spring?
如果你只想做一个平庸的码农，去学ssh能让你找到一份不错的入门工作。
如果你希望能深入的理解系统、语言、框架，去学习语言本身提供的功能，去学习servlet、jdbc、java，去看看如何用他们构造通用的复杂的系统，也许未来5-10年，人们再提起j2ee，说的就是你创造的框架的名字，而不再是什么spring struts hibernate。
我们总是希望高内聚低耦合，但两者通常是矛盾的；如果你愿意放弃其中的一个，就可以在另一个上面走的更远。
㈡ 现在JFinal越来越火，它的发展趋势怎么样
JFinal 采用微内核全方位扩展架构，全方位是指其扩展方式在空间上的表现形式。JFinal由Handler、Interceptor、Controller、Render、Plugin五大部分组成。
看过源码的都知道, JFinal 是轻薄封装, 原理还是javax.servlet.http.HttpServletRequest等, 所以学好原理, 是最靠谱的, JFinal是为我们快速开发业务实现用的, 新手最好先学会javax.servlet 再来上手JFinal ,
发展趋势 ? 当做一个工具就好了, Java项目都可以放入JFinal , 小巧方便的, 招聘JFinal 也挺多的
㈢ jfinal框架下 分页采取的是freemark 现在要加个下拉框 ，用户根据下拉框的数字，选择页面显示多少条 数据
这个框架我没用过。
加下拉框根据框中的数字 每页显示多少条 这点就可以判断是用SQL分页的。
/**
正序分页 每页20条、第3页 **/
Select * from ( select top 20 * FROM TableName b
WHERE (time <= (SELECT max(time) FROM (
SELECT TOP 60 time FROM TableName b where 1=1 ORDER BY time ) AS T )) 1=1 ORDER BY time desc ) AS T ORDER BY time /**
倒叙分页 每页30条、第2页 **/
Select * from ( select top 30 * FROM TableName b
WHERE (time >= (SELECT min(time) FROM (
SELECT TOP 60 time FROM TableName b where 1=1 ORDER BY time desc ) AS T )) 1=1 ORDER BY time ) AS T ORDER BY time desc
㈣ JFinal 集成kisso怎么使用里面的shiro
这个你需要看kisso的代码了。
推荐一套完整的Shiro Demo，免费的。
推荐一套完整的ShiroDemo，免费的。
ShiroDemo：http://www.sojson.com/shiro
Demo已经部署到线上，地址是http://shiro.itboy.net
管理员帐号：admin，密码：sojson.com如果密码错误，请用sojson。PS：你可以注册自己的帐号，然后用管理员赋权限给你自己的帐号，但是，每20分钟会把数据初始化一次。建议自己下载源码，让Demo跑起来，然后跑的更快。
管理员帐号：admin，密码：sojson.com 如果密码错误，请用sojson。PS：你可以注册自己的帐号，然后用管理员赋权限给你自己的帐号，但是，每20分钟会把数据初始化一次。建议自己下载源码，让Demo跑起来，然后跑的更快。
㈤ JAVA SSH和JFinal框架 有什么区别（优缺点）
1．SSHIntroction
SSH不是一个框架，而是多个框架（struts+spring+hibernate）的集成，是目前较流行的一种Web应用程序开源集成框架，用于构建灵活、易于扩展的多层Web应用程序。如下图1所示为SSH的架构图.
Web层，就是MVC模式里面的“C”（controller）与“V”（View），负责控制业务逻辑层与页面的交互与展现，在SSH架构中，Struts充当controller，JSP充当View。
Service层（就是业务逻辑层），负责实现业务逻辑。业务逻辑层以DAO层为基础，通过对DAO组件的正面模式包装，完成系统所要求的业务逻辑。
DAO层，负责与持久化对象交互。该层封装了数据的增、删、查、改的操作。
PO，持久化对象。通过实体关系映射工具将关系型数据库的数据映射成对象，很方便地实现以面向对象方式操作数据库，该系统采用Hibernate作为ORM框架。Spring的作用贯穿了整个中间层，将Web层、Service层、DAO层及PO无缝整合，其数据服务层用来存放数据。
1.1 Struts的优劣势
1.2 Spring的优劣势
Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架。
1.3 Hibernate的优劣势
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
优点：
1)
Hibernate是JDBC的轻量级的对象封装，它是一个独立的对象持久层框架。Hibernate可以用在任何JDBC可以使用的场合，例如Java应用程序的数据库访问代码，DAO接口的实现类，甚至可以是BMP里面的访问数据库的代码。
2)
Hibernate是一个和JDBC密切关联的框架，所以Hibernate的兼容性和JDBC驱动，和数据库都有一定的关系，但是和使用它的Java程序，和AppServer 没有任何关系，也不存在兼容性问题。
3)
Hibernate不能用来直接和EntityBean 做对比，只有放在整个J2EE项目的框架中才能比较。并且即使是放在软件整体框架中来看，Hibernate也是做为JDBC的替代者出现的，而不是EntityBean 的替代者出现的，
4)
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
5)
Hibernate可以应用在任何使用JDBC的场合。
6)
Hibernate使用Java反射机制而不是字节码增强程序来实现透明性。
7)
Hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。
8)
它支持各种关系数据库，从一对一到多对多的各种复杂关系。
缺点：
1)
它限制所使用的对象模型。(例如，一个持久性类不能映射到多个表)。
2)
较JDBC，Hibernate更消耗内存。
3)
对于小型项目，Hibernate开发效率低。
2．jFinal Introction
jFinal的相关介绍，请参阅http://code.google.com/p/jfinal/
3．TheComparison
不可否认，SSH与jFinal都是非常优秀的架构，两者都有各自的优点，如何进行取舍取决于项目与项目组成员的实际情况！
注：*表示所在项具有相对优势
原文地址：http://blog.csdn.net/daijin888888/article/details/50800887
㈥ jfinal .findById 与.find谁的效率高
findById ：是按照主键查询，肯定只能查询一条或者0条记录，一般数据库默认主键为索引，使用索引速度肯定快的
find：按照你的sql语句的where条件查询，查询0-N条。
按照你的需求，如果要按照主键查询建议用findById，如果查询多条只能用find。
如果要查询1条记录，硬是要比较速度，还是findById比较快，看源码find要进行很多list的实例化。
必须是可以的啊， 配合 jsch.jar（ftp文件上传使用） 使用。
Controller 源码中已经提供两个获取 批量上传的文件 方法
publicList<UploadFile>getFiles(StringuploadPath,intmaxPostSize){
if(==false)
request=newMultipartRequest(request,uploadPath,maxPostSize);
return((MultipartRequest)request).getFiles();
}
publicList<UploadFile>getFiles(StringuploadPath){
if(==false)
request=newMultipartRequest(request,uploadPath);
return((MultipartRequest)request).getFiles();
}
获取 到 List<UploadFile> 文件集合之后， 再使用 jsch.jar 进行ftp文件上传到其他服务器
JSchjsch=newJSch();
SessionsshSession=jsch.getSession(this.username,this.host,this.port);
sshSession.setPassword(password);
PropertiessshConfig=newProperties();
sshConfig.put("StrictHostKeyChecking","no");
sshSession.setConfig(sshConfig);
sshSession.connect(20000);
Channelsftp=sshSession.openChannel("sftp");
sftp.connect();
。。。这个网络搜一下，代码很多，这里就不在啰嗦了
㈧ jfinal什么时候出web版的后台管理
可以加入Jfinal俱乐部，
引用官网的：
俱乐部当前发放的福利是本社区 jfinal.com 的源代码，并取名为
jfinal-club。jfinal-club 在核心功能上相当于一个迷你的 OSChina 社区，newsfeed
信息流模块整合了整站动态数据，交互性极好。重要功能：动态消息、@提到我、remind提醒、关注、好友、粉丝、私信、发贴、回贴、点赞、收藏、定时任务等功能。常见的功能也很全面：文件下载、图片上传、用户头像裁剪、登录、注册、邮件激活、找回密码、XSS过滤、缓存、后台管理、以及一些常用工具类等等。
jfinal-club 是官方出品的唯一 JFinal 最佳实践，绝无仅有的极简设计，获得 jfinal-club 也就获得了作者本人对
JFinal 的使用精髓。基于 jfinal 3.3 开发，获得 jfinal-club 将以令人难以想象的速度掌握新版本功能。
jfinal-club 是一个长期进化的，不断添加实用功能的项目，加入俱乐部以后，将随之长期享受该福利。
---------------
web版的后台管理社区做的比较好的有：
JfinalUIB ， EOVA ，JPress， ... 等很多都非常的好
http://www.jfinal.com/project 相关项目http://www.jfinal.com/club 俱乐部
㈨ 如何使用python爬虫jfinal
一、gzip/deflate支持
现在的网页普遍支持gzip压缩，这往往可以解决大量传输时间，以VeryCD的主页为例，未压缩版本247K，压缩了以后45K，为原来的1/5。这就意味着抓取速度会快5倍。
然而python的urllib/urllib2默认都不支持压缩，要返回压缩格式，必须在request的header里面写明’accept-
encoding’，然后读取response后更要检查header查看是否有’content-encoding’一项来判断是否需要解码，很繁琐琐
碎。如何让urllib2自动支持gzip, defalte呢？其实可以继承BaseHanlder类，然后build_opener的方式来处理：
import urllib2
from gzip import GzipFile
from StringIO import StringIO
class ContentEncodingProcessor(urllib2.BaseHandler):
"""A handler to add gzip capabilities to urllib2 requests """
# add headers to requests
def http_request(self, req):
req.add_header("Accept-Encoding", "gzip, deflate")
return req
# decode
def http_response(self, req, resp):
old_resp = resp
# gzip
if resp.headers.get("content-encoding") == "gzip":
gz = GzipFile(
fileobj=StringIO(resp.read()),
mode="r"
)
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code)
resp.msg = old_resp.msg
# deflate
if resp.headers.get("content-encoding") == "deflate":
gz = StringIO( deflate(resp.read()) )
resp = urllib2.addinfourl(gz, old_resp.headers, old_resp.url, old_resp.code) # 'class to add info() and
resp.msg = old_resp.msg
return resp
# deflate support
import zlib
def deflate(data): # zlib only provides the zlib compress format,not the deflate format;
try: # so on top of all there's this workaround:
return zlib.decompress(data, -zlib.MAX_WBITS)
except zlib.error:
return zlib.decompress(data)然后就简单了，
encoding_support = ContentEncodingProcessor
opener = urllib2.build_opener( encoding_support, urllib2.HTTPHandler )
#直接用opener打开网页，如果服务器支持gzip/defalte则自动解压缩
content = opener.open(url).read()二、更方便地多线程
总结一文的确提及了一个简单的多线程模板，但是那个东东真正应用到程序里面去只会让程序变得支离破碎，不堪入目。在怎么更方便地进行多线程方面我也动了一番脑筋。先想想怎么进行多线程调用最方便呢？
1、用twisted进行异步I/O抓取
事实上更高效的抓取并非一定要用多线程，也可以使用异步I/O法：直接用twisted的getPage方法，然后分别加上异步I/O结束时的callback和errback方法即可。例如可以这么干：
from twisted.web.client import getPage
from twisted.internet import reactor
links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]
def parse_page(data,url):
print len(data),url
def fetch_error(error,url):
print error.getErrorMessage(),url
# 批量抓取链接
for url in links:
getPage(url,timeout=5)
.addCallback(parse_page,url) #成功则调用parse_page方法
.addErrback(fetch_error,url) #失败则调用fetch_error方法
reactor.callLater(5, reactor.stop) #5秒钟后通知reactor结束程序
reactor.run()twisted人如其名，写的代码实在是太扭曲了，非正常人所能接受，虽然这个简单的例子看上去还好；每次写twisted的程序整个人都扭曲了，累得不得了，文档等于没有，必须得看源码才知道怎么整，唉不提了。
如果要支持gzip/deflate，甚至做一些登陆的扩展，就得为twisted写个新的HTTPClientFactory类诸如此类，我这眉头真是大皱，遂放弃。有毅力者请自行尝试。
这篇讲怎么用twisted来进行批量网址处理的文章不错，由浅入深，深入浅出，可以一看。
2、设计一个简单的多线程抓取类
还是觉得在urllib之类python“本土”的东东里面折腾起来更舒服。试想一下，如果有个Fetcher类，你可以这么调用
f = Fetcher(threads=10) #设定下载线程数为10
for url in urls:
f.push(url) #把所有url推入下载队列
while f.taskleft(): #若还有未完成下载的线程
content = f.pop() #从下载完成队列中取出结果
do_with(content) # 处理content内容这么个多线程调用简单明了，那么就这么设计吧，首先要有两个队列，用Queue搞定，多线程的基本架构也和“技巧总结”一文类似，push方法和
pop方法都比较好处理，都是直接用Queue的方法，taskleft则是如果有“正在运行的任务”或者”队列中的任务”则为是，也好办，于是代码如
下：import urllib2
from threading import Thread,Lock
from Queue import Queue
import time
class Fetcher:
def __init__(self,threads):
self.opener = urllib2.build_opener(urllib2.HTTPHandler)
self.lock = Lock() #线程锁
self.q_req = Queue() #任务队列
self.q_ans = Queue() #完成队列
self.threads = threads
for i in range(threads):
t = Thread(target=self.threadget)
t.setDaemon(True)
t.start()
self.running = 0
def __del__(self): #解构时需等待两个队列完成
time.sleep(0.5)
self.q_req.join()
self.q_ans.join()
def taskleft(self):
return self.q_req.qsize()+self.q_ans.qsize()+self.running
def push(self,req):
self.q_req.put(req)
def pop(self):
return self.q_ans.get()
def threadget(self):
while True:
req = self.q_req.get()
with self.lock: #要保证该操作的原子性，进入critical area
self.running += 1
try:
ans = self.opener.open(req).read()
except Exception, what:
ans = ''
print what
self.q_ans.put((req,ans))
with self.lock:
self.running -= 1
self.q_req.task_done()
time.sleep(0.1) # don't spam
if __name__ == "__main__":
links = [ 'http://www.verycd.com/topics/%d/'%i for i in range(5420,5430) ]
f = Fetcher(threads=10)
for url in links:
f.push(url)
while f.taskleft():
url,content = f.pop()
print url,len(content)
㈩ jfinal 如何导出zip压缩文件
官网介绍：JFinal 是基于 Java 语言的极速 WEB + ORM 框架，其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展、Restful。在拥有Java语言所有优势的同时再拥有ruby、python、php等动态语言的开发效率！为您节约更多时间，去陪恋人、家人和朋友 :)
Jfinal做为后台，进行下载文件服务时，源码中可看到：
Controller中已经提供了，方法：
/**
*Renderwithfile
*/
publicvoidrenderFile(StringfileName){
render=renderManager.getRenderFactory().getFileRender(fileName);
}
/**
*Renderwithfile,
*/
publicvoidrenderFile(StringfileName,StringdownloadFileName){
render=renderManager.getRenderFactory().getFileRender(fileName,downloadFileName);
}
/**
*Renderwithfile
*/
publicvoidrenderFile(Filefile){
render=renderManager.getRenderFactory().getFileRender(file);
}
/**
*Renderwithfile,
file=文件，downloadFileName=下载时客户端显示的文件名称，很贴心
*/
publicvoidrenderFile(Filefile,StringdownloadFileName){
render=renderManager.getRenderFactory().getFileRender(file,downloadFileName);
}
大家可以看到源码中 FileRender 是有处理各个浏览器的兼容问题，所以可以方便的使用
/**
*Copyright(c)2011-2017,JamesZhan詹波([email protected]).
*
*LicensendertheApacheLicense,Version2.0(the"License");
*.
*YoumayobtainaoftheLicenseat
*
*http://www.apache.org/licenses/LICENSE-2.0
*
*,software
*"ASIS"BASIS,
*,eitherexpressorimplied.
*
*limitationsundertheLicense.
*/
packagecom.jfinal.render;
importjava.io.BufferedInputStream;
importjava.io.File;
importjava.io.FileInputStream;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.OutputStream;
importjava.io.UnsupportedEncodingException;
importjava.net.URLEncoder;
importjavax.servlet.ServletContext;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importcom.jfinal.kit.LogKit;
importcom.jfinal.kit.StrKit;
/**
*FileRender.
*/
{
_CONTENT_TYPE="application/octet-stream";
;
;
protectedFilefile;
=null;
publicFileRender(Filefile){
if(file==null){
("filecannotbenull.");
}
this.file=file;
}
publicFileRender(Filefile,StringdownloadFileName){
this(file);
if(StrKit.isBlank(downloadFileName)){
("downloadFileNamecannotbeblank.");
}
this.downloadFileName=downloadFileName;
}
publicFileRender(StringfileName){
if(StrKit.isBlank(fileName)){
("fileNamecannotbeblank.");
}
StringfullFileName;
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=newFile(fullFileName);
}
publicFileRender(StringfileName,StringdownloadFileName){
this(fileName);
if(StrKit.isBlank(downloadFileName)){
("downloadFileNamecannotbeblank.");
}
this.downloadFileName=downloadFileName;
}
staticvoidinit(StringbaseDownloadPath,ServletContextservletContext){
FileRender.baseDownloadPath=baseDownloadPath;
FileRender.servletContext=servletContext;
}
publicvoidrender(){
if(file==null||!file.isFile()){
RenderManager.me().getRenderFactory().getErrorRender(404).setContext(request,response).render();
return;
}
//---------
response.setHeader("Accept-Ranges","bytes");
Stringfn=downloadFileName==null?file.getName():downloadFileName;
response.setHeader("Content-disposition","attachment;"+encodeFileName(request,fn));
StringcontentType=servletContext.getMimeType(file.getName());
response.setContentType(contentType!=null?contentType:DEFAULT_CONTENT_TYPE);
//---------
if(StrKit.isBlank(request.getHeader("Range"))){
normalRender();
}else{
rangeRender();
}
}
protectedStringencodeFileName(StringfileName){
try{
//returnnewString(fileName.getBytes("GBK"),"ISO8859-1");
returnnewString(fileName.getBytes(getEncoding()),"ISO8859-1");
}catch(UnsupportedEncodingExceptione){
returnfileName;
}
}
/**
*依据浏览器判断编码规则
*/
publicStringencodeFileName(HttpServletRequestrequest,StringfileName){
StringuserAgent=request.getHeader("User-Agent");
try{
StringencodedFileName=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=""+newString(fileName.getBytes("UTF-8"),"ISO8859-1")+""";
}
//FireFox浏览器，可以使用MimeUtility或filename*或ISO编码的中文输出
if(userAgent.indexOf("mozilla")!=-1){
return"filename*=UTF-8''"+encodedFileName;
}
return"filename=""+encodedFileName+""";
}catch(UnsupportedEncodingExceptione){
thrownewRuntimeException(e);
}
}
protectedvoidnormalRender(){
response.setHeader("Content-Length",String.valueOf(file.length()));
InputStreaminputStream=null;
OutputStreamoutputStream=null;
try{
inputStream=newBufferedInputStream(newFileInputStream(file));
outputStream=response.getOutputStream();
byte[]buffer=newbyte[1024];
for(intlen=-1;(len=inputStream.read(buffer))!=-1;){
outputStream.write(buffer,0,len);
}
outputStream.flush();
outputStream.close();
}catch(IOExceptione){
Stringn=e.getClass().getSimpleName();
if(n.equals("ClientAbortException")||n.equals("EofException")){
}else{
thrownewRenderException(e);
}
}catch(Exceptione){
thrownewRenderException(e);
}finally{
if(inputStream!=null)
try{inputStream.close();}catch(IOExceptione){LogKit.error(e.getMessage(),e);}
}
}
protectedvoidrangeRender(){
Long[]range={null,null};
processRange(range);
StringcontentLength=String.valueOf(range[1].longValue()-range[0].longValue()+1);
response.setHeader("Content-Length",contentLength);
response.setStatus(HttpServletResponse.SC_PARTIAL_CONTENT);//status=206
//Content-Range:bytes0-499/10000
StringBuildercontentRange=newStringBuilder("bytes").append(String.valueOf(range[0])).append("-").append(String.valueOf(range[1])).append("/").append(String.valueOf(file.length()));
response.setHeader("Content-Range",contentRange.toString());
InputStreaminputStream=null;
OutputStreamoutputStream=null;
try{
longstart=range[0];
longend=range[1];
inputStream=newBufferedInputStream(newFileInputStream(file));
if(inputStream.skip(start)!=start)
thrownewRuntimeException("Fileskiperror");
outputStream=response.getOutputStream();
byte[]buffer=newbyte[1024];
longposition=start;
for(intlen;position<=end&&(len=inputStream.read(buffer))!=-1;){
if(position+len<=end){
outputStream.write(buffer,0,len);
position+=len;
}
else{
for(inti=0;i<len&&position<=end;i++){
outputStream.write(buffer[i]);
position++;
}
}
}
outputStream.flush();
outputStream.close();
}
catch(IOExceptione){
Stringn=e.getClass().getSimpleName();
if(n.equals("ClientAbortException")||n.equals("EofException")){
}else{
thrownewRenderException(e);
}
}
catch(Exceptione){
thrownewRenderException(e);
}
finally{
if(inputStream!=null)
try{inputStream.close();}catch(IOExceptione){LogKit.error(e.getMessage(),e);}
}
}
/**
*Examplesofbyte-ranges-specifiervalues(assuminganentity-bodyoflength10000):
*Thefirst500bytes(byteoffsets0-499,inclusive):bytes=0-499
*Thesecond500bytes(byteoffsets500-999,inclusive):bytes=500-999
*Thefinal500bytes(byteoffsets9500-9999,inclusive):bytes=-500
*Orbytes=9500-
*/
protectedvoidprocessRange(Long[]range){
StringrangeStr=request.getHeader("Range");
intindex=rangeStr.indexOf(',');
if(index!=-1)
rangeStr=rangeStr.substring(0,index);
rangeStr=rangeStr.replace("bytes=","");
String[]arr=rangeStr.split("-",2);
if(arr.length<2)
thrownewRuntimeException("Rangeerror");
longfileLength=file.length();
for(inti=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;
}
}
//Rangeformatlike:9500-
if(range[0]!=null&&range[1]==null){
range[1]=fileLength-1;
}
//Rangeformatlike:-500
elseif(range[0]==null&&range[1]!=null){
range[0]=fileLength-range[1];
range[1]=fileLength-1;
}
//checkfinalrange
if(range[0]==null||range[1]==null||range[0].longValue()>range[1].longValue())
thrownewRuntimeException("Rangeerror");
}
}