一、日期工具类
package com.ebd.application.common.utils;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.apache.commons.lang.time.DateFormatUtils;
/**
* 日期工具类, 继承org.apache.commons.lang.time.DateUtils类
*/
public class DateUtils extends org.apache.commons.lang.time.DateUtils {
private static String[] parsePatterns = { "yyyy-MM-dd",
"yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy/MM/dd",
"yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm" };
/**
* 得到当前日期字符串 格式（yyyy-MM-dd）
*/
public static String getDate() {
return getDate("yyyy-MM-dd");
}
/**
* Timestamp to Date String
*/
public static String timestamptoString(Long timestampStr) {
Timestamp ts = new Timestamp(timestampStr);
String dateStr = "";
DateFormat sdf = new SimpleDateFormat(parsePatterns[1]);
try {
dateStr = sdf.format(ts);
} catch (Exception e) {
e.printStackTrace();
}
return dateStr;
}
/**
* 得到当前日期字符串 格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String getDate(String pattern) {
return DateFormatUtils.format(new Date(), pattern);
}
/**
* 得到日期字符串 默认格式（yyyy-MM-dd） pattern可以为："yyyy-MM-dd" "HH:mm:ss" "E"
*/
public static String formatDate(Date date, Object... pattern) {
String formatDate = null;
if (pattern != null && pattern.length > 0) {
formatDate = DateFormatUtils.format(date, pattern[0].toString());
} else {
formatDate = DateFormatUtils.format(date, "yyyy-MM-dd");
}
return formatDate;
}
/**
* 得到日期时间字符串，转换格式（yyyy-MM-dd HH:mm:ss）
*/
public static String formatDateTime(Date date) {
return formatDate(date, "yyyy-MM-dd HH:mm:ss");
}
/**
* 得到当前时间字符串 格式（HH:mm:ss）
*/
public static String getTime() {
return formatDate(new Date(), "HH:mm:ss");
}
/**
* 得到当前日期和时间字符串 格式（yyyy-MM-dd HH:mm:ss）
*/
public static String getDateTime() {
return formatDate(new Date(), "yyyy-MM-dd HH:mm:ss");
}
/**
* 得到当前年份字符串 格式（yyyy）
*/
public static String getYear() {
return formatDate(new Date(), "yyyy");
}
/**
* 得到当前月份字符串 格式（MM）
*/
public static String getMonth() {
return formatDate(new Date(), "MM");
}
/**
* 得到当天字符串 格式（dd）
*/
public static String getDay() {
return formatDate(new Date(), "dd");
}
/**
* 得到当前星期字符串 格式（E）星期几
*/
public static String getWeek() {
return formatDate(new Date(), "E");
}
/**
* 日期型字符串转化为日期 格式 { "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm",
* "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm" }
*/
public static Date parseDate(Object str) {
if (str == null) {
return null;
}
try {
return parseDate(str.toString(), parsePatterns);
} catch (ParseException e) {
return null;
}
}
/**
* 获取过去的天数
*
* @param date
* @return
*/
public static long pastDays(Date date) {
long t = new Date().getTime() - date.getTime();
return t / (24 * 60 * 60 * 1000);
}
public static Date getDateStart(Date date) {
if (date == null) {
return null;
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
date = sdf.parse(formatDate(date, "yyyy-MM-dd") + " 00:00:00");
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
public static Date getDateEnd(Date date) {
if (date == null) {
return null;
}
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
date = sdf.parse(formatDate(date, "yyyy-MM-dd") + " 23:59:59");
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
二、文件目录工具
package com.ebd.application.common.utils;
import java.io.File;
import java.io.IOException;
public class CreateFileUtil {
public static boolean createFile(String destFileName) {
File file = new File(destFileName);
if(file.exists()) {
System.out.println("创建单个文件" + destFileName + "失败，目标文件已存在！");
return false;
}
if (destFileName.endsWith(File.separator)) {
System.out.println("创建单个文件" + destFileName + "失败，目标文件不能为目录！");
return false;
}
//判断目标文件所在的目录是否存在
if(!file.getParentFile().exists()) {
//如果目标文件所在的目录不存在，则创建父目录
System.out.println("目标文件所在目录不存在，准备创建它！");
if(!file.getParentFile().mkdirs()) {
System.out.println("创建目标文件所在目录失败！");
return false;
}
}
//创建目标文件
try {
if (file.createNewFile()) {
System.out.println("创建单个文件" + destFileName + "成功！");
return true;
} else {
System.out.println("创建单个文件" + destFileName + "失败！");
return false;
}
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建单个文件" + destFileName + "失败！" + e.getMessage());
return false;
}
}
public static boolean createDir(String destDirName) {
File dir = new File(destDirName);
if (dir.exists()) {
System.out.println(destDirName + "目录已经存在");
return true;
}
if (!destDirName.endsWith(File.separator)) {
destDirName = destDirName + File.separator;
}
//创建目录
if (dir.mkdirs()) {
System.out.println("创建目录" + destDirName + "成功！");
return true;
} else {
System.out.println("创建目录" + destDirName + "失败！");
return false;
}
}
public static String createTempFile(String prefix, String suffix, String dirName) {
File tempFile = null;
if (dirName == null) {
try{
//在默认文件夹下创建临时文件
tempFile = File.createTempFile(prefix, suffix);
//返回临时文件的路径
return tempFile.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建临时文件失败！" + e.getMessage());
return null;
}
} else {
File dir = new File(dirName);
//如果临时文件所在目录不存在，首先创建
if (!dir.exists()) {
if (!CreateFileUtil.createDir(dirName)) {
System.out.println("创建临时文件失败，不能创建临时文件所在的目录！");
return null;
}
}
try {
//在指定目录下创建临时文件
tempFile = File.createTempFile(prefix, suffix, dir);
return tempFile.getCanonicalPath();
} catch (IOException e) {
e.printStackTrace();
System.out.println("创建临时文件失败！" + e.getMessage());
return null;
}
}
}
public static void main(String[] args) {
//创建目录
String dirName = "D:/work/temp/temp0/temp1";
CreateFileUtil.createDir(dirName);
//创建文件
String fileName = dirName + "/temp2/tempFile.txt";
CreateFileUtil.createFile(fileName);
//创建临时文件
String prefix = "temp";
String suffix = ".txt";
for (int i = 0; i < 10; i++) {
System.out.println("创建了临时文件："
+ CreateFileUtil.createTempFile(prefix, suffix, dirName));
}
//在默认目录下创建临时文件
for (int i = 0; i < 10; i++) {
System.out.println("在默认目录下创建了临时文件："
+ CreateFileUtil.createTempFile(prefix, suffix, null));
}
}
}
三、中文判断工具类
package com.ebd.application.common.utils;
import java.util.regex.Pattern;
/**
* 中文判断工具类
* @author Administrator
*/
public class CharUtil {
public static void main(String[] args) {
String[] strArr = new String[] { "www.micmiu.com", "!@#$%^&*()_+{}[]|"'?/:;<>,.", "！￥……（）——：；“”‘’《》，。？、", "不要啊", "やめて", "韩佳人", "???" };
for (String str : strArr) {
System.out.println("===========> 测试字符串：" + str);
System.out.println("正则判断结果：" + isChineseByREG(str) + " -- " + isChineseByName(str));
System.out.println("Unicode判断结果 ：" + isChinese(str));
System.out.println("详细判断列表：");
char[] ch = str.toCharArray();
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
System.out.println(c + " --> " + (isChinese(c) ? "是" : "否"));
}
}
}
// 根据Unicode编码完美的判断中文汉字和符号
private static boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS || ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A || ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION || ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
return true;
}
return false;
}
// 完整的判断中文汉字和符号
public static boolean isChinese(String strName) {
char[] ch = strName.toCharArray();
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (isChinese(c)) {
return true;
}
}
return false;
}
// 只能判断部分CJK字符（CJK统一汉字）
public static boolean isChineseByREG(String str) {
if (str == null) {
return false;
}
Pattern pattern = Pattern.compile("[\u4E00-\u9FBF]+");
return pattern.matcher(str.trim()).find();
}
// 只能判断部分CJK字符（CJK统一汉字）
public static boolean isChineseByName(String str) {
if (str == null) {
return false;
}
// 大小写不同：\p 表示包含，\P 表示不包含
// \p{Cn} 的意思为 Unicode 中未被定义字符的编码，\P{Cn} 就表示 Unicode中已经被定义字符的编码
String reg = "\p{InCJK Unified Ideographs}&&\P{Cn}";
Pattern pattern = Pattern.compile(reg);
return pattern.matcher(str.trim()).find();
}
}
四、文件上传工具
package com.ebd.application.common.utils;
import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.multipart.MultipartFile;
public class FileUploadUtils {
public static final String UPLOAD_URL = "c:/pp";
/**
* 上传图片，图片的名称filename是根据时间+随机数组装成的
* @param file MultipartFile file
* @param request HttpServletRequest request,
* @param uploadDir 上传的目的文件夹
* @return 返回文件的上传地址 (uploadDir/filename)
*/
public static String upload(MultipartFile file, HttpServletRequest request,String uploadDir) {
String logoUrl = null;
if (file != null && !file.isEmpty()) {
System.out.println(request.getSession().getServletContext());
String filePath = request.getSession().getServletContext()
.getRealPath(uploadDir);
//目录不存在时，新建目录
createDirectory(filePath);
//得到原图片的后缀名
String srcfilename = file.getOriginalFilename();
String suffix=srcfilename.substring(srcfilename.lastIndexOf("."));
//组装新图片的名称
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS");
String format = dateFormat.format(new Date());
String filename = format+ new Random().nextInt(1000000)+suffix;
File destFile = new File(filePath, filename);
//如果文件存在，继续随机名称
while(destFile.exists()){
filename = format+ new Random().nextInt(1000000)+suffix;
destFile = new File(filePath, filename);
}
try {
file.transferTo(destFile);
logoUrl = uploadDir + "/" + filename;
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return logoUrl;
}
/**
* 上传文件，文件名为源文件的名称
* @param file
* @param request
* @param uploadDir
* @return 上传文件的路径:uploadDir + "/" + srcfilename
*/
public static String uploadFile(MultipartFile file, HttpServletRequest request,String uploadDir) {
String logoUrl = null;
if (file != null && !file.isEmpty()) {
//获取上传文件夹的真实地址
String dirPath = request.getSession().getServletContext()
.getRealPath(uploadDir);
//目录不存在时，新建目录
createDirectory(dirPath);
//得到源文件的名称
String srcfilename = file.getOriginalFilename();
//构建目标文件
File destFile = new File(dirPath, srcfilename);
try {
//上传文件
file.transferTo(destFile);
logoUrl = uploadDir + "/" + srcfilename;
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
return logoUrl;
}
/**
* 新建目录
* @param dirPath
*/
public static void createDirectory(String dirPath){
if(StringUtils.isNotBlank(dirPath)){
// 获得文件对象
File file = new File(dirPath);
if(!file.exists()){
// 如果路径不存在,则创建
file.mkdirs();
}
}
}
/**
* 删除单个文件
* @param path 被删除文件的文件名
* @return 单个文件删除成功返回true，否则返回false
*/
public static boolean deleteFile(String path){
boolean flag = false;
File file = new File(path);
// 路径为文件且不为空则进行删除
if(file.isFile() && file.exists()){
file.delete();
flag = true;
}
return flag;
}
/**
* 生产缩略图
* @param src 原图
* @param dir 缩略图
* @param fileName 缩略图名称
* @return
*/
public static String thumb(File src,File dir,String fileName,int nw,int nh){
try {
/*
AffineTransform 类表示 2D 仿射变换，它执行从 2D 坐标到其他 2D
坐标的线性映射，保留了线的“直线性”和“平行性”。可以使用一系
列平移、缩放、翻转、旋转和剪切来构造仿射变换。
*/
AffineTransform transform = new AffineTransform();
//读取图片
BufferedImage bis = ImageIO.read(src);
int w = bis.getWidth();
int h = bis.getHeight();
double sx = (double)nw/w;
double sy = (double)nh/h;
//将此变换设置为缩放变换。
transform.setToScale(sx,sy);
/*
* AffineTransformOp类使用仿射转换来执行从源图像或 Raster 中 2D 坐标到目标图像或
* Raster 中 2D 坐标的线性映射。所使用的插值类型由构造方法通过
* 一个 RenderingHints 对象或通过此类中定义的整数插值类型之一来指定。
* 如果在构造方法中指定了 RenderingHints 对象，则使用插值提示和呈现
* 的质量提示为此操作设置插值类型。要求进行颜色转换时，可以使用颜色
* 呈现提示和抖动提示。 注意，务必要满足以下约束：源图像与目标图像
* 必须不同。 对于 Raster 对象，源图像中的 band 数必须等于目标图像中
* 的 band 数。
*/
AffineTransformOp ato = new AffineTransformOp(transform,null);
BufferedImage bid = new BufferedImage(nw,nh,BufferedImage.TYPE_3BYTE_BGR);
/*
* TYPE_3BYTE_BGR 表示一个具有 8 位 RGB 颜色分量的图像，
* 对应于 Windows 风格的 BGR 颜色模型，具有用 3 字节存
* 储的 Blue、Green 和 Red 三种颜色。
*/
ato.filter(bis,bid);
ImageIO.write(bid,"jpeg",dir);
} catch(Exception e) {
e.printStackTrace();
}
return dir + "/" + fileName;
}
/**
* 复制整个文件夹内容
* @param oldPath
* @param newPath
* @return boolean
*/
public static void copyFolder(String oldPath, String newPath) {
try {
//如果文件夹不存在 则建立新文件夹
(new File(newPath)).mkdirs();
File a=new File(oldPath);
String[] file=a.list();
File temp=null;
for (int i = 0; i < file.length; i++) {
if(oldPath.endsWith(File.separator)){
temp=new File(oldPath+file[i]);
}
else{
temp=new File(oldPath+File.separator+file[i]);
}
if(temp.isFile()){
FileInputStream input = new FileInputStream(temp);
FileOutputStream output = new FileOutputStream(newPath + "/" +
(temp.getName()).toString());
byte[] b = new byte[1024 * 5];
int len;
while ( (len = input.read(b)) != -1) {
output.write(b, 0, len);
}
output.flush();
output.close();
input.close();
}
if(temp.isDirectory()){//如果是子文件夹
copyFolder(oldPath+"/"+file[i],newPath+"/"+file[i]);
}
}
}
catch (Exception e) {
System.out.println("复制整个文件夹内容操作出错");
e.printStackTrace();
}
}
/**
* 删除文件夹
* @param filePathAndName
* @param fileContent
* @return boolean
*/
public static void delFolder(String folderPath) {
try {
delAllFile(folderPath); //删除完里面所有内容
String filePath = folderPath;
filePath = filePath.toString();
java.io.File myFilePath = new java.io.File(filePath);
myFilePath.delete(); //删除空文件夹
}
catch (Exception e) {
System.out.println("删除文件夹操作出错");
e.printStackTrace();
}
}
/**
* 删除文件夹里面的所有文件
* @param path
*/
public static void delAllFile(String path) {
File file = new File(path);
if (!file.exists()) {
return;
}
if (!file.isDirectory()) {
return;
}
String[] tempList = file.list();
File temp = null;
for (int i = 0; i < tempList.length; i++) {
if (path.endsWith(File.separator)) {
temp = new File(path + tempList[i]);
}
else {
temp = new File(path + File.separator + tempList[i]);
}
if (temp.isFile()) {
temp.delete();
}
if (temp.isDirectory()) {
delAllFile(path+"/"+ tempList[i]);//先删除文件夹里面的文件
delFolder(path+"/"+ tempList[i]);//再删除空文件夹
}
}
}
/**
* 移动文件到指定目录
* @param oldPath
* @param newPath
*/
public static void moveFile(String oldPath, String newPath) {
copyFolder(oldPath, newPath);
delFolder(oldPath);
}
public static void main(String[] args) {
// System.out.println(new Date().getTime());
// System.out.println(String.valueOf(new Date().getTime()));
//// File f =new File("TileTest.doc");
// String fileName="TileTest....6.6doc";
// String prefix=fileName.substring(fileName.lastIndexOf("."));
// System.out.println(prefix);
// System.out.println(new Random().nextInt(1000000));
// System.out.println(new Random().nextInt(1000000));
// File f = new File("d:/1.txt");
// System.out.println(f.exists());
File src = new File("D:\dcd01448724c402a8cf8b852e1307510\qrcode_for_gh_cf64bce34a18_344.jpg");
File dir = new File("D:\dcd01448724c402a8cf8b852e1307510");
// File src = new File("D:\architecture\vungu\workspace0428\vp-standweb\src\main\webapp\fileUpload\images\subscribe\dcd01448724c402a8cf8b852e1307510\20160120171448178836077.png");
// File dir = new File("D:\architecture\vungu\workspace0428\vp-standweb\src\main\webapp\fileUpload\images\subscribe\dcd01448724c402a8cf8b852e1307510");
String fileName = "20160120171448178836077thumb.jpg";
int nw=360;
int nh=200;
thumb(src, dir, fileName, nw, nh);
}
}
五、UUID简单工具
package com.ebd.application.common.utils;
import java.security.SecureRandom;
import java.util.UUID;
public class Identities {
private static SecureRandom random = new SecureRandom();
public static String uuid() {
return UUID.randomUUID().toString().replaceAll("-", "");
}
public static long randomLong() {
return Math.abs(random.nextLong());
}
}
六、JDBC工具
package com.ebd.application.common.utils;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* JDBC工具类
* @author Administrator
*/
public class JdbcUtils {
//数据库用户名
private static final String USERNAME = "root";
//数据库密码
private static final String PASSWORD = "root";
//驱动信息
private static final String DRIVER = "com.mysql.jdbc.Driver";
//数据库地址
private static final String URL = "jdbc:mysql://localhost:3306/test";
private Connection connection;
private PreparedStatement pstmt;
private ResultSet resultSet;
public JdbcUtils() {
// TODO Auto-generated constructor stub
try{
Class.forName(DRIVER);
System.out.println("数据库连接成功！");
}catch(Exception e){
}
}
/**
* 获得数据库的连接
* @return
*/
public Connection getConnection(){
try {
connection = DriverManager.getConnection(URL, USERNAME, PASSWORD);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return connection;
}
/**
* 增加、删除、改
* @param sql
* @param params
* @return
* @throws SQLException
*/
public boolean updateByPreparedStatement(String sql, List<Object> params)throws SQLException{
boolean flag = false;
int result = -1;
pstmt = connection.prepareStatement(sql);
int index = 1;
if(params != null && !params.isEmpty()){
for(int i=0; i<params.size(); i++){
pstmt.setObject(index++, params.get(i));
}
}
result = pstmt.executeUpdate();
flag = result > 0 ? true : false;
return flag;
}
/**
* 查询单条记录
* @param sql
* @param params
* @return
* @throws SQLException
*/
public Map<String, Object> findSimpleResult(String sql, List<Object> params) throws SQLException{
Map<String, Object> map = new HashMap<String, Object>();
int index = 1;
pstmt = connection.prepareStatement(sql);
if(params != null && !params.isEmpty()){
for(int i=0; i<params.size(); i++){
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();//返回查询结果
ResultSetMetaData metaData = resultSet.getMetaData();
int col_len = metaData.getColumnCount();
while(resultSet.next()){
for(int i=0; i<col_len; i++ ){
String cols_name = metaData.getColumnName(i+1);
Object cols_value = resultSet.getObject(cols_name);
if(cols_value == null){
cols_value = "";
}
map.put(cols_name, cols_value);
}
}
return map;
}
/**查询多条记录
* @param sql
* @param params
* @return
* @throws SQLException
*/
public List<Map<String, Object>> findModeResult(String sql, List<Object> params) throws SQLException{
List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
int index = 1;
pstmt = connection.prepareStatement(sql);
if(params != null && !params.isEmpty()){
for(int i = 0; i<params.size(); i++){
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while(resultSet.next()){
Map<String, Object> map = new HashMap<String, Object>();
for(int i=0; i<cols_len; i++){
String cols_name = metaData.getColumnName(i+1);
Object cols_value = resultSet.getObject(cols_name);
if(cols_value == null){
cols_value = "";
}
map.put(cols_name, cols_value);
}
list.add(map);
}
return list;
}
/**通过反射机制查询单条记录
* @param sql
* @param params
* @param cls
* @return
* @throws Exception
*/
public <T> T findSimpleRefResult(String sql, List<Object> params,
Class<T> cls )throws Exception{
T resultObject = null;
int index = 1;
pstmt = connection.prepareStatement(sql);
if(params != null && !params.isEmpty()){
for(int i = 0; i<params.size(); i++){
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while(resultSet.next()){
//通过反射机制创建一个实例
resultObject = cls.newInstance();
for(int i = 0; i<cols_len; i++){
String cols_name = metaData.getColumnName(i+1);
Object cols_value = resultSet.getObject(cols_name);
if(cols_value == null){
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true); //打开javabean的访问权限
field.set(resultObject, cols_value);
}
}
return resultObject;
}
/**通过反射机制查询多条记录
* @param sql
* @param params
* @param cls
* @return
* @throws Exception
*/
public <T> List<T> findMoreRefResult(String sql, List<Object> params,
Class<T> cls )throws Exception {
List<T> list = new ArrayList<T>();
int index = 1;
pstmt = connection.prepareStatement(sql);
if(params != null && !params.isEmpty()){
for(int i = 0; i<params.size(); i++){
pstmt.setObject(index++, params.get(i));
}
}
resultSet = pstmt.executeQuery();
ResultSetMetaData metaData = resultSet.getMetaData();
int cols_len = metaData.getColumnCount();
while(resultSet.next()){
//通过反射机制创建一个实例
T resultObject = cls.newInstance();
for(int i = 0; i<cols_len; i++){
String cols_name = metaData.getColumnName(i+1);
Object cols_value = resultSet.getObject(cols_name);
if(cols_value == null){
cols_value = "";
}
Field field = cls.getDeclaredField(cols_name);
field.setAccessible(true); //打开javabean的访问权限
field.set(resultObject, cols_value);
}
list.add(resultObject);
}
return list;
}
/**
* 释放数据库连接
*/
public void releaseConn(){
if(resultSet != null){
try{
resultSet.close();
}catch(SQLException e){
e.printStackTrace();
}
}
}
/**
* @param args
*/
public static void main(String[] args) throws SQLException {
// TODO Auto-generated method stub
JdbcUtils jdbcUtils = new JdbcUtils();
jdbcUtils.getConnection();
/*******************增*********************/
/* String sql = "insert into userinfo (username, pswd) values (?, ?), (?, ?), (?, ?)";
List<Object> params = new ArrayList<Object>();
params.add("小明");
params.add("123xiaoming");
params.add("张三");
params.add("zhangsan");
params.add("李四");
params.add("lisi000");
try {
boolean flag = jdbcUtils.updateByPreparedStatement(sql, params);
System.out.println(flag);
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
/*******************删*********************/
//删除名字为张三的记录
/* String sql = "delete from userinfo where username = ?";
List<Object> params = new ArrayList<Object>();
params.add("小明");
boolean flag = jdbcUtils.updateByPreparedStatement(sql, params);*/
/*******************改*********************/
//将名字为李四的密码改了
/* String sql = "update userinfo set pswd = ? where username = ? ";
List<Object> params = new ArrayList<Object>();
params.add("lisi88888");
params.add("李四");
boolean flag = jdbcUtils.updateByPreparedStatement(sql, params);
System.out.println(flag);*/
/*******************查*********************/
//不利用反射查询多个记录
/* String sql2 = "select * from userinfo ";
List<Map<String, Object>> list = jdbcUtils.findModeResult(sql2, null);
System.out.println(list);*/
//利用反射查询 单条记录
// String sql = "select * from userinfo where username = ? ";
// List<Object> params = new ArrayList<Object>();
// params.add("李四");
// UserInfo userInfo;
// try {
// userInfo = jdbcUtils.findSimpleRefResult(sql, params, UserInfo.class);
// System.out.print(userInfo);
// } catch (Exception e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
String sql2 = "select * from student ";
List<Map<String, Object>> list = jdbcUtils.findModeResult(sql2, null);
System.out.println(list);
}
}
七、JsonUtil
package com.ebd.application.common.utils;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.BooleanUtils;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;
public class JsonUtil extends BaseController{
@SuppressWarnings("unused")
private HttpServletRequest request;
private HttpServletResponse response ;
public JsonUtil(HttpServletRequest request, HttpServletResponse response) {
this.request = request;
this.response = response;
}
/**
* ajax后台封装jsonString
* @param jsonStr
* @throws IOException
*/
public void sendJson(String jsonStr) throws IOException {
response.setContentType("text/html;charset=utf-8");
PrintWriter out = response.getWriter();
out.print(jsonStr);
out.flush();
out.close();
}
/**
* json字符串转成Java的Array数组
* @param json
* @param clazz
* @return
*/
@SuppressWarnings("rawtypes")
public static Object[] readJSON2Array(String json, Class clazz) {
JSONArray jsonArray = JSONArray.fromObject(json);
Object[] infoList = (Object[]) JSONArray.toArray(jsonArray, clazz);
return infoList;
}
/**
* JSON字符串转成Java的List集合
* @param json
* @param clazz
* @return
*/
@SuppressWarnings({ "rawtypes", "deprecation" })
public static List<?> readJSON2List(String json, Class clazz) {
JSONArray jsonArray = JSONArray.fromObject(json);
List<?> infoList = JSONArray.toList(jsonArray, clazz);
return infoList;
}
/**
* JSON对象反序列化成Java对象
* @param json
* @param clazz
* @return
*/
@SuppressWarnings("rawtypes")
public static Object readJSON2Bean(String json, Class clazz) {
JSONObject jsonObject = JSONObject.fromObject(json);
Object bean = JSONObject.toBean(jsonObject, clazz);
return bean;
}
/**
* 生成json格式串
* @param bean
* @param isSeri
* @param isFix
* @return
*/
public static String writeBean2JSON(Object bean, boolean isSeri, boolean isFix) {
if (bean == null) {
return null;
}
String jsonStr = null;
if (BooleanUtils.isTrue(isSeri)) {
jsonStr = JSONSerializer.toJSON(bean).toString();
if (BooleanUtils.isTrue(isFix)) {
jsonStr = "[" + jsonStr + "]";
}
} else {
if (BooleanUtils.isTrue(isFix)) {
jsonStr = JSONArray.fromObject(bean).toString();
} else {
jsonStr = JSONObject.fromObject(bean).toString();
}
}
return jsonStr;
}
/**
* List生成Json
* @param list
* @param isSeri
* @param isFix
* @return
*/
public static String writeList2JSON(List<?> list, boolean isSeri,
boolean isFix) {
if (list == null) {
return null;
}
String jsonStr = null;
if (BooleanUtils.isTrue(isSeri)) {// 需要序列化
jsonStr = JSONSerializer.toJSON(list).toString();
if (BooleanUtils.isTrue(isFix)) {
jsonStr = "[" + jsonStr + "]";
}
} else {
if (BooleanUtils.isTrue(isFix)) {
jsonStr = JSONArray.fromObject(list).toString();
} else {
jsonStr = JSONObject.fromObject(list).toString();
}
}
return jsonStr;
}
/**
* Map生成Json
* @param map
* @param isSeri
* @param isFix
* @return
*/
public static String writeMap2JSON(Map<String, Object> map, boolean isSeri,
boolean isFix) {
String jsonStr = null;
if (BooleanUtils.isTrue(isSeri)) {// 序列化
jsonStr = JSONSerializer.toJSON(map).toString();
if (BooleanUtils.isTrue(isFix)) {
jsonStr = "[" + jsonStr + "]";
}
} else {
if (BooleanUtils.isTrue(isFix)) {
jsonStr = JSONArray.fromObject(map).toString();
} else {
jsonStr = JSONObject.fromObject(map).toString();
}
}
return jsonStr;
}
/**
* Json串转为Bean
* @param json
* @param clazz
* @param subList
* @return
*/
@SuppressWarnings("rawtypes")
public static Object readJSON2Bean(String json, Class clazz, Map<String, Object> subList) {
JSONObject jsonObject = JSONObject.fromObject(json);
Object bean = JSONObject.toBean(jsonObject, clazz, subList);
return bean;
}
}
八、SpringUtils
package com.ebd.application.common.utils;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public final class SpringUtils implements BeanFactoryPostProcessor {
private static ConfigurableListableBeanFactory beanFactory; // Spring应用上下文环境
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
SpringUtils.beanFactory = beanFactory;
}
/**
* 获取对象
* @param name
* @return Object 一个以所给名字注册的bean的实例
* @throws org.springframework.beans.BeansException
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException {
return (T) beanFactory.getBean(name);
}
/**
* 获取类型为requiredType的对象
* @param clz
* @return
* @throws org.springframework.beans.BeansException
*
*/
public static <T> T getBean(Class<T> clz) throws BeansException {
T result = (T) beanFactory.getBean(clz);
return result;
}
/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
*
* @param name
* @return boolean
*/
public static boolean containsBean(String name) {
return beanFactory.containsBean(name);
}
/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
* 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
*
* @param name
* @return boolean
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
return beanFactory.isSingleton(name);
}
/**
* @param name
* @return Class 注册对象的类型
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
return beanFactory.getType(name);
}
/**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名
*
* @param name
* @return
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
*
*/
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
return beanFactory.getAliases(name);
}
}