概述
RedisUtils
@Component
public final class RedisUtils {
@Autowired
private RedisTemplate<String, Object> redisTemplate;
/**
* 指定缓存失效时间
*
* @param key 键
* @param time 时间(秒)
* @return
*/
public boolean expire(String key, long time) {
try {
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据 key 获取过期时间
*
* @param key 键(不能为 Null)
* @return 时间(秒) 返回0代表永久有效
*/
public long getExpire(String key) {
return redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
/**
* 判断 key 是否存在
*
* @param key 键(不能为 Null)
* @return true 存在 false 不存在
*/
public boolean hashKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除缓存
*
* @param key 可以传一个值 或多个
*/
public void del(String... key) {
if (key != null && key.length > 0) {
redisTemplate.delete(key[0]);
} else {
redisTemplate.delete(CollectionUtils.arrayToList(key));
}
}
//==================================String====================================
/**
* 普通缓存获取
*
* @param key 键
* @return 值
*/
public Object get(String key) {
return key == null ? null : redisTemplate.opsForValue().get(key);
}
/**
* 普通缓存放入
*
* @param key 键
* @param value 值
* @return true 成功 false 失败
*/
public boolean set(String key, Object value) {
try {
redisTemplate.opsForValue().set(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 普通缓存放入并设置时间
*
* @param key 键
* @param value 值
* @param time 时间(秒) time > 0 若 time <= 0 将设置无限期
* @return true 成功 false 失败
*/
public boolean set(String key, Object value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 递增
*
* @param key 键
* @param delta 要增加几(大于0)
* @return
*/
public long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 递减
*
* @param key 键
* @param delta 要减少几(小于0)
* @return
*/
public long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0");
}
return redisTemplate.opsForValue().decrement(key, delta);
}
// ================================Map=================================
/**
* HashGet
*
* @param key 键 不能为null
* @param item 项 不能为null
*/
public Object hget(String key, String item) {
return redisTemplate.opsForHash().get(key, item);
}
/**
* 获取hashKey对应的所有键值
*
* @param key 键
* @return 对应的多个键值
*/
public Map<Object, Object> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* HashSet
*
* @param key 键
* @param map 对应多个键值
*/
public boolean hmset(String key, Map<String, Object> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* HashSet 并设置时间
*
* @param key 键
* @param map 对应多个键值
* @param time 时间(秒)
* @return true成功 false失败
*/
public boolean hmset(String key, Map<String, Object> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value) {
try {
redisTemplate.opsForHash().put(key, item, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 向一张hash表中放入数据,如果不存在将创建
*
* @param key 键
* @param item 项
* @param value 值
* @param time 时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
* @return true 成功 false失败
*/
public boolean hset(String key, String item, Object value, long time) {
try {
redisTemplate.opsForHash().put(key, item, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 删除hash表中的值
*
* @param key 键 不能为null
* @param item 项 可以使多个 不能为null
*/
public void hdel(String key, Object... item) {
redisTemplate.opsForHash().delete(key, item);
}
/**
* 判断hash表中是否有该项的值
*
* @param key 键 不能为null
* @param item 项 不能为null
* @return true 存在 false不存在
*/
public boolean hHasKey(String key, String item) {
return redisTemplate.opsForHash().hasKey(key, item);
}
/**
* hash递增 如果不存在,就会创建一个 并把新增后的值返回
*
* @param key 键
* @param item 项
* @param by 要增加几(大于0)
*/
public double hincr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, by);
}
/**
* hash递减
*
* @param key 键
* @param item 项
* @param by 要减少记(小于0)
*/
public double hdecr(String key, String item, double by) {
return redisTemplate.opsForHash().increment(key, item, -by);
}
// ============================set=============================
/**
* 根据key获取Set中的所有值
*
* @param key 键
*/
public Set<Object> sGet(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 根据value从一个set中查询,是否存在
*
* @param key 键
* @param value 值
* @return true 存在 false不存在
*/
public boolean sHasKey(String key, Object value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将数据放入set缓存
*
* @param key 键
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSet(String key, Object... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 将set数据放入缓存
*
* @param key 键
* @param time 时间(秒)
* @param values 值 可以是多个
* @return 成功个数
*/
public long sSetAndTime(String key, long time, Object... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 获取set缓存的长度
*
* @param key 键
*/
public long sGetSetSize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 移除值为value的
*
* @param key 键
* @param values 值 可以是多个
* @return 移除的个数
*/
public long setRemove(String key, Object... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================list=================================
/**
* 获取list缓存的内容
*
* @param key 键
* @param start 开始
* @param end 结束 0 到 -1代表所有值
*/
public List<Object> lGet(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 获取list缓存的长度
*
* @param key 键
*/
public long lGetListSize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
/**
* 通过索引 获取list中的值
*
* @param key 键
* @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
*/
public Object lGetIndex(String key, long index) {
try {
return redisTemplate.opsForList().index(key, index);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
*/
public boolean lSet(String key, Object value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
*/
public boolean lSet(String key, Object value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @return
*/
public boolean lSet(String key, List<Object> value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将list放入缓存
*
* @param key 键
* @param value 值
* @param time 时间(秒)
* @return
*/
public boolean lSet(String key, List<Object> value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 根据索引修改list中的某条数据
*
* @param key 键
* @param index 索引
* @param value 值
* @return
*/
public boolean lUpdateIndex(String key, long index, Object value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 移除N个值为value
*
* @param key 键
* @param count 移除多少个
* @param value 值
* @return 移除的个数
*/
public long lRemove(String key, long count, Object value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception e) {
e.printStackTrace();
return 0;
}
}
// ===============================HyperLogLog=================================
public long pfadd(String key, String value) {
return redisTemplate.opsForHyperLogLog().add(key, value);
}
public long pfcount(String key) {
return redisTemplate.opsForHyperLogLog().size(key);
}
public void pfremove(String key) {
redisTemplate.opsForHyperLogLog().delete(key);
}
public void pfmerge(String key1, String key2) {
redisTemplate.opsForHyperLogLog().union(key1, key2);
}
}
QRCodeUtil 二维码生成工具
Maven依赖：
<dependency>
<groupId>com.google.zxing</groupId>
<artifactId>core</artifactId>
<version>3.3.3</version>
</dependency>
二维码生成工具类
public class QRCodeUtil {
//编码
private static final String CHARSET = "utf-8";
//文件格式
private static final String FORMAT = "JPG";
// 二维码尺寸
private static final int QRCODE_SIZE = 300;
// LOGO宽度
private static final int LOGO_WIDTH = 60;
// LOGO高度
private static final int LOGO_HEIGHT = 60;
/**
* @Description 生成二维码
* @Author xw
* @Date 12:14 2020/2/12
* @Param [content, logoPath, needCompress] 内容,logo路径,是否压缩
* @return java.awt.image.BufferedImage
**/
public static BufferedImage createImage(String content, String logoPath, boolean needCompress) throws Exception {
Hashtable<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();
hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
hints.put(EncodeHintType.CHARACTER_SET, CHARSET);
hints.put(EncodeHintType.MARGIN, 1);
BitMatrix bitMatrix = new MultiFormatWriter().encode(content, BarcodeFormat.QR_CODE, QRCODE_SIZE, QRCODE_SIZE,
hints);
int width = bitMatrix.getWidth();
int height = bitMatrix.getHeight();
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
image.setRGB(x, y, bitMatrix.get(x, y) ? 0xFF000000 : 0xFFFFFFFF);
}
}
if (logoPath == null || "".equals(logoPath)) {
return image;
}
// 插入图片
QRCodeUtil.insertImage(image, logoPath, needCompress);
return image;
}
/**
* @Description 插入logo
* @Author xw
* @Date 12:15 2020/2/12
* @Param [source, logoPath, needCompress] 二维码图片,logo路径,是否压缩
* @return void
**/
private static void insertImage(BufferedImage source, String logoPath, boolean needCompress) throws IOException {
InputStream inputStream = null;
try {
inputStream = QRCodeUtil.getResourceAsStream(logoPath);
Image src = ImageIO.read(inputStream);
int width = src.getWidth(null);
int height = src.getHeight(null);
if (needCompress) {
// 压缩LOGO
width = width>LOGO_WIDTH?LOGO_WIDTH:width;
height = height>LOGO_HEIGHT?LOGO_HEIGHT:height;
Image image = src.getScaledInstance(width, height, Image.SCALE_SMOOTH);
BufferedImage tag = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
Graphics g = tag.getGraphics();
g.drawImage(image, 0, 0, null);
// 绘制缩小后的图
g.dispose();
src = image;
}
// 插入LOGO
Graphics2D graph = source.createGraphics();
int x = (QRCODE_SIZE - width) / 2;
int y = (QRCODE_SIZE - height) / 2;
graph.drawImage(src, x, y, width, height, null);
Shape shape = new RoundRectangle2D.Float(x, y, width, width, 6, 6);
graph.setStroke(new BasicStroke(3f));
graph.draw(shape);
graph.dispose();
} catch (IOException e) {
e.printStackTrace();
throw new RuntimeException(e);
} finally {
if (inputStream != null) {
inputStream.close();
}
}
}
/**
* @Description 生成二维码,获得到输出流 ,logo内嵌
* @Author xw
* @Date 12:16 2020/2/12
* @Param [content, logoPath, output, needCompress] 内容,logo路径,输出流,是否压缩
* @return void
**/
public static void encode(String content, String logoPath, OutputStream output, boolean needCompress)
throws Exception {
BufferedImage image = QRCodeUtil.createImage(content, logoPath, needCompress);
ImageIO.write(image, FORMAT, output);
}
/**
* @Description 获取指定文件的输入流，获取logo
* @Author xw
* @Date 12:17 2020/2/12
* @Param [logoPath] logo路径
* @return java.io.InputStream
**/
public static InputStream getResourceAsStream(String logoPath) {
return QRCodeUtil.class.getResourceAsStream(logoPath);
}
}
LogUtils 打印日志工具
打印日志工具类
/**
* 打印日志工具类
* 单例模式，调用getInstance方式时传入Class参数
*/
public class LogUtils {
private static Logger logger;
public static Logger getInstance(Class c){
return logger = LoggerFactory.getLogger(c);
}
private LogUtils(){}
}
FTPUtil FTP工具
Maven依赖：
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.6</version>
</dependency>
FTP工具类：
/**
*FTP工具类
*/
public class FtpUtil {
/**
* FTP服务器hostname
*/
private static String HOST = "192.168.31.63";
/**
* FTP服务器端口
*/
private static int PORT = 21;
/**
* FTP登录账号
*/
private static String USERNAME = "root";
/**
* FTP登录密码
*/
private static String PASSWORD = "root";
/**
* FTP服务器基础目录
*/
private static String BASEPATH = "";
/**
* FTP客户端
*/
private static FTPClient ftp;
/**
* @Description 初始化FTP客户端
* @Author xw
* @Date 12:34 2020/2/5
* @Param []
* @return boolean
**/
public static boolean initFtpClient(){
ftp = new FTPClient();
int reply;
try {
// 连接FTP服务器
ftp.connect(HOST, PORT);
//登录, 如果采用默认端口，可以使用ftp.connect(host)的方式直接连接FTP服务器
ftp.login(USERNAME, PASSWORD);
ftp.setBufferSize(10240);
//设置传输超时时间为60秒
ftp.setDataTimeout(600000);
//连接超时为60秒
ftp.setConnectTimeout(600000);
//FTP以二进制形式传输
ftp.setFileType(FTP.BINARY_FILE_TYPE);
reply = ftp.getReplyCode();
if (!FTPReply.isPositiveCompletion(reply)) {
ftp.disconnect();
return false;
}
} catch (IOException e) {
e.printStackTrace();
}
return true;
}
/**
* Description: 向FTP服务器上传文件
* @param filePath FTP服务器文件存放路径。例如分日期存放：/2015/01/01。文件的路径为basePath+filePath
* @param filename 上传到FTP服务器上的文件名
* @param input 本地要上传的文件的 输入流
* @return 成功返回true，否则返回false
*/
public static boolean uploadFile(String filePath, String filename, InputStream input) {
boolean result = false;
try {
filePath = new String(filePath.getBytes("GBK"),"iso-8859-1");
filename = new String(filename.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return result;
};
//切换到上传目录
ftp.enterLocalPassiveMode();
if (!ftp.changeWorkingDirectory(BASEPATH+filePath)) {
//如果目录不存在创建目录
String[] dirs = filePath.split("/");
String tempPath = BASEPATH;
for (String dir : dirs) {
if (null == dir || "".equals(dir)){
continue;
}
tempPath += "/" + dir;
if (!ftp.changeWorkingDirectory(tempPath)) {
if (!ftp.makeDirectory(tempPath)) {
return result;
} else {
ftp.changeWorkingDirectory(tempPath);
}
}
}
}
//设置上传文件的类型为二进制类型
ftp.setFileType(FTP.BINARY_FILE_TYPE);
//上传文件
ftp.enterLocalPassiveMode();
if (!ftp.storeFile(filename, input)) {
return result;
}
input.close();
ftp.logout();
result = true;
}
catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return result;
}
/**
* Description: 从FTP服务器下载文件
* @param remotePath FTP服务器上的相对路径
* @param fileName 要下载的文件名
* @return
*/
public static boolean downloadFile( String remotePath,String fileName,String localPath) {
boolean result = false;
try {
remotePath = new String(remotePath.getBytes("GBK"),"iso-8859-1");
fileName = new String(fileName.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return result;
};
// 转移到FTP服务器目录
ftp.changeWorkingDirectory(remotePath);
ftp.enterLocalPassiveMode();
FTPFile[] fs = ftp.listFiles();
for (FTPFile ff : fs) {
if (ff.getName().equals(fileName)) {
ftp.enterLocalPassiveMode();
FileOutputStream outputStream = new FileOutputStream(new File(localPath));
ftp.retrieveFile(remotePath+"/"+fileName,outputStream);
result = true;
outputStream.close();
}
}
ftp.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return result;
}
/**
* @Description 从ftp服务器下载文件到指定输出流
* @Author xw
* @Date 22:30 2020/3/5
* @Param [remotePath, fileName, outputStream]
* @return boolean
**/
public static boolean downloadFile(String remotePath, String fileName, OutputStream outputStream) {
boolean result = false;
try {
remotePath = new String(remotePath.getBytes("GBK"),"iso-8859-1");
fileName = new String(fileName.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return result;
};
// 转移到FTP服务器目录
ftp.changeWorkingDirectory(remotePath);
ftp.enterLocalPassiveMode();
FTPFile[] fs = ftp.listFiles();
for (FTPFile ff : fs) {
if (ff.getName().equals(fileName)) {
ftp.enterLocalPassiveMode();
ftp.retrieveFile(remotePath+"/"+fileName,outputStream);
result = true;
}
}
ftp.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return result;
}
/**
* @Description 删除文件
* @Author xw
* @Date 11:38 2020/2/6
* @Param [remotePath, fileName]
* @return void
**/
public static boolean deleteFile( String remotePath,String fileName){
boolean flag = false;
try {
remotePath = new String(remotePath.getBytes("GBK"),"iso-8859-1");
fileName = new String(fileName.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return flag;
};
// 转移到FTP服务器目录
ftp.changeWorkingDirectory(remotePath);
ftp.enterLocalPassiveMode();
FTPFile[] fs = ftp.listFiles();
for (FTPFile ff : fs) {
if ("".equals(fileName)){
return flag;
}
if (ff.getName().equals(fileName)){
String filePath = remotePath + "/" +fileName;
ftp.deleteFile(filePath);
flag = true;
}
}
ftp.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return flag;
}
/**
* @Description 删除文件夹
* @Author xw
* @Date 11:38 2020/2/6
* @Param [remotePath, fileName]
* @return void
**/
public static boolean deleteFolder( String remotePath){
boolean flag = false;
try {
remotePath = new String(remotePath.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return flag;
};
// 转移到FTP服务器目录
ftp.changeWorkingDirectory(remotePath);
ftp.enterLocalPassiveMode();
FTPFile[] fs = ftp.listFiles();
if (fs.length==0){
ftp.removeDirectory(remotePath);
flag = true;
}
ftp.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return flag;
}
/**
* @Description 修改文件名称或者文件夹名
* @Author xw
* @Date 21:18 2020/2/11
* @Param [oldAllName, newAllName]
* @return boolean
**/
public static boolean reNameFile( String oldAllName,String newAllName){
boolean flag = false;
try {
oldAllName = new String(oldAllName.getBytes("GBK"),"iso-8859-1");
newAllName = new String(newAllName.getBytes("GBK"),"iso-8859-1");
if (!initFtpClient()){
return flag;
};
ftp.enterLocalPassiveMode();
ftp.rename(oldAllName,newAllName);
flag = true;
ftp.logout();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ftp.isConnected()) {
try {
ftp.disconnect();
} catch (IOException ioe) {
}
}
}
return flag;
}
}
MailUtil 邮箱工具
Maven依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
邮箱工具类
@Component
public class MailUtils {
@Autowired
private JavaMailSender mailSender;
/**
*@param mail接收者的mail
*/
public String getMailCode(String mail){
//定义邮箱实例
SimpleMailMessage message = new SimpleMailMessage();
message.setSubject("邮箱标题");
message.setText("邮箱正文");
message.setTo(mail);
message.setFrom("your email");
mailSender.send(message);
return code;
}
}
FileUploadUtil 文件上传工具
文件上传工具类
/**
* Description : 文件上传工具栏
*/
public class FileUploadUtil {
public static Map<String,Object> fileUpload(MultipartFile img, HttpServletRequest request){
HttpSession session = request.getSession();
//创建文件上传的目录 结构为:upload/日期/用户名/文件名
String path = File.separator + "upload" + File.separator + DateTimeUtil.getDate();
String realPath = session.getServletContext().
getRealPath(path);
File file = new File(realPath);
//创建上传文件目录 用户名+upload
if(!file.exists()){
file.mkdirs();
}
//获取上传文件名
String fileName = img.getOriginalFilename();
//防止上传文件重名
fileName = System.currentTimeMillis() + fileName;
//给editor返回的json数据
Map<String,Object> map = new HashMap<>();
//图片回调地址
String url = "http://localhost:8080" + request.getContextPath() + path + File.separator + fileName;
//将回调地址存储在session中
session.setAttribute("url",url);
try {
//调用上传文件方法
img.transferTo(new File(realPath + File.separator + fileName));
map.put("success",1);//只能写数字1
map.put("message","上传图片成功");
map.put("url",url);
} catch (IOException e) {
e.printStackTrace();
map.put("success","0");
map.put("message","上传失败");
}
return map;
}
}
JDBC通用增删改查
JDBC工具类
/**
* JDBC工具类
*/
public class Util1 {
//加载驱动
static {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
//获得连接
public static Connection getConnection(){
try {
DriverManager.getConnection("jdbc:mysql://localhost:3306/mysql?characterEnconding=utf-8","root","root");
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
/** 增删改的通用方法
* @param String sql 要执行的sql
* @param Object[] obj 对象类型的数组 里面存放着 sql执行的占位符参数
* Object... 可变参数
* */
public static boolean executeUpdate(String sql,Object... args){
Connection conn = null;
PreparedStatement ps = null;
try {
conn = getConnection();
ps = conn.prepareStatement(sql);
//有参数
for(int i=0;i<args.length;i++){
ps.setObject(i+1,args[i]);
}
//执行sql语句
int i = ps.executeUpdate();
//返回 true
return i>0;
} catch (SQLException e) {
e.printStackTrace();
}finally{
//关闭资源
close(conn,ps,null);
}
return false;
}
/**
* 查询的通用方法
* @param sql;
* @param args;
* @return
* */
public static List<Map<String,Object>> executeQuery(String sql,Object... args){
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
conn = getConnection();
ps = conn.prepareStatement(sql);
//有可能有参数
for(int i=0;i<args.length;i++){
ps.setObject(i+1,args[i]);
}
//执行sql语句
rs = ps.executeQuery();
//创建List集合
List<Map<String, Object>> list = new ArrayList<>();
//获取本次查询结果集有多少列
int count = rs.getMetaData().getColumnCount();
//while循环
while(rs.next()){
//创建Map集合 获取一个数据封装成一个Map集合
Map<String, Object> map = new HashMap<>();
//for循环 遍历所有的列
for(int i=0;i<count;i++){
//获取本次查询结果集的列名
String name = rs.getMetaData().getColumnLabel(i + 1);
map.put(name,rs.getObject(name));
}
//把所有的map集合添加到List集合中
list.add(map);
}
//返回值
return list;
} catch (SQLException e) {
e.printStackTrace();
}finally{
//关闭资源
close(conn,ps,rs);
}
return null;
}
/**
* 关闭资源的通用方法
* */
public static void close(Connection conn,Statement stat,ResultSet rs){
try{
if(rs!=null){
rs.close();
}
if(stat!=null){
stat.close();
}
if(conn!=null){
conn.close();
}
}catch(Exception e){
e.printStackTrace();
}
}
}
自定义配置文件版
public class BaseDao {
// 配置集合
public static Properties properties = new Properties();
// 加载驱动
static {
// 集合对象加载数据
InputStream is = BaseDao.class.getResourceAsStream("data.properties");
try {
properties.load(is);
} catch (IOException e) {
e.printStackTrace();
}
// 获取配置中的数据，从集合中获取
String driver = properties.getProperty("driver");
// 加载jdbc驱动
try {
Class.forName(driver);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
// 获取连接对象
public Connection getConnection() {
// 获取配置中的数据，从集合中获取
String url = properties.getProperty("url");
String user = properties.getProperty("user");
String pwd = properties.getProperty("pwd");
// 获取连接对象
Connection connection = null;
try {
connection = DriverManager.getConnection(url, user, pwd);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
// 返回连接对象
return connection;
}
// 关闭资源
public void closeAll(Connection connection, Statement statement, ResultSet resultSet) {
// 按顺序删除
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
//通用的增删改
public int commonUpdate(String sql, Object[] objects) {
// 获取连接对象
Connection connection = getConnection();
// 构建执行者
PreparedStatement preparedStatement = null;
try {
preparedStatement = connection.prepareStatement(sql);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
// 填入数据
for (int i = 0; i < objects.length; i++) {
try {
preparedStatement.setObject(i + 1, objects[i]);
// preparedStatement.setNull(位置, Types.INTEGER);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
// 执行语句
int i = 0;
try {
i = preparedStatement.executeUpdate();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
// 返回受景响的行数
return i;
}
// 通用查询
public ResultSet commonSelect(String sql, Object[] objects) {
// 定义一个返回值
ResultSet resultSet = null;
// 获取连接对象
Connection connection = getConnection();
// 获得安全执行者
PreparedStatement preparedStatement = null;
try {
preparedStatement = connection.prepareStatement(sql);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
for (int i = 0; i < objects.length; i++) {
try {
assert preparedStatement != null;
preparedStatement.setObject(i + 1, objects[i]);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
// 安全执行者执行
try {
assert preparedStatement != null;
resultSet = preparedStatement.executeQuery();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
// 处理结果集
return resultSet;
}
}
Mybatis 工具类的封装
MyBatisUtils
/**
* MyBatis工具类
*/
public class MyBatisUtils {
//创建SqlSession
private static SqlSession sqlSession;
//初始化创建SqlSession
static {
//工厂构建者
SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
//MyBatis配置文件名称
String configName = "sqlMapConfig.xml";
//定义输入流
InputStream is = null;
try {
//读取配置文件
is = Resources.getResourceAsStream(configName);
} catch (IOException e) {
e.printStackTrace();
}
//通过配置文件构建出工厂类
SqlSessionFactory ssf = ssfb.build(is);
//通过工厂类获取sqlSession
sqlSession = ssf.openSession(true);
}
//获取sqlSession
public static SqlSession getSqlsession(){
return sqlSession;
}
//归还sqlSession
public static void closeSqlsession(SqlSession sqlSession){
if (sqlSession!=null){
sqlSession.close();
}
}
}
MyBatis逆向生成
MyBatisUtils
public class GeneratorSqlmap {
public void generator() throws Exception{
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
//指定 逆向工程配置文件
File configFile = new File("generatorConfig.xml");
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = cp.parseConfiguration(configFile);
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
callback, warnings);
myBatisGenerator.generate(null);
}
public static void main(String[] args) throws Exception {
try {
GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
generatorSqlmap.generator();
} catch (Exception e) {
e.printStackTrace();
}
}
}
配置文件generatorConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<context id="testTables" targetRuntime="MyBatis3">
<commentGenerator>
<!-- 是否去除自动生成的注释 true：是 ： false:否 -->
<property name="suppressAllComments" value="true"/>
</commentGenerator>
<!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/demo1?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true"
userId="root"
password="root">
<property name="nullCatalogMeansCurrent" value="true"/>
</jdbcConnection>
<!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL 和
NUMERIC 类型解析为java.math.BigDecimal -->
<javaTypeResolver>
<property name="forceBigDecimals" value="false"/>
</javaTypeResolver>
<!-- targetProject:生成PO类的位置 -->
<javaModelGenerator targetPackage="com.demo.pojo"
targetProject=".src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false"/>
<!-- 从数据库返回的值被清理前后的空格 -->
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- targetProject:mapper映射文件生成的位置 -->
<sqlMapGenerator targetPackage="com.demo.mapper"
targetProject=".src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false"/>
</sqlMapGenerator>
<!-- targetPackage：mapper接口生成的位置 -->
<javaClientGenerator type="XMLMAPPER"
targetPackage="com.demo.mapper"
targetProject=".src">
<!-- enableSubPackages:是否让schema作为包的后缀 -->
<property name="enableSubPackages" value="false"/>
</javaClientGenerator>
<!-- 指定数据库表 -->
<table schema="" tableName="demo1"></table>
</context>
</generatorConfiguration>
DateUtil 日期工具
public class DateUtil {
/**
* util.Date转字符串
*/
public static String getDateStr(Date date) {
// 实例化一个格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 把日期对象格式化
// 返回这个字符串
return sdf.format(date);
}
/**
* 字符串转成util.Date对象
*/
public static Date getDate(String dateStr) {
// 实例化一个格式化对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
// 日期格式解析
Date date = null;
try {
date = sdf.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
// 返回日期
return date;
}
}
MD5加密工具类MD5Utils
public class MD5Util {
/**
* 1.MD5（message-digest algorithm 5）信息摘要算法，
* 它的长度一般是32位的16进制数字符串（如81dc9bdb52d04dc20036dbd8313ed055）
* 2.由于系统密码明文存储容易被黑客盗取
* 3.应用：注册时，将密码进行md5加密，存到数据库中，防止可以看到数据库数据的人恶意篡改。
* 登录时,将密码进行md5加密,与存储在数据库中加密过的密码进行比对
* 4.md5不可逆，即没有对应的算法，从产生的md5值逆向得到原始数据。
* 但是可以使用暴力破解，这里的破解并非把摘要还原成原始数据，如暴力枚举法。
*
*/
public final static String getMD5(String str){
try {
MessageDigest md = MessageDigest.getInstance("SHA");//创建具有指定算法名称的摘要
md.update(str.getBytes()); //使用指定的字节数组更新摘要
byte mdBytes[] = md.digest(); //进行哈希计算并返回一个字节数组
String hash = "";
for(int i= 0;i<mdBytes.length;i++){ //循环字节数组
int temp;
if(mdBytes[i]<0) //如果有小于0的字节,则转换为正数
temp =256+mdBytes[i];
else
temp=mdBytes[i];
if(temp<16)
hash+= "0";
hash+=Integer.toString(temp,16); //将字节转换为16进制后，转换为字符串
}
return hash;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
}
UUIDUtils
public class UUIDUtils {
/** 16位的UUID */
public static String getUUID() {
return UUID.randomUUID().toString().replace("-","").substring(0,15);
}
/** 32位的UUID */
public static String getUUID32() {
return UUID.randomUUID().toString().replace("-","").substring(0,31);
}
}
Maven识别所有的配置文件
<!--识别所有的配置文件-->
<resources>
<!--识别java下的配置文件-->
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
<!--识别resources下的配置文件-->
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>false</filtering>
</resource>
</resources>
web.xml 4.0模板
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
</web-app >
Thymeleaf模板
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
</body>
</html>
sqlMapConfig模板
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="org/mybatis/example/BlogMapper.xml"/>
</mappers>
</configuration>
Mapper模板
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="">
</mapper>
最后
以上就是闪闪铃铛为你收集整理的Java工具类及配置文件模板大全的全部内容，希望文章能够帮你解决Java工具类及配置文件模板大全所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。
发表评论 取消回复