package org.calonlan.security.component;

import java.io.Serializable;

import java.util.Collection;

import java.util.HashSet;

import java.util.Set;

import org.apache.shiro.session.Session;

public class JedisShiroSessionRepository implements ShiroSessionRepository {

    /**

     *

     * redis session key 前缀

     *

     * */

    private final String REDIS_SHIRO_SESSION = "shiro-session";

    private RedisManager redisManager;

    @Override

    public void saveSession(Session session) {

        redisManager.init();

        if (session == null || session.getId() == null) {

            System.out.println("session 或者 session ID 为空");

        }

        byte[] key = getRedisSessionKey(session.getId()).getBytes();

        byte[] value = SerializeUtils.serialize(session);

        Long timeOut = session.getTimeout() / 1000;

        redisManager.set(key, value, Integer.parseInt(timeOut.toString()));

    }

    @Override

    public void deleteSession(Serializable sessionId) {

        redisManager.init();

        if (sessionId == null) {

            System.out.println("id为空");

        }

        redisManager.del(getRedisSessionKey(sessionId).getBytes());

    }

    @Override

    public Session getSession(Serializable sessionId) {

        redisManager.init();

        if (null == sessionId) {

            System.out.println("id为空");

            return null;

        }

        Session session = null;

        byte[] value = redisManager.get(getRedisSessionKey(sessionId)

                .getBytes());

        if (null == value)

            return null;

        session = (Session) SerializeUtils.deserialize(value);

        return session;

    }

    @Override

    public Collection<Session> getAllSessions() {

        redisManager.init();

        Set<Session> sessions = new HashSet<Session>();

        Set<byte[]> byteKeys = redisManager

                .keys(this.REDIS_SHIRO_SESSION + "*");

        if (byteKeys != null && byteKeys.size() > 0) {

            for (byte[] bs : byteKeys) {

                Session s = (Session) SerializeUtils.deserialize(redisManager

                        .get(bs));

                sessions.add(s);

            }

        }

        return sessions;

    }

    /**

     * 获取redis中的session key

     *

     * @param sessionId

     * @return

     */

    private String getRedisSessionKey(Serializable sessionId) {

        return this.REDIS_SHIRO_SESSION + sessionId;

    }

    public RedisManager getRedisManager() {

        return redisManager;

    }

    public void setRedisManager(RedisManager redisManager) {

        this.redisManager = redisManager;

    }

    public JedisShiroSessionRepository() {

    }

    // public static void main(String[] args) {

    // Jedis jj = new Jedis("localhost");

    // //jj.set("key2", "232323231=========");

    // String ss = jj.get("key1");

    // System.out.println(jj.get("key2"));

    // System.out.println(ss);

    // }

}

package org.calonlan.security.component;

import java.util.Collection;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Set;

import org.apache.shiro.cache.Cache;

import org.apache.shiro.cache.CacheException;

public class JedisShiroCache<K, V> implements Cache<K, V> {

    private final String REDIS_SHIRO_CACHE = "shiro-cache";

    private RedisManager redisManager;

    private String name;

    public JedisShiroCache(RedisManager redisManager, String name) {

        this.redisManager = redisManager;

        this.name = name;

    }

    public String getName() {

        if (null == null) {

            return "";

        }

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    @Override

    public void clear() throws CacheException {

        redisManager.init();

        String keysPattern = this.REDIS_SHIRO_CACHE + "*";

        redisManager.flushDB();

    }

    @Override

    public V get(K key) throws CacheException {

        redisManager.init();

        byte[] byteKey = getCacheKey(key).getBytes();

        byte[] byteValue = redisManager.get(byteKey);

        if (null == byteValue)

            return null;

        return (V) SerializeUtils.deserialize(byteValue);

    }

    @Override

    public Set<K> keys() {

        redisManager.init();

        Set<byte[]> byteSet = redisManager.keys(this.REDIS_SHIRO_CACHE + "*");

        Set<K> keys = new HashSet<K>();

        for (byte[] bs : byteSet) {

            keys.add((K) SerializeUtils.deserialize(bs));

        }

        return keys;

    }

    @Override

    public V put(K key, V value) throws CacheException {

        redisManager.init();

        V previos = get(key);

        redisManager.set(getCacheKey(key).getBytes(),

                SerializeUtils.serialize(value));

        return previos;

    }

    @Override

    public V remove(K key) throws CacheException {

        redisManager.init();

        V previos = get(key);

        redisManager.del(getCacheKey(key).getBytes());

        return previos;

    }

    @Override

    public int size() {

        redisManager.init();

        if (keys() == null)

            return 0;

        return keys().size();

    }

    @Override

    public Collection<V> values() {

        Set<byte[]> byteSet = redisManager.keys(this.REDIS_SHIRO_CACHE + "*");

        List<V> result = new LinkedList<V>();

        for (byte[] bs : byteSet) {

            result.add((V) SerializeUtils.deserialize(redisManager.get(bs)));

        }

        return result;

    }

    private String getCacheKey(Object key) {

        return this.REDIS_SHIRO_CACHE + getName() + ":" + key;

    }

}

package org.calonlan.security.component;

import java.util.Iterator;

import java.util.Set;

import org.springframework.beans.factory.annotation.Value;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.JedisPool;

import redis.clients.jedis.JedisPoolConfig;

/**

 * @author Administrator

 *         redismanager主要用来给用户提供一个设计完备的，通过jedis的jar包来管理redis内存数据库的各种方法

 */

public class RedisManager {

    // ip和port属性都定义在了properties文件中，这里通过spring的注解方式来直接使用

    @Value("${redis.ip}")

    private String host;

    @Value("${redis.port}")

    private int port;

    // 设置为0的话就是永远都不会过期

    private int expire = 0;

    // 定义一个管理池，所有的redisManager共同使用。

    private static JedisPool jedisPool = null;

    public RedisManager() {

    }

    /**

     *

     * 初始化方法,在这个方法中通过host和port来初始化jedispool。

     *

     * */

    public void init() {

        if (null == host || 0 == port) {

            System.out.println("请初始化redis配置文件");

            throw new NullPointerException("找不到redis配置");

        }

        if (jedisPool == null) {

            jedisPool = new JedisPool(new JedisPoolConfig(), host, port);

        }

    }

    /**

     * get value from redis

     *

     * @param key

     * @return

     */

    public byte[] get(byte[] key) {

        byte[] value = null;

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            value = jedis.get(key);

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * get value from redis

     *

     * @param key

     * @return

     */

    public String get(String key) {

        String value = null;

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            value = jedis.get(key);

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * set

     *

     * @param key

     * @param value

     * @return

     */

    public byte[] set(byte[] key, byte[] value) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.set(key, value);

            if (this.expire != 0) {

                jedis.expire(key, this.expire);

            }

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * set

     *

     * @param key

     * @param value

     * @return

     */

    public String set(String key, String value) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.set(key, value);

            if (this.expire != 0) {

                jedis.expire(key, this.expire);

            }

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * set

     *

     * @param key

     * @param value

     * @param expire

     * @return

     */

    public byte[] set(byte[] key, byte[] value, int expire) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.set(key, value);

            if (expire != 0) {

                jedis.expire(key, expire);

            }

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * set

     *

     * @param key

     * @param value

     * @param expire

     * @return

     */

    public String set(String key, String value, int expire) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.set(key, value);

            if (expire != 0) {

                jedis.expire(key, expire);

            }

        } finally {

            jedisPool.returnResource(jedis);

        }

        return value;

    }

    /**

     * del

     *

     * @param key

     */

    public void del(byte[] key) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.del(key);

        } finally {

            jedisPool.returnResource(jedis);

        }

    }

    /**

     * del

     *

     * @param key

     */

    public void del(String key) {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.del(key);

        } finally {

            jedisPool.returnResource(jedis);

        }

    }

    /**

     * flush

     */

    public void flushDB() {

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            jedis.flushDB();

        } finally {

            jedisPool.returnResource(jedis);

        }

    }

    /**

     * size

     */

    public Long dbSize() {

        Long dbSize = 0L;

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            dbSize = jedis.dbSize();

        } finally {

            jedisPool.returnResource(jedis);

        }

        return dbSize;

    }

    /**

     * keys

     *

     * @param regex

     * @return

     */

    public Set<byte[]> keys(String pattern) {

        Set<byte[]> keys = null;

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            System.out.println("我调用了keys方法=---shiro");

            keys = jedis.keys(pattern.getBytes());

            if (null != keys)

                System.out.println(keys.size());

        } finally {

            jedisPool.returnResource(jedis);

        }

        return keys;

    }

    public void dels(String pattern) {

        Set<byte[]> keys = null;

        Jedis jedis = jedisPool.getResource();

        jedis.auth("你的密码");

        try {

            System.out.println("我调用了dels方法=---shiro");

            keys = jedis.keys(pattern.getBytes());

            Iterator<byte[]> ito = keys.iterator();

            while (ito.hasNext()) {

                jedis.del(ito.next());

            }

        } finally {

            jedisPool.returnResource(jedis);

        }

    }

    public String getHost() {

        return host;

    }

    public void setHost(String host) {

        this.host = host;

    }

    public int getPort() {

        return port;

    }

    public void setPort(int port) {

        this.port = port;

    }

    public int getExpire() {

        return expire;

    }

    public void setExpire(int expire) {

        this.expire = expire;

    }

}

/**

 * Copyright (c) 2005-2012 https://github.com/zhangkaitao

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 */

package org.calonlan.security.spring;

import net.sf.ehcache.Ehcache;

import org.apache.shiro.cache.Cache;

import org.apache.shiro.cache.CacheException;

import org.apache.shiro.cache.CacheManager;

import org.apache.shiro.util.CollectionUtils;

import org.springframework.cache.support.SimpleValueWrapper;

import java.util.*;

/**

 * 包装Spring cache抽象

 * <p>User: Zhang Kaitao

 * <p>Date: 13-3-23 上午8:26

 * <p>Version: 1.0

 */

public class SpringCacheManagerWrapper implements CacheManager {

    private org.springframework.cache.CacheManager cacheManager;

    /**

     * 设置spring cache manager

     *

     * @param cacheManager

     */

    public void setCacheManager(org.springframework.cache.CacheManager cacheManager) {

        this.cacheManager = cacheManager;

    }

    @Override

    public <K, V> Cache<K, V> getCache(String name) throws CacheException {

        org.springframework.cache.Cache springCache = cacheManager.getCache(name);

        return new SpringCacheWrapper(springCache);

    }

    static class SpringCacheWrapper implements Cache {

        private org.springframework.cache.Cache springCache;

        SpringCacheWrapper(org.springframework.cache.Cache springCache) {

            this.springCache = springCache;

        }

        @Override

        public Object get(Object key) throws CacheException {

            Object value = springCache.get(key);

            if (value instanceof SimpleValueWrapper) {

                return ((SimpleValueWrapper) value).get();

            }

            return value;

        }

        @Override

        public Object put(Object key, Object value) throws CacheException {

            springCache.put(key, value);

            return value;

        }

        @Override

        public Object remove(Object key) throws CacheException {

            springCache.evict(key);

            return null;

        }

        @Override

        public void clear() throws CacheException {

            springCache.clear();

        }

        @Override

        public int size() {

            if(springCache.getNativeCache() instanceof Ehcache) {

                Ehcache ehcache = (Ehcache) springCache.getNativeCache();

                return ehcache.getSize();

            }

            throw new UnsupportedOperationException("invoke spring cache abstract size method not supported");

        }

        @Override

        public Set keys() {

            if(springCache.getNativeCache() instanceof Ehcache) {

                Ehcache ehcache = (Ehcache) springCache.getNativeCache();

                return new HashSet(ehcache.getKeys());

            }

            throw new UnsupportedOperationException("invoke spring cache abstract keys method not supported");

        }

        @Override

        public Collection values() {

            if(springCache.getNativeCache() instanceof Ehcache) {

                Ehcache ehcache = (Ehcache) springCache.getNativeCache();

                List keys = ehcache.getKeys();

                if (!CollectionUtils.isEmpty(keys)) {

                    List values = new ArrayList(keys.size());

                    for (Object key : keys) {

                        Object value = get(key);

                        if (value != null) {

                            values.add(value);

                        }

                    }

                    return Collections.unmodifiableList(values);

                } else {

                    return Collections.emptyList();

                }

            }

            throw new UnsupportedOperationException("invoke spring cache abstract values method not supported");

        }

    }

}

RetryLimitHashedCredentialsMatcher：

package org.calonlan.security.credentials;

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 java.util.concurrent.atomic.AtomicInteger;

/**

 * <p>User: Zhang Kaitao

 * <p>Date: 14-1-28

 * <p>Version: 1.0

 */

public class RetryLimitHashedCredentialsMatcher extends HashedCredentialsMatcher {

    private Cache<String, AtomicInteger> passwordRetryCache;

    public RetryLimitHashedCredentialsMatcher(CacheManager cacheManager) {

        passwordRetryCache = cacheManager.getCache("passwordRetryCache");

    }

    @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

            throw new ExcessiveAttemptsException();

        }

        boolean matches = super.doCredentialsMatch(token, info);

        if(matches) {

            //clear retry count

            passwordRetryCache.remove(username);

        }

        return matches;

    }

}

UserRealm：

package org.calonlan.security.realm;

import org.apache.log4j.Logger;

import org.apache.shiro.authc.AuthenticationException;

import org.apache.shiro.authc.AuthenticationInfo;

import org.apache.shiro.authc.AuthenticationToken;

import org.apache.shiro.authc.LockedAccountException;

import org.apache.shiro.authc.SimpleAuthenticationInfo;

import org.apache.shiro.authz.AuthorizationInfo;

import org.apache.shiro.authz.SimpleAuthorizationInfo;

import org.apache.shiro.cache.Cache;

import org.apache.shiro.realm.AuthorizingRealm;

import org.apache.shiro.subject.PrincipalCollection;

import org.apache.shiro.util.ByteSource;

import org.calonlan.security.entity.User;

import org.calonlan.security.service.ResourceService;

import org.calonlan.security.service.UserRoleService;

import org.calonlan.security.service.UserService;

/**

 * @ClassName: UserRealm

 * @Description: TODO(这里用一句话描述这个类的作用)

 * @author mbc

 * @date 2014-6-7 上午11:49:06

 *

 */

public class UserRealm extends AuthorizingRealm {

    private static final Logger logger = Logger.getLogger(UserRealm.class);

    @javax.annotation.Resource

    private UserRoleService userRoleService;

    @javax.annotation.Resource

    private ResourceService resourceService;

    @javax.annotation.Resource

    private UserService userService;

    /*

     * (非 Javadoc) <p>Title: doGetAuthorizationInfo</p> <p>Description:权限授权 </p>

     *

     * @param principals

     *

     * @return

     *

     * @see

     * org.apache.shiro.realm.AuthorizingRealm#doGetAuthorizationInfo(org.apache

     * .shiro.subject.PrincipalCollection)

     */

    @Override

    protected AuthorizationInfo doGetAuthorizationInfo(

            PrincipalCollection principals) {

        // 为空的情况直接返回null

        if (null == principals) {

            return null;

        }

        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();

        String username = (String) principals.getPrimaryPrincipal();

        Cache<Object, AuthenticationInfo> cache = getAuthenticationCache();

        System.out.println(cache == null);

        logger.info("[用户:" + username + "|权限授权]");

        authorizationInfo.setRoles(userRoleService

                .loadRoleIdsByUsername(username));

        authorizationInfo.setStringPermissions(resourceService

                .loadPermissionsByUsername(username));

        logger.info("[用户:" + username + "|权限授权完成]");

        return authorizationInfo;

    }

    /*

     * (非 Javadoc) <p>Title: doGetAuthenticationInfo</p> <p>Description:权限认证

     * </p>

     *

     * @param token

     *

     * @return

     *

     * @throws AuthenticationException

     *

     * @see

     * org.apache.shiro.realm.AuthenticatingRealm#doGetAuthenticationInfo(org

     * .apache.shiro.authc.AuthenticationToken)

     */

    @Override

    protected AuthenticationInfo doGetAuthenticationInfo(

            AuthenticationToken token) throws AuthenticationException {

        SimpleAuthenticationInfo authenticationInfo;

        String username = (String) token.getPrincipal();

        logger.info("[用户:" + username + "|系统权限认证]");

        User user = userService.loadByUsername(username);

        if (user != null) {

            if ("帐号锁定".equals(user.getState())) {

                throw new LockedAccountException();// 帐号锁定

            }

            // 交给AuthenticatingRealm使用CredentialsMatcher进行密码匹配，如果觉得人家的不好可以自定义实现

            authenticationInfo = new SimpleAuthenticationInfo(

                    user.getUsername(), user.getPassword(),

                    ByteSource.Util.bytes(user.getCredentialsSalt()), getName());// realm

            logger.info("[用户:" + username + "|系统权限认证完成]");

            return authenticationInfo; // name

        } else

            return null;

    }

}