springboot和mybatis整合在這我就不說了有興趣的自己去找一下，網上有很多

下面介紹一下和shiro整合的一些配置以及怎麼防止使用者重複登入，什麼叫防止重複登入？

嗯........ 好吧，我解釋一下就是，一個賬號在同一時間只能在一處登入，比如張三在北京登入了，還沒有下線呢，李四也用同一賬號在上海登入了，那就會把北京的張三擠下來，張三如果不服，也可以把李四擠下來。就像qq在電腦端一樣，後面的會把前面的擠下線。

好，明白了。

下面進行技術講解，哈哈哈哈

stringboot提倡習慣大於約定，所以基本沒有xml檔案配置，那些通過xml配置產生的交給Spring管理的bean都變成了這樣

@Bean
 
(name="sessionDAO")
public MemorySessionDAO getMemorySessionDAO()
{
      return new MemorySessionDAO();
}

@Bean註解寫在函式上面即表示該函式產生的bean交給了Spring管理，預設為函式的名字為bean的id

可以用@Qualifier("bean的id")來寫在引數前

或者用@Resource("")寫在變數上面

跑偏了，跑偏了

下面直接上shiro和Spring整合的配置檔案吧

import org.apache.shiro.cache.MemoryConstrainedCacheManager;
 
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.eis.MemorySessionDAO;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
 
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
@Configuration
public class ShiorConfig {


    @Bean(name="sessionDAO")
    public MemorySessionDAO getMemorySessionDAO()
    {
          return new MemorySessionDAO();
}

    @Bean(name = "sessionIdCookie")
    public SimpleCookie getSimpleCookie()
    {
        SimpleCookie simpleCookie = new SimpleCookie();
simpleCookie.setName("SHRIOSESSIONID");
        return simpleCookie;
}

    //配置shiro session 的一個管理器
@Bean(name = "sessionManager")
    public DefaultWebSessionManager getDefaultWebSessionManager(@Qualifier("sessionDAO") MemorySessionDAO sessionDAO,
@Qualifier("sessionIdCookie") SimpleCookie simpleCookie)
    {
        DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
sessionManager.setSessionDAO(sessionDAO);
sessionManager.setSessionIdCookie(simpleCookie);
        return sessionManager;
}

    //配置session的快取管理器
@Bean(name= "shiroCacheManager")
    public MemoryConstrainedCacheManager getMemoryConstrainedCacheManager()
    {
        return new MemoryConstrainedCacheManager();
}

    @Bean(name="shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") SecurityManager manager) {

        //安全事務管理器工廠類
ShiroFilterFactoryBean bean=new ShiroFilterFactoryBean();
bean.setSecurityManager(manager);
//配置未登入時攔截到的路徑
bean.setLoginUrl("/user/notlogin");
//配置訪問許可權
LinkedHashMap<String, String> filterChainDefinitionMap=new LinkedHashMap<>();
filterChainDefinitionMap.put("/user/validateCode","anon");//匿名訪問驗證碼
filterChainDefinitionMap.put("/user/insert", "anon");//匿名註冊
filterChainDefinitionMap.put("/user/login", "anon"); //匿名登入
filterChainDefinitionMap.put("/AidocPlatform/index.html", "anon"); //匿名訪問
filterChainDefinitionMap.put("/u/**", "anon"); //匿名登入
filterChainDefinitionMap.put("/*", "authc");//表示需要認證才可以訪問
filterChainDefinitionMap.put("/**", "authc");//表示需要認證才可以訪問
filterChainDefinitionMap.put("/*.*", "authc");
bean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return bean;
}
    //配置核心安全事務管理器
@Bean(name="securityManager")
    public SecurityManager securityManager(@Qualifier("authRealm") AuthRealm authRealm,
@Qualifier("shiroCacheManager") MemoryConstrainedCacheManager shiroCacheManager,
@Qualifier("sessionManager") DefaultWebSessionManager sessionManager) {
        System.err.println("--------------shiro已經載入----------------");
DefaultWebSecurityManager manager=new DefaultWebSecurityManager();
manager.setRealm(authRealm);
manager.setCacheManager(shiroCacheManager);
manager.setSessionManager(sessionManager);
        return manager;
}
    //配置自定義的許可權登入器
@Bean(name="authRealm")
    public AuthRealm authRealm(@Qualifier("credentialsMatcher") CredentialsMatcher matcher) {
        AuthRealm authRealm=new AuthRealm();
authRealm.setCredentialsMatcher(matcher);
        return authRealm;
}
    //配置自定義的密碼比較器
@Bean(name="credentialsMatcher")
    public CredentialsMatcher credentialsMatcher() {
        return new CredentialsMatcher();
}
    @Bean
public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
}
    @Bean
public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator creator=new DefaultAdvisorAutoProxyCreator();
creator.setProxyTargetClass(true);
        return creator;
}
    @Bean
public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager") SecurityManager manager) {
        AuthorizationAttributeSourceAdvisor advisor=new AuthorizationAttributeSourceAdvisor();
advisor.setSecurityManager(manager);
        return advisor;
}

自定義密碼比較器

import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.authc.credential.SimpleCredentialsMatcher;
public class CredentialsMatcher extends SimpleCredentialsMatcher {

    @Override
public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {
        UsernamePasswordToken utoken=(UsernamePasswordToken) token;
//獲得使用者輸入的密碼:(可以採用加鹽(salt)的方式去檢驗)
String inPassword = new String(utoken.getPassword());
//獲得資料庫中的密碼
String dbPassword=(String) info.getCredentials();
//進行密碼的比對
return this.equals(inPassword, dbPassword);
}

}

自定義Realm檔案

import ai.medp.aidoc.dto.user.RoleDto;
import ai.medp.aidoc.dto.user.UserDto;
import ai.medp.aidoc.service.UserService;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.session.mgt.eis.SessionDAO;
import org.apache.shiro.subject.PrincipalCollection;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class AuthRealm extends AuthorizingRealm {

    @Autowired
private UserService userService;
@Autowired
private SessionDAO sessionDAO;
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principal) {

        UserDto user = (UserDto) principal.fromRealm(this.getClass().getName()).iterator().next();//獲取session中的使用者
List<String> permissions = new ArrayList<>();
Set<RoleDto> roles = user.getRoleDtos();
        if (roles.size() > 0) {
            for (RoleDto role : roles) {
                permissions.add(role.getRole());
}
        }
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
info.addRoles(permissions);//將許可權放入shiro中.
return info;
}


    @Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {

        //獲取使用者輸入的token
UsernamePasswordToken utoken = (UsernamePasswordToken) token;
String username = utoken.getUsername();
//以下為只允許同一賬戶單個登入
       Collection<Session> sessions = sessionDAO.getActiveSessions();
        if(sessions.size()>0) {
            for (Session session : sessions) {
                System.out.println("::::::::::::::::" + session);
                //獲得session中已經登入使用者的名字
                if(null!=session.getAttribute("user")) {
                    String loginUsername = ((UserDto)session.getAttribute("user")).getEmail();
                    System.out.println("::::::::::::::::" + loginUsername);
                    if (username.equals(loginUsername)) {  //這裡的username也就是當前登入的username
                        session.setTimeout(0);  //這裡就把session清除，
                        System.out.println("清除了");
                    }
                }
            }
        }
UserDto user = userService.findUserByUserName(username);
Set<RoleDto> set = userService.getUserPermissionsName(user.getId());
user.setRoleDtos(set);
//放入shiro.呼叫CredentialsMatcher檢驗密碼
return new SimpleAuthenticationInfo(user, user.getPassword(), this.getClass().getName());
}
}

咳咳......   敲黑板  關鍵程式碼在這，登陸成功時我將使用者儲存到了shiro提供的session的Attribute中key值時user，所以現在拿到了session之後先判斷能不能通過“user”取到值，如果取得到再進行匹配使用者的名字（每個使用者的名字必須不同）如果匹配上了，就將該session移除，系統會為新登入的使用者新建一個session,之前的session失效之後之前的賬戶就無法繼續操作就會被迫下線，當然，這是shiro中過濾器的功勞，大體上的邏輯就是這樣，但是這種方法有個效率問題，如果一千萬使用者線上，那就要遍歷一千萬次，太慢了，以後再想到有其他什麼方法再說吧

Collection<Session> sessions = sessionDAO.getActiveSessions();
        if(sessions.size()>0) {
            for (Session session : sessions) {
                System.out.println("::::::::::::::::" + session);
                //獲得session中已經登入使用者的名字
                if(null!=session.getAttribute("user")) {
                    String loginUsername = ((UserDto)session.getAttribute("user")).getEmail();
                    System.out.println("::::::::::::::::" + loginUsername);
                    if (username.equals(loginUsername)) {  //這裡的username也就是當前登入的username
                        session.setTimeout(0);  //這裡就把session清除，
                        System.out.println("清除了");
                    }
                }
            }
        }