package org.sg.sgg.json;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.beanutils.BeanUtils;
public class JSONUtils {
/**
* 将List对象序列化为JSON文本
*
* @param <T>
* @param list
* @return
*/
public static <T> String toJSONString(List<T> list) {
JSONArray js = JSONArray.fromObject(list);
return js.toString();
}
/**
* 将对象序列化为JSON文本
*
* @param obj
* @return
*/
public static String toJSONString(Object object) {
JSONObject jo = JSONObject.fromObject(object);
return jo.toString();
}
/***
* 将JSON对象数组序列化为JSON文本
*
* @param ja
* @return
*/
public static String toJSONString(JSONArray ja) {
return ja.toString();
}
/**
* 将JSON对象序列化为JSON文本
*
* @param jo
* @return
*/
public static String toJSONString(JSONObject jo) {
return jo.toString();
}
/**
* 将对象转换为List对象
*
* @param object
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static List toArrayList(Object object) {
List arrList = new ArrayList();
JSONArray ja = JSONArray.fromObject(object);
Iterator<?> iterator = ja.iterator();
while (iterator.hasNext()) {
JSONObject jo = (JSONObject) iterator.next();
Iterator<?> keys = jo.keys();
while (keys.hasNext()) {
Object key = keys.next();
Object value = jo.get(key);
arrList.add(value);
}
}
return arrList;
}
/**
* 将对象转换为Collection对象
*
* @param object
* @return
*/
@SuppressWarnings("rawtypes")
public static Collection toCollection(Object object) {
JSONArray ja = JSONArray.fromObject(object);
return JSONArray.toCollection(ja);
}
/**
* 将对象转换为JSON对象数组
*
* @param object
* @return
*/
public static JSONArray toJSONArray(Object object) {
return JSONArray.fromObject(object);
}
/***
* 将对象转换为JSON对象
*
* @param object
* @return
*/
public static JSONObject toJSONObject(Object object) {
return JSONObject.fromObject(object);
}
/**
* 将一个json数组转换成list对象
*
* @param jsonStr
* @return
*/
@SuppressWarnings("unchecked")
public static List<Map<String, Object>> json2List(String jsonStr) {
JSONArray ja = JSONArray.fromObject(jsonStr);
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Iterator<JSONObject> it = ja.iterator();
while (it.hasNext()) {
JSONObject json2 = it.next();
list.add(json2Map(json2));
}
return list;
}
/**
* 将一个json数组转换成list对象
*
* @param jsonStr
* @return
*/
@SuppressWarnings("unchecked")
public static List<Map<String, Object>> json2List(JSONArray ja) {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Iterator<JSONObject> it = ja.iterator();
while (it.hasNext()) {
JSONObject json2 = it.next();
list.add(json2Map(json2));
}
return list;
}
/**
* 将一个json对象转换成Map对象
*
* @param jsonStr
* @return
*/
@SuppressWarnings("unchecked")
public static Map<String, Object> json2Map(String jsonStr) {
Map<String, Object> map = new HashMap<String, Object>();
JSONObject jo = JSONObject.fromObject(jsonStr);
for (Object key : jo.keySet()) {
Object value = jo.get(key);
if (value instanceof JSONArray) {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Iterator<JSONObject> iterator = ((JSONArray) value).iterator();
while (iterator.hasNext()) {
JSONObject jo2 = iterator.next();
list.add(json2Map(jo2.toString()));
}
map.put(key.toString(), value);
} else {
map.put(key.toString(), value);
}
}
return map;
}
/**
* 将一个json对象转换成Map对象
*
* @param jo
* @return
*/
@SuppressWarnings("unchecked")
public static Map<String, Object> json2Map(JSONObject jo) {
Map<String, Object> map = new HashMap<String, Object>();
for (Object key : jo.keySet()) {
Object value = jo.get(key);
if (value instanceof JSONArray) {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
Iterator<JSONObject> iterator = ((JSONArray) value).iterator();
while (iterator.hasNext()) {
JSONObject jo2 = iterator.next();
list.add(json2Map(jo2.toString()));
}
map.put(key.toString(), value);
} else {
map.put(key.toString(), value);
}
}
return map;
}
public static String map2Json(Map<Object, Object> map){
if (null == map) {
return null;
}
JSONObject jo = JSONObject.fromObject(map);
return jo.toString();
}
/**
* //通过HTTP url获取JSON数据
*
* @return
*/
public static List<Map<String, Object>> getListByUrl(String url) {
StringBuilder builder = null;
try {
InputStream in = new URL(url).openStream();
BufferedReader reader = new BufferedReader(
new InputStreamReader(in));
builder = new StringBuilder();
String line = "";
while ((line = reader.readLine()) != null) {
builder.append(line);
}
} catch (Exception e) {
e.printStackTrace();
}
return json2List(builder.toString());
}
/**
* //通过HTTP url获取JSON数据
*
* @return
*/
public static Map<String, Object> getMapByUrl(String url) {
StringBuilder builder = null;
try {
InputStream in = new URL(url).openStream();
BufferedReader reader = new BufferedReader(
new InputStreamReader(in));
String line = "";
builder = new StringBuilder();
while ((line = reader.readLine()) != null) {
builder.append(line);
}
} catch (Exception e) {
e.printStackTrace();
}
return json2Map(builder.toString());
}
/**
* 将对象转换为HashMap
*
* @param object
* @return
*/
@SuppressWarnings("rawtypes")
public static HashMap toHashMap(Object object) {
HashMap<String, Object> map = new HashMap<String, Object>();
JSONObject jo = JSONUtils.toJSONObject(object);
Iterator iterator = jo.keys();
while (iterator.hasNext()) {
Object obj = iterator.next();
String key = "";
if (obj instanceof String) {
key = (String) obj;
}
Object value = jo.get(key);
map.put(key, value);
}
return map;
}
/**
* 将对象转换为List<Map<String,Object>> 返回非实体类型(Map<String,Object>)的List
*
* @return
*/
@SuppressWarnings("rawtypes")
public static List<Map<String, Object>> toList(Object object) {
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
JSONArray ja = JSONArray.fromObject(object);
for (Object obj : ja) {
if (obj instanceof JSONObject) {
JSONObject jo = (JSONObject) obj;
Map<String, Object> map = new HashMap<String, Object>();
Iterator iterator = jo.keys();
while (iterator.hasNext()) {
Object o = iterator.next();
String key = "";
if (o instanceof String) {
key = (String) o;
}
Object value = jo.get(key);
map.put(key, value);
}
list.add(map);
}
}
return list;
}
/**
* 将JSON对象数组转换为传入类型的List
*
* @param <T>
* @param ja
* @param clazz
* @return
*/
@SuppressWarnings({ "unchecked", "deprecation" })
public static <T> List<T> toList(JSONArray ja, Class<T> clazz) {
return JSONArray.toList(ja, clazz);
}
/**
* 将对象转换为传入类型的List
*
* @param <T>
* @param object
* @param clazz
* @return
*/
@SuppressWarnings({ "unchecked", "deprecation" })
public static <T> List<T> toList(Object object, Class<T> clazz) {
JSONArray ja = JSONArray.fromObject(object);
return JSONArray.toList(ja, clazz);
}
/**
* 将JSON对象转换为传入类型的对象
*
* @param <T>
* @param jo
* @param clazz
* @return
*/
@SuppressWarnings({ "static-access", "unchecked" })
public static <T> T toBean(JSONObject jo, Class<T> clazz) {
return (T) jo.toBean(jo, clazz);
}
/**
* 将将对象转换为传入类型的对象
*
* @param <T>
* @param object
* @param clazz
* @return
*/
@SuppressWarnings({ "static-access", "unchecked" })
public static <T> T toBean(Object object, Class<T> clazz) {
JSONObject jo = JSONObject.fromObject(object);
return (T) jo.toBean(jo, clazz);
}
/***
* 将JSON文本反序列化为主从关系的实体
*
* @param <T>
* 泛型T 代表主实体类型
* @param <D>
* 泛型D 代表从实体类型
* @param jsonString
* JSON文本
* @param mainClass
* 主实体类型
* @param detailName
* 从实体类在主实体类中的属性名称
* @param detailClass
* 从实体类型
* @return
*/
@SuppressWarnings("unused")
public static <T, D> T toBean(String jsonString, Class<T> mainClass,
String detailName, Class<D> detailClass) {
JSONObject jo = JSONObject.fromObject(jsonString);
JSONArray ja = (JSONArray) jo.get(detailName);
T mainEntity = JSONUtils.toBean(jo, mainClass);
List<D> detailList = JSONUtils.toList(ja, detailClass);
try {
BeanUtils.setProperty(mainEntity, detailName, detailClass);
} catch (Exception e) {
throw new RuntimeException("主从关系JSON反序列化实体失败！");
}
return mainEntity;
}
/**
* 将JSON文本反序列化为主从关系的实体
*
* @param <T>>泛型T 代表主实体类型
* @param <D1>泛型D1 代表从实体类型
* @param <D2>泛型D2 代表从实体类型
* @param jsonStringJSON文本
* @param maiinClass
* 主实体类型
* @param detailName1
* 从实体类在主实体类中的属性
* @param detailClass1
* 从实体类型
* @param detailName2
* 从实体类在主实体类中的属性
* @param detailClass2
* 从实体类型
* @return
*/
@SuppressWarnings("unused")
public static <T, D1, D2> T toBean(String jsonString, Class<T> maiinClass,
String detailName1, Class<D1> detailClass1, String detailName2,
Class<D2> detailClass2) {
JSONObject jo = JSONObject.fromObject(jsonString);
JSONArray ja1 = (JSONArray) jo.get(detailName1);
JSONArray ja2 = (JSONArray) jo.get(detailName2);
T mainEntity = JSONUtils.toBean(jo, maiinClass);
List<D1> detailList1 = JSONUtils.toList(ja1, detailClass1);
List<D2> detailList2 = JSONUtils.toList(ja2, detailClass2);
try {
BeanUtils.setProperty(mainEntity, detailName1, detailClass1);
BeanUtils.setProperty(mainEntity, detailName2, detailClass2);
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("主从关系JSON反序列化实体失败！");
}
return mainEntity;
}
/***
* 将JSON文本反序列化为主从关系的实体
*
* @param <T>泛型T 代表主实体类型
* @param <D1>泛型D1 代表从实体类型
* @param <D2>泛型D2 代表从实体类型
* @param jsonString
* JSON文本
* @param mainClass
* 主实体类型
* @param detailName1
* 从实体类在主实体类中的属性
* @param detailClass1
* 从实体类型
* @param detailName2
* 从实体类在主实体类中的属性
* @param detailClass2
* 从实体类型
* @param detailName3
* 从实体类在主实体类中的属性
* @param detailClass3
* 从实体类型
* @return
*/
public static <T, D1, D2, D3> T toBean(String jsonString,
Class<T> mainClass, String detailName1, Class<D1> detailClass1,
String detailName2, Class<D2> detailClass2, String detailName3,
Class<D3> detailClass3) {
JSONObject jsonObject = JSONObject.fromObject(jsonString);
JSONArray jsonArray1 = (JSONArray) jsonObject.get(detailName1);
JSONArray jsonArray2 = (JSONArray) jsonObject.get(detailName2);
JSONArray jsonArray3 = (JSONArray) jsonObject.get(detailName3);
T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
List<D1> detailList1 = JSONUtils.toList(jsonArray1, detailClass1);
List<D2> detailList2 = JSONUtils.toList(jsonArray2, detailClass2);
List<D3> detailList3 = JSONUtils.toList(jsonArray3, detailClass3);
try {
BeanUtils.setProperty(mainEntity, detailName1, detailList1);
BeanUtils.setProperty(mainEntity, detailName2, detailList2);
BeanUtils.setProperty(mainEntity, detailName3, detailList3);
} catch (Exception ex) {
throw new RuntimeException("主从关系JSON反序列化实体失败！");
}
return mainEntity;
}
/***
* 将JSON文本反序列化为主从关系的实体
*
* @param <T>
* 主实体类型
* @param jsonString
* JSON文本
* @param mainClass
* 主实体类型
* @param detailClass
* 存放了多个从实体在主实体中属性名称和类型
* @return
*/
@SuppressWarnings("rawtypes")
public static <T> T toBean(String jsonString, Class<T> mainClass,
HashMap<String, Class> detailClass) {
JSONObject jsonObject = JSONObject.fromObject(jsonString);
T mainEntity = JSONUtils.toBean(jsonObject, mainClass);
for (Object key : detailClass.keySet()) {
try {
Class value = (Class) detailClass.get(key);
BeanUtils.setProperty(mainEntity, key.toString(), value);
} catch (Exception ex) {
throw new RuntimeException("主从关系JSON反序列化实体失败！");
}
}
return mainEntity;
}
}
|
package org.sg.sgg.jdbc;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import org.apache.log4j.Logger;
import org.sg.sgg.property.propertyUtils;
public class GetConFactory {
private static final Logger logger = Logger.getLogger(GetConFactory.class);
public static PreparedStatement pst = null;
public static Statement st = null;
public static ResultSet rs = null;
/**
* 数据库连接实例
*/
public static Connection conn = null;
/**
* 数据库的辅助类
*/
GetClientHandle getClientHandle = new GetClientHandle();
/**
* 返回数据库连接
* @return
*/
public Connection getConnection(){
Connection connection = null;
try {
Class.forName(propertyUtils.getConfigParam("jdbc.driverClassName"));
connection = DriverManager.getConnection(
propertyUtils.getConfigParam("jdbc.url"),
propertyUtils.getConfigParam("jdbc.username"),
propertyUtils.getConfigParam("jdbc.password")
);
} catch (Exception e) {
logger.error("获取数据库连接出错:" + e.getMessage());
}
return connection;
}
/**
* 当数据连接为空,或数据源关闭时,在创建连接实例
*/
public static Connection getConInstance(){
try {
if (conn == null || conn.isClosed() == true) {
conn = new GetConFactory().getConnection();
}
} catch (SQLException e) {
logger.error("获取数据库连接出错:" + e.getMessage());
}
return conn;
}
}
package org.sg.sgg.jdbc;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.log4j.Logger;
public class GetClientHandle {
private static final Logger logger = Logger.getLogger(GetClientHandle.class);
/**
* 关闭数据库连接
* @param pst
* @param rs
*/
public static void getCloseInf(PreparedStatement pst,ResultSet rs){
try {
if (pst != null) {
pst.close();
}
if (rs != null) {
rs.close();
}
} catch (SQLException e) {
logger.error("关闭数据库出现异常："+e.getMessage());
e.printStackTrace();
}
}
/**
* 根据参数 添加 删除 修改
* @param con
* @param pst
* @param sql
* @param params
*/
public void getClientModifyRemoveBean(Connection con,
PreparedStatement pst, String sql, String[] params) {
try {
pst = con.prepareStatement(sql);
if (params.length > 0) {
for (int i = 0; i < params.length; i++) {
pst.setString(i + 1, params[i]);
}
}
pst.execute();
} catch (Exception e) {
e.printStackTrace();
} finally {
getCloseInf(pst, null);
}
}
/**
* 根据参数 查询总记录数
* @param con
* @param pst
* @param res
* @param sql
* @param params
* @return
*/
public String getClientString(Connection con, PreparedStatement pst,
ResultSet res, String sql, String[] params) {
String text = null;
try {
pst = con.prepareStatement(sql);
if (params.length > 0) {
for (int i = 0; i < params.length; i++) {
pst.setString(i + 1, params[i]);
}
}
res = pst.executeQuery();
if (res.next()) {
text = res.getString(1);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
getCloseInf(pst, res);
}
return text;
}
/**
* 根据传入参数 查询单个对象
* @param con
* @param pst
* @param res
* @param sql
* @param cla
* @param params
* @return
*/
public Object getClientBean(Connection con, PreparedStatement pst,
ResultSet res, String sql, Class<?> cla, String[] params) {
Object bean = null;
try {
pst = con.prepareStatement(sql);
if (params.length > 0) {
for (int i = 0; i < params.length; i++) {
pst.setString(i + 1, params[i]);
}
}
res = pst.executeQuery();
if (res.next()) {
bean = cla.newInstance();
getClientBean(bean, res.getMetaData(), res);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
getCloseInf(pst, res);
}
return bean;
}
/**
* 根据参数 获取List对象
* @param con
* @param pst
* @param res
* @param sql
* @param cla
* @param params
* @return
*/
public List<?> getClientListBean(Connection con, PreparedStatement pst,
ResultSet res, String sql, Class<?> cla, String[] params) {
List list = new ArrayList();
try {
Object bean = null;
pst = con.prepareStatement(sql);
if (params.length > 0) {
for (int i = 0; i < params.length; i++) {
pst.setString(i + 1, params[i]);
}
}
res = pst.executeQuery();
while (res.next()) {
bean = cla.newInstance();
getClientBean(bean, res.getMetaData(), res);
list.add(bean);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
getCloseInf(pst, res);
}
return list;
}
/**
*
* @param bean
* @param mt
* @param res
*/
public static void getClientBean(Object bean, ResultSetMetaData mt,
ResultSet res) {
try {
for (int i = 1; i < mt.getColumnCount() + 1; i++)
BeanUtils.copyProperty(bean, getUpperCase(mt.getColumnName(i)),
res.getString(mt.getColumnName(i)));
} catch (Exception e) {
e.printStackTrace();
}
}
public static String getUpperCase(String table_filed) {
String name = table_filed.toLowerCase();
StringBuffer bf = new StringBuffer();
for (int j = 0; j < name.length(); j++) {
char c = name.charAt(j);
if (c == '_') {
j++;
bf.append(name.substring(j, j + 1).toUpperCase());
} else if (j == 0) {
bf.append(String.valueOf(c).toLowerCase());
} else {
bf.append(c);
}
}
return bf.toString();
}
}
|
package org.sg.sgg.file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;
import org.apache.log4j.Logger;
public class FileUtils {
private final static Logger logger = Logger.getLogger(FileUtils.class);
/**
* 判断源文件是否存在且是否为文件
* @param sourceFile
* @return
*/
public static boolean isExistsSource(String sourceFile) {
File srcFile = new File(sourceFile);
if (!srcFile.exists()) {
logger.info("复制文件失败：源文件" + sourceFile + "不存在!");
return false;
} else if (!srcFile.isFile()) {
logger.info("复制文件失败：" + sourceFile + "不是一个文件!");
return false;
}
return true;
}
/**
* 判断目标文件所在目录是否存在
* @param targetFile
* @return
*/
public static boolean isExistsTargetDir(String targetFile) {
File destFile = new File(targetFile);
if (!destFile.getParentFile().exists()) {
// 如果目标文件所在的目录不存在，则创建目录
logger.info("目标文件所在的目录不存在：" + destFile.getParentFile());
//创建目录
//destFile.getParentFile().mkdirs();
return false;
}
return true;
}
/**
* 判断该文件是否存在
* @param fileName - 文件名称
* @param path - 目录
* @return - 是否存在
*/
public static boolean isFileExist(String fileName, String path){
File file = new File(getDoPath(path)+fileName);
return file.exists();
}
/**
* 复制单个文件
*
* @param srcFileName
* 待复制的文件名
* @param destFileName
* 目标文件名
* @return 如果复制成功，则返回true，否则返回false
*/
public static boolean copyFile(String srcFileName, String destFileName) {
//源文件是否存在
isExistsSource(srcFileName);
//目标文件所在目录是否存在
isExistsTargetDir(destFileName);
// 准备复制文件
int byteread = 0;// 读取的位数
InputStream in = null;
OutputStream out = null;
File srcFile = new File(srcFileName);
File destFile = new File(destFileName);
try {
// 打开原文件
in = new FileInputStream(srcFile);
// 打开连接到目标文件的输出流
out = new FileOutputStream(destFile);
byte[] buffer = new byte[1024];
// 一次读取1024个字节，当byteread为-1时表示文件已经读完
while ((byteread = in.read(buffer)) != -1) {
// 将读取的字节写入输出流
out.write(buffer, 0, byteread);
}
logger.info("复制文件" + srcFileName + "至" + destFileName + "成功!");
return true;
} catch (Exception e) {
logger.error("复制文件失败：" + e.getMessage());
return false;
} finally {
// 关闭输入输出流，注意先关闭输出流，再关闭输入流
if (out != null) {
try {
out.close();
} catch (IOException e) {
logger.error("复制文件关闭流时出错:" + e.getMessage());
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
logger.error("复制文件关闭流时出错:" + e.getMessage());
}
}
}
}
//==============================================================================
//
//删除文件夹
// 此为调用java基础类，利用递归实现方式
// 除此之外用apache io包FileUtils也很方便，以下为apache io包实现方式：
// org.apache.commons.io.FileUtils.deleteDirectory(f);//删除目录
// org.apache.tools.ant.util.FileUtils.delete(f);//删除文件
//
//==============================================================================
/**
* 删除文件夹：文件夹下的所有文件
* @param filepath 格式形如：d://1//2/3//4
* 即为删除4这个文件夹
* @return
*/
public static boolean removeFile(String filepath) {
try {
File f = new File(filepath);
if(f.exists() && f.isDirectory()) { //判断是文件还是目录
if(f.listFiles().length == 0) { //若目录下没有文件则直接删除
f.delete();
} else { //若有则把文件放进数组，并判断是否有下级目录
File childFile[]=f.listFiles();
int i = f.listFiles().length;
for(int j = 0; j < i; j++) {
if(childFile[j].isDirectory()) {
//递归调用del方法并取得子目录路径
removeFile(childFile[j].getAbsolutePath());
}
childFile[j].delete(); //删除文件
}
//删除文件夹下的子文件后再删除主文件夹
f.delete();
}
}
} catch (Exception e) {
e.printStackTrace();
logger.error("删除文件出错!");
return false;
}
return true;
}
/**
* 传递一个路径和文件名称，删除该文件
* @param fileName - 文件名称
* @param path - 路径
* @return - 是否删除成功
*/
public static boolean removeFile(String fileName, String path){
boolean flag = false;
if (isFileExist(fileName, path)) {
File file = new File(getDoPath(path)+fileName);
flag = file.delete();
}
return flag;
}
/**
* 删除当前文件
* @param file - 要删除的文件
* @return 是否删除成功
*/
public static boolean removeFile(File file){
boolean flag = false;
if (file != null && file.exists()) {
flag = file.delete();
}
return flag;
}
/**
* 传入一个文件名，得到这个文件名称的后缀 包含 .
* @param fileName - 文件名
* @return
*/
public static String getSuffixContainPoint(String fileName){
int index = fileName.lastIndexOf(".");
if (index != -1) {
String suffix = fileName.substring(index);//后缀
return suffix;
}else {
return null;
}
}
/**
* 传入一个文件名，得到这个文件名称的后缀 不包含 .
* @param fileName - 文件名
* @return
*/
public static String getSuffixUnContainPoint(String fileName){
int index = fileName.lastIndexOf(".");
if (index != -1) {
String suffix = fileName.substring(index + 1);//后缀
return suffix;
} else {
return null;
}
}
/**
* 利用uuid产生一个随机的name
* @param fileName 文件名
* @return
*/
public static String getRandomName(String fileName){
String randomName = UUID.randomUUID().toString();
//如果文件没有后缀名 默认就是给添加 后缀 txt
return getNewFileName(fileName, randomName , "txt");
}
/**
* 用当前日期、时间和1000以内的随机数组合成的文件名称
* @param fileName - 文件名
* @return
*/
public static String getNumberFileName(String fileName){
SimpleDateFormat format = new SimpleDateFormat("yyMMddhhmmss");
int rand = new Random().nextInt(1000);
String numberFileName = format.format(new Date()) + rand;
return getNewFileName(fileName, numberFileName, "txt");
}
/**
* 传递一个文件名称和一个新名称，组合成一个新的带后缀文件名
* 当传递的文件名没有后缀，会添加默认的后缀
* @param fileName - 文件名称
* @param newFileName - 新文件名称
* @param nullSuffix - 为没有后缀的文件所添加的后缀 如果没有 可传递一个默认的后缀名 eq .txt
* @return
*/
public static String getNewFileName(String fileName,String newFileName,String nullSuffix){
String suffix = getSuffixContainPoint(fileName);
if (suffix != null) {
newFileName += suffix;
}else {
newFileName = newFileName.concat(".").concat(nullSuffix);
}
return newFileName;
}
/**
*
* @param pathName
* @return
*/
public static boolean isBlankForPath(String pathName) {
boolean flag = false;
String[] letters = new String[] { "/", "\\", ":", "*", "?", "\"", " <",
">", " ¦", "%20", "#", "$", "%" };
for (int i = 0; i < letters.length; i++) {
if (pathName.indexOf(letters[i]) != -1) {
flag = true;
} else {
flag = false;
}
}
return flag;
}
/**
* 处理后的系统文件路径
* @param path
* @return
*/
public static String getDoPath(String path){
path = path.replace("\\", "/");
String lastChar = path.substring(path.length() - 1);
if (!"/".equals(lastChar)) {
path += "/";
}
return path;
}
/**
* 创建指定的path路径目录
* @param path - 目录、路径
* @return
*/
public static boolean mkDir(String path){
File file = null;
try {
file = new File(path);
if (!file.exists()) {
return file.mkdirs();
}
}catch (Exception e) {
logger.error("创建文件失败..错误如下：");
e.printStackTrace();
}finally{
file = null;
}
return false;
}
}
|
package org.sg.sgg.date;
import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import org.apache.log4j.Logger;
public class DateUtils extends Date {
private static final long serialVersionUID = 1L;
private static final Logger LOGGER = Logger.getLogger(Date.class);
public DateUtils() {
super();
}
/**
* 得到当前年
* @return
*/
public static int getCurrYear(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.YEAR);
}
/**
* 得到当前月份
* 注意，这里的月份依然是从0开始的
* @return
*/
public static int getCurrMonth(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.MONTH);
}
/**
* 得到当前日
* @return
*/
public static int getCurrDay(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.DAY_OF_MONTH);
}
/**
* 得到当前星期
* @return
*/
public static int getCurrWeek(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.DAY_OF_WEEK);
}
/**
* 得到当前小时
* @return
*/
public static int getCurrHour(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.HOUR);
}
/**
* 得到当前分钟
* @return
*/
public static int getCurrMinute(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.MINUTE);
}
/**
* 得到当前秒
* @return
*/
public static int getCurrSecond(){
Calendar cal = Calendar.getInstance();
return cal.get(Calendar.SECOND);
}
/**
* Date类型转换到Calendar类型
* @param date
* @return
*/
public static Calendar Date2Calendar(Date date){
Calendar cal = Calendar.getInstance();
cal.setTime(date);
return cal;
}
/**
* Calendar类型转换到Date类型
* @param cal
* @return
*/
public static Date calendar2Date(Calendar cal){
return cal.getTime();
}
/**
* Date类型转换到Timestamp类型
* @param date
* @return
*/
public static Timestamp date2Timestamp(Date date){
return new Timestamp(date.getTime());
}
/**
* Calendar类型转换到Timestamp类型
* @return
*/
public static Timestamp calendar2Timestamp(Calendar cal){
return new Timestamp(cal.getTimeInMillis());
}
/**
* Timestamp类型转换到Calendar类型
* @param timestamp
* @return
*/
public static Calendar timestamp2Calendar(Timestamp timestamp){
Calendar cal = Calendar.getInstance();
cal.setTime(timestamp);
return cal;
}
/**
* 当前时间的下一天时间
*
* @return
*/
public static Date nextDate() {
return nextDate(new DateUtils(), 1);
}
/**
* 得到当前时间的毫秒数
*
* @return
*/
public static Long getCurrentTimeMillis() {
return System.currentTimeMillis();
}
/**
* 获取任意时间后num天的时间
*
* @param date
* java.util.Date
* @param num
* @return
*/
public static Date nextDate(Date date, int num) {
Calendar cla = Calendar.getInstance();
cla.setTime(date);
cla.add(Calendar.DAY_OF_YEAR, num);
return cla.getTime();
}
/**
* 获取任意时间后num天的时间
*
* @param date
* String; <br>
* 格式支持�?<br>
* yyyy-MM-dd HH:mm:ss <br>
* yyyy年MM月dd日HH时mm分ss�?<br>
* yyyy/MM/dd HH:mm:ss <br>
* 默认时间格式
* @param num
* int
* @return java.util.Date
* @throws ParseException
*/
public static Date nextDate(String date, int num) throws ParseException {
if (date == null)
return null;
SimpleDateFormat sdf = null;
if (date.indexOf("-") != -1)
sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
else if (date.indexOf("-") != -1)
sdf = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss");
else if (date.indexOf("/") != -1)
sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
else if (date.indexOf("CST") != -1)
sdf = new SimpleDateFormat();
else
System.out.println("no match format:");
return nextDate(sdf.parse(date), num);
}
/**
* 获取当天时间num天后的时间<br>
* 如果num小于0则返回当前时间的前num天的时间<br>
* ，否则返回当天时间后num天的时间
*
* @param num
* int;
* @return java.util.Date
*/
public static Date nextDate(int num) {
return nextDate(new Date(), num);
}
/**
* 取得当前日期是多少周
*
* @param date
* @return
*/
public static int getWeekOfYear(Date date) {
Calendar c = Calendar.getInstance();
c.setFirstDayOfWeek(Calendar.MONDAY);
/**
* 设置一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则使用值 1 调用此方法。
* 如果最少天数必须是一整个星期，则使用值 7 调用此方法。
**/
c.setMinimalDaysInFirstWeek(1);
c.setTime(date);
return c.get(Calendar.WEEK_OF_YEAR);
}
/**
* 得到某一年周的总数
*
* @param year
* @return
*/
public static int getMaxWeekNumOfYear(int year) {
Calendar c = Calendar.getInstance();
c.set(year, Calendar.DECEMBER, 31, 23, 59, 59);
return getWeekOfYear(c.getTime());
}
/**
* 得到某年某周的第一天
*
* @param year
* @param week
* @return
*/
public static Date getFirstDayOfWeek(int year, int week) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.WEEK_OF_YEAR, week);
c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 设置周一
c.setFirstDayOfWeek(Calendar.MONDAY);
return c.getTime();
}
/**
*得到当周的第一天
*
* @param year
* @param week
* @return
*/
public static Date getFirstDayOfWeek(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);// 设置周一
c.setFirstDayOfWeek(Calendar.MONDAY);
return c.getTime();
}
/**
* 得到某年某周的最后一天
*
* @param year
* @param week
* @return
*/
public static Date getLastDayOfWeek(int year, int week) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.WEEK_OF_YEAR, week);
c.setFirstDayOfWeek(Calendar.MONDAY);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
return c.getTime();
}
/**
* 得到当前周的周的最后一天
*
* @param year
* @param week
* @return
*/
public static Date getLastDayOfWeek(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.setFirstDayOfWeek(Calendar.MONDAY);
c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
return c.getTime();
}
/**
* 得到某年某月的第一天
*
* @param year
* @param month
* @return
*/
public static Date getFirstDayOfMonth(int year, int month) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month - 1);
c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 获得当前月的第一天
*
* @param year
* @param date
* @return
*/
public static Date getFirstDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMinimum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
*得到某年某月的最后一天
*
* @param year
* @param month
* @return
*/
public static Date getLastDayOfMonth(int year, int month) {
Calendar c = Calendar.getInstance();
c.set(Calendar.YEAR, year);
c.set(Calendar.MONTH, month - 1);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 获得当前月的最后一天
*
* @param year
* @param date
* @return
*/
public static Date getLastDayOfMonth(Date date) {
Calendar c = Calendar.getInstance();
c.setTime(date);
c.set(Calendar.DAY_OF_MONTH, c.getActualMaximum(Calendar.DAY_OF_MONTH));
return c.getTime();
}
/**
* 得到某年某季度第一天
*
* @param year
* @param quarter
* @return
*/
public static Date getFirstDayOfQuarter(int year, int quarter) {
int month = 0;
if (quarter > 4) {
return null;
} else {
month = (quarter - 1) * 3 + 1;
}
return getFirstDayOfMonth(year, month);
}
/**
* 得到某年某季度最后一天
*
* @param year
* @param quarter
* @return
*/
public static Date getLastDayOfQuarter(int year, int quarter) {
int month = 0;
if (quarter > 4) {
return null;
} else {
month = quarter * 3;
}
return getLastDayOfMonth(year, month);
}
/**
* 得到某年第一天
*
* @param year
* @return
*/
public static Date getFirstDayOfYear(int year) {
return getFirstDayOfQuarter(year, 1);
}
/**
* 得到当年第一天
*
* @param year
* @return
*/
public static Date getFirstDayOfYear(Date date) {
Calendar c=Calendar.getInstance();
c.setTime(date);
int year=c.get(Calendar.YEAR);
return getFirstDayOfYear(year);
}
/**
* 得到某年最后一天
*
* @param year
* @return
*/
public static Date getLastDayOfYear(int year) {
return getLastDayOfQuarter(year, 4);
}
/**
* 得到当年最后一天
*
* @param year
* @return
*/
public static Date getLastDayOfYear(Date date) {
Calendar c=Calendar.getInstance();
c.setTime(date);
int year=c.get(Calendar.YEAR);
return getLastDayOfYear(year);
}
/**
* 功能：获取本周的开始时间
* 示例：2013-05-13 00:00:00
*/
public static Date getWeekStart() {// 当周开始时间
Calendar currentDate = Calendar.getInstance();
currentDate.setFirstDayOfWeek(Calendar.MONDAY);
currentDate.set(Calendar.HOUR_OF_DAY, 0);
currentDate.set(Calendar.MINUTE, 0);
currentDate.set(Calendar.SECOND, 0);
currentDate.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
return (Date) currentDate.getTime();
}
/**
* 功能：获取本周的结束时间
* 示例：2013-05-19 23:59:59
*/
public static Date getWeekEnd() {// 当周结束时间
Calendar currentDate = Calendar.getInstance();
currentDate.setFirstDayOfWeek(Calendar.MONDAY);
currentDate.set(Calendar.HOUR_OF_DAY, 23);
currentDate.set(Calendar.MINUTE, 59);
currentDate.set(Calendar.SECOND, 59);
currentDate.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
return (Date) currentDate.getTime();
}
/**
* 得到指定或者当前时间前n天的Calendar
* @param day
* @return
*/
@SuppressWarnings("unused")
public static Calendar getBeforeNDays(int n){
Calendar cal = null;
//偏移量，给定n天的毫秒数
long offset = n * 24 * 60 * 60 * 1000;
if (cal != null) {
cal.setTimeInMillis(cal.getTimeInMillis() - offset);
}else {
cal = Calendar.getInstance();
cal.setTimeInMillis(cal.getTimeInMillis() - offset);
}
return cal;
}
/**
* 得到指定或者当前时间后n天的Calendar
* @param n
* @return
*/
@SuppressWarnings("unused")
public static Calendar getAfterNDays(int n){
Calendar cal = null;
//偏移量，给定n天的毫秒数
long offset = n*24*60*60*1000;
if (cal != null) {
cal.setTimeInMillis(cal.getTimeInMillis() + offset);
}else {
cal = Calendar.getInstance();
cal.setTimeInMillis(cal.getTimeInMillis() + offset);
}
return cal;
}
/**
* 获取当前时间的后一天
* @return
*/
@SuppressWarnings("unused")
public static Calendar getTomorrowDay(){
long offset = 1*24*60*60*1000;
Calendar cal = null;
if (cal != null) {
cal.setTimeInMillis(cal.getTimeInMillis() + offset);
}else {
cal = Calendar.getInstance();
cal.setTimeInMillis(cal.getTimeInMillis() + offset);
}
return cal;
}
/**
* 获取当前时间的上一天
* @return
*/
@SuppressWarnings("unused")
public static Calendar getYesterDay(){
long offset = 1*24*60*60*1000;
Calendar cal = null;
if (cal != null) {
cal.setTimeInMillis(cal.getTimeInMillis() - offset);
}else {
cal = Calendar.getInstance();
cal.setTimeInMillis(cal.getTimeInMillis() - offset);
}
return cal;
}
}
|
package com.web.util;
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 javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.jdom2.Document;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
public class XmlUtil {
public static void saxXml(String path, SaxHandler saxHandler) {
InputStream in = null;
try {
in = new FileInputStream(path);
saxXml(in, saxHandler);
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void saxXml(InputStream in, SaxHandler saxHandler) {
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(in, saxHandler);
} catch (Exception e) {
e.printStackTrace();
}
saxHandler.resultCallback();
}
public static void domXml(String path, DomHandler domHandler) {
File file = new File(path);
InputStream in = null;
try {
in = new FileInputStream(file);
domXml(in, file, domHandler);
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/**
* dom解析xml
*
* @param in
* @param file
* @param domHandler
*/
public static void domXml(InputStream in, File file, DomHandler domHandler) {
SAXBuilder saxBuilder = new SAXBuilder();
Document doc = null;
try {
doc = saxBuilder.build(in);
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
domHandler.resultCallback(doc);
if (file != null) {
Format format = Format.getCompactFormat();
// 设置XML文件的缩进为4个空格
format.setIndent(" ");
// 设置XML文件的字符集为UTF-8
format.setEncoding("UTF-8");
// 将格式应用到输出流中
XMLOutputter XMLOut = new XMLOutputter(format);
// 将文档通过文件输出流生成xml文件
try {
XMLOut.output(doc, new FileOutputStream(file));
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.web.util;
import org.jdom2.Document;
public abstract class DomHandler {
public abstract void resultCallback(Document doc);
}
package com.web.util;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
public class WebServiceTool {
public final static String GET = "GET";
public final static String POST = "POST";
public final static String PUT = "PUT";
public final static String DELETE = "DELETE";
public final static Integer TIMEOUT = 5000;
public static void sendRest(String urlStr, Map<String, Object> params,
String method, WebServiceCallBack webServiceCallBack)
throws Exception {
if (GET.equalsIgnoreCase(method)) {
sendGet(urlStr, params, webServiceCallBack);
} else if (POST.equalsIgnoreCase(method)) {
sendPost(urlStr, params, webServiceCallBack);
}
}
public static void sendSoap(String urlStr, Map<String, String> headers,
String soapStr, WebServiceCallBack webServiceCallBack)
throws Exception {
URL url = new URL(urlStr);
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(POST);
httpURLConn.setConnectTimeout(TIMEOUT);
// 设置请求头
if (headers != null) {
for (String key : headers.keySet()) {
httpURLConn.setRequestProperty(key, headers.get(key));
}
}
httpURLConn.connect();
OutputStream out = null;
// 发送soap包
if (StringUtils.isNotBlank(soapStr)) {
out = httpURLConn.getOutputStream();
out.write(soapStr.getBytes());
out.flush();
}
String contentType = httpURLConn.getContentType();
// 获得响应流
InputStream in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
public static void sendGet(String urlStr, Map<String, Object> params,
WebServiceCallBack webServiceCallBack) {
StringBuffer urlSb = new StringBuffer(urlStr);
int i = 0;
if (params != null) {
for (String key : params.keySet()) {
if (i++ == 0) {
urlSb.append("?");
} else {
urlSb.append("&");
}
urlSb.append(key);
urlSb.append("=");
urlSb.append(params.get(key));
}
}
URL url;
InputStream in = null;
try {
url = new URL(urlSb.toString());
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(GET);
httpURLConn.setConnectTimeout(TIMEOUT);
httpURLConn.connect();
String contentType = httpURLConn.getContentType();
in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void sendPost(String urlStr, Map<String, Object> params,
WebServiceCallBack webServiceCallBack) throws Exception {
StringBuffer paramStr = new StringBuffer();
int counter=0;
for (String key : params.keySet()) {
Object value = params.get(key);
paramStr.append(key).append("=").append(value);
if (++counter!=params.size()) {
paramStr.append("&");
}
}
URL url = new URL(urlStr);
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(POST);
httpURLConn.connect();
OutputStream out = httpURLConn.getOutputStream();
DataOutputStream serviceDataout = new DataOutputStream(
out);
serviceDataout.write(paramStr.toString().getBytes("UTF-8"));
String contentType = httpURLConn.getContentType();
InputStream in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
}
public static String getSoap(String soapClassPath,
Map<String, Object> params) throws IOException {
String soapDiskPath = WebServiceTool.class.getResource(
"/" + soapClassPath).getPath();
StringBuffer soap = new StringBuffer();
InputStream in = new FileInputStream(soapDiskPath);
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(in));
String line = null;
while ((line = bufferedReader.readLine()) != null) {
if (params != null && params.size() > 0) {
for (String key : params.keySet()) {
line = line.replace("$" + key + "$", params.get(key) + "");
}
}
soap.append(line).append(System.getProperty("line.separator"));
}
return soap.toString();
}
}
package com.web.util;
import java.io.InputStream;
public interface WebServiceCallBack {
public void resultHandler(InputStream in,String contentType);
}
package com.teamax.action;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.views.util.ContextUtil;
import org.jdom2.Document;
import org.jdom2.Namespace;
import com.opensymphony.xwork2.ActionContext;
import com.sun.org.apache.bcel.internal.generic.NEW;
import com.web.util.DomHandler;
import com.web.util.WebServiceCallBack;
import com.web.util.WebServiceTool;
import com.web.util.XmlUtil;
public class SurveyingDataAction {
private final String getMetaListSoapTemp = "GetMetaList.txt";
private final String getMetaInfoSoapTemp = "GetMetaInfo.txt";
private final String getMetaTypesSoapTemp = "GetMetaTypes.txt";
private static String urlString = null;
private static String terrainMapGeometryUrl = null;
private String json = null;
static {
InputStream in = SurveyingDataAction.class
.getResourceAsStream("/webService.properties");
Properties properties = new Properties();
try {
properties.load(in);
} catch (IOException e) {
e.printStackTrace();
}
urlString = properties.getProperty("surveyingData");
terrainMapGeometryUrl = properties.getProperty("terrainMapVector");
}
public String getMetaList() {
// Map<String, Object> params = new HashMap<String, Object>();
// params.put("typeId", "");
// params.put("startIndex", "");
// params.put("pageSize", "");
Map<String, Object> params = dealMap(ActionContext.getContext()
.getParameters());
final Object typeId=params.get("typeId");
try {
String soapStr = WebServiceTool
.getSoap(getMetaListSoapTemp, params);
Map<String, String> headers = new HashMap<String, String>();
headers.put("Content-Type", "application/soap+xml; charset=utf-8");
headers.put("Content-Length",
String.valueOf(soapStr.getBytes().length));
headers.put("Host", "192.168.1.11");
WebServiceTool.sendSoap(urlString, headers, soapStr,
new WebServiceCallBack() {
@Override
public void resultHandler(InputStream in,
String contentType) {
XmlUtil.domXml(in, null, new DomHandler() {
@Override
public void resultCallback(Document doc) {
json = doc
.getRootElement()
.getChild(
"Body",
Namespace
.getNamespace(
"soap12",
"http://www.w3.org/2003/05/soap-envelope"))
.getChild(
"GetMetaListResponse",
Namespace
.getNamespace("http://tempuri.org/"))
.getChildText(
"GetMetaListResult",
Namespace
.getNamespace("http://tempuri.org/"));
}
});
}
});
JSONArray jsonArray=JSONArray.fromObject(json);
for (int i = 0; i < jsonArray.size(); i++) {
jsonArray.getJSONObject(i).put("TYPEID",typeId);
}
ActionContext.getContext().put("json", jsonArray.toString());
} catch (Exception e) {
e.printStackTrace();
}
return "resource_data_PE";
}
public String getGeometry() {
Object type = ServletActionContext.getRequest().getParameter("type");
String byframe = null;
if (type != null) {
try {
byframe = new String(type.toString().getBytes("ISO-8859-1"),
"UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
} else {
byframe = "''";
}
Map<String, Object> params = new HashMap<String, Object>();
params.put("f", "pjson");
params.put("gdbVersion", "");
params.put("geometry", "");
params.put("geometryPrecision", "");
params.put("geometryType", "esriGeometryEnvelope");
params.put("groupByFieldsForStatistics", "");
params.put("inSR", "");
params.put("maxAllowableOffset", "");
params.put("objectIds", "");
params.put("orderByFields", "");
params.put("outFields", "");
params.put("outSR", "");
params.put("outStatistics", "");
params.put("relationParam", "");
params.put("returnCountOnly", "false");
params.put("returnGeometry", "true");
params.put("returnIdsOnly", "false");
params.put("returnM", "false");
params.put("returnZ", "false");
params.put("spatialRel", "esriSpatialRelIntersects");
params.put("text", "");
params.put("time", "");
// params.put("where", "BYFRAME='218-262-II'");
params.put("where", "BYFRAME='" + byframe + "'");
// params.put("where", "1=1");
try {
WebServiceTool.sendPost(terrainMapGeometryUrl, params,
new WebServiceCallBack() {
@Override
public void resultHandler(InputStream in,
String contentType) {
BufferedReader bufferedReader = null;
try {
bufferedReader = new BufferedReader(
new InputStreamReader(in, "UTF-8"));
} catch (UnsupportedEncodingException e1) {
e1.printStackTrace();
}
StringBuffer json = new StringBuffer();
String temp = null;
try {
while ((temp = bufferedReader.readLine()) != null) {
json.append(temp);
}
} catch (IOException e) {
e.printStackTrace();
}
// StringBuffer pointsStr = new StringBuffer();
JSONObject jsonObject = JSONObject.fromObject(json
.toString());
JSONArray pointsArray = jsonObject
.getJSONArray("features").getJSONObject(0)
.getJSONObject("geometry")
.getJSONArray("rings").getJSONArray(0);
ActionContext.getContext().put("points",
pointsArray.toString());
}
});
} catch (Exception e) {
e.printStackTrace();
}
return "loadMap";
}
public void getMetaInfo() throws UnsupportedEncodingException {
Object typeId = ServletActionContext.getRequest().getParameter("typeId");
Object metaId = ServletActionContext.getRequest().getParameter("metaId");
metaId=new String(metaId.toString().getBytes("ISO-8859-1"), "UTF-8");
Map<String, Object> params=new HashMap<String, Object>();
params.put("typeId", typeId);
params.put("metaId", metaId);
try {
String soapStr = WebServiceTool.getSoap(getMetaInfoSoapTemp,
params);
Map<String, String> headers = new HashMap<String, String>();
headers.put("Content-Type", "application/soap+xml; charset=utf-8");
headers.put("Content-Length",
String.valueOf(soapStr.getBytes().length));
headers.put("Host", "192.168.1.11");
WebServiceTool.sendSoap(urlString, headers, soapStr,
new WebServiceCallBack() {
@Override
public void resultHandler(InputStream in,
String contentType) {
XmlUtil.domXml(in, null, new DomHandler() {
@Override
public void resultCallback(Document doc) {
json = doc.getRootElement()
.getChild("Body",Namespace.getNamespace("soap12","http://www.w3.org/2003/05/soap-envelope"))
.getChild("GetMetaInfoResponse",Namespace.getNamespace("http://tempuri.org/"))
.getChildText("GetMetaInfoResult",Namespace.getNamespace("http://tempuri.org/"));
}
});
}
});
StringBuffer jsonFormat=new StringBuffer();
JSONArray jsonArray=JSONArray.fromObject(json);
jsonFormat.append("[");
for (int i = 0; i < jsonArray.size(); i++) {
jsonFormat.append("{");
JSONObject jsonObject=jsonArray.getJSONObject(i);
for (Object key : jsonObject.keySet()) {
jsonFormat.append(System.getProperty("line.separator"));
jsonFormat.append("\"");
jsonFormat.append(key);
jsonFormat.append("\"");
jsonFormat.append(":");
jsonFormat.append("\"");
jsonFormat.append(jsonObject.get(key));
jsonFormat.append("\"");
jsonFormat.append(",");
}
jsonFormat.append("}");
}
jsonFormat.append("]");
printStrText("<pre>"+jsonFormat.toString()+"</pre>");
} catch (Exception e) {
e.printStackTrace();
}
}
public void getMetaTypes() {
try {
String soapStr = WebServiceTool.getSoap(getMetaTypesSoapTemp, null);
Map<String, String> headers = new HashMap<String, String>();
headers.put("Content-Type", "application/soap+xml; charset=utf-8");
headers.put("Content-Length",
String.valueOf(soapStr.getBytes().length));
headers.put("Host", "192.168.1.11");
WebServiceTool.sendSoap(urlString, headers, soapStr,
new WebServiceCallBack() {
@Override
public void resultHandler(InputStream in,
String contentType) {
XmlUtil.domXml(in, null, new DomHandler() {
@Override
public void resultCallback(Document doc) {
json = doc
.getRootElement()
.getChild(
"Body",
Namespace
.getNamespace(
"soap12",
"http://www.w3.org/2003/05/soap-envelope"))
.getChild(
"GetMetaTypesResponse",
Namespace
.getNamespace("http://tempuri.org/"))
.getChildText(
"GetMetaTypesResult",
Namespace
.getNamespace("http://tempuri.org/"));
}
});
}
});
printStrText(json);
} catch (Exception e) {
e.printStackTrace();
}
}
private void printStrText(String value) throws Exception {
HttpServletResponse response = ServletActionContext.getResponse();
response.setHeader("Pragma", "No-cache");
response.setHeader("Cache-Control", "no-cache");
response.setDateHeader("Expires", 0);
response.setContentType("text/html;charset=UTF-8");
response.getWriter().print(value);
}
private Map<String, Object> dealMap(Map<String, Object> objMap) {
Map<String, Object> strMap = new HashMap<String, Object>();
for (String key : objMap.keySet()) {
String[] value = (String[]) (objMap.get(key));
strMap.put(key, value[0]);
}
return strMap;
}
}
|
package com.web.util;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.List;
import java.util.Map;
import org.apache.commons.lang.StringUtils;
import org.apache.struts2.ServletActionContext;
import org.apache.struts2.views.util.ContextUtil;
import com.opensymphony.xwork2.ActionContext;
public class WebServiceTool {
public final static String GET = "GET";
public final static String POST = "POST";
public final static String PUT = "PUT";
public final static String DELETE = "DELETE";
public final static Integer TIMEOUT = 5000;
public static void sendRest(String urlStr, Map<String, Object> params,
String method, WebServiceCallBack webServiceCallBack)
throws Exception {
if (GET.equalsIgnoreCase(method)) {
sendGet(urlStr, params, webServiceCallBack);
} else if (POST.equalsIgnoreCase(method)) {
sendPost(urlStr, params, webServiceCallBack);
}
}
public static void sendSoap(String urlStr, Map<String, String> headers,
String soapStr, WebServiceCallBack webServiceCallBack)
throws Exception {
URL url = new URL(urlStr);
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(POST);
httpURLConn.setConnectTimeout(TIMEOUT);
// 设置请求头
if (headers != null) {
for (String key : headers.keySet()) {
httpURLConn.setRequestProperty(key, headers.get(key));
}
}
httpURLConn.connect();
OutputStream out = null;
// 发送soap包
if (StringUtils.isNotBlank(soapStr)) {
out = httpURLConn.getOutputStream();
out.write(soapStr.getBytes());
out.flush();
}
String contentType = httpURLConn.getContentType();
// 获得响应流
InputStream in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
if (in != null) {
in.close();
}
if (out != null) {
out.close();
}
}
public static void sendGet(String urlStr, Map<String, Object> params,
WebServiceCallBack webServiceCallBack) {
StringBuffer urlSb = new StringBuffer(urlStr);
int i = 0;
if (params != null) {
for (String key : params.keySet()) {
if (i++ == 0) {
urlSb.append("?");
} else {
urlSb.append("&");
}
urlSb.append(key);
urlSb.append("=");
urlSb.append(params.get(key));
}
}
URL url;
InputStream in = null;
try {
url = new URL(urlSb.toString());
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(GET);
httpURLConn.setConnectTimeout(TIMEOUT);
httpURLConn.connect();
String contentType = httpURLConn.getContentType();
in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
} catch (Exception e) {
e.printStackTrace();
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public static void sendPost(String urlStr, Map<String, Object> params,
WebServiceCallBack webServiceCallBack) throws Exception {
StringBuffer paramStr = new StringBuffer();
int counter=0;
for (String key : params.keySet()) {
Object value = params.get(key);
paramStr.append(key).append("=").append(value);
if (++counter!=params.size()) {
paramStr.append("&");
}
}
URL url = new URL(urlStr);
HttpURLConnection httpURLConn = (HttpURLConnection) url
.openConnection();
httpURLConn.setDoInput(true);
httpURLConn.setDoOutput(true);
httpURLConn.setRequestMethod(POST);
httpURLConn.connect();
OutputStream out = httpURLConn.getOutputStream();
DataOutputStream serviceDataout = new DataOutputStream(
out);
serviceDataout.write(paramStr.toString().getBytes("UTF-8"));
String contentType = httpURLConn.getContentType();
InputStream in = httpURLConn.getInputStream();
webServiceCallBack.resultHandler(in, contentType);
}
public static String getSoap(String soapClassPath,
Map<String, Object> params) throws IOException {
String soapDiskPath = WebServiceTool.class.getResource(
"/" + soapClassPath).getPath();
StringBuffer soap = new StringBuffer();
InputStream in = new FileInputStream(soapDiskPath);
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(in));
String line = null;
while ((line = bufferedReader.readLine()) != null) {
if (params != null && params.size() > 0) {
for (String key : params.keySet()) {
line = line.replace("$" + key + "$", params.get(key) + "");
}
}
soap.append(line).append(System.getProperty("line.separator"));
}
return soap.toString();
}
}
package com.web.util;
import java.io.InputStream;
public interface WebServiceCallBack {
public void resultHandler(InputStream in,String contentType);
}
|
