2. 程式人生 > >spring boot 整合shiro(使用者授權和許可權控制)

spring boot 整合shiro(使用者授權和許可權控制)

阿新 • • 發佈：2018-12-29

(1) pom.xml中新增Shiro依賴

<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.4.0</version>
</dependency>

(2) 注入Shiro Factory和SecurityManager

Shiro幾個核心的類，第一就是ShiroFilterFactory,第二就是SecurityManager，那麼最簡單的配置就是注入這兩個類就ok了

import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.util.LinkedHashMap;
import java.util.Map;

@Component
@Configuration
public class ShiroConfig {
    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        System.out.println("ShiroConfiguration.shirFilter()");
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        //攔截器.
        Map <String, String> filterChainDefinitionMap = new LinkedHashMap <String, String>();
//anon:所有url都都可以匿名訪問;
//authc: 需要認證才能進行訪問;
//user:配置記住我或認證通過可以訪問；
        // 配置不會被攔截的連結 順序判斷
        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/authenRecharge/**", "anon");
        // 配置不會被攔截的連結 順序判斷
        filterChainDefinitionMap.put("/interface/**", "anon");
        filterChainDefinitionMap.put("/manage/**", "anon");
        filterChainDefinitionMap.put("/wicket/**", "anon");
        filterChainDefinitionMap.put("/dbwizard/**", "anon");
        filterChainDefinitionMap.put("/mallbook/login", "anon");
        filterChainDefinitionMap.put("/css/**", "anon");
        filterChainDefinitionMap.put("/images/**", "anon");
        filterChainDefinitionMap.put("/js/**", "anon");
        filterChainDefinitionMap.put("/wicket/resource/**", "anon");
        //配置退出 過濾器,其中的具體的退出程式碼Shiro已經替我們實現了
        filterChainDefinitionMap.put("/logout", "logout");
        //<!-- 過濾鏈定義，從上向下順序執行，一般將/**放在最為下邊 -->:這是一個坑呢，一不小心程式碼就不好使了;
        //<!-- authc:所有url都必須認證通過才可以訪問; anon:所有url都都可以匿名訪問-->
        filterChainDefinitionMap.put("/**", "authc");
        // 如果不設定預設會自動尋找Web工程根目錄下的"/login.jsp"頁面
        shiroFilterFactoryBean.setLoginUrl("/");
        // 登入成功後要跳轉的連結
        shiroFilterFactoryBean.setSuccessUrl("/mallbook/MallHouse");

        //未授權介面;
        shiroFilterFactoryBean.setUnauthorizedUrl("/403");
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }
//這個很重要，將我們自定義的Realm注入到SecurityManager中
    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        return securityManager;
    }
    /**
     * 憑證匹配器
     *應為我們身份認證用的密碼是加密的，所以需要一個加密演算法 ，要是使用明文就不用了
     * （由於我們的密碼校驗交給Shiro的SimpleAuthenticationInfo進行處理了
     * 所以我們需要修改下doGetAuthenticationInfo中的程式碼; ）
     *
     * @return
     */
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        hashedCredentialsMatcher.setHashAlgorithmName("MD5");//雜湊演算法:這裡使用MD5演算法;
        hashedCredentialsMatcher.setHashIterations(1);//雜湊的次數，比如雜湊兩次，相當於 md5(md5(""));
        return hashedCredentialsMatcher;
    }
//身份認證realm;
    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm myShiroRealm = new MyShiroRealm();
        myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
        return myShiroRealm;
    }
    /**
     * 開啟shiro aop註解支援.
     * 使用代理方式;所以需要開啟程式碼支援;
     *
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new         
             AuthorizationAttributeSourceAdvisor();
            advisor.setSecurityManager(securityManager);
        return advisor;
    }

}

 

(3) 身份認證，許可權控制

認證實現

Shiro的認證過程最終會交由Realm執行，這時會呼叫Realm的getAuthenticationInfo(token)方法。

該方法主要執行以下操作:

1、檢查提交的進行認證的令牌資訊

2、根據令牌資訊從資料來源(通常為資料庫)中獲取使用者資訊

3、對使用者資訊進行匹配驗證。

4、驗證通過將返回一個封裝了使用者資訊的AuthenticationInfo例項。

5、驗證失敗則丟擲AuthenticationException異常資訊。

而在我們的應用程式中要做的就是自定義一個Realm類，繼承AuthorizingRealm抽象類，過載doGetAuthenticationInfo ()，重寫獲取使用者資訊的方法。

shiro的認證最終是交給了Realm進行執行了，所以我們需要自己重新實現一個Realm，此Realm繼承AuthorizingRealm。

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.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

public class MallBookShiroRealm extends AuthorizingRealm {
    @Autowired
    private UpmsUserService userService;

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

    /**
     * 許可權認證，為當前登入的Subject授予角色和許可權
     * <p>
     * 本例中該方法的呼叫時機為需授權資源被訪問時
     * 並且每次訪問需授權資源時都會執行該方法中的邏輯，這表明本例中預設並未啟用AuthorizationCache
     * 如果連續訪問同一個URL（比如重新整理），該方法不會被重複呼叫，Shiro有一個時間間隔（也就是cache時間，在ehcache-shiro.xml中配置），超過這個時間間隔再重新整理頁面，該方法會被執行
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        logger.info("許可權配置-->EpayShiroRealm.doGetAuthorizationInfo()");
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        UserInfo userInfo = (UserInfo) principals.getPrimaryPrincipal();
        for (RolesInfo role : userInfo.getRoles()) {
            authorizationInfo.addRole(role.getName());
            for (UpmsPermission p : role.getPermissions()) {
                if (null != p.getPermissionValue() && p.getPermissionValue().length() > 0) {
                    authorizationInfo.addStringPermission(p.getPermissionValue());
                }
            }
        }
        return authorizationInfo;
    }


    /**
     * 主要是用來進行身份認證的，也就是說驗證使用者輸入的賬號和密碼是否正確
     *
     * @param token
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
            throws AuthenticationException {

        logger.info("正在驗證身份...");
        // 獲取使用者的輸入的賬號.
        //將token轉換成UsernamePasswordToken
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = (String) token.getPrincipal();
        System.out.println(token.getCredentials());

        // 通過username從資料庫中查詢 User物件，如果找到，沒找到.
        // 實際專案中，這裡可以根據實際情況做快取，如果不做，Shiro自己也是有時間間隔機制，2分鐘內不會重複執行該方法
        UserInfo userInfo = userService.findByUsername(username);
        System.out.println("----->>userInfo=" + userInfo);
        if (null == userInfo) {
            return null;
        }
        // 得到鹽值加密後的密碼：只用於方便資料庫測試，後期不會用到。
        return new SimpleAuthenticationInfo(
                userInfo,
                userInfo.getPassword(),
                ByteSource.Util.bytes(userInfo.getSalt()),
                getName()
        );
    }
}

繼承AuthorizingRealm主要需要實現兩個方法：
doGetAuthenticationInfo();
doGetAuthorizationInfo();
其中doGetAuthenticationInfo主要是用來進行身份認證的，也就是說驗證使用者輸入的賬號和密碼是否正確。
SimpleAuthenticationInfo oauthenticationInfo =
  return new SimpleAuthenticationInfo(
                userInfo,//使用者名稱
                userInfo.getPassword(),//密碼
                ByteSource.Util.bytes(userInfo.getSalt()),//加密的鹽
                getName()//realm name
        );


doGetAuthorizationInfo()是許可權控制，當訪問到頁面的時候，使用了相應的註解或者shiro標籤才會執行此方法否則不會執行，所以如果只是簡單的身份認證沒有許可權的控制的話，那麼這個方法可以不進行實現，直接返回null即可。
主要的類：SimpleAuthorizationInfo 
  for (RolesInfo role : userInfo.getRoles()) {
            authorizationInfo.addRole(role.getName());//新增角色
            for (UpmsPermission p : role.getPermissions()) {
                if (null != p.getPermissionValue() && p.getPermissionValue().length() > 0) {
                    authorizationInfo.addStringPermission(p.getPermissionValue());//新增選單
                }
            }
        }

到這裡的話身份認證許可權控制基本是完成了，最後我們在編寫一個登入的時候，登入的處理

import java.util.ArrayList;
import java.util.List;
@RestController
public class LoginController{
    Logger log= LoggerFactory.getLogger(LoginController.class);
    @Autowired
    private UpmsUserService userService;

    @RequestMapping(value = "/ajaxLogin", method = RequestMethod.POST)
    public Object login(String username, String password) {
        String passwordNew= RSAUtils.decrypt(password, RSAUtils.getPrivateKey(Constant.PWD_PRIVATE_KEY));
        UsernamePasswordToken token = new UsernamePasswordToken(username, passwordNew);
        token.setHost("localhost");
        Subject currentUser = SecurityUtils.getSubject();

        UpmsResultConstant messageCode = UpmsResultConstant.LOGIN_SUCCESS;
        if (null == userService.getUserInfo(token.getUsername())) {
            return new UpmsResult(UpmsResultConstant.FAILED, UpmsResultConstant.FAILED.code);
        }
        try {
            currentUser.login(token);
        } catch (UnknownAccountException ex) {
            messageCode = UpmsResultConstant.LOGIN_ACCOUNT_ERROR;
            ex.printStackTrace();
        } catch (IncorrectCredentialsException ex) {
            messageCode = UpmsResultConstant.LOGIN_PASSWORD_ERROR;
            ex.printStackTrace();
        } catch (LockedAccountException ex) {
            messageCode = UpmsResultConstant.LOGIN_ACCOUNT_LOCKED;
            ex.printStackTrace();
        } catch (ExcessiveAttemptsException ex) {
            messageCode = UpmsResultConstant.LOGIN_EXCESSIVE_ERROR;
            ex.printStackTrace();
        } catch (AuthenticationException ex) {
            messageCode = UpmsResultConstant.LOGIN_AUTHTICATION_FAIL;
            ex.printStackTrace();
        }

        if (currentUser.isAuthenticated()) {
            LoginInfo loginInfo = new LoginInfo();
            UserInfo userInfo = (UserInfo) currentUser.getPrincipals().getPrimaryPrincipal();
            loginInfo.setAvatar(userInfo.getAvatar());
            loginInfo.setIntroduction(userInfo.getRole());
            loginInfo.setName(userInfo.getUserName());
            loginInfo.setToken(currentUser.getSession().getId().toString());
            if (null != userInfo.getRoles() && userInfo.getRoles().size() > 0) {
                List<String> roles = new ArrayList<>();
                for (RolesInfo rolesInfo : userInfo.getRoles()) {
                    roles.add(rolesInfo.getName());
                }
                loginInfo.setRole(roles);
            } else {
                return new UpmsResult(UpmsResultConstant.FAILED, UpmsResultConstant.FAILED.code);
            }

            return new UpmsResult(UpmsResultConstant.SUCCESS, loginInfo);
        } else {
            return new UpmsResult(messageCode, 0);
        }
    }

 
    @RequestMapping(value = "/getUserInfo")
    public Object getUserInfo() {
        UserInfo userInfo = UserUtils.getUser();
        LoginInfo loginInfo = new LoginInfo();
        loginInfo.setAvatar(userInfo.getAvatar());
        loginInfo.setIntroduction(userInfo.getRole());
        loginInfo.setName(userInfo.getRealName());
        loginInfo.setToken(userInfo.getToken());
        List<String> roles = new ArrayList<String>();
        List<String> pms = new ArrayList<String>();
        for (RolesInfo rolesInfo : userInfo.getRoles()) {
 
            roles.add(rolesInfo.getTitle());
            for (UpmsPermission permission : rolesInfo.getPermissions()) {
                pms.add(permission.getPermissionValue());
            }
        }
        loginInfo.setPms(pms);
        loginInfo.setRole(roles);
        loginInfo.setMchId(userInfo.getUserId().toString());
        return new UpmsResult(UpmsResultConstant.SUCCESS, loginInfo);
    }
}

這個時候訪問http://localhost:9527/#/login就可以跳轉到index頁面了

 

此時身份認證是好了，但是許可權控制好像還沒有作用

還需要兩部分：

第一就是開啟shiro aop註解支援

在ShiroConfig需要開啟shiro aop註解支援.

@Bean

public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {

AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();

advisor.setSecurityManager(securityManager);

return advisor;

}

第二就是在controller方法中加入相應的註解：

@RequiresPermissions("sys_user_add")//許可權管理

@RestController
@RequestMapping(value = "/manage/user")
public class UserController {
    @Autowired
    private UpmsUserService userService;
    private static Logger log = LoggerFactory.getLogger(UserController.class);
    @Autowired
    IdWorker idWorker;

   

    @RequiresPermissions("user_manager")
    @RequestMapping(value = "/list", method = RequestMethod.POST)
    @ResponseBody
    public Object list(UpmsUser user) {
        return new UpmsResult(
                UpmsResultConstant.SUCCESS
                , userService.listUser(user)
        );
    }
    
    @RequiresPermissions("sys_user_edit")
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public Object update(UpmsUser upmsUser) {

        log.info("-------------------------------");
        // 邏輯驗證
        ComplexResult result = FluentValidator.checkAll()
                .doValidate()
                .result(ResultCollectors.toComplex());
        if (!result.isSuccess()) {
            return new UpmsResult(UpmsResultConstant.INVALID_LENGTH, result.getErrors());
        }
        String passwordNew = "";
        if (StringUtils.isNotEmpty(upmsUser.getPassword())) {
            passwordNew = RSAUtils.decrypt(upmsUser.getPassword(), RSAUtils.getPrivateKey(Constant.PWD_PRIVATE_KEY));
            // 不允許直接改密碼
            Object md = new SimpleHash("MD5", passwordNew, upmsUser.getSalt(), 1);
            upmsUser.setPassword(md.toString());
            upmsUser.setVerifyPassword(DictConstant.USER_HAS_LOGGED);
        }
//        upmsUser.setPassword(null);
        int count = userService.updateUser(upmsUser);
        return new UpmsResult(UpmsResultConstant.SUCCESS, count);
    }

    @RequiresPermissions("sys_user_edit")
    @RequestMapping(value = "/updatePassword", method = RequestMethod.POST)
    public Object updatePassword(UpmsUser upmsUser) {
        String passwordNew = RSAUtils.decrypt(upmsUser.getPassword(), RSAUtils.getPrivateKey(Constant.PWD_PRIVATE_KEY));
        // 不允許直接改密碼
        Object md = new SimpleHash("MD5", passwordNew, ByteSource.Util.bytes(upmsUser.getSalt()), 1);
        if (md.toString().equals(UserUtils.getUser().getPassword())) {
            return new UpmsResult(UpmsResultConstant.PASSWORD_REPEAT, 0);
        }
        upmsUser.setPassword(md.toString());
        upmsUser.setVerifyPassword(DictConstant.USER_HAS_LOGGED);
        int count = userService.updateUser(upmsUser);
        return new UpmsResult(UpmsResultConstant.SUCCESS, count);
    }

    @RequiresPermissions("sys_user_disabled")
    @RequestMapping(value = "/locked", method = RequestMethod.POST)
    public Object locked(UpmsUser upmsUser) {
        int count = userService.updateUser(upmsUser.getUserId(), StatusEnum.FORBIDDEN.getByteVal());
        return new UpmsResult(UpmsResultConstant.SUCCESS, count);
    }

    @RequiresPermissions("sys_user_enabled")
    @RequestMapping(value = "/unlock", method = RequestMethod.POST)
    public Object unlock(UpmsUser upmsUser) {
        int count = userService.updateUser(upmsUser.getUserId(), StatusEnum.NORMAL.getByteVal());
        return new UpmsResult(UpmsResultConstant.SUCCESS, count);
    }

    @RequestMapping(value = "listCurrentUser", method = RequestMethod.POST)
    public Object listCurrentUser() {
        return new UpmsResult(
                UpmsResultConstant.SUCCESS
                , userService.selectUserInfoById());
    }
}

到此，身份認證及許可權管理已完成，如果還要加入快取機制，還要引入依賴

參考：spring boot學習教程

 

相關推薦

spring boot 整合shiro(使用者授權和許可權控制)

(1) pom.xml中新增Shiro依賴 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId>

spring-boot(八) springboot整合shiro-登入認證和許可權管理

Apache Shiro What is Apache Shiro? Apache Shiro是一個功能強大、靈活的，開源的安全框架。它可以乾淨利落地處理身份驗證、授權、企業會話管理和加密。 Apache Shiro的首要目標是易於使用和理解。安全通常很複雜，甚至讓人感到很痛苦，但是Shiro卻不是

Spring Boot 整合Shiro實現登陸認證和許可權控制

我在做畢設的時候，使用了Shiro作為專案中的登陸認證和許可權控制。 下面是我專案中如何實現整合shiro的學習記錄。 匯入shiro依賴包到pom.xml <!-- Shiro依賴 --> <dependency>

spring boot整合shiro 簡單許可權控制

package me.config; import javax.annotation.Resource; import me.domain.entity.CmsUser; import me.service.UserService; import me.utils.MD5Util

Spring Boot 整合 Shiro實現許可權控制,親測可用,附帶sql

前提： 本文主要講解Spring Boot 與 Shiro的整合 與許可權控制的實現方式（主要以程式碼實現功能為主），主要用到的技術Spring Boot+Shiro+Jpa（通過Maven構建），並不會涉及到Shiro框架的原始碼分析 如果有想要學習Shiro框架的小夥伴可以去http://shiro.

Spring Boot 整合Shiro和CAS

請大家在看本文之前，先了解如下知識點： 1、Shiro 是什麼？怎麼用？ 2、Cas 是什麼？怎麼用？ 3、最好有Spring基礎 首先看一下下面這張圖： 第一個流程是單純使用Shiro的流程。 第二個流程是單純使用Cas的流程。 第三個圖是Shiro整合Cas後的流程。 PS：流程圖急急

Spring Boot 整合Shiro和Redis關於@Cacheble註解無效的解決方法

在我做專案的時候，在Spring Boot 中對Shiro和Redis進行了整合，但實際發現Spring boot中Shiro和Redis整合後，Spring的@cacheble註解無效。 出現的情況如下： 如果只是Spring boot和Redis整合，

Spring Boot 整合 Shiro實現認證及授權管理

Spring Boot Shiro 本示例要內容 基於RBAC，授權、認證 加密、解密 統一異常處理 redis session支援 介紹 Apache Shiro 是一個功能強大且易於使用的Java安全框架，可執行身份驗證，授權，加密和會話管理。藉助Shiro易於理解的API，您可以快速輕鬆地保護任何應

Spring Boot整合JPA、Redis和Swagger2

enc code extends art redis學習 and 小結 JD pip 好久沒有總結了，最近也一直在學習。今天就把spring boot與其它技術的整合做個小總結，主要是jpa、redis和swagger2。公司裏有用到這些，整合起來也很簡單。 首先，新建一個

spring boot整合cxf發布和調用webservice

密碼 ict noclass nfa ack 報錯 地址 需要 兼容 一.前言 說起web service最近幾年restful大行其道，大有取代傳統soap web service的趨勢，但是一些特有或相對老舊的系統依然使用了傳統的soap web service，

spring-boot整合shiro

概述 許可權體系在現代任何IT系統中都是很基礎但又非常重要的部分，無論是傳統MIS系統還是網際網路系統，出於保護業務資料和應用自身的安全，都會設計自己的授權鑑權策略。 最近專案中也需要用到許可權驗證功能，專案為spring-boot工程，現成的許可權驗證框架有shiro和spri

Spring Boot整合shiro

shiro面世已經有很長時間了，相比Spring security更加精簡一些，也更容易上手，因此就想分享下這段時間的學習成果，就當是學習筆記了1 pom檔案如下<project xmlns="http://maven.apache.org/POM/4.0.0" xml

spring boot整合Shiro實現單點登入

前面的部落格中，我們說道了Shiro的兩個最大的特點，認證和授權，而單點登入也是屬於認證的一部分，預設情況下，Shiro已經為我們實現了和Cas的整合，我們加入整合的一些配置就ok了。 1、加入shiro-cas包 <!-- shiro整合cas單點 -->

spring-boot 整合junit測試類 和 spring-boot整合整合testng

一、spring-boot 整合junit測試類 1.引入junit依賴 <!-- springboot junit依賴 --> <dependency> <groupId>org.springframework.boot

Spring Boot整合shiro，出現UnavailableSecurityManagerException 異常

問題描述：由於在java過濾器中通過User token = (User) SecurityUtils.getSubject().getPrincipal();獲取當前的登入使用者的資訊，報UnavailableSecurityManagerException這個異常。spr

spring boot 整合shiro 配置類報錯問題

這裡傳入的是下邊返回的自定義Realm,下邊是報錯，報的是該類不能被裝載，由jdk自己裝載，這裡不是太懂，記錄一下，由於錯誤太長，不好截圖，直接複製錯誤內容 >>>>>>>>>>>>>>&

Spring Boot 整合Shiro給Swagger&Druid放行資源

shiro的過濾器鏈配置： //放行靜態資源 filterChainDefinitionMap.put("/static/**", "anon");

spring boot整合shiro之shiro過濾器介紹

過濾器鏈條配置說明 1、一個URL可以配置多個Filter，使用逗號分隔 2、當設定多個過濾器時，全部驗證通過，才視為通過 3、部分過濾器可指定引數，如perms，roles Shiro內建的FilterChain anon(org.apac

Spring Boot 整合 Shiro 進行登入認證

安全無處不在，趁著放假讀了一下 Shiro 文件，並記錄一下 Shiro 整合 Spring Boot 在資料庫中根據角色控制訪問許可權 簡介 Apache Shiro是一個功能強大、靈活的，開源的安全框架。它可以乾淨利落地處理身份驗證、授權、企業會話管理和

spring boot 整合shiro詳細教程

我們開發時候有時候要把傳統spring shiro轉成spring boot專案，或者直接整合，那麼我們要搞清楚一個知識，就是 xml配置和spring bean程式碼配置的關係，這一點很重要，因為spring boot是沒有xml配置檔案的(也不絕對，spring boot