java jodd框架介绍及使用示例

2022-11-04 21:46:12

Jodd是一个普通开源Java包。你可以把Jodd想象成Java的"瑞士军刀",不仅小，锋利而且包含许多便利的功能。Jodd 提供的功能有：
 提供操作Java bean，
 可以从各种数据源加载Bean,
 简化JDBC的接连与代码，
 剖析SQL查询，
 处理时间与日期，
 操作与格式化String,
 搜索本地硬盘上的文件，
 帮助处理Servlet请求等。
除此之外还包含一个很小，但实用的基于JSP的MVC框架。

jodd使用示例：

JODD中的时间操作类

jodd时间操作

 import jodd.datetime.JDateTime;

 public static void main(String[] args) {

         JDateTime jDateTime=new JDateTime();

         Date date1=jDateTime.convertToDate();//当前时间

         System.out.println("CostCountForDayDaemon.main()"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SS").format(date1));

         jDateTime.setTime(0, 0, 0, 0);//将当前时间的时分秒毫秒置成零点零分零秒零毫秒

         Date jDate=jDateTime.convertToDate();//将该时间转化成修改后的时间

         System.out.println("CostCountForDayDaemon.main()"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SS").format(jDate));

         jDateTime.subDay(1);//将当前时间往前减一天

         Date date=jDateTime.convertToDate();

         System.out.println("CostCountForDayDaemon.main()"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SS").format(date));

     }

 CostCountForDayDaemon.main()2015-03-17 14:54:41 887

 CostCountForDayDaemon.main()2015-03-17 00:00:00 00

 CostCountForDayDaemon.main()2015-03-16 00:00:00 00
  1. import java.util.TimeZone;
  2. import org.apache.log4j.Logger;
  3. import org.junit.Test;
  4. import jodd.datetime.JDateTime;
  5. /**
  6. * JODD中的时间操作类
  7. * @author DJZHOU
  8. *
  9. */
  10. public class JDateTimeUtil {
  11. private Logger log = Logger.getLogger(JDateTimeUtil.class) ;
  12. @Test
  13. public void testConstructor()
  14. {
  15. /*
  16. * 构造函数的使用
  17. */
  18. JDateTime jdt = new JDateTime();        // set current date and time
  19. jdt = new JDateTime(2012, 12, 21);      // set 21st December 2012, midnight
  20. jdt = new JDateTime(System.currentTimeMillis());
  21. jdt = new JDateTime(2012, 12, 21, 11, 54, 22, 124);  // set 21st December 2012, 11:54:22.124
  22. jdt = new JDateTime("2012-12-21 11:54:22.124");     // -//-
  23. jdt = new JDateTime("12/21/2012", "MM/DD/YYYY");    // set 21st December 2012, midnight
  24. }
  25. @Test
  26. public void testSet()
  27. {
  28. JDateTime jdt = new JDateTime();        // set current date and time
  29. /*
  30. * set方法的使用:设定日期时间
  31. */
  32. jdt.set(2012, 12, 21, 11, 54, 22, 124);     // set 21st December 2012, 11:54:22.124
  33. jdt.set(2012, 12, 21);                      // set 21st December 2012, midnight
  34. jdt.setDate(2012, 12, 21);                  // change date to 21st December 2012, do not change te time
  35. jdt.setCurrentTime();                       // set current date and time
  36. jdt.setYear(1973);                          // change the year
  37. jdt.setHour(22);                            // change the hour
  38. jdt.setTime(18, 00, 12, 853);
  39. }
  40. @Test
  41. public void testGet()
  42. {
  43. JDateTime jdt = new JDateTime();        // set current date and time
  44. /*
  45. * get方法的使用:读取日期和时间
  46. */
  47. jdt.getYear();
  48. jdt.getDateTimeStamp();
  49. log.warn(jdt.getDateTimeStamp());//获取当前时间
  50. log.warn(jdt.getJulianDate());
  51. log.warn(jdt.getDay()) ;
  52. log.warn(jdt.getDayOfMonth()) ;
  53. log.warn(jdt.getDayOfWeek()) ;
  54. log.warn(jdt.getDayOfYear()) ;
  55. log.warn(jdt.getEra()) ;
  56. log.warn(jdt.getFirstDayOfWeek()) ;
  57. log.warn(jdt.getFormat()) ;
  58. }
  59. @Test
  60. public void testAdd()
  61. {
  62. JDateTime jdt = new JDateTime();        // set current date and time
  63. jdt.add(1, 2, 3, 4, 5, 6, 7);    // add 1 year, 2 months, 3 days, 4 hours...
  64. jdt.add(4, 2, 0);           // add 4 years and 2 months
  65. jdt.addMonth(-120);         // go back 120 months
  66. jdt.subYear(1);             // go back one year
  67. jdt.addHour(1234);          // add 1234 hours
  68. }
  69. @Test
  70. public void testAdd2()
  71. {
  72. JDateTime jdt = new JDateTime() ;
  73. log.warn(jdt.toString("YYYY-MM-DD")) ;
  74. jdt.addDay(-20) ;
  75. log.warn(jdt.toString("YYYY-MM-DD")) ;
  76. jdt.addDay(10, true) ;
  77. log.warn(jdt.toString("YYYY-MM-DD")) ;
  78. jdt.addYear(1);
  79. log.warn(jdt.toString("YYYY-MM-DD")) ;
  80. }
  81. @Test
  82. public void testFormat()
  83. {
  84. JDateTime jdt = new JDateTime();        // set current date and time
  85. /**
  86. * 转换说明
  87. YYYY    年
  88. MM      月
  89. DD      日
  90. D       一周中的第几天 从周一算起
  91. MML     月,长型
  92. MMS     月,短行
  93. DL      一周中的第几天 长型 从周一算起
  94. DS      一周中的第几天 短型 从周一算起
  95. hh      小时
  96. mm      分钟
  97. ss      秒
  98. mss     毫秒
  99. DDD     一年中的第几天
  100. WW      一年中的第几周
  101. WWW     一年中的第几周并用W标识
  102. W       一个月中的第几周
  103. E       年代,公元前还是公元后
  104. TZL     时间长型
  105. TZS     时间短型
  106. *
  107. */
  108. log.warn(jdt.convertToDate()) ;
  109. log.warn(jdt.toString("YYYY-MM-DD"));
  110. log.warn(jdt.toString("YYYY-MM-DD hh:mm:ss"));//转换成字符串
  111. log.warn(jdt.toString("WW"));//本年度第几周
  112. log.warn(jdt.toString("YYYY")) ;
  113. }
  114. }

JODD操作properties文件

  1. import java.io.File;
  2. import java.io.IOException;
  3. import org.apache.log4j.Logger;
  4. import org.junit.Test;
  5. import jodd.props.Props;
  6. /**
  7. * JODD操作properties文件
  8. * @author DJZHOU
  9. *
  10. */
  11. public class PropUtil {
  12. private static Logger log = Logger.getLogger(PropUtil.class) ;
  13. @Test
  14. public void propExam(){
  15. /*
  16. *  读取prop文件中的属性值
  17. */
  18. Props p = new Props();
  19. log.warn(URLUtil.getClassPath(this.getClass())+"/a.properties") ;
  20. try {
  21. p.load(new File(URLUtil.getClassPath(this.getClass())+"/a.properties"));
  22. } catch (IOException e) {
  23. e.printStackTrace();
  24. }
  25. String story = p.getValue("a");
  26. log.warn(p.getBaseValue("a")) ;
  27. log.warn(story);
  28. log.warn(null == p.getValue("a")) ;
  29. log.warn(p.toString()) ;
  30. p.setValue("c", "cc") ;
  31. }
  32. }

JODD操作email类

  1. import java.io.File;
  2. import java.io.IOException;
  3. import org.junit.Test;
  4. import jodd.io.FileUtil;
  5. import jodd.mail.Email;
  6. import jodd.mail.EmailAttachment;
  7. import jodd.mail.EmailMessage;
  8. import jodd.mail.SendMailSession;
  9. import jodd.mail.SmtpSslServer;
  10. import jodd.mail.att.ByteArrayAttachment;
  11. import jodd.mail.att.FileAttachment;
  12. import jodd.util.MimeTypes;
  13. /**
  14. * JODD操作email类
  15. *
  16. * @author DJZHOU
  17. *
  18. */
  19. public class EmailUtil
  20. {
  21. public static void main(String[] args)
  22. {
  23. Email email = Email.create();
  24. email.addMessage(new EmailMessage("消息"));
  25. email.addText("邮件内容");
  26. email.embedFile(new File("d:/console.txt"));
  27. email.from("771842634@qq.com").to("771842634@qq.com");
  28. email.subject("主题");
  29. SendMailSession mailSession = new SmtpSslServer("smtp.qq.com//发送端邮箱服务器协议", "发送端QQ邮箱", "发送端QQ邮箱密码").createSession();
  30. mailSession.open();
  31. mailSession.sendMail(email);
  32. mailSession.close();
  33. System.out.println("发送成功!...");
  34. }
  35. @Test
  36. public void test() throws IOException
  37. {
  38. Email email = new Email();
  39. email.setFrom("infoxxx@jodd.org");
  40. email.setTo("igorxxxx@gmail.com");
  41. email.setSubject("test7");
  42. EmailMessage textMessage = new EmailMessage("Hello!", MimeTypes.MIME_TEXT_PLAIN);
  43. email.addMessage(textMessage);
  44. EmailMessage htmlMessage = new EmailMessage(
  45. "<html><META http-equiv=Content-Type content=\"text/html; charset=utf-8\">" +
  46. "<body><h1>Hey!</h1><img src='cid:c.png'><h2>Hay!</h2></body></html>",
  47. MimeTypes.MIME_TEXT_HTML);
  48. email.addMessage(htmlMessage);
  49. EmailAttachment embeddedAttachment =
  50. new ByteArrayAttachment(FileUtil.readBytes("d:\\c.png"), "image/png", "c.png", "c.png");
  51. email.attach(embeddedAttachment);
  52. EmailAttachment attachment = new FileAttachment(new File("d:\\b.jpg"), "b.jpg", "image/jpeg");
  53. email.attach(attachment);
  54. }
  55. }

String字符串的操作工具类

    1. import org.junit.Test;
    2. import jodd.util.StringUtil;
    3. /**
    4. * String字符串的操作工具类,太强大以至于我要发疯
    5. *
    6. * @author DJZHOU
    7. *
    8. */
    9. public class StringExamUtil
    10. {
    11. @Test
    12. public void stringExam()
    13. {
    14. String exam = "abcdefg10101010abcdefg";
    15. String result = "";
    16. /*
    17. * replace 字符替换
    18. */
    19. // 将字符串exam中的a替换成b
    20. result = StringUtil.replace(exam, "a", "b");
    21. // 将字符串exam中的a替换成8,b替换成9
    22. result = StringUtil.replace(exam, new String[] { "a", "b" }, new String[] { "8", "9" });
    23. // 将字符串exam中的a替换成b 这里是替换字符
    24. result = StringUtil.replaceChar(exam, 'a', 'b');
    25. // 将字符串exam中的a替换成8,b替换成9 这里是替换字符
    26. result = StringUtil.replaceChars(exam, new char[] { 'a', 'b' }, new char[] { '8', '9' });
    27. // 将字符串exam中的第一个a替换成b
    28. result = StringUtil.replaceFirst(exam, "a", "b");
    29. // 将字符串exam中的第一个a替换成b 这里是替换字符
    30. result = StringUtil.replaceFirst(exam, 'a', 'b');
    31. // 将字符串exam中的最后一个a替换成b
    32. result = StringUtil.replaceLast(exam, "a", "b");
    33. // 将字符串exam中的最后一个a替换成b 这里是替换字符
    34. result = StringUtil.replaceLast(exam, 'a', 'b');
    35. // 将字符串exam中的a和A替换成FF b和B替换成gg 即忽略大小写
    36. result = StringUtil.replaceIgnoreCase(exam, new String[] { "a", "b" }, new String[] { "FF", "gg" });
    37. /*
    38. * remove 字符移除
    39. */
    40. // 将字符串exam中的a移除
    41. result = StringUtil.remove(exam, "a");
    42. // 将字符串exam中的a移除 移除的是字符
    43. result = StringUtil.remove(exam, 'a');
    44. // 将字符串exam中的a b移除 移除的是字符 最后一个参数为无限参数
    45. result = StringUtil.removeChars(exam, 'a', 'b');
    46. // 将字符串exam中的a移除
    47. result = StringUtil.removeChars(exam, "a");
    48. /*
    49. * 判断字符串是否为空
    50. */
    51. // 判断字符串exam是否为空
    52. System.out.println(StringUtil.isEmpty(exam));
    53. // 判断字符串exam是否不为空
    54. System.out.println(StringUtil.isNotEmpty(exam));
    55. // 判断字符串exam是否为空 这里的空为去掉空格之后
    56. System.out.println(StringUtil.isBlank("   "));
    57. // 判断字符串exam是否不为空 这里的空为去掉空格之后
    58. System.out.println(StringUtil.isNotBlank("   "));
    59. // 判断字符串(无限参数)是否都为空 他们之间的关系为并且
    60. System.out.println(StringUtil.isAllEmpty(exam, "  ", "null"));
    61. // 判断字符串(无限参数)是否都为空 这里的空为去掉空格之后 他们之间的关系为并且
    62. System.out.println(StringUtil.isAllBlank(exam, "  ", "null"));
    63. // 对比字符串exam中的第4索引的字符是不是d
    64. System.out.println(StringUtil.isCharAtEqual(exam, 4, 'd'));
    65. // 对比字符串exam中的第4索引的字符是不是 不是d
    66. System.out.println(StringUtil.isCharAtEscaped(exam, 4, 'd'));
    67. /*
    68. * equals安全的字符串对比是否相等 不需要考虑null.equals等问题
    69. */
    70. // 判断字符串exam与aaa是否相等
    71. System.out.println(StringUtil.equals(exam, "aaa"));
    72. // 判断两个数组是否相等
    73. System.out.println(StringUtil.equals(new String[] { "aaa" }, new String[] { "aaa", "bbb" }));
    74. // 判断两个数组是否相等 且忽略大小写
    75. System.out.println(StringUtil.equalsIgnoreCase(new String[] { "aaa" }, new String[] { "aaa", "bbb" }));
    76. // 获取字符串bbb在数组中的索引
    77. System.out.println(StringUtil.equalsOne("bbb", new String[] { "aaa", "bbb" }));
    78. // 获取字符串bbb在数组中的索引 且忽略大小写
    79. System.out.println(StringUtil.equalsOneIgnoreCase("bbb", new String[] { "aaa", "bbb" }));
    80. /*
    81. * 首字母的更改
    82. */
    83. // 首字母大写
    84. result = StringUtil.capitalize(exam);
    85. // 首字母小写
    86. result = StringUtil.uncapitalize(exam);
    87. /*
    88. * split字符串分割
    89. */
    90. // 将字符串按 , 分割
    91. String[] array = StringUtil.split("1,2,3,4,5,6,7,8", ",");
    92. /*
    93. * indexOf 获取字符串中的字符索引
    94. */
    95. /*
    96. * Strips, crops, trims and cuts
    97. */
    98. // 若这个字符串以a为开头,则去掉a
    99. result = StringUtil.stripLeadingChar(exam, 'a');
    100. // 若这个字符串以g为结尾,则去掉g
    101. result = StringUtil.stripTrailingChar(exam, 'g');
    102. // 若该字符串为"" 则返回null 若不是则返回字符串
    103. result = StringUtil.crop("");
    104. // 裁剪数组 将""变成null
    105. StringUtil.cropAll(new String[] { "", " " });
    106. // 去掉字符串两边的空格
    107. result = StringUtil.trimDown("  aa  ");
    108. // 去掉字符串左边的空格
    109. result = StringUtil.trimLeft("  aa  ");
    110. // 去掉字符串右边的空格
    111. result = StringUtil.trimRight("  aa  ");
    112. // 去掉字符串右边的空格
    113. String[] array2 = new String[] { "  aa  ", "  b  b" };
    114. /*
    115. * 去掉数组内空格
    116. */
    117. StringUtil.trimAll(array2);
    118. StringUtil.trimDownAll(array2);
    119. for (String string : array2)
    120. {
    121. System.out.println(string);
    122. }
    123. /*
    124. * 切割字符串
    125. */
    126. // 从字符串的f字符开始切割字符串 保留f
    127. result = StringUtil.cutFromIndexOf(exam, 'f');
    128. // 从字符串的fg字符串开始切割字符串 保留fg
    129. result = StringUtil.cutFromIndexOf(exam, "fg");
    130. // 检查字符串是否为abc开头,若为此开头,则切割掉abc
    131. result = StringUtil.cutPrefix(exam, "abc");
    132. // 检查字符串是否为efg结尾,若为此结尾,则切割掉efg
    133. result = StringUtil.cutSuffix(exam, "efg");
    134. // 检查字符串是否为efg开头或结尾,若为此开头或结尾,则切割掉efg
    135. result = StringUtil.cutSurrounding(exam, "efg");
    136. // 检查字符串是否为abc开头efg结尾,若为为abc开头efg结尾,则切割掉
    137. result = StringUtil.cutSurrounding(exam, "abc", "efg");
    138. // 截取到字符串的f字符开始切割字符串 不保留f
    139. result = StringUtil.cutToIndexOf(exam, 'f');
    140. // 截取到字符串的fg字符串开始切割字符串 不保留fg
    141. result = StringUtil.cutToIndexOf(exam, "fg");
    142. /*
    143. * 其他很多小巧的方法,可以自行研究
    144. */
    145. System.out.println(result);
    146. }
    147. }
上一篇：.NET Core 中导入导出Excel


下一篇：Linux大棚命令记录