记录一下代码: 本代码只使用 生成功能
TwoDimensionCode.jsp
<%@ page contentType="text/html;charset=UTF-8" %>
<%@ include file="/webpage/include/taglib.jsp"%>
<html>
<head>
<title>接口管理</title>
<meta name="decorator" content="default"/>
<script type="text/javascript" src="${ctxStatic}/common/readTwoD.js"></script>
</head>
<body>
<body class="gray-bg">
<div class="wrapper wrapper-content">
<div class="ibox">
<div class="ibox-title">
<h5>二维码测试 </h5>
<div class="ibox-tools">
<a class="collapse-link">
<i class="fa fa-chevron-up"></i>
</a>
<a class="dropdown-toggle" data-toggle="dropdown" href="#">
<i class="fa fa-wrench"></i>
</a>
<ul class="dropdown-menu dropdown-user">
<li><a href="#">选项1</a>
</li>
<li><a href="#">选项2</a>
</li>
</ul>
<a class="close-link">
<i class="fa fa-times"></i>
</a>
</div>
</div>
<div class="ibox-content">
<form class="form-horizontal">
<div class="form-group">
<div class="col-sm-2">二维码内容</div>
<div class="col-sm-8">
<input type="text" id="encoderContent" title="输入内容" value="http://www.atjava.com" class="form-control">
<span class="help-inline">请输入要生成二维码的字符串</span>
</div>
<div class="col-sm-2">
<a class="btn btn-small btn-success" οnclick="createTwoD();">生成</a>
</div>
</div>
<div class="hr-line-dashed"></div>
<div class="form-group">
<div class="col-sm-2">二维码图像</div>
<div class="col-sm-8">
<img id="encoderImgId" cache="false" width="265px" height="265px;" class="block"/>
<span class="help-inline">使用微信扫一扫</span>
</div>
</div>
</form>
</div>
</div>
</div>
</body>
</html>引入的js文件 code
readTwoD.js
var locat = (window.location+'').split('/');
$(function(){if('tool'== locat[3]){locat = locat[0]+'//'+locat[2];}else{locat = locat[0]+'//'+locat[2]+'/'+locat[3];};});
//清除空格
String.prototype.trim=function(){
return this.replace(/(^\s*)|(\s*$)/g,'');
};
//====================上传二维码=================
$(document).ready(function(){
var str='';
$("#uploadify1").uploadify({
'buttonImg' : locat+"/static/img/twoDimensonCode.png",
'uploader' : locat+"/static/uploadify/uploadify.swf",
'script' : locat+"/static/uploadify/uploadFile.jsp;jsessionid="+jsessionid,
'cancelImg' : locat+"/static/uploadify/cancel.png",
'folder' : locat+"/uploadFiles/twoDimensionCode",//上传文件存放的路径,请保持与uploadFile.jsp中PATH的值相同
'queueId' : "fileQueue",
'queueSizeLimit' : 1,//限制上传文件的数量
//'fileExt' : "*.rar,*.zip",
//'fileDesc' : "RAR *.rar",//限制文件类型
'fileExt' : '*.jpg;*.gif;*.png',
'fileDesc' : 'Please choose(.JPG, .GIF, .PNG)',
'auto' : false,
'multi' : true,//是否允许多文件上传
'simUploadLimit': 2,//同时运行上传的进程数量
'buttonText': "files",
'scriptData': {'uploadPath':'/uploadFiles/twoDimensionCode/'},//这个参数用于传递用户自己的参数，此时'method' 必须设置为GET, 后台可以用request.getParameter('name')获取名字的值
'method' : "GET",
'onComplete':function(event,queueId,fileObj,response,data){
str = response.trim();//单个上传完毕执行
},
'onAllComplete' : function(event,data) {
//alert(str); //全部上传完毕执行
readContent(str);
},
'onSelect' : function(event, queueId, fileObj){
$("#hasTp1").val("ok");
}
});
});
//====================上传二维码=================
function uploadTwo(){
if($("#uploadify1").val()){
top.layer.alert('请选择二维码！', {icon: 0});
return false;
}
$('#uploadify1').uploadifyUpload();
}
//去后台解析二维码返回解析内容
function readContent(str){
$.ajax({
type: "POST",
url: locat+'/a/tools/TwoDimensionCodeController/readTwoDimensionCode',
data: {imgId:str,tm:new Date().getTime()},
dataType:'json',
cache: false,
success: function(data){
if("success" == data.result){
if('null' == data.readContent || null == data.readContent){
top.layer.alert('读取失败，二维码无效！', {icon: 0});
}else{
$("#readContent").text(data.readContent);
}
}else{
top.layer.alert('后台读取出错！', {icon: 0});
return;
}
}
});
}
//生成二维码
function createTwoD(){
if($("#encoderContent").val()==""){
top.layer.alert('输入框不能为空！', {icon: 0});
$("#encoderContent").focus();
return false;
}
$.ajax({
type: "POST",
url: locat+'/a/tools/TwoDimensionCodeController/createTwoDimensionCode.do',
data: {encoderContent:$("#encoderContent").val(),tm:new Date().getTime()},
dataType:'json',
cache: false,
success: function(data){
if(data.success){
$("#encoderImgId").attr("src",data.body.filePath);
}else{
top.layer.alert('生成二维码失败！', {icon: 0});
return false;
}
}
});
return true;
}package com.jeeplus.modules.tools.web;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import com.jeeplus.common.config.Global;
import com.jeeplus.common.json.AjaxJson;
import com.jeeplus.common.utils.FileUtils;
import com.jeeplus.common.web.BaseController;
import com.jeeplus.modules.sys.entity.User;
import com.jeeplus.modules.sys.security.SystemAuthorizingRealm.Principal;
import com.jeeplus.modules.sys.service.SystemService;
import com.jeeplus.modules.sys.utils.UserUtils;
import com.jeeplus.modules.tools.utils.TwoDimensionCode;
/**
* 二维码Controller
* @author jeeplus
* @version 2015-11-30
*/
@Controller
@RequestMapping(value = "${adminPath}/tools/TwoDimensionCodeController")
public class TwoDimensionCodeController extends BaseController {
@Autowired
private SystemService systemService;
/**
* 二维码页面
*/
@RequestMapping(value = {"index", ""})
public String index() throws Exception{
return "modules/tools/TwoDimensionCode";
}
/**
* 生成二维码
* @param args
* @throws Exception
*/
@RequestMapping(value="createTwoDimensionCode")
@ResponseBody
public AjaxJson createTwoDimensionCode(HttpServletRequest request, String encoderContent){
AjaxJson j = new AjaxJson();
Principal principal = (Principal) UserUtils.getPrincipal();
User user = UserUtils.getUser();
if (principal == null){
j.setSuccess(false);
j.setErrorCode("0");
j.setMsg("没有登录");
}
String realPath = Global.getUserfilesBaseDir() + Global.USERFILES_BASE_URL
+ principal + "/qrcode/";
FileUtils.createDirectory(realPath);
String name="test.png"; //encoderImgId此处二维码的图片名
try {
String filePath = realPath + name; //存放路径
TwoDimensionCode.encoderQRCode(encoderContent, filePath, "png");//执行生成二维码
user.setQrCode(request.getContextPath()+Global.USERFILES_BASE_URL
+ principal + "/qrcode/"+name);
systemService.updateUserInfo(user);
j.setSuccess(true);
j.setMsg("二维码生成成功");
j.put("filePath", request.getContextPath()+Global.USERFILES_BASE_URL
+ principal + "/qrcode/"+name);
} catch (Exception e) {
}
return j;
}
//
// /**
// * 解析二维码
// * @param args
// * @throws Exception
// */
// @RequestMapping(value="/readTwoDimensionCode")
// @ResponseBody
// public Object readTwoDimensionCode(){
// Map<String,String> map = new HashMap<String,String>();
// PageData pd = new PageData();
// pd = this.getPageData();
// String errInfo = "success",readContent="";
// String imgId = pd.getString("imgId");//内容
// if(null == imgId){
// errInfo = "error";
// }else{
// try {
// String filePath = PathUtil.getClasspath() + Const.FILEPATHTWODIMENSIONCODE + imgId; //存放路径
// readContent = TwoDimensionCode.decoderQRCode(filePath);//执行读取二维码
// } catch (Exception e) {
// errInfo = "error";
// }
// }
// map.put("result", errInfo); //返回结果
// map.put("readContent", readContent); //读取的内容
// return AppUtil.returnObject(new PageData(), map);
// }
//
}两个工具类为:
package com.jeeplus.modules.tools.utils;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import javax.imageio.ImageIO;
import jp.sourceforge.qrcode.QRCodeDecoder;
import jp.sourceforge.qrcode.exception.DecodingFailedException;
import com.swetake.util.Qrcode;
public class TwoDimensionCode {
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param imgPath
* 图片路径
*/
public static void encoderQRCode(String content, String imgPath) {
encoderQRCode(content, imgPath, "png", 2);
}
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param output
* 输出流
*/
public static void encoderQRCode(String content, OutputStream output) {
encoderQRCode(content, output, "png", 2);
}
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param imgPath
* 图片路径
* @param imgType
* 图片类型
*/
public static void encoderQRCode(String content, String imgPath, String imgType) {
encoderQRCode(content, imgPath, imgType, 2);
}
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param output
* 输出流
* @param imgType
* 图片类型
*/
public static void encoderQRCode(String content, OutputStream output,
String imgType) {
encoderQRCode(content, output, imgType, 2);
}
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param imgPath
* 图片路径
* @param imgType
* 图片类型
* @param size
* 二维码尺寸
*/
public static void encoderQRCode(String content, String imgPath, String imgType,
int size) {
try {
BufferedImage bufImg = qRCodeCommon(content, imgType, size);
File imgFile = new File(imgPath);
// 生成二维码QRCode图片
ImageIO.write(bufImg, imgType, imgFile);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 生成二维码(QRCode)图片
*
* @param content
* 存储内容
* @param output
* 输出流
* @param imgType
* 图片类型
* @param size
* 二维码尺寸
*/
public static void encoderQRCode(String content, OutputStream output,
String imgType, int size) {
try {
BufferedImage bufImg = qRCodeCommon(content, imgType, size);
// 生成二维码QRCode图片
ImageIO.write(bufImg, imgType, output);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 生成二维码(QRCode)图片的公共方法
*
* @param content
* 存储内容
* @param imgType
* 图片类型
* @param size
* 二维码尺寸
* @return
*/
private static BufferedImage qRCodeCommon(String content, String imgType, int size) {
BufferedImage bufImg = null;
size = 10;
try {
Qrcode qrcodeHandler = new Qrcode();
// 设置二维码排错率，可选L(7%)、M(15%)、Q(25%)、H(30%)，排错率越高可存储的信息越少，但对二维码清晰度的要求越小
qrcodeHandler.setQrcodeErrorCorrect('M');
qrcodeHandler.setQrcodeEncodeMode('B');
// 设置设置二维码尺寸，取值范围1-40，值越大尺寸越大，可存储的信息越大
qrcodeHandler.setQrcodeVersion(size);
// 获得内容的字节数组，设置编码格式
byte[] contentBytes = content.getBytes("utf-8");
// 图片尺寸
//int imgSize = 67 + 12 * (size - 1);
int imgSize = 67 + 12 * (size - 1);
//System.out.println(imgSize);
bufImg = new BufferedImage(imgSize, imgSize,
BufferedImage.TYPE_INT_RGB);
Graphics2D gs = bufImg.createGraphics();
// 设置背景颜色
gs.setBackground(Color.WHITE);
gs.clearRect(0, 0, imgSize, imgSize);
// 设定图像颜色> BLACK
gs.setColor(Color.BLACK);
// 设置偏移量，不设置可能导致解析出错
int pixoff = 2;
// 输出内容> 二维码
if (contentBytes.length > 0 && contentBytes.length < 800) {
boolean[][] codeOut = qrcodeHandler.calQrcode(contentBytes);
for (int i = 0; i < codeOut.length; i++) {
for (int j = 0; j < codeOut.length; j++) {
if (codeOut[j][i]) {
gs.fillRect(j * 3 + pixoff, i * 3 + pixoff, 3, 3);
}
}
}
} else {
throw new Exception("QRCode content bytes length = "
+ contentBytes.length + " not in [0, 800].");
}
gs.dispose();
bufImg.flush();
} catch (Exception e) {
e.printStackTrace();
}
return bufImg;
}
/**
* 解析二维码（QRCode）
*
* @param imgPath
* 图片路径
* @return
*/
public static String decoderQRCode(String imgPath) throws Exception{
// QRCode 二维码图片的文件
File imageFile = new File(imgPath);
BufferedImage bufImg = null;
String content = null;
try {
bufImg = ImageIO.read(imageFile);
QRCodeDecoder decoder = new QRCodeDecoder();
content = new String(decoder.decode(new TwoDimensionCodeImage(
bufImg)), "utf-8");
} catch (IOException e) {
//System.out.println("Error: " + e.getMessage());
//e.printStackTrace();
} catch (DecodingFailedException dfe) {
//System.out.println("Error: " + dfe.getMessage());
//dfe.printStackTrace();
}
return content;
}
/**
* 解析二维码（QRCode）
*
* @param input
* 输入流
* @return
*/
public static String decoderQRCode(InputStream input) {
BufferedImage bufImg = null;
String content = null;
try {
bufImg = ImageIO.read(input);
QRCodeDecoder decoder = new QRCodeDecoder();
content = new String(decoder.decode(new TwoDimensionCodeImage(
bufImg)), "utf-8");
} catch (IOException e) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
} catch (DecodingFailedException dfe) {
System.out.println("Error: " + dfe.getMessage());
dfe.printStackTrace();
}
return content;
}
public static void main(String[] args) {
String imgPath = "F:/a.png";
/*String encoderContent = "Hello 大大、小小,welcome to QRCode!"
+ "\nMyblog [ http://sjsky.iteye.com ]"
+ "\nEMail [ sjsky007@gmail.com ]";*/
String encoderContent = "http://www.baidu.com";
TwoDimensionCode handler = new TwoDimensionCode();
handler.encoderQRCode(encoderContent, imgPath, "png");
// try {
// OutputStream output = new FileOutputStream(imgPath);
// handler.encoderQRCode(content, output);
// } catch (Exception e) {
// e.printStackTrace();
// }
System.out.println("========encoder success");
//String decoderContent = handler.decoderQRCode(imgPath);
System.out.println("解析结果如下：");
//System.out.println(decoderContent);
System.out.println("========decoder success!!!");
}
}
package com.jeeplus.modules.tools.utils;
import java.awt.image.BufferedImage;
import jp.sourceforge.qrcode.data.QRCodeImage;
/**
* 二维码
* 创建人：FH 创建时间：2015年4月10日
* @version
*/
public class TwoDimensionCodeImage implements QRCodeImage {
BufferedImage bufImg;
public TwoDimensionCodeImage(BufferedImage bufImg) {
this.bufImg = bufImg;
}
@Override
public int getHeight() {
return bufImg.getHeight();
}
@Override
public int getPixel(int x, int y) {
return bufImg.getRGB(x, y);
}
@Override
public int getWidth() {
return bufImg.getWidth();
}
}
其他涉及到的类有：
package com.jeeplus.common.json;
import java.util.LinkedHashMap;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.jeeplus.common.mapper.JsonMapper;
/**
* $.ajax后需要接受的JSON
*
* @author
*
*/
public class AjaxJson {
private boolean success = true;// 是否成功
private String errorCode = "-1";//错误代码
private String msg = "操作成功";// 提示信息
private LinkedHashMap<String, Object> body = new LinkedHashMap();//封装json的map
public LinkedHashMap<String, Object> getBody() {
return body;
}
public void setBody(LinkedHashMap<String, Object> body) {
this.body = body;
}
public void put(String key, Object value){//向json中添加属性，在js中访问，请调用data.map.key
body.put(key, value);
}
public void remove(String key){
body.remove(key);
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {//向json中添加属性，在js中访问，请调用data.msg
this.msg = msg;
}
public boolean isSuccess() {
return success;
}
public void setSuccess(boolean success) {
this.success = success;
}
@JsonIgnore//返回对象时忽略此属性
public String getJsonStr() {//返回json字符串数组，将访问msg和key的方式统一化，都使用data.key的方式直接访问。
String json = JsonMapper.getInstance().toJson(this);
return json;
}
public void setErrorCode(String errorCode) {
this.errorCode = errorCode;
}
public String getErrorCode() {
return errorCode;
}
}
/**
* Copyright © 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
*/
package com.jeeplus.modules.sys.utils;
import java.io.IOException;
import java.util.Date;
import java.util.List;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.UnavailableSecurityManagerException;
import org.apache.shiro.session.InvalidSessionException;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import com.jeeplus.common.service.BaseService;
import com.jeeplus.common.sms.SMSUtils;
import com.jeeplus.common.utils.CacheUtils;
import com.jeeplus.common.utils.SpringContextHolder;
import com.jeeplus.common.utils.StringUtils;
import com.jeeplus.modules.sys.dao.AreaDao;
import com.jeeplus.modules.sys.dao.MenuDao;
import com.jeeplus.modules.sys.dao.OfficeDao;
import com.jeeplus.modules.sys.dao.RoleDao;
import com.jeeplus.modules.sys.dao.UserDao;
import com.jeeplus.modules.sys.entity.Area;
import com.jeeplus.modules.sys.entity.Menu;
import com.jeeplus.modules.sys.entity.Office;
import com.jeeplus.modules.sys.entity.Role;
import com.jeeplus.modules.sys.entity.User;
import com.jeeplus.modules.sys.security.SystemAuthorizingRealm.Principal;
/**
* 用户工具类
* @author jeeplus
* @version 2013-12-05
*/
public class UserUtils {
private static UserDao userDao = SpringContextHolder.getBean(UserDao.class);
private static RoleDao roleDao = SpringContextHolder.getBean(RoleDao.class);
private static MenuDao menuDao = SpringContextHolder.getBean(MenuDao.class);
private static AreaDao areaDao = SpringContextHolder.getBean(AreaDao.class);
private static OfficeDao officeDao = SpringContextHolder.getBean(OfficeDao.class);
public static final String USER_CACHE = "userCache";
public static final String USER_CACHE_ID_ = "id_";
public static final String USER_CACHE_LOGIN_NAME_ = "ln";
public static final String USER_CACHE_LIST_BY_OFFICE_ID_ = "oid_";
public static final String CACHE_ROLE_LIST = "roleList";
public static final String CACHE_MENU_LIST = "menuList";
public static final String CACHE_AREA_LIST = "areaList";
public static final String CACHE_OFFICE_LIST = "officeList";
public static final String CACHE_OFFICE_ALL_LIST = "officeAllList";
/**
* 根据ID获取用户
* @param id
* @return 取不到返回null
*/
public static User get(String id){
User user = (User)CacheUtils.get(USER_CACHE, USER_CACHE_ID_ + id);
if (user == null){
user = userDao.get(id);
if (user == null){
return null;
}
user.setRoleList(roleDao.findList(new Role(user)));
CacheUtils.put(USER_CACHE, USER_CACHE_ID_ + user.getId(), user);
CacheUtils.put(USER_CACHE, USER_CACHE_LOGIN_NAME_ + user.getLoginName(), user);
}
return user;
}
/**
* 根据登录名获取用户
* @param loginName
* @return 取不到返回null
*/
public static User getByLoginName(String loginName){
User user = (User)CacheUtils.get(USER_CACHE, USER_CACHE_LOGIN_NAME_ + loginName);
if (user == null){
user = userDao.getByLoginName(new User(null, loginName));
if (user == null){
return null;
}
user.setRoleList(roleDao.findList(new Role(user)));
CacheUtils.put(USER_CACHE, USER_CACHE_ID_ + user.getId(), user);
CacheUtils.put(USER_CACHE, USER_CACHE_LOGIN_NAME_ + user.getLoginName(), user);
}
return user;
}
/**
* 清除当前用户缓存
*/
public static void clearCache(){
removeCache(CACHE_ROLE_LIST);
removeCache(CACHE_MENU_LIST);
removeCache(CACHE_AREA_LIST);
removeCache(CACHE_OFFICE_LIST);
removeCache(CACHE_OFFICE_ALL_LIST);
UserUtils.clearCache(getUser());
}
/**
* 清除指定用户缓存
* @param user
*/
public static void clearCache(User user){
CacheUtils.remove(USER_CACHE, USER_CACHE_ID_ + user.getId());
CacheUtils.remove(USER_CACHE, USER_CACHE_LOGIN_NAME_ + user.getLoginName());
CacheUtils.remove(USER_CACHE, USER_CACHE_LOGIN_NAME_ + user.getOldLoginName());
if (user.getOffice() != null && user.getOffice().getId() != null){
CacheUtils.remove(USER_CACHE, USER_CACHE_LIST_BY_OFFICE_ID_ + user.getOffice().getId());
}
}
/**
* 获取当前用户
* @return 取不到返回 new User()
*/
public static User getUser(){
Principal principal = getPrincipal();
if (principal!=null){
User user = get(principal.getId());
if (user != null){
List<Role> roleList = roleDao.findList(new Role(user));
user.setRoleList(roleList);
return user;
}
return new User();
}
// 如果没有登录，则返回实例化空的User对象。
return new User();
}
/**
* 获取当前用户角色列表
* @return
*/
public static List<Role> getRoleList(){
@SuppressWarnings("unchecked")
List<Role> roleList = (List<Role>)getCache(CACHE_ROLE_LIST);
if (roleList == null){
User user = getUser();
if (user.isAdmin()){
roleList = roleDao.findAllList(new Role());
}else{
Role role = new Role();
role.getSqlMap().put("dsf", BaseService.dataScopeFilter(user.getCurrentUser(), "o", "u"));
roleList = roleDao.findList(role);
}
putCache(CACHE_ROLE_LIST, roleList);
}
return roleList;
}
/**
* 获取当前用户授权菜单
* @return
*/
public static List<Menu> getMenuList(){
@SuppressWarnings("unchecked")
List<Menu> menuList = (List<Menu>)getCache(CACHE_MENU_LIST);
if (menuList == null){
User user = getUser();
if (user.isAdmin()){
menuList = menuDao.findAllList(new Menu());
}else{
Menu m = new Menu();
m.setUserId(user.getId());
menuList = menuDao.findByUserId(m);
}
putCache(CACHE_MENU_LIST, menuList);
}
return menuList;
}
/**
* 获取当前用户授权菜单
* @return
*/
public static Menu getTopMenu(){
Menu topMenu = new Menu();
List<Menu> menuList = getMenuList();
if(!menuList.isEmpty()){
topMenu = menuList.get(0);
}
return topMenu;
}
/**
* 获取当前用户授权的区域
* @return
*/
public static List<Area> getAreaList(){
@SuppressWarnings("unchecked")
List<Area> areaList = (List<Area>)getCache(CACHE_AREA_LIST);
if (areaList == null){
areaList = areaDao.findAllList(new Area());
putCache(CACHE_AREA_LIST, areaList);
}
return areaList;
}
/**
* 获取当前用户有权限访问的部门
* @return
*/
public static List<Office> getOfficeList(){
@SuppressWarnings("unchecked")
List<Office> officeList = (List<Office>)getCache(CACHE_OFFICE_LIST);
if (officeList == null){
User user = getUser();
if (user.isAdmin()){
officeList = officeDao.findAllList(new Office());
}else{
Office office = new Office();
office.getSqlMap().put("dsf", BaseService.dataScopeFilter(user, "a", ""));
officeList = officeDao.findList(office);
}
putCache(CACHE_OFFICE_LIST, officeList);
}
return officeList;
}
/**
* 获取当前用户有权限访问的部门
* @return
*/
public static List<Office> getOfficeAllList(){
@SuppressWarnings("unchecked")
List<Office> officeList = (List<Office>)getCache(CACHE_OFFICE_ALL_LIST);
if (officeList == null){
officeList = officeDao.findAllList(new Office());
}
return officeList;
}
/**
* 获取授权主要对象
*/
public static Subject getSubject(){
return SecurityUtils.getSubject();
}
/**
* 获取当前登录者对象
*/
public static Principal getPrincipal(){
try{
Subject subject = SecurityUtils.getSubject();
Principal principal = (Principal)subject.getPrincipal();
if (principal != null){
return principal;
}
// subject.logout();
}catch (UnavailableSecurityManagerException e) {
}catch (InvalidSessionException e){
}
return null;
}
public static Session getSession(){
try{
Subject subject = SecurityUtils.getSubject();
Session session = subject.getSession(false);
if (session == null){
session = subject.getSession();
}
if (session != null){
return session;
}
// subject.logout();
}catch (InvalidSessionException e){
}
return null;
}
// ============== User Cache ==============
public static Object getCache(String key) {
return getCache(key, null);
}
public static Object getCache(String key, Object defaultValue) {
// Object obj = getCacheMap().get(key);
Object obj = getSession().getAttribute(key);
return obj==null?defaultValue:obj;
}
public static void putCache(String key, Object value) {
// getCacheMap().put(key, value);
getSession().setAttribute(key, value);
}
public static void removeCache(String key) {
// getCacheMap().remove(key);
getSession().removeAttribute(key);
}
public static String getTime(Date date){
StringBuffer time = new StringBuffer();
Date date2 = new Date();
long temp = date2.getTime() - date.getTime();
long days = temp / 1000 / 3600/24; //相差小时数
if(days>0){
time.append(days+"天");
}
long temp1 = temp % (1000 * 3600*24);
long hours = temp1 / 1000 / 3600; //相差小时数
if(days>0 || hours>0){
time.append(hours+"小时");
}
long temp2 = temp1 % (1000 * 3600);
long mins = temp2 / 1000 / 60; //相差分钟数
time.append(mins + "分钟");
return time.toString();
}
//发送注册码
public static String sendRandomCode(String uid, String pwd, String tel, String randomCode) throws IOException {
//发送内容
String content = "您的验证码是："+randomCode+"，有效期30分钟，请在有效期内使用。";
return SMSUtils.send(uid, pwd, tel, content);
}
//注册用户重置密码
public static String sendPass(String uid, String pwd, String tel, String password) throws IOException {
//发送内容
String content = "您的新密码是："+password+"，请登录系统，重新设置密码。";
return SMSUtils.send(uid, pwd, tel, content);
}
/**
* 导出Excel调用,根据姓名转换为ID
*/
public static User getByUserName(String name){
User u = new User();
u.setName(name);
List<User> list = userDao.findList(u);
if(list.size()>0){
return list.get(0);
}else{
return new User();
}
}
/**
* 导出Excel使用，根据名字转换为id
*/
public static Office getByOfficeName(String name){
Office o = new Office();
List<Office> list = officeDao.findList(o);
for(Office office : list){
if(StringUtils.equals(name, office.getName())){
return office;
}
}
return o;
}
/**
* 导出Excel使用，根据名字转换为id
*/
public static Area getByAreaName(String name){
Area a = new Area();
a.setName(name);
List<Area> list = areaDao.findList(a);
if(list.size()>0){
return list.get(0);
}else{
return new Area();
}
}
}
package com.jeeplus.common.config;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Reader;
import java.util.Map;
import java.util.Properties;
import org.apache.ibatis.io.Resources;
import org.springframework.core.io.DefaultResourceLoader;
import com.ckfinder.connector.ServletContextFactory;
import com.google.common.collect.Maps;
import com.jeeplus.common.utils.PropertiesLoader;
import com.jeeplus.common.utils.StringUtils;
/**
* 全局配置类
* @author jeeplus
* @version 2014-06-25
*/
public class Global {
/**
* 当前对象实例
*/
private static Global global = new Global();
/**
* 保存全局属性值
*/
private static Map<String, String> map = Maps.newHashMap();
/**
* 属性文件加载对象
*/
private static PropertiesLoader loader = new PropertiesLoader("jeeplus.properties");
/**
* 显示/隐藏
*/
public static final String SHOW = "1";
public static final String HIDE = "0";
/**
* 是/否
*/
public static final String YES = "1";
public static final String NO = "0";
/**
* 对/错
*/
public static final String TRUE = "true";
public static final String FALSE = "false";
/**
* 上传文件基础虚拟路径
*/
public static final String USERFILES_BASE_URL = "/userfiles/";
/**
* 获取当前对象实例
*/
public static Global getInstance() {
return global;
}
/**
* 获取配置
* @see ${fns:getConfig('adminPath')}
*/
public static String getConfig(String key) {
String value = map.get(key);
if (value == null){
value = loader.getProperty(key);
map.put(key, value != null ? value : StringUtils.EMPTY);
}
return value;
}
/**
* 获取管理端根路径
*/
public static String getAdminPath() {
return getConfig("adminPath");
}
/**
* 获取前端根路径
*/
public static String getFrontPath() {
return getConfig("frontPath");
}
/**
* 获取URL后缀
*/
public static String getUrlSuffix() {
return getConfig("urlSuffix");
}
/**
* 是否是演示模式，演示模式下不能修改用户、角色、密码、菜单、授权
*/
public static Boolean isDemoMode() {
String dm = getConfig("demoMode");
return "true".equals(dm) || "1".equals(dm);
}
/**
* 在修改系统用户和角色时是否同步到Activiti
*/
public static Boolean isSynActivitiIndetity() {
String dm = getConfig("activiti.isSynActivitiIndetity");
return "true".equals(dm) || "1".equals(dm);
}
/**
* 页面获取常量
* @see ${fns:getConst('YES')}
*/
public static Object getConst(String field) {
try {
return Global.class.getField(field).get(null);
} catch (Exception e) {
// 异常代表无配置，这里什么也不做
}
return null;
}
/**
* 获取上传文件的根目录
* @return
*/
public static String getUserfilesBaseDir() {
String dir = getConfig("userfiles.basedir");
if (StringUtils.isBlank(dir)){
try {
dir = ServletContextFactory.getServletContext().getRealPath("/");
} catch (Exception e) {
return "";
}
}
if(!dir.endsWith("/")) {
dir += "/";
}
// System.out.println("userfiles.basedir: " + dir);
return dir;
}
/**
* 获取工程路径
* @return
*/
public static String getProjectPath(){
// 如果配置了工程路径，则直接返回，否则自动获取。
String projectPath = Global.getConfig("projectPath");
if (StringUtils.isNotBlank(projectPath)){
return projectPath;
}
try {
File file = new DefaultResourceLoader().getResource("").getFile();
if (file != null){
while(true){
File f = new File(file.getPath() + File.separator + "src" + File.separator + "main");
if (f == null || f.exists()){
break;
}
if (file.getParentFile() != null){
file = file.getParentFile();
}else{
break;
}
}
projectPath = file.toString();
}
} catch (IOException e) {
e.printStackTrace();
}
return projectPath;
}
/**
* 写入properties信息
*
* @param key
* 名称
* @param value
* 值
*/
public static void modifyConfig(String key, String value) {
try {
// 从输入流中读取属性列表（键和元素对）
Properties prop = getProperties();
prop.setProperty(key, value);
String path = Global.class.getResource("/jeeplus.properties").getPath();
FileOutputStream outputFile = new FileOutputStream(path);
prop.store(outputFile, "modify");
outputFile.close();
outputFile.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 返回 Properties
* @param fileName 文件名 (注意：加载的是src下的文件,如果在某个包下．请把包名加上)
* @param
* @return
*/
public static Properties getProperties(){
Properties prop = new Properties();
try {
Reader reader = Resources.getResourceAsReader("/jeeplus.properties");
prop.load(reader);
} catch (Exception e) {
return null;
}
return prop;
}
}
package com.jeeplus.common.utils;
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.util.Enumeration;
import org.apache.tools.zip.ZipEntry;
import org.apache.tools.zip.ZipFile;
import org.apache.tools.zip.ZipOutputStream;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 文件操作工具类
* 实现文件的创建、删除、复制、压缩、解压以及目录的创建、删除、复制、压缩解压等功能
* @author jeeplus
* @version 2013-06-21
*/
public class FileUtils extends org.apache.commons.io.FileUtils {
private static Logger log = LoggerFactory.getLogger(FileUtils.class);
/**
* 复制单个文件，如果目标文件存在，则不覆盖
* @param srcFileName 待复制的文件名
* @param descFileName 目标文件名
* @return 如果复制成功，则返回true，否则返回false
*/
public static boolean copyFile(String srcFileName, String descFileName) {
return FileUtils.copyFileCover(srcFileName, descFileName, false);
}
/**
* 复制单个文件
* @param srcFileName 待复制的文件名
* @param descFileName 目标文件名
* @param coverlay 如果目标文件已存在，是否覆盖
* @return 如果复制成功，则返回true，否则返回false
*/
public static boolean copyFileCover(String srcFileName,
String descFileName, boolean coverlay) {
File srcFile = new File(srcFileName);
// 判断源文件是否存在
if (!srcFile.exists()) {
log.debug("复制文件失败，源文件 " + srcFileName + " 不存在!");
return false;
}
// 判断源文件是否是合法的文件
else if (!srcFile.isFile()) {
log.debug("复制文件失败，" + srcFileName + " 不是一个文件!");
return false;
}
File descFile = new File(descFileName);
// 判断目标文件是否存在
if (descFile.exists()) {
// 如果目标文件存在，并且允许覆盖
if (coverlay) {
log.debug("目标文件已存在，准备删除!");
if (!FileUtils.delFile(descFileName)) {
log.debug("删除目标文件 " + descFileName + " 失败!");
return false;
}
} else {
log.debug("复制文件失败，目标文件 " + descFileName + " 已存在!");
return false;
}
} else {
if (!descFile.getParentFile().exists()) {
// 如果目标文件所在的目录不存在，则创建目录
log.debug("目标文件所在的目录不存在，创建目录!");
// 创建目标文件所在的目录
if (!descFile.getParentFile().mkdirs()) {
log.debug("创建目标文件所在的目录失败!");
return false;
}
}
}
// 准备复制文件
// 读取的位数
int readByte = 0;
InputStream ins = null;
OutputStream outs = null;
try {
// 打开源文件
ins = new FileInputStream(srcFile);
// 打开目标文件的输出流
outs = new FileOutputStream(descFile);
byte[] buf = new byte[1024];
// 一次读取1024个字节，当readByte为-1时表示文件已经读取完毕
while ((readByte = ins.read(buf)) != -1) {
// 将读取的字节流写入到输出流
outs.write(buf, 0, readByte);
}
log.debug("复制单个文件 " + srcFileName + " 到" + descFileName
+ "成功!");
return true;
} catch (Exception e) {
log.debug("复制文件失败：" + e.getMessage());
return false;
} finally {
// 关闭输入输出流，首先关闭输出流，然后再关闭输入流
if (outs != null) {
try {
outs.close();
} catch (IOException oute) {
oute.printStackTrace();
}
}
if (ins != null) {
try {
ins.close();
} catch (IOException ine) {
ine.printStackTrace();
}
}
}
}
/**
* 复制整个目录的内容，如果目标目录存在，则不覆盖
* @param srcDirName 源目录名
* @param descDirName 目标目录名
* @return 如果复制成功返回true，否则返回false
*/
public static boolean copyDirectory(String srcDirName, String descDirName) {
return FileUtils.copyDirectoryCover(srcDirName, descDirName,
false);
}
/**
* 复制整个目录的内容
* @param srcDirName 源目录名
* @param descDirName 目标目录名
* @param coverlay 如果目标目录存在，是否覆盖
* @return 如果复制成功返回true，否则返回false
*/
public static boolean copyDirectoryCover(String srcDirName,
String descDirName, boolean coverlay) {
File srcDir = new File(srcDirName);
// 判断源目录是否存在
if (!srcDir.exists()) {
log.debug("复制目录失败，源目录 " + srcDirName + " 不存在!");
return false;
}
// 判断源目录是否是目录
else if (!srcDir.isDirectory()) {
log.debug("复制目录失败，" + srcDirName + " 不是一个目录!");
return false;
}
// 如果目标文件夹名不以文件分隔符结尾，自动添加文件分隔符
String descDirNames = descDirName;
if (!descDirNames.endsWith(File.separator)) {
descDirNames = descDirNames + File.separator;
}
File descDir = new File(descDirNames);
// 如果目标文件夹存在
if (descDir.exists()) {
if (coverlay) {
// 允许覆盖目标目录
log.debug("目标目录已存在，准备删除!");
if (!FileUtils.delFile(descDirNames)) {
log.debug("删除目录 " + descDirNames + " 失败!");
return false;
}
} else {
log.debug("目标目录复制失败，目标目录 " + descDirNames + " 已存在!");
return false;
}
} else {
// 创建目标目录
log.debug("目标目录不存在，准备创建!");
if (!descDir.mkdirs()) {
log.debug("创建目标目录失败!");
return false;
}
}
boolean flag = true;
// 列出源目录下的所有文件名和子目录名
File[] files = srcDir.listFiles();
for (int i = 0; i < files.length; i++) {
// 如果是一个单个文件，则直接复制
if (files[i].isFile()) {
flag = FileUtils.copyFile(files[i].getAbsolutePath(),
descDirName + files[i].getName());
// 如果拷贝文件失败，则退出循环
if (!flag) {
break;
}
}
// 如果是子目录，则继续复制目录
if (files[i].isDirectory()) {
flag = FileUtils.copyDirectory(files[i]
.getAbsolutePath(), descDirName + files[i].getName());
// 如果拷贝目录失败，则退出循环
if (!flag) {
break;
}
}
}
if (!flag) {
log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 失败!");
return false;
}
log.debug("复制目录 " + srcDirName + " 到 " + descDirName + " 成功!");
return true;
}
/**
*
* 删除文件，可以删除单个文件或文件夹
*
* @param fileName 被删除的文件名
* @return 如果删除成功，则返回true，否是返回false
*/
public static boolean delFile(String fileName) {
File file = new File(fileName);
if (!file.exists()) {
log.debug(fileName + " 文件不存在!");
return true;
} else {
if (file.isFile()) {
return FileUtils.deleteFile(fileName);
} else {
return FileUtils.deleteDirectory(fileName);
}
}
}
/**
*
* 删除单个文件
*
* @param fileName 被删除的文件名
* @return 如果删除成功，则返回true，否则返回false
*/
public static boolean deleteFile(String fileName) {
File file = new File(fileName);
if (file.exists() && file.isFile()) {
if (file.delete()) {
log.debug("删除文件 " + fileName + " 成功!");
return true;
} else {
log.debug("删除文件 " + fileName + " 失败!");
return false;
}
} else {
log.debug(fileName + " 文件不存在!");
return true;
}
}
/**
*
* 删除目录及目录下的文件
*
* @param dirName 被删除的目录所在的文件路径
* @return 如果目录删除成功，则返回true，否则返回false
*/
public static boolean deleteDirectory(String dirName) {
String dirNames = dirName;
if (!dirNames.endsWith(File.separator)) {
dirNames = dirNames + File.separator;
}
File dirFile = new File(dirNames);
if (!dirFile.exists() || !dirFile.isDirectory()) {
log.debug(dirNames + " 目录不存在!");
return true;
}
boolean flag = true;
// 列出全部文件及子目录
File[] files = dirFile.listFiles();
for (int i = 0; i < files.length; i++) {
// 删除子文件
if (files[i].isFile()) {
flag = FileUtils.deleteFile(files[i].getAbsolutePath());
// 如果删除文件失败，则退出循环
if (!flag) {
break;
}
}
// 删除子目录
else if (files[i].isDirectory()) {
flag = FileUtils.deleteDirectory(files[i]
.getAbsolutePath());
// 如果删除子目录失败，则退出循环
if (!flag) {
break;
}
}
}
if (!flag) {
log.debug("删除目录失败!");
return false;
}
// 删除当前目录
if (dirFile.delete()) {
log.debug("删除目录 " + dirName + " 成功!");
return true;
} else {
log.debug("删除目录 " + dirName + " 失败!");
return false;
}
}
/**
* 创建单个文件
* @param descFileName 文件名，包含路径
* @return 如果创建成功，则返回true，否则返回false
*/
public static boolean createFile(String descFileName) {
File file = new File(descFileName);
if (file.exists()) {
log.debug("文件 " + descFileName + " 已存在!");
return false;
}
if (descFileName.endsWith(File.separator)) {
log.debug(descFileName + " 为目录，不能创建目录!");
return false;
}
if (!file.getParentFile().exists()) {
// 如果文件所在的目录不存在，则创建目录
if (!file.getParentFile().mkdirs()) {
log.debug("创建文件所在的目录失败!");
return false;
}
}
// 创建文件
try {
if (file.createNewFile()) {
log.debug(descFileName + " 文件创建成功!");
return true;
} else {
log.debug(descFileName + " 文件创建失败!");
return false;
}
} catch (Exception e) {
e.printStackTrace();
log.debug(descFileName + " 文件创建失败!");
return false;
}
}
/**
* 创建目录
* @param descDirName 目录名,包含路径
* @return 如果创建成功，则返回true，否则返回false
*/
public static boolean createDirectory(String descDirName) {
String descDirNames = descDirName;
if (!descDirNames.endsWith(File.separator)) {
descDirNames = descDirNames + File.separator;
}
File descDir = new File(descDirNames);
if (descDir.exists()) {
log.debug("目录 " + descDirNames + " 已存在!");
return false;
}
// 创建目录
if (descDir.mkdirs()) {
log.debug("目录 " + descDirNames + " 创建成功!");
return true;
} else {
log.debug("目录 " + descDirNames + " 创建失败!");
return false;
}
}
/**
* 写入文件
* @param file 要写入的文件
*/
public static void writeToFile(String fileName, String content, boolean append) {
try {
FileUtils.write(new File(fileName), content, "utf-8", append);
log.debug("文件 " + fileName + " 写入成功!");
} catch (IOException e) {
log.debug("文件 " + fileName + " 写入失败! " + e.getMessage());
}
}
/**
* 写入文件
* @param file 要写入的文件
*/
public static void writeToFile(String fileName, String content, String encoding, boolean append) {
try {
FileUtils.write(new File(fileName), content, encoding, append);
log.debug("文件 " + fileName + " 写入成功!");
} catch (IOException e) {
log.debug("文件 " + fileName + " 写入失败! " + e.getMessage());
}
}
/**
* 压缩文件或目录
* @param srcDirName 压缩的根目录
* @param fileName 根目录下的待压缩的文件名或文件夹名，其中*或""表示跟目录下的全部文件
* @param descFileName 目标zip文件
*/
public static void zipFiles(String srcDirName, String fileName,
String descFileName) {
// 判断目录是否存在
if (srcDirName == null) {
log.debug("文件压缩失败，目录 " + srcDirName + " 不存在!");
return;
}
File fileDir = new File(srcDirName);
if (!fileDir.exists() || !fileDir.isDirectory()) {
log.debug("文件压缩失败，目录 " + srcDirName + " 不存在!");
return;
}
String dirPath = fileDir.getAbsolutePath();
File descFile = new File(descFileName);
try {
ZipOutputStream zouts = new ZipOutputStream(new FileOutputStream(
descFile));
if ("*".equals(fileName) || "".equals(fileName)) {
FileUtils.zipDirectoryToZipFile(dirPath, fileDir, zouts);
} else {
File file = new File(fileDir, fileName);
if (file.isFile()) {
FileUtils.zipFilesToZipFile(dirPath, file, zouts);
} else {
FileUtils
.zipDirectoryToZipFile(dirPath, file, zouts);
}
}
zouts.close();
log.debug(descFileName + " 文件压缩成功!");
} catch (Exception e) {
log.debug("文件压缩失败：" + e.getMessage());
e.printStackTrace();
}
}
/**
* 解压缩ZIP文件，将ZIP文件里的内容解压到descFileName目录下
* @param zipFileName 需要解压的ZIP文件
* @param descFileName 目标文件
*/
public static boolean unZipFiles(String zipFileName, String descFileName) {
String descFileNames = descFileName;
if (!descFileNames.endsWith(File.separator)) {
descFileNames = descFileNames + File.separator;
}
try {
// 根据ZIP文件创建ZipFile对象
ZipFile zipFile = new ZipFile(zipFileName);
ZipEntry entry = null;
String entryName = null;
String descFileDir = null;
byte[] buf = new byte[4096];
int readByte = 0;
// 获取ZIP文件里所有的entry
@SuppressWarnings("rawtypes")
Enumeration enums = zipFile.getEntries();
// 遍历所有entry
while (enums.hasMoreElements()) {
entry = (ZipEntry) enums.nextElement();
// 获得entry的名字
entryName = entry.getName();
descFileDir = descFileNames + entryName;
if (entry.isDirectory()) {
// 如果entry是一个目录，则创建目录
new File(descFileDir).mkdirs();
continue;
} else {
// 如果entry是一个文件，则创建父目录
new File(descFileDir).getParentFile().mkdirs();
}
File file = new File(descFileDir);
// 打开文件输出流
OutputStream os = new FileOutputStream(file);
// 从ZipFile对象中打开entry的输入流
InputStream is = zipFile.getInputStream(entry);
while ((readByte = is.read(buf)) != -1) {
os.write(buf, 0, readByte);
}
os.close();
is.close();
}
zipFile.close();
log.debug("文件解压成功!");
return true;
} catch (Exception e) {
log.debug("文件解压失败：" + e.getMessage());
return false;
}
}
/**
* 将目录压缩到ZIP输出流
* @param dirPath 目录路径
* @param fileDir 文件信息
* @param zouts 输出流
*/
public static void zipDirectoryToZipFile(String dirPath, File fileDir,
ZipOutputStream zouts) {
if (fileDir.isDirectory()) {
File[] files = fileDir.listFiles();
// 空的文件夹
if (files.length == 0) {
// 目录信息
ZipEntry entry = new ZipEntry(getEntryName(dirPath, fileDir));
try {
zouts.putNextEntry(entry);
zouts.closeEntry();
} catch (Exception e) {
e.printStackTrace();
}
return;
}
for (int i = 0; i < files.length; i++) {
if (files[i].isFile()) {
// 如果是文件，则调用文件压缩方法
FileUtils
.zipFilesToZipFile(dirPath, files[i], zouts);
} else {
// 如果是目录，则递归调用
FileUtils.zipDirectoryToZipFile(dirPath, files[i],
zouts);
}
}
}
}
/**
* 将文件压缩到ZIP输出流
* @param dirPath 目录路径
* @param file 文件
* @param zouts 输出流
*/
public static void zipFilesToZipFile(String dirPath, File file,
ZipOutputStream zouts) {
FileInputStream fin = null;
ZipEntry entry = null;
// 创建复制缓冲区
byte[] buf = new byte[4096];
int readByte = 0;
if (file.isFile()) {
try {
// 创建一个文件输入流
fin = new FileInputStream(file);
// 创建一个ZipEntry
entry = new ZipEntry(getEntryName(dirPath, file));
// 存储信息到压缩文件
zouts.putNextEntry(entry);
// 复制字节到压缩文件
while ((readByte = fin.read(buf)) != -1) {
zouts.write(buf, 0, readByte);
}
zouts.closeEntry();
fin.close();
System.out
.println("添加文件 " + file.getAbsolutePath() + " 到zip文件中!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 获取待压缩文件在ZIP文件中entry的名字，即相对于跟目录的相对路径名
* @param dirPat 目录名
* @param file entry文件名
* @return
*/
private static String getEntryName(String dirPath, File file) {
String dirPaths = dirPath;
if (!dirPaths.endsWith(File.separator)) {
dirPaths = dirPaths + File.separator;
}
String filePath = file.getAbsolutePath();
// 对于目录，必须在entry名字后面加上"/"，表示它将以目录项存储
if (file.isDirectory()) {
filePath += "/";
}
int index = filePath.indexOf(dirPaths);
return filePath.substring(index + dirPaths.length());
}
// /**
// * 修复路径，将 \\ 或 / 等替换为 File.separator
// * @param path
// * @return
// */
// public static String path(String path){
// String p = StringUtils.replace(path, "\\", "/");
// p = StringUtils.join(StringUtils.split(p, "/"), "/");
// if (!StringUtils.startsWithAny(p, "/") && StringUtils.startsWithAny(path, "\\", "/")){
// p += "/";
// }
// if (!StringUtils.endsWithAny(p, "/") && StringUtils.endsWithAny(path, "\\", "/")){
// p = p + "/";
// }
// return p;
// }
}
package com.jeeplus.common.config;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.Reader;
import java.util.Map;
import java.util.Properties;
import org.apache.ibatis.io.Resources;
import org.springframework.core.io.DefaultResourceLoader;
import com.ckfinder.connector.ServletContextFactory;
import com.google.common.collect.Maps;
import com.jeeplus.common.utils.PropertiesLoader;
import com.jeeplus.common.utils.StringUtils;
/**
* 全局配置类
* @author jeeplus
* @version 2014-06-25
*/
public class Global {
/**
* 当前对象实例
*/
private static Global global = new Global();
/**
* 保存全局属性值
*/
private static Map<String, String> map = Maps.newHashMap();
/**
* 属性文件加载对象
*/
private static PropertiesLoader loader = new PropertiesLoader("jeeplus.properties");
/**
* 显示/隐藏
*/
public static final String SHOW = "1";
public static final String HIDE = "0";
/**
* 是/否
*/
public static final String YES = "1";
public static final String NO = "0";
/**
* 对/错
*/
public static final String TRUE = "true";
public static final String FALSE = "false";
/**
* 上传文件基础虚拟路径
*/
public static final String USERFILES_BASE_URL = "/userfiles/";
/**
* 获取当前对象实例
*/
public static Global getInstance() {
return global;
}
/**
* 获取配置
* @see ${fns:getConfig('adminPath')}
*/
public static String getConfig(String key) {
String value = map.get(key);
if (value == null){
value = loader.getProperty(key);
map.put(key, value != null ? value : StringUtils.EMPTY);
}
return value;
}
/**
* 获取管理端根路径
*/
public static String getAdminPath() {
return getConfig("adminPath");
}
/**
* 获取前端根路径
*/
public static String getFrontPath() {
return getConfig("frontPath");
}
/**
* 获取URL后缀
*/
public static String getUrlSuffix() {
return getConfig("urlSuffix");
}
/**
* 是否是演示模式，演示模式下不能修改用户、角色、密码、菜单、授权
*/
public static Boolean isDemoMode() {
String dm = getConfig("demoMode");
return "true".equals(dm) || "1".equals(dm);
}
/**
* 在修改系统用户和角色时是否同步到Activiti
*/
public static Boolean isSynActivitiIndetity() {
String dm = getConfig("activiti.isSynActivitiIndetity");
return "true".equals(dm) || "1".equals(dm);
}
/**
* 页面获取常量
* @see ${fns:getConst('YES')}
*/
public static Object getConst(String field) {
try {
return Global.class.getField(field).get(null);
} catch (Exception e) {
// 异常代表无配置，这里什么也不做
}
return null;
}
/**
* 获取上传文件的根目录
* @return
*/
public static String getUserfilesBaseDir() {
String dir = getConfig("userfiles.basedir");
if (StringUtils.isBlank(dir)){
try {
dir = ServletContextFactory.getServletContext().getRealPath("/");
} catch (Exception e) {
return "";
}
}
if(!dir.endsWith("/")) {
dir += "/";
}
// System.out.println("userfiles.basedir: " + dir);
return dir;
}
/**
* 获取工程路径
* @return
*/
public static String getProjectPath(){
// 如果配置了工程路径，则直接返回，否则自动获取。
String projectPath = Global.getConfig("projectPath");
if (StringUtils.isNotBlank(projectPath)){
return projectPath;
}
try {
File file = new DefaultResourceLoader().getResource("").getFile();
if (file != null){
while(true){
File f = new File(file.getPath() + File.separator + "src" + File.separator + "main");
if (f == null || f.exists()){
break;
}
if (file.getParentFile() != null){
file = file.getParentFile();
}else{
break;
}
}
projectPath = file.toString();
}
} catch (IOException e) {
e.printStackTrace();
}
return projectPath;
}
/**
* 写入properties信息
*
* @param key
* 名称
* @param value
* 值
*/
public static void modifyConfig(String key, String value) {
try {
// 从输入流中读取属性列表（键和元素对）
Properties prop = getProperties();
prop.setProperty(key, value);
String path = Global.class.getResource("/jeeplus.properties").getPath();
FileOutputStream outputFile = new FileOutputStream(path);
prop.store(outputFile, "modify");
outputFile.close();
outputFile.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 返回 Properties
* @param fileName 文件名 (注意：加载的是src下的文件,如果在某个包下．请把包名加上)
* @param
* @return
*/
public static Properties getProperties(){
Properties prop = new Properties();
try {
Reader reader = Resources.getResourceAsReader("/jeeplus.properties");
prop.load(reader);
} catch (Exception e) {
return null;
}
return prop;
}
}
package com.jeeplus.modules.sys.service;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import org.apache.shiro.session.Session;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jeeplus.common.config.Global;
import com.jeeplus.common.persistence.Page;
import com.jeeplus.common.security.Digests;
import com.jeeplus.common.security.shiro.session.SessionDAO;
import com.jeeplus.common.service.BaseService;
import com.jeeplus.common.service.ServiceException;
import com.jeeplus.common.utils.CacheUtils;
import com.jeeplus.common.utils.Encodes;
import com.jeeplus.common.utils.StringUtils;
import com.jeeplus.modules.sys.dao.MenuDao;
import com.jeeplus.modules.sys.dao.RoleDao;
import com.jeeplus.modules.sys.dao.UserDao;
import com.jeeplus.modules.sys.entity.Menu;
import com.jeeplus.modules.sys.entity.Office;
import com.jeeplus.modules.sys.entity.Role;
import com.jeeplus.modules.sys.entity.User;
import com.jeeplus.modules.sys.security.SystemAuthorizingRealm;
import com.jeeplus.modules.sys.utils.LogUtils;
import com.jeeplus.modules.sys.utils.UserUtils;
/**
* 系统管理，安全相关实体的管理类,包括用户、角色、菜单.
* @author jeeplus
* @version 2013-12-05
*/
@Service
@Transactional(readOnly = true)
public class SystemService extends BaseService implements InitializingBean {
public static final String HASH_ALGORITHM = "SHA-1";
public static final int HASH_INTERATIONS = 1024;
public static final int SALT_SIZE = 8;
@Autowired
private UserDao userDao;
@Autowired
private RoleDao roleDao;
@Autowired
private MenuDao menuDao;
@Autowired
private SessionDAO sessionDao;
@Autowired
private SystemAuthorizingRealm systemRealm;
public SessionDAO getSessionDao() {
return sessionDao;
}
//-- User Service --//
/**
* 获取用户
* @param id
* @return
*/
public User getUser(String id) {
return UserUtils.get(id);
}
/**
* 根据登录名获取用户
* @param loginName
* @return
*/
public User getUserByLoginName(String loginName) {
return UserUtils.getByLoginName(loginName);
}
public Page<User> findUser(Page<User> page, User user) {
// 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
// 设置分页参数
user.setPage(page);
// 执行分页查询
List<User> userList = userDao.findList(user);
for(User thisUser : userList){
List<Role> roleList = roleDao.findList(new Role(thisUser));
thisUser.setRoleList(roleList);
}
page.setList(userList);
return page;
}
/**
* 无分页查询人员列表
* @param user
* @return
*/
public List<User> findUser(User user){
// 生成数据权限过滤条件（dsf为dataScopeFilter的简写，在xml中使用 ${sqlMap.dsf}调用权限SQL）
user.getSqlMap().put("dsf", dataScopeFilter(user.getCurrentUser(), "o", "a"));
List<User> list = userDao.findList(user);
return list;
}
/**
* 通过部门ID获取用户列表，仅返回用户id和name（树查询用户时用）
* @param user
* @return
*/
@SuppressWarnings("unchecked")
public List<User> findUserByOfficeId(String officeId) {
List<User> list = (List<User>)CacheUtils.get(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId);
if (list == null){
User user = new User();
user.setOffice(new Office(officeId));
list = userDao.findUserByOfficeId(user);
CacheUtils.put(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + officeId, list);
}
return list;
}
@Transactional(readOnly = false)
public void saveUser(User user) {
if (StringUtils.isBlank(user.getId())){
user.preInsert();
userDao.insert(user);
}else{
// 清除原用户机构用户缓存
User oldUser = userDao.get(user.getId());
if (oldUser.getOffice() != null && oldUser.getOffice().getId() != null){
CacheUtils.remove(UserUtils.USER_CACHE, UserUtils.USER_CACHE_LIST_BY_OFFICE_ID_ + oldUser.getOffice().getId());
}
// 更新用户数据
user.preUpdate();
userDao.update(user);
}
if (StringUtils.isNotBlank(user.getId())){
// 更新用户与角色关联
userDao.deleteUserRole(user);
if (user.getRoleList() != null && user.getRoleList().size() > 0){
userDao.insertUserRole(user);
}else{
throw new ServiceException(user.getLoginName() + "没有设置角色！");
}
// 清除用户缓存
UserUtils.clearCache(user);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
}
@Transactional(readOnly = false)
public void updateUserInfo(User user) {
user.preUpdate();
userDao.updateUserInfo(user);
// 清除用户缓存
UserUtils.clearCache(user);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
@Transactional(readOnly = false)
public void deleteUser(User user) {
userDao.delete(user);
// 清除用户缓存
UserUtils.clearCache(user);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
@Transactional(readOnly = false)
public void updatePasswordById(String id, String loginName, String newPassword) {
User user = new User(id);
user.setPassword(entryptPassword(newPassword));
userDao.updatePasswordById(user);
// 清除用户缓存
user.setLoginName(loginName);
UserUtils.clearCache(user);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
@Transactional(readOnly = false)
public void updateUserLoginInfo(User user) {
// 保存上次登录信息
user.setOldLoginIp(user.getLoginIp());
user.setOldLoginDate(user.getLoginDate());
// 更新本次登录信息
user.setLoginIp(UserUtils.getSession().getHost());
user.setLoginDate(new Date());
userDao.updateLoginInfo(user);
}
/**
* 生成安全的密码，生成随机的16位salt并经过1024次 sha-1 hash
*/
public static String entryptPassword(String plainPassword) {
byte[] salt = Digests.generateSalt(SALT_SIZE);
byte[] hashPassword = Digests.sha1(plainPassword.getBytes(), salt, HASH_INTERATIONS);
return Encodes.encodeHex(salt)+Encodes.encodeHex(hashPassword);
}
/**
* 验证密码
* @param plainPassword 明文密码
* @param password 密文密码
* @return 验证成功返回true
*/
public static boolean validatePassword(String plainPassword, String password) {
byte[] salt = Encodes.decodeHex(password.substring(0,16));
byte[] hashPassword = Digests.sha1(plainPassword.getBytes(), salt, HASH_INTERATIONS);
return password.equals(Encodes.encodeHex(salt)+Encodes.encodeHex(hashPassword));
}
/**
* 获得活动会话
* @return
*/
public Collection<Session> getActiveSessions(){
return sessionDao.getActiveSessions(false);
}
//-- Role Service --//
public Role getRole(String id) {
return roleDao.get(id);
}
public Role getRoleByName(String name) {
Role r = new Role();
r.setName(name);
return roleDao.getByName(r);
}
public Role getRoleByEnname(String enname) {
Role r = new Role();
r.setEnname(enname);
return roleDao.getByEnname(r);
}
public List<Role> findRole(Role role){
return roleDao.findList(role);
}
public List<Role> findAllRole(){
return UserUtils.getRoleList();
}
@Transactional(readOnly = false)
public void saveRole(Role role) {
if (StringUtils.isBlank(role.getId())){
role.preInsert();
roleDao.insert(role);
}else{
role.preUpdate();
roleDao.update(role);
}
// 更新角色与菜单关联
roleDao.deleteRoleMenu(role);
if (role.getMenuList().size() > 0){
roleDao.insertRoleMenu(role);
}
// 更新角色与部门关联
roleDao.deleteRoleOffice(role);
if (role.getOfficeList().size() > 0){
roleDao.insertRoleOffice(role);
}
// 清除用户角色缓存
UserUtils.removeCache(UserUtils.CACHE_ROLE_LIST);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
@Transactional(readOnly = false)
public void deleteRole(Role role) {
roleDao.delete(role);
// 清除用户角色缓存
UserUtils.removeCache(UserUtils.CACHE_ROLE_LIST);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
}
@Transactional(readOnly = false)
public Boolean outUserInRole(Role role, User user) {
List<Role> roles = user.getRoleList();
for (Role e : roles){
if (e.getId().equals(role.getId())){
roles.remove(e);
saveUser(user);
return true;
}
}
return false;
}
@Transactional(readOnly = false)
public User assignUserToRole(Role role, User user) {
if (user == null){
return null;
}
List<String> roleIds = user.getRoleIdList();
if (roleIds.contains(role.getId())) {
return null;
}
user.getRoleList().add(role);
saveUser(user);
return user;
}
//-- Menu Service --//
public Menu getMenu(String id) {
return menuDao.get(id);
}
public List<Menu> findAllMenu(){
return UserUtils.getMenuList();
}
@Transactional(readOnly = false)
public void saveMenu(Menu menu) {
// 获取父节点实体
menu.setParent(this.getMenu(menu.getParent().getId()));
// 获取修改前的parentIds，用于更新子节点的parentIds
String oldParentIds = menu.getParentIds();
// 设置新的父节点串
menu.setParentIds(menu.getParent().getParentIds()+menu.getParent().getId()+",");
// 保存或更新实体
if (StringUtils.isBlank(menu.getId())){
menu.preInsert();
menuDao.insert(menu);
}else{
menu.preUpdate();
menuDao.update(menu);
}
// 更新子节点 parentIds
Menu m = new Menu();
m.setParentIds("%,"+menu.getId()+",%");
List<Menu> list = menuDao.findByParentIdsLike(m);
for (Menu e : list){
e.setParentIds(e.getParentIds().replace(oldParentIds, menu.getParentIds()));
menuDao.updateParentIds(e);
}
// 清除用户菜单缓存
UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
// 清除日志相关缓存
CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
}
@Transactional(readOnly = false)
public void updateMenuSort(Menu menu) {
menuDao.updateSort(menu);
// 清除用户菜单缓存
UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
// 清除日志相关缓存
CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
}
@Transactional(readOnly = false)
public void deleteMenu(Menu menu) {
menuDao.delete(menu);
// 清除用户菜单缓存
UserUtils.removeCache(UserUtils.CACHE_MENU_LIST);
// // 清除权限缓存
// systemRealm.clearAllCachedAuthorizationInfo();
// 清除日志相关缓存
CacheUtils.remove(LogUtils.CACHE_MENU_NAME_PATH_MAP);
}
/**
* 获取Key加载信息
*/
public static boolean printKeyLoadMessage(){
StringBuilder sb = new StringBuilder();
sb.append("\r\n======================================================================\r\n");
sb.append("\r\n 欢迎使用 "+Global.getConfig("productName")+" - Powered By http://www.jeeplus.org\r\n");
sb.append("\r\n======================================================================\r\n");
System.out.println(sb.toString());
return true;
}
@Override
public void afterPropertiesSet() throws Exception {
// TODO Auto-generated method stub
}
}
下载的页面: uploadFile.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ page import="java.io.*, java.util.*, org.apache.commons.fileupload.*, java.util.*" %>
<%@ page import="org.apache.commons.fileupload.disk.*, org.apache.commons.fileupload.servlet.*" %>
<%!
public void upload(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
String savePath = this.getServletConfig().getServletContext().getRealPath("");
savePath = savePath + request.getParameter("uploadPath");
File f1 = new File(savePath);
//这里接收了uploadPath的值 System.out.println(request.getParameter("uploadPath"));
if (!f1.exists()) {
f1.mkdirs();
}
DiskFileItemFactory fac = new DiskFileItemFactory();
ServletFileUpload upload = new ServletFileUpload(fac);
upload.setHeaderEncoding("utf-8");
List fileList = null;
try {
fileList = upload.parseRequest(request);
} catch (FileUploadException ex) {
return;
}
String fileNmae = request.getParameter("fileNmae");
Iterator<FileItem> it = fileList.iterator();
String name = "";
String extName = "";
while (it.hasNext()) {
FileItem item = it.next();
if (!item.isFormField()) {
name = item.getName();
long size = item.getSize();
String type = item.getContentType();
//System.out.println(size + " " + type);
if (name == null || name.trim().equals("")) {
continue;
}
// 扩展名格式：
if (name.lastIndexOf(".") >= 0) {
extName = name.substring(name.lastIndexOf("."));
}
File file = null;
if(null != fileNmae && !"".equals(fileNmae)){
file = new File(savePath + fileNmae);
}else{
do {
if(null != fileNmae && !"".equals(fileNmae)){
file = new File(savePath + fileNmae);
}else{
name = new java.text.SimpleDateFormat("yyyyMMddhhmmss").format(new Date()); //获取当前日期
name = name + (int)(Math.random()*90000+10000);
file = new File(savePath + name + extName);
}
} while (file.exists());
}
File saveFile = new File(savePath + name + extName);
try {
item.write(saveFile);
} catch (Exception e) {
e.printStackTrace();
}
}
}
response.getWriter().print((name.trim() + extName.trim()).trim());
}
%>
<%
upload(request, response);
%>
1404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
