1. package com.test;
  2. import java.io.DataInputStream;
  3. import java.io.DataOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  7. import java.io.IOException;
  8. import java.io.RandomAccessFile;
  9. import java.net.HttpURLConnection;
  10. import java.net.URL;
  11. /**
  12. * 文件断点续传加分段上传线程
  13. * @author wzztestin
  14. *
  15. */
  16. /**
  17. * 文件断点续传加分段上传线程
  18. * @author wzztestin
  19. *
  20. */
  21. public class DownFileFetch extends Thread {
  22. DownFileInfoBean siteInfoBean = null; // 文件信息 Bean
  23. long[] nStartPos; // 开始位置
  24. long[] nEndPos; // 结束位置
  25. DownFileSplitterFetch[] fileSplitterFetch; // 子线程对象
  26. long nFileLength; // 文件长度
  27. boolean bFirst = true; // 是否第一次取文件
  28. boolean bStop = false; // 停止标志
  29. File tmpFile; // 文件下载的临时信息
  30. DataOutputStream output; // 输出到文件的输出流
  31. boolean fileflag; //是本地上传还是远程下载的标志
  32. File downfile; //本地文件下载
  33. int splitter = 0;
  34. /**
  35. * 下载上传文件抓取初始化
  36. * @param bean
  37. * @throws IOException
  38. */
  39. public DownFileFetch(DownFileInfoBean bean) throws IOException {
  40. siteInfoBean = bean;
  41. /**
  42. * File.separator windows是\,unix是/
  43. */
  44. tmpFile = new File(bean.getSFilePath() + File.separator
  45. + bean.getSFileName() + ".info");
  46. if (tmpFile.exists()) {
  47. bFirst = false;
  48. //读取已下载的文件信息
  49. read_nPos();
  50. } else {
  51. nStartPos = new long[bean.getNSplitter()];
  52. nEndPos = new long[bean.getNSplitter()];
  53. }
  54. fileflag = bean.getFileflag();
  55. downfile = bean.getDownfile();
  56. this.splitter = bean.getNSplitter();
  57. }
  58. public void run() {
  59. // 获得文件长度
  60. // 分割文件
  61. // 实例 FileSplitterFetch
  62. // 启动 FileSplitterFetch 线程
  63. // 等待子线程返回
  64. try {
  65. if (bFirst) {
  66. nFileLength = getFileSize();
  67. if (nFileLength == -1) {
  68. DownFileUtility.log("File Length is not known!");
  69. } else if (nFileLength == -2) {
  70. DownFileUtility.log("File is not access!");
  71. } else {
  72. for (int i = 0; i < nStartPos.length; i++) {
  73. nStartPos[i] = (long) (i * (nFileLength / nStartPos.length));
  74. }
  75. for (int i = 0; i < nEndPos.length - 1; i++) {
  76. nEndPos[i] = nStartPos[i + 1];
  77. }
  78. nEndPos[nEndPos.length - 1] = nFileLength;
  79. }
  80. }
  81. // 启动子线程
  82. fileSplitterFetch = new DownFileSplitterFetch[nStartPos.length];
  83. for (int i = 0; i < nStartPos.length; i++) {
  84. fileSplitterFetch[i] = new DownFileSplitterFetch(
  85. siteInfoBean.getSSiteURL(), siteInfoBean.getSFilePath()
  86. + File.separator + siteInfoBean.getSFileName()+"_"+i,
  87. nStartPos[i], nEndPos[i], i,fileflag,downfile,bFirst);
  88. DownFileUtility.log("Thread " + i + " , nStartPos = " + nStartPos[i]
  89. + ", nEndPos = " + nEndPos[i]);
  90. fileSplitterFetch[i].start();
  91. }
  92. //下载子线程是否完成标志
  93. boolean breakWhile = false;
  94. while (!bStop) {
  95. write_nPos();
  96. DownFileUtility.sleep(500);
  97. breakWhile = true;
  98. for (int i = 0; i < nStartPos.length; i++) {
  99. if (!fileSplitterFetch[i].bDownOver) {
  100. breakWhile = false;
  101. break;
  102. }else{
  103. write_nPos();
  104. }
  105. }
  106. if (breakWhile){
  107. break;
  108. }
  109. }
  110. hebinfile(siteInfoBean.getSFilePath()+ File.separator + siteInfoBean.getSFileName(),splitter);
  111. DownFileUtility.log("文件下载结束！");
  112. } catch (Exception e) {
  113. e.printStackTrace();
  114. }
  115. }
  116. /**
  117. * 获得文件长度
  118. * @return
  119. */
  120. public long getFileSize() {
  121. int nFileLength = -1;
  122. if(fileflag){
  123. try {
  124. URL url = new URL(siteInfoBean.getSSiteURL());
  125. HttpURLConnection httpConnection = (HttpURLConnection) url
  126. .openConnection();
  127. httpConnection.setRequestProperty("User-Agent", "NetFox");
  128. int responseCode = httpConnection.getResponseCode();
  129. if (responseCode >= 400) {
  130. processErrorCode(responseCode);
  131. //represent access is error
  132. return -2;
  133. }
  134. String sHeader;
  135. for (int i = 1;; i++) {
  136. sHeader = httpConnection.getHeaderFieldKey(i);
  137. if (sHeader != null) {
  138. if (sHeader.equals("Content-Length")) {
  139. nFileLength = Integer.parseInt(httpConnection
  140. .getHeaderField(sHeader));
  141. break;
  142. }
  143. } else {
  144. break;
  145. }
  146. }
  147. } catch (IOException e) {
  148. e.printStackTrace();
  149. } catch (Exception e) {
  150. e.printStackTrace();
  151. }
  152. DownFileUtility.log(nFileLength);
  153. }else{
  154. try{
  155. File myflie = downfile;
  156. nFileLength = (int)myflie.length();
  157. }catch(Exception e){
  158. e.printStackTrace();
  159. }
  160. DownFileUtility.log(nFileLength);
  161. }
  162. return nFileLength;
  163. }
  164. /**
  165. * 保存下载信息（文件指针位置）
  166. */
  167. private void write_nPos() {
  168. try {
  169. output = new DataOutputStream(new FileOutputStream(tmpFile));
  170. output.writeInt(nStartPos.length);
  171. for (int i = 0; i < nStartPos.length; i++) {
  172. output.writeLong(fileSplitterFetch[i].nStartPos);
  173. output.writeLong(fileSplitterFetch[i].nEndPos);
  174. }
  175. output.close();
  176. } catch (IOException e) {
  177. e.printStackTrace();
  178. } catch (Exception e) {
  179. e.printStackTrace();
  180. }
  181. }
  182. /**
  183. * 读取保存的下载信息（文件指针位置）
  184. */
  185. private void read_nPos() {
  186. try {
  187. DataInputStream input = new DataInputStream(new FileInputStream(
  188. tmpFile));
  189. int nCount = input.readInt();
  190. nStartPos = new long[nCount];
  191. nEndPos = new long[nCount];
  192. for (int i = 0; i < nStartPos.length; i++) {
  193. nStartPos[i] = input.readLong();
  194. nEndPos[i] = input.readLong();
  195. }
  196. input.close();
  197. } catch (IOException e) {
  198. e.printStackTrace();
  199. } catch (Exception e) {
  200. e.printStackTrace();
  201. }
  202. }
  203. /**
  204. * 输出错误信息
  205. * @param nErrorCode
  206. */
  207. private void processErrorCode(int nErrorCode) {
  208. DownFileUtility.log("Error Code : " + nErrorCode);
  209. }
  210. /**
  211. * 停止文件下载
  212. */
  213. public void siteStop() {
  214. bStop = true;
  215. for (int i = 0; i < nStartPos.length; i++)
  216. fileSplitterFetch[i].splitterStop();
  217. }
  218. /**
  219. * 合并文件
  220. * @param sName
  221. * @param splitternum
  222. */
  223. private void hebinfile(String sName,int splitternum){
  224. try{
  225. File file = new File(sName);
  226. if(file.exists()){
  227. file.delete();
  228. }
  229. RandomAccessFile saveinput = new RandomAccessFile(sName,"rw");
  230. for(int i = 0;i<splitternum;i++){
  231. try {
  232. RandomAccessFile input = new RandomAccessFile (new File(sName+"_"+i),"r");
  233. byte[] b = new byte[1024];
  234. int nRead;
  235. while ((nRead = input.read(b, 0, 1024)) > 0) {
  236. write(saveinput,b, 0, nRead);
  237. }
  238. input.close();
  239. } catch (Exception e) {
  240. e.printStackTrace();
  241. }
  242. }
  243. DownFileUtility.log("file size is "+saveinput.length());
  244. }catch(Exception e){
  245. e.printStackTrace();
  246. }
  247. }
  248. /**
  249. * 写文件
  250. * @param b
  251. * @param nStart
  252. * @param nLen
  253. * @return
  254. */
  255. private int write(RandomAccessFile oSavedFile,byte[] b, int nStart, int nLen) {
  256. int n = -1;
  257. try {
  258. oSavedFile.seek(oSavedFile.length());
  259. oSavedFile.write(b, nStart, nLen);
  260. n = nLen;
  261. } catch (IOException e) {
  262. e.printStackTrace();
  263. }
  264. return n;
  265. }
  266. }
  1. package com.test;
  2. import java.io.File;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.RandomAccessFile;
  6. import java.net.HttpURLConnection;
  7. import java.net.URL;
  8. /**
  9. * 下载上传子线程
  10. * @author wzztestin
  11. *
  12. */
  13. public class DownFileSplitterFetch extends Thread {
  14. String sURL; // 下载文件的地址
  15. long nStartPos; // 文件分段的开始位置
  16. long nEndPos; // 文件分段的结束位置
  17. int nThreadID; // 线程的 ID
  18. boolean bDownOver = false; // 是否下载完成
  19. boolean bStop = false; // 停止下载
  20. DownFileAccess fileAccessI = null; // 文件对象
  21. boolean fileflag; //是URL下载还是本地下载
  22. File file = null;//本地下载文件
  23. boolean bFirst = true;
  24. /**
  25. * 下载，上传子线程初始化
  26. * @param sURL
  27. * @param sName
  28. * @param nStart
  29. * @param nEnd
  30. * @param id
  31. * @param fileflag
  32. * @param downfile
  33. * @throws IOException
  34. */
  35. public DownFileSplitterFetch(String sURL, String sName, long nStart, long nEnd,
  36. int id,boolean fileflag,File downfile,boolean bFirst) throws IOException {
  37. this.sURL = sURL;
  38. this.nStartPos = nStart;
  39. this.nEndPos = nEnd;
  40. nThreadID = id;
  41. fileAccessI = new DownFileAccess(sName, nStartPos,bFirst);
  42. this.fileflag = fileflag;
  43. this.file = downfile;
  44. this.bFirst = bFirst;
  45. }
  46. /**
  47. * 线程执行
  48. */
  49. public void run() {
  50. if(fileflag){
  51. this.urldownload();
  52. }else{
  53. this.filedownload();
  54. }
  55. }
  56. /**
  57. * 打印回应的头信息
  58. * @param con
  59. */
  60. public void logResponseHead(HttpURLConnection con) {
  61. for (int i = 1;; i++) {
  62. String header = con.getHeaderFieldKey(i);
  63. if (header != null){
  64. DownFileUtility.log(header + " : " + con.getHeaderField(header));
  65. }else{
  66. break;
  67. }
  68. }
  69. }
  70. /**
  71. * 地址下载
  72. */
  73. private void urldownload(){
  74. DownFileUtility.log("Thread " + nThreadID + " url down filesize is "+(nEndPos-nStartPos));
  75. DownFileUtility.log("Thread " + nThreadID + " url start >> "+nStartPos +"------end >> "+nEndPos);
  76. while (nStartPos < nEndPos && !bStop) {
  77. try {
  78. URL url = new URL(sURL);
  79. HttpURLConnection httpConnection = (HttpURLConnection) url
  80. .openConnection();
  81. httpConnection.setRequestProperty("User-Agent", "NetFox");
  82. String sProperty = "bytes=" + nStartPos + "-";
  83. httpConnection.setRequestProperty("RANGE", sProperty);
  84. DownFileUtility.log(sProperty);
  85. InputStream input = httpConnection.getInputStream();
  86. byte[] b = new byte[1024];
  87. int nRead;
  88. while ((nRead = input.read(b, 0, 1024)) > 0
  89. && nStartPos < nEndPos && !bStop) {
  90. if((nStartPos+nRead)>nEndPos)
  91. {
  92. nRead = (int)(nEndPos - nStartPos);
  93. }
  94. nStartPos += fileAccessI.write(b, 0, nRead);
  95. }
  96. DownFileUtility.log("Thread " + nThreadID + " nStartPos : "+nStartPos);
  97. fileAccessI.oSavedFile.close();
  98. DownFileUtility.log("Thread " + nThreadID + " is over!");
  99. input.close();
  100. bDownOver = true;
  101. } catch (Exception e) {
  102. e.printStackTrace();
  103. }
  104. }
  105. if(!bDownOver){
  106. if(nStartPos >= nEndPos){
  107. bDownOver = true;
  108. }
  109. }
  110. }
  111. /**
  112. * 文件下载
  113. */
  114. private void filedownload(){
  115. DownFileUtility.log("Thread " + nThreadID + " down filesize is "+(nEndPos-nStartPos));
  116. DownFileUtility.log("Thread " + nThreadID + " start >> "+nStartPos +"------end >> "+nEndPos);
  117. while (nStartPos < nEndPos && !bStop) {
  118. try {
  119. RandomAccessFile input = new RandomAccessFile(file,"r");
  120. input.seek(nStartPos);
  121. byte[] b = new byte[1024];
  122. int nRead;
  123. while ((nRead = input.read(b, 0, 1024)) > 0
  124. && nStartPos < nEndPos && !bStop) {
  125. if((nStartPos+nRead)>nEndPos)
  126. {
  127. nRead = (int)(nEndPos - nStartPos);
  128. }
  129. nStartPos += fileAccessI.write(b, 0, nRead);
  130. }
  131. fileAccessI.oSavedFile.close();
  132. DownFileUtility.log("Thread " + nThreadID + " is over!");
  133. input.close();
  134. bDownOver = true;
  135. input.close();
  136. } catch (Exception e) {
  137. e.printStackTrace();
  138. }
  139. }
  140. if(!bDownOver){
  141. if(nStartPos >= nEndPos){
  142. bDownOver = true;
  143. }
  144. }
  145. DownFileUtility.log("Thread " + nThreadID + "last start >> "+nStartPos );
  146. }
  147. /**
  148. * 停止
  149. */
  150. public void splitterStop() {
  151. bStop = true;
  152. }
  153. }
  1. package com.test;
  2. import java.io.*;
  3. /**
  4. * 文件对象
  5. * @author wzztestin
  6. *
  7. */
  8. public class DownFileAccess implements Serializable {
  9. /**
  10. *
  11. */
  12. private static final long serialVersionUID = -2518013155676212866L;
  13. //写入文件的流
  14. RandomAccessFile oSavedFile;
  15. //开始位置
  16. long nPos;
  17. boolean bFirst;
  18. public DownFileAccess() throws IOException {
  19. this("", 0,true);
  20. }
  21. /**
  22. * 写入文件初始化
  23. * @param sName
  24. * @param nPos
  25. * @throws IOException
  26. */
  27. public DownFileAccess(String sName, long nPos,boolean bFirst) throws IOException {
  28. File wfile = new File(sName);
  29. oSavedFile = new RandomAccessFile(wfile,"rw");
  30. if(!bFirst){
  31. oSavedFile.seek(wfile.length());
  32. }
  33. this.nPos = nPos;
  34. this.bFirst = bFirst;
  35. }
  36. /**
  37. * 写文件
  38. * @param b
  39. * @param nStart
  40. * @param nLen
  41. * @return
  42. */
  43. public synchronized int write(byte[] b, int nStart, int nLen) {
  44. int n = -1;
  45. try {
  46. oSavedFile.write(b, nStart, nLen);
  47. n = nLen;
  48. } catch (IOException e) {
  49. e.printStackTrace();
  50. }
  51. return n;
  52. }
  53. }
  1. package com.test;
  2. import java.io.File;
  3. public class DownFileInfoBean {
  4. private String sSiteURL; // 文件的下载地址
  5. private String sFilePath; // 保存文件的路径
  6. private String sFileName; // 保存文件的名字
  7. private int nSplitter; // 文件分成几段，默认是5段
  8. private boolean fileflag; // 如果为FALSE则是本地下载,为TRUE则URL下载
  9. private File downfile;
  10. public File getDownfile() {
  11. return downfile;
  12. }
  13. public void setDownfile(File downfile) {
  14. this.downfile = downfile;
  15. }
  16. public boolean getFileflag() {
  17. return fileflag;
  18. }
  19. public void setFileflag(boolean fileflag) {
  20. this.fileflag = fileflag;
  21. }
  22. /**
  23. * 默认初始化
  24. */
  25. public DownFileInfoBean() {
  26. // default 5
  27. this("", "", "", 5,false,null);
  28. }
  29. /**
  30. * 下载文件信息初始化
  31. * @param sURL 下载的链接地址
  32. * @param sPath 上传的保存路径
  33. * @param sName 上传保存的文件名
  34. * @param nSpiltter 文件分段个数
  35. * @param fileflag 是本地文件上传下载还是链接上传下载的标志
  36. * @param downfile 本地下载文件(FILE)
  37. */
  38. public DownFileInfoBean(String sURL, String sPath, String sName, int nSpiltter,boolean fileflag,File downfile) {
  39. sSiteURL = sURL;
  40. sFilePath = sPath;
  41. sFileName = sName;
  42. this.nSplitter = nSpiltter;
  43. this.fileflag = fileflag;
  44. this.downfile = downfile;
  45. }
  46. public String getSSiteURL() {
  47. return sSiteURL;
  48. }
  49. public void setSSiteURL(String value) {
  50. sSiteURL = value;
  51. }
  52. public String getSFilePath() {
  53. return sFilePath;
  54. }
  55. public void setSFilePath(String value) {
  56. sFilePath = value;
  57. }
  58. public String getSFileName() {
  59. return sFileName;
  60. }
  61. public void setSFileName(String value) {
  62. sFileName = value;
  63. }
  64. public int getNSplitter() {
  65. return nSplitter;
  66. }
  67. public void setNSplitter(int nCount) {
  68. nSplitter = nCount;
  69. }
  70. }
  1. package com.test;
  2. /**
  3. * 简单的工具类
  4. * @author wzztestin
  5. *
  6. */
  7. public class DownFileUtility {
  8. public DownFileUtility() {
  9. }
  10. /**
  11. * 休眠时长
  12. * @param nSecond
  13. */
  14. public static void sleep(int nSecond) {
  15. try {
  16. Thread.sleep(nSecond);
  17. } catch (Exception e) {
  18. e.printStackTrace();
  19. }
  20. }
  21. /**
  22. * 打印日志信息
  23. * @param sMsg
  24. */
  25. public static void log(String sMsg) {
  26. System.err.println(sMsg);
  27. }
  28. /**
  29. * 打印日志信息
  30. * @param sMsg
  31. */
  32. public static void log(int sMsg) {
  33. System.err.println(sMsg);
  34. }
  35. }
  1. package com.test;
  2. public class TestMethod {
  3. public TestMethod() {
  4. try {
  5. DownFileInfoBean bean = new DownFileInfoBean(
  6. "http://cdn.market.hiapk.com/data/upload//2012/09_27/17/car.wu.wei.kyo.shandian_174928.apk", "D:\\temp",
  7. "shandian_174928.apk", 5,true,null);
  8. /*File file = new File("D:\\dan07.apk");
  9. DownFileInfoBean bean = new DownFileInfoBean(null, "D:\\temp",
  10. "dan07.apk", 3,false,file);*/
  11. DownFileFetch fileFetch = new DownFileFetch(bean);
  12. fileFetch.start();
  13. } catch (Exception e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. public static void main(String[] args) {
  18. new TestMethod();
  19. }
  20. }

java多线程分块上传并支持断点续传最新修正完整版本[转]的更多相关文章

  1. java大附件上传，支持断点续传

    一. 功能性需求与非功能性需求 要求操作便利,一次选择多个文件和文件夹进行上传:支持PC端全平台操作系统,Windows,Linux,Mac 支持文件和文件夹的批量下载,断点续传.刷新页面后继续传输. ...

  2. web大附件上传，支持断点续传

    一. 功能性需求与非功能性需求 要求操作便利,一次选择多个文件和文件夹进行上传:支持PC端全平台操作系统,Windows,Linux,Mac 支持文件和文件夹的批量下载,断点续传.刷新页面后继续传输. ...

  3. jsp大附件上传，支持断点续传

    我们平时经常做的是上传文件,上传文件夹与上传文件类似,但也有一些不同之处,这次做了上传文件夹就记录下以备后用. 这次项目的需求: 支持大文件的上传和续传,要求续传支持所有浏览器,包括ie6,ie7,i ...

  4. B/S大附件上传，支持断点续传

    核心原理: 该项目核心就是文件分块上传.前后端要高度配合,需要双方约定好一些数据,才能完成大文件分块,我们在项目中要重点解决的以下问题. * 如何分片: * 如何合成一个文件: * 中断了从哪个分片开 ...

  5. PHP 大文件上传，支持断点续传，求具体方案、源码或者文件上传插件

    文件夹数据库处理逻辑 publicclass DbFolder { JSONObject root; public DbFolder() { this.root = new JSONObject(); ...

  6. 【FTP】FTP文件上传下载-支持断点续传

    Jar包:apache的commons-net包: 支持断点续传 支持进度监控(有时出不来,搞不清原因) 相关知识点 编码格式: UTF-8等; 文件类型: 包括[BINARY_FILE_TYPE(常 ...

  7. php大附件上传，支持断点续传

    前段时间做视频上传业务,通过网页上传视频到服务器. 视频大小 小则几十M,大则 1G+,以一般的HTTP请求发送数据的方式的话,会遇到的问题:1,文件过大,超出服务端的请求大小限制:2,请求时间过长, ...

  8. asp.net大附件上传，支持断点续传

    以ASP.NET Core WebAPI 作后端 API ,用 Vue 构建前端页面,用 Axios 从前端访问后端 API ,包括文件的上传和下载. 准备文件上传的API #region 文件上传  ...

  9. FTP文件上传并支持断点续传（一）—— win10 本地环境 ftp站点构建

    由于之前项目开发是采用是采用的FTP文件上传,就一直想学习,但由于FTP服务器是公司的,为了方便就像把本地变成ftp站点,其实很简单,但也有很多坑 这里简单介绍一下自己遇到的坑 一:开通本地的ftp权 ...

随机推荐

  1. ARM汇编编程基础之一 —— 寄存器

    ARM的汇编编程,本质上就是针对CPU寄存器的编程,所以我们首先要弄清楚ARM有哪些寄存器?这些寄存器都是如何使用的? ARM寄存器分为2类,普通寄存器和状态寄存器 寄存器类别 寄存器在汇编中的名称 ...

  2. NodeJS下的Mongodb操作

    今天用Node写一个小程序中需要用到数据库操作,试用了一下,发现官方的驱动已经非常好用了,也支持async. 一个简单的实例如下: const MongoClient = require('mongo ...

  3. C - 项目收藏

    Web框架 [荐]Kore:开源 C 语言 Web 框架 Raphters:A web framework for C ulfius:Web Framework for REST API in C, ...

  4. Weekly linux and ConferenceByYear(2002-now)

    https://lwn.net/Archives/ https://lwn.net/Archives/ConferenceByYear/

  5. Revit API过滤元素类别(FamilySymbol与FamilyInstance)

    仅OfCategory()过滤的元素包含系统FamilySymbolOfClass(typeof(FamilyInstance))过滤出来文档中族实例. ;         ;         ;   ...

  6. error: internal error: unable to execute QEMU command &#39;migrate&#39;: this feature or command is not cur

    感谢朋友支持本博客,欢迎共同探讨交流,因为能力和时间有限.错误之处在所难免,欢迎指正. 假设转载.请保留作者信息. 博客地址:http://blog.csdn.net/qq_21398167 原博文地 ...

  7. ASP.NET Web API实践系列11,如何设计出优秀的API

    本篇摘自:InfoQ的微信公众号 在设计API的时候考虑的问题包括:API所使用的传输协议.支持的消息格式.接口的控制.名称.关联.次序,等等.我们很难始终作出正确的决策,很可能是在多次犯错之后,并从 ...

  8. C#编程（四十二）----------委托和事件

    委托和事件 委托是C#总比较重要的概念,学习C#爱这里最容易产生迷惑. 有些时候,犹豫我们在开发程序时对后续可能出现的要求及变化考虑不足而导致麻烦,这些新变化可能导致程序的重新编写,那能不能改变这种情 ...

  9. WordPress主题开发：WP_Query基本用法

    为什么要学WP_Query? wordpress默认会根据网址调用数据,不能满足我们所有建站要求,而WP_Query可以用于查询任何你想要的内容,相当于自定义数据调用. 便于记忆,在讲用法之前我们回顾 ...

  10. log4j1修改DailyRollingFileAppender支持日志最大数量

    配置说明: log4j.appender.logfile=org.apache.log4j.MyDailyRollingFileAppender log4j.appender.logfile.File ...