java 的一些常用方法

1.获取某个前端页面的内容

/**
* 获得url页面信息
* 
* @param url
*            网址
* @return 字符串
* @throws IOException
*/
public static StringBuffer getUrl(String url) throws IOException {
BufferedReader in = null;
StringBuffer stb = new StringBuffer();
try {
URL u = new URL(url);
System.out.println("URL:" + url);
in = new BufferedReader(new InputStreamReader(u.openStream(),
"utf-8"));
String str;
while ((str = in.readLine()) != null) {
stb.append(str);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
in.close();
}
return stb;
}

2.获取项目的访问路径

/**
* 获得项目访问路径
* 
* @param request
* @return
*/
public static String getItemUrl(HttpServletRequest request) {
String path = request.getContextPath();
itemUrl = request.getScheme() + "://" + request.getServerName() + ":"
+ request.getServerPort() + path + "/";
return getItemUrl();
}

以下为我常用的一些方法

/**
* json 反序列化 方法。把 一个json字符串，反序列化成 指定类型的对象
* 
* @param <T>
* @return
*/
public static <T> T JsonDeserialize(String jsonAsString, Class<T> pojoClass)
throws JsonMappingException, JsonParseException, IOException {
ObjectMapper objectMapper = new ObjectMapper();
return objectMapper.readValue(jsonAsString, pojoClass);
}


/**
* 将对象转成jsonString形式
*/
public static <T> JSONObject JsonSerialize(T t) {
JSONObject jsonObject = JSONObject.fromObject(t);
return jsonObject;
}


/**
* 读取Request的内容
* 
* @param Request
* @return
*/
public static String ReadRequestContent(HttpServletRequest Request) {
StringBuilder sb = new StringBuilder();


String line = null;
try {
BufferedReader in = new BufferedReader(new InputStreamReader(
Request.getInputStream()));


while ((line = in.readLine()) != null) {
sb.append(line);
}
} catch (IOException e) {
e.printStackTrace();
}
String result = sb.toString();
return result;
}


/**
* 取得当前时间戳（精确到秒）
* 
* @return
*/
public static String timeStamp() {
long time = System.currentTimeMillis();
String t = String.valueOf(time / 1000);
return t;
}


/**
* 生成随机串，随机串包含字母或数字
* 
* @return 随机串
*/
public static String getnonceStr() {
String val = "";
Random random = new Random();
int length = random.nextInt(31);
if (length < 10) {
length = 11;
}
for (int i = 0; i < length; i++) {
// 输出字母还是数字
String charOrNum = random.nextInt(2) % 2 == 0 ? "char" : "num";
// 字符串
if ("char".equalsIgnoreCase(charOrNum)) {
// 取得大写字母还是小写字母
int choice = random.nextInt(2) % 2 == 0 ? 65 : 97;
val += (char) (choice + random.nextInt(26));
} else if ("num".equalsIgnoreCase(charOrNum)) { // 数字
val += String.valueOf(random.nextInt(10));
}
}
return val;
}


/**
* 将字节数组转化成字符串
*/
public static String byte2str(byte[] array) {
StringBuffer hexstr = new StringBuffer();
String shaHex = "";
for (int i = 0; i < array.length; i++) {
shaHex = Integer.toHexString(array[i] & 0xFF);
if (shaHex.length() < 2) {
hexstr.append(0);
}
hexstr.append(shaHex);


}
return hexstr.toString();
}


/**
* 处理http GET.POST请求，返回数据
* 
* 请求的url地址http GET成功后返回的数据，失败抛WebException异常
*/
public static JSONObject httpsRequest(String requestUrl,
String requestMethod, String outputStr) {
JSONObject jsonObject = null;
try {
// 创建SSLContext对象，并使用我们指定的信任管理器初始化
TrustManager[] tm = { new MyX509TrustManager() };
SSLContext sslContext = SSLContext.getInstance("SSL", "SunJSSE");
sslContext.init(null, tm, new java.security.SecureRandom());
// 从上述SSLContext对象中得到SSLSocketFactory对象
SSLSocketFactory ssf = sslContext.getSocketFactory();


URL url = new URL(requestUrl);
HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
conn.setSSLSocketFactory(ssf);


conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
// 设置请求方式（GET/POST）
conn.setRequestMethod(requestMethod);


// 当outputStr不为null时向输出流写数据
if (null != outputStr) {
OutputStream outputStream = conn.getOutputStream();
// 注意编码格式
outputStream.write(outputStr.getBytes("UTF-8"));
outputStream.close();
}


// 从输入流读取返回内容
InputStream inputStream = conn.getInputStream();
InputStreamReader inputStreamReader = new InputStreamReader(
inputStream, "utf-8");
BufferedReader bufferedReader = new BufferedReader(
inputStreamReader);
String str = null;
StringBuffer buffer = new StringBuffer();
while ((str = bufferedReader.readLine()) != null) {
buffer.append(str);
}


// 释放资源
bufferedReader.close();
inputStreamReader.close();
inputStream.close();
inputStream = null;
conn.disconnect();
String o = buffer.toString();
if (o.contains("[CDATA")) {


o = o.replace("<![CDATA[", "").replace("]]>", "");
XMLSerializer xmlSerializer = new XMLSerializer();
JSON json = xmlSerializer.read(o);
return (JSONObject) json;
}
jsonObject = JSONObject.fromObject(o);
} catch (ConnectException ce) {
ce.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return jsonObject;
}


/**
* java对象转化成xml字符串
* 
* java对象实例 String xml字符串
*/
private static XStream xstream = new XStream(new XppDriver() {
public HierarchicalStreamWriter createWriter(Writer out) {
return new PrettyPrintWriter(out) {
// 对所有的xml节点都增加cdata标记
boolean cdata = true;


public void starNode(String name, Class clazz) {
super.startNode(name, clazz);
}


protected void writeText(QuickWriter writer, String text) {
if (cdata) {
writer.write("<![CDATA[");
writer.write(text);
writer.write("]]>");
} else {
writer.write(text);
}


}
};


}


});


public static String serializeToXml(Object obj) {
PayData paydata = (PayData) obj;
xstream.alias("xml", PayData.class);
return xstream.toXML(paydata);


}


public static String serializeToXml1(Object obj) {
com.pb.action.weixinApp.util.PayData paydata1 = (com.pb.action.weixinApp.util.PayData) obj;
xstream.alias("xml", com.pb.action.weixinApp.util.PayData.class);
return xstream.toXML(paydata1);


}


/**
* xml对象转化成json
* 
* @param obj
*            java对象实例
* @return String xml字符串
*/
public static HashMap<String, String> parseXML(HttpServletRequest request) {


HashMap<String, String> map = new HashMap<String, String>();
SAXReader reader = new SAXReader();
Document doc;
try {
doc = reader.read(request.getInputStream());
// 得到xml的根节点
Element root = doc.getRootElement();
recursiveParseXML(root, map);
} catch (DocumentException | IOException e) {
e.printStackTrace();
}


return map;
}


private static void recursiveParseXML(Element root,
HashMap<String, String> map) {
// 得到根節點的子節點列表
List<Element> elementlist = root.elements();
// 判斷子元素有沒有列表
if (elementlist.size() == 0) {
map.put(root.getName(), root.getTextTrim());


} else {
for (Element e : elementlist) {
recursiveParseXML(e, map);
}
}
}


/**
* 将传入xml字符串转化为java对象
* 
* @param xmlstr
* @param cls
*            xml对应的class类
* @return T xml对应的class类的实例对象 调用的方法实例：PersonBean
*         person=XmlUtil.toBean(xmlStr, PersonBean.class);
*/
public <T> T deSerizalizeFromXml(String xmlstr, Class<T> cls)
throws Exception {
// 注意：不是new Xstream();否则报错：java.lang.NoClassDefFoundError:
// org/xmlpull/v1/XmlPullParserFactory
XStream xstream = new XStream(new DomDriver());
xstream.processAnnotations(cls);
T obj = (T) xstream.fromXML(xmlstr);
return obj;
}


/**
* 从Request对象中获得客户端IP，处理了HTTP代理服务器和Nginx的反向代理截取了ip
* 
* @param request
* @return ip
*/
public static String getIp2(HttpServletRequest request) {
String ip = request.getHeader("X-Forwarded-For");
if (StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
// 多次反向代理后会有多个ip值，第一个ip才是真实ip
int index = ip.indexOf(",");
if (index != -1) {
return ip.substring(0, index);
} else {
return ip;
}
}
ip = request.getHeader("X-Real-IP");
if (StringUtils.isNotEmpty(ip) && !"unKnown".equalsIgnoreCase(ip)) {
return ip;
}
return request.getRemoteAddr();
}


/**
* 获取编码后的url
* 
* @param source
* @return
*/


public static String urlEncodeUTF8(String source) {
String result = source;
try {
result = URLEncoder.encode(source, "utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return result;
}


/**
* 获取当前的格式化时间
* 
* @param source
* @return
*/


public static String simpleTime() {
SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");
String time = sdf.format(new Date());
return time;
}