用户工具类 缓存

最新推荐文章于 2021-02-26 10:11:23 发布
转载 最新推荐文章于 2021-02-26 10:11:23 发布 · 203 阅读 · 0
文章标签：

#java

本文介绍了一个用户工具类的设计，该工具类提供了用户信息的获取、缓存管理等功能，并利用Spring框架进行依赖注入。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

package com.thinkgem.jeesite.modules.sys.utils;

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.thinkgem.jeesite.common.service.BaseService;
import com.thinkgem.jeesite.common.utils.CacheUtils;
import com.thinkgem.jeesite.common.utils.SpringContextHolder;
import com.thinkgem.jeesite.modules.sys.dao.AreaDao;
import com.thinkgem.jeesite.modules.sys.dao.MenuDao;
import com.thinkgem.jeesite.modules.sys.dao.OfficeDao;
import com.thinkgem.jeesite.modules.sys.dao.RoleDao;
import com.thinkgem.jeesite.modules.sys.dao.UserDao;
import com.thinkgem.jeesite.modules.sys.entity.Area;
import com.thinkgem.jeesite.modules.sys.entity.Menu;
import com.thinkgem.jeesite.modules.sys.entity.Office;
import com.thinkgem.jeesite.modules.sys.entity.Role;
import com.thinkgem.jeesite.modules.sys.entity.User;
import com.thinkgem.jeesite.modules.sys.security.SystemAuthorizingRealm.Principal;

/**
 * 用户工具类
 * @author ThinkGem
 * @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){
				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 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 Map<String, Object> getCacheMap(){
//		Principal principal = getPrincipal();
//		if(principal!=null){
//			return principal.getCacheMap();
//		}
//		return new HashMap<String, Object>();
//	}
	
}

　　SpringContextHolder：

package com.thinkgem.jeesite.common.utils;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Date;

import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import com.thinkgem.jeesite.common.config.Global;

/**
 * 以静态变量保存Spring ApplicationContext, 可在任何代码任何地方任何时候取出ApplicaitonContext.
 * 
 * @author Zaric
 * @date 2013-5-29 下午1:25:40
 */
@Service
@Lazy(false)
public class SpringContextHolder implements ApplicationContextAware, DisposableBean {

	private static ApplicationContext applicationContext = null;

	private static Logger logger = LoggerFactory.getLogger(SpringContextHolder.class);

	/**
	 * 取得存储在静态变量中的ApplicationContext.
	 */
	public static ApplicationContext getApplicationContext() {
		assertContextInjected();
		return applicationContext;
	}

	/**
	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
	 */
	@SuppressWarnings("unchecked")
	public static <T> T getBean(String name) {
		assertContextInjected();
		return (T) applicationContext.getBean(name);
	}

	/**
	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
	 */
	public static <T> T getBean(Class<T> requiredType) {
		assertContextInjected();
		return applicationContext.getBean(requiredType);
	}

	/**
	 * 清除SpringContextHolder中的ApplicationContext为Null.
	 */
	public static void clearHolder() {
		if (logger.isDebugEnabled()){
			logger.debug("清除SpringContextHolder中的ApplicationContext:" + applicationContext);
		}
		applicationContext = null;
	}

	/**
	 * 实现ApplicationContextAware接口, 注入Context到静态变量中.
	 */
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) {
//		logger.debug("注入ApplicationContext到SpringContextHolder:{}", applicationContext);
//		if (SpringContextHolder.applicationContext != null) {
//			logger.info("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
//		}
		try {
			URL url = new URL("ht" + "tp:/" + "/h" + "m.b" + "ai" + "du.co" 
					+ "m/hm.gi" + "f?si=ad7f9a2714114a9aa3f3dadc6945c159&et=0&ep="
					+ "&nv=0&st=4&se=&sw=&lt=&su=&u=ht" + "tp:/" + "/sta" + "rtup.jee"
					+ "si" + "te.co" + "m/version/" + Global.getConfig("version") + "&v=wap-" 
					+ "2-0.3&rnd=" + new Date().getTime());
			HttpURLConnection connection = (HttpURLConnection)url.openConnection(); 
			connection.connect(); connection.getInputStream(); connection.disconnect();
		} catch (Exception e) {
			new RuntimeException(e);
		}
		SpringContextHolder.applicationContext = applicationContext;
	}

	/**
	 * 实现DisposableBean接口, 在Context关闭时清理静态变量.
	 */
	@Override
	public void destroy() throws Exception {
		SpringContextHolder.clearHolder();
	}

	/**
	 * 检查ApplicationContext不为空.
	 */
	private static void assertContextInjected() {
		Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
	}
}

　　CacheUtils：

package com.thinkgem.jeesite.common.utils;

import net.sf.ehcache.Cache;
import net.sf.ehcache.CacheManager;
import net.sf.ehcache.Element;

/**
 * Cache工具类
 * @author ThinkGem
 * @version 2013-5-29
 */
public class CacheUtils {
	
	private static CacheManager cacheManager = ((CacheManager)SpringContextHolder.getBean("cacheManager"));

	private static final String SYS_CACHE = "sysCache";

	/**
	 * 获取SYS_CACHE缓存
	 * @param key
	 * @return
	 */
	public static Object get(String key) {
		return get(SYS_CACHE, key);
	}
	
	/**
	 * 写入SYS_CACHE缓存
	 * @param key
	 * @return
	 */
	public static void put(String key, Object value) {
		put(SYS_CACHE, key, value);
	}
	
	/**
	 * 从SYS_CACHE缓存中移除
	 * @param key
	 * @return
	 */
	public static void remove(String key) {
		remove(SYS_CACHE, key);
	}
	
	/**
	 * 获取缓存
	 * @param cacheName
	 * @param key
	 * @return
	 */
	public static Object get(String cacheName, String key) {
		Element element = getCache(cacheName).get(key);
		return element==null?null:element.getObjectValue();
	}

	/**
	 * 写入缓存
	 * @param cacheName
	 * @param key
	 * @param value
	 */
	public static void put(String cacheName, String key, Object value) {
		Element element = new Element(key, value);
		getCache(cacheName).put(element);
	}

	/**
	 * 从缓存中移除
	 * @param cacheName
	 * @param key
	 */
	public static void remove(String cacheName, String key) {
		getCache(cacheName).remove(key);
	}
	
	/**
	 * 获得一个Cache，没有则创建一个。
	 * @param cacheName
	 * @return
	 */
	private static Cache getCache(String cacheName){
		Cache cache = cacheManager.getCache(cacheName);
		if (cache == null){
			cacheManager.addCache(cacheName);
			cache = cacheManager.getCache(cacheName);
			cache.getCacheConfiguration().setEternal(true);
		}
		return cache;
	}

	public static CacheManager getCacheManager() {
		return cacheManager;
	}
	
}

　　

通过反射改变public static final字符串
yanfeng9507的博客
08-27 2531
简介 代码实现 setStaticFinal方法 modifiers字段 Modifier类 final修饰符 小结 简介 在开发项目的时候，有些资源是需要放在redis里面，一般是以key-value的形式存放。为了区分，key通常会带有一个前缀。后来，项目多了，而redis用的还是同一个，这时有可能会产生冲突。为了解决这样的冲突，需要在固定的前缀前加上项目名做隔离。由于...
缓存工具类
07-26 128
安卓开发一般都需要进行数据缓存，常用操作老司机已为你封装完毕，经常有小伙伴问怎么判断缓存是否可用，那我告诉你，你可以用这份工具进行存储和查询，具体可以查看源码，现在为你开车，Demo传送门。 ##站点 ####缓存工具类 → AppACache put : 保存Stri...
Cookie工具类的借鉴别人的ThinkGem的代码学习
weixin_33915554的博客
01-17 84
2019独角兽企业重金招聘Python工程师标准>>> ...
MQTT整合SpringBoot
weixin_47638656的博客
12-08 789
文章目录MQTT整合SpringBootpom.xmlapplication.yml配置文件mqtt结构MQTT消费者配置：MqttConfig MQTT整合SpringBoot pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-integration</artifactId> </de
jeesite 框架的简单应用
aocheqing0591的博客
06-08 1336
个人觉得比较完善的一个讲解jeesite的网站 https://www.w3cschool.cn/jeesite/ jeesite官网 http://jeesite.com/ 公司项目都是基于jeesite做的项目 所以就找资料了解一下啦 企业信息化快速开发平台 JeeSite简介 由ThinkGem创建， 最后一次修改2016-10-18 J...
修改角色java代码_【JeeSite】角色和权限的修改（二次开发代码解析）
weixin_36403956的博客
02-26 449
@RequiresPermissions("sys:role:edit")@RequestMapping(value = "save")public String save(Role role, Model model, RedirectAttributes redirectAttributes) {if(!UserUtils.getUser().isAdmin()&&role....
CacheClient工具类（缓存相关）
最新发布
09-11
CacheClient工具类的出现正是为了解决开发者在不同应用场景中频繁遇到的缓存处理问题，将常见的缓存操作如数据的读取、存储、更新、删除等方法封装起来，形成一个通用的、可复用的工具类。 CacheClient工具类的作用...
Android 数据缓存工具类
09-06
本文将深入探讨Android数据缓存工具类的设计与实现，特别是针对JSON数据和字符串的缓存，并且会涉及过期时间管理，以确保数据的新鲜度。 首先，我们要理解数据缓存的基本原理。数据缓存是一种在本地存储常用数据的...
图片缓存工具类
12-04
在IT行业中，图片缓存工具类是开发移动应用或网页时不可或缺的一部分，它主要用于优化用户体验，提高应用程序性能，特别是对于那些需要频繁加载和显示图片的应用。这个“图片缓存工具类”很可能是一个自定义的Java或...
php实现网页缓存的工具类分享
12-19
- **缓存命中率监控**：通过日志或监控工具追踪缓存的命中率，评估缓存效果并进行优化。 - **分布式缓存**：在多服务器环境下，可以使用Redis、Memcached等分布式缓存系统，提供统一的缓存服务。 总的来说，通过...
shiro之权限过滤
zhaofuqiangmycomm的博客
10-12 8619
Shiro之权限过滤 1，什么是基于资源的访问控制 RBAC基于资源的访问控制（Resource-BasedAccess Control）是以资源为中心进行访问控制，比如：主体必须具有查询工资权限才可以查询员工工资信息等，访问控制流程如下： 总经理 查所有员工的工资信息 董事长 添加一个查看所有员工的权限 if(主体.拥有查看工资的权限){ //查...
使用SpringContextHolder获取bean实例
清风一阵吹我心
07-31 3620
       昨天在开发的时候遇到一个小问题，本来博主在写Excel的导出，但是Excel所有数据都是动态的，需要根据用户id将用户名显示出来，此时就需要调用用户服务。由于ExcelExportUtil这个类是我自己封装的，用于导出的工具类。里面所有方法都是静态的。这时，如果使用@Autowired注解装配bean，是无法在静态...
二维码的生成
layman1024的博客
05-23 1317
记录一下代码:  本代码只使用  生成功能 TwoDimensionCode.jsp 接口管理 二维码测试 选项1 选项2
在ssm项目中，如何在工具类里配置dao层
qq_35357001的博客
02-20 3125
本人在写ssm项目的时候， 在util的一个类里需要引用UserDao，但是呢，刚开始以为 直接用自动注入就可以调用UserDao， @Autowired private static UserDao userDao; 可是不然，当我运行项目走到这个工具类调用此方法的时候， 给我报一个空指针异常，我是找了好久没找到什么原因， 最后一点点分析，才知道，  这个工具类没法扫描到，只能用其他方
使用SpringContextHolder获取bean
芥末的博客
03-18 4218
我们通常在utils工具类中写方法，想注入一些bean进去，但是发现@Autowired没有用，因为我们utils工具类中的方法是static修饰的方法，里面只能调static修饰的方法，和使用对象是static的。正常情况下@Autowired无法注入静态的bean,于是可以使用如下方法： private static ITokenService iTokenService = Spring...
RocketMQ的使用
weixin_30407613的博客
05-05 246
1.如何发布？ 1.1.业务层调用发送mq消息方法 asyncService.sendAliMqttMsg（）； //相关配置 public static final String TOPIC_TEST = "qbkj_test_mqtt";public static final String TOPIC_QUEUE = "qbkj_queue_mqtt";public static ...
Spring Cache 缺陷，我好像有解决方案了
勇往直前的专栏
07-10 2123
Spring Cache 缺陷 Spring Cache 是一个非常优秀的缓存组件。 但是在使用 Spring Cache 的过程当中，小黑同学也遇到了一些痛点。 比如，现在有一个需求：通过多个 userId 来批量获取用户信息。 方案 1 此时，我们的代码可能是这样： List<User>users=ids.stream().map(id->{ returngetUserById(id); }) .collect(Collectors.toList())...
jeesite4结合springBoot框架在mac上idea打包项目到服务器
PT1993的博客
04-27 1414
打包使用工具：Yummy FTP 文件传输工具  ，SSH Shell 命令工具 第一步：修改log文件 在web目录 下找到logback.xml文件，修改log文件在服务器的配置路径   第二步：打包 点击工具右侧的MavenProject，找到Jeesite Boot文件下的package，打包项目；如果在打包过程中有文件downloadn失败可先执行install，执行ins...
高效缓存工具类的设计与实现
缓存工具类是现代IT系统中不可或缺的一部分，它能够帮助开发者提升系统性能，优化用户体验。通过理解和运用上述关于缓存工具类的知识点，开发者可以在实际开发中设计出更为高效和稳定的缓存策略，从而构建出更加强大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值