weixin_30713953
weixin_30713953

Spring 整合 Shiro

一、引入依赖


<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>4.3.18.RELEASEversion>
    <scope>testscope>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>4.3.18.RELEASEversion>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>4.3.18.RELEASEversion>
dependency>
<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-context-supportartifactId>
    <version>4.3.18.RELEASEversion>
dependency>



<dependency>
    <groupId>org.apache.shirogroupId>
    <artifactId>shiro-springartifactId>
    <version>1.4.0version>
dependency>



<dependency>
    <groupId>net.sf.ehcachegroupId>
    <artifactId>ehcache-coreartifactId>
    <version>2.6.11version>
dependency>

二、创建 ehcache 缓存配置文件 

文件：ehchache.xml

xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" dynamicConfig="false">
    <diskStore path="java.io.tmpdir"/>

    <cache name="authenticationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true"/>

    <cache name="authorizationCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true"/>

    <cache name="activeSessionCache"
           maxEntriesLocalHeap="2000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           statistics="true">
    cache>

    
    <cache name="halfHour"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="1800"
           timeToLiveSeconds="1800"
           overflowToDisk="false"
           diskPersistent="false" />

    
    <cache name="hour"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="3600"
           timeToLiveSeconds="3600"
           overflowToDisk="false"
           diskPersistent="false" />

    
    <cache name="oneDay"
           maxElementsInMemory="10000"
           maxElementsOnDisk="100000"
           eternal="false"
           timeToIdleSeconds="86400"
           timeToLiveSeconds="86400"
           overflowToDisk="false"
           diskPersistent="false" />

    

    <defaultCache name="defaultCache"
                  maxElementsInMemory="10000"
                  eternal="false"
                  timeToIdleSeconds="120"
                  timeToLiveSeconds="120"
                  overflowToDisk="false"
                  maxElementsOnDisk="100000"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="120"
                  memoryStoreEvictionPolicy="LRU"/>
ehcache>
View Code

四、Spring 整合 Shiro

1. 创建文件 spring-shiro.xml

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

beans>

2. 将 shiro 的缓存管理器交给 spring-cache 管理

package com.beovo.dsd.common.shiro.cache;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheException;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.util.Destroyable;
import org.springframework.util.ClassUtils;

/**
 * 使用spring-cache作为shiro缓存- 缓存管理器
 * @author Jimc.
 * @since 2018/11/22.
 */
public class ShiroSpringCacheManager implements CacheManager, Destroyable {
    private static final Logger logger = LogManager.getLogger(ShiroSpringCacheManager.class);
    private org.springframework.cache.CacheManager cacheManager;
    private final boolean hasEhcache;

    public ShiroSpringCacheManager() {
        hasEhcache = ClassUtils.isPresent("net.sf.ehcache.Ehcache", this.getClass().getClassLoader());
    }

    public org.springframework.cache.CacheManager getCacheManager() {
        return cacheManager;
    }

    public void setCacheManager(org.springframework.cache.CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }

    @Override
    public  Cache getCache(String name) throws CacheException {
        if (logger.isTraceEnabled()) {
            logger.trace("Acquiring ShiroSpringCache instance named [" + name + "]");
        }
        org.springframework.cache.Cache cache = cacheManager.getCache(name);
        return new ShiroSpringCache(cache, hasEhcache);
    }

    @Override
    public void destroy() throws Exception {
        cacheManager = null;
    }

}
View Code 
package com.beovo.dsd.common.shiro.cache;

import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import org.apache.shiro.cache.CacheException;
import org.springframework.cache.Cache;
import org.springframework.cache.Cache.ValueWrapper;

import java.util.*;

/**
 * 使用spring-cache作为shiro缓存
 * @author Jimc.
 * @since 2018/11/22.
 */
public class ShiroSpringCache implements org.apache.shiro.cache.Cache {

    private static final Log log = LogFactory.get();

    private final Cache cache;

    private final boolean hasEhcache;

    public ShiroSpringCache(Cache cache, boolean hasEhcache) {
        if (cache == null) {
            throw new IllegalArgumentException("Cache argument cannot be null.");
        }
        this.cache = cache;
        this.hasEhcache = hasEhcache;
    }

    @Override
    public V get(K key) throws CacheException {
        if (log.isTraceEnabled()) {
            log.trace("Getting object from cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        ValueWrapper valueWrapper = cache.get(key);
        if (valueWrapper == null) {
            if (log.isTraceEnabled()) {
                log.trace("Element for [" + key + "] is null.");
            }
            return null;
        }
        return (V) valueWrapper.get();
    }

    @Override
    public V put(K key, V value) throws CacheException {
        if (log.isTraceEnabled()) {
            log.trace("Putting object in cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        V previous = get(key);
        cache.put(key, value);
        return previous;
    }

    @Override
    public V remove(K key) throws CacheException {
        if (log.isTraceEnabled()) {
            log.trace("Removing object from cache [" + this.cache.getName() + "] for key [" + key + "]key type:" + key.getClass());
        }
        V previous = get(key);
        cache.evict(key);
        return previous;
    }

    @Override
    public void clear() throws CacheException {
        if (log.isTraceEnabled()) {
            log.trace("Clearing all objects from cache [" + this.cache.getName() + "]");
        }
        cache.clear();
    }

    @Override
    public int size() {
        if (hasEhcache) {
            Object nativeCache = cache.getNativeCache();
            if (nativeCache instanceof net.sf.ehcache.Ehcache) {
                net.sf.ehcache.Ehcache ehcache = (net.sf.ehcache.Ehcache) nativeCache;
                return ehcache.getSize();
            }
        }
        return 0;
    }

    @Override
    public Set keys() {
        if (hasEhcache) {
            Object nativeCache = cache.getNativeCache();
            if (nativeCache instanceof net.sf.ehcache.Ehcache) {
                net.sf.ehcache.Ehcache ehcache = (net.sf.ehcache.Ehcache) nativeCache;
                return new HashSet<>(ehcache.getKeys());
            }
        }
        return Collections.emptySet();
    }

    @Override
    public Collection values() {
        if (hasEhcache) {
            Object nativeCache = cache.getNativeCache();
            if (nativeCache instanceof net.sf.ehcache.Ehcache) {
                net.sf.ehcache.Ehcache ehcache = (net.sf.ehcache.Ehcache) nativeCache;
                List keys = ehcache.getKeys();
                Map elementMap = ehcache.getAll(keys);
                List values = new ArrayList<>();
                for (net.sf.ehcache.Element element : elementMap.values()) {
                    values.add(element.getObjectValue());
                }
                return (Collection) values;
            }
        }
        return Collections.emptySet();
    }

    @Override
    public String toString() {
        return "ShiroSpringCache [" + this.cache.getName() + "]";
    }
} 
     
    View Code 
    
   
将 缓存管理器交给 Spring 来管理，在 spring-shiro.xml 添加配置如下：
 
   
 
    
   
    <bean id="shiroSpringCacheManager" class="com.beovo.dsd.common.shiro.cache.ShiroSpringCacheManager">
        <property name="cacheManager" ref="cacheManager"/>
    bean>
 
   
 
   
3. 自定义 Realm
 
   
（1）创建一个存放用户信息的bean
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro;

import java.io.Serializable;
import java.util.List;

/**
 * 自定义Authentication对象，使得Subject除了携带用户的登录名外还可以携带更多信息
 * @author Jimc.
 * @since 2018/11/23.
 */
public class ShiroUser implements Serializable {

    private static final long serialVersionUID = -1373760725780840091L;

    /**
     * 主键ID
     */
    private Long id;

    /**
     * 账号
     */
    private String account;

    /**
     * 姓名
     */
    private String name;

    /**
     * 部门id集
     */
    private List deptIds;

    /**
     * 部门名称集
     */
    private List deptNames;

    /**
     * 角色id集
     */
    private List roleIds;

    /**
     * 角色名称集
     */
    private List roleNames;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        this.account = account;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List getDeptIds() {
        return deptIds;
    }

    public void setDeptIds(List deptIds) {
        this.deptIds = deptIds;
    }

    public List getDeptNames() {
        return deptNames;
    }

    public void setDeptNames(List deptNames) {
        this.deptNames = deptNames;
    }

    public List getRoleIds() {
        return roleIds;
    }

    public void setRoleIds(List roleIds) {
        this.roleIds = roleIds;
    }

    public List getRoleNames() {
        return roleNames;
    }

    public void setRoleNames(List roleNames) {
        this.roleNames = roleNames;
    }
}
 
    
 
    View Code 
   
 
   
（2）首先创建一个继承 AuthorizingRealm 的类
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.StrUtil;
import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import com.beovo.dsd.po.User;
import com.beovo.dsd.service.UserAuthService;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.cache.CacheManager;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * shiro权限认证
 * @author Jimc.
 * @since 2018/11/22.
 */
public class ShiroDbRealm extends AuthorizingRealm {

    private static final Log log = LogFactory.get();

    @Autowired
    private UserAuthService userAuthService;

    public ShiroDbRealm(CacheManager cacheManager, CredentialsMatcher matcher) {
        super(cacheManager, matcher);
    }

    /**
     * Shiro登录认证(原理：用户提交 用户名和密码  --- shiro 封装令牌 ---- realm 通过用户名将密码查询返回 ---- shiro 自动去比较查询出密码和用户输入密码是否一致---- 进行登陆控制)
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authcToken) throws AuthenticationException {
        log.info("Shiro开始登录认证");
        UsernamePasswordToken token = Convert.convert(UsernamePasswordToken.class, authcToken);
        User user = userAuthService.getUser(token.getUsername());
        ShiroUser shiroUser = userAuthService.getShiroUser(user);

        // 认证缓存信息
        return userAuthService.info(shiroUser, user, getName());
    }

    /**
     * Shiro权限认证
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        ShiroUser shiroUser = Convert.convert(ShiroUser.class, principals.getPrimaryPrincipal());
        List<Long> roleIds = shiroUser.getRoleIds();

        Set<String> permissionSet = new HashSet<>();
        Set<String> roleAliasSet = new HashSet<>();

        for (Long roleId : roleIds) {
            List<String> permissions = userAuthService.getPermissionsByRoleId(roleId);
            if (CollUtil.isNotEmpty(permissions)) {
                for (String permission : permissions) {
                    if (StrUtil.isNotEmpty(permission)) {
                        permissionSet.add(permission);
                    }
                }
            }
            String roleAlias = userAuthService.getRoleAliasByRoleId(roleId);
            roleAliasSet.add(roleAlias);
        }

        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        info.addStringPermissions(permissionSet);
        info.addRoles(roleAliasSet);
        return info;
    }
}
 
    
 
    View Code 
   
 
   
（3）加入到 spring-shiro.xml 配置中
 
   
 
    

    <bean id="shiroDbRealm" class="com.beovo.dsd.common.shiro.ShiroDbRealm">
        <constructor-arg index="0" name="cacheManager" ref="shiroSpringCacheManager"/>
        <constructor-arg index="1" name="matcher" ref="credentialsMatcher"/>
        
        <property name="authenticationCachingEnabled" value="true"/>
        
        <property name="authenticationCacheName" value="authenticationCache"/>
        
        <property name="authorizationCacheName" value="authorizationCache"/>
    bean>
 
   
 
   
3. 添加会话管理器
 
   
 
    

    <bean id="sessionManager" class="org.apache.shiro.web.session.mgt.DefaultWebSessionManager">
        
        <property name="globalSessionTimeout" value="#{30 * 60 * 1000}"/>
        
        <property name="sessionIdUrlRewritingEnabled" value="false"/>
        <property name="sessionDAO" ref="sessionDAO"/>
    bean>

    
    <bean id="sessionDAO" class="org.apache.shiro.session.mgt.eis.EnterpriseCacheSessionDAO">
        
        <property name="activeSessionsCacheName" value="activeSessionCache"/>
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
    bean>
 
   
 
   
4. 添加Remember管理器
 
   
 
    
 
    <bean id="rememberMeCookie" class="org.apache.shiro.web.servlet.SimpleCookie">
        <constructor-arg value="rememberMe"/>
        <property name="httpOnly" value="true"/>
        
        <property name="maxAge" value="#{7 * 24 * 60 * 60}"/>
    bean>

    
    <bean id="rememberMeManager" class="org.apache.shiro.web.mgt.CookieRememberMeManager">
        <property name="cipherKey" value="#{T(org.apache.shiro.codec.Base64).decode('amltYwAAAAAAAAAAAAAAAA==')}"/>
        <property name="cookie" ref="rememberMeCookie"/>
    bean>
 
   
 
   
5. 添加密码加密配置
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro;

/**
 * shiro密码加密配置
 *
 * @author Jimc.
 * @since 2018/11/22.
 */
public class PasswordHash {

    /**
     * 加密算法名称
     */
    private String algorithmName;

    /**
     * 密码hash次数
     */
    private Integer hashIterations;

    public String getAlgorithmName() {
        return algorithmName;
    }

    public void setAlgorithmName(String algorithmName) {
        this.algorithmName = algorithmName;
    }

    public Integer getHashIterations() {
        return hashIterations;
    }

    public void setHashIterations(Integer hashIterations) {
        this.hashIterations = hashIterations;
    }

    /**
     * 密码加密
     *
     * @param source 加密源对象
     * @param salt   加密盐
     * @return 加密后的字符
     */
    public String encrypt(Object source, Object salt) {
        return ShiroKit.encrypt(algorithmName, source, salt, hashIterations);
    }
}
 
    
 
    View Code 
   
 
   
 
    

    <bean id="passwordHash" class="com.beovo.dsd.common.shiro.PasswordHash">
        
        <property name="algorithmName" value="md5"/>
        <property name="hashIterations" value="2"/>
    bean>
 
   
 
   
6. 添加密码错误次数锁定功能
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro;

import cn.hutool.log.Log;
import cn.hutool.log.LogFactory;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.ExcessiveAttemptsException;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.cache.Cache;
import org.apache.shiro.cache.CacheManager;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.util.Assert;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * 输错5次密码锁定半小时，ehcache.xml配置
 * @author Jimc.
 * @since 2018/11/22.
 */
public class RetryLimitCredentialsMatcher extends HashedCredentialsMatcher implements InitializingBean {
    private static final Log log = LogFactory.get();
    private final static String DEFAULT_CACHE_NAME = "retryLimitCache";
    
    private final CacheManager cacheManager;
    private String retryLimitCacheName;
    private Cache passwordRetryCache;
    private PasswordHash passwordHash;
    
    public RetryLimitCredentialsMatcher(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
        this.retryLimitCacheName = DEFAULT_CACHE_NAME;
    }
    
    public String getRetryLimitCacheName() {
        return retryLimitCacheName;
    }

    public void setRetryLimitCacheName(String retryLimitCacheName) {
        this.retryLimitCacheName = retryLimitCacheName;
    }
    
    public void setPasswordHash(PasswordHash passwordHash) {
        this.passwordHash = passwordHash;
    }

    @Override
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        String username = (String) token.getPrincipal();
        //retry count + 1
        AtomicInteger retryCount = passwordRetryCache.get(username);
        if(retryCount == null) {
            retryCount = new AtomicInteger(0);
            passwordRetryCache.put(username, retryCount);
        }
        if(retryCount.incrementAndGet() > 5) {
            //if retry count > 5 throw
            String message = "用户名: " + username + " 密码连续输入错误超过5次，锁定半小时！";
            log.warn(message);
            throw new ExcessiveAttemptsException(message);
        } else {
            passwordRetryCache.put(username, retryCount);
        }

        boolean matches = super.doCredentialsMatch(token, info);
        if(matches) {
            //clear retry data
            passwordRetryCache.remove(username);
        }
        return matches;
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        Assert.notNull(passwordHash, "you must set passwordHash!");
        super.setHashAlgorithmName(passwordHash.getAlgorithmName());
        super.setHashIterations(passwordHash.getHashIterations());
        this.passwordRetryCache = cacheManager.getCache(retryLimitCacheName);
    }
}
 
    
 
    View Code 
   
 
   
 
    
 
    <bean id="credentialsMatcher" class="com.beovo.dsd.common.shiro.RetryLimitCredentialsMatcher">
        <constructor-arg ref="shiroSpringCacheManager"/>
        <property name="retryLimitCacheName" value="halfHour"/>
        <property name="passwordHash" ref="passwordHash"/>
    bean>
 
   
 
   
7. 添加拦截器
 
   
 
    

    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        
        <property name="securityManager" ref="securityManager"/>
        
        <property name="loginUrl" value="/login"/>
        
        <property name="successUrl" value="/index"/>
        
        <property name="unauthorizedUrl" value="/unauth"/>
        <property name="filterChainDefinitions">
            <value>
                
                /login = anon
                /captcha = anon
                /resources/** = anon
                /** = user
            value>
        property>
        <property name="filters">
            <map>
                <entry key="user" value-ref="ajaxSessionFilter"/>
            map>
        property>
    bean>

    
    <bean id="ajaxSessionFilter" class="com.beovo.dsd.common.shiro.filter.ShiroAjaxSessionFilter"/>
 
   
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro.filter;

import cn.hutool.core.util.StrUtil;
import org.apache.shiro.web.filter.authc.UserFilter;
import org.apache.shiro.web.util.WebUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * ajax shiro session超时统一处理
 * @author Jimc.
 * @since 2018/11/23.
 */
public class ShiroAjaxSessionFilter extends UserFilter {

    @Override
    protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        HttpServletRequest req = WebUtils.toHttp(request);
        String xmlHttpRequest = req.getHeader("X-Requested-With");
        if (StrUtil.isNotBlank(xmlHttpRequest)) {
            if (xmlHttpRequest.equalsIgnoreCase("XMLHttpRequest")) {
                HttpServletResponse res = WebUtils.toHttp(response);
                // 采用res.sendError(401);在Easyui中会处理掉error，$.ajaxSetup中监听不到
                res.setHeader("oauthstatus", "401");
                return false;
            }
        }
        return super.onAccessDenied(request, response);
    }
}
 
    
 
    View Code 
   
 
   
8. 将自定义Realm、缓存管理器、会话管理器以及Remember管理器交给shiro的安全管理器
 
   
 
    

    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        
        <property name="realm" ref="shiroDbRealm"/>
        
        <property name="cacheManager" ref="shiroSpringCacheManager"/>
        
        <property name="rememberMeManager" ref="rememberMeManager"/>
        
        <property name="sessionManager" ref="sessionManager"/>
    bean>
 
   
 
   
9. 提供一个shiro的工具类
 
   
 
     
     
    
 
     
package com.beovo.dsd.common.shiro;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.RandomUtil;
import cn.hutool.core.util.StrUtil;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.ByteSource;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;

import java.util.Collection;

/**
 * shiro工具类
 *
 * @author Jimc.
 * @since 2018/11/23.
 */
public class ShiroKit {

    private static final String NAMES_DELIMITER = ",";

    /**
     * 密码盐长度
     */
    private static final int SALT_LENGTH = 16;

    /**
     * shiro密码加密
     *
     * @param algorithmName  算法
     * @param source         源对象(密码)
     * @param salt           密码盐
     * @param hashIterations hash次数
     * @return 加密后的字符
     */
    public static String encrypt(String algorithmName, Object source, Object salt, int hashIterations) {
        ByteSource saltSource = new Md5Hash(salt);
        return new SimpleHash(algorithmName, source, saltSource, hashIterations).toString();
    }

    /**
     * 获取随机16位盐值
     */
    public static String getRandomSalt() {
        return RandomUtil.randomString(SALT_LENGTH);
    }

    /**
     * 获取当前 Subject
     *
     * @return Subject
     */
    public static Subject getSubject() {
        return SecurityUtils.getSubject();
    }

    /**
     * 获取封装的 ShiroUser
     *
     * @return ShiroUser
     */
    public static ShiroUser getUser() {
        if (isGuest()) {
            return null;
        } else {
            return Convert.convert(ShiroUser.class, getSubject().getPrincipals().getPrimaryPrincipal());
        }
    }

    /**
     * 从shiro获取session
     */
    public static Session getSession() {
        return getSubject().getSession();
    }

    /**
     * 获取shiro指定的sessionKey
     */
    @SuppressWarnings("unchecked")
    public static  T getSessionAttr(String key) {
        Session session = getSession();
        return ObjectUtil.isNotNull(session) ? (T) session.getAttribute(key) : null;
    }

    /**
     * 设置shiro指定的sessionKey
     */
    public static void setSessionAttr(String key, Object value) {
        Session session = getSession();
        session.setAttribute(key, value);
    }

    /**
     * 移除shiro指定的sessionKey
     */
    public static void removeSessionAttr(String key) {
        Session session = getSession();
        if (ObjectUtil.isNotNull(session)) {
            session.removeAttribute(key);
        }
    }

    /**
     * 验证当前用户是否属于该角色？,使用时与lacksRole 搭配使用
     *
     * @param roleName 角色名
     * @return 属于该角色：true，否则false
     */
    public static boolean hasRole(String roleName) {
        return ObjectUtil.isNotNull(getSubject()) && StrUtil.isNotEmpty(roleName)
                && getSubject().hasRole(roleName);
    }

    /**
     * 与hasRole标签逻辑相反，当用户不属于该角色时验证通过。
     *
     * @param roleName 角色名
     * @return 不属于该角色：true，否则false
     */
    public static boolean lacksRole(String roleName) {
        return !hasRole(roleName);
    }

    /**
     * 验证当前用户是否属于以下任意一个角色。
     *
     * @param roleNames 角色列表
     * @return 属于:true,否则false
     */
    public static boolean hasAnyRoles(String roleNames) {
        boolean hasAnyRole = false;
        Subject subject = getSubject();
        if (ObjectUtil.isNotNull(getSubject()) && StrUtil.isNotEmpty(roleNames)) {
            for (String role : roleNames.split(NAMES_DELIMITER)) {
                if (subject.hasRole(role.trim())) {
                    hasAnyRole = true;
                    break;
                }
            }
        }
        return hasAnyRole;
    }

    /**
     * 验证当前用户是否属于以下所有角色。
     *
     * @param roleNames 角色列表
     * @return 属于:true,否则false
     */
    public static boolean hasAllRoles(String roleNames) {
        boolean hasAllRole = true;
        Subject subject = getSubject();
        if (ObjectUtil.isNotNull(getSubject()) && StrUtil.isNotEmpty(roleNames)) {
            for (String role : roleNames.split(NAMES_DELIMITER)) {
                if (!subject.hasRole(role.trim())) {
                    hasAllRole = false;
                    break;
                }
            }
        }
        return hasAllRole;
    }

    /**
     * 验证当前用户是否拥有指定权限,使用时与lacksPermission 搭配使用
     *
     * @param permission 权限名
     * @return 拥有权限：true，否则false
     */
    public static boolean hasPermission(String permission) {
        return ObjectUtil.isNotNull(getSubject()) && StrUtil.isNotEmpty(permission)
                && getSubject().isPermitted(permission);
    }

    /**
     * 与hasPermission标签逻辑相反，当前用户没有制定权限时，验证通过。
     *
     * @param permission 权限名
     * @return 拥有权限：true，否则false
     */
    public static boolean lacksPermission(String permission) {
        return !hasPermission(permission);
    }

    /**
     * 已认证通过的用户。不包含已记住的用户，这是与user标签的区别所在。与notAuthenticated搭配使用
     *
     * @return 通过身份验证：true，否则false
     */
    public static boolean isAuthenticated() {
        return ObjectUtil.isNotNull(getSubject()) && getSubject().isAuthenticated();
    }

    /**
     * 未认证通过用户，与authenticated标签相对应。与guest标签的区别是，该标签包含已记住用户。。
     *
     * @return 没有通过身份验证：true，否则false
     */
    public static boolean notAuthenticated() {
        return !isAuthenticated();
    }

    /**
     * 认证通过或已记住的用户。与guset搭配使用。
     *
     * @return 用户：true，否则 false
     */
    public static boolean isUser() {
        return ObjectUtil.isNotNull(getSubject()) && ObjectUtil.isNotNull(getSubject().getPrincipal());
    }

    /**
     * 验证当前用户是否为“访客”，即未认证（包含未记住）的用户。用user搭配使用
     *
     * @return 访客：true，否则false
     */
    public static boolean isGuest() {
        return !isUser();
    }

    /**
     * 输出当前用户信息，通常为登录帐号信息。
     *
     * @return 当前用户信息
     */
    public static String principal() {
        Subject subject = getSubject();
        if (ObjectUtil.isNotNull(subject)) {
            Object principal = subject.getPrincipal();
            return principal.toString();
        }
        return "";
    }

    /**
     * 单用户登录时，判断用户是否已经登录
     */
    public static boolean isLogin(String username) {
        Collection sessions = ((DefaultWebSessionManager) (((DefaultWebSecurityManager) SecurityUtils
                .getSecurityManager()).getSessionManager())).getSessionDAO().getActiveSessions();
        if (CollUtil.isNotEmpty(sessions)) {
            for (Session session : sessions) {
                String _username = Convert.toStr(session.getAttribute("username"));
                if (StrUtil.isNotEmpty(_username) && StrUtil.equals(username, _username)) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 获取当前用户的部门数据范围的集合
     */
    /*public static List getDeptDataScope() {
        Long deptId = getUser().getDeptId();
//        List subDeptIds = ConstantFactory.me().getSubDeptId(deptId);
//        subDeptIds.add(deptId);
        return subDeptIds;
    }*/

    /**
     * 判断当前用户是否是超级管理员
     */
     /*public static boolean isAdmin() {
       Set roles = ShiroKit.getUser().getRoles();
        for (Long role : roles) {
            String singleRoleTip = ConstantFactory.me().getSingleRoleTip(role);
            if (singleRoleTip.equals(Const.ADMIN_NAME)) {
                return true;
            }
        }
        return false;
    }*/
}
 
    
 
    View Code 
   
 
   
 五、在web.xml添加shiro的过滤器
 
   
 
    
 
    <filter>
        <filter-name>shiroFilterfilter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxyfilter-class>
        <init-param>
            <param-name>targetFilterLifecycleparam-name>
            <param-value>trueparam-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>shiroFilterfilter-name>
        <url-pattern>/*url-pattern>
        <dispatcher>REQUESTdispatcher>
        <dispatcher>FORWARDdispatcher>
    filter-mapping>
 
   
 
   
 
 
   
源码下载
 
   
  
转载于:https://www.cnblogs.com/Jimc/p/10038635.html
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Spring 整合 Shiro)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 承担即成长
                        吉林付巍巍

                        
    《苏霍姆林斯基教育学》课程，几天前召开了义工培训会，我听了回放后主动联系郑老师要求加入义工团队。虽然这样每周要付出至少一天的时间进行打卡阅读和点评，但这样可以强迫规划好每日的作息时间，完成专业阅读方面的学习，这种重要的事情是必须要融入日常的生活中的，这一工作的申请也督促我合理安排自己的时间，把碎片化的时间整合好，无形中提高了每日利用时间的效率。上学期跟随着教师阅读地图课程组进行点评，发现了许多优秀
    
                    
    • 
                    
  • LeetCode github集合，附CMU大神整理笔记
                        Wesley@
LeetCodegithub
                        
    GithubLeetCode集合本人所有做过的题目都写在一个java项目中，同步到github中了，算是见证自己的进步。github目前同步的题目是2020-09-17日之后写的题。之前写过的题会陆续跟新到github中。目前大概400个题目Github项目链接：https://github.com/sunliancheng/leetcode_github附上一份优秀的教材整合：这是卡内基梅隆(C
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • 郭生白中药方论之二(破除温凉寒热的框框)
                        本能学堂a昨年

                        
    离病说药茫茫然，对症下药不着边。顺势利导一乘法，排异调节渡法船。无限整合非模糊，模糊病区得清楚。共性之外求个性，亲和不生抗药性。温凉寒热巧方便，君臣佐使筏喻焉。药包大小折中看，毒性有无一念间。导读破除温凉寒热的框框寒热温凉是基于中药共性的传统分类药无寒热人有寒热药无寒热病有寒热抛弃温凉不并用的错误观念寒热温凉是基于中药共性的传统分类寒热温凉是个共性，是说的共性。这个共性，知道什么叫共性吗？所有的药
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 自由职业者做什么赚钱？省钱快报能月入三千吗？
                        高省APP珊珊

                        
    说起省钱快报，很多人都觉得很耳熟，省钱快报是一个社交电商平台，省钱快报是一个给大家提供优惠券一级购物返佣的优惠平台,整合了京东淘宝拼多多等等各大电商平台的优惠券和佣金，用户领券购买更优惠！所有的售后服务也都还和你之前的平台买东西一样，副业赚钱，可以用省钱快报来增加收入。至于我为何转到高省APP呢？当然是高省佣金更高，模式更好。高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • 爬虫技术抓取网站数据
                        Bearjumpingcandy
爬虫
                        
    爬虫技术是指通过程序自动访问网页并提取数据的技术。一般来说，爬虫技术包含以下几个步骤：确定目标网站：确定需要抓取的网站，并了解其页面结构和数据特点。分析页面结构：分析网页的结构和源代码，找到需要抓取的数据在页面中的位置和标识。编写爬虫程序：使用编程语言（如Python）编写爬虫程序，实现对目标网站的自动访问和数据提取。处理抓取数据：对抓取到的数据进行清洗、去重、整合等处理，以便后续的分析和利用。爬
    
                    
    • 
                    
  • 2018-05-24
                        石竹花开

                        
    一明演说故事板块第1讲：一种软实力叫讲故事分享：1.好的销售不是卖产品，而是卖故事；2.让别人接受自己的观点是讲故事的目的；3.真诚，真情实感的故事才能凝聚人，实现整合。图片发自App
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • 从单体到微服务：FastAPI ‘挂载’子应用程序的转变
                        黑金IT
fastapi微服务fastapi架构
                        
    在现代Web应用开发中，模块化架构是一种常见的设计模式，它有助于将大型应用程序分解为更小、更易于管理的部分。FastAPI，作为一个高性能的PythonWeb框架，提供了强大的支持来实现这种模块化设计。通过“挂载”子应用程序，我们可以为不同的功能区域（如前端接口、管理员接口和用户中心）创建独立的应用程序，并将它们整合到一个主应用程序中。本文将详细介绍如何在FastAPI中使用“挂载”子应用程序的方
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • 整合孩子大脑，培养幸福能力
                        维娅丫

                        
    图片发自App幸福是一种能力，一种解决问题的能力。为人父母，我们要具备足够的能力去培养一个健康、快乐的孩子。在日常生活中，每一个人都会遇到各种各样的问题、困惑、烦恼、挫折，怎样才能化悲伤为开心，化愤怒为力量，坚定的向我们的幸福出发呢？下面，我就谈一下如何帮助孩子整合大脑，培养孩子获得幸福的能力。是什么塑造了我们的大脑呢？———体验。甚至到了老年，体验也仍然在改变着大脑的生理结构。每经历一次体验，一
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                                
  • HQL之投影查询
                                    归来朝歌
HQLHibernate查询语句投影查询
                                    
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 
针对上面的场景，如果需要将一个对象查出来： 
HQL语句写“from 对象”即可 
Session session = HibernateUtil.openSession();
		
    
                                
    • 
                                
  • Spring整合redis
                                    bylijinnan
redis
                                    
    pom.xml 
 

<dependencies>
		<!-- Spring Data - Redis Library -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redi
    
                                
    • 
                                
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2
                                    0624chenhong
Hibernate
                                    
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 
        在项目中出现了org.hiber
    
                                
    • 
                                
  • android动画效果
                                    不懂事的小屁孩
android动画
                                    
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 
 
Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 
第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。 
 

    
                                
    • 
                                
  • js delete 删除机理以及它的内存泄露问题的解决方案
                                    换个号韩国红果果
JavaScript
                                    
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 
举例： 

var person={name:{firstname:'bob'}}
var p=person.name
delete person.name
p.firstname  -->'bob'
// 依然可以访问p.firstname，存在内存泄露
    
                                
    • 
                                
  • Oracle将零干预分析加入网络即服务计划
                                    蓝儿唯美
oracle
                                    
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
    
                                
    • 
                                
  • spring学习——springmvc（二）
                                    a-john
springMVC
                                    
    Spring MVC提供了非常方便的文件上传功能。 
1，配置Spring支持文件上传： 
DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
    
                                
    • 
                                
  • POJ-2828-Buy Tickets
                                    aijuans
ACM_POJ
                                    
    POJ-2828-Buy Tickets 
http://poj.org/problem?id=2828 
线段树，逆序插入 
 
#include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
    
                                
    • 
                                
  • Java Ant build.xml详解
                                    asia007
build.xml
                                    
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
    
                                
    • 
                                
  • android按钮监听器的四种技术
                                    百合不是茶
androidxml配置监听器实现接口
                                    
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;  
  
1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似 
  
创建监听器的实例 
myLis lis = new myLis(); 
  
使用add方法给按钮添加监听器 
 
    
                                
    • 
                                
  • 软件架构师不等同于资深程序员
                                    bijian1013
程序员架构师架构设计
                                    
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。 
        如今很多的公司
    
                                
    • 
                                
  • TeamForge Wiki Syntax & CollabNet User Information Center
                                    sunjing
TeamForgeHow doAttachementAnchorWiki Syntax
                                    
    the CollabNet user information center http://help.collab.net/ 
  
How do I create a new Wiki page? 
A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
    
                                
    • 
                                
  • 【Redis四】Redis数据类型
                                    bit1129
redis
                                    
    概述 
Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 
Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
    
                                
    • 
                                
  • SSH2整合-附源码
                                    白糖_
eclipsespringtomcatHibernateGoogle
                                    
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 
我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。 
  
  
补充1：项目中部分jar包不是最新版的，可能导
    
                                
    • 
                                
  • [转]开源项目代码的学习方法
                                    braveCS
学习方法
                                    
    转自： 
http://blog.sina.com.cn/s/blog_693458530100lk5m.html 
http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 
  
1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
    
                                
    • 
                                
  • 编程之美-子数组的最大和（二维）
                                    bylijinnan
编程之美
                                    
    package beautyOfCoding;

import java.util.Arrays;
import java.util.Random;

public class MaxSubArraySum2 {

	/**
	 * 编程之美 子数组之和的最大值（二维）
	 */
	private static final int ROW = 5;
	private stat
    
                                
    • 
                                
  • 读书笔记-3
                                    chengxuyuancsdn
jquery笔记resultMap配置ibatis一对多配置
                                    
    1、resultMap配置 
2、ibatis一对多配置 
3、jquery笔记 
 
1、resultMap配置
当<select resultMap="topic_data">
<resultMap id="topic_data">必须一一对应。
(1)<resultMap class="tblTopic&q
    
                                
    • 
                                
  • [物理与天文]物理学新进展
                                    comsci

                                    
     
 
      如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境 
 
      怎么办呢? 
 
 
    
                                
    • 
                                
  • Oracle 11g新特性:Automatic Diagnostic Repository
                                    daizj
oracleADR
                                    
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 
FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 
 
在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 
这两份log文
    
                                
    • 
                                
  • 简单排序:选择排序
                                    dieslrae
选择排序
                                    
    
    public void selectSort(int[] array){
        int select;
        
        for(int i=0;i<array.length;i++){
            select = i;
            
            for(int k=i+1;k<array.leng
    
                                
    • 
                                
  • C语言学习六指针的经典程序，互换两个数字
                                    dcj3sjt126com
c
                                    
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 
# include <stdio.h>

void swap_1(int, int);
void swap_2(int *, int *);
void swap_3(int *, int *);

int main(void)
{
	int a = 3;
	int b = 
    
                                
    • 
                                
  • php 5.4中php-fpm 的重启、终止操作命令
                                    dcj3sjt126com
PHP
                                    
    php 5.4中php-fpm 的重启、终止操作命令: 
查看php运行目录命令：which php/usr/bin/php 
查看php-fpm进程数：ps aux | grep -c php-fpm 
查看运行内存/usr/bin/php  -i|grep mem 
重启php-fpm/etc/init.d/php-fpm restart 
在phpinfo()输出内容可以看到php
    
                                
    • 
                                
  • 线程同步工具类
                                    shuizhaosi888
同步工具类
                                    
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch） 
  
闭锁（CountDownLatch） 
public class RunMain {
	public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
		fin
    
                                
    • 
                                
  • bleeding edge是什么意思
                                    haojinghua
DI
                                    
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  
我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 
  
In computer science, bleeding edge is a term that 
    
                                
    • 
                                
  • c中实现utf8和gbk的互转
                                    jimmee
ciconvutf8&gbk编码
                                    
    #include <iconv.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>

int code_c
    
                                
    • 
                                
  • 大型分布式网站架构设计与实践
                                    lilin530
应用服务器搜索引擎
                                    
    1.大型网站软件系统的特点？ 
a.高并发，大流量。 
b.高可用。 
c.海量数据。 
d.用户分布广泛，网络情况复杂。 
e.安全环境恶劣。 
f.需求快速变更，发布频繁。 
g.渐进式发展。 
 
2.大型网站架构演化发展历程？ 
a.初始阶段的网站架构。 
应用程序，数据库，文件等所有的资源都在一台服务器上。 
b.应用服务器和数据服务器分离。 
c.使用缓存改善网站性能。 
d.使用应用
    
                                
    • 
                                
  • 在代码中获取Android theme中的attr属性值
                                    OliveExcel
androidtheme
                                    
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 
  
在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: 
int defaultColor = 0xFF000000;
int[] attrsArray = { andorid.r.
    
                                
    • 
                                
  • 基于Zookeeper的分布式共享锁
                                    roadrunners
zookeeper分布式共享锁
                                    
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。 
  
共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。 
  
官
    
                                
    • 
                                
  • 两个容易被忽略的MySQL知识
                                    tomcat_oracle
mysql
                                    
    1、varchar(5)可以存储多少个汉字，多少个字母数字？   　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。   　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
    
                                
    • 
                                
  • zoj 3827 Information Entropy(水题)
                                    阿尔萨斯
format
                                    
     题目链接：zoj 3827 Information Entropy 
 题目大意：三种底，计算和。 
 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 
#include <cstdio>
#include <cstring>
#include <cmath&
    
                                
    •