锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
* Excel WorkBook瀵硅薄綾?
* @author zhouqian
*
*/
public class ExcelWorkBook {
/** 宸ヤ綔綈?*/
private static HSSFWorkbook workbook = new HSSFWorkbook();
/** 宸ヤ綔琛?*/
private HSSFSheet sheet;
/** 琛ㄥご鏁版嵁 */
private String[] tableHeader;
/**
* 鏋勯犲嚱鏁?br />
* @param workbookName 宸ヤ綔琛ㄥ悕
* @param tableHeader 琛ㄥご鏁版嵁
*/
public ExcelWorkBook(String workbookName, String[] tableHeader) {
super();
this.tableHeader = tableHeader;
sheet = workbook.createSheet(workbookName);
}
/**
* 鍒涘緩琛ㄥご
* @param headerName
*/
public void createTableHeader(String headerName) {
HSSFHeader header = sheet.getHeader();
header.setCenter(headerName);
HSSFRow headerRow = sheet.createRow(0);
int cellNumber = tableHeader.length;
for (int i = 0; i < cellNumber; i++) {
HSSFCell headerCell = headerRow.createCell((short)i);
headerCell.setEncoding(HSSFCell.ENCODING_UTF_16);
headerCell.setCellValue(tableHeader[i]);
}
}
/**
* 鍒涘緩琛?br />
* @param data 瑕佸啓鍏ョ殑鏁版嵁
* @param rowIndex 絎瑀owIndex琛?
*/
public void createTableRow(String[] data, int rowIndex) {
HSSFRow row = sheet.createRow(rowIndex);
for (int i = 0; i < data.length; i++) {
HSSFCell cell = row.createCell((short)i);
cell.setEncoding(HSSFCell.ENCODING_UTF_16);
cell.setCellValue(data[i]);
}
}
/**
* 鍒涘緩鏁翠釜Excel琛?br />
* @param headerName
*/
public void createExcelSheet(String headerName, String[][] data) {
this.createTableHeader(headerName);
String[] rowData;
for (int i = 0; i < data.length; i++) {
rowData = data[i];
createTableRow(rowData, i + 1);
}
}
/**
* 瀵煎嚭Excel琛ㄦ牸
* @param os
* @throws IOException
*/
public void exportExcel(OutputStream os) throws IOException {
sheet.setGridsPrinted(true);
HSSFFooter footer = sheet.getFooter();
footer.setRight("Page " + HSSFFooter.page() + " of " + HSSFFooter.numPages());
workbook.write(os);
}
public HSSFSheet getSheet() {
return sheet;
}
public void setSheet(HSSFSheet sheet) {
this.sheet = sheet;
}
public String[] getTableHeader() {
return tableHeader;
}
public void setTableHeader(String[] tableHeader) {
this.tableHeader = tableHeader;
}
}
/** 娑堟伅瀵硅薄 */
private Message message;
/** 閭歡浼氳瘽 */
private Session session;
public MailClient() {
super();
this.session = createDefaultSession();
}
public MailClient(Session session) {
super();
this.session = session;
}
public MailClient(Message message) {
this();
this.message = message;
}
public MailClient(Session session, Message message) {
super();
this.session = session;
this.message = message;
}
/**
* 鍒涘緩閭歡浼氳瘽
*
* @return
*/
protected Session createDefaultSession() {
Properties props = new Properties();
props.put("mail.smtp.host", "smtp.163.com");
props.put("mail.smtp.auth", "true");
Session session = Session.getInstance(props);
session.setDebug(true);
return session;
}
/**
* 鍒涘緩綰枃鏈偖浠?br />
*
* @param recipientTO
* @param recipientCC
* @param recipientBCC
* @return
* @throws MessagingException
*/
protected Message createMimeMessage(String subject, String content,
String recipientTO, String recipientCC, String recipientBCC)
throws MessagingException {
Message message = createBlankMessage(recipientTO, recipientCC,
recipientBCC);
// 璁劇疆閭歡鏍囬
message.setSubject(subject);
// 璁劇疆閭歡鍐呭
message.setText(content);
// 璁劇疆鍙戦佹椂闂?br /> message.setSentDate(new Date(System.currentTimeMillis()));
// 瀛樺偍閭歡淇℃伅
message.saveChanges();
return message;
}
/**
* 鍒涘緩甯TML鍐呭鐨勯偖浠?br />
*
* @param subject
* @param content
* @param recipientTO
* @param recipientCC
* @param recipientBCC
* @return
* @throws MessagingException
*/
protected Message createHTMLMessage(String subject, String content,
String recipientTO, String recipientCC, String recipientBCC)
throws MessagingException {
Message message = createBlankMessage(recipientTO, recipientCC,
recipientBCC);
// 璁劇疆閭歡鏍囬
message.setSubject(subject);
// 璁劇疆鍙戦佹椂闂?br /> message.setSentDate(new Date(System.currentTimeMillis()));
// 鍒涘緩瀛樻斁閭歡鍐呭鐨凚odyPart瀵硅薄
BodyPart bp = new MimeBodyPart();
bp.setContent(content, "text/html;charset=gb2312");
// 鍒涘緩涓涓狹imeMultipart鏉ュ瓨鏀綛odyPart瀵硅薄
Multipart mp = new MimeMultipart();
mp.addBodyPart(bp);
message.setContent(mp);
message.saveChanges();
return message;
}
/**
* 鍒涘緩甯﹂檮浠剁殑閭歡
*
* @param subject
* @param content
* @param recipientTO
* @param recipientCC
* @param recipientBCC
* @return
* @throws MessagingException
*/
protected Message createAttachMessage(String subject, String content,
File attachment, String recipientTO, String recipientCC,
String recipientBCC) throws MessagingException {
Message message = createBlankMessage(recipientTO, recipientCC,
recipientBCC);
// 璁劇疆閭歡鏍囬
message.setSubject(subject);
// 璁劇疆鍙戦佹椂闂?br /> message.setSentDate(new Date(System.currentTimeMillis()));
// 鍒涘緩瀛樻斁閭歡鍐呭鐨凚odyPart瀵硅薄
BodyPart bp = new MimeBodyPart();
bp.setContent(content, "text/html;charset=gb2312");
// 鍒涘緩涓涓狹imeMultipart鏉ュ瓨鏀綛odyPart瀵硅薄
Multipart mp = new MimeMultipart();
mp.addBodyPart(bp);
// 璁劇疆閭歡鐨勯檮浠?br />
bp = new MimeBodyPart();
FileDataSource fds = new FileDataSource(attachment.getName());
DataHandler dh = new DataHandler(fds);
try {
bp.setFileName(new String(attachment.getName().getBytes("gb2312")));
} catch (UnsupportedEncodingException e) {
final String errMess = "Caught exception while encoding file name:"
+ attachment.getName();
logger.error(errMess);
throw new MailException(errMess, e);
}
bp.setDataHandler(dh);
mp.addBodyPart(bp);
message.setContent(mp);
message.saveChanges();
return message;
}
/**
* 鍒涘緩絀虹櫧閭歡
*
* @param recipientTO
* @param recipientCC
* @param recipientBCC
* @return
* @throws MessagingException
*/
protected Message createBlankMessage(String recipientTO,
String recipientCC, String recipientBCC) throws MessagingException {
Message message = new MimeMessage(session);
// 璁劇疆鍙戜歡浜?br />
InternetAddress from = new InternetAddress("mfktfp2004@163.com");
message.setFrom(from);
// 璁劇疆鏀朵歡浜?br />
InternetAddress to = new InternetAddress(recipientTO);
message.setRecipient(Message.RecipientType.TO, to);
if (StringUtil.isNotEmpty(recipientCC)) {
InternetAddress cc = new InternetAddress(recipientCC);
message.setRecipient(Message.RecipientType.CC, cc);
}
if (StringUtil.isNotEmpty(recipientBCC)) {
InternetAddress bcc = new InternetAddress(recipientBCC);
message.setRecipient(Message.RecipientType.BCC, bcc);
}
return message;
}
/**
* 鍙戦侀偖浠?br />
*
* @param message
* @throws MessagingException
*/
public void sendEmail(Message message) throws MessagingException {
// 浠mtp鏂瑰紡鐧婚檰閭
Transport transport = session.getTransport("smtp");
transport.connect("smtp.163.com", "mfktfp2004", "19850921"); // SMTP鍦板潃錛岀敤鎴峰悕錛屽瘑鐮?/p>
// 鍙戦侀偖浠?br />
transport.sendMessage(message, message.getAllRecipients());
transport.close();
}
/**
* 鍙戦佺函鏂囨湰閭歡
*
* @param subject
* @param content
* @param recipientTO
* @param recipientCC
* @param recipientBCC
*/
public void sendMimeEmail(String subject, String content,
String recipientTO, String recipientCC, String recipientBCC) {
Message message = null;
try {
message = createMimeMessage(subject, content, recipientTO,
recipientCC, recipientBCC);
sendEmail(message);
} catch (MessagingException e) {
logger.error("Send mime email failure", e);
throw new MailException("Error sending email, failure", e);
}
}
/**
* 鍙戦佸甫HTML鍐呭鐨勯偖浠?br />
*
* @param subject
* @param content
* @param recipientTO
* @param recipientCC
* @param recipientBCC
*/
public void sendHTMLEmail(String subject, String content,
String recipientTO, String recipientCC, String recipientBCC) {
Message message = null;
try {
message = createHTMLMessage(subject, content, recipientTO,
recipientCC, recipientBCC);
sendEmail(message);
} catch (MessagingException e) {
logger.error("Send html email failure", e);
throw new MailException("Error sending email, failure", e);
}
}
/**
* 鍙戦佸甫闄勪歡鐨勯偖浠?br />
*
* @param subject
* @param content
* @param recipientTO
* @param recipientCC
* @param recipientBCC
*/
public void sendAttachEmail(String subject, String content,
File attachment, String recipientTO, String recipientCC,
String recipientBCC) {
Message message = null;
try {
message = createAttachMessage(subject, content, attachment,
recipientTO, recipientCC, recipientBCC);
sendEmail(message);
} catch (MessagingException e) {
logger.error("Send html email failure", e);
throw new MailException("Error sending email, failure", e);
}
}
public Message getMessage() {
return message;
}
public void setMessage(Message message) {
this.message = message;
}
public Session getSession() {
return session;
}
public void setSession(Session session) {
this.session = session;
}
public static void main(String[] args) {
MailClient client = new MailClient();
client.sendMimeEmail("test", "test", "zhouqian1103@163.com", null, null);
}
}
public class MailException extends RuntimeException {
private static final long serialVersionUID = 1L;
/** Throwable瀹炰緥 */
protected Throwable throwable;
public MailException() {
super();
}
public MailException(String message) {
super(message);
}
public MailException(Throwable cause) {
this.throwable = cause;
}
public MailException(String message, Throwable cause) {
super(message);
this.throwable = cause;
}
public void printStackTrace(PrintStream ps) {
super.printStackTrace(ps);
if (throwable != null) {
ps.println("with nested Exception:" + throwable);
throwable.printStackTrace(ps);
}
}
public void printStackTrace(PrintWriter pw) {
super.printStackTrace(pw);
if (throwable != null) {
pw.println("with nested Exception:" + throwable);
throwable.printStackTrace(pw);
}
}
public String toString() {
if (throwable == null) {
return super.toString();
} else {
return super.toString() + "with nested exception:" + throwable;
}
}
public Throwable getThrowable() {
return throwable;
}
}
鍚庡彴錛?/p>
SAXBuilder saxb = new SAXBuilder();
Document doc = saxb.build(request.getInputStream());
Element root = doc.getRootElement();
String type = root.getChildText("type");
String inputCondition = root.getChildText("condition");
// 鑾峰緱閰嶇疆鏂囦歡涓殑鍖呭悕
String packagepath = resConf.getClass().getPackage().toString();
// 杞崲閰嶇疆鏂囦歡鏈湴璺緞
String packagePath = packagepath.substring(8).replace(".","/")+"/";
String configFilePath = webPath+packagePath;
return configFilePath;
}
/**
* 鑾峰彇class鏂囦歡鐨勭粷瀵硅礬寰?br />
*/
public static String getClassPath(Class cls) {
String path = null;
java.net.URL url = getClassLocationURL(cls);
if (url != null) {
path = url.getPath();
if ("jar".equalsIgnoreCase(url.getProtocol())) {
try {
path = new java.net.URL(path).getPath();
} catch (Exception e) {
e.printStackTrace();
}
int location = path.indexOf("!/");
if (location != -1) {
path = path.substring(0, location);
}
}
try {
java.io.File file = new java.io.File(path);
path = file.getCanonicalPath();
} catch (Exception ex) {
ex.printStackTrace();
}
}
return pathChange(path);
}
/**
* 鑾峰彇class鏂囦歡浣嶇疆鐨刄RL
*/
public static java.net.URL getClassLocationURL(final Class cls) {
java.net.URL result = null;
String clsAsResource = cls.getName().replace('.', '/').concat(".class");
java.security.ProtectionDomain pd = cls.getProtectionDomain();
/**
* java.lang.Class contract does not specify if 'pd' can ever be null;
* it is not the case for Sun's implementations, but guard against null
* just in case:
*/
if (pd != null) {
java.security.CodeSource cs = pd.getCodeSource();
/**
* 'cs' can be null depending on the classloader behavior:
*/
if (cs != null)
result = cs.getLocation();
if (result != null) {
if ("file".equals(result.getProtocol())) {
try {
if (result.toExternalForm().endsWith(".jar")
|| result.toExternalForm().endsWith(".zip"))
result = new java.net.URL("jar:".concat(
result.toExternalForm()).concat("!/")
.concat(clsAsResource));
else if (new File(result.getFile()).isDirectory())
result = new java.net.URL(result, clsAsResource);
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
}
if (result == null) {
ClassLoader clsLoader = cls.getClassLoader();
result = clsLoader != null ? clsLoader.getResource(clsAsResource)
: ClassLoader.getSystemResource(clsAsResource);
}
return result;
}
/**
* 灝?\"杞彉"/",鐢ㄤ簬璺緞杞崲
*/
public static String pathChange(String befstr) {
StringBuffer afStr = new StringBuffer();
for (int i = 0; i < befstr.length(); i++) {
if ((befstr.charAt(i)) == '\\')
afStr.append(String.valueOf('/'));
else
afStr.append(befstr.substring(i, i + 1));
}
return afStr.toString();
}
public static void main(String[] args)
{
System.out.println(getConfigFileContent("formattedfilter.xml"));
// System.out.println(getClassPath(StringUtil.class));
}
/**
* XML鏂囦歡瑙f瀽鎴愬璞$殑鎺ュ彛瀹炵幇綾?br />
* @author chou
* @version [鐗堟湰,2008-07-26]
* @see [鐩稿叧綾?鏂規硶]
* @since [浜у搧/妯″潡鐗堟湰]
*/
public class SQLFilterConfigManagerImpl implements SQLFilterConfigManager,
InitializingBean {
// 甯擱噺瀹氫箟
private static final String ATTRIBUTE_NAME = "name";
private static final String ATTRIBUTE_PREFIXION = "prefixion";
private static final String ATTRIBUTE_PROPERTY = "property";
private static final String ATTRIBUTE_CONTENT = "content";
private static final String FILENAME = "formattedfilter.xml";
/** 閰嶇疆鏂囦歡瀵瑰簲鐨勫璞?*/
private Map data = null;
/**
* InitializingBean鎺ュ彛鏂規硶
*/
public void afterPropertiesSet() throws Exception
{
loadXml();
}
/**
* 灝哫ML鏂囦歡鍐呭瑙f瀽涓哄璞?br />
*
*/
private void loadXml()
{
Map ldata = new HashMap();
InputStream fileStream = ResourceConfig.getConfigFileStream(FILENAME);
try {
// 鑾峰彇閰嶇疆鏂囦歡鐨勬牴緇撶偣
Element root = OperateXML.getRoot(fileStream);
// 鑾峰彇鏍圭粨鐐逛笅鐨勫瓙緇撶偣
List typeList = OperateXML.getSubNodes(root);
if (typeList != null)
{
for (Iterator iterator = typeList.iterator(); iterator
.hasNext();)
{
Element e = (Element) iterator.next();
TypeConfig type = loadTypeConfig(e);
if (type != null)
{
fillTypeConfig(type, e);
ldata.put(type.getName(), type);
}
}
}
data = ldata;
}
finally
{
if (fileStream != null)
{
try
{
fileStream.close();
}
catch (IOException e)
{
}
}
}
}
/**
* 鐢熸垚騫跺垵濮嬪寲TypeConfig瀵硅薄
* @param e XML緇撶偣鍏冪礌
* @return
*/
private TypeConfig loadTypeConfig(Element e)
{
TypeConfig type = new TypeConfig();
type.setName(e.attributeValue(ATTRIBUTE_NAME));
return type;
}
private void fillTypeConfig(TypeConfig type, Element e)
{
List typeList = OperateXML.getSubNodes(e);
if (typeList != null && typeList.size() > 0)
{
Set set = new HashSet();
for (Iterator iterator = typeList.iterator(); iterator.hasNext();)
{
Element ef = (Element) iterator.next();
FilterFormatter formatter = loadFilterFormatter(ef);
if (formatter != null)
{
fillFilterFormatter(formatter, ef);
set.add(formatter);
}
}
type.setFomatters(set);
}
}
/**
* 緇橣ilterFormatter瀵硅薄璁懼畾灞炴у?br />
* @param formatter 瑕佽瀹氬睘鎬у肩殑FilterFormatter瀵硅薄
* @param e XML鏂囦歡緇撶偣鍏冪礌
*/
private void fillFilterFormatter(FilterFormatter formatter, Element e)
{
List typeList = OperateXML.getSubNodes(e);
if (typeList != null && typeList.size() > 0)
{
Set set = new HashSet();
for (Iterator iterator = typeList.iterator(); iterator.hasNext();)
{
Element ef = (Element) iterator.next();
FormatterCondition formatterCondition = loadFormatterCondition(ef);
if (formatterCondition != null)
{
fillFormatterCondition(formatterCondition, ef);
set.add(formatterCondition);
}
}
formatter.setConditions(set);
}
}
/**
* 緇橣ormatterCondition瀵硅薄璁懼畾灞炴у?br />
* @param formatter 瑕佽瀹氬睘鎬у肩殑FormatterCondition瀵硅薄
* @param e XML鏂囦歡緇撶偣鍏冪礌
*/
private void fillFormatterCondition(FormatterCondition formatterCondition, Element e)
{
List typeList = OperateXML.getSubNodes(e);
if (typeList != null && typeList.size() > 0)
{
Set set = new HashSet();
for (Iterator iterator = typeList.iterator(); iterator.hasNext();)
{
Element ef = (Element) iterator.next();
Example eg = new Example();
//eg.setExample(e.attributeValue(ATTRIBUTE_EXAMPLE));
eg.setExample(ef.getText());
set.add(eg);
}
formatterCondition.setExamples(set);
}
}
/* private void fillExample(Example example, Element e)
{
example.setExample(e.getText());
}*/
/**
* 鐢熸垚騫跺垵濮嬪寲FormatterCondition瀵硅薄
* @param e XML緇撶偣鍏冪礌
* @return
*/
private FormatterCondition loadFormatterCondition(Element e)
{
FormatterCondition formatterCondition = new FormatterCondition();
formatterCondition.setContent(e.attributeValue(ATTRIBUTE_CONTENT));
return formatterCondition;
}
/**
* 鐢熸垚騫跺垵濮嬪寲FilterFormatter瀵硅薄
* @param e XML緇撶偣鍏冪礌
* @return
*/
private FilterFormatter loadFilterFormatter(Element e)
{
FilterFormatter formatter = new FilterFormatter();
formatter.setPrefixion(e.attributeValue(ATTRIBUTE_PREFIXION));
formatter.setProperty(e.attributeValue(ATTRIBUTE_PROPERTY));
return formatter;
}
/**
* 鑾峰彇鎸囧畾綾誨瀷瀛楁鐨勮繃婊ゆ牸寮忓拰渚嬪瓙鐨凪ap
* @param type 瀛楁綾誨瀷
* @return 灝佽浜嗚瀛楁綾誨瀷鐨勮繃婊ゆ牸寮忓拰渚嬪瓙鐨凪ap
*/
public TypeConfig getTypeConfig(String key) {
// TODO Auto-generated method stub
return (TypeConfig)data.get(key);
}
}
/**
* 鏂囦歡鎿嶄綔綾?br />
* @author chou
* @version [鐗堟湰鍙?2008-8-4]
* @see [鐩稿叧綾?鏂規硶]
* @since [浜у搧/妯″潡鐗堟湰]
*/
public class OperateFile
{
/**涓嬭澆鏂囦歡鐨勭紪鐮佹牸寮?/
private static final String FILECODING = "UTF-8";
/**鏃ュ織綾?/
private final Logger log = Logger.getLogger(getClass());
private static final String CONTENT_TYPE = "application/octet-stream";
/**
* 涓嬭澆鏂囦歡
* @param fileName 鏂囦歡鍚嶇О鍔犺礬寰?br />
* @throws IOException
*/
public void downFile(String fileName, byte[] fileContent, HttpServletResponse res, HttpServletRequest req)
throws BaseException
{
String downFileName = null;
BufferedOutputStream bos = null;
if (fileContent != null && fileContent.length >= 0 && res != null)
{
try
{
res.setContentType(CONTENT_TYPE);
if(fileName == null || fileName.equals("") == true)
{
fileName = "anonymous";
}
downFileName = URLEncoder.encode(fileName, FILECODING);
if (req.getHeader("User-Agent").indexOf("MSIE 5.5") != -1)
{
res.setHeader("Content-disposition", "filename=" + downFileName);
}
else
{
res.setHeader("Content-disposition", "attachment; filename=" + downFileName);
}
byte[] buff = fileContent;
bos = new BufferedOutputStream(res.getOutputStream());
bos.write(buff);
}
catch (Exception e)
{
log.info("鏂囦歡涓嬭澆: " + e + " 鏂囦歡涓嬭澆寮傚父錛?);
}
finally
{
if (bos != null)
{
try
{
bos.flush();
}
catch (Exception e)
{
log.info("鏂囦歡涓嬭澆: " + e + " 鏂囦歡涓嬭澆寮傚父錛?);
}
try
{
bos.close();
}
catch (Exception e)
{
log.info("鏂囦歡涓嬭澆: " + e + " 鏂囦歡涓嬭澆寮傚父錛?);
}
}
}
}
}
}
public class OperateJson
{
/**
* 鏈柟娉曟彁渚涘皢List闆嗗悎涓殑convertObj瀵硅薄杞崲鍒癑SONArray闆嗗悎涓璊SONObject,
* 榪斿洖杞崲涓篔SONObject涔嬪悗鐨凧SONArray闆嗗悎
* @param convertObj List闆嗗悎涓璞$殑Class
* @param list 闇瑕佽漿鎹負JSONArray闆嗗悎鐨勬暟鎹?br />
* @return
* @throws IllegalAccessException
* @throws IllegalArgumentException
* @throws Exception
*/
public JSONArray convertJSONArray(Class<?> convertObj, List list)
throws IllegalArgumentException, IllegalAccessException
{
JSONArray array = new JSONArray();
JSONObject jObj = null;
Field[] fields = convertObj.getDeclaredFields();
Object obj = null;
for (Iterator iter = list.iterator(); iter.hasNext(); array.add(jObj))
{
obj = iter.next();
jObj = new JSONObject();
for (int i = 0; i < fields.length; i++)
{
jObj.element(fields[i].getName(), fields[i].get(obj));
}
}
return array;
}
public JSONArray convertJSONArrayByField(Class<?> convertObj, List list)
throws IllegalArgumentException, IllegalAccessException, SecurityException,
NoSuchMethodException, InvocationTargetException
{
JSONArray array = new JSONArray();
JSONObject jObj = null;
Field[] fields = convertObj.getDeclaredFields();
Object obj = null;
for (Iterator iter = list.iterator(); iter.hasNext(); array.add(jObj))
{
obj = iter.next();
jObj = new JSONObject();
for (int i = 0; i < fields.length; i++)
{
String name = fields[i].getName();
String xx = name.substring(0, 1);
name = name.substring(1);
name = xx.toUpperCase() + name;
Method method = convertObj.getMethod("get" + name);
jObj.element(fields[i].getName(), method.invoke(obj));
}
}
return array;
}
/**
* @param convertObj
* @param list
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
public String toJSONString(Class<?> convertObj, List list) throws IllegalArgumentException,
IllegalAccessException
{
Field[] fields = convertObj.getFields();
Object obj = null;
StringBuffer value = new StringBuffer("[");
for (Iterator iter = list.iterator(); iter.hasNext();)
{
obj = iter.next();
for (int i = 0; i < fields.length; i++)
{
if (i != 0)
{
value.append(",{");
}
else
{
value.append("{");
}
value.append("'" + fields[i].getName() + "':'" + fields[i].get(obj) + "',");
}
}
value.append("]");
return value.toString();
}
/**
* 璇ユ柟娉曟妸鏁扮粍瀵硅薄杞崲鎴恓sonObj褰㈠紡鐨勫瓧絎︿覆
* @param arrayObj
* @return
*/
public static String toJSONString(String[][] arrayObj)
{
StringBuffer value = new StringBuffer("[");
for (int i = 0; i < arrayObj.length; i++)
{
String[] field = arrayObj[i];
if (i != 0)
{
value.append(",{");
}
else
{
value.append("{");
}
value.append("'id':'" + field[0] + "',");
value.append("'name':'" + field[1] + "',");
value.append("'descn':'" + field[2] + "'");
value.append("}");
}
value.append("]");
return value.toString();
}
/**
* @param arrayObj
* @return
*/
public static String convertJSONArray(String[][] arrayObj)
{
JSONArray array = new JSONArray();
JSONObject jObj = null;
for (int i = 0; i < arrayObj.length; i++)
{
String[] field = arrayObj[i];
jObj = new JSONObject();
jObj.element("id", field[0]);
jObj.element("name", field[1]);
jObj.element("descn", field[2]);
array.add(jObj);
}
return array.toString();
}
/**
* 閫氳繃List瀵硅薄鑾峰緱鍏憡鐨凧SON瀵硅薄
* @param list
* @param loginUser 褰撳墠鐧婚檰鐢ㄦ埛緙栧彿
* @return JSONObject
*/
public JSONObject convertJSONBulletin(List list, User loginUser, int count)
{
// 鍒涘緩涓涓狫SONArray瀵硅薄
JSONArray array = new JSONArray();
// 鍒涘緩涓涓繚瀛樺叕鍛婄殑瀵硅薄
JSONObject jObj = null;
JSONObject totle = new JSONObject();
// 鏍煎紡鍖栨椂闂存牸寮?br /> SimpleDateFormat sdf = new SimpleDateFormat("MM/dd/yyyy hh:mm:ss");
// 紜畾闆嗗悎鐨勫ぇ灝?br /> int size = list.size();
// 閬嶅巻List瀵硅薄
for (int i = 0; i < size; i++)
{
jObj = new JSONObject();
Bulletins bulletins = (Bulletins) list.get(i);
jObj.element("newsID", bulletins.getNewsId()); // 璁劇疆鍏憡緙栧彿
jObj.element("status", bulletins.getNewsStatus()); // 璁劇疆鍏憡鐨勭姸鎬?br />
jObj.element("newsType", bulletins.getNewsType()); // 璁劇疆鍏憡鐨勭被鍨?br />
jObj.element("newTitle", bulletins.getNewsTitle()); // 璁劇疆鍏憡鏍囬
jObj.element("newsGroup", bulletins.getGroupName()); // 璁劇疆鍏憡鐨勫綊灞?br />
jObj.element("startDate", sdf.format(bulletins.getBeginTime()).substring(0, 10)); // 璁劇疆鍏憡寮濮嬫椂闂?br />
jObj.element("endDate", sdf.format(bulletins.getEndTime()).substring(0, 10)); // 璁劇疆鍏憡緇撴潫鏃墮棿
jObj.element("popType", bulletins.getPopType()); // 璁劇疆鍏憡鐨勫脊鍑烘柟寮?br />
jObj.element("groupCode", bulletins.getFGroupcode()); // 璁劇疆鍏憡鐨勫綊灞為儴闂ㄧ紪鍙?br />
jObj.element("userId", loginUser.getId()); // 璁劇疆鍏憡鍒涘緩浜虹紪鍙?/p>
array.add(jObj);
}
totle.accumulate("totalRecord", count);
totle.accumulate("records", array);
return totle;
}
public static void main(String[] args)
{
String[][] array = new String[10][3];
for (int i = 0; i < array.length; i++)
{
array[i][0] = i + "";
array[i][1] = "name " + i;
array[i][2] = "descn " + i;
}
long jsona = System.currentTimeMillis();
String json1 = OperateJson.convertJSONArray(array);
long jsonb = System.currentTimeMillis();
System.out.println(json1);
System.out.println("===========" + (jsonb - jsona));
long a = System.currentTimeMillis();
String c = OperateJson.toJSONString(array);
long b = System.currentTimeMillis();
System.out.println(c);
System.out.println("===========" + (b - a));
}
}