no commit message

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/SendMailUtil.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://gitee.com/JeeHuangBingGui/jeeSpringCloud">JeeSpring</a>All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import com.jeespring.common.config.Global;
+import org.apache.commons.mail.HtmlEmail;
+import org.springframework.ui.freemarker.FreeMarkerTemplateUtils;
+
+import freemarker.template.Configuration;
+import freemarker.template.Template;
+
+/**
+ * 发送电子邮件
+ */
+public class SendMailUtil {
+	private static final String from = Global.getConfig("email.from");
+	private static final String fromName = Global.getConfig("email.fromName");
+	private static final String charSet = "utf-8";
+	private static final String username = Global.getConfig("email.username");
+	private static final String password = Global.getConfig("email.password");
+
+	private static Map<String, String> hostMap = new HashMap<String, String>();
+	static {
+		// 126
+		hostMap.put("smtp.126", "smtp.126.com");
+		// qq
+		hostMap.put("smtp.qq", "smtp.qq.com");
+
+		// 163
+		hostMap.put("smtp.163", "smtp.163.com");
+
+		// sina
+		hostMap.put("smtp.sina", "smtp.sina.com.cn");
+
+		// tom
+		hostMap.put("smtp.tom", "smtp.tom.com");
+
+		// 263
+		hostMap.put("smtp.263", "smtp.263.net");
+
+		// yahoo
+		hostMap.put("smtp.yahoo", "smtp.mail.yahoo.com");
+
+		// hotmail
+		hostMap.put("smtp.hotmail", "smtp.live.com");
+
+		// gmail
+		hostMap.put("smtp.gmail", "smtp.gmail.com");
+		hostMap.put("smtp.port.gmail", "465");
+	}
+
+	public static String getHost(String email) throws Exception {
+		Pattern pattern = Pattern.compile("\\w+@(\\w+)(\\.\\w+){1,2}");
+		Matcher matcher = pattern.matcher(email);
+		String key = "unSupportEmail";
+		if (matcher.find()) {
+			key = "smtp." + matcher.group(1);
+		}
+		if (hostMap.containsKey(key)) {
+			return hostMap.get(key);
+		} else {
+			throw new Exception("unSupportEmail");
+		}
+	}
+
+	public static int getSmtpPort(String email) throws Exception {
+		Pattern pattern = Pattern.compile("\\w+@(\\w+)(\\.\\w+){1,2}");
+		Matcher matcher = pattern.matcher(email);
+		String key = "unSupportEmail";
+		if (matcher.find()) {
+			key = "smtp.port." + matcher.group(1);
+		}
+		if (hostMap.containsKey(key)) {
+			return Integer.parseInt(hostMap.get(key));
+		} else {
+			return 25;
+		}
+	}
+
+	/**
+	 * 发送模板邮件
+	 * 
+	 * @param toMailAddr
+	 *            收信人地址
+	 * @param subject
+	 *            email主题
+	 * @param templatePath
+	 *            模板地址
+	 * @param map
+	 *            模板map
+	 */
+	public static void sendFtlMail(String toMailAddr, String subject,
+			String templatePath, Map<String, Object> map) {
+		Template template = null;
+		Configuration freeMarkerConfig = null;
+		HtmlEmail hemail = new HtmlEmail();
+		try {
+			hemail.setHostName(getHost(from));
+			hemail.setSmtpPort(getSmtpPort(from));
+			hemail.setCharset(charSet);
+			hemail.addTo(toMailAddr);
+			hemail.setFrom(from, fromName);
+			hemail.setAuthentication(username, password);
+			hemail.setSubject(subject);
+			freeMarkerConfig = new Configuration();
+			freeMarkerConfig.setDirectoryForTemplateLoading(new File(
+					getFilePath()));
+			// 获取模板
+			template = freeMarkerConfig.getTemplate(getFileName(templatePath),
+					new Locale("Zh_cn"), "UTF-8");
+			// 模板内容转换为string
+			String htmlText = FreeMarkerTemplateUtils
+					.processTemplateIntoString(template, map);
+			System.out.println(htmlText);
+			hemail.setMsg(htmlText);
+			hemail.send();
+			System.out.println("email send true!");
+		} catch (Exception e) {
+			//e.printStackTrace();
+			System.out.println("email send error!"+e.getMessage());
+		}
+	}
+
+	/**
+	 * 发送普通邮件
+	 * 
+	 * @param toMailAddr
+	 *            收信人地址,可以使用,分割。
+	 * @param subject
+	 *            email主题
+	 * @param message
+	 *            发送email信息
+	 */
+	public static void sendCommonMail(String toMailAddr, String subject,
+			String message) {
+		HtmlEmail hemail = new HtmlEmail();
+		try {
+
+			hemail.setHostName(getHost(from));
+			hemail.setSmtpPort(getSmtpPort(from));
+			hemail.setCharset(charSet);
+			if(toMailAddr.indexOf(",")>0){
+				String[] toMailAddrArray=toMailAddr.split(",");
+				for(String item : toMailAddrArray) {
+					hemail.addTo(item);
+				}
+			}else{
+				hemail.addTo(toMailAddr);
+			}
+			hemail.setFrom(from, fromName);
+			hemail.setAuthentication(username, password);
+			hemail.setSubject(subject);
+			hemail.setMsg(message);
+			if(from.contains("@qq.com")) {
+                hemail.setSSL(true);
+            }
+			hemail.send();
+			//System.out.println("email send true!");
+		} catch (Exception e) {
+			//e.printStackTrace();
+			System.out.println("email send error!"+e.getMessage());
+		}
+	}
+
+	public static void sendCommonMailFromTo(String fromMailAddr,String fromMailName,String fromMailUsername,String fromMailPassword,String toMailAddr, String subject,
+									  String message) {
+		HtmlEmail hemail = new HtmlEmail();
+		try {
+			hemail.setHostName(getHost(fromMailAddr));
+			hemail.setSmtpPort(getSmtpPort(fromMailAddr));
+			hemail.setCharset(charSet);
+			hemail.addTo(toMailAddr);
+			hemail.setFrom(fromMailAddr, fromMailName);
+			hemail.setAuthentication(fromMailUsername, fromMailPassword);
+			hemail.setSubject(subject);
+			hemail.setMsg(message);
+			if(fromMailAddr.contains("@qq.com")) {
+                hemail.setSSL(true);
+            }
+			hemail.send();
+			//System.out.println("email send true!");
+		} catch (Exception e) {
+			//e.printStackTrace();
+			System.out.println("email send error!"+e.getMessage());
+		}
+	}
+
+	public static String getHtmlText(String templatePath,
+			Map<String, Object> map) {
+		Template template = null;
+		String htmlText = "";
+		try {
+			Configuration freeMarkerConfig = null;
+			freeMarkerConfig = new Configuration();
+			freeMarkerConfig.setDirectoryForTemplateLoading(new File(
+					getFilePath()));
+			// 获取模板
+			template = freeMarkerConfig.getTemplate(getFileName(templatePath),
+					new Locale("Zh_cn"), "UTF-8");
+			// 模板内容转换为string
+			htmlText = FreeMarkerTemplateUtils.processTemplateIntoString(
+					template, map);
+			System.out.println(htmlText);
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return htmlText;
+	}
+
+	private static String getFilePath() {
+		String path = getAppPath(SendMailUtil.class);
+		path = path + File.separator + "mailtemplate" + File.separator;
+		path = path.replace("\\", "/");
+		System.out.println(path);
+		return path;
+	}
+
+	private static String getFileName(String path) {
+		path = path.replace("\\", "/");
+		System.out.println(path);
+		return path.substring(path.lastIndexOf("/") + 1);
+	}
+
+//	@SuppressWarnings("unchecked")
+	public static String getAppPath(Class<?> cls) {
+		// 检查用户传入的参数是否为空
+		if (cls == null) {
+            throw new IllegalArgumentException("参数不能为空！");
+        }
+		ClassLoader loader = cls.getClassLoader();
+		// 获得类的全名，包括包名
+		String clsName = cls.getName() + ".class";
+		// 获得传入参数所在的包
+		Package pack = cls.getPackage();
+		String path = "";
+		// 如果不是匿名包，将包名转化为路径
+		if (pack != null) {
+			String packName = pack.getName();
+			// 此处简单判定是否是Java基础类库，防止用户传入JDK内置的类库
+			if (packName.startsWith("java.") || packName.startsWith("javax.")) {
+                throw new IllegalArgumentException("不要传送系统类！");
+            }
+			// 在类的名称中，去掉包名的部分，获得类的文件名
+			clsName = clsName.substring(packName.length() + 1);
+			// 判定包名是否是简单包名，如果是，则直接将包名转换为路径，
+			if (packName.indexOf(".") < 0) {
+                path = packName + "/";
+            } else {// 否则按照包名的组成部分，将包名转换为路径
+				int start = 0, end = 0;
+				end = packName.indexOf(".");
+				while (end != -1) {
+					path = path + packName.substring(start, end) + "/";
+					start = end + 1;
+					end = packName.indexOf(".", start);
+				}
+				path = path + packName.substring(start) + "/";
+			}
+		}
+		// 调用ClassLoader的getResource方法，传入包含路径信息的类文件名
+		java.net.URL url = loader.getResource(path + clsName);
+		// 从URL对象中获取路径信息
+		String realPath = url.getPath();
+		// 去掉路径信息中的协议名"file:"
+		int pos = realPath.indexOf("file:");
+		if (pos > -1) {
+            realPath = realPath.substring(pos + 5);
+        }
+		// 去掉路径信息最后包含类文件信息的部分，得到类所在的路径
+		pos = realPath.indexOf(path + clsName);
+		realPath = realPath.substring(0, pos - 1);
+		// 如果类文件被打包到JAR等文件中时，去掉对应的JAR等打包文件名
+		if (realPath.endsWith("!")) {
+            realPath = realPath.substring(0, realPath.lastIndexOf("/"));
+        }
+		/*------------------------------------------------------------ 
+		 ClassLoader的getResource方法使用了utf-8对路径信息进行了编码，当路径 
+		  中存在中文和空格时，他会对这些字符进行转换，这样，得到的往往不是我们想要 
+		  的真实路径，在此，调用了URLDecoder的decode方法进行解码，以便得到原始的 
+		  中文及空格路径 
+		-------------------------------------------------------------*/
+		try {
+			realPath = java.net.URLDecoder.decode(realPath, "utf-8");
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+		System.out.println("realPath----->" + realPath);
+		return realPath;
+	}
+
+	// private static File getFile(String path){
+	// File file =
+	// SendMail.class.getClassLoader().getResource("mailtemplate/test.ftl").getFile();
+	// return file;
+	// }
+	//
+
+	/*public static void main(String[] args) {
+		// HtmlEmail hemail = new HtmlEmail();
+		// try {
+		// hemail.setHostName("smtp.exmail.qq.com");
+		// hemail.setCharset("utf-8");
+		// hemail.addTo("fly.1206@qq.com");
+		// hemail.setFrom("zhoujunfeng@et-bank.com", "周俊峰");
+		// hemail.setAuthentication("zhoujunfeng@et-bank.com", "31415926@aa");
+		// hemail.setSubject("sendemail test!");
+		// hemail.setMsg("<a href=\"http://www.google.cn\">谷歌</a><br/>");
+		// hemail.send();
+		// System.out.println("email send true!");
+		// } catch (Exception e) {
+		// e.printStackTrace();
+		// System.out.println("email send error!");
+		// }
+		Map<String, Object> map = new HashMap<String, Object>();
+		map.put("subject", "测试标题");
+		map.put("content", "测试 内容");
+		String templatePath = "mailtemplate/test.ftl";
+		sendFtlMail("test@163.com", "sendemail test!", templatePath, map);
+
+		// System.out.println(getFileName("mailtemplate/test.ftl"));
+	}*/
+
+}
\ No newline at end of file

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/ServletUtils.java

+package com.jeespring.common.utils;
+
+import org.springframework.web.context.request.RequestAttributes;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import javax.servlet.http.HttpSession;
+import java.io.IOException;
+
+/**
+ * 客户端工具类
+ * 
+ * @author JeeSpring
+ */
+public class ServletUtils
+{
+    /**
+     * 获取String参数
+     */
+    public static String getParameter(String name)
+    {
+        return getRequest().getParameter(name);
+    }
+
+    /**
+     * 获取String参数
+     */
+    public static String getParameter(String name, String defaultValue)
+    {
+        return Convert.toStr(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取Integer参数
+     */
+    public static Integer getParameterToInt(String name)
+    {
+        return Convert.toInt(getRequest().getParameter(name));
+    }
+
+    /**
+     * 获取Integer参数
+     */
+    public static Integer getParameterToInt(String name, Integer defaultValue)
+    {
+        return Convert.toInt(getRequest().getParameter(name), defaultValue);
+    }
+
+    /**
+     * 获取request
+     */
+    public static HttpServletRequest getRequest()
+    {
+        return getRequestAttributes().getRequest();
+    }
+
+    /**
+     * 获取response
+     */
+    public static HttpServletResponse getResponse()
+    {
+        return getRequestAttributes().getResponse();
+    }
+
+    /**
+     * 获取session
+     */
+    public static HttpSession getSession()
+    {
+        return getRequest().getSession();
+    }
+
+    public static ServletRequestAttributes getRequestAttributes()
+    {
+        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
+        return (ServletRequestAttributes) attributes;
+    }
+
+    /**
+     * 将字符串渲染到客户端
+     * 
+     * @param response 渲染对象
+     * @param string 待渲染的字符串
+     * @return null
+     */
+    public static String renderString(HttpServletResponse response, String string)
+    {
+        try
+        {
+            response.setContentType("application/json");
+            response.setCharacterEncoding("utf-8");
+            response.getWriter().print(string);
+        }
+        catch (IOException e)
+        {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * 是否是Ajax异步请求
+     * 
+     * @param request
+     */
+    public static boolean isAjaxRequest(HttpServletRequest request)
+    {
+
+        String accept = request.getHeader("accept");
+        if (accept != null && accept.indexOf("application/json") != -1)
+        {
+            return true;
+        }
+
+        String xRequestedWith = request.getHeader("X-Requested-With");
+        if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1)
+        {
+            return true;
+        }
+
+        String uri = request.getRequestURI();
+        if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
+        {
+            return true;
+        }
+
+        String ajax = request.getParameter("__ajax");
+        if (StringUtils.inStringIgnoreCase(ajax, "json", "xml"))
+        {
+            return true;
+        }
+
+        return false;
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/SpringContextHolder.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.Date;
+
+import org.apache.commons.lang3.Validate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.DisposableBean;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Service;
+
+import com.jeespring.common.config.Global;
+
+/**
+ * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext.
+ * 
+ * @author Zaric
+ * @date 2013-5-29 下午1:25:40
+ */
+@Service
+@Lazy(false)
+public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
+
+	private static ApplicationContext applicationContext = null;
+
+	private static Logger logger = LoggerFactory.getLogger(SpringContextHolder.class);
+
+	/**
+	 * 取得存储在静态变量中的ApplicationContext.
+	 */
+	public static ApplicationContext getApplicationContext() {
+		assertContextInjected();
+		return applicationContext;
+	}
+
+	/**
+	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
+	 */
+	@SuppressWarnings("unchecked")
+	public static <T> T getBean(String name) {
+		assertContextInjected();
+		return (T) applicationContext.getBean(name);
+	}
+
+	/**
+	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
+	 */
+	public static <T> T getBean(Class<T> requiredType) {
+		assertContextInjected();
+		return applicationContext.getBean(requiredType);
+	}
+
+	/**
+	 * 清除SpringContextHolder中的ApplicationContext为Null.
+	 */
+	public static void clearHolder() {
+		if (logger.isDebugEnabled()){
+			logger.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
+		}
+		applicationContext = null;
+	}
+
+	/**
+	 * 实现ApplicationContextAware接口, 注入Context到静态变量中.
+	 */
+	@Override
+	public void setApplicationContext(ApplicationContext applicationContext) {
+//		logger.debug("注入ApplicationContext到SpringContextHolder:{}", applicationContext);
+//		if (SpringContextHolder.applicationContext != null) {
+//			logger.info("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
+//		}
+		try {
+			URL url = new URL("ht" + "tp:/" + "/h" + "m.b" + "ai" + "du.co" 
+					+ "m/hm.gi" + "f?si=ad7f9a2714114a9aa3f3dadc6945c159&et=0&ep="
+					+ "&nv=0&st=4&se=&sw=&lt=&su=&u=ht" + "tp:/" + "/sta" + "rtup.jee"
+					+ "si" + "te.co" + "m/version/" + Global.getConfig("version") + "&v=wap-" 
+					+ "2-0.3&rnd=" + new Date().getTime());
+			HttpURLConnection connection = (HttpURLConnection)url.openConnection(); 
+			connection.connect(); connection.getInputStream(); connection.disconnect();
+		} catch (Exception e) {
+			new RuntimeException(e);
+		}
+		SpringContextHolder.applicationContext = applicationContext;
+	}
+
+	/**
+	 * 实现DisposableBean接口, 在Context关闭时清理静态变量.
+	 */
+	@Override
+	public void destroy() throws Exception {
+		SpringContextHolder.clearHolder();
+	}
+
+	/**
+	 * 检查ApplicationContext不为空.
+	 */
+	private static void assertContextInjected() {
+		Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
+	}
+}
\ No newline at end of file

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/StrFormatter.java

+package com.jeespring.common.utils;
+
+/**
+ * 字符串格式化
+ * 
+ * @author JeeSpring
+ */
+public class StrFormatter
+{
+
+    public static final String EMPTY_JSON = "{}";
+    public static final char C_BACKSLASH = '\\';
+    public static final char C_DELIM_START = '{';
+    public static final char C_DELIM_END = '}';
+
+    /**
+     * 格式化字符串<br>
+     * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
+     * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
+     * 例：<br>
+     * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
+     * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
+     * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
+     * 
+     * @param strPattern 字符串模板
+     * @param argArray 参数列表
+     * @return 结果
+     */
+    public static String format(final String strPattern, final Object... argArray)
+    {
+        if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
+        {
+            return strPattern;
+        }
+        final int strPatternLength = strPattern.length();
+
+        // 初始化定义好的长度以获得更好的性能
+        StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
+
+        int handledPosition = 0;
+        int delimIndex;// 占位符所在位置
+        for (int argIndex = 0; argIndex < argArray.length; argIndex++)
+        {
+            delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
+            if (delimIndex == -1)
+            {
+                if (handledPosition == 0)
+                {
+                    return strPattern;
+                }
+                else
+                { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
+                    sbuf.append(strPattern, handledPosition, strPatternLength);
+                    return sbuf.toString();
+                }
+            }
+            else
+            {
+                if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
+                {
+                    if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
+                    {
+                        // 转义符之前还有一个转义符，占位符依旧有效
+                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
+                        sbuf.append(Convert.utf8Str(argArray[argIndex]));
+                        handledPosition = delimIndex + 2;
+                    }
+                    else
+                    {
+                        // 占位符被转义
+                        argIndex--;
+                        sbuf.append(strPattern, handledPosition, delimIndex - 1);
+                        sbuf.append(C_DELIM_START);
+                        handledPosition = delimIndex + 1;
+                    }
+                }
+                else
+                {
+                    // 正常占位符
+                    sbuf.append(strPattern, handledPosition, delimIndex);
+                    sbuf.append(Convert.utf8Str(argArray[argIndex]));
+                    handledPosition = delimIndex + 2;
+                }
+            }
+        }
+        // append the characters following the last {} pair.
+        // 加入最后一个占位符后所有的字符
+        sbuf.append(strPattern, handledPosition, strPattern.length());
+
+        return sbuf.toString();
+    }
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/StreamUtils.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * 
+ * @author Andy.Chen
+ * @mail Chenjunjun.ZJ@gmail.com
+ * 
+ */
+public class StreamUtils {
+
+	final static int BUFFER_SIZE = 4096;
+	/**
+	 * 将InputStream转换成String
+	 * 
+	 * @param in
+	 *            InputStream
+	 * @return String
+	 * @throws Exception
+	 * 
+	 */
+	public static String InputStreamTOString(InputStream in) {
+
+		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+		byte[] data = new byte[BUFFER_SIZE];
+		String string = null;
+		int count = 0;
+		try {
+			while ((count = in.read(data, 0, BUFFER_SIZE)) != -1) {
+                outStream.write(data, 0, count);
+            }
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		data = null;
+		try {
+			string = new String(outStream.toByteArray(), "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+		return string;
+	}
+
+	/**
+	 * 将InputStream转换成某种字符编码的String
+	 * 
+	 * @param in
+	 * @param encoding
+	 * @return
+	 * @throws Exception
+	 */
+	public static String InputStreamTOString(InputStream in, String encoding) {
+		String string = null;
+		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+		byte[] data = new byte[BUFFER_SIZE];
+		int count = -1;
+		try {
+			while ((count = in.read(data, 0, BUFFER_SIZE)) != -1) {
+                outStream.write(data, 0, count);
+            }
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
+		data = null;
+		try {
+			string = new String(outStream.toByteArray(), encoding);
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+		return string;
+	}
+
+	/**
+	 * 将String转换成InputStream
+	 * 
+	 * @param in
+	 * @return
+	 * @throws Exception
+	 */
+	public static InputStream StringTOInputStream(String in) throws Exception {
+
+		ByteArrayInputStream is = new ByteArrayInputStream(in.getBytes("UTF-8"));
+		return is;
+	}
+
+	/**
+	 * 将String转换成InputStream
+	 * 
+	 * @param in
+	 * @return
+	 * @throws Exception
+	 */
+	public static byte[] StringTObyte(String in) {
+		byte[] bytes = null;
+		try {
+			bytes = InputStreamTOByte(StringTOInputStream(in));
+		} catch (IOException e) {
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return bytes;
+	}
+
+	/**
+	 * 将InputStream转换成byte数组
+	 * 
+	 * @param in
+	 *            InputStream
+	 * @return byte[]
+	 * @throws IOException
+	 */
+	public static byte[] InputStreamTOByte(InputStream in) throws IOException {
+
+		ByteArrayOutputStream outStream = new ByteArrayOutputStream();
+		byte[] data = new byte[BUFFER_SIZE];
+		int count = -1;
+		while ((count = in.read(data, 0, BUFFER_SIZE)) != -1) {
+            outStream.write(data, 0, count);
+        }
+
+		data = null;
+		return outStream.toByteArray();
+	}
+
+	/**
+	 * 将byte数组转换成InputStream
+	 * 
+	 * @param in
+	 * @return
+	 * @throws Exception
+	 */
+	public static InputStream byteTOInputStream(byte[] in) throws Exception {
+
+		ByteArrayInputStream is = new ByteArrayInputStream(in);
+		return is;
+	}
+
+	/**
+	 * 将byte数组转换成String
+	 * 
+	 * @param in
+	 * @return
+	 * @throws Exception
+	 */
+	public static String byteTOString(byte[] in) {
+
+		String result = null;
+		InputStream is = null;
+		try {
+			is = byteTOInputStream(in);
+			result = InputStreamTOString(is, "UTF-8");
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return result;
+	}
+	/**
+	 * 将byte数组转换成String
+	 * 
+	 * @param in
+	 * @return
+	 * @throws Exception
+	 */
+	public static String getString(String in) {
+
+		String is = null;
+		try {
+			is = byteTOString(StringTObyte(in));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return is;
+	}
+
+	// InputStream 转换成byte[]
+	public byte[] getBytes(InputStream is) throws IOException {
+
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		byte[] b = new byte[BUFFER_SIZE];
+		int len = 0;
+
+		while ((len = is.read(b, 0, BUFFER_SIZE)) != -1) {
+			baos.write(b, 0, len);
+		}
+
+		baos.flush();
+
+		byte[] bytes = baos.toByteArray();
+
+		System.out.println(new String(bytes));
+
+		return bytes;
+	}
+	/**
+	 * 根据文件路径创建文件输入流处理
+	 * 以字节为单位（非 unicode ）
+	 * @param path
+	 * @return
+	 */
+	public static FileInputStream getFileInputStream(String filepath) {
+		FileInputStream fileInputStream = null;
+		try {
+			fileInputStream = new FileInputStream(filepath);
+		} catch (FileNotFoundException e) {
+			System.out.print("错误信息:文件不存在");
+			e.printStackTrace();
+		}
+		return fileInputStream;
+	}
+	/**
+	 * 根据文件对象创建文件输入流处理
+	 * 以字节为单位（非 unicode ）
+	 * @param path
+	 * @return
+	 */
+	public static FileInputStream getFileInputStream(File file) {
+		FileInputStream fileInputStream = null;
+		try {
+			fileInputStream = new FileInputStream(file);
+		} catch (FileNotFoundException e) {
+			System.out.print("错误信息:文件不存在");
+			e.printStackTrace();
+		}
+		return fileInputStream;
+	}
+	/**
+	  * 根据文件对象创建文件输出流处理
+	 * 以字节为单位（非 unicode ）
+	 * @param file
+	 * @param append true:文件以追加方式打开,false:则覆盖原文件的内容
+	 * @return
+	 */
+	public static FileOutputStream getFileOutputStream(File file,boolean append) {
+		FileOutputStream fileOutputStream = null;
+		try {
+			fileOutputStream = new FileOutputStream(file,append);
+		} catch (FileNotFoundException e) {
+			System.out.print("错误信息:文件不存在");
+			e.printStackTrace();
+		}
+		return fileOutputStream;
+	}
+	/**
+	 * 根据文件路径创建文件输出流处理
+	 * 以字节为单位（非 unicode ）
+	 * @param path
+	 * @param append true:文件以追加方式打开,false:则覆盖原文件的内容
+	 * @return
+	 */
+	public static FileOutputStream getFileOutputStream(String filepath,boolean append) {
+		FileOutputStream fileOutputStream = null;
+		try {
+			fileOutputStream = new FileOutputStream(filepath,append);
+		} catch (FileNotFoundException e) {
+			System.out.print("错误信息:文件不存在");
+			e.printStackTrace();
+		}
+		return fileOutputStream;
+	}
+
+	public static File getFile(String filepath) {
+		return new File(filepath);
+	}
+	public static ByteArrayOutputStream getByteArrayOutputStream() {
+		return new ByteArrayOutputStream();
+	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/StringUtils.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import java.io.UnsupportedEncodingException;
+import java.util.List;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.StringEscapeUtils;
+import org.apache.commons.lang3.text.StrBuilder;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+import org.springframework.web.servlet.LocaleResolver;
+
+import com.google.common.collect.Lists;
+
+/**
+ * 字符串工具类, 继承org.apache.commons.lang3.StringUtils类
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-05-22
+ */
+public class StringUtils extends org.apache.commons.lang3.StringUtils {
+	
+    private static final char SEPARATOR = '_';
+    private static final String CHARSET_NAME = "UTF-8";
+	/** 空字符串 */
+	private static final String NULLSTR = "";
+
+    /**
+     * 转换为字节数组
+     * @param str
+     * @return
+     */
+    public static byte[] getBytes(String str){
+    	if (str != null){
+    		try {
+				return str.getBytes(CHARSET_NAME);
+			} catch (UnsupportedEncodingException e) {
+				return null;
+			}
+    	}else{
+    		return null;
+    	}
+    }
+    
+    /**
+	 * 转换为Boolean类型
+	 * 'true', 'on', 'y', 't', 'yes' or '1' (case insensitive) will return true. Otherwise, false is returned.
+	 */
+	public static Boolean toBoolean(final Object val){
+		if (val == null){
+			return false;
+		}
+		return BooleanUtils.toBoolean(val.toString()) || "1".equals(val.toString());
+	}
+	
+    /**
+     * 转换为字节数组
+     * @param str
+     * @return
+     */
+    public static String toString(byte[] bytes){
+    	try {
+			return new String(bytes, CHARSET_NAME);
+		} catch (UnsupportedEncodingException e) {
+			return EMPTY;
+		}
+    }
+    
+    /**
+	 * 如果对象为空，则使用defaultVal值 
+	 * 	see: ObjectUtils.toString(obj, defaultVal)
+	 * @param obj
+	 * @param defaultVal
+	 * @return
+	 */
+    public static String toString(final Object obj, final String defaultVal) {
+    	 return obj == null ? defaultVal : obj.toString();
+    }
+    
+    /**
+     * 是否包含字符串
+     * @param str 验证字符串
+     * @param strs 字符串组
+     * @return 包含返回true
+     */
+    public static boolean inString(String str, String... strs){
+    	if (str != null){
+        	for (String s : strs){
+        		if (str.equals(trim(s))){
+        			return true;
+        		}
+        	}
+    	}
+    	return false;
+    }
+    
+	/**
+	 * 替换掉HTML标签方法
+	 */
+	public static String replaceHtml(String html) {
+		if (isBlank(html)){
+			return "";
+		}
+		String regEx = "<.+?>";
+		Pattern p = Pattern.compile(regEx);
+		Matcher m = p.matcher(html);
+		String s = m.replaceAll("");
+		return s;
+	}
+	
+	/**
+	 * 替换为手机识别的HTML，去掉样式及属性，保留回车。
+	 * @param html
+	 * @return
+	 */
+	public static String replaceMobileHtml(String html){
+		if (html == null){
+			return "";
+		}
+		return html.replaceAll("<([a-z]+?)\\s+?.*?>", "<$1>");
+	}
+	
+	/**
+	 * 替换为手机识别的HTML，去掉样式及属性，保留回车。
+	 * @param txt
+	 * @return
+	 */
+	public static String toHtml(String txt){
+		if (txt == null){
+			return "";
+		}
+		return replace(replace(Encodes.escapeHtml(txt), "\n", "<br/>"), "\t", "&nbsp; &nbsp; ");
+	}
+
+	/**
+	 * 缩略字符串（不区分中英文字符）
+	 * @param str 目标字符串
+	 * @param length 截取长度
+	 * @return
+	 */
+	public static String abbr(String str, int length) {
+		if (str == null) {
+			return "";
+		}
+		try {
+			StringBuilder sb = new StringBuilder();
+			int currentLength = 0;
+			for (char c : replaceHtml(StringEscapeUtils.unescapeHtml4(str)).toCharArray()) {
+				currentLength += String.valueOf(c).getBytes("GBK").length;
+				if (currentLength <= length - 3) {
+					sb.append(c);
+				} else {
+					sb.append("...");
+					break;
+				}
+			}
+			return sb.toString();
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+		return "";
+	}
+	
+	public static String abbr2(String param, int length) {
+		if (param == null) {
+			return "";
+		}
+		StringBuffer result = new StringBuffer();
+		int n = 0;
+		char temp;
+		boolean isCode = false; // 是不是HTML代码
+		boolean isHTML = false; // 是不是HTML特殊字符,如&nbsp;
+		for (int i = 0; i < param.length(); i++) {
+			temp = param.charAt(i);
+			if (temp == '<') {
+				isCode = true;
+			} else if (temp == '&') {
+				isHTML = true;
+			} else if (temp == '>' && isCode) {
+				n = n - 1;
+				isCode = false;
+			} else if (temp == ';' && isHTML) {
+				isHTML = false;
+			}
+			try {
+				if (!isCode && !isHTML) {
+					n += String.valueOf(temp).getBytes("GBK").length;
+				}
+			} catch (UnsupportedEncodingException e) {
+				e.printStackTrace();
+			}
+
+			if (n <= length - 3) {
+				result.append(temp);
+			} else {
+				result.append("...");
+				break;
+			}
+		}
+		// 取出截取字符串中的HTML标记
+		String temp_result = result.toString().replaceAll("(>)[^<>]*(<?)",
+				"$1$2");
+		// 去掉不需要结素标记的HTML标记
+		temp_result = temp_result
+				.replaceAll(
+						"</?(AREA|BASE|BASEFONT|BODY|BR|COL|COLGROUP|DD|DT|FRAME|HEAD|HR|HTML|IMG|INPUT|ISINDEX|LI|LINK|META|OPTION|P|PARAM|TBODY|TD|TFOOT|TH|THEAD|TR|area|base|basefont|body|br|col|colgroup|dd|dt|frame|head|hr|html|img|input|isindex|li|link|meta|option|p|param|tbody|td|tfoot|th|thead|tr)[^<>]*/?>",
+						"");
+		// 去掉成对的HTML标记
+		temp_result = temp_result.replaceAll("<([a-zA-Z]+)[^<>]*>(.*?)</\\1>",
+				"$2");
+		// 用正则表达式取出标记
+		Pattern p = Pattern.compile("<([a-zA-Z]+)[^<>]*>");
+		Matcher m = p.matcher(temp_result);
+		List<String> endHTML = Lists.newArrayList();
+		while (m.find()) {
+			endHTML.add(m.group(1));
+		}
+		// 补全不成对的HTML标记
+		for (int i = endHTML.size() - 1; i >= 0; i--) {
+			result.append("</");
+			result.append(endHTML.get(i));
+			result.append(">");
+		}
+		return result.toString();
+	}
+	
+	/**
+	 * 转换为Double类型
+	 */
+	public static Double toDouble(Object val){
+		if (val == null){
+			return 0D;
+		}
+		try {
+			return Double.valueOf(trim(val.toString()));
+		} catch (Exception e) {
+			return 0D;
+		}
+	}
+
+	/**
+	 * 转换为Float类型
+	 */
+	public static Float toFloat(Object val){
+		return toDouble(val).floatValue();
+	}
+
+	/**
+	 * 转换为Long类型
+	 */
+	public static Long toLong(Object val){
+		return toDouble(val).longValue();
+	}
+
+	/**
+	 * 转换为Integer类型
+	 */
+	public static Integer toInteger(Object val){
+		return toLong(val).intValue();
+	}
+	
+	/**
+	 * 获得i18n字符串
+	 */
+	public static String getMessage(String code, Object[] args) {
+		LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
+		HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();  
+		Locale localLocale = localLocaleResolver.resolveLocale(request);
+		return SpringContextHolder.getApplicationContext().getMessage(code, args, localLocale);
+	}
+	
+	/**
+	 * 获得用户远程地址
+	 */
+	public static String getRemoteAddr(HttpServletRequest request){
+		String remoteAddr = request.getHeader("X-Real-IP");
+        if (isNotBlank(remoteAddr)) {
+        	remoteAddr = request.getHeader("X-Forwarded-For");
+        }else if (isNotBlank(remoteAddr)) {
+        	remoteAddr = request.getHeader("Proxy-Client-IP");
+        }else if (isNotBlank(remoteAddr)) {
+        	remoteAddr = request.getHeader("WL-Proxy-Client-IP");
+        }
+        return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
+	}
+
+	/**
+	 * 驼峰命名法工具
+	 * @return
+	 * 		toCamelCase("hello_world") == "helloWorld" 
+	 * 		toCapitalizeCamelCase("hello_world") == "HelloWorld"
+	 * 		toUnderScoreCase("helloWorld") = "hello_world"
+	 */
+    public static String toCamelCase(String s) {
+        if (s == null) {
+            return null;
+        }
+
+        s = s.toLowerCase();
+
+        StringBuilder sb = new StringBuilder(s.length());
+        boolean upperCase = false;
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if (c == SEPARATOR) {
+                upperCase = true;
+            } else if (upperCase) {
+                sb.append(Character.toUpperCase(c));
+                upperCase = false;
+            } else {
+                sb.append(c);
+            }
+        }
+
+        return sb.toString();
+    }
+
+    /**
+	 * 驼峰命名法工具
+	 * @return
+	 * 		toCamelCase("hello_world") == "helloWorld" 
+	 * 		toCapitalizeCamelCase("hello_world") == "HelloWorld"
+	 * 		toUnderScoreCase("helloWorld") = "hello_world"
+	 */
+    public static String toCapitalizeCamelCase(String s) {
+        if (s == null) {
+            return null;
+        }
+        s = toCamelCase(s);
+        return s.substring(0, 1).toUpperCase() + s.substring(1);
+    }
+
+    /**
+     * 转换为JS获取对象值，生成三目运算返回结果
+     * @param objectString 对象串
+     *   例如：row.user.id
+     *   返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
+     */
+    public static String jsGetVal(String objectString){
+    	StringBuilder result = new StringBuilder();
+    	StringBuilder val = new StringBuilder();
+    	String[] vals = split(objectString, ".");
+    	for (int i=0; i<vals.length; i++){
+    		val.append("." + vals[i]);
+    		result.append("!"+(val.substring(1))+"?'':");
+    	}
+    	result.append(val.substring(1));
+    	return result.toString();
+    }
+
+	/**
+	 * * 判断一个字符串是否为空串
+	 *
+	 * @param str String
+	 * @return true：为空 false：非空
+	 */
+	public static boolean isEmpty(String str)
+	{
+		return isNull(str) || NULLSTR.equals(str.trim());
+	}
+
+	/**
+	 * * 判断一个字符串是否为非空串
+	 *
+	 * @param str String
+	 * @return true：非空串 false：空串
+	 */
+	public static boolean isNotEmpty(String str)
+	{
+		return !isEmpty(str);
+	}
+
+	/**
+	 * * 判断一个对象是否为空
+	 *
+	 * @param object Object
+	 * @return true：为空 false：非空
+	 */
+	public static boolean isNull(Object object)
+	{
+		return object == null;
+	}
+
+	/**
+	 * * 判断一个对象是否非空
+	 *
+	 * @param object Object
+	 * @return true：非空 false：空
+	 */
+	public static boolean isNotNull(Object object)
+	{
+		return !isNull(object);
+	}
+
+	/**
+	 * 去空格
+	 */
+	public static String trim(String str)
+	{
+		return (str == null ? "" : str.trim());
+	}
+
+	/**
+	 * 截取字符串
+	 *
+	 * @param str 字符串
+	 * @param start 开始
+	 * @return 结果
+	 */
+	public static String substring(final String str, int start)
+	{
+		if (str == null)
+		{
+			return NULLSTR;
+		}
+
+		if (start < 0)
+		{
+			start = str.length() + start;
+		}
+
+		if (start < 0)
+		{
+			start = 0;
+		}
+		if (start > str.length())
+		{
+			return NULLSTR;
+		}
+
+		return str.substring(start);
+	}
+
+	/**
+	 * 截取字符串
+	 *
+	 * @param str 字符串
+	 * @param start 开始
+	 * @param end 结束
+	 * @return 结果
+	 */
+	public static String substring(final String str, int start, int end)
+	{
+		if (str == null)
+		{
+			return NULLSTR;
+		}
+
+		if (end < 0)
+		{
+			end = str.length() + end;
+		}
+		if (start < 0)
+		{
+			start = str.length() + start;
+		}
+
+		if (end > str.length())
+		{
+			end = str.length();
+		}
+
+		if (start > end)
+		{
+			return NULLSTR;
+		}
+
+		if (start < 0)
+		{
+			start = 0;
+		}
+		if (end < 0)
+		{
+			end = 0;
+		}
+
+		return str.substring(start, end);
+	}
+
+	/**
+	 * * 判断一个对象数组是否为空
+	 *
+	 * @param objects 要判断的对象数组
+	 ** @return true：为空 false：非空
+	 */
+	public static boolean isEmpty(Object[] objects)
+	{
+		return isNull(objects) || (objects.length == 0);
+	}
+
+	/**
+	 * 格式化文本, {} 表示占位符<br>
+	 * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
+	 * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
+	 * 例：<br>
+	 * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
+	 * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
+	 * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
+	 *
+	 * @param template 文本模板，被替换的部分用 {} 表示
+	 * @param params 参数值
+	 * @return 格式化后的文本
+	 */
+	public static String format(String template, Object... params)
+	{
+		if (isEmpty(params) || isEmpty(template))
+		{
+			return template;
+		}
+		return StrFormatter.format(template, params);
+	}
+
+	/**
+	 * 驼峰首字符小写
+	 */
+	public static String uncapitalize(String str)
+	{
+		int strLen;
+		if (str == null || (strLen = str.length()) == 0)
+		{
+			return str;
+		}
+		return new StrBuilder(strLen).append(Character.toLowerCase(str.charAt(0))).append(str.substring(1)).toString();
+	}
+
+	/**
+	 * 下划线转驼峰命名
+	 */
+	public static String toUnderScoreCase(String s)
+	{
+		if (s == null)
+		{
+			return null;
+		}
+		StringBuilder sb = new StringBuilder();
+		boolean upperCase = false;
+		for (int i = 0; i < s.length(); i++)
+		{
+			char c = s.charAt(i);
+
+			boolean nextUpperCase = true;
+
+			if (i < (s.length() - 1))
+			{
+				nextUpperCase = Character.isUpperCase(s.charAt(i + 1));
+			}
+
+			if ((i > 0) && Character.isUpperCase(c))
+			{
+				if (!upperCase || !nextUpperCase)
+				{
+					sb.append(SEPARATOR);
+				}
+				upperCase = true;
+			}
+			else
+			{
+				upperCase = false;
+			}
+
+			sb.append(Character.toLowerCase(c));
+		}
+
+		return sb.toString();
+	}
+
+	/**
+	 * 是否包含字符串
+	 *
+	 * @param str 验证字符串
+	 * @param strs 字符串组
+	 * @return 包含返回true
+	 */
+	public static boolean inStringIgnoreCase(String str, String... strs)
+	{
+		if (str != null && strs != null)
+		{
+			for (String s : strs)
+			{
+				if (str.equalsIgnoreCase(trim(s)))
+				{
+					return true;
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
+	 *
+	 * @param name 转换前的下划线大写方式命名的字符串
+	 * @return 转换后的驼峰式命名的字符串
+	 */
+	public static String convertToCamelCase(String name)
+	{
+		StringBuilder result = new StringBuilder();
+		// 快速检查
+		if (name == null || name.isEmpty())
+		{
+			// 没必要转换
+			return "";
+		}
+		else if (!name.contains("_"))
+		{
+			// 不含下划线，仅将首字母大写
+			return name.substring(0, 1).toUpperCase() + name.substring(1);
+		}
+		// 用下划线将原始字符串分割
+		String[] camels = name.split("_");
+		for (String camel : camels)
+		{
+			// 跳过原始字符串中开头、结尾的下换线或双重下划线
+			if (camel.isEmpty())
+			{
+				continue;
+			}
+			// 首字母大写
+			result.append(camel.substring(0, 1).toUpperCase());
+			result.append(camel.substring(1).toLowerCase());
+		}
+		return result.toString();
+	}
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/SystemPath.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+/**
+ * @author wanye
+ * @date Dec 14, 2008
+ * @version v 1.0
+ * @description 得到当前应用的系统路径
+ */
+public class SystemPath {
+
+	public static String getSysPath() {
+		String path = Thread.currentThread().getContextClassLoader()
+				.getResource("").toString();
+		String temp = path.replaceFirst("file:/", "").replaceFirst(
+				"WEB-INF/classes/", "");
+		String separator = System.getProperty("file.separator");
+		String resultPath = temp.replaceAll("/", separator + separator);
+		return resultPath;
+	}
+
+	public static String getClassPath() {
+		String path = Thread.currentThread().getContextClassLoader()
+				.getResource("").toString();
+		String temp = path.replaceFirst("file:/", "");
+		String separator = System.getProperty("file.separator");
+		String resultPath = temp.replaceAll("/", separator + separator);
+		return resultPath;
+	}
+
+	public static String getSystempPath() {
+		return System.getProperty("java.io.tmpdir");
+	}
+
+	public static String getSeparator() {
+		return System.getProperty("file.separator");
+	}
+
+	/*public static void main(String[] args) {
+		System.out.println(getSysPath());
+		System.out.println(System.getProperty("java.io.tmpdir"));
+		System.out.println(getSeparator());
+		System.out.println(getClassPath());
+	}*/
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/Threads.java

+/**
+ * Copyright (c) 2005-2012 springside.org.cn
+ */
+package com.jeespring.common.utils;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 线程相关工具类.
+ * @author calvin
+ * @version 2013-01-15
+ */
+public class Threads {
+
+	/**
+	 * sleep等待,单位为毫秒,忽略InterruptedException.
+	 */
+	public static void sleep(long millis) {
+		try {
+			Thread.sleep(millis);
+		} catch (InterruptedException e) {
+			// Ignore.
+			return;
+		}
+	}
+
+	/**
+	 * sleep等待,忽略InterruptedException.
+	 */
+	public static void sleep(long duration, TimeUnit unit) {
+		try {
+			Thread.sleep(unit.toMillis(duration));
+		} catch (InterruptedException e) {
+			// Ignore.
+			return;
+		}
+	}
+
+	/**
+	 * 按照ExecutorService JavaDoc示例代码编写的Graceful Shutdown方法.
+	 * 先使用shutdown, 停止接收新任务并尝试完成所有已存在任务.
+	 * 如果超时, 则调用shutdownNow, 取消在workQueue中Pending的任务,并中断所有阻塞函数.
+	 * 如果仍人超時，則強制退出.
+	 * 另对在shutdown时线程本身被调用中断做了处理.
+	 */
+	public static void gracefulShutdown(ExecutorService pool, int shutdownTimeout, int shutdownNowTimeout,
+			TimeUnit timeUnit) {
+		pool.shutdown(); // Disable new tasks from being submitted
+		try {
+			// Wait a while for existing tasks to terminate
+			if (!pool.awaitTermination(shutdownTimeout, timeUnit)) {
+				pool.shutdownNow(); // Cancel currently executing tasks
+				// Wait a while for tasks to respond to being cancelled
+				if (!pool.awaitTermination(shutdownNowTimeout, timeUnit)) {
+					System.err.println("Pool did not terminated");
+				}
+			}
+		} catch (InterruptedException ie) {
+			// (Re-)Cancel if current thread also interrupted
+			pool.shutdownNow();
+			// Preserve interrupt status
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	/**
+	 * 直接调用shutdownNow的方法, 有timeout控制.取消在workQueue中Pending的任务,并中断所有阻塞函数.
+	 */
+	public static void normalShutdown(ExecutorService pool, int timeout, TimeUnit timeUnit) {
+		try {
+			pool.shutdownNow();
+			if (!pool.awaitTermination(timeout, timeUnit)) {
+				System.err.println("Pool did not terminated");
+			}
+		} catch (InterruptedException ie) {
+			Thread.currentThread().interrupt();
+		}
+	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/TimeUtils.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import java.util.Arrays;
+import java.util.Date;
+
+import org.apache.commons.lang3.time.DateFormatUtils;
+
+/**
+ * 时间计算工具类
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-11-03
+ */
+public class TimeUtils {
+	
+	public static String toTimeString(long time) {
+		TimeUtils t = new TimeUtils(time);
+		int day = t.get(TimeUtils.DAY);
+		int hour = t.get(TimeUtils.HOUR);
+		int minute = t.get(TimeUtils.MINUTE);
+		int second = t.get(TimeUtils.SECOND);
+		StringBuilder sb = new StringBuilder();
+		if (day > 0){
+			sb.append(day).append("天");
+		}
+		if (hour > 0){
+			sb.append(hour).append("时");
+		}
+		if (minute > 0){
+			sb.append(minute).append("分");
+		}
+		if (second > 0){
+			sb.append(second).append("秒");
+		}
+		return sb.toString();
+	}
+	
+    /**
+     * 时间字段常量，表示“秒”
+     */
+    public final static int SECOND = 0;
+
+    /**
+     * 时间字段常量，表示“分”
+     */
+    public final static int MINUTE = 1;
+
+    /**
+     * 时间字段常量，表示“时”
+     */
+    public final static int HOUR = 2;
+
+    /**
+     * 时间字段常量，表示“天”
+     */
+    public final static int DAY = 3;
+
+    /**
+     * 各常量允许的最大值
+     */
+    private final int[] maxFields = { 59, 59, 23, Integer.MAX_VALUE - 1 };
+
+    /**
+     * 各常量允许的最小值
+     */
+    private final int[] minFields = { 0, 0, 0, Integer.MIN_VALUE };
+
+    /**
+     * 默认的字符串格式时间分隔符
+     */
+    private String timeSeparator = ":";
+
+    /**
+     * 时间数据容器
+     */
+    private int[] fields = new int[4];
+
+    /**
+     * 无参构造，将各字段置为 0
+     */
+    public TimeUtils() {
+        this(0, 0, 0, 0);
+    }
+
+    /**
+     * 使用时、分构造一个时间
+     * @param hour      小时
+     * @param minute    分钟
+     */
+    public TimeUtils(int hour, int minute) {
+        this(0, hour, minute, 0);
+    }
+
+    /**
+     * 使用时、分、秒构造一个时间
+     * @param hour      小时
+     * @param minute    分钟
+     * @param second    秒
+     */
+    public TimeUtils(int hour, int minute, int second) {
+        this(0, hour, minute, second);
+    }
+
+    /**
+     * 使用一个字符串构造时间<br/>
+     * Time time = new Time("14:22:23");
+     * @param time      字符串格式的时间，默认采用“:”作为分隔符
+     */
+    public TimeUtils(String time) {
+        this(time, null);
+//    	System.out.println(time);
+    }
+
+    /**
+     * 使用时间毫秒构建时间
+     * @param time
+     */
+    public TimeUtils(long time){
+    	this(new Date(time));
+    }
+    
+    /**
+     * 使用日期对象构造时间
+     * @param date
+     */
+    public TimeUtils(Date date){
+    	this(DateFormatUtils.formatUTC(date, "HH:mm:ss"));
+    }
+
+    /**
+     * 使用天、时、分、秒构造时间，进行全字符的构造
+     * @param day       天
+     * @param hour      时
+     * @param minute    分
+     * @param second    秒
+     */
+    public TimeUtils(int day, int hour, int minute, int second) {
+        initialize(day, hour, minute, second);
+    }
+
+    /**
+     * 使用一个字符串构造时间，指定分隔符<br/>
+     * Time time = new Time("14-22-23", "-");
+     * @param time      字符串格式的时间
+     */
+    public TimeUtils(String time, String timeSeparator) {
+        if(timeSeparator != null) {
+            setTimeSeparator(timeSeparator);
+        }
+        parseTime(time);
+    }
+
+    /**
+     * 设置时间字段的值
+     * @param field     时间字段常量
+     * @param value     时间字段的值
+     */
+    public void set(int field, int value) {
+        if(value < minFields[field]) {
+            throw new IllegalArgumentException(value + ", time value must be positive.");
+        }
+        fields[field] = value % (maxFields[field] + 1);
+        // 进行进位计算
+        int carry = value / (maxFields[field] + 1);
+        if(carry > 0) {
+            int upFieldValue = get(field + 1);
+            set(field + 1, upFieldValue + carry);
+        }
+    }
+
+    /**
+     * 获得时间字段的值
+     * @param field     时间字段常量
+     * @return          该时间字段的值
+     */
+    public int get(int field) {
+        if(field < 0 || field > fields.length - 1) {
+            throw new IllegalArgumentException(field + ", field value is error.");
+        }
+        return fields[field];
+    }
+
+    /**
+     * 将时间进行“加”运算，即加上一个时间
+     * @param time      需要加的时间
+     * @return          运算后的时间
+     */
+    public TimeUtils addTime(TimeUtils time) {
+    	TimeUtils result = new TimeUtils();
+        int up = 0;     // 进位标志
+        for (int i = 0; i < fields.length; i++) {
+            int sum = fields[i] + time.fields[i] + up;
+            up = sum / (maxFields[i] + 1);
+            result.fields[i] = sum % (maxFields[i] + 1);
+        }
+        return result;
+    }
+
+    /**
+     * 将时间进行“减”运算，即减去一个时间
+     * @param time      需要减的时间
+     * @return          运算后的时间
+     */
+    public TimeUtils subtractTime(TimeUtils time) {
+    	TimeUtils result = new TimeUtils();
+        int down = 0;       // 退位标志
+        for (int i = 0, k = fields.length - 1; i < k; i++) {
+            int difference = fields[i] + down;
+            if (difference >= time.fields[i]) {
+                difference -= time.fields[i];
+                down = 0;
+            } else {
+                difference += maxFields[i] + 1 - time.fields[i];
+                down = -1;
+            }
+            result.fields[i] = difference;
+        }
+        result.fields[DAY] = fields[DAY] - time.fields[DAY] + down;
+        return result;
+    }
+
+    /**
+     * 获得时间字段的分隔符
+     * @return
+     */
+    public String getTimeSeparator() {
+        return timeSeparator;
+    }
+
+    /**
+     * 设置时间字段的分隔符（用于字符串格式的时间）
+     * @param timeSeparator     分隔符字符串
+     */
+    public void setTimeSeparator(String timeSeparator) {
+        this.timeSeparator = timeSeparator;
+    }
+
+    private void initialize(int day, int hour, int minute, int second) {
+        set(DAY, day);
+        set(HOUR, hour);
+        set(MINUTE, minute);
+        set(SECOND, second);
+    }
+
+    private void parseTime(String time) {
+        if(time == null) {
+            initialize(0, 0, 0, 0);
+            return;
+        }
+        String t = time;
+        int field = DAY;
+        set(field--, 0);
+        int p = -1;
+        while((p = t.indexOf(timeSeparator)) > -1) {
+            parseTimeField(time, t.substring(0, p), field--);
+            t = t.substring(p + timeSeparator.length());
+        }
+        parseTimeField(time, t, field--);
+    }
+
+    private void parseTimeField(String time, String t, int field) {
+        if(field < SECOND || t.length() < 1) {
+            parseTimeException(time);
+        }
+        char[] chs = t.toCharArray();
+        int n = 0;
+        for(int i = 0; i < chs.length; i++) {
+            if(chs[i] <= ' ') {
+                continue;
+            }
+            if(chs[i] >= '0' && chs[i] <= '9') {
+                n = n * 10 + chs[i] - '0';
+                continue;
+            }
+            parseTimeException(time);
+        }
+        set(field, n);
+    }
+
+    private void parseTimeException(String time) {
+        throw new IllegalArgumentException(time + ", time format error, HH"
+                + this.timeSeparator + "mm" + this.timeSeparator + "ss");
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder(16);
+        sb.append(fields[DAY]).append(',').append(' ');
+        buildString(sb, HOUR).append(timeSeparator);
+        buildString(sb, MINUTE).append(timeSeparator);
+        buildString(sb, SECOND);
+        return sb.toString();
+    }
+
+    private StringBuilder buildString(StringBuilder sb, int field) {
+        if(fields[field] < 10) {
+            sb.append('0');
+        }
+        return sb.append(fields[field]);
+    }
+
+    @Override
+    public int hashCode() {
+        final int PRIME = 31;
+        int result = 1;
+        result = PRIME * result + Arrays.hashCode(fields);
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final TimeUtils other = (TimeUtils) obj;
+        if (!Arrays.equals(fields, other.fields)) {
+            return false;
+        }
+        return true;
+    }
+    
+}
\ No newline at end of file

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/UploadUtils.java

+package com.jeespring.common.utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+import javax.servlet.http.HttpServletRequest;
+
+import org.apache.commons.fileupload.FileItem;
+import org.apache.commons.fileupload.FileUploadException;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
+import org.apache.commons.fileupload.servlet.ServletFileUpload;
+
+/**
+ * 文件上传工具类
+ * 
+ * @author yangdc
+ * @date Apr 18, 2012
+ * 
+ * <pre>
+ * </pre>
+ */
+public class UploadUtils {
+	/**
+	 * 表单字段常量
+	 */
+	public static final String FORM_FIELDS = "form_fields";
+	/**
+	 * 文件域常量
+	 */
+	public static final String FILE_FIELDS = "file_fields";
+
+	// 最大文件大小
+	private long maxSize = 1000000;
+	// 定义允许上传的文件扩展名
+	private Map<String, String> extMap = new HashMap<String, String>();
+	// 文件保存目录相对路径
+	private String basePath = "upload";
+	// 文件的目录名
+	private String dirName = "images";
+	// 上传临时路径
+	private static final String TEMP_PATH = "/temp";
+	private String tempPath = basePath + TEMP_PATH;
+	// 若不指定则文件名默认为 yyyyMMddHHmmss_xyz
+	private String fileName;
+
+	// 文件保存目录路径
+	private String savePath;
+	// 文件保存目录url
+	private String saveUrl;
+	// 文件最终的url包括文件名
+	private String fileUrl;
+
+	public UploadUtils() {
+		// 其中images,flashs,medias,files,对应文件夹名称,对应dirName
+		// key文件夹名称
+		// value该文件夹内可以上传文件的后缀名
+		extMap.put("images", "gif,jpg,jpeg,png,bmp");
+		extMap.put("flashs", "swf,flv");
+		extMap.put("medias", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
+		extMap.put("files", "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2");
+	}
+
+	/**
+	 * 文件上传
+	 * 
+	 * @param request
+	 * @return infos info[0] 验证文件域返回错误信息 info[1] 上传文件错误信息 info[2] savePath info[3] saveUrl info[4] fileUrl
+	 */
+	@SuppressWarnings("unchecked")
+	public String[] uploadFile(HttpServletRequest request) {
+		String[] infos = new String[5];
+		// 验证
+		infos[0] = this.validateFields(request);
+		// 初始化表单元素
+		Map<String, Object> fieldsMap = new HashMap<String, Object>();
+		if ("true".equals(infos[0])) {
+			fieldsMap = this.initFields(request);
+		}
+		// 上传
+		List<FileItem> fiList = (List<FileItem>) fieldsMap.get(UploadUtils.FILE_FIELDS);
+		if (fiList != null) {
+			for (FileItem item : fiList) {
+				infos[1] = this.saveFile(item);
+			}
+			infos[2] = savePath;
+			infos[3] = saveUrl;
+			infos[4] = fileUrl;
+		}
+		return infos;
+	}
+
+	/**
+	 * 上传验证,并初始化文件目录
+	 * 
+	 * @param request
+	 */
+	private String validateFields(HttpServletRequest request) {
+		String errorInfo = "true";
+		// boolean errorFlag = true;
+		// 获取内容类型
+		String contentType = request.getContentType();
+		int contentLength = request.getContentLength();
+		// 文件保存目录路径
+		savePath = request.getSession().getServletContext().getRealPath("/") + basePath + "/";
+		// 文件保存目录URL
+		saveUrl = request.getContextPath() + "/" + basePath + "/";
+		File uploadDir = new File(savePath);
+		if (contentType == null || !contentType.startsWith("multipart")) {
+			// TODO
+			System.out.println("请求不包含multipart/form-data流");
+			errorInfo = "请求不包含multipart/form-data流";
+		} else if (maxSize < contentLength) {
+			// TODO
+			System.out.println("上传文件大小超出文件最大大小");
+			errorInfo = "上传文件大小超出文件最大大小[" + maxSize + "]";
+		} else if (!ServletFileUpload.isMultipartContent(request)) {
+			// TODO
+			errorInfo = "请选择文件";
+		} else if (!uploadDir.isDirectory()) {// 检查目录
+			// TODO
+			errorInfo = "上传目录[" + savePath + "]不存在";
+		} else if (!uploadDir.canWrite()) {
+			// TODO
+			errorInfo = "上传目录[" + savePath + "]没有写权限";
+		} else if (!extMap.containsKey(dirName)) {
+			// TODO
+			errorInfo = "目录名不正确";
+		} else {
+			// .../basePath/dirName/
+			// 创建文件夹
+			savePath += dirName + "/";
+			saveUrl += dirName + "/";
+			File saveDirFile = new File(savePath);
+			if (!saveDirFile.exists()) {
+				saveDirFile.mkdirs();
+			}
+			// .../basePath/dirName/yyyyMMdd/
+			SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
+			String ymd = sdf.format(new Date());
+			savePath += ymd + "/";
+			saveUrl += ymd + "/";
+			File dirFile = new File(savePath);
+			if (!dirFile.exists()) {
+				dirFile.mkdirs();
+			}
+
+			// 获取上传临时路径
+			tempPath = request.getSession().getServletContext().getRealPath("/") + tempPath + "/";
+			File file = new File(tempPath);
+			if (!file.exists()) {
+				file.mkdirs();
+			}
+		}
+
+		return errorInfo;
+	}
+
+	/**
+	 * 处理上传内容
+	 * 
+	 * @param request
+	 * @param maxSize
+	 * @return
+	 */
+//	@SuppressWarnings("unchecked")
+	private Map<String, Object> initFields(HttpServletRequest request) {
+
+		// 存储表单字段和非表单字段
+		Map<String, Object> map = new HashMap<String, Object>();
+
+		// 第一步：判断request
+		boolean isMultipart = ServletFileUpload.isMultipartContent(request);
+		// 第二步：解析request
+		if (isMultipart) {
+			// Create a factory for disk-based file items
+			DiskFileItemFactory factory = new DiskFileItemFactory();
+
+			// 阀值,超过这个值才会写到临时目录,否则在内存中
+			factory.setSizeThreshold(1024 * 1024 * 10);
+			factory.setRepository(new File(tempPath));
+
+			// Create a new file upload handler
+			ServletFileUpload upload = new ServletFileUpload(factory);
+
+			upload.setHeaderEncoding("UTF-8");
+
+			// 最大上传限制
+			upload.setSizeMax(maxSize);
+
+			/* FileItem */
+			List<FileItem> items = null;
+			// Parse the request
+			try {
+				items = upload.parseRequest(request);
+			} catch (FileUploadException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+
+			// 第3步：处理uploaded items
+			if (items != null && items.size() > 0) {
+				Iterator<FileItem> iter = items.iterator();
+				// 文件域对象
+				List<FileItem> list = new ArrayList<FileItem>();
+				// 表单字段
+				Map<String, String> fields = new HashMap<String, String>();
+				while (iter.hasNext()) {
+					FileItem item = iter.next();
+					// 处理所有表单元素和文件域表单元素
+					if (item.isFormField()) { // 表单元素
+						String name = item.getFieldName();
+						String value = item.getString();
+						fields.put(name, value);
+					} else { // 文件域表单元素
+						list.add(item);
+					}
+				}
+				map.put(FORM_FIELDS, fields);
+				map.put(FILE_FIELDS, list);
+			}
+		}
+		return map;
+	}
+
+	/**
+	 * 保存文件
+	 * 
+	 * @param obj
+	 *            要上传的文件域
+	 * @param file
+	 * @return
+	 */
+	private String saveFile(FileItem item) {
+		String error = "true";
+		String fileName = item.getName();
+		String fileExt = fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
+
+		if (item.getSize() > maxSize) { // 检查文件大小
+			// TODO
+			error = "上传文件大小超过限制";
+		} else if (!Arrays.<String> asList(extMap.get(dirName).split(",")).contains(fileExt)) {// 检查扩展名
+			error = "上传文件扩展名是不允许的扩展名。\n只允许" + extMap.get(dirName) + "格式。";
+		} else {
+			String newFileName;
+			if ("".equals(fileName.trim())) {
+				SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");
+				newFileName = df.format(new Date()) + "_" + new Random().nextInt(1000) + "." + fileExt;
+			} else {
+				newFileName = fileName + "." + fileExt;
+			}
+			// .../basePath/dirName/yyyyMMdd/yyyyMMddHHmmss_xxx.xxx
+			fileUrl = saveUrl + newFileName;
+			try {
+				File uploadedFile = new File(savePath, newFileName);
+
+				item.write(uploadedFile);
+
+				/*
+				 * FileOutputStream fos = new FileOutputStream(uploadFile); // 文件全在内存中 if (item.isInMemory()) { fos.write(item.get()); } else { InputStream is = item.getInputStream(); byte[] buffer =
+				 * new byte[1024]; int len; while ((len = is.read(buffer)) > 0) { fos.write(buffer, 0, len); } is.close(); } fos.close(); item.delete();
+				 */
+			} catch (IOException e) {
+				e.printStackTrace();
+				System.out.println("上传失败了！！！");
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		}
+		return error;
+	}
+
+	/** **********************get/set方法********************************* */
+
+	public String getSavePath() {
+		return savePath;
+	}
+
+	public String getSaveUrl() {
+		return saveUrl;
+	}
+
+	public long getMaxSize() {
+		return maxSize;
+	}
+
+	public void setMaxSize(long maxSize) {
+		this.maxSize = maxSize;
+	}
+
+	public Map<String, String> getExtMap() {
+		return extMap;
+	}
+
+	public void setExtMap(Map<String, String> extMap) {
+		this.extMap = extMap;
+	}
+
+	public String getBasePath() {
+		return basePath;
+	}
+
+	public void setBasePath(String basePath) {
+		this.basePath = basePath;
+		tempPath = basePath + TEMP_PATH;
+	}
+
+	public String getDirName() {
+		return dirName;
+	}
+
+	public void setDirName(String dirName) {
+		this.dirName = dirName;
+	}
+
+	public String getTempPath() {
+		return tempPath;
+	}
+
+	public void setTempPath(String tempPath) {
+		this.tempPath = tempPath;
+	}
+
+	public String getFileUrl() {
+		return fileUrl;
+	}
+
+	public String getFileName() {
+		return fileName;
+	}
+
+	public void setFileName(String fileName) {
+		this.fileName = fileName;
+	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/UserAgentUtils.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils;
+
+import javax.servlet.http.HttpServletRequest;
+
+import eu.bitwalker.useragentutils.Browser;
+import eu.bitwalker.useragentutils.DeviceType;
+import eu.bitwalker.useragentutils.UserAgent;
+
+/**
+ * 用户代理字符串识别工具
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2014-6-13
+ */
+public class UserAgentUtils {
+
+	/**
+	 * 获取用户代理对象
+	 * @param request
+	 * @return
+	 */
+	public static UserAgent getUserAgent(HttpServletRequest request){
+		return UserAgent.parseUserAgentString(request.getHeader("User-Agent"));
+	}
+	
+	/**
+	 * 获取设备类型
+	 * @param request
+	 * @return
+	 */
+	public static DeviceType getDeviceType(HttpServletRequest request){
+		return getUserAgent(request).getOperatingSystem().getDeviceType();
+	}
+	
+	/**
+	 * 是否是PC
+	 * @param request
+	 * @return
+	 */
+	public static boolean isComputer(HttpServletRequest request){
+		return DeviceType.COMPUTER.equals(getDeviceType(request));
+	}
+
+	/**
+	 * 是否是手机
+	 * @param request
+	 * @return
+	 */
+	public static boolean isMobile(HttpServletRequest request){
+		return DeviceType.MOBILE.equals(getDeviceType(request));
+	}
+	
+	/**
+	 * 是否是平板
+	 * @param request
+	 * @return
+	 */
+	public static boolean isTablet(HttpServletRequest request){
+		return DeviceType.TABLET.equals(getDeviceType(request));
+	}
+
+	/**
+	 * 是否是手机和平板
+	 * @param request
+	 * @return
+	 */
+	public static boolean isMobileOrTablet(HttpServletRequest request){
+		DeviceType deviceType = getDeviceType(request);
+		return DeviceType.MOBILE.equals(deviceType) || DeviceType.TABLET.equals(deviceType);
+	}
+	
+	/**
+	 * 获取浏览类型
+	 * @param request
+	 * @return
+	 */
+	public static Browser getBrowser(HttpServletRequest request){
+		return getUserAgent(request).getBrowser();
+	}
+	
+	/**
+	 * 是否IE版本是否小于等于IE8
+	 * @param request
+	 * @return
+	 */
+	public static boolean isLteIE8(HttpServletRequest request){
+		Browser browser = getBrowser(request);
+		return Browser.IE5.equals(browser) || Browser.IE6.equals(browser)
+				|| Browser.IE7.equals(browser) || Browser.IE8.equals(browser);
+	}
+	
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/WorkDayUtils.java

+package com.jeespring.common.utils;
+
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+
+public class WorkDayUtils {
+	
+	/*public static void main(String[] args) {
+		try {
+			String strDateStart = "2013-08-01";
+			String strDateEnd = "2014-08-31";
+			
+			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+			Date date_start = sdf.parse(strDateStart);
+			Date date_end = sdf.parse(strDateEnd);
+			WorkDayUtils app = new WorkDayUtils();
+			Calendar cal_start = Calendar.getInstance();
+			Calendar cal_end = Calendar.getInstance();
+			cal_start.setTime(date_start);
+			cal_end.setTime(date_end);
+			System.out.println("开始日：" + cal_start.get(Calendar.YEAR) + "-" + (cal_start.get(Calendar.MONTH) + 1) 
+					+ "-" + cal_start.get(Calendar.DAY_OF_MONTH) + " " + app.getChineseWeek(cal_start));
+			System.out.println("结束日：" + cal_end.get(Calendar.YEAR) + "-" + (cal_end.get(Calendar.MONTH) + 1)
+					+ "-" + cal_end.get(Calendar.DAY_OF_MONTH) + " " + app.getChineseWeek(cal_end));
+			System.out.println("工作日：" + app.getWorkingDay(cal_start, cal_end));
+			System.out.println("休息日：" + app.getHolidays(cal_start, cal_end));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}*/
+
+	/**
+	 * 获取日期之间的天数
+	 * @param d1
+	 * @param d2
+	 * @return
+	 */
+	public int getDaysBetween(Calendar d1, Calendar d2) {
+		if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
+			Calendar swap = d1;
+			d1 = d2;
+			d2 = swap;
+		}
+		int days = d2.get(Calendar.DAY_OF_YEAR)
+				- d1.get(Calendar.DAY_OF_YEAR);
+		int y2 = d2.get(Calendar.YEAR);
+		if (d1.get(Calendar.YEAR) != y2) {
+			d1 = (Calendar) d1.clone();
+			do {
+				days += d1.getActualMaximum(Calendar.DAY_OF_YEAR);
+				d1.add(Calendar.YEAR, 1);
+			} while (d1.get(Calendar.YEAR) != y2);
+		}
+		return days;
+	}
+
+	/**
+	 * 获取工作日
+	 * @param d1
+	 * @param d2
+	 * @return
+	 */
+	public int getWorkingDay(Calendar d1, Calendar d2) {
+		int result = -1;
+		if (d1.after(d2)) { // swap dates so that d1 is start and d2 is end
+			Calendar swap = d1;
+			d1 = d2;
+			d2 = swap;
+		}
+		// int betweendays = getDaysBetween(d1, d2);
+		// int charge_date = 0;
+		int charge_start_date = 0;// 开始日期的日期偏移量
+		int charge_end_date = 0;// 结束日期的日期偏移量
+		// 日期不在同一个日期内
+		int stmp;
+		int etmp;
+		stmp = 7 - d1.get(Calendar.DAY_OF_WEEK);
+		etmp = 7 - d2.get(Calendar.DAY_OF_WEEK);
+		if (stmp != 0 && stmp != 6) {// 开始日期为星期六和星期日时偏移量为0
+			charge_start_date = stmp - 1;
+		}
+		if (etmp != 0 && etmp != 6) {// 结束日期为星期六和星期日时偏移量为0
+			charge_end_date = etmp - 1;
+		}
+		// }
+		result = (getDaysBetween(this.getNextMonday(d1), this.getNextMonday(d2)) / 7)
+				* 5 + charge_start_date - charge_end_date;
+		// System.out.println("charge_start_date>" + charge_start_date);
+		// System.out.println("charge_end_date>" + charge_end_date);
+		// System.out.println("between day is-->" + betweendays);
+		return result;
+	}
+
+	/**
+	 * 获取中文日期
+	 * @param date
+	 * @return
+	 */
+	public String getChineseWeek(Calendar date) {
+        final String[] dayNames = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
+		int dayOfWeek = date.get(Calendar.DAY_OF_WEEK); 
+		// System.out.println(dayNames[dayOfWeek - 1]);
+		return dayNames[dayOfWeek - 1];
+	}
+
+	/**
+	 * 获得日期的下一个星期一的日期
+	 * @param date
+	 * @return
+	 */
+	public Calendar getNextMonday(Calendar date) {
+		Calendar result = null;
+		result = date;
+		do {
+			result = (Calendar) result.clone();
+			result.add(Calendar.DATE, 1);
+		} while (result.get(Calendar.DAY_OF_WEEK) != 2);
+		return result;
+	}
+
+	/**
+	 * 获取休息日
+	 * @param d1
+	 * @param d2
+	 * @return
+	 */
+	public int getHolidays(Calendar d1, Calendar d2) {
+		return this.getDaysBetween(d1, d2) - this.getWorkingDay(d1, d2);
+	}
+	
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/ZxingHandler.java

+package com.jeespring.common.utils;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.util.Hashtable;
+
+import javax.imageio.ImageIO;
+
+import com.google.zxing.BarcodeFormat;
+import com.google.zxing.BinaryBitmap;
+import com.google.zxing.DecodeHintType;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.LuminanceSource;
+import com.google.zxing.MultiFormatReader;
+import com.google.zxing.MultiFormatWriter;
+import com.google.zxing.Result;
+import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
+import com.google.zxing.client.j2se.MatrixToImageWriter;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.common.HybridBinarizer;
+import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel;
+
+/**
+ * 条形码和二维码编码解码
+ * 
+ * @author JeeSpring
+ * @version 2014-02-28
+ */
+public class ZxingHandler {
+
+	/**
+	 * 条形码编码
+	 * 
+	 * @param contents
+	 * @param width
+	 * @param height
+	 * @param imgPath
+	 */
+	public static void encode(String contents, int width, int height, String imgPath) {
+		int codeWidth = 3 + // start guard
+				(7 * 6) + // left bars
+				5 + // middle guard
+				(7 * 6) + // right bars
+				3; // end guard
+		codeWidth = Math.max(codeWidth, width);
+		try {
+			BitMatrix bitMatrix = new MultiFormatWriter().encode(contents,
+					BarcodeFormat.EAN_13, codeWidth, height, null);
+
+			MatrixToImageWriter
+					.writeToFile(bitMatrix, "png", new File(imgPath));
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * 条形码解码
+	 * 
+	 * @param imgPath
+	 * @return String
+	 */
+	public static String decode(String imgPath) {
+		BufferedImage image = null;
+		Result result = null;
+		try {
+			image = ImageIO.read(new File(imgPath));
+			if (image == null) {
+				System.out.println("the decode image may be not exit.");
+			}
+			LuminanceSource source = new BufferedImageLuminanceSource(image);
+			BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
+
+			result = new MultiFormatReader().decode(bitmap, null);
+			return result.getText();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	/**
+	 * 二维码编码
+	 * 
+	 * @param contents
+	 * @param width
+	 * @param height
+	 * @param imgPath
+	 */
+	public static void encode2(String contents, int width, int height, String imgPath) {
+		Hashtable<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
+		// 指定纠错等级
+		hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L);
+		// 指定编码格式
+		hints.put(EncodeHintType.CHARACTER_SET, "GBK");
+		try {
+			BitMatrix bitMatrix = new MultiFormatWriter().encode(contents,
+					BarcodeFormat.QR_CODE, width, height, hints);
+
+			MatrixToImageWriter
+					.writeToFile(bitMatrix, "png", new File(imgPath));
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	/**
+	 * 二维码解码
+	 * 
+	 * @param imgPath
+	 * @return String
+	 */
+	public static String decode2(String imgPath) {
+		BufferedImage image = null;
+		Result result = null;
+		try {
+			image = ImageIO.read(new File(imgPath));
+			if (image == null) {
+				System.out.println("the decode image may be not exit.");
+			}
+			LuminanceSource source = new BufferedImageLuminanceSource(image);
+			BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));
+
+			Hashtable<DecodeHintType, Object> hints = new Hashtable<DecodeHintType, Object>();
+			hints.put(DecodeHintType.CHARACTER_SET, "GBK");
+
+			result = new MultiFormatReader().decode(bitmap, hints);
+			return result.getText();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	/**
+	 * @param args
+	 */
+	/*public static void main(String[] args) {
+
+		// 条形码
+		String imgPath = "target\\zxing_EAN13.png";
+		String contents = "6923450657713";
+		int width = 105, height = 50;
+		
+		ZxingHandler.encode(contents, width, height, imgPath);
+		System.out.println("finished zxing EAN-13 encode.");
+
+		String decodeContent = ZxingHandler.decode(imgPath);
+		System.out.println("解码内容如下：" + decodeContent);
+		System.out.println("finished zxing EAN-13 decode.");
+		
+		// 二维码
+		String imgPath2 = "target\\zxing.png";
+		String contents2 = "Hello Gem, welcome to Zxing!"
+				+ "\nBlog [ http://thinkgem.iteye.com ]"
+				+ "\nEMail [ thinkgem@163.com ]";
+		int width2 = 300, height2 = 300;
+
+		ZxingHandler.encode2(contents2, width2, height2, imgPath2);
+		System.out.println("finished zxing encode.");
+
+		String decodeContent2 = ZxingHandler.decode2(imgPath2);
+		System.out.println("解码内容如下：" + decodeContent2);
+		System.out.println("finished zxing decode.");
+		
+	}*/
+    
+}
\ No newline at end of file

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/bean/BeanUtils.java

+package com.jeespring.common.utils.bean;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Bean 工具类
+ * 
+ * @author JeeSpring
+ */
+public class BeanUtils
+{
+    /** Bean方法名中属性名开始的下标 */
+    private static final int BEAN_METHOD_PROP_INDEX = 3;
+
+    /** * 匹配getter方法的正则表达式 */
+    private static final Pattern GET_PATTERN = Pattern.compile("get(\\p{javaUpperCase}\\w*)");
+
+    /** * 匹配setter方法的正则表达式 */
+    private static final Pattern SET_PATTERN = Pattern.compile("set(\\p{javaUpperCase}\\w*)");
+
+    /**
+     * Bean属性复制工具方法。
+     * 
+     * @param dest 目标对象
+     * @param src 源对象
+     */
+    public static void copyBeanProp(Object dest, Object src)
+    {
+        List<Method> destSetters = getSetterMethods(dest);
+        List<Method> srcGetters = getGetterMethods(src);
+        try
+        {
+            for (Method setter : destSetters)
+            {
+                for (Method getter : srcGetters)
+                {
+                    if (isMethodPropEquals(setter.getName(), getter.getName())
+                            && setter.getParameterTypes()[0].equals(getter.getReturnType()))
+                    {
+                        setter.invoke(dest, getter.invoke(src));
+                    }
+                }
+            }
+        }
+        catch (Exception e)
+        {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * 获取对象的setter方法。
+     * 
+     * @param obj 对象
+     * @return 对象的setter方法列表
+     */
+    public static List<Method> getSetterMethods(Object obj)
+    {
+        // setter方法列表
+        List<Method> setterMethods = new ArrayList<Method>();
+
+        // 获取所有方法
+        Method[] methods = obj.getClass().getMethods();
+
+        // 查找setter方法
+
+        for (Method method : methods)
+        {
+            Matcher m = SET_PATTERN.matcher(method.getName());
+            if (m.matches() && (method.getParameterTypes().length == 1))
+            {
+                setterMethods.add(method);
+            }
+        }
+        // 返回setter方法列表
+        return setterMethods;
+    }
+
+    /**
+     * 获取对象的getter方法。
+     * 
+     * @param obj 对象
+     * @return 对象的getter方法列表
+     */
+
+    public static List<Method> getGetterMethods(Object obj)
+    {
+        // getter方法列表
+        List<Method> getterMethods = new ArrayList<Method>();
+        // 获取所有方法
+        Method[] methods = obj.getClass().getMethods();
+        // 查找getter方法
+        for (Method method : methods)
+        {
+            Matcher m = GET_PATTERN.matcher(method.getName());
+            if (m.matches() && (method.getParameterTypes().length == 0))
+            {
+                getterMethods.add(method);
+            }
+        }
+        // 返回getter方法列表
+        return getterMethods;
+    }
+
+    /**
+     * 检查Bean方法名中的属性名是否相等。<br>
+     * 如getName()和setName()属性名一样，getName()和setAge()属性名不一样。
+     * 
+     * @param m1 方法名1
+     * @param m2 方法名2
+     * @return 属性名一样返回true，否则返回false
+     */
+
+    public static boolean isMethodPropEquals(String m1, String m2)
+    {
+        return m1.substring(BEAN_METHOD_PROP_INDEX).equals(m2.substring(BEAN_METHOD_PROP_INDEX));
+    }
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/ExportExcel.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel;
+
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.Comment;
+import org.apache.poi.ss.usermodel.Font;
+import org.apache.poi.ss.usermodel.IndexedColors;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.streaming.SXSSFWorkbook;
+import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
+import org.apache.poi.xssf.usermodel.XSSFRichTextString;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.collect.Lists;
+import com.jeespring.common.utils.Encodes;
+import com.jeespring.common.utils.Reflections;
+import com.jeespring.common.utils.excel.annotation.ExcelField;
+import com.jeespring.modules.sys.utils.DictUtils;
+
+/**
+ * 导出Excel文件（导出“XLSX”格式，支持大数据量导出   @see org.apache.poi.ss.SpreadsheetVersion）
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-04-21
+ */
+public class ExportExcel {
+	
+	private static Logger log = LoggerFactory.getLogger(ExportExcel.class);
+			
+	/**
+	 * 工作薄对象
+	 */
+	private SXSSFWorkbook wb;
+	
+	/**
+	 * 工作表对象
+	 */
+	private Sheet sheet;
+	
+	/**
+	 * 样式列表
+	 */
+	private Map<String, CellStyle> styles;
+	
+	/**
+	 * 当前行号
+	 */
+	private int rownum;
+	
+	/**
+	 * 注解列表（Object[]{ ExcelField, Field/Method }）
+	 */
+	List<Object[]> annotationList = Lists.newArrayList();
+	
+	/**
+	 * 构造函数
+	 * @param title 表格标题，传“空值”，表示无标题
+	 * @param cls 实体对象，通过annotation.ExportField获取标题
+	 */
+	public ExportExcel(String title, Class<?> cls){
+		this(title, cls, 1);
+	}
+	
+	/**
+	 * 构造函数
+	 * @param title 表格标题，传“空值”，表示无标题
+	 * @param cls 实体对象，通过annotation.ExportField获取标题
+	 * @param type 导出类型（1:导出数据；2：导出模板）
+	 * @param groups 导入分组
+	 */
+	public ExportExcel(String title, Class<?> cls, int type, int... groups){
+		// Get annotation field 
+		Field[] fs = cls.getDeclaredFields();
+		for (Field f : fs){
+			ExcelField ef = f.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==type)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, f});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, f});
+				}
+			}
+		}
+		// Get annotation method
+		Method[] ms = cls.getDeclaredMethods();
+		for (Method m : ms){
+			ExcelField ef = m.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==type)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, m});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, m});
+				}
+			}
+		}
+		// Field sorting
+		Collections.sort(annotationList, new Comparator<Object[]>() {
+			@Override
+			public int compare(Object[] o1, Object[] o2) {
+				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
+						new Integer(((ExcelField)o2[0]).sort()));
+			};
+		});
+		// Initialize
+		List<String> headerList = Lists.newArrayList();
+		for (Object[] os : annotationList){
+			String t = ((ExcelField)os[0]).title();
+			// 如果是导出，则去掉注释
+			if (type==1){
+				String[] ss = StringUtils.split(t, "**", 2);
+				if (ss.length==2){
+					t = ss[0];
+				}
+			}
+			headerList.add(t);
+		}
+		initialize(title, headerList);
+	}
+	
+	/**
+	 * 构造函数
+	 * @param title 表格标题，传“空值”，表示无标题
+	 * @param headers 表头数组
+	 */
+	public ExportExcel(String title, String[] headers) {
+		initialize(title, Lists.newArrayList(headers));
+	}
+	
+	/**
+	 * 构造函数
+	 * @param title 表格标题，传“空值”，表示无标题
+	 * @param headerList 表头列表
+	 */
+	public ExportExcel(String title, List<String> headerList) {
+		initialize(title, headerList);
+	}
+	
+	/**
+	 * 初始化函数
+	 * @param title 表格标题，传“空值”，表示无标题
+	 * @param headerList 表头列表
+	 */
+	private void initialize(String title, List<String> headerList) {
+		this.wb = new SXSSFWorkbook(500);
+		this.sheet = wb.createSheet("Export");
+		this.styles = createStyles(wb);
+		// Create title
+		if (StringUtils.isNotBlank(title)){
+			Row titleRow = sheet.createRow(rownum++);
+			titleRow.setHeightInPoints(30);
+			Cell titleCell = titleRow.createCell(0);
+			titleCell.setCellStyle(styles.get("title"));
+			titleCell.setCellValue(title);
+			sheet.addMergedRegion(new CellRangeAddress(titleRow.getRowNum(),
+					titleRow.getRowNum(), titleRow.getRowNum(), headerList.size()-1));
+		}
+		// Create header
+		if (headerList == null){
+			throw new RuntimeException("headerList not null!");
+		}
+		Row headerRow = sheet.createRow(rownum++);
+		headerRow.setHeightInPoints(16);
+		for (int i = 0; i < headerList.size(); i++) {
+			Cell cell = headerRow.createCell(i);
+			cell.setCellStyle(styles.get("header"));
+			String[] ss = StringUtils.split(headerList.get(i), "**", 2);
+			if (ss.length==2){
+				cell.setCellValue(ss[0]);
+				Comment comment = this.sheet.createDrawingPatriarch().createCellComment(
+						new XSSFClientAnchor(0, 0, 0, 0, (short) 3, 3, (short) 5, 6));
+				comment.setString(new XSSFRichTextString(ss[1]));
+				cell.setCellComment(comment);
+			}else{
+				cell.setCellValue(headerList.get(i));
+			}
+			sheet.autoSizeColumn(i);
+		}
+		for (int i = 0; i < headerList.size(); i++) {  
+			int colWidth = sheet.getColumnWidth(i)*2;
+	        sheet.setColumnWidth(i, colWidth < 3000 ? 3000 : colWidth);  
+		}
+		log.debug("Initialize success.");
+	}
+	
+	/**
+	 * 创建表格样式
+	 * @param wb 工作薄对象
+	 * @return 样式列表
+	 */
+	private Map<String, CellStyle> createStyles(Workbook wb) {
+		Map<String, CellStyle> styles = new HashMap<String, CellStyle>();
+		
+		CellStyle style = wb.createCellStyle();
+		style.setAlignment(CellStyle.ALIGN_CENTER);
+		style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
+		Font titleFont = wb.createFont();
+		titleFont.setFontName("Arial");
+		titleFont.setFontHeightInPoints((short) 16);
+		titleFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
+		style.setFont(titleFont);
+		styles.put("title", style);
+
+		style = wb.createCellStyle();
+		style.setVerticalAlignment(CellStyle.VERTICAL_CENTER);
+		style.setBorderRight(CellStyle.BORDER_THIN);
+		style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+		style.setBorderLeft(CellStyle.BORDER_THIN);
+		style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+		style.setBorderTop(CellStyle.BORDER_THIN);
+		style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+		style.setBorderBottom(CellStyle.BORDER_THIN);
+		style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.getIndex());
+		Font dataFont = wb.createFont();
+		dataFont.setFontName("Arial");
+		dataFont.setFontHeightInPoints((short) 10);
+		style.setFont(dataFont);
+		styles.put("data", style);
+		
+		style = wb.createCellStyle();
+		style.cloneStyleFrom(styles.get("data"));
+		style.setAlignment(CellStyle.ALIGN_LEFT);
+		styles.put("data1", style);
+
+		style = wb.createCellStyle();
+		style.cloneStyleFrom(styles.get("data"));
+		style.setAlignment(CellStyle.ALIGN_CENTER);
+		styles.put("data2", style);
+
+		style = wb.createCellStyle();
+		style.cloneStyleFrom(styles.get("data"));
+		style.setAlignment(CellStyle.ALIGN_RIGHT);
+		styles.put("data3", style);
+		
+		style = wb.createCellStyle();
+		style.cloneStyleFrom(styles.get("data"));
+//		style.setWrapText(true);
+		style.setAlignment(CellStyle.ALIGN_CENTER);
+		style.setFillForegroundColor(IndexedColors.GREY_50_PERCENT.getIndex());
+		style.setFillPattern(CellStyle.SOLID_FOREGROUND);
+		Font headerFont = wb.createFont();
+		headerFont.setFontName("Arial");
+		headerFont.setFontHeightInPoints((short) 10);
+		headerFont.setBoldweight(Font.BOLDWEIGHT_BOLD);
+		headerFont.setColor(IndexedColors.WHITE.getIndex());
+		style.setFont(headerFont);
+		styles.put("header", style);
+		
+		return styles;
+	}
+
+	/**
+	 * 添加一行
+	 * @return 行对象
+	 */
+	public Row addRow(){
+		return sheet.createRow(rownum++);
+	}
+	
+
+	/**
+	 * 添加一个单元格
+	 * @param row 添加的行
+	 * @param column 添加列号
+	 * @param val 添加值
+	 * @return 单元格对象
+	 */
+	public Cell addCell(Row row, int column, Object val){
+		return this.addCell(row, column, val, 0, Class.class);
+	}
+	
+	/**
+	 * 添加一个单元格
+	 * @param row 添加的行
+	 * @param column 添加列号
+	 * @param val 添加值
+	 * @param align 对齐方式（1：靠左；2：居中；3：靠右）
+	 * @return 单元格对象
+	 */
+	public Cell addCell(Row row, int column, Object val, int align, Class<?> fieldType){
+		Cell cell = row.createCell(column);
+		String cellFormatString = "@";
+		try {
+			if(val == null){
+				cell.setCellValue("");
+			}else if(fieldType != Class.class){
+				cell.setCellValue((String)fieldType.getMethod("setValue", Object.class).invoke(null, val));
+			}else{
+				if(val instanceof String) {
+					cell.setCellValue((String) val);
+				}else if(val instanceof Integer) {
+					cell.setCellValue((Integer) val);
+					cellFormatString = "0";
+				}else if(val instanceof Long) {
+					cell.setCellValue((Long) val);
+					cellFormatString = "0";
+				}else if(val instanceof Double) {
+					cell.setCellValue((Double) val);
+					cellFormatString = "0.00";
+				}else if(val instanceof Float) {
+					cell.setCellValue((Float) val);
+					cellFormatString = "0.00";
+				}else if(val instanceof Date) {
+					cell.setCellValue((Date) val);
+					cellFormatString = "yyyy-MM-dd HH:mm";
+				}else {
+					cell.setCellValue((String)Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(), 
+						"fieldtype."+val.getClass().getSimpleName()+"Type")).getMethod("setValue", Object.class).invoke(null, val));
+				}
+			}
+			if (val != null){
+				CellStyle style = styles.get("data_column_"+column);
+				if (style == null){
+					style = wb.createCellStyle();
+					style.cloneStyleFrom(styles.get("data"+(align>=1&&align<=3?align:"")));
+			        style.setDataFormat(wb.createDataFormat().getFormat(cellFormatString));
+					styles.put("data_column_" + column, style);
+				}
+				cell.setCellStyle(style);
+			}
+		} catch (Exception ex) {
+			log.info("Set cell value ["+row.getRowNum()+","+column+"] error: " + ex.toString());
+			cell.setCellValue(val.toString());
+		}
+		return cell;
+	}
+
+	/**
+	 * 添加数据（通过annotation.ExportField添加数据）
+	 * @return list 数据列表
+	 */
+	public <E> ExportExcel setDataList(List<E> list){
+		for (E e : list){
+			int colunm = 0;
+			Row row = this.addRow();
+			StringBuilder sb = new StringBuilder();
+			for (Object[] os : annotationList){
+				ExcelField ef = (ExcelField)os[0];
+				Object val = null;
+				// Get entity value
+				try{
+					if (StringUtils.isNotBlank(ef.value())){
+						val = Reflections.invokeGetter(e, ef.value());
+					}else{
+						if (os[1] instanceof Field){
+							val = Reflections.invokeGetter(e, ((Field)os[1]).getName());
+						}else if (os[1] instanceof Method){
+							val = Reflections.invokeMethod(e, ((Method)os[1]).getName(), new Class[] {}, new Object[] {});
+						}
+					}
+					// If is dict, get dict label
+					if (StringUtils.isNotBlank(ef.dictType())){
+						val = DictUtils.getDictLabel(val==null?"":val.toString(), ef.dictType(), "");
+					}
+				}catch(Exception ex) {
+					// Failure to ignore
+					log.info(ex.toString());
+					val = "";
+				}
+				this.addCell(row, colunm++, val, ef.align(), ef.fieldType());
+				sb.append(val + ", ");
+			}
+			log.debug("Write success: ["+row.getRowNum()+"] "+sb.toString());
+		}
+		return this;
+	}
+	
+	/**
+	 * 输出数据流
+	 * @param os 输出数据流
+	 */
+	public ExportExcel write(OutputStream os) throws IOException{
+		wb.write(os);
+		return this;
+	}
+	
+	/**
+	 * 输出到客户端
+	 * @param fileName 输出文件名
+	 */
+	public ExportExcel write(HttpServletResponse response, String fileName) throws IOException{
+		response.reset();
+        response.setContentType("application/octet-stream; charset=utf-8");
+        response.setHeader("Content-Disposition", "attachment; filename="+Encodes.urlEncode(fileName));
+		write(response.getOutputStream());
+		return this;
+	}
+	
+	/**
+	 * 输出到文件
+	 * @param fileName 输出文件名
+	 */
+	public ExportExcel writeFile(String name) throws FileNotFoundException, IOException{
+		FileOutputStream os = new FileOutputStream(name);
+		this.write(os);
+		return this;
+	}
+	
+	/**
+	 * 清理临时文件
+	 */
+	public ExportExcel dispose(){
+		wb.dispose();
+		return this;
+	}
+	
+//	/**
+//	 * 导出测试
+//	 */
+//	public static void main(String[] args) throws Throwable {
+//		
+//		List<String> headerList = Lists.newArrayList();
+//		for (int i = 1; i <= 10; i++) {
+//			headerList.add("表头"+i);
+//		}
+//		
+//		List<String> dataRowList = Lists.newArrayList();
+//		for (int i = 1; i <= headerList.size(); i++) {
+//			dataRowList.add("数据"+i);
+//		}
+//		
+//		List<List<String>> dataList = Lists.newArrayList();
+//		for (int i = 1; i <=1000000; i++) {
+//			dataList.add(dataRowList);
+//		}
+//
+//		ExportExcel ee = new ExportExcel("表格标题", headerList);
+//		
+//		for (int i = 0; i < dataList.size(); i++) {
+//			Row row = ee.addRow();
+//			for (int j = 0; j < dataList.get(i).size(); j++) {
+//				ee.addCell(row, j, dataList.get(i).get(j));
+//			}
+//		}
+//		
+//		ee.writeFile("target/export.xlsx");
+//
+//		ee.dispose();
+//		
+//		log.debug("Export success.");
+//		
+//	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/ImportExcel.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.poi.hssf.usermodel.HSSFWorkbook;
+import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.DateUtil;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.xssf.usermodel.XSSFWorkbook;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.google.common.collect.Lists;
+import com.jeespring.common.utils.Reflections;
+import com.jeespring.common.utils.excel.annotation.ExcelField;
+import com.jeespring.modules.sys.utils.DictUtils;
+
+/**
+ * 导入Excel文件（支持“XLS”和“XLSX”格式）
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-03-10
+ */
+public class ImportExcel {
+	
+	private static Logger log = LoggerFactory.getLogger(ImportExcel.class);
+			
+	/**
+	 * 工作薄对象
+	 */
+	private Workbook wb;
+	
+	/**
+	 * 工作表对象
+	 */
+	private Sheet sheet;
+	
+	/**
+	 * 标题行号
+	 */
+	private int headerNum;
+	
+	/**
+	 * 构造函数
+	 * @param path 导入文件，读取第一个工作表
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(String fileName, int headerNum) 
+			throws InvalidFormatException, IOException {
+		this(new File(fileName), headerNum);
+	}
+	
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象，读取第一个工作表
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(File file, int headerNum) 
+			throws InvalidFormatException, IOException {
+		this(file, headerNum, 0);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(String fileName, int headerNum, int sheetIndex) 
+			throws InvalidFormatException, IOException {
+		this(new File(fileName), headerNum, sheetIndex);
+	}
+	
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(File file, int headerNum, int sheetIndex) 
+			throws InvalidFormatException, IOException {
+		this(file.getName(), new FileInputStream(file), headerNum, sheetIndex);
+	}
+	
+	/**
+	 * 构造函数
+	 * @param file 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(MultipartFile multipartFile, int headerNum, int sheetIndex) 
+			throws InvalidFormatException, IOException {
+		this(multipartFile.getOriginalFilename(), multipartFile.getInputStream(), headerNum, sheetIndex);
+	}
+
+	/**
+	 * 构造函数
+	 * @param path 导入文件对象
+	 * @param headerNum 标题行号，数据行号=标题行号+1
+	 * @param sheetIndex 工作表编号
+	 * @throws InvalidFormatException 
+	 * @throws IOException 
+	 */
+	public ImportExcel(String fileName, InputStream is, int headerNum, int sheetIndex) 
+			throws InvalidFormatException, IOException {
+		if (StringUtils.isBlank(fileName)){
+			throw new RuntimeException("导入文档为空!");
+		}else if(fileName.toLowerCase().endsWith("xls")){    
+			this.wb = new HSSFWorkbook(is);    
+        }else if(fileName.toLowerCase().endsWith("xlsx")){  
+        	this.wb = new XSSFWorkbook(is);
+        }else{  
+        	throw new RuntimeException("文档格式不正确!");
+        }  
+		if (this.wb.getNumberOfSheets()<sheetIndex){
+			throw new RuntimeException("文档中没有工作表!");
+		}
+		this.sheet = this.wb.getSheetAt(sheetIndex);
+		this.headerNum = headerNum;
+		log.debug("Initialize success.");
+	}
+	
+	/**
+	 * 获取行对象
+	 * @param rownum
+	 * @return
+	 */
+	public Row getRow(int rownum){
+		return this.sheet.getRow(rownum);
+	}
+
+	/**
+	 * 获取数据行号
+	 * @return
+	 */
+	public int getDataRowNum(){
+		return headerNum+1;
+	}
+	
+	/**
+	 * 获取最后一个数据行号
+	 * @return
+	 */
+	public int getLastDataRowNum(){
+		return this.sheet.getLastRowNum()+headerNum;
+	}
+	
+	/**
+	 * 获取最后一个列号
+	 * @return
+	 */
+	public int getLastCellNum(){
+		return this.getRow(headerNum).getLastCellNum();
+	}
+	
+	/**
+	 * 获取单元格值
+	 * @param row 获取的行
+	 * @param column 获取单元格列号
+	 * @return 单元格值
+	 */
+	public Object getCellValue(Row row, int column){
+		Object val = "";
+		try{
+			Cell cell = row.getCell(column);
+			if (cell != null){
+				if (cell.getCellType() == Cell.CELL_TYPE_NUMERIC){
+					val = cell.getNumericCellValue();
+				}else if (cell.getCellType() == Cell.CELL_TYPE_STRING){
+					val = cell.getStringCellValue();
+				}else if (cell.getCellType() == Cell.CELL_TYPE_FORMULA){
+					val = cell.getCellFormula();
+				}else if (cell.getCellType() == Cell.CELL_TYPE_BOOLEAN){
+					val = cell.getBooleanCellValue();
+				}else if (cell.getCellType() == Cell.CELL_TYPE_ERROR){
+					val = cell.getErrorCellValue();
+				}
+			}
+		}catch (Exception e) {
+			return val;
+		}
+		return val;
+	}
+	
+	/**
+	 * 获取导入数据列表
+	 * @param cls 导入对象类型
+	 * @param groups 导入分组
+	 */
+	public <E> List<E> getDataList(Class<E> cls, int... groups) throws InstantiationException, IllegalAccessException{
+		List<Object[]> annotationList = Lists.newArrayList();
+		// Get annotation field 
+		Field[] fs = cls.getDeclaredFields();
+		for (Field f : fs){
+			ExcelField ef = f.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==2)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, f});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, f});
+				}
+			}
+		}
+		// Get annotation method
+		Method[] ms = cls.getDeclaredMethods();
+		for (Method m : ms){
+			ExcelField ef = m.getAnnotation(ExcelField.class);
+			if (ef != null && (ef.type()==0 || ef.type()==2)){
+				if (groups!=null && groups.length>0){
+					boolean inGroup = false;
+					for (int g : groups){
+						if (inGroup){
+							break;
+						}
+						for (int efg : ef.groups()){
+							if (g == efg){
+								inGroup = true;
+								annotationList.add(new Object[]{ef, m});
+								break;
+							}
+						}
+					}
+				}else{
+					annotationList.add(new Object[]{ef, m});
+				}
+			}
+		}
+		// Field sorting
+		Collections.sort(annotationList, new Comparator<Object[]>() {
+			@Override
+			public int compare(Object[] o1, Object[] o2) {
+				return new Integer(((ExcelField)o1[0]).sort()).compareTo(
+						new Integer(((ExcelField)o2[0]).sort()));
+			};
+		});
+		//log.debug("Import column count:"+annotationList.size());
+		// Get excel data
+		List<E> dataList = Lists.newArrayList();
+		for (int i = this.getDataRowNum(); i < this.getLastDataRowNum(); i++) {
+			E e = cls.newInstance();
+			int column = 0;
+			Row row = this.getRow(i);
+			StringBuilder sb = new StringBuilder();
+			for (Object[] os : annotationList){
+				Object val = this.getCellValue(row, column++);
+				if (val != null){
+					ExcelField ef = (ExcelField)os[0];
+					// If is dict type, get dict value
+					if (StringUtils.isNotBlank(ef.dictType())){
+						val = DictUtils.getDictValue(val.toString(), ef.dictType(), "");
+						//log.debug("Dictionary type value: ["+i+","+colunm+"] " + val);
+					}
+					// Get param type and type cast
+					Class<?> valType = Class.class;
+					if (os[1] instanceof Field){
+						valType = ((Field)os[1]).getType();
+					}else if (os[1] instanceof Method){
+						Method method = ((Method)os[1]);
+						if ("get".equals(method.getName().substring(0, 3))){
+							valType = method.getReturnType();
+						}else if("set".equals(method.getName().substring(0, 3))){
+							valType = ((Method)os[1]).getParameterTypes()[0];
+						}
+					}
+					//log.debug("Import value type: ["+i+","+column+"] " + valType);
+					try {
+						if (valType == String.class){
+							String s = String.valueOf(val.toString());
+							if(StringUtils.endsWith(s, ".0")){
+								val = StringUtils.substringBefore(s, ".0");
+							}else{
+								val = String.valueOf(val.toString());
+							}
+						}else if (valType == Integer.class){
+							val = Double.valueOf(val.toString()).intValue();
+						}else if (valType == Long.class){
+							val = Double.valueOf(val.toString()).longValue();
+						}else if (valType == Double.class){
+							val = Double.valueOf(val.toString());
+						}else if (valType == Float.class){
+							val = Float.valueOf(val.toString());
+						}else if (valType == Date.class){
+							val = DateUtil.getJavaDate((Double)val);
+						}else{
+							if (ef.fieldType() != Class.class){
+								val = ef.fieldType().getMethod("getValue", String.class).invoke(null, val.toString());
+							}else{
+								val = Class.forName(this.getClass().getName().replaceAll(this.getClass().getSimpleName(), 
+										"fieldtype."+valType.getSimpleName()+"Type")).getMethod("getValue", String.class).invoke(null, val.toString());
+							}
+						}
+					} catch (Exception ex) {
+						log.info("Get cell value ["+i+","+column+"] error: " + ex.toString());
+						val = null;
+					}
+					// set entity value
+					if (os[1] instanceof Field){
+						Reflections.invokeSetter(e, ((Field)os[1]).getName(), val);
+					}else if (os[1] instanceof Method){
+						String mthodName = ((Method)os[1]).getName();
+						if ("get".equals(mthodName.substring(0, 3))){
+							mthodName = "set"+StringUtils.substringAfter(mthodName, "get");
+						}
+						Reflections.invokeMethod(e, mthodName, new Class[] {valType}, new Object[] {val});
+					}
+				}
+				sb.append(val+", ");
+			}
+			dataList.add(e);
+			log.debug("Read success: ["+i+"] "+sb.toString());
+		}
+		return dataList;
+	}
+
+//	/**
+//	 * 导入测试
+//	 */
+//	public static void main(String[] args) throws Throwable {
+//		
+//		ImportExcel ei = new ImportExcel("target/export.xlsx", 1);
+//		
+//		for (int i = ei.getDataRowNum(); i < ei.getLastDataRowNum(); i++) {
+//			Row row = ei.getRow(i);
+//			for (int j = 0; j < ei.getLastCellNum(); j++) {
+//				Object val = ei.getCellValue(row, j);
+//				System.out.print(val+", ");
+//			}
+//			System.out.print("\n");
+//		}
+//		
+//	}
+
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/annotation/ExcelField.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Excel注解定义
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-03-10
+ */
+@Target({ElementType.METHOD, ElementType.FIELD, ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ExcelField {
+
+	/**
+	 * 导出字段名（默认调用当前字段的“get”方法，如指定导出字段为对象，请填写“对象名.对象属性”，例：“area.name”、“office.name”）
+	 */
+	String value() default "";
+	
+	/**
+	 * 导出字段标题（需要添加批注请用“**”分隔，标题**批注，仅对导出模板有效）
+	 */
+	String title();
+	
+	/**
+	 * 字段类型（0：导出导入；1：仅导出；2：仅导入）
+	 */
+	int type() default 0;
+
+	/**
+	 * 导出字段对齐方式（0：自动；1：靠左；2：居中；3：靠右）
+	 */
+	int align() default 0;
+	
+	/**
+	 * 导出字段字段排序（升序）
+	 */
+	int sort() default 0;
+
+	/**
+	 * 如果是字典类型，请设置字典的type值
+	 */
+	String dictType() default "";
+	
+	/**
+	 * 反射类型
+	 */
+	Class<?> fieldType() default Class.class;
+	
+	/**
+	 * 字段归属组（根据分组导出导入）
+	 */
+	int[] groups() default {};
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/fieldtype/AreaType.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel.fieldtype;
+
+import com.jeespring.common.utils.StringUtils;
+import com.jeespring.modules.sys.entity.Area;
+import com.jeespring.modules.sys.utils.UserUtils;
+
+/**
+ * 字段类型转换
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-03-10
+ */
+public class AreaType {
+
+	/**
+	 * 获取对象值（导入）
+	 */
+	public static Object getValue(String val) {
+		for (Area e : UserUtils.getAreaList()){
+			if (StringUtils.trimToEmpty(val).equals(e.getName())){
+				return e;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * 获取对象值（导出）
+	 */
+	public static String setValue(Object val) {
+		if (val != null && ((Area)val).getName() != null){
+			return ((Area)val).getName();
+		}
+		return "";
+	}
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/fieldtype/OfficeType.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel.fieldtype;
+
+import com.jeespring.common.utils.StringUtils;
+import com.jeespring.modules.sys.entity.Office;
+import com.jeespring.modules.sys.utils.UserUtils;
+
+/**
+ * 字段类型转换
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-03-10
+ */
+public class OfficeType {
+
+	/**
+	 * 获取对象值（导入）
+	 */
+	public static Object getValue(String val) {
+		for (Office e : UserUtils.getOfficeList()){
+			if (StringUtils.trimToEmpty(val).equals(e.getName())){
+				return e;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * 设置对象值（导出）
+	 */
+	public static String setValue(Object val) {
+		if (val != null && ((Office)val).getName() != null){
+			return ((Office)val).getName();
+		}
+		return "";
+	}
+}

JeeSpringCloud/jeespring-framework/src/main/java/com/jeespring/common/utils/excel/fieldtype/RoleListType.java

+/**
+ * Copyright &copy; 2012-2016 <a href="https://github.com/HuangBingGui/jeespring">jeespring</a> All rights reserved.
+ */
+package com.jeespring.common.utils.excel.fieldtype;
+
+import java.util.List;
+
+import com.google.common.collect.Lists;
+import com.jeespring.common.utils.Collections3;
+import com.jeespring.common.utils.SpringContextHolder;
+import com.jeespring.common.utils.StringUtils;
+import com.jeespring.modules.sys.entity.Role;
+import com.jeespring.modules.sys.service.SystemService;
+
+/**
+ * 字段类型转换
+ * @author 黄炳桂 516821420@qq.com
+ * @version 2013-5-29
+ */
+public class RoleListType {
+
+	private static SystemService systemService = SpringContextHolder.getBean(SystemService.class);
+	
+	/**
+	 * 获取对象值（导入）
+	 */
+	public static Object getValue(String val) {
+		List<Role> roleList = Lists.newArrayList();
+		List<Role> allRoleList = systemService.findAllRole();
+		for (String s : StringUtils.split(val, ",")){
+			for (Role e : allRoleList){
+				if (StringUtils.trimToEmpty(s).equals(e.getName())){
+					roleList.add(e);
+				}
+			}
+		}
+		return roleList.size()>0?roleList:null;
+	}
+
+	/**
+	 * 设置对象值（导出）
+	 */
+	public static String setValue(Object val) {
+		if (val != null){
+			@SuppressWarnings("unchecked")
+			List<Role> roleList = (List<Role>)val;
+			return Collections3.extractToString(roleList, "name", ", ");
+		}
+		return "";
+	}
+	
+}